recce-nightly 1.3.0.20250507__py3-none-any.whl → 1.4.0.20250514__py3-none-any.whl

tests/test_config.py

@@ -10,7 +10,7 @@ test_root_path = os.path.dirname(os.path.abspath(__file__))
 
 class RecceConfigTestCase(TestCase):
     def setUp(self):
-        self.recce_config_path = os.path.join(test_root_path, 'data', 'config', 'recce.yml')
+        self.recce_config_path = os.path.join(test_root_path, "data", "config", "recce.yml")
         pass
 
     def tearDown(self):
@@ -21,25 +21,23 @@ class RecceConfigTestCase(TestCase):
         config = RecceConfig(self.recce_config_path)
 
         # Test data contains 2 checks
-        preset_checks = config.config.get('checks')
+        preset_checks = config.config.get("checks")
         self.assertIsNotNone(preset_checks)
         self.assertIsInstance(preset_checks, list)
         self.assertEqual(len(preset_checks), 2)
 
-    @patch('recce.config.RecceConfig.save')
+    @patch("recce.config.RecceConfig.save")
     def test_recce_config_not_found(self, mock_save):
-        default_config = RecceConfig('NOT_EXISTING_FILE')
+        default_config = RecceConfig("NOT_EXISTING_FILE")
         assert mock_save.called is True
         # Default config should be generated
-        preset_checks = default_config.config.get('checks')
+        preset_checks = default_config.config.get("checks")
         self.assertIsNotNone(default_config.config)
         self.assertIsInstance(preset_checks, list)
         self.assertEqual(len(preset_checks), 2)
 
-    @patch('recce.yaml.safe_load')
+    @patch("recce.yaml.safe_load")
     def test_recce_config_null_checks(self, mock_yaml_safe_load):
         # mock to load a yaml file with null checks
-        mock_yaml_safe_load.return_value = {
-            'checks': None
-        }
+        mock_yaml_safe_load.return_value = {"checks": None}
         RecceConfig(self.recce_config_path)

tests/test_core.py

@@ -21,7 +21,9 @@ def test_lineage_diff(dbt_test_helper):
     dbt_test_helper.create_model("model1", sql_model1, sql_model1)
     dbt_test_helper.create_model("model2", sql_model2, sql_model2_)
     result = dbt_test_helper.context.get_lineage_diff()
-    nodediff = result.diff.get('model1')
+    nodediff = result.diff.get("model1")
     assert nodediff is None
-    nodediff2 = result.diff.get('model2')
-    assert nodediff2 is not None and nodediff2.change_status == 'modified' and nodediff2.change.category == 'non_breaking'
+    nodediff2 = result.diff.get("model2")
+    assert (
+        nodediff2 is not None and nodediff2.change_status == "modified" and nodediff2.change.category == "non_breaking"
+    )

tests/test_dbt.py

@@ -1,18 +1,18 @@
 import os
 from unittest import TestCase
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
 
-from recce.adapter.dbt_adapter import load_manifest, load_catalog, DbtAdapter
+from recce.adapter.dbt_adapter import DbtAdapter, load_catalog, load_manifest
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 
 
 class TestAdapterLineage(TestCase):
     def setUp(self) -> None:
-        self.manifest = load_manifest(path=os.path.join(current_dir, 'manifest.json'))
+        self.manifest = load_manifest(path=os.path.join(current_dir, "manifest.json"))
         assert self.manifest is not None
 
-        self.catalog = load_catalog(path=os.path.join(current_dir, 'catalog.json'))
+        self.catalog = load_catalog(path=os.path.join(current_dir, "catalog.json"))
         assert self.catalog is not None
 
     def tearDown(self):
@@ -22,8 +22,8 @@ class TestAdapterLineage(TestCase):
         dbt_adapter = DbtAdapter(curr_manifest=self.manifest)
         lineage = dbt_adapter.get_lineage()
         assert lineage is not None
-        assert lineage['nodes']['model.jaffle_shop.orders'] is not None
-        assert 'columns' not in lineage['nodes']['model.jaffle_shop.orders']
+        assert lineage["nodes"]["model.jaffle_shop.orders"] is not None
+        assert "columns" not in lineage["nodes"]["model.jaffle_shop.orders"]
 
     def test_load_lineage_with_catalog(self):
         mock_adapter = MagicMock()
@@ -33,4 +33,4 @@ class TestAdapterLineage(TestCase):
         dbt_adapter.adapter = mock_adapter
         lineage = dbt_adapter.get_lineage()
         assert lineage is not None
