@datarecce/ui 0.1.40 → 0.2.0

package/recce-source/tests/models/test_run_models.py

@@ -1,295 +0,0 @@
-from recce.models.types import Run, RunStatus, RunType
-from recce.state import RecceState
-
-
-class TestRecceStateWithRuns:
-    """Test RecceState integration with Run objects and Run.__init__ result validation"""
-
-    def test_recce_state_with_query_result_validation(self):
-        """Test RecceState correctly deserializes query results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "query",
-                    "name": "customer_query",
-                    "params": {"sql": "SELECT * FROM customers"},
-                    "status": "finished",
-                    "result": {
-                        "columns": [{"name": "customer_id", "type": "integer"}, {"name": "name", "type": "text"}],
-                        "data": [[1, "Alice"], [2, "Bob"]],
-                        "limit": None,
-                        "more": False,
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        # Verify Run was created correctly
-        assert isinstance(run, Run)
-        assert run.type == RunType.QUERY
-        assert run.status == RunStatus.FINISHED
-
-        # Verify Run.__init__ validated and preserved result structure
-        assert run.result is not None
-        assert "columns" in run.result
-        assert "data" in run.result
-
-        # Verify DataFrameColumn auto-set key=name (from DataFrameColumn.__init__)
-        assert run.result["columns"][0]["key"] == "customer_id"
-        assert run.result["columns"][0]["name"] == "customer_id"
-
-    def test_recce_state_with_profile_result_validation(self):
-        """Test RecceState correctly deserializes profile results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "profile",
-                    "name": "customers_profile",
-                    "params": {"model": "customers"},
-                    "status": "finished",
-                    "result": {
-                        "current": {
-                            "columns": [
-                                {"name": "column_name", "type": "text"},
-                                {"name": "row_count", "type": "integer"},
-                            ],
-                            "data": [["customer_id", 100], ["name", 100]],
-                        }
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        assert run.type == RunType.PROFILE
-        assert run.result is not None
-        assert "current" in run.result
-
-        # Verify DataFrameColumn auto-set key=name in nested structure
-        assert run.result["current"]["columns"][0]["key"] == "column_name"
-
-    def test_recce_state_with_query_diff_result_validation(self):
-        """Test RecceState correctly deserializes query_diff results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "query_diff",
-                    "name": "users_diff",
-                    "status": "finished",
-                    "result": {
-                        "base": {"columns": [{"name": "id", "type": "integer"}], "data": [[1], [2]]},
-                        "current": {"columns": [{"name": "id", "type": "integer"}], "data": [[1], [2], [3]]},
-                        "diff": None,
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        assert run.type == RunType.QUERY_DIFF
-        assert run.result is not None
-        assert "base" in run.result
-        assert "current" in run.result
-        # Verify both base and current DataFrames have auto-set keys
-        assert run.result["base"]["columns"][0]["key"] == "id"
-        assert run.result["current"]["columns"][0]["key"] == "id"
-
-    def test_recce_state_with_value_diff_result_validation(self):
-        """Test RecceState correctly deserializes value_diff results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "value_diff",
-                    "name": "products_diff",
-                    "status": "finished",
-                    "result": {
-                        "summary": {"total": 100, "added": 5, "removed": 2},
-                        "data": {"columns": [{"name": "product_id", "type": "integer"}], "data": [[1], [2]]},
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        assert run.type == RunType.VALUE_DIFF
-        assert run.result is not None
-        assert "summary" in run.result
-        assert run.result["summary"]["total"] == 100
-        # Verify nested DataFrame has auto-set key
-        assert run.result["data"]["columns"][0]["key"] == "product_id"
-
-    def test_recce_state_with_value_diff_detail_result_validation(self):
-        """Test RecceState correctly deserializes value_diff_detail results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "value_diff_detail",
-                    "name": "detailed_diff",
-                    "status": "finished",
-                    "result": {
-                        "columns": [{"name": "id", "type": "integer"}, {"name": "__diff_status__", "type": "text"}],
-                        "data": [[1, "modified"], [2, "added"]],
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        assert run.type == RunType.VALUE_DIFF_DETAIL
-        assert run.result is not None
-        assert "columns" in run.result
-        assert run.result["columns"][0]["key"] == "id"
-
-    def test_recce_state_with_profile_diff_result_validation(self):
-        """Test RecceState correctly deserializes profile_diff results through Run.__init__"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "profile_diff",
-                    "name": "profile_comparison",
-                    "status": "finished",
-                    "result": {
-                        "base": {"columns": [{"name": "stat", "type": "text"}], "data": [["count", 100]]},
-                        "current": {"columns": [{"name": "stat", "type": "text"}], "data": [["count", 105]]},
-                    },
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        assert run.type == RunType.PROFILE_DIFF
-        assert run.result is not None
-        assert "base" in run.result
-        assert "current" in run.result
-
-    def test_recce_state_with_unvalidated_run_types(self):
-        """Test RecceState with run types that don't go through Run.__init__ validation"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "row_count_diff",
-                    "name": "customers_row_count",
-                    "status": "finished",
-                    "result": {"customers": {"base": 95, "curr": 100}},
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-        run = state.runs[0]
-
-        # row_count_diff doesn't go through Run.__init__ validation
-        # so result stays as-is (dict without DataFrame structure)
-        assert run.type == RunType.ROW_COUNT_DIFF
-        assert run.result is not None
-        assert run.result["customers"]["base"] == 95
-
-    def test_recce_state_roundtrip_with_results(self):
-        """Test RecceState serialization roundtrip preserves validated results"""
-        original_state = RecceState(
-            runs=[
-                Run(
-                    type=RunType.QUERY,
-                    status=RunStatus.FINISHED,
-                    result={"columns": [{"name": "id", "type": "integer"}], "data": [[1], [2]]},
-                )
-            ]
-        )
-
-        # Serialize and deserialize
-        json_str = original_state.to_json()
-        restored_state = RecceState.from_json(json_str)
-
-        # Verify result structure is preserved
-        assert len(restored_state.runs) == 1
-        run = restored_state.runs[0]
-        assert run.result is not None
-        assert run.result["columns"][0]["key"] == "id"
-
-    def test_recce_state_with_runs_without_results(self):
-        """Test RecceState works with runs that have no results"""
-        state_dict = {
-            "runs": [
-                {"type": "query", "name": "pending_query", "status": "running"},
-                {"type": "profile", "name": "pending_profile", "status": "running"},
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-
-        assert len(state.runs) == 2
-        assert state.runs[0].result is None
-        assert state.runs[1].result is None
-
-    def test_recce_state_with_null_results(self):
-        """Test RecceState handles runs with explicitly null results"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "query",
-                    "name": "failed_query",
-                    "status": "failed",
-                    "result": None,
-                    "error": "Query execution failed",
-                }
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-
-        assert len(state.runs) == 1
-        assert state.runs[0].result is None
-        assert state.runs[0].error == "Query execution failed"
-
-    def test_recce_state_with_mixed_result_states(self):
-        """Test RecceState with runs in various states (finished, running, failed, cancelled)"""
-        state_dict = {
-            "runs": [
-                {
-                    "type": "query",
-                    "name": "completed_query",
-                    "status": "finished",
-                    "result": {"columns": [{"name": "id", "type": "integer"}], "data": [[1]]},
-                },
-                {"type": "profile", "name": "running_profile", "status": "running"},
-                {
-                    "type": "value_diff",
-                    "name": "failed_diff",
-                    "status": "failed",
-                    "result": None,
-                    "error": "Connection timeout",
-                },
-                {"type": "query_diff", "name": "cancelled_diff", "status": "cancelled"},
-            ],
-            "checks": [],
-        }
-
-        state = RecceState(**state_dict)
-
-        assert len(state.runs) == 4
-        assert state.runs[0].result is not None  # Finished with result
-        assert state.runs[1].result is None  # Running, no result yet
-        assert state.runs[2].result is None  # Failed, null result
-        assert state.runs[3].result is None  # Cancelled, no result

package/recce-source/tests/recce_cloud/test_ci_providers.py

@@ -1,351 +0,0 @@
-"""
-Tests for CI provider detection and information extraction.
-"""
-
-import json
-import os
-from unittest.mock import mock_open, patch
-
-from recce_cloud.ci_providers import CIDetector, GitHubActionsProvider, GitLabCIProvider
-from recce_cloud.ci_providers.base import CIInfo
-
-
-class TestGitHubActionsProvider:
-    """Tests for GitHub Actions provider."""
-
-    def test_can_handle_true(self):
-        """Test detection when GITHUB_ACTIONS is true."""
-        with patch.dict(os.environ, {"GITHUB_ACTIONS": "true"}):
-            provider = GitHubActionsProvider()
-            assert provider.can_handle() is True
-
-    def test_can_handle_false(self):
-        """Test detection when GITHUB_ACTIONS is not set."""
-        with patch.dict(os.environ, {}, clear=True):
-            provider = GitHubActionsProvider()
-            assert provider.can_handle() is False
-
-    def test_extract_pr_number_from_event(self):
-        """Test PR number extraction from event JSON."""
-        event_data = {"pull_request": {"number": 123}}
-        mock_file = mock_open(read_data=json.dumps(event_data))
-
-        with patch.dict(os.environ, {"GITHUB_EVENT_PATH": "/tmp/event.json"}):
-            with patch("builtins.open", mock_file):
-                with patch("os.path.exists", return_value=True):
-                    provider = GitHubActionsProvider()
-                    pr_number = provider._extract_pr_number()
-                    assert pr_number == 123
-
-    def test_extract_pr_number_no_event(self):
-        """Test PR number extraction when event path doesn't exist."""
-        with patch.dict(os.environ, {}, clear=True):
-            provider = GitHubActionsProvider()
-            pr_number = provider._extract_pr_number()
-            assert pr_number is None
-
-    def test_extract_commit_sha(self):
-        """Test commit SHA extraction."""
-        with patch.dict(os.environ, {"GITHUB_SHA": "abc123def456"}):
-            provider = GitHubActionsProvider()
-            commit_sha = provider._extract_commit_sha()
-            assert commit_sha == "abc123def456"
-
-    def test_extract_commit_sha_fallback(self):
-        """Test commit SHA extraction with git fallback."""
-        with patch.dict(os.environ, {}, clear=True):
-            with patch.object(GitHubActionsProvider, "run_git_command", return_value="git123456"):
-                provider = GitHubActionsProvider()
-                commit_sha = provider._extract_commit_sha()
-                assert commit_sha == "git123456"
-
-    def test_extract_base_branch(self):
-        """Test base branch extraction."""
-        with patch.dict(os.environ, {"GITHUB_BASE_REF": "main"}):
-            provider = GitHubActionsProvider()
-            base_branch = provider._extract_base_branch()
-            assert base_branch == "main"
-
-    def test_extract_base_branch_default(self):
-        """Test base branch extraction defaults to main."""
-        with patch.dict(os.environ, {}, clear=True):
-            provider = GitHubActionsProvider()
-            base_branch = provider._extract_base_branch()
-            assert base_branch == "main"
-
-    def test_extract_source_branch(self):
-        """Test source branch extraction."""
-        with patch.dict(os.environ, {"GITHUB_HEAD_REF": "feature-branch"}):
-            provider = GitHubActionsProvider()
-            source_branch = provider._extract_source_branch()
-            assert source_branch == "feature-branch"
-
-    def test_extract_source_branch_fallback(self):
-        """Test source branch extraction with fallback."""
-        with patch.dict(os.environ, {"GITHUB_REF_NAME": "develop"}, clear=True):
-            provider = GitHubActionsProvider()
-            source_branch = provider._extract_source_branch()
-            assert source_branch == "develop"
-
-    def test_extract_ci_info_pr_context(self):
-        """Test full CI info extraction in PR context."""
-        event_data = {"pull_request": {"number": 456}}
-        mock_file = mock_open(read_data=json.dumps(event_data))
-
-        with patch.dict(
-            os.environ,
-            {
-                "GITHUB_ACTIONS": "true",
-                "GITHUB_EVENT_PATH": "/tmp/event.json",
-                "GITHUB_SHA": "abc123",
-                "GITHUB_BASE_REF": "main",
-                "GITHUB_HEAD_REF": "feature",
-                "GITHUB_REPOSITORY": "owner/repo",
-            },
-        ):
-            with patch("builtins.open", mock_file):
-                with patch("os.path.exists", return_value=True):
-                    provider = GitHubActionsProvider()
-                    ci_info = provider.extract_ci_info()
-
-                    assert ci_info.platform == "github-actions"
-                    assert ci_info.cr_number == 456
-                    assert ci_info.cr_url == "https://github.com/owner/repo/pull/456"
-                    assert ci_info.session_type == "cr"
-                    assert ci_info.commit_sha == "abc123"
-                    assert ci_info.base_branch == "main"
-                    assert ci_info.source_branch == "feature"
-                    assert ci_info.repository == "owner/repo"
-
-    def test_extract_ci_info_main_branch(self):
-        """Test CI info extraction for main branch."""
-        with patch.dict(
-            os.environ,
-            {
-                "GITHUB_ACTIONS": "true",
-                "GITHUB_SHA": "main123",
-                "GITHUB_REF_NAME": "main",
-                "GITHUB_REPOSITORY": "owner/repo",
-            },
-            clear=True,
-        ):
-            provider = GitHubActionsProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.platform == "github-actions"
-            assert ci_info.cr_number is None
-            assert ci_info.session_type == "prod"
-            assert ci_info.source_branch == "main"
-
-    def test_extract_access_token(self):
-        """Test GITHUB_TOKEN detection."""
-        with patch.dict(
-            os.environ,
-            {
-                "GITHUB_ACTIONS": "true",
-                "GITHUB_TOKEN": "ghp_test123token456",
-                "GITHUB_SHA": "abc123",
-            },
-            clear=True,
-        ):
-            provider = GitHubActionsProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.access_token == "ghp_test123token456"
-
-    def test_extract_access_token_not_set(self):
-        """Test when GITHUB_TOKEN is not set."""
-        with patch.dict(os.environ, {"GITHUB_ACTIONS": "true", "GITHUB_SHA": "abc123"}, clear=True):
-            provider = GitHubActionsProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.access_token is None
-
-
-class TestGitLabCIProvider:
-    """Tests for GitLab CI provider."""
-
-    def test_can_handle_true(self):
-        """Test detection when GITLAB_CI is true."""
-        with patch.dict(os.environ, {"GITLAB_CI": "true"}):
-            provider = GitLabCIProvider()
-            assert provider.can_handle() is True
-
-    def test_can_handle_false(self):
-        """Test detection when GITLAB_CI is not set."""
-        with patch.dict(os.environ, {}, clear=True):
-            provider = GitLabCIProvider()
-            assert provider.can_handle() is False
-
-    def test_extract_mr_number(self):
-        """Test MR number extraction."""
-        with patch.dict(os.environ, {"CI_MERGE_REQUEST_IID": "789"}):
-            provider = GitLabCIProvider()
-            mr_number = provider._extract_mr_number()
-            assert mr_number == 789
-
-    def test_extract_mr_number_none(self):
-        """Test MR number extraction when not set."""
-        with patch.dict(os.environ, {}, clear=True):
-            provider = GitLabCIProvider()
-            mr_number = provider._extract_mr_number()
-            assert mr_number is None
-
-    def test_extract_commit_sha(self):
-        """Test commit SHA extraction."""
-        with patch.dict(os.environ, {"CI_COMMIT_SHA": "gitlab123"}):
-            provider = GitLabCIProvider()
-            commit_sha = provider._extract_commit_sha()
-            assert commit_sha == "gitlab123"
-
-    def test_extract_base_branch(self):
-        """Test base branch extraction."""
-        with patch.dict(os.environ, {"CI_MERGE_REQUEST_TARGET_BRANCH_NAME": "master"}):
-            provider = GitLabCIProvider()
-            base_branch = provider._extract_base_branch()
-            assert base_branch == "master"
-
-    def test_extract_source_branch(self):
-        """Test source branch extraction."""
-        with patch.dict(os.environ, {"CI_MERGE_REQUEST_SOURCE_BRANCH_NAME": "feature"}):
-            provider = GitLabCIProvider()
-            source_branch = provider._extract_source_branch()
-            assert source_branch == "feature"
-
-    def test_extract_ci_info_mr_context(self):
-        """Test full CI info extraction in MR context."""
-        with patch.dict(
-            os.environ,
-            {
-                "GITLAB_CI": "true",
-                "CI_MERGE_REQUEST_IID": "101",
-                "CI_COMMIT_SHA": "gitlab456",
-                "CI_MERGE_REQUEST_TARGET_BRANCH_NAME": "main",
-                "CI_MERGE_REQUEST_SOURCE_BRANCH_NAME": "feature-x",
-                "CI_PROJECT_PATH": "group/project",
-                "CI_SERVER_URL": "https://gitlab.com",
-            },
-        ):
-            provider = GitLabCIProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.platform == "gitlab-ci"
-            assert ci_info.cr_number == 101
-            assert ci_info.cr_url == "https://gitlab.com/group/project/-/merge_requests/101"
-            assert ci_info.session_type == "cr"
-            assert ci_info.commit_sha == "gitlab456"
-            assert ci_info.base_branch == "main"
-            assert ci_info.source_branch == "feature-x"
-            assert ci_info.repository == "group/project"
-
-    def test_extract_ci_info_mr_context_self_hosted(self):
-        """Test MR URL construction for self-hosted GitLab."""
-        with patch.dict(
-            os.environ,
-            {
-                "GITLAB_CI": "true",
-                "CI_MERGE_REQUEST_IID": "42",
-                "CI_PROJECT_PATH": "mycompany/myproject",
-                "CI_SERVER_URL": "https://gitlab.mycompany.com",
-            },
-            clear=True,
-        ):
-            provider = GitLabCIProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.cr_url == "https://gitlab.mycompany.com/mycompany/myproject/-/merge_requests/42"
-
-    def test_extract_access_token(self):
-        """Test CI_JOB_TOKEN detection."""
-        with patch.dict(
-            os.environ,
-            {"GITLAB_CI": "true", "CI_JOB_TOKEN": "glpat-test123token456", "CI_COMMIT_SHA": "gitlab123"},
-            clear=True,
-        ):
-            provider = GitLabCIProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.access_token == "glpat-test123token456"
-
-    def test_extract_access_token_not_set(self):
-        """Test when CI_JOB_TOKEN is not set."""
-        with patch.dict(os.environ, {"GITLAB_CI": "true", "CI_COMMIT_SHA": "gitlab123"}, clear=True):
-            provider = GitLabCIProvider()
-            ci_info = provider.extract_ci_info()
-
-            assert ci_info.access_token is None
-
-
-class TestCIDetector:
-    """Tests for CI detector."""
-
-    def test_detect_github_actions(self):
-        """Test detection of GitHub Actions."""
-        with patch.dict(os.environ, {"GITHUB_ACTIONS": "true", "GITHUB_SHA": "test123"}, clear=True):
-            ci_info = CIDetector.detect()
-            assert ci_info.platform == "github-actions"
-
-    def test_detect_gitlab_ci(self):
-        """Test detection of GitLab CI."""
-        with patch.dict(os.environ, {"GITLAB_CI": "true", "CI_COMMIT_SHA": "test456"}, clear=True):
-            ci_info = CIDetector.detect()
-            assert ci_info.platform == "gitlab-ci"
-
-    def test_detect_fallback(self):
-        """Test fallback detection when no CI platform detected."""
-        with patch.dict(os.environ, {}, clear=True):
-            with patch.object(CIDetector, "_fallback_detection") as mock_fallback:
-                mock_fallback.return_value = CIInfo(
-                    platform=None, session_type="dev", commit_sha="fallback123", base_branch="main"
-                )
-                ci_info = CIDetector.detect()
-                assert ci_info.platform is None
-                assert ci_info.session_type == "dev"
-                mock_fallback.assert_called_once()
-
-    def test_apply_overrides_cr_github(self):
-        """Test applying CR override for GitHub Actions."""
-        ci_info = CIInfo(platform="github-actions", cr_number=100, session_type="cr", repository="owner/repo")
-        ci_info = CIDetector.apply_overrides(ci_info, cr=200)
-
-        assert ci_info.cr_number == 200
-        assert ci_info.cr_url == "https://github.com/owner/repo/pull/200"
-        assert ci_info.session_type == "cr"
-
-    def test_apply_overrides_cr_gitlab(self):
-        """Test applying CR override for GitLab CI."""
-        with patch.dict(os.environ, {"CI_SERVER_URL": "https://gitlab.com"}):
-            ci_info = CIInfo(platform="gitlab-ci", cr_number=50, session_type="cr", repository="group/project")
-            ci_info = CIDetector.apply_overrides(ci_info, cr=75)
-
-            assert ci_info.cr_number == 75
-            assert ci_info.cr_url == "https://gitlab.com/group/project/-/merge_requests/75"
-            assert ci_info.session_type == "cr"
-
-    def test_apply_overrides_session_type(self):
-        """Test applying session type override."""
-        ci_info = CIInfo(session_type="dev")
-        ci_info = CIDetector.apply_overrides(ci_info, session_type="prod")
-
-        assert ci_info.session_type == "prod"
-
-    def test_apply_overrides_cr_redetermines_session_type(self):
-        """Test that CR override re-determines session type."""
-        ci_info = CIInfo(cr_number=None, session_type="dev", source_branch="feature")
-        ci_info = CIDetector.apply_overrides(ci_info, cr=100)
-
-        assert ci_info.cr_number == 100
-        assert ci_info.session_type == "cr"
-
-    def test_fallback_detection_with_git(self):
-        """Test fallback detection using git commands."""
-        with patch.dict(os.environ, {}, clear=True):
-            with patch("recce_cloud.ci_providers.base.BaseCIProvider.run_git_command") as mock_git:
-                mock_git.side_effect = ["commit123", "feature-branch"]
-                ci_info = CIDetector._fallback_detection()
-
-                assert ci_info.platform is None
-                assert ci_info.commit_sha == "commit123"
-                assert ci_info.source_branch == "feature-branch"
-                assert ci_info.base_branch == "main"
-                assert ci_info.session_type == "dev"