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

tests/test_cli.py

@@ -1,20 +1,24 @@
 from unittest import TestCase
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
 
 from click.testing import CliRunner
 
-from recce.cli import server as cli_command_server, run as cli_command_run
+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():
-    from recce.cli import 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__
+    assert result.output.replace("\n", "") == __version__
 
 
 class TestCommandServer(TestCase):
@@ -22,90 +26,175 @@ class TestCommandServer(TestCase):
         self.runner = CliRunner()
         pass
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.uvicorn.run')
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("recce.cli.uvicorn.run")
     def test_cmd_server(self, mock_run, mock_verify_required_artifacts):
         from recce.server import app
+
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server, ['--host', 'unittest', '--port', 5566])
-        mock_run.assert_called_once_with(app, host='unittest', port=5566, lifespan='on')
+        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')
+    @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'])
+        result = self.runner.invoke(cli_command_server, ["--cloud"])
         assert result.exit_code == 1
 
-    @patch('recce.cli.uvicorn.run')
+    @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'])
+        result = self.runner.invoke(cli_command_server, ["--cloud", "--password", "unittest"])
         assert result.exit_code == 1
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.util.recce_cloud.get_recce_cloud_onboarding_state')
-    @patch('recce.cli.uvicorn.run')
-    @patch('recce.cli.RecceStateLoader')
-    def test_cmd_server_with_cloud(self, mock_state_loader_class, mock_run, mock_get_recce_cloud_onboarding_state,
-                                   mock_verify_required_artifacts):
-        mock_state_loader = MagicMock(spec=RecceStateLoader)
+    @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_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'])
+
+        # 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):
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("os.path.isdir", side_effect=lambda path: True if path == "existed_folder" else False)
+    @patch("recce.cli.uvicorn.run")
+    @patch("recce.server.AppState")
+    def test_cmd_server_with_single_env(self, mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts):
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
+        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
+        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):
+        assert (
+            verify_required_artifacts_args.kwargs["target_path"]
+            == verify_required_artifacts_args.kwargs["target_base_path"]
+        )
+
+    @patch.object(RecceContext, "verify_required_artifacts")
+    @patch("os.path.isdir", side_effect=lambda path: True if path == "existed_folder" else False)
+    @patch("recce.cli.uvicorn.run")
+    @patch("recce.server.AppState")
+    def test_cmd_server_with_single_env_but_review_mode_enabled(
+        self, mock_app_state, mock_run, mock_isdir, mock_verify_required_artifacts
+    ):
         mock_verify_required_artifacts.return_value = True, None
-        self.runner.invoke(cli_command_server,
-                           [
-                               'existed_state_file',
-                               '--review',
-                               '--target-path', 'existed_folder',
-                               '--target-base-path', 'non_existed_folder',
-                           ])
+        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
+        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):
@@ -113,10 +202,35 @@ class TestCommandRun(TestCase):
         self.runner = CliRunner()
         pass
 
-    @patch.object(RecceContext, 'verify_required_artifacts')
-    @patch('recce.cli.cli_run')
+    @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
+        )

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

tests/test_cloud_listing_cli.py

