fixed linters issues

Author: arbiv

integration_tests/tests/dbt_project.py

@@ -290,4 +290,6 @@ def assert_table_exists(self, table_name: str):
             table_exists_result = []
         except Exception as e:
             raise AssertionError(f"Failed to check if {table_name} exists: {e}")
-        assert table_exists_result, f"{table_name} table does not exist. The artifact was not created."
+        assert (
+            table_exists_result
+        ), f"{table_name} table does not exist. The artifact was not created."

integration_tests/tests/test_dbt_artifacts/test_groups.py

@@ -1,6 +1,5 @@
-from dbt_project import DbtProject
 import pytest
-from ruamel.yaml import YAML
+from dbt_project import DbtProject
 
 GROUP_NAME = "test_group"
 OWNER_NAME = "Data Spock"
@@ -25,7 +24,9 @@ def _write_group_config(dbt_project: DbtProject, group_config: dict, name: str):
     return dbt_project.write_yaml(group_config, name=name)
 
 
-def _get_group_from_table(dbt_project: DbtProject, group_name: str, table_name: str = "dbt_groups"):
+def _get_group_from_table(
+    dbt_project: DbtProject, group_name: str, table_name: str = "dbt_groups"
+):
     """Helper to read a group from the dbt_groups artifact table."""
     groups = dbt_project.read_table(table_name, raise_if_empty=True)
     return next((g for g in groups if g["name"] == group_name), None)
@@ -42,34 +43,43 @@ def _get_group_from_table(dbt_project: DbtProject, group_name: str, table_name:
         ),
         # Single group with name only, no email
         (
-            {"groups": [
-                {"name": GROUP_NAME, "owner": {"name": OWNER_NAME}}
-            ]},
+            {"groups": [{"name": GROUP_NAME, "owner": {"name": OWNER_NAME}}]},
             [(GROUP_NAME, OWNER_NAME, None)],
             "single_group_without_email",
         ),
         # Single group with email only, no name
         (
-            {"groups": [
-                {"name": GROUP_NAME, "owner": {"email": OWNER_EMAIL}}
-            ]},
+            {"groups": [{"name": GROUP_NAME, "owner": {"email": OWNER_EMAIL}}]},
             [(GROUP_NAME, None, OWNER_EMAIL)],
             "single_group_without_name",
         ),
         # Single group with owner additional fields
         (
-            {"groups": [
-                {"name": GROUP_NAME, "owner": {"email": OWNER_EMAIL, "slack": "slack_channel"}}
-            ]},
+            {
+                "groups": [
+                    {
+                        "name": GROUP_NAME,
+                        "owner": {"email": OWNER_EMAIL, "slack": "slack_channel"},
+                    }
+                ]
+            },
             [(GROUP_NAME, None, OWNER_EMAIL)],
             "single_group_with_additional_fields",
         ),
         # Two groups, each with owner
         (
-            {"groups": [
-                {"name": "test_group_1", "owner": {"name": "Owner One", "email": "[email protected]"}},
-                {"name": "test_group_2", "owner": {"name": "Owner Two", "email": "[email protected]"}},
-            ]},
+            {
+                "groups": [
+                    {
+                        "name": "test_group_1",
+                        "owner": {"name": "Owner One", "email": "[email protected]"},
+                    },
+                    {
+                        "name": "test_group_2",
+                        "owner": {"name": "Owner Two", "email": "[email protected]"},
+                    },
+                ]
+            },
             [
                 ("test_group_1", "Owner One", "[email protected]"),
                 ("test_group_2", "Owner Two", "[email protected]"),
@@ -83,25 +93,35 @@ def _get_group_from_table(dbt_project: DbtProject, group_name: str, table_name:
         "single_group_without_name",
         "single_group_with_additional_fields",
         "two_groups",
-    ]
+    ],
 )
-def test_dbt_groups_artifact_parametrized(dbt_project: DbtProject, group_config, expected_groups, test_name):
+def test_dbt_groups_artifact_parametrized(
+    dbt_project: DbtProject, group_config, expected_groups, test_name
+):
     """
     Parametrized test for group artifact scenarios:
     - Single group with owner (name and email)
     - Single group with owner (name only, no email)
     - Two groups, each with owner
     Asserts that the group(s) and owner details are present and correct in the dbt_groups artifact table.
     """
