@datarecce/ui 0.1.29 → 0.1.31

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

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

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

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