@datarecce/ui 0.1.40 → 0.2.0

package/recce-source/tests/test_cloud_listing_cli.py

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

@@ -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)

package/recce-source/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()

package/recce-source/tests/test_core.py

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

@@ -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