-        assert len(lineage['nodes']['model.jaffle_shop.orders']['columns']) == 9
+        assert len(lineage["nodes"]["model.jaffle_shop.orders"]["columns"]) == 9

tests/test_pull_request.py

@@ -4,7 +4,7 @@ from unittest.mock import patch
 import pytest
 import requests
 
-from recce.pull_request import fetch_pr_metadata_from_event_path, _fetch_pr_title
+from recce.pull_request import _fetch_pr_title, fetch_pr_metadata_from_event_path
 
 
 @pytest.fixture

tests/test_server.py

@@ -5,6 +5,7 @@ from fastapi.testclient import TestClient
 
 from recce.core import default_context
 from recce.server import app
+
 # noinspection PyUnresolvedReferences
 from tests.adapter.dbt_adapter.conftest import dbt_test_helper
 
@@ -12,10 +13,12 @@ from tests.adapter.dbt_adapter.conftest import dbt_test_helper
 @pytest.fixture
 def temp_folder():
     import tempfile
+
     temp_dir = tempfile.mkdtemp()
     yield temp_dir
 
     import shutil
+
     shutil.rmtree(temp_dir)
 
 
@@ -29,36 +32,39 @@ def test_health():
 def test_stateless(dbt_test_helper):
     context = default_context()
     from recce.state import RecceStateLoader
+
     context.state_loader = RecceStateLoader()
     client = TestClient(app)
     response = client.get("/api/info")
     assert response.status_code == 200
     info = response.json()
-    assert info['file_mode'] is False
-    assert info['cloud_mode'] is False
+    assert info["file_mode"] is False
+    assert info["cloud_mode"] is False
 
 
 def test_file_mode(dbt_test_helper):
     context = default_context()
     from recce.state import RecceStateLoader
-    context.state_loader = RecceStateLoader(state_file='/tmp/recce_state.json')
+
+    context.state_loader = RecceStateLoader(state_file="/tmp/recce_state.json")
     client = TestClient(app)
     response = client.get("/api/info")
     assert response.status_code == 200
     info = response.json()
-    assert info['file_mode'] is True
-    assert info['filename'] == 'recce_state.json'
-    assert info['cloud_mode'] is False
+    assert info["file_mode"] is True
+    assert info["filename"] == "recce_state.json"
+    assert info["cloud_mode"] is False
 
 
 def test_saveas_and_rename(dbt_test_helper, temp_folder):
     context = default_context()
-    state_file = os.path.join(temp_folder, 'recce_state.json')
-    state_file2 = os.path.join(temp_folder, 'recce_state2.json')
-    state_file3 = os.path.join(temp_folder, 'recce_state3.json')
-    os.makedirs(os.path.join(temp_folder, 'dir.json'))
+    state_file = os.path.join(temp_folder, "recce_state.json")
+    state_file2 = os.path.join(temp_folder, "recce_state2.json")
+    state_file3 = os.path.join(temp_folder, "recce_state3.json")
+    os.makedirs(os.path.join(temp_folder, "dir.json"))
 
     from recce.state import RecceStateLoader
+
     context.state_loader = RecceStateLoader(state_file=state_file)
     client = TestClient(app)
 
@@ -69,7 +75,7 @@ def test_saveas_and_rename(dbt_test_helper, temp_folder):
     response = client.post("/api/save-as", json={"filename": "recce_state2.json"})
     assert response.status_code == 200
     assert os.path.exists(state_file2)
-    assert context.state_loader.state_file == os.path.join(temp_folder, 'recce_state2.json')
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state2.json")
 
     # Same file
     response = client.post("/api/save-as", json={"filename": "recce_state2.json"})
@@ -84,7 +90,7 @@ def test_saveas_and_rename(dbt_test_helper, temp_folder):
     assert response.status_code == 200
     assert not os.path.exists(state_file2)
     assert os.path.exists(state_file3)
-    assert context.state_loader.state_file == os.path.join(temp_folder, 'recce_state3.json')
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state3.json")
 
     # Conflict
     response = client.post("/api/save-as", json={"filename": "recce_state.json"})
@@ -95,4 +101,4 @@ def test_saveas_and_rename(dbt_test_helper, temp_folder):
     # Overwrite
     response = client.post("/api/save-as", json={"filename": "recce_state.json", "overwrite": True})
     assert response.status_code == 200
-    assert context.state_loader.state_file == os.path.join(temp_folder, 'recce_state.json')
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state.json")

tests/test_state.py

@@ -5,20 +5,19 @@ from datetime import datetime
 
 from recce.core import RecceContext
 from recce.models import Check, Run
