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

tests/tasks/test_top_k.py

@@ -1,73 +0,0 @@
-import pytest
-
-from recce.tasks import TopKDiffTask
-from recce.tasks.top_k import TopKDiffCheckValidator
-
-
-def test_top_k(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        4,Bob,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        4,,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-
-    params = dict(
-        model="customers",
-        column_name="name",
-        k=50,
-    )
-
-    task = TopKDiffTask(params)
-    run_result = task.execute()
-
-    # {
-    #     'values': ['Bob', 'Alice', 'Charlie'],
-    #     'counts': [2, 1, 1],
-    #     'valids': 4,
-    #     'total': 4
-    # }
-    assert run_result['current']['values'][0] == 'Bob'
-    assert run_result['current']['counts'][0] == 2
-    assert run_result['current']['valids'] == 4
-    assert run_result['current']['total'] == 4
-
-    # {
-    #     'values': ['Bob', 'Alice', 'Charlie'],
-    #     'counts': [1, 1, 1],
-    #     'valids': 3,
-    #     'total': 4
-    # }
-    assert run_result['base']['counts'][0] == 1
-    assert run_result['base']['valids'] == 3
-    assert run_result['base']['total'] == 4
-
-
-def test_validator():
-    def validate(params: dict = {}, view_options: dict = {}):
-        TopKDiffCheckValidator().validate({
-            'name': 'test',
-            'type': 'top_k_diff',
-            'params': params,
-            'view_options': view_options,
-        })
-
-    validate({
-        "model": "customers",
-        "column_name": "name",
-        "k": 50,
-    })
-
-    with pytest.raises(ValueError):
-        validate({})

tests/tasks/test_valuediff.py

@@ -1,74 +0,0 @@
-import pytest
-
-from recce.tasks import ValueDiffTask, ValueDiffDetailTask
-
-
-def test_value_diff(dbt_test_helper):
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,35
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers", csv_data_base, csv_data_curr)
-    params = dict(model='customers', primary_key=['customer_id'])
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    assert len(run_result.data.columns) == 3
-    assert len(run_result.data.data) == 3
-
-    params = dict(model='customers', primary_key=['customer_id'])
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    assert len(run_result.columns) == 5
-    assert len(run_result.data) == 2
-
-
-def test_validator():
-    from recce.tasks.valuediff import ValueDiffCheckValidator
-
-    def validate(params: dict = {}, view_options: dict = {}):
-        ValueDiffCheckValidator().validate({
-            'name': 'test',
-            'type': 'value_diff',
-            'params': params,
-            'view_options': view_options,
-        })
-
-    validate({
-        'model': 'customers',
-        'primary_key': 'customer_id',
-    })
-    validate({
-        'model': 'customers',
-        'primary_key': ['customer_id'],
-    })
-    validate({
-        'model': 'customers',
-        'primary_key': ['customer_id'],
-        'columns': ['name', 'age'],
-    })
-
-    with pytest.raises(ValueError):
-        validate({
-        })
-
-    with pytest.raises(ValueError):
-        validate({
-            'model': 'customers',
-        })
-
-    with pytest.raises(ValueError):
-        validate({
-            'model': 'customers',
-            'primary_key': ['customer_id'],
-            'columns': 'name',
-        })

tests/test_cli.py

@@ -1,122 +0,0 @@
-from unittest import TestCase
-from unittest.mock import patch, MagicMock
-
-from click.testing import CliRunner
-
-from recce.cli import server as cli_command_server, run as cli_command_run
-from recce.core import RecceContext
-from recce.state import RecceStateLoader
-
-
-def test_cmd_version():
-    from recce.cli import version
-    from recce import __version__
-    runner = CliRunner()
-    result = runner.invoke(version, [])
-    assert result.exit_code == 0
-    assert result.output.replace('\n', '') == __version__
-
-
-class TestCommandServer(TestCase):
-    def setUp(self):
-        self.runner = CliRunner()
-        pass
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.uvicorn.run')
-    def test_cmd_server(self, mock_run, mock_verify_required_artifacts):
-        from recce.server import app
-        mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server, ['--host', 'unittest', '--port', 5566])
-        mock_run.assert_called_once_with(app, host='unittest', port=5566, lifespan='on')
-
-    @patch('recce.cli.uvicorn.run')
-    def test_cmd_server_with_cloud_without_password(self, mock_run):
-        # Should fail if no password is provided
-        result = self.runner.invoke(cli_command_server, ['--cloud'])
-        assert result.exit_code == 1
-
-    @patch('recce.cli.uvicorn.run')
-    def test_cmd_server_with_cloud_without_token(self, mock_run):
-        # Should fail if no token is provided
-        result = self.runner.invoke(cli_command_server, ['--cloud', '--password', 'unittest'])
-        assert result.exit_code == 1
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.util.recce_cloud.get_recce_cloud_onboarding_state')
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.cli.RecceStateLoader')
-    def test_cmd_server_with_cloud(self, mock_state_loader_class, mock_run, mock_get_recce_cloud_onboarding_state,
-                                   mock_verify_required_artifacts):
-        mock_state_loader = MagicMock(spec=RecceStateLoader)
-        mock_state_loader.verify.return_value = True
-        mock_state_loader.review_mode = True
-        mock_get_recce_cloud_onboarding_state.return_value = 'completed'
-        mock_verify_required_artifacts.return_value = True, None
-
-        mock_state_loader_class.return_value = mock_state_loader
-        self.runner.invoke(cli_command_server, ['--cloud', '--password', 'unittest', '--cloud-token', 'unittest'])
-        mock_state_loader_class.assert_called_once()
-        mock_run.assert_called_once()
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('os.path.isdir', side_effect=lambda path: True if path == 'existed_folder' else False)
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.server.AppState')
-    def test_cmd_server_with_single_env(self,
-                                        mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts):
-        mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
-        mock_run.assert_called_once()
-
-        # Onboarding mode should be set to True
-        app_state_call_args = mock_app_state.call_args
-        app_state_flag = app_state_call_args.kwargs['flag']
-        assert 'single_env_onboarding' in app_state_flag
-        assert app_state_flag['single_env_onboarding'] is True
-        assert 'show_relaunch_hint' in app_state_flag
-        assert app_state_flag['show_relaunch_hint'] is True
-
-        # The target_base_path should be set to the same as target_path
-        verify_required_artifacts_args = mock_verify_required_artifacts.call_args
-        assert verify_required_artifacts_args.kwargs['target_path'] == verify_required_artifacts_args.kwargs[
-            'target_base_path']
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('os.path.isdir', side_effect=lambda path: True if path == 'existed_folder' else False)
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.server.AppState')
-    def test_cmd_server_with_single_env_but_review_mode_enabled(self,
-                                                                mock_app_state, mock_run, mock_isdir,
-                                                                mock_verify_required_artifacts):
-        mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               'existed_state_file',
-                               '--review',
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
-        mock_run.assert_called_once()
-        app_state_call_args = mock_app_state.call_args
-        app_state_flag = app_state_call_args.kwargs['flag']
-        assert 'single_env_onboarding' in app_state_flag
-        assert app_state_flag['single_env_onboarding'] is False
-
-
-class TestCommandRun(TestCase):
-    def setUp(self):
-        self.runner = CliRunner()
-        pass
-
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.cli_run')
-    def test_cmd_run(self, mock_cli_run, mock_verify_required_artifacts):
-        mock_verify_required_artifacts.return_value = True, None
-
-        self.runner.invoke(cli_command_run, [])
-        mock_cli_run.assert_called_once()

tests/test_config.py

@@ -1,45 +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_core.py

@@ -1,27 +0,0 @@
-# noinspection PyUnresolvedReferences
-from tests.adapter.dbt_adapter.conftest import dbt_test_helper
-
-
-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 patch, MagicMock
-
-from recce.adapter.dbt_adapter import load_manifest, load_catalog, DbtAdapter
-
-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_metadata_from_event_path, _fetch_pr_title
-
-
-@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,98 +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
-
-
-@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')