-    with _write_group_config(dbt_project, group_config, name=f"groups_test_{test_name}.yml"):
+    with _write_group_config(
+        dbt_project, group_config, name=f"groups_test_{test_name}.yml"
+    ):
         dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
         dbt_project.dbt_runner.run()
         dbt_project.assert_table_exists("dbt_groups")
     for group_name, owner_name, owner_email in expected_groups:
         group = _get_group_from_table(dbt_project, group_name)
-        assert group is not None, f"Group {group_name} not found in dbt_groups artifact table."
-        assert group.get("owner_name") == owner_name, f"Expected owner name {owner_name}, got {group.get('owner_name')}"
-        assert group.get("owner_email") == owner_email, f"Expected owner email {owner_email}, got {group.get('owner_email')}"
+        assert (
+            group is not None
+        ), f"Group {group_name} not found in dbt_groups artifact table."
+        assert (
+            group.get("owner_name") == owner_name
+        ), f"Expected owner name {owner_name}, got {group.get('owner_name')}"
+        assert (
+            group.get("owner_email") == owner_email
+        ), f"Expected owner email {owner_email}, got {group.get('owner_email')}"
 
 
 def test_model_group_attribute(dbt_project: DbtProject):
@@ -121,21 +141,26 @@ def test_model_group_attribute(dbt_project: DbtProject):
                 "group": GROUP_NAME,
                 "description": "A model assigned to a group for testing",
             }
-        ]
+        ],
     }
-    with _write_group_config(dbt_project, GROUP_CONFIG, name="groups_test_model_inherits.yml"), \
-         dbt_project.write_yaml(schema_yaml, name="schema_model_with_group.yml"):
+    with _write_group_config(
+        dbt_project, GROUP_CONFIG, name="groups_test_model_inherits.yml"
+    ), dbt_project.write_yaml(schema_yaml, name="schema_model_with_group.yml"):
         model_path = dbt_project.models_dir_path / "tmp" / f"{model_name}.sql"
         model_path.parent.mkdir(parents=True, exist_ok=True)
         model_path.write_text(model_sql)
         try:
             dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
             dbt_project.dbt_runner.run(select=model_name)
             dbt_project.assert_table_exists("dbt_models")
-            models = dbt_project.read_table("dbt_models", where=f"name = '{model_name}'", raise_if_empty=True)
+            models = dbt_project.read_table(
+                "dbt_models", where=f"name = '{model_name}'", raise_if_empty=True
+            )
             assert len(models) == 1, f"Expected 1 model, got {len(models)}"
             model_row = models[0]
-            assert model_row["group_name"] == GROUP_NAME, f"Expected group_name {GROUP_NAME}, got {model_row['group_name']}"
+            assert (
+                model_row["group_name"] == GROUP_NAME
+            ), f"Expected group_name {GROUP_NAME}, got {model_row['group_name']}"
         finally:
             if model_path.exists():
                 model_path.unlink()
@@ -154,31 +179,31 @@ def test_test_group_attribute(dbt_project: DbtProject):
                 "name": model_name,
                 "group": GROUP_NAME,
                 "description": "A model assigned to a group for testing",
-                "columns": [
-                    {
-                        "name": "col",
-                        "tests": ["unique"]
-                    }
-                ]
+                "columns": [{"name": "col", "tests": ["unique"]}],
             }
-        ]
+        ],
     }
     model_sql = """
     select 1 as col
     """
-    with _write_group_config(dbt_project, GROUP_CONFIG, name="groups_test_model_inherits.yml"), \
-         dbt_project.write_yaml(schema_yaml, name="schema_model_with_group.yml"):
+    with _write_group_config(
+        dbt_project, GROUP_CONFIG, name="groups_test_model_inherits.yml"
+    ), dbt_project.write_yaml(schema_yaml, name="schema_model_with_group.yml"):
         model_path = dbt_project.models_dir_path / "tmp" / f"{model_name}.sql"
         model_path.parent.mkdir(parents=True, exist_ok=True)
         model_path.write_text(model_sql)
         try:
             dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
             dbt_project.dbt_runner.run(select=model_name)
             dbt_project.assert_table_exists("dbt_tests")