-from recce.state import RecceState, ArtifactsRoot, RecceStateLoader
+from recce.state import ArtifactsRoot, RecceState, RecceStateLoader
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
 
 
 class TestRecceState(unittest.TestCase):
     def test_merge_checks(self):
-        check1 = Check(name='test1', description='', type='query')
-        check2 = Check(name='test2', description='', type='query',
-                       updated_at=datetime(2000, 1, 1))
-        check2_2 = Check(name='test2_2', description='', type='query',
-                         updated_at=datetime(2020, 1, 1),
-                         check_id=check2.check_id)
-        check3 = Check(name='test3', description='', type='query')
+        check1 = Check(name="test1", description="", type="query")
+        check2 = Check(name="test2", description="", type="query", updated_at=datetime(2000, 1, 1))
+        check2_2 = Check(
+            name="test2_2", description="", type="query", updated_at=datetime(2020, 1, 1), check_id=check2.check_id
+        )
+        check3 = Check(name="test3", description="", type="query")
 
         context = RecceContext()
         state = RecceState(checks=[check1], runs=[])
@@ -33,10 +32,22 @@ class TestRecceState(unittest.TestCase):
         self.assertEqual(check2_2.name, context.checks[1].name)
 
     def test_merge_preset_checks(self):
-        check1 = Check(name='test1', description='test1', type='query', params=dict(foo='bar'),
-                       updated_at=datetime(2000, 1, 1), is_preset=True)
-        check2 = Check(name='test2', description='test2', type='query', params=dict(foo='bar'),
-                       updated_at=datetime(2001, 1, 1), is_preset=True)
+        check1 = Check(
+            name="test1",
+            description="test1",
+            type="query",
+            params=dict(foo="bar"),
+            updated_at=datetime(2000, 1, 1),
+            is_preset=True,
+        )
+        check2 = Check(
+            name="test2",
+            description="test2",
+            type="query",
+            params=dict(foo="bar"),
+            updated_at=datetime(2001, 1, 1),
+            is_preset=True,
+        )
 
         context = RecceContext(checks=[check1])
         state = RecceState(checks=[check2], runs=[])
@@ -51,10 +62,10 @@ class TestRecceState(unittest.TestCase):
         self.assertEqual(check2.name, context.checks[0].name)
 
     def test_revert_checks(self):
-        check1 = Check(name='test1', description='', type='query')
-        check2 = Check(name='test2', description='', type='query')
-        check2_2 = Check(name='test2_2', description='', type='query', check_id=check2.check_id)
-        check3 = Check(name='test3', description='', type='query')
+        check1 = Check(name="test1", description="", type="query")
+        check2 = Check(name="test2", description="", type="query")
+        check2_2 = Check(name="test2_2", description="", type="query", check_id=check2.check_id)
+        check3 = Check(name="test3", description="", type="query")
 
         context = RecceContext(checks=[check1, check2])
         state = RecceState(checks=[check2_2, check3], runs=[])
@@ -63,9 +74,9 @@ class TestRecceState(unittest.TestCase):
         self.assertEqual(check2_2.name, context.checks[0].name)
 
     def test_merge_runs(self):
-        run1 = Run(type='query')
-        run2 = Run(type='query')
-        run3 = Run(type='query')
+        run1 = Run(type="query")
+        run2 = Run(type="query")
+        run3 = Run(type="query")
 
         context = RecceContext(runs=[])
         state = RecceState(runs=[run1])
@@ -80,9 +91,10 @@ class TestRecceState(unittest.TestCase):
     def test_merge_dbt_artifacts(self):
         import json
         import os
-        with open(os.path.join(current_dir, 'manifest.json'), 'r') as f:
+
+        with open(os.path.join(current_dir, "manifest.json"), "r") as f:
             manifest = json.load(f)