@@ -0,0 +1,324 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from click.testing import CliRunner
+
+from recce.cli import list_organizations, list_projects, list_sessions
+from recce.exceptions import RecceConfigException
+from recce.util.recce_cloud import RecceCloudException
+
+
+class TestCloudListingCLI(unittest.TestCase):
+    """Test cases for the cloud listing CLI commands."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_organizations_success(self, mock_recce_cloud, mock_prepare_token):
+        """Test successful list-organizations command."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_organizations.return_value = [
+            {"id": 1, "name": "org1", "display_name": "Organization 1"},
+            {"id": 2, "name": "org2", "display_name": "Organization 2"},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Organizations", result.output)
+        self.assertIn("org1", result.output)
+        self.assertIn("Organization 1", result.output)
+        self.assertIn("org2", result.output)
+        self.assertIn("Organization 2", result.output)
+        mock_cloud_instance.list_organizations.assert_called_once()
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_organizations_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-organizations command with no organizations."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_organizations.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No organizations found", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_organizations_invalid_token(self, mock_prepare_token):
+        """Test list-organizations command with invalid token."""
+        # Setup mock to raise exception
+        mock_prepare_token.side_effect = RecceConfigException("Invalid token")
+
+        # Test command
+        result = self.runner.invoke(list_organizations, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_with_cli_arg(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with CLI argument."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [
+            {"id": 1, "name": "project1", "display_name": "Project 1"},
+            {"id": 2, "name": "project2", "display_name": "Project 2"},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with CLI argument
+        result = self.runner.invoke(list_projects, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 8", result.output)
+        self.assertIn("project1", result.output)
+        self.assertIn("Project 1", result.output)
+        mock_cloud_instance.list_projects.assert_called_once_with("8")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_with_env_var(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with environment variable."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [{"id": 1, "name": "project1", "display_name": "Project 1"}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with environment variable
+        result = self.runner.invoke(list_projects, [], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 8", result.output)
+        self.assertIn("project1", result.output)
+        mock_cloud_instance.list_projects.assert_called_once_with("8")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_cli_overrides_env(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command where CLI argument overrides environment variable."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = [{"id": 1, "name": "project1", "display_name": "Project 1"}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with both env var and CLI arg (CLI should win)
+        result = self.runner.invoke(list_projects, ["--organization", "10"], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Projects in Organization 10", result.output)
+        # Verify CLI argument (10) was used, not env var (8)
+        mock_cloud_instance.list_projects.assert_called_once_with("10")
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_projects_missing_organization(self, mock_prepare_token):
+        """Test list-projects command with missing organization ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without organization ID
+        result = self.runner.invoke(list_projects, [])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Organization ID is required", result.output)
+        self.assertIn("--organization", result.output)
+        self.assertIn("RECCE_ORGANIZATION_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_projects_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-projects command with no projects."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_projects.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_projects, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No projects found in organization 8", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_with_cli_args(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with CLI arguments."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [
+            {"id": "session1", "name": "PR-123", "is_base": False},
+            {"id": "session2", "name": "Base Session", "is_base": True},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with CLI arguments
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 7", result.output)
+        self.assertIn("PR-123", result.output)
+        self.assertIn("Base Session", result.output)
+        self.assertIn("✓", result.output)  # Base session marker
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "7")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_with_env_vars(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with environment variables."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [{"id": "session1", "name": "Session 1", "is_base": False}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with environment variables
+        result = self.runner.invoke(list_sessions, [], env={"RECCE_ORGANIZATION_ID": "8", "RECCE_PROJECT_ID": "7"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 7", result.output)
+        self.assertIn("Session 1", result.output)
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "7")
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_mixed_env_and_cli(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with mixed environment variables and CLI args."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [{"id": "session1", "name": "Session 1", "is_base": False}]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command with env var for org and CLI arg for project
+        result = self.runner.invoke(list_sessions, ["--project", "9"], env={"RECCE_ORGANIZATION_ID": "8"})
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("Sessions in Project 9", result.output)
+        # Verify it used env var for org (8) and CLI arg for project (9)
+        mock_cloud_instance.list_sessions.assert_called_once_with("8", "9")
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_sessions_missing_organization(self, mock_prepare_token):
+        """Test list-sessions command with missing organization ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without organization ID
+        result = self.runner.invoke(list_sessions, ["--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Organization ID is required", result.output)
+        self.assertIn("--organization", result.output)
+        self.assertIn("RECCE_ORGANIZATION_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    def test_list_sessions_missing_project(self, mock_prepare_token):
+        """Test list-sessions command with missing project ID."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+
+        # Test command without project ID
+        result = self.runner.invoke(list_sessions, ["--organization", "8"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Project ID is required", result.output)
+        self.assertIn("--project", result.output)
+        self.assertIn("RECCE_PROJECT_ID", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_empty(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with no sessions."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = []
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        self.assertIn("No sessions found in project 7", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_list_sessions_api_error(self, mock_recce_cloud, mock_prepare_token):
+        """Test list-sessions command with API error."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.side_effect = RecceCloudException("Access denied", "Forbidden", 403)
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 1)
+        self.assertIn("Error", result.output)
+
+    @patch("recce.cli.prepare_api_token")
+    @patch("recce.util.recce_cloud.RecceCloud")
+    def test_sessions_base_session_display(self, mock_recce_cloud, mock_prepare_token):
+        """Test that base sessions are properly marked with checkmark."""
+        # Setup mocks
+        mock_prepare_token.return_value = "test-token"
+        mock_cloud_instance = Mock()
+        mock_cloud_instance.list_sessions.return_value = [
+            {"id": "session1", "name": "Regular Session", "is_base": False},
+            {"id": "session2", "name": "Base Session", "is_base": True},
+            {"id": "session3", "name": "Another Regular", "is_base": False},
+        ]
+        mock_recce_cloud.return_value = mock_cloud_instance
+
+        # Test command
+        result = self.runner.invoke(list_sessions, ["--organization", "8", "--project", "7"])
+
+        # Assertions
+        self.assertEqual(result.exit_code, 0)
+        output_lines = result.output.split("\n")
+
+        # Find the base session line and verify it has the checkmark
+        base_session_line = None
+        for line in output_lines:
+            if "Base Session" in line:
+                base_session_line = line
+                break
+
+        self.assertIsNotNone(base_session_line)
+        self.assertIn("✓", base_session_line)
+
+
+if __name__ == "__main__":
+    unittest.main()