@datarecce/ui 0.1.40 → 0.2.0

package/recce-source/tests/tasks/test_valuediff.py

@@ -1,361 +0,0 @@
-import pytest
-
-from recce.tasks import ValueDiffDetailTask, ValueDiffTask
-
-# =============================================================================
-# ValueDiffTask Tests (_query_value_diff for summary statistics)
-# =============================================================================
-
-
-def test_value_diff(dbt_test_helper):
-    """Basic test: one row has a value change (age: 35 -> 30)"""
-    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 = {"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 = {"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_value_diff_identical_data(dbt_test_helper):
-    """When base and current are identical, diff should be empty."""
-    csv_data = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("identical_customers", csv_data, csv_data)
-
-    # ValueDiffTask should show 100% match
-    params = {"model": "identical_customers", "primary_key": ["customer_id"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    assert run_result.summary.added == 0
-    assert run_result.summary.removed == 0
-    # All rows should be matched
-    for row in run_result.data.data:
-        column_name, matched, matched_p = row
-        assert matched_p == 1.0  # 100% match
-
-    # ValueDiffDetailTask should return empty diff (no changed rows)
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    assert len(run_result.data) == 0
-
-
-def test_value_diff_added_rows(dbt_test_helper):
-    """Test detection of rows added in current (not in base).
-
-    ValueDiffTask summary counts rows with matching PKs in both tables.
-    Added/removed rows show up in the per-column statistics and ValueDiffDetailTask.
-    """
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        """
-
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers_added", csv_data_base, csv_data_curr)
-
-    params = {"model": "customers_added", "primary_key": ["customer_id"]}
-
-    # ValueDiffDetailTask should show the added row
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    assert len(run_result.data) == 1
-    # Check in_a/in_b flags - added row should have in_a=False, in_b=True
-    row = run_result.data[0]
-    in_a_idx = next(i for i, c in enumerate(run_result.columns) if c.key.lower() == "in_a")
-    in_b_idx = next(i for i, c in enumerate(run_result.columns) if c.key.lower() == "in_b")
-    assert row[in_a_idx] is False
-    assert row[in_b_idx] is True
-
-
-def test_value_diff_removed_rows(dbt_test_helper):
-    """Test detection of rows removed in current (present in base only).
-
-    ValueDiffTask summary counts rows with matching PKs in both tables.
-    Added/removed rows show up in ValueDiffDetailTask.
-    """
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        """
-
-    dbt_test_helper.create_model("customers_removed", csv_data_base, csv_data_curr)
-
-    params = {"model": "customers_removed", "primary_key": ["customer_id"]}
-
-    # ValueDiffDetailTask should show the removed row
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    assert len(run_result.data) == 1
-    # Check in_a/in_b flags - removed row should have in_a=True, in_b=False
-    row = run_result.data[0]
-    in_a_idx = next(i for i, c in enumerate(run_result.columns) if c.key.lower() == "in_a")
-    in_b_idx = next(i for i, c in enumerate(run_result.columns) if c.key.lower() == "in_b")
-    assert row[in_a_idx] is True
-    assert row[in_b_idx] is False
-
-
-def test_value_diff_modified_rows(dbt_test_helper):
-    """Test detection of rows with value changes."""
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,31
-        2,Bobby,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers_modified", csv_data_base, csv_data_curr)
-
-    params = {"model": "customers_modified", "primary_key": ["customer_id"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    assert run_result.summary.added == 0
-    assert run_result.summary.removed == 0
-    # Should have some mismatched columns (age for id=1, name for id=2)
-
-    # Detail should show 4 rows (2 pairs for modified rows: old + new values)
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    # Each modified row appears twice (once in_a=True,in_b=False and once in_a=False,in_b=True)
-    assert len(run_result.data) == 4
-
-
-def test_value_diff_composite_primary_key(dbt_test_helper):
-    """Test with composite (multi-column) primary key."""
-    csv_data_base = """
-        region,customer_id,name,revenue
-        US,1,Alice,100
-        US,2,Bob,200
-        EU,1,Charlie,150
-        """
-
-    csv_data_curr = """
-        region,customer_id,name,revenue
-        US,1,Alice,100
-        US,2,Bob,250
-        EU,1,Charlie,150
-        """
-
-    dbt_test_helper.create_model("customers_composite", csv_data_base, csv_data_curr)
-
-    # Use composite primary key
-    params = {"model": "customers_composite", "primary_key": ["region", "customer_id"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    assert run_result.summary.added == 0
-    assert run_result.summary.removed == 0
-
-    # Check primary_key was preserved as list
-    assert isinstance(task.params.primary_key, list)
-    assert len(task.params.primary_key) == 2
-
-    # Detail task
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    # One row modified (US,2 has revenue change)
-    assert len(run_result.data) == 2  # pair of rows for the modified record
-
-
-def test_value_diff_single_primary_key_string(dbt_test_helper):
-    """Test with single primary key passed as string (not list)."""
-    csv_data_base = """
-        id,value
-        1,100
-        2,200
-        """
-
-    csv_data_curr = """
-        id,value
-        1,100
-        2,250
-        """
-
-    dbt_test_helper.create_model("single_pk", csv_data_base, csv_data_curr)
-
-    # Pass primary_key as string, not list
-    params = {"model": "single_pk", "primary_key": "id"}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    assert run_result.summary.added == 0
-    assert run_result.summary.removed == 0
-
-    # Primary key should be normalized to string (not list) when passed as string
-    assert isinstance(task.params.primary_key, str)
-
-
-def test_value_diff_selected_columns(dbt_test_helper):
-    """Test diffing only specific columns."""
-    csv_data_base = """
-        customer_id,name,age,city
-        1,Alice,30,NYC
-        2,Bob,25,LA
-        """
-
-    csv_data_curr = """
-        customer_id,name,age,city
-        1,Alice,31,NYC
-        2,Bob,25,SF
-        """
-
-    dbt_test_helper.create_model("customers_cols", csv_data_base, csv_data_curr)
-
-    # Only compare 'name' column (should show 100% match)
-    params = {"model": "customers_cols", "primary_key": ["customer_id"], "columns": ["name"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    # Only customer_id and name columns in result
-    assert len(run_result.data.data) == 2  # customer_id + name
-
-    # Compare 'age' column (should show mismatch for id=1)
-    params = {"model": "customers_cols", "primary_key": ["customer_id"], "columns": ["age"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    # Find the age row and check it's not 100% matched
-    age_row = next((r for r in run_result.data.data if r[0] == "age"), None)
-    assert age_row is not None
-    assert age_row[2] < 1.0  # matched_p < 100%
-
-
-def test_value_diff_with_nulls(dbt_test_helper):
-    """Test handling of NULL values."""
-    csv_data_base = """
-        customer_id,name,age
-        1,Alice,30
-        2,,25
-        3,Charlie,
-        """
-
-    csv_data_curr = """
-        customer_id,name,age
-        1,Alice,30
-        2,Bob,25
-        3,Charlie,35
-        """
-
-    dbt_test_helper.create_model("customers_nulls", csv_data_base, csv_data_curr)
-
-    params = {"model": "customers_nulls", "primary_key": ["customer_id"]}
-    task = ValueDiffTask(params)
-    run_result = task.execute()
-    # Row count should be correct
-    assert run_result.summary.total == 3
-
-    # Detail should show changed rows
-    task = ValueDiffDetailTask(params)
-    run_result = task.execute()
-    # Rows 2 and 3 have changes (null to value)
-    assert len(run_result.data) >= 2
-
-
-# Note: Empty table tests (test_value_diff_empty_base, test_value_diff_empty_current)
-# are skipped because DuckDB cannot infer column types from empty CSVs (headers only),
-# causing type conversion errors during SQL execution.
-
-
-# =============================================================================
-# Validator Tests
-# =============================================================================
-
-
-def test_validator():
-    from recce.tasks.valuediff import ValueDiffCheckValidator
-
-    def validate(params=None, view_options=None):
-        if view_options is None:
-            view_options = {}
-        if params is None:
-            params = {}
-        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",
-            }
-        )

package/recce-source/tests/test_cli.py

@@ -1,236 +0,0 @@
-from unittest import TestCase
-from unittest.mock import MagicMock, patch
-
-from click.testing import CliRunner
-
-from recce.cli import run as cli_command_run
-from recce.cli import server as cli_command_server
-from recce.cli import snapshot as cli_command_snapshot
-from recce.cli import upload_session as cli_command_upload_session
-from recce.core import RecceContext
-from recce.state import CloudStateLoader
-
-
-def test_cmd_version():
-    from recce import __version__
-    from recce.cli 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, "--single-env"])
-        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.CloudStateLoader")
-    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=CloudStateLoader)
-        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", "--single-env"]
-        )
-        mock_state_loader_class.assert_called_once()
-        mock_run.assert_called_once()
-
-    @patch.object(RecceContext, "verify_required_artifacts")
-    @patch("recce.util.recce_cloud.get_recce_cloud_onboarding_state")
-    @patch("recce.cli.uvicorn.run")
-    @patch("recce.cli.CloudStateLoader")
-    @patch("recce.cli.prepare_api_token", return_value="test_api_token")
-    def test_cmd_server_with_session_id(
-        self,
-        mock_prepare_api_token,
-        mock_state_loader_class,
-        mock_run,
-        mock_get_recce_cloud_onboarding_state,
-        mock_verify_required_artifacts,
-    ):
-        """Test that --session-id automatically enables cloud and review mode"""
-        mock_state_loader = MagicMock(spec=CloudStateLoader)
-        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
-
-        # Test with --session-id (should automatically enable cloud and review)
-        result = self.runner.invoke(cli_command_server, ["--session-id", "test-session-123", "--single-env"])
-
-        # Should succeed
-        assert result.exit_code == 0
-
-        # Should create CloudStateLoader with session_id in cloud_options
-        mock_state_loader_class.assert_called_once()
-        call_args = mock_state_loader_class.call_args
-        assert call_args.kwargs["review_mode"] is True
-        assert "session_id" in call_args.kwargs["cloud_options"]
-        assert call_args.kwargs["cloud_options"]["session_id"] == "test-session-123"
-
-        mock_run.assert_called_once()
-
-    @patch.object(RecceContext, "verify_required_artifacts")
-    @patch("recce.util.recce_cloud.get_recce_cloud_onboarding_state")
-    @patch("recce.cli.uvicorn.run")
-    @patch("recce.cli.CloudStateLoader")
-    @patch("recce.cli.prepare_api_token", return_value="test_api_token")
-    def test_cmd_server_with_share_url(
-        self,
-        mock_prepare_api_token,
-        mock_state_loader_class,
-        mock_run,
-        mock_get_recce_cloud_onboarding_state,
-        mock_verify_required_artifacts,
-    ):
-        """Test that --share-url automatically enables cloud and review mode"""
-        mock_state_loader = MagicMock(spec=CloudStateLoader)
-        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
-
-        # Test with --share-url (should automatically enable cloud and review)
-        result = self.runner.invoke(
-            cli_command_server, ["--share-url", "https://cloud.recce.io/share/abc123", "--single-env"]
-        )
-
-        # Should succeed
-        assert result.exit_code == 0
-
-        # Should create CloudStateLoader with share_id in cloud_options
-        mock_state_loader_class.assert_called_once()
-        call_args = mock_state_loader_class.call_args
-        assert call_args.kwargs["review_mode"] is True
-        assert "share_id" in call_args.kwargs["cloud_options"]
-        assert call_args.kwargs["cloud_options"]["share_id"] == "abc123"
-
-        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,
-            ["--single-env", "--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",
-                "--single-env",
-                "--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()
-
-
-class TestCommandUploadSession(TestCase):
-    def setUp(self):
-        self.runner = CliRunner()
-        pass
-
-    @patch("recce.cli.prepare_api_token", return_value="unittest_token")
-    @patch("recce.cli.upload_artifacts_to_session", return_value=0)
-    def test_cmd_upload_session(self, mock_upload_artifacts_to_session, mock_prepare_api_token):
-        self.runner.invoke(
-            cli_command_upload_session,
-            ["--session-id", "unittest_session", "--api-token", mock_prepare_api_token.return_value],
-        )
-        mock_upload_artifacts_to_session.assert_called_once_with(
-            "target", session_id="unittest_session", token="unittest_token", debug=False
-        )
-
-        self.runner.invoke(
-            cli_command_snapshot,
-            ["--snapshot-id", "unittest_session", "--api-token", mock_prepare_api_token.return_value],
-        )
-        mock_upload_artifacts_to_session.assert_called_once_with(
-            "target", session_id="unittest_session", token="unittest_token", debug=False
-        )

package/recce-source/tests/test_cli_mcp_optional.py

@@ -1,45 +0,0 @@
-"""
-Test that CLI can be imported even when mcp is not available.
-"""
-
-import sys
-from unittest.mock import patch
-
-
-def test_cli_can_be_imported_without_mcp():
-    """Test that recce.cli can be imported even if mcp package is not available"""
-    # This test verifies that the CLI module doesn't fail to import
-    # when mcp is not installed, since mcp is an optional dependency
-    from recce import cli
-
-    assert cli is not None
-    assert hasattr(cli, "cli")
-    assert hasattr(cli, "mcp_server")
-
-
-def test_mcp_server_command_fails_gracefully_without_mcp():
-    """Test that mcp-server command shows helpful error when mcp is not available"""
-    # Mock sys.modules to simulate mcp not being installed
-    with patch.dict(sys.modules, {"mcp": None, "mcp.server": None, "mcp.server.stdio": None, "mcp.types": None}):
-        # Remove mcp_server from modules to force reimport
-        if "recce.mcp_server" in sys.modules:
-            del sys.modules["recce.mcp_server"]
-
-        from recce.cli import mcp_server
-
-        # The function should exist
-        assert mcp_server is not None
-
-        # When called, it should handle ImportError gracefully
-        # (We can't easily test the actual execution without more mocking,
-        # but we've verified the function exists and can be imported)
-
-
-def test_cli_command_exists():
-    """Test that both server and mcp-server commands are registered"""
-    from recce.cli import cli
-
-    # Check that both commands exist
-    commands = {cmd.name for cmd in cli.commands.values()}
-    assert "server" in commands
-    assert "mcp_server" in commands or "mcp-server" in commands