-            tests = dbt_project.read_table("dbt_tests", where="name LIKE 'unique%'", raise_if_empty=True)
+            tests = dbt_project.read_table(
+                "dbt_tests", where="name LIKE 'unique%'", raise_if_empty=True
+            )
             assert len(tests) == 1, f"Expected 1 test, got {len(tests)}"
             test_row = tests[0]
-            assert test_row["group_name"] == GROUP_NAME, f"Expected group_name {GROUP_NAME}, got {test_row['group_name']}"
+            assert (
+                test_row["group_name"] == GROUP_NAME
+            ), f"Expected group_name {GROUP_NAME}, got {test_row['group_name']}"
         finally:
             if model_path.exists():
                 model_path.unlink()
@@ -196,7 +221,10 @@ def test_test_override_group(dbt_project: DbtProject):
     group_config = {
         "groups": [
             {"name": test_group, "owner": {"name": OWNER_NAME, "email": OWNER_EMAIL}},
-            {"name": override_group, "owner": {"name": "Override Owner", "email": "[email protected]"}},
+            {
+                "name": override_group,
+                "owner": {"name": "Override Owner", "email": "[email protected]"},
+            },
         ]
     }
     schema_yaml = {
@@ -209,34 +237,33 @@ def test_test_override_group(dbt_project: DbtProject):
                 "columns": [
                     {
                         "name": "col",
-                        "tests": [
-                            {
-                                "unique": {
-                                    "config": {"group": override_group}
-                                }
-                            }
-                        ]
+                        "tests": [{"unique": {"config": {"group": override_group}}}],
                     }
-                ]
+                ],
             }
-        ]
+        ],
     }
     model_sql = """
     select 1 as col
     """
-    with _write_group_config(dbt_project, group_config, name="groups_test_override_group.yml"), \
-         dbt_project.write_yaml(schema_yaml, name="schema_model_with_override_group.yml"):
+    with _write_group_config(
+        dbt_project, group_config, name="groups_test_override_group.yml"
+    ), dbt_project.write_yaml(schema_yaml, name="schema_model_with_override_group.yml"):
         model_path = dbt_project.models_dir_path / "tmp" / f"{model_name}.sql"
         model_path.parent.mkdir(parents=True, exist_ok=True)
         model_path.write_text(model_sql)
         try:
             dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
             dbt_project.dbt_runner.run(select=model_name)
             dbt_project.assert_table_exists("dbt_tests")
-            tests = dbt_project.read_table("dbt_tests", where="name LIKE 'unique%'", raise_if_empty=True)
+            tests = dbt_project.read_table(
+                "dbt_tests", where="name LIKE 'unique%'", raise_if_empty=True
+            )
             assert len(tests) == 1, f"Expected 1 test, got {len(tests)}"
             test_row = tests[0]
-            assert test_row["group_name"] == override_group, f"Expected group_name {override_group}, got {test_row['group_name']}"
+            assert (
+                test_row["group_name"] == override_group
+            ), f"Expected group_name {override_group}, got {test_row['group_name']}"
         finally:
             if model_path.exists():
                 model_path.unlink()
@@ -258,25 +285,30 @@ def test_seed_group_attribute(dbt_project: DbtProject):
                 "group": GROUP_NAME,
                 "description": "A seed assigned to a group for testing",
             }
-        ]
+        ],
     }
 
     seed_path = dbt_project.seeds_dir_path / f"{seed_name}.csv"
     try:
-        with _write_group_config(dbt_project, GROUP_CONFIG, name="groups_test_seed_inherits.yml"), \
-             dbt_project.write_yaml(schema_yaml, name="schema_seed_with_group.yml"):
+        with _write_group_config(
+            dbt_project, GROUP_CONFIG, name="groups_test_seed_inherits.yml"
+        ), dbt_project.write_yaml(schema_yaml, name="schema_seed_with_group.yml"):
             seed_path.parent.mkdir(parents=True, exist_ok=True)
             seed_path.write_text(seed_csv)
             # Run dbt seed
             dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
             dbt_project.dbt_runner.seed(select=seed_name)
 
