From b81be7d35fc9ba09f05afc20f53b3aff2784b1a1 Mon Sep 17 00:00:00 2001 From: Valentin Khomutenko Date: Thu, 6 Jul 2023 17:47:21 +0200 Subject: [PATCH 1/4] add dataset schemas to --json output --- data_diff/dbt.py | 4 ++- data_diff/format.py | 33 ++++++++++++++----- tests/test_format.py | 75 ++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 97 insertions(+), 15 deletions(-) diff --git a/data_diff/dbt.py b/data_diff/dbt.py index 212c0fc8..80c5fd1e 100644 --- a/data_diff/dbt.py +++ b/data_diff/dbt.py @@ -313,8 +313,10 @@ def _local_diff(diff_vars: TDiffVars, json_output: bool = False) -> None: jsonify( diff, dbt_model=diff_vars.dbt_model, + dataset1_columns=table1_columns, + dataset2_columns=table2_columns, with_summary=True, - with_columns={ + columns_diff={ "added": columns_added, "removed": columns_removed, "changed": columns_type_changed, diff --git a/data_diff/format.py b/data_diff/format.py index 5a16f274..60418996 100644 --- a/data_diff/format.py +++ b/data_diff/format.py @@ -18,8 +18,10 @@ def jsonify_error(table1: List[str], table2: List[str], dbt_model: str, error: s def jsonify( diff: DiffResultWrapper, dbt_model: str, + dataset1_columns: Dict[str, Tuple[str, str, Any, Any, Any]], + dataset2_columns: Dict[str, Tuple[str, str, Any, Any, Any]], + columns_diff: Dict[str, List[str]], with_summary: bool = False, - with_columns: Optional[Dict[str, List[str]]] = None, ) -> "JsonDiff": """ Converts the diff result into a JSON-serializable format. @@ -53,16 +55,13 @@ def jsonify( if with_summary: summary = _jsonify_diff_summary(diff.get_stats_dict(is_dbt=True)) - columns = None - if with_columns: - columns = _jsonify_columns_diff(with_columns, list(key_columns)) + columns = _jsonify_columns_diff(dataset1_columns, dataset2_columns, columns_diff, list(key_columns)) is_different = bool( t1_exclusive_rows or t2_exclusive_rows or diff_rows - or with_columns - and (with_columns["added"] or with_columns["removed"] or with_columns["changed"]) + or (columns_diff["added"] or columns_diff["removed"] or columns_diff["changed"]) ) return JsonDiff( status="success", @@ -137,9 +136,15 @@ class ExclusiveColumns: dataset1: List[str] dataset2: List[str] +@dataclass +class Column: + name: str + type: str @dataclass class JsonColumnsSummary: + dataset1: List[Column] + dataset2: List[Column] primaryKey: List[str] exclusive: ExclusiveColumns typeChanged: List[str] @@ -179,7 +184,7 @@ class JsonDiff: summary: Optional[JsonDiffSummary] columns: Optional[JsonColumnsSummary] - version: str = "1.0.0" + version: str = "1.1.0" def _group_rows( @@ -262,8 +267,20 @@ def _jsonify_diff_summary(stats_dict: dict) -> JsonDiffSummary: ) -def _jsonify_columns_diff(columns_diff: Dict[str, List[str]], key_columns: List[str]) -> JsonColumnsSummary: +def _jsonify_columns_diff(dataset1_columns: Dict[str, Tuple[str, str, Any, Any, Any]], + dataset2_columns: Dict[str, Tuple[str, str, Any, Any, Any]], + columns_diff: Dict[str, List[str]], key_columns: List[str]) -> JsonColumnsSummary: return JsonColumnsSummary( + dataset1=[ + Column(name=name, type=type_) + for (name, type_, *_) + in dataset1_columns.values() + ], + dataset2=[ + Column(name=name, type=type_) + for (name, type_, *_) + in dataset2_columns.values() + ], primaryKey=key_columns, exclusive=ExclusiveColumns( dataset2=list(columns_diff.get("added", [])), diff --git a/tests/test_format.py b/tests/test_format.py index 393a4e95..b278b0f5 100644 --- a/tests/test_format.py +++ b/tests/test_format.py @@ -35,11 +35,28 @@ def test_jsonify_diff(self): diff=[], stats={}, ) - json_diff = jsonify(diff, dbt_model="my_model") + json_diff = jsonify( + diff, + dbt_model="my_model", + dataset1_columns={ + "id": ('id', 'integer', None, None, None), + "value": ('value', 'integer', None, None, None), + }, + dataset2_columns={ + "id": ('id', 'integer', None, None, None), + "value": ('value', 'integer', None, None, None), + }, + columns_diff={ + "added": [], + "removed": [], + "typeChanged": [], + } + ) + self.assertEqual( json_diff, { - "version": "1.0.0", + "version": "1.1.0", "status": "success", "result": "different", "model": "my_model", @@ -57,8 +74,23 @@ def test_jsonify_diff(self): }, ], }, + "columns": { + "dataset1": [ + {"name": "id", "type": "integer"}, + {"name": "value", "type": "integer"} + ], + "dataset2": [ + {"name": "id", "type": "integer"}, + {"name": "value", "type": "integer"} + ], + "primaryKey": ["id"], + "exclusive": { + "dataset1": [], + "dataset2": [], + }, + "typeChanged": [], + }, "summary": None, - "columns": None, }, ) @@ -86,11 +118,27 @@ def test_jsonify_diff_no_difeference(self): diff=[], stats={}, ) - json_diff = jsonify(diff, dbt_model="model") + json_diff = jsonify( + diff, + dbt_model="model", + dataset1_columns={ + "id": ('id', 'integer', None, None, None), + "value": ('value', 'integer', None, None, None), + }, + dataset2_columns={ + "id": ('id', 'integer', None, None, None), + "value": ('value', 'integer', None, None, None), + }, + columns_diff={ + "added": [], + "removed": [], + "changed": [], + } + ) self.assertEqual( json_diff, { - "version": "1.0.0", + "version": "1.1.0", "status": "success", "result": "identical", "model": "model", @@ -100,8 +148,23 @@ def test_jsonify_diff_no_difeference(self): "exclusive": {"dataset1": [], "dataset2": []}, "diff": [], }, + "columns": { + "primaryKey": ["id"], + "dataset1": [ + {"name": "id", "type": "integer"}, + {"name": "value", "type": "integer"} + ], + "dataset2": [ + {"name": "id", "type": "integer"}, + {"name": "value", "type": "integer"} + ], + "exclusive": { + "dataset1": [], + "dataset2": [], + }, + "typeChanged": [], + }, "summary": None, - "columns": None, }, ) From 680b1bc3af4c965b5d131804e24693601fcf235e Mon Sep 17 00:00:00 2001 From: Valentin Khomutenko Date: Sun, 9 Jul 2023 13:56:26 +0200 Subject: [PATCH 2/4] add both logical & raw type to schema --- data_diff/dbt.py | 18 +++++++++-- data_diff/format.py | 74 ++++++++++++++++++++++++++++++++++++++------- 2 files changed, 79 insertions(+), 13 deletions(-) diff --git a/data_diff/dbt.py b/data_diff/dbt.py index 80c5fd1e..a5b40138 100644 --- a/data_diff/dbt.py +++ b/data_diff/dbt.py @@ -308,13 +308,27 @@ def _local_diff(diff_vars: TDiffVars, json_output: bool = False) -> None: ) return + dataset1_columns = [ + (name, + type_, + table1.database.dialect.parse_type(table1.table_path, name, type_, *other)) + for (name, type_, *other) + in table1_columns.values() + ] + dataset2_columns = [ + (name, + type_, + table2.database.dialect.parse_type(table2.table_path, name, type_, *other)) + for (name, type_, *other) + in table2_columns.values() + ] print( json.dumps( jsonify( diff, dbt_model=diff_vars.dbt_model, - dataset1_columns=table1_columns, - dataset2_columns=table2_columns, + dataset1_columns=dataset1_columns, + dataset2_columns=dataset2_columns, with_summary=True, columns_diff={ "added": columns_added, diff --git a/data_diff/format.py b/data_diff/format.py index 60418996..b06c4142 100644 --- a/data_diff/format.py +++ b/data_diff/format.py @@ -1,8 +1,23 @@ import collections -from typing import Any, Optional, List, Dict, Tuple +from enum import Enum +from typing import Any, Optional, List, Dict, Tuple, Type from runtype import dataclass from data_diff.diff_tables import DiffResultWrapper +from data_diff.sqeleton.abcs.database_types import ( + JSON, + Boolean, + ColType, + Array, + ColType_UUID, + Date, + FractionalType, + NumericType, + Struct, + TemporalType, + ColType_Alphanum, + String_Alphanum +) def jsonify_error(table1: List[str], table2: List[str], dbt_model: str, error: str) -> "FailedDiff": @@ -14,12 +29,13 @@ def jsonify_error(table1: List[str], table2: List[str], dbt_model: str, error: s error=error, ).json() +Columns = List[Tuple[str, str, Type[ColType]]] def jsonify( diff: DiffResultWrapper, dbt_model: str, - dataset1_columns: Dict[str, Tuple[str, str, Any, Any, Any]], - dataset2_columns: Dict[str, Tuple[str, str, Any, Any, Any]], + dataset1_columns: Columns, + dataset2_columns: Columns, columns_diff: Dict[str, List[str]], with_summary: bool = False, ) -> "JsonDiff": @@ -136,10 +152,36 @@ class ExclusiveColumns: dataset1: List[str] dataset2: List[str] +class ColumnKind(Enum): + INTEGER = 'integer' + FLOAT = 'float' + STRING = 'string' + DATE = 'date' + TIME = 'time' + DATETIME = 'datetime' + BOOL = 'boolean' + UNSUPPORTED = 'unsupported' + +KIND_MAPPING: List[Tuple[Type[ColType], ColumnKind]] = [ + (Boolean, ColumnKind.BOOL), + (Date, ColumnKind.DATE), + (TemporalType, ColumnKind.DATETIME), + (FractionalType, ColumnKind.FLOAT), + (NumericType, ColumnKind.INTEGER), + (ColType_UUID, ColumnKind.STRING), + (ColType_Alphanum, ColumnKind.STRING), + (String_Alphanum, ColumnKind.STRING), + (JSON, ColumnKind.STRING), + (Array, ColumnKind.STRING), + (Struct, ColumnKind.STRING), + (ColType, ColumnKind.UNSUPPORTED) +] + @dataclass class Column: name: str type: str + kind: str @dataclass class JsonColumnsSummary: @@ -267,19 +309,23 @@ def _jsonify_diff_summary(stats_dict: dict) -> JsonDiffSummary: ) -def _jsonify_columns_diff(dataset1_columns: Dict[str, Tuple[str, str, Any, Any, Any]], - dataset2_columns: Dict[str, Tuple[str, str, Any, Any, Any]], +def _jsonify_columns_diff(dataset1_columns: Columns, + dataset2_columns: Columns, columns_diff: Dict[str, List[str]], key_columns: List[str]) -> JsonColumnsSummary: return JsonColumnsSummary( dataset1=[ - Column(name=name, type=type_) - for (name, type_, *_) - in dataset1_columns.values() + Column(name=name, + type=type_, + kind=_map_kind(kind).value) + for (name, type_, kind) + in dataset1_columns ], dataset2=[ - Column(name=name, type=type_) - for (name, type_, *_) - in dataset2_columns.values() + Column(name=name, + type=type_, + kind=_map_kind(kind).value) + for (name, type_, kind) + in dataset2_columns ], primaryKey=key_columns, exclusive=ExclusiveColumns( @@ -288,3 +334,9 @@ def _jsonify_columns_diff(dataset1_columns: Dict[str, Tuple[str, str, Any, Any, ), typeChanged=list(columns_diff.get("changed", [])), ) + +def _map_kind(kind: Type[ColType]) -> ColumnKind: + for raw_kind, json_kind in KIND_MAPPING: + if isinstance(kind, raw_kind): + return json_kind + return ColumnKind.UNSUPPORTED From a82dbc634f4d545e52cac4f3638224a3f1e8c182 Mon Sep 17 00:00:00 2001 From: Valentin Khomutenko Date: Sun, 9 Jul 2023 14:09:59 +0200 Subject: [PATCH 3/4] fix tests --- data_diff/format.py | 4 +-- tests/test_format.py | 86 ++++++++++++++++++++++++++++++-------------- 2 files changed, 61 insertions(+), 29 deletions(-) diff --git a/data_diff/format.py b/data_diff/format.py index b06c4142..d39ed112 100644 --- a/data_diff/format.py +++ b/data_diff/format.py @@ -29,7 +29,7 @@ def jsonify_error(table1: List[str], table2: List[str], dbt_model: str, error: s error=error, ).json() -Columns = List[Tuple[str, str, Type[ColType]]] +Columns = List[Tuple[str, str, ColType]] def jsonify( diff: DiffResultWrapper, @@ -335,7 +335,7 @@ def _jsonify_columns_diff(dataset1_columns: Columns, typeChanged=list(columns_diff.get("changed", [])), ) -def _map_kind(kind: Type[ColType]) -> ColumnKind: +def _map_kind(kind: ColType) -> ColumnKind: for raw_kind, json_kind in KIND_MAPPING: if isinstance(kind, raw_kind): return json_kind diff --git a/tests/test_format.py b/tests/test_format.py index b278b0f5..c5f05463 100644 --- a/tests/test_format.py +++ b/tests/test_format.py @@ -1,6 +1,7 @@ import unittest from data_diff.diff_tables import DiffResultWrapper, InfoTree, SegmentInfo, TableSegment from data_diff.format import jsonify +from data_diff.sqeleton.abcs.database_types import Integer from data_diff.sqeleton.databases import Database @@ -38,14 +39,14 @@ def test_jsonify_diff(self): json_diff = jsonify( diff, dbt_model="my_model", - dataset1_columns={ - "id": ('id', 'integer', None, None, None), - "value": ('value', 'integer', None, None, None), - }, - dataset2_columns={ - "id": ('id', 'integer', None, None, None), - "value": ('value', 'integer', None, None, None), - }, + dataset1_columns=[ + ('id', 'NUMBER', Integer()), + ('value', 'NUMBER', Integer()), + ], + dataset2_columns=[ + ('id', 'NUMBER', Integer()), + ('value', 'NUMBER', Integer()), + ], columns_diff={ "added": [], "removed": [], @@ -76,12 +77,12 @@ def test_jsonify_diff(self): }, "columns": { "dataset1": [ - {"name": "id", "type": "integer"}, - {"name": "value", "type": "integer"} + {"name": "id", "type": "NUMBER", "kind": "integer"}, + {"name": "value", "type": "NUMBER", "kind": "integer"} ], "dataset2": [ - {"name": "id", "type": "integer"}, - {"name": "value", "type": "integer"} + {"name": "id", "type": "NUMBER", "kind": "integer"}, + {"name": "value", "type": "NUMBER", "kind": "integer"} ], "primaryKey": ["id"], "exclusive": { @@ -121,14 +122,14 @@ def test_jsonify_diff_no_difeference(self): json_diff = jsonify( diff, dbt_model="model", - dataset1_columns={ - "id": ('id', 'integer', None, None, None), - "value": ('value', 'integer', None, None, None), - }, - dataset2_columns={ - "id": ('id', 'integer', None, None, None), - "value": ('value', 'integer', None, None, None), - }, + dataset1_columns=[ + ('id', 'NUMBER', Integer()), + ('value', 'NUMBER', Integer()), + ], + dataset2_columns=[ + ('id', 'NUMBER', Integer()), + ('value', 'NUMBER', Integer()), + ], columns_diff={ "added": [], "removed": [], @@ -151,12 +152,12 @@ def test_jsonify_diff_no_difeference(self): "columns": { "primaryKey": ["id"], "dataset1": [ - {"name": "id", "type": "integer"}, - {"name": "value", "type": "integer"} + {"name": "id", "type": "NUMBER", "kind": "integer"}, + {"name": "value", "type": "NUMBER", "kind": "integer"} ], "dataset2": [ - {"name": "id", "type": "integer"}, - {"name": "value", "type": "integer"} + {"name": "id", "type": "NUMBER", "kind": "integer"}, + {"name": "value", "type": "NUMBER", "kind": "integer"} ], "exclusive": { "dataset1": [], @@ -196,11 +197,27 @@ def test_jsonify_column_suffix_fix(self): diff=[], stats={}, ) - json_diff = jsonify(diff, dbt_model="my_model") + json_diff = jsonify( + diff, + dbt_model="my_model", + dataset1_columns=[ + ('id_a', 'NUMBER', Integer()), + ('value_b', 'NUMBER', Integer()), + ], + dataset2_columns=[ + ('id_a', 'NUMBER', Integer()), + ('value_b', 'NUMBER', Integer()), + ], + columns_diff={ + "added": [], + "removed": [], + "typeChanged": [], + }, + ) self.assertEqual( json_diff, { - "version": "1.0.0", + "version": "1.1.0", "status": "success", "result": "different", "model": "my_model", @@ -221,6 +238,21 @@ def test_jsonify_column_suffix_fix(self): ], }, "summary": None, - "columns": None, + "columns": { + "dataset1": [ + {"name": "id_a", "type": "NUMBER", "kind": "integer"}, + {"name": "value_b", "type": "NUMBER", "kind": "integer"} + ], + "dataset2": [ + {"name": "id_a", "type": "NUMBER", "kind": "integer"}, + {"name": "value_b", "type": "NUMBER", "kind": "integer"} + ], + "primaryKey": ["id_a"], + "exclusive": { + "dataset1": [], + "dataset2": [], + }, + "typeChanged": [], + }, }, ) From 4ee1a88e7e10760eb07cbc4e5eb6c28b7584670d Mon Sep 17 00:00:00 2001 From: Valentin Khomutenko Date: Sun, 9 Jul 2023 14:19:07 +0200 Subject: [PATCH 4/4] format --- data_diff/dbt.py | 14 +++-------- data_diff/format.py | 47 ++++++++++++++++++----------------- tests/test_format.py | 58 ++++++++++++++++++++++---------------------- 3 files changed, 56 insertions(+), 63 deletions(-) diff --git a/data_diff/dbt.py b/data_diff/dbt.py index a5b40138..fd3223de 100644 --- a/data_diff/dbt.py +++ b/data_diff/dbt.py @@ -309,18 +309,12 @@ def _local_diff(diff_vars: TDiffVars, json_output: bool = False) -> None: return dataset1_columns = [ - (name, - type_, - table1.database.dialect.parse_type(table1.table_path, name, type_, *other)) - for (name, type_, *other) - in table1_columns.values() + (name, type_, table1.database.dialect.parse_type(table1.table_path, name, type_, *other)) + for (name, type_, *other) in table1_columns.values() ] dataset2_columns = [ - (name, - type_, - table2.database.dialect.parse_type(table2.table_path, name, type_, *other)) - for (name, type_, *other) - in table2_columns.values() + (name, type_, table2.database.dialect.parse_type(table2.table_path, name, type_, *other)) + for (name, type_, *other) in table2_columns.values() ] print( json.dumps( diff --git a/data_diff/format.py b/data_diff/format.py index d39ed112..d9d971ac 100644 --- a/data_diff/format.py +++ b/data_diff/format.py @@ -16,7 +16,7 @@ Struct, TemporalType, ColType_Alphanum, - String_Alphanum + String_Alphanum, ) @@ -29,7 +29,9 @@ def jsonify_error(table1: List[str], table2: List[str], dbt_model: str, error: s error=error, ).json() -Columns = List[Tuple[str, str, ColType]] + +Columns = List[Tuple[str, str, ColType]] + def jsonify( diff: DiffResultWrapper, @@ -152,15 +154,17 @@ class ExclusiveColumns: dataset1: List[str] dataset2: List[str] + class ColumnKind(Enum): - INTEGER = 'integer' - FLOAT = 'float' - STRING = 'string' - DATE = 'date' - TIME = 'time' - DATETIME = 'datetime' - BOOL = 'boolean' - UNSUPPORTED = 'unsupported' + INTEGER = "integer" + FLOAT = "float" + STRING = "string" + DATE = "date" + TIME = "time" + DATETIME = "datetime" + BOOL = "boolean" + UNSUPPORTED = "unsupported" + KIND_MAPPING: List[Tuple[Type[ColType], ColumnKind]] = [ (Boolean, ColumnKind.BOOL), @@ -174,15 +178,17 @@ class ColumnKind(Enum): (JSON, ColumnKind.STRING), (Array, ColumnKind.STRING), (Struct, ColumnKind.STRING), - (ColType, ColumnKind.UNSUPPORTED) + (ColType, ColumnKind.UNSUPPORTED), ] + @dataclass class Column: name: str type: str kind: str + @dataclass class JsonColumnsSummary: dataset1: List[Column] @@ -309,23 +315,15 @@ def _jsonify_diff_summary(stats_dict: dict) -> JsonDiffSummary: ) -def _jsonify_columns_diff(dataset1_columns: Columns, - dataset2_columns: Columns, - columns_diff: Dict[str, List[str]], key_columns: List[str]) -> JsonColumnsSummary: +def _jsonify_columns_diff( + dataset1_columns: Columns, dataset2_columns: Columns, columns_diff: Dict[str, List[str]], key_columns: List[str] +) -> JsonColumnsSummary: return JsonColumnsSummary( dataset1=[ - Column(name=name, - type=type_, - kind=_map_kind(kind).value) - for (name, type_, kind) - in dataset1_columns + Column(name=name, type=type_, kind=_map_kind(kind).value) for (name, type_, kind) in dataset1_columns ], dataset2=[ - Column(name=name, - type=type_, - kind=_map_kind(kind).value) - for (name, type_, kind) - in dataset2_columns + Column(name=name, type=type_, kind=_map_kind(kind).value) for (name, type_, kind) in dataset2_columns ], primaryKey=key_columns, exclusive=ExclusiveColumns( @@ -335,6 +333,7 @@ def _jsonify_columns_diff(dataset1_columns: Columns, typeChanged=list(columns_diff.get("changed", [])), ) + def _map_kind(kind: ColType) -> ColumnKind: for raw_kind, json_kind in KIND_MAPPING: if isinstance(kind, raw_kind): diff --git a/tests/test_format.py b/tests/test_format.py index c5f05463..5de8feec 100644 --- a/tests/test_format.py +++ b/tests/test_format.py @@ -37,23 +37,23 @@ def test_jsonify_diff(self): stats={}, ) json_diff = jsonify( - diff, - dbt_model="my_model", + diff, + dbt_model="my_model", dataset1_columns=[ - ('id', 'NUMBER', Integer()), - ('value', 'NUMBER', Integer()), - ], + ("id", "NUMBER", Integer()), + ("value", "NUMBER", Integer()), + ], dataset2_columns=[ - ('id', 'NUMBER', Integer()), - ('value', 'NUMBER', Integer()), + ("id", "NUMBER", Integer()), + ("value", "NUMBER", Integer()), ], columns_diff={ "added": [], "removed": [], "typeChanged": [], - } + }, ) - + self.assertEqual( json_diff, { @@ -78,11 +78,11 @@ def test_jsonify_diff(self): "columns": { "dataset1": [ {"name": "id", "type": "NUMBER", "kind": "integer"}, - {"name": "value", "type": "NUMBER", "kind": "integer"} + {"name": "value", "type": "NUMBER", "kind": "integer"}, ], "dataset2": [ {"name": "id", "type": "NUMBER", "kind": "integer"}, - {"name": "value", "type": "NUMBER", "kind": "integer"} + {"name": "value", "type": "NUMBER", "kind": "integer"}, ], "primaryKey": ["id"], "exclusive": { @@ -120,21 +120,21 @@ def test_jsonify_diff_no_difeference(self): stats={}, ) json_diff = jsonify( - diff, - dbt_model="model", + diff, + dbt_model="model", dataset1_columns=[ - ('id', 'NUMBER', Integer()), - ('value', 'NUMBER', Integer()), - ], + ("id", "NUMBER", Integer()), + ("value", "NUMBER", Integer()), + ], dataset2_columns=[ - ('id', 'NUMBER', Integer()), - ('value', 'NUMBER', Integer()), + ("id", "NUMBER", Integer()), + ("value", "NUMBER", Integer()), ], columns_diff={ "added": [], "removed": [], "changed": [], - } + }, ) self.assertEqual( json_diff, @@ -153,11 +153,11 @@ def test_jsonify_diff_no_difeference(self): "primaryKey": ["id"], "dataset1": [ {"name": "id", "type": "NUMBER", "kind": "integer"}, - {"name": "value", "type": "NUMBER", "kind": "integer"} + {"name": "value", "type": "NUMBER", "kind": "integer"}, ], "dataset2": [ {"name": "id", "type": "NUMBER", "kind": "integer"}, - {"name": "value", "type": "NUMBER", "kind": "integer"} + {"name": "value", "type": "NUMBER", "kind": "integer"}, ], "exclusive": { "dataset1": [], @@ -198,15 +198,15 @@ def test_jsonify_column_suffix_fix(self): stats={}, ) json_diff = jsonify( - diff, + diff, dbt_model="my_model", dataset1_columns=[ - ('id_a', 'NUMBER', Integer()), - ('value_b', 'NUMBER', Integer()), - ], + ("id_a", "NUMBER", Integer()), + ("value_b", "NUMBER", Integer()), + ], dataset2_columns=[ - ('id_a', 'NUMBER', Integer()), - ('value_b', 'NUMBER', Integer()), + ("id_a", "NUMBER", Integer()), + ("value_b", "NUMBER", Integer()), ], columns_diff={ "added": [], @@ -241,11 +241,11 @@ def test_jsonify_column_suffix_fix(self): "columns": { "dataset1": [ {"name": "id_a", "type": "NUMBER", "kind": "integer"}, - {"name": "value_b", "type": "NUMBER", "kind": "integer"} + {"name": "value_b", "type": "NUMBER", "kind": "integer"}, ], "dataset2": [ {"name": "id_a", "type": "NUMBER", "kind": "integer"}, - {"name": "value_b", "type": "NUMBER", "kind": "integer"} + {"name": "value_b", "type": "NUMBER", "kind": "integer"}, ], "primaryKey": ["id_a"], "exclusive": {