recce-nightly 1.15.0.20250806__py3-none-any.whl → 1.26.0.20251124__py3-none-any.whl

tests/recce_cloud/test_platform_clients.py

@@ -0,0 +1,333 @@
+"""
+Tests for platform-specific Recce Cloud API clients.
+"""
+
+import os
+from unittest.mock import patch
+from urllib.parse import urlparse
+
+import pytest
+
+from recce_cloud.api.factory import create_platform_client
+from recce_cloud.api.github import GitHubRecceCloudClient
+from recce_cloud.api.gitlab import GitLabRecceCloudClient
+from recce_cloud.ci_providers.base import CIInfo
+
+
+class TestGitHubRecceCloudClient:
+    """Tests for GitHub Actions API client."""
+
+    def test_init(self):
+        """Test client initialization."""
+        client = GitHubRecceCloudClient(token="test_token", repository="owner/repo")
+        assert client.token == "test_token"
+        assert client.repository == "owner/repo"
+        parsed = urlparse(client.api_host)
+        # Accept main domain or subdomains:
+        assert parsed.hostname == "cloud.datarecce.io" or (
+            parsed.hostname and parsed.hostname.endswith(".cloud.datarecce.io")
+        )
+
+    def test_touch_recce_session_pr(self):
+        """Test touch_recce_session for PR context."""
+        client = GitHubRecceCloudClient(token="test_token", repository="owner/repo")
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "test_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            response = client.touch_recce_session(
+                branch="feature-branch", adapter_type="postgres", cr_number=123, session_type="cr"
+            )
+
+            assert response["session_id"] == "test_session_id"
+            assert response["manifest_upload_url"] == "https://s3.aws.com/manifest"
+            assert response["catalog_upload_url"] == "https://s3.aws.com/catalog"
+
+            # Verify correct API endpoint was called
+            mock_request.assert_called_once()
+            call_args = mock_request.call_args
+            assert call_args[0][0] == "POST"
+            assert "github/owner/repo/touch-recce-session" in call_args[0][1]
+            assert call_args[1]["json"]["branch"] == "feature-branch"
+            assert call_args[1]["json"]["adapter_type"] == "postgres"
+            assert call_args[1]["json"]["pr_number"] == 123
+
+    def test_touch_recce_session_base(self):
+        """Test touch_recce_session for base branch context."""
+        client = GitHubRecceCloudClient(token="test_token", repository="owner/repo")
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "base_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            client.touch_recce_session(branch="main", adapter_type="snowflake")
+
+            # Verify pr_number is not in the payload when cr_number is None
+            call_args = mock_request.call_args
+            assert "pr_number" not in call_args[1]["json"]
+
+    def test_touch_recce_session_prod_type(self):
+        """Test touch_recce_session with --type prod (should not include pr_number)."""
+        client = GitHubRecceCloudClient(token="test_token", repository="owner/repo")
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "prod_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            # Even with cr_number detected, session_type="prod" should omit pr_number
+            client.touch_recce_session(branch="main", adapter_type="postgres", cr_number=123, session_type="prod")
+
+            # Verify pr_number is NOT in the payload when session_type is "prod"
+            call_args = mock_request.call_args
+            assert "pr_number" not in call_args[1]["json"]
+            assert call_args[1]["json"]["branch"] == "main"
+            assert call_args[1]["json"]["adapter_type"] == "postgres"
+
+    def test_upload_completed(self):
+        """Test upload_completed notification."""
+        client = GitHubRecceCloudClient(token="test_token", repository="owner/repo")
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {}
+
+            client.upload_completed(session_id="test_session_id")
+
+            mock_request.assert_called_once()
+            call_args = mock_request.call_args
+            assert call_args[0][0] == "POST"
+            assert "github/owner/repo/upload-completed" in call_args[0][1]
+            assert call_args[1]["json"]["session_id"] == "test_session_id"
+
+
+class TestGitLabRecceCloudClient:
+    """Tests for GitLab CI API client."""
+
+    def test_init(self):
+        """Test client initialization."""
+        client = GitLabRecceCloudClient(
+            token="test_token",
+            project_path="group/project",
+            repository_url="https://gitlab.com/group/project",
+        )
+        assert client.token == "test_token"
+        assert client.project_path == "group/project"
+        assert client.repository_url == "https://gitlab.com/group/project"
+
+    def test_touch_recce_session_mr(self):
+        """Test touch_recce_session for MR context."""
+        client = GitLabRecceCloudClient(
+            token="test_token",
+            project_path="group/project",
+            repository_url="https://gitlab.com/group/project",
+        )
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "test_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            response = client.touch_recce_session(
+                branch="feature-branch",
+                adapter_type="postgres",
+                cr_number=456,
+                commit_sha="abc123def456",
+                session_type="cr",
+            )
+
+            assert response["session_id"] == "test_session_id"
+
+            # Verify correct API endpoint and payload
+            call_args = mock_request.call_args
+            assert call_args[0][0] == "POST"
+            assert "gitlab/group/project/touch-recce-session" in call_args[0][1]
+            payload = call_args[1]["json"]
+            assert payload["branch"] == "feature-branch"
+            assert payload["adapter_type"] == "postgres"
+            assert payload["mr_iid"] == 456
+            assert payload["commit_sha"] == "abc123def456"
+            assert payload["repository_url"] == "https://gitlab.com/group/project"
+
+    def test_touch_recce_session_base(self):
+        """Test touch_recce_session for base branch context."""
+        client = GitLabRecceCloudClient(
+            token="test_token",
+            project_path="group/project",
+            repository_url="https://gitlab.com/group/project",
+        )
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "base_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            client.touch_recce_session(branch="main", adapter_type="bigquery", commit_sha="base123")
+
+            # Verify mr_iid is not in the payload when cr_number is None
+            call_args = mock_request.call_args
+            assert "mr_iid" not in call_args[1]["json"]
+
+    def test_touch_recce_session_prod_type(self):
+        """Test touch_recce_session with --type prod (should not include mr_iid)."""
+        client = GitLabRecceCloudClient(
+            token="test_token",
+            project_path="group/project",
+            repository_url="https://gitlab.com/group/project",
+        )
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {
+                "session_id": "prod_session_id",
+                "manifest_upload_url": "https://s3.aws.com/manifest",
+                "catalog_upload_url": "https://s3.aws.com/catalog",
+            }
+
+            # Even with cr_number detected, session_type="prod" should omit mr_iid
+            client.touch_recce_session(
+                branch="main",
+                adapter_type="postgres",
+                cr_number=456,
+                commit_sha="abc123def456",
+                session_type="prod",
+            )
+
+            # Verify mr_iid is NOT in the payload when session_type is "prod"
+            call_args = mock_request.call_args
+            assert "mr_iid" not in call_args[1]["json"]
+            assert call_args[1]["json"]["branch"] == "main"
+            assert call_args[1]["json"]["adapter_type"] == "postgres"
+            assert call_args[1]["json"]["commit_sha"] == "abc123def456"
+
+    def test_upload_completed(self):
+        """Test upload_completed notification."""
+        client = GitLabRecceCloudClient(
+            token="test_token",
+            project_path="group/project",
+            repository_url="https://gitlab.com/group/project",
+        )
+
+        with patch.object(client, "_make_request") as mock_request:
+            mock_request.return_value = {}
+
+            client.upload_completed(session_id="test_session_id", commit_sha="commit456")
+
+            mock_request.assert_called_once()
+            call_args = mock_request.call_args
+            assert call_args[0][0] == "POST"
+            assert "gitlab/group/project/upload-completed" in call_args[0][1]
+            payload = call_args[1]["json"]
+            assert payload["session_id"] == "test_session_id"
+            assert payload["commit_sha"] == "commit456"
+
+
+class TestFactoryCreatePlatformClient:
+    """Tests for create_platform_client factory function."""
+
+    def test_create_github_client(self):
+        """Test creating GitHub client."""
+        ci_info = CIInfo(platform="github-actions", repository="owner/repo")
+
+        client = create_platform_client(token="test_token", ci_info=ci_info)
+
+        assert isinstance(client, GitHubRecceCloudClient)
+        assert client.repository == "owner/repo"
+
+    def test_create_github_client_from_env(self):
+        """Test creating GitHub client with environment fallback."""
+        with patch.dict(os.environ, {"GITHUB_REPOSITORY": "owner/repo"}):
+            ci_info = CIInfo(platform="github-actions")
+
+            client = create_platform_client(token="test_token", ci_info=ci_info)
+
+            assert isinstance(client, GitHubRecceCloudClient)
+            assert client.repository == "owner/repo"
+
+    def test_create_github_client_missing_repository(self):
+        """Test error when GitHub repository information is missing."""
+        ci_info = CIInfo(platform="github-actions")
+
+        with patch.dict(os.environ, {}, clear=True):
+            with pytest.raises(ValueError, match="GitHub repository information is required"):
+                create_platform_client(token="test_token", ci_info=ci_info)
+
+    def test_create_gitlab_client(self):
+        """Test creating GitLab client."""
+        with patch.dict(
+            os.environ,
+            {"CI_PROJECT_URL": "https://gitlab.com/group/project"},
+        ):
+            ci_info = CIInfo(platform="gitlab-ci", repository="group/project")
+
+            client = create_platform_client(token="test_token", ci_info=ci_info)
+
+            assert isinstance(client, GitLabRecceCloudClient)
+            assert client.project_path == "group/project"
+            assert client.repository_url == "https://gitlab.com/group/project"
+
+    def test_create_gitlab_client_from_env(self):
+        """Test creating GitLab client with environment fallback."""
+        with patch.dict(
+            os.environ,
+            {
+                "CI_PROJECT_PATH": "group/project",
+                "CI_PROJECT_URL": "https://gitlab.com/group/project",
+            },
+        ):
+            ci_info = CIInfo(platform="gitlab-ci")
+
+            client = create_platform_client(token="test_token", ci_info=ci_info)
+
+            assert isinstance(client, GitLabRecceCloudClient)
+            assert client.project_path == "group/project"
+
+    def test_create_gitlab_client_missing_project_path(self):
+        """Test error when GitLab project path is missing."""
+        with patch.dict(os.environ, {}, clear=True):
+            ci_info = CIInfo(platform="gitlab-ci")
+
+            with pytest.raises(ValueError, match="GitLab project path is required"):
+                create_platform_client(token="test_token", ci_info=ci_info)
+
+    def test_create_gitlab_client_missing_project_url(self):
+        """Test error when GitLab project URL is missing."""
+        with patch.dict(os.environ, {"CI_PROJECT_PATH": "group/project"}, clear=True):
+            ci_info = CIInfo(platform="gitlab-ci", repository="group/project")
+
+            with pytest.raises(ValueError, match="GitLab project URL is required"):
+                create_platform_client(token="test_token", ci_info=ci_info)
+
+    def test_create_client_unsupported_platform(self):
+        """Test error for unsupported platform."""
+        ci_info = CIInfo(platform="unsupported-ci")
+
+        with pytest.raises(ValueError, match="Unsupported platform"):
+            create_platform_client(token="test_token", ci_info=ci_info)
+
+    def test_auto_detect_ci_info(self):
+        """Test automatic CI detection when ci_info is not provided."""
+        with patch.dict(
+            os.environ,
+            {
+                "GITHUB_ACTIONS": "true",
+                "GITHUB_REPOSITORY": "owner/repo",
+                "GITHUB_SHA": "abc123",
+            },
+            clear=True,
+        ):
+            client = create_platform_client(token="test_token")
+
+            assert isinstance(client, GitHubRecceCloudClient)
+            assert client.repository == "owner/repo"

tests/test_cli.py

@@ -5,8 +5,10 @@ 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 RecceStateLoader
+from recce.state import CloudStateLoader
 
 
 def test_cmd_version():
@@ -48,11 +50,11 @@ class TestCommandServer(TestCase):
     @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")
+    @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=RecceStateLoader)
+        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"
@@ -65,6 +67,82 @@ class TestCommandServer(TestCase):
         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")
@@ -131,3 +209,28 @@ class TestCommandRun(TestCase):
 
         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
+        )

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