-        manifest['metadata']['generated_at'] = '2000-01-01T00:00:00Z'
+        manifest["metadata"]["generated_at"] = "2000-01-01T00:00:00Z"
         artifacts = ArtifactsRoot(
             base=dict(
                 manifest=manifest,
@@ -93,13 +105,14 @@ class TestRecceState(unittest.TestCase):
         )
 
         from tests.adapter.dbt_adapter.dbt_test_helper import DbtTestHelper
+
         adapter = DbtTestHelper().adapter
         adapter.import_artifacts(artifacts)
-        self.assertNotEqual(adapter.base_manifest.metadata.invocation_id, manifest.get('metadata').get('invocation_id'))
+        self.assertNotEqual(adapter.base_manifest.metadata.invocation_id, manifest.get("metadata").get("invocation_id"))
 
-        manifest['metadata']['generated_at'] = '2099-01-01T00:00:00Z'
+        manifest["metadata"]["generated_at"] = "2099-01-01T00:00:00Z"
         adapter.import_artifacts(artifacts)
-        self.assertEqual(adapter.base_manifest.metadata.invocation_id, manifest.get('metadata').get('invocation_id'))
+        self.assertEqual(adapter.base_manifest.metadata.invocation_id, manifest.get("metadata").get("invocation_id"))
 
     def test_state_loader(self):
         context = RecceContext()
@@ -107,14 +120,14 @@ class TestRecceState(unittest.TestCase):
         # copy ./recce_state.json to temp and open
 
         # use library to create a temp file in the context
-        import tempfile
-        import shutil
         import os
+        import shutil
+        import tempfile
 
         with tempfile.NamedTemporaryFile() as f:
             # copy ./recce_state.json to temp file
             current_dir = os.path.dirname(os.path.abspath(__file__))
-            state_file = os.path.join(current_dir, 'recce_state.json')
+            state_file = os.path.join(current_dir, "recce_state.json")
             shutil.copy(state_file, f.name)
 
             # load the state file

tests/test_summary.py

@@ -1,20 +1,24 @@
 import os
 import unittest
 
-from recce.adapter.dbt_adapter import load_manifest, DbtAdapter, DbtVersion
+from recce.adapter.dbt_adapter import DbtAdapter, DbtVersion, load_manifest
 from recce.core import RecceContext, set_default_context
-from recce.summary import generate_summary_metadata, _build_lineage_graph, generate_mermaid_lineage_graph
+from recce.summary import (
+    _build_lineage_graph,
+    generate_mermaid_lineage_graph,
+    generate_summary_metadata,
+)
 
 current_dir = os.path.dirname(os.path.abspath(__file__))
-base_manifest_dir = os.path.join(current_dir, 'data', 'manifest', 'base')
-pr2_manifest_dir = os.path.join(current_dir, 'data', 'manifest', 'pr2')  # Pull Request 2l
+base_manifest_dir = os.path.join(current_dir, "data", "manifest", "base")
+pr2_manifest_dir = os.path.join(current_dir, "data", "manifest", "pr2")  # Pull Request 2l
 
 dbt_version = DbtVersion()
 
 
-@unittest.skipIf(dbt_version < '1.8.1', "Dbt version is less than 1.8.1")
+@unittest.skipIf(dbt_version < "1.8.1", "Dbt version is less than 1.8.1")
 def test_generate_summary_metadata():
-    manifest = load_manifest(path=os.path.join(current_dir, 'manifest.json'))
+    manifest = load_manifest(path=os.path.join(current_dir, "manifest.json"))
     assert manifest is not None
     dbt_adapter = DbtAdapter(curr_manifest=manifest)
     curr_lineage = dbt_adapter.get_lineage()
@@ -23,18 +27,18 @@ def test_generate_summary_metadata():
     # Summary with no changes
     generate_summary_metadata(curr_lineage, base_lineage)
 
-    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, 'manifest.json'))
-    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, 'manifest.json'))
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
     dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
     curr_lineage = dbt_adapter.get_lineage()
     base_lineage = dbt_adapter.get_lineage(base=True)
     generate_summary_metadata(curr_lineage, base_lineage)
 
 
-@unittest.skipIf(dbt_version < 'v1.8.1', "Dbt version is less than 1.8.1")
+@unittest.skipIf(dbt_version < "v1.8.1", "Dbt version is less than 1.8.1")
 def test_build_lineage_graph():
-    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, 'manifest.json'))
-    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, 'manifest.json'))
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
     dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
     curr_lineage = dbt_adapter.get_lineage()
     base_lineage = dbt_adapter.get_lineage(base=True)
@@ -47,11 +51,11 @@ def test_build_lineage_graph():
     assert len(lineage_graph.modified_set) == 3
 
 
-@unittest.skipIf(dbt_version < 'v1.8.1', "Dbt version is less than 1.8.1")
+@unittest.skipIf(dbt_version < "v1.8.1", "Dbt version is less than 1.8.1")
 def test_generate_mermaid_lineage_graph():
     set_default_context(RecceContext())
-    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, 'manifest.json'))
-    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, 'manifest.json'))
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
     dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
     curr_lineage = dbt_adapter.get_lineage()
     base_lineage = dbt_adapter.get_lineage(base=True)