recce-nightly 1.10.0.20250625__py3-none-any.whl → 1.30.0.20251221__py3-none-any.whl

tests/test_config.py

@@ -1,43 +0,0 @@
-import os.path
-from unittest import TestCase
-from unittest.mock import patch
-
-from recce.config import RecceConfig
-from recce.util import SingletonMeta
-
-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")
-        pass
-
-    def tearDown(self):
-        # Reset the SingletonMeta instances due to RecceConfig is a singleton
-        SingletonMeta._instances = {}
-
-    def test_load_recce_config(self):
-        config = RecceConfig(self.recce_config_path)
-
-        # Test data contains 2 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")
-    def test_recce_config_not_found(self, mock_save):
-        default_config = RecceConfig("NOT_EXISTING_FILE")
-        assert mock_save.called is True
-        # Default config should be generated
-        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")
-    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}
-        RecceConfig(self.recce_config_path)

tests/test_connect_to_cloud.py

@@ -1,82 +0,0 @@
-import base64
-import unittest
-from unittest.mock import patch
-from urllib.parse import quote
-
-from cryptography.hazmat.primitives import hashes
-from cryptography.hazmat.primitives.asymmetric import padding
-
-from recce.connect_to_cloud import (
-    connect_to_cloud_background_task,
-    decrypt_code,
-    generate_key_pair,
-    is_callback_server_running,
-    prepare_connection_url,
-)
-
-
-class ConnectToCloudTests(unittest.TestCase):
-
-    def test_generate_key_pair(self):
-        private_key, public_key = generate_key_pair()
-        self.assertIsNotNone(private_key)
-        self.assertIsNotNone(public_key)
-        self.assertEqual(private_key.public_key().public_numbers(), public_key.public_numbers())
-
-    def test_prepare_connection_url(self):
-        _, public_key = generate_key_pair()
-        url, port = prepare_connection_url(public_key)
-        self.assertIn("connect?", url)
-        self.assertTrue(port >= 10000 and port <= 15000)
-
-    def test_decrypt_code(self):
-        private_key, public_key = generate_key_pair()
-        test_string = "recce-api-token-123"
-        ciphertext = public_key.encrypt(
-            test_string.encode(),
-            padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None),
-        )
-        b64_ciphertext = base64.b64encode(ciphertext).decode()
-        result = decrypt_code(private_key, b64_ciphertext)
-        self.assertEqual(result, test_string)
-
-    @patch("recce.connect_to_cloud.update_recce_api_token")
-    @patch("recce.connect_to_cloud.update_onboarding_state")
-    @patch("recce.connect_to_cloud.RecceCloud")
-    def test_handle_callback_request_success(self, mock_recce_cloud, mock_update_state, mock_update_token):
-        private_key, public_key = generate_key_pair()
-
-        # Prepare encrypted token
-        test_token = "recce-api-token-xyz"
-        ciphertext = public_key.encrypt(
-            test_token.encode(),
-            padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None),
-        )
-        encrypted_b64 = base64.b64encode(ciphertext).decode()
-
-        # Set up mocks
-        mock_recce_cloud.return_value.verify_token.return_value = True
-
-        from recce.connect_to_cloud import handle_callback_request
-
-        result = handle_callback_request(f"code={quote(encrypted_b64)}", private_key)
-
-        assert result == test_token
-        mock_update_token.assert_called_once_with(test_token)
-        mock_update_state.assert_called_once_with(test_token, False)
-
-    def test_is_callback_server_running(self):
-        # Should return False by default
-        self.assertFalse(is_callback_server_running())
-
-    @patch("recce.connect_to_cloud.run_one_time_http_server")
-    def test_connect_to_cloud_background_task_runs(self, mock_server):
-        private_key, public_key = generate_key_pair()
-        url, port = prepare_connection_url(public_key)
-
-        connect_to_cloud_background_task(private_key, port, url)
-        mock_server.assert_called_once()
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_core.py

@@ -1,29 +0,0 @@
-# noinspection PyUnresolvedReferences
-from tests.adapter.dbt_adapter.conftest import dbt_test_helper  # noqa: F401
-
-
-def test_lineage_diff(dbt_test_helper):
-    sql_model1 = """
-    select a from T
-    """
-
-    sql_model2 = """
-    select a from {{ ref("model1") }}
-    """
-
-    sql_model2_ = """
-    select
-    a,b
-    from
-    {{ ref("model1") }}
-    """
-
-    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")
-    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"
-    )

tests/test_dbt.py

@@ -1,36 +0,0 @@
-import os
-from unittest import TestCase
-from unittest.mock import MagicMock
-
-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"))
-        assert self.manifest is not None
-
-        self.catalog = load_catalog(path=os.path.join(current_dir, "catalog.json"))
-        assert self.catalog is not None
-
-    def tearDown(self):
-        pass
-
-    def test_load_lineage(self):
-        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"]
-
-    def test_load_lineage_with_catalog(self):
-        mock_adapter = MagicMock()
-        mock_adapter.type.return_value = None
-
-        dbt_adapter = DbtAdapter(curr_manifest=self.manifest, curr_catalog=self.catalog)
-        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

tests/test_pull_request.py

@@ -1,130 +0,0 @@
-import json
-from unittest.mock import patch
-
-import pytest
-import requests
-
-from recce.pull_request import _fetch_pr_title, fetch_pr_metadata_from_event_path
-
-
-@pytest.fixture
-def mock_github_event(tmp_path, monkeypatch):
-    event_data = {
-        "number": 1,
-        "pull_request": {
-            "_links": {
-                "html": {"href": "https://github.com/xyz/abc/pull/1"},
-                "self": {"href": "api_url_here"},
-            }
-        },
-    }
-    event_file = tmp_path / "github_event.json"
-    with open(event_file, "w") as f:
-        json.dump(event_data, f)
-
-    monkeypatch.setenv("GITHUB_EVENT_PATH", str(event_file))
-    monkeypatch.setenv("GITHUB_REPOSITORY", "abc/xyz")
-
-
-@pytest.fixture
-def mock_github_token(monkeypatch):
-    monkeypatch.setenv("GITHUB_TOKEN", "github_token_here")
-
-
-class MockResponse:
-    def __init__(self, status_code, json_data=None):
-        self.status_code = status_code
-        self.json_data = json_data
-
-    def json(self):
-        return self.json_data
-
-
-@pytest.fixture
-def mock_get_request_success(monkeypatch):
-    def mock_get(*args, **kwargs):
-        return MockResponse(200, json_data={"title": "Update README.md"})
-
-    monkeypatch.setattr(requests, "get", mock_get)
-
-
-@pytest.fixture
-def mock_get_request_failure(monkeypatch):
-    def mock_get(*args, **kwargs):
-        return MockResponse(404)
-
-    monkeypatch.setattr(requests, "get", mock_get)
-
-
-def test_fetch_pr_metadata(mock_github_event, mock_github_token, mock_get_request_success):
-    result = fetch_pr_metadata_from_event_path()
-
-    assert result is not None
-    assert result["github_pr_id"] == 1
-    assert result["github_pr_url"] == "https://github.com/xyz/abc/pull/1"
-    assert result["github_pr_title"] == "Update README.md"
-    assert result["github_repository"] == "abc/xyz"
-
-
-def test_fetch_pr_metadata_no_event(mock_get_request_success, monkeypatch):
-    monkeypatch.delenv("GITHUB_EVENT_PATH", raising=False)
-
-    result = fetch_pr_metadata_from_event_path()
-
-    assert result is None
-
-
-def test_fetch_pr_metadata_request_error(mock_github_event, mock_get_request_failure):
-    result = fetch_pr_metadata_from_event_path()
-
-    assert result is not None
-    assert result["github_pr_id"] == 1
-    assert result["github_pr_url"] == "https://github.com/xyz/abc/pull/1"
-    assert result["github_pr_title"] is None
-
-
-def test_fetch_pr_metadata_exception(mock_github_event, monkeypatch):
-    monkeypatch.setenv("GITHUB_EVENT_PATH", "nonexistent_path")
-
-    result = fetch_pr_metadata_from_event_path()
-
-    assert result is None
-
-
-def test_fetch_pr_metadata_no_token(mock_github_event):
-    with patch.dict("os.environ", clear=True):
-        result = fetch_pr_metadata_from_event_path()
-
-    assert result is None
-
-
-def test_fetch_pr_title(mock_github_token, mock_get_request_success):
-    result = _fetch_pr_title("api_url_here")
-
-    assert result == "Update README.md"
-
-
-def test_fetch_pr_title_request_error(mock_github_token, mock_get_request_failure):
-    result = _fetch_pr_title("api_url_here")
-
-    assert result is None
-
-
-def test_fetch_pr_title_exception(mock_github_token, monkeypatch):
-    monkeypatch.setenv("GITHUB_TOKEN", "github_token_here")
-
-    def mock_get(*args, **kwargs):
-        raise Exception("Test exception")
-
-    monkeypatch.setattr(requests, "get", mock_get)
-
-    result = _fetch_pr_title("api_url_here")
-
-    assert result is None
-
-
-def test_fetch_pr_title_no_token():
-    with patch.dict("os.environ", clear=True):
-        result = _fetch_pr_title("api_url_here")
-
-    assert result is None

tests/test_server.py

