@datarecce/ui 0.1.30 → 0.1.31

package/recce-source/tests/test_cloud_listing_cli.py

@@ -0,0 +1,324 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from click.testing import CliRunner
+
+from recce.cli import list_organizations, list_projects, list_sessions
+from recce.exceptions import RecceConfigException
+from recce.util.recce_cloud import RecceCloudException
+
+
+class TestCloudListingCLI(unittest.TestCase):
+    """Test cases for the cloud listing CLI commands."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_organizations_success(self, mock_recce_cloud, mock_prepare_token):
+        """Test successful list-organizations command."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_organizations.return_value = [
+            {"id": 1, "name": "org1", "display_name": "Organization 1"},
+            {"id": 2, "name": "org2", "display_name": "Organization 2"},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Organizations", result.output)
+        self.assertIn("org1", result.output)
+        self.assertIn("Organization 1", result.output)
+        self.assertIn("org2", result.output)
+        self.assertIn("Organization 2", result.output)
+        mock_cloud_instance.list_organizations.assert_called_once()
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_organizations_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-organizations command with no organizations."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_organizations.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No organizations found", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_organizations_invalid_token(self, mock_prepare_token):
+        """Test list-organizations command with invalid token."""
+        # Setup mock to raise exception
+        mock_prepare_token.side_effect = RecceConfigException("Invalid token")
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_with_cli_arg(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with CLI argument."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [
+            {"id": 1, "name": "project1", "display_name": "Project 1"},
+            {"id": 2, "name": "project2", "display_name": "Project 2"},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with CLI argument
+        result = self.runner.invoke(list_projects, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 8", result.output)
+        self.assertIn("project1", result.output)
+        self.assertIn("Project 1", result.output)
+        mock_cloud_instance.list_projects.assert_called_once_with("8")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_with_env_var(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with environment variable."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [{"id": 1, "name": "project1", "display_name": "Project 1"}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with environment variable
+        result = self.runner.invoke(list_projects, [], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 8", result.output)
+        self.assertIn("project1", result.output)
+        mock_cloud_instance.list_projects.assert_called_once_with("8")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_cli_overrides_env(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command where CLI argument overrides environment variable."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [{"id": 1, "name": "project1", "display_name": "Project 1"}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with both env var and CLI arg (CLI should win)
+        result = self.runner.invoke(list_projects, ["--organization", "10"], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 10", result.output)
+        # Verify CLI argument (10) was used, not env var (8)
+        mock_cloud_instance.list_projects.assert_called_once_with("10")
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_projects_missing_organization(self, mock_prepare_token):
+        """Test list-projects command with missing organization ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without organization ID
+        result = self.runner.invoke(list_projects, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Organization ID is required", result.output)
+        self.assertIn("--organization", result.output)
+        self.assertIn("RECCE_ORGANIZATION_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with no projects."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_projects, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No projects found in organization 8", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_with_cli_args(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with CLI arguments."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [
+            {"id": "session1", "name": "PR-123", "is_base": False},
+            {"id": "session2", "name": "Base Session", "is_base": True},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with CLI arguments
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 7", result.output)
+        self.assertIn("PR-123", result.output)
+        self.assertIn("Base Session", result.output)
+        self.assertIn("✓", result.output)  # Base session marker
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "7")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_with_env_vars(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with environment variables."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [{"id": "session1", "name": "Session 1", "is_base": False}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with environment variables
+        result = self.runner.invoke(list_sessions, [], env={"RECCE_ORGANIZATION_ID": "8", "RECCE_PROJECT_ID": "7"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 7", result.output)
+        self.assertIn("Session 1", result.output)
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "7")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_mixed_env_and_cli(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with mixed environment variables and CLI args."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [{"id": "session1", "name": "Session 1", "is_base": False}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with env var for org and CLI arg for project
+        result = self.runner.invoke(list_sessions, ["--project", "9"], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 9", result.output)
+        # Verify it used env var for org (8) and CLI arg for project (9)
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "9")
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_sessions_missing_organization(self, mock_prepare_token):
+        """Test list-sessions command with missing organization ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without organization ID
+        result = self.runner.invoke(list_sessions, ["--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Organization ID is required", result.output)
+        self.assertIn("--organization", result.output)
+        self.assertIn("RECCE_ORGANIZATION_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_sessions_missing_project(self, mock_prepare_token):
+        """Test list-sessions command with missing project ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without project ID
+        result = self.runner.invoke(list_sessions, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Project ID is required", result.output)
+        self.assertIn("--project", result.output)
+        self.assertIn("RECCE_PROJECT_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with no sessions."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No sessions found in project 7", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_api_error(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with API error."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.side_effect = RecceCloudException("Access denied", "Forbidden", 403)
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Error", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_sessions_base_session_display(self, mock_recce_cloud, mock_prepare_token):
+        """Test that base sessions are properly marked with checkmark."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [
+            {"id": "session1", "name": "Regular Session", "is_base": False},
+            {"id": "session2", "name": "Base Session", "is_base": True},
+            {"id": "session3", "name": "Another Regular", "is_base": False},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        output_lines = result.output.split("\n")
+
+        # Find the base session line and verify it has the checkmark
+        base_session_line = None
+        for line in output_lines:
+            if "Base Session" in line:
+                base_session_line = line
+                break
+
+        self.assertIsNotNone(base_session_line)
+        self.assertIn("✓", base_session_line)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/recce-source/tests/test_config.py

@@ -0,0 +1,43 @@
+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)

package/recce-source/tests/test_connect_to_cloud.py

@@ -0,0 +1,82 @@
+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()

package/recce-source/tests/test_core.py

@@ -0,0 +1,174 @@
+# noinspection PyUnresolvedReferences
+import os
+import unittest
+from datetime import datetime
+
+from recce.core import RecceContext
+from recce.models import Check, Run, RunType
+from recce.state import ArtifactsRoot, FileStateLoader, RecceState
+from tests.adapter.dbt_adapter.conftest import dbt_test_helper  # noqa: F401
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+
+class TestRecceState(unittest.TestCase):
+    def test_load(self):
+        run = Run(type=RunType.QUERY, params=dict(sql_template="select * from users"))
+        check = Check(name="check 1", description="desc 1", type=run.type, params=run.params)
+
+        state = RecceState(runs=[run], checks=[check])
+        json_content = state.to_json()
+        new_state = RecceState.from_json(json_content)
+
+        run_loaded = new_state.runs[0]
+        check_loaded = new_state.checks[0]
+
+        assert run.run_id == run_loaded.run_id
+        assert check.check_id == check_loaded.check_id
+
+    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 = FileStateLoader(state_file=f.name)
+            state = state_loader.load()
+            assert len(state.runs) == 17
+
+
+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"

package/recce-source/tests/test_dbt.py

@@ -0,0 +1,36 @@
+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