-            dbt_project.assert_table_exists('dbt_seeds')
+            dbt_project.assert_table_exists("dbt_seeds")
 
-            seeds = dbt_project.read_table("dbt_seeds", where=f"name = '{seed_name}'", raise_if_empty=True)
+            seeds = dbt_project.read_table(
+                "dbt_seeds", where=f"name = '{seed_name}'", raise_if_empty=True
+            )
             assert len(seeds) == 1, f"Expected 1 seed, got {len(seeds)}"
             seed_row = seeds[0]
-            assert seed_row["group_name"] == GROUP_NAME, f"Expected group_name {GROUP_NAME}, got {seed_row['group_name']}"
+            assert (
+                seed_row["group_name"] == GROUP_NAME
+            ), f"Expected group_name {GROUP_NAME}, got {seed_row['group_name']}"
     finally:
         if seed_path.exists():
             seed_path.unlink()
@@ -306,29 +338,40 @@ def test_snapshot_group_attribute(dbt_project: DbtProject):
                 "group": GROUP_NAME,
                 "description": "A snapshot assigned to a group for testing",
             }
-        ]
+        ],
     }
     snapshots_dir = dbt_project.project_dir_path / "snapshots"
     snapshot_path = snapshots_dir / f"{snapshot_name}.sql"
     try:
-        with _write_group_config(dbt_project, GROUP_CONFIG, name="groups_test_snapshot_inherits.yml"), \
-             dbt_project.write_yaml(schema_yaml, name="schema_snapshot_with_group.yml"):
+        with _write_group_config(
+            dbt_project, GROUP_CONFIG, name="groups_test_snapshot_inherits.yml"
+        ), dbt_project.write_yaml(schema_yaml, name="schema_snapshot_with_group.yml"):
             snapshots_dir.mkdir(parents=True, exist_ok=True)
             snapshot_path.write_text(snapshot_sql)
             # Debug: print file existence and directory contents
-            print(f"DEBUG: Snapshot file exists: {snapshot_path.exists()} at {snapshot_path}")
-            print(f"DEBUG: Snapshots dir contents: {list(snapshots_dir.iterdir()) if snapshots_dir.exists() else 'DIR DOES NOT EXIST'}")
+            print(
+                f"DEBUG: Snapshot file exists: {snapshot_path.exists()} at {snapshot_path}"
+            )
+            print(
+                f"DEBUG: Snapshots dir contents: {list(snapshots_dir.iterdir()) if snapshots_dir.exists() else 'DIR DOES NOT EXIST'}"
+            )
             # Run dbt snapshot (runs all snapshots, as selecting is not supported by the runner)
             dbt_project.dbt_runner.vars["disable_dbt_artifacts_autoupload"] = False
             dbt_project.dbt_runner.run()
 
-            dbt_project.assert_table_exists('dbt_snapshots')
+            dbt_project.assert_table_exists("dbt_snapshots")
 
-            snapshots = dbt_project.read_table("dbt_snapshots", where=f"name = '{snapshot_name}'", raise_if_empty=False)
-            assert snapshots, f"No rows found in dbt_snapshots for name = '{snapshot_name}'"
+            snapshots = dbt_project.read_table(
+                "dbt_snapshots", where=f"name = '{snapshot_name}'", raise_if_empty=False
+            )
+            assert (
+                snapshots
+            ), f"No rows found in dbt_snapshots for name = '{snapshot_name}'"
             assert len(snapshots) == 1, f"Expected 1 snapshot, got {len(snapshots)}"
             snapshot_row = snapshots[0]
-            assert snapshot_row["group_name"] == GROUP_NAME, f"Expected group_name {GROUP_NAME}, got {snapshot_row['group_name']}"
+            assert (
+                snapshot_row["group_name"] == GROUP_NAME
+            ), f"Expected group_name {GROUP_NAME}, got {snapshot_row['group_name']}"
     finally:
         if snapshot_path.exists():
             snapshot_path.unlink()