@@ -1,104 +0,0 @@
-import os
-
-import pytest
-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  # noqa: F401
-
-
-@pytest.fixture
-def temp_folder():
-    import tempfile
-
-    temp_dir = tempfile.mkdtemp()
-    yield temp_dir
-
-    import shutil
-
-    shutil.rmtree(temp_dir)
-
-
-def test_health():
-    client = TestClient(app)
-    response = client.get("/api/health")
-    assert response.status_code == 200
-    assert response.json() == {"status": "ok"}
-
-
-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
-
-
-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")
-    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
-
-
-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"))
-
-    from recce.state import RecceStateLoader
-
-    context.state_loader = RecceStateLoader(state_file=state_file)
-    client = TestClient(app)
-
-    response = client.post("/api/save", json={"filename": "recce_state2.json"})
-    assert response.status_code == 200
-    assert os.path.exists(state_file)
-
-    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")
-
-    # Same file
-    response = client.post("/api/save-as", json={"filename": "recce_state2.json"})
-    assert response.status_code == 400
-
-    # folder
-    response = client.post("/api/save-as", json={"filename": "dir.json"})
-    assert response.status_code == 400
-
-    # Rename
-    response = client.post("/api/rename", json={"filename": "recce_state3.json"})
-    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")
-
-    # Conflict
-    response = client.post("/api/save-as", json={"filename": "recce_state.json"})
-    assert response.status_code == 409
-    response = client.post("/api/rename", json={"filename": "recce_state.json"})
-    assert response.status_code == 409
-
-    # 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")

tests/test_state.py

@@ -1,134 +0,0 @@
-# add the RecceState test case
-import os
-import unittest
-from datetime import datetime
-
-from recce.core import RecceContext
-from recce.models import Check, Run
-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")
-
-        context = RecceContext()
-        state = RecceState(checks=[check1], runs=[])
-        context.import_state(state)
-        self.assertEqual(1, len(context.checks))
-        self.assertEqual(check1.name, context.checks[0].name)
-
-        context = RecceContext(checks=[check1, check2])
-        state = RecceState(checks=[check1, check2_2, check3], runs=[])
-        context.import_state(state)
-        self.assertEqual(3, len(context.checks))
-        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,
-        )
-
-        context = RecceContext(checks=[check1])
-        state = RecceState(checks=[check2], runs=[])
-        context.import_state(state)
-        self.assertEqual(1, len(context.checks))
-        self.assertEqual(check2.name, context.checks[0].name)
-
-        context = RecceContext(checks=[check2])
-        state = RecceState(checks=[check1], runs=[])
-        context.import_state(state)
-        self.assertEqual(1, len(context.checks))
-        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")
-
-        context = RecceContext(checks=[check1, check2])
-        state = RecceState(checks=[check2_2, check3], runs=[])
-        context.import_state(state, merge=False)
-        self.assertEqual(2, len(context.checks))
-        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")
-
-        context = RecceContext(runs=[])
-        state = RecceState(runs=[run1])
-        context.import_state(state)
-        self.assertEqual(1, len(context.runs))
-
-        context = RecceContext(runs=[run1, run2])
-        state = RecceState(runs=[run2, run3])
-        context.import_state(state)
-        self.assertEqual(3, len(context.runs))
-
-    def test_merge_dbt_artifacts(self):
-        import json
-        import os
-
-        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"
-        artifacts = ArtifactsRoot(
-            base=dict(
-                manifest=manifest,
-            ),
-            current=dict(
-                manifest=manifest,
-            ),
-        )
-
-        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"))
-
-        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"))
-
-    def test_state_loader(self):
-        # copy ./recce_state.json to temp and open
-
-        # use library to create a temp file in the context
-        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")
-            shutil.copy(state_file, f.name)
-
-            # load the state file
-            state_loader = RecceStateLoader(state_file=f.name)
-            state = state_loader.load()
-            assert len(state.runs) == 17

tests/test_summary.py

@@ -1,65 +0,0 @@
-import os
-import unittest
-
-from recce.adapter.dbt_adapter import DbtAdapter, DbtVersion, load_manifest
-from recce.core import RecceContext, set_default_context
-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
-
-dbt_version = DbtVersion()
-
-
-@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"))
-    assert manifest is not None
-    dbt_adapter = DbtAdapter(curr_manifest=manifest)
-    curr_lineage = dbt_adapter.get_lineage()
-    base_lineage = dbt_adapter.get_lineage()
-
-    # 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"))
-    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")
-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"))
-    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)
-
-    lineage_graph = _build_lineage_graph(curr_lineage, base_lineage)
-    # Modified nodes: 3
-    # - int_customer_orders: added
-    # - int_customer_payments: added
-    # - customers: modified
-    assert len(lineage_graph.modified_set) == 3
-
-
-@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"))
-    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)
-    graph = _build_lineage_graph(curr_lineage, base_lineage)
-    mermaid_content, is_empty_graph, is_partial_graph = generate_mermaid_lineage_graph(graph)
-    assert is_empty_graph is False
-    assert is_partial_graph is False