test(cli): add 15 tests for app.py and doctor.py CLI modules

Add unit tests for CLI app configuration commands and doctor checks:
- 8 tests for app.py: validate_config, list_config, main app, global options
- 7 tests for doctor.py: run_doctor_checks with various configurations

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: zhujian0805

tests/unit/test_app_cli.py

@@ -0,0 +1,121 @@
+"""Tests for CLI app module."""
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from code_assistant_manager.cli.app import app, config_app, list_config, validate_config
+
+
+@pytest.fixture
+def runner():
+    """Create a CLI test runner."""
+    return CliRunner()
+
+
+class TestValidateConfig:
+    """Tests for config validation command."""
+
+    def test_validate_config_success(self, runner, tmp_path):
+        """validate_config passes with valid configuration."""
+        config_file = tmp_path / "providers.json"
+        config_file.write_text(json.dumps({"providers": []}))
+
+        mock_cm = MagicMock()
+        mock_cm.validate_config.return_value = (True, [])
+
+        with patch("code_assistant_manager.config.ConfigManager", return_value=mock_cm):
+            result = runner.invoke(
+                config_app, ["validate", "--config", str(config_file)]
+            )
+
+        assert result.exit_code == 0
+        assert "passed" in result.output.lower()
+
+    def test_validate_config_failure(self, runner, tmp_path):
+        """validate_config reports errors with invalid configuration."""
+        config_file = tmp_path / "providers.json"
+        config_file.write_text(json.dumps({"providers": []}))
+
+        mock_cm = MagicMock()
+        mock_cm.validate_config.return_value = (False, ["Missing required field"])
+
+        with patch("code_assistant_manager.config.ConfigManager", return_value=mock_cm):
+            result = runner.invoke(
+                config_app, ["validate", "--config", str(config_file)]
+            )
+
+        assert "failed" in result.output.lower()
+        assert "Missing required field" in result.output
+
+    def test_validate_config_file_not_found(self, runner, tmp_path):
+        """validate_config handles missing file gracefully."""
+        config_file = tmp_path / "nonexistent.json"
+
+        with patch(
+            "code_assistant_manager.config.ConfigManager",
+            side_effect=FileNotFoundError("Config not found"),
+        ):
+            result = runner.invoke(
+                config_app, ["validate", "--config", str(config_file)]
+            )
+
+        assert "not found" in result.output.lower()
+
+
+class TestListConfig:
+    """Tests for config list command."""
+
+    def test_list_config_shows_locations(self, runner):
+        """list_config shows configuration file locations."""
+        result = runner.invoke(config_app, ["list"])
+
+        assert result.exit_code == 0
+        assert "Configuration Files" in result.output
+        # Should mention some standard locations
+        assert "providers.json" in result.output
+
+    def test_list_config_shows_editor_configs(self, runner):
+        """list_config shows editor configuration locations."""
+        result = runner.invoke(config_app, ["list"])
+
+        assert result.exit_code == 0
+        # Should show editor configurations section
+        assert "Editor" in result.output or "claude" in result.output.lower()
+
+
+class TestMainApp:
+    """Tests for main app commands."""
+
+    def test_app_help(self, runner):
+        """app shows help message."""
+        result = runner.invoke(app, ["--help"])
+
+        assert result.exit_code == 0
+        assert "Code Assistant Manager" in result.output
+
+    def test_app_subcommands_available(self, runner):
+        """app has expected subcommands."""
+        result = runner.invoke(app, ["--help"])
+
+        assert result.exit_code == 0
+        # Check for main subcommands
+        assert "mcp" in result.output
+        assert "prompt" in result.output
+        assert "skill" in result.output
+        assert "plugin" in result.output
+
+
+class TestGlobalOptions:
+    """Tests for global CLI options."""
+
+    def test_debug_option(self, runner):
+        """--debug option enables debug logging."""
+        with patch("code_assistant_manager.cli.app.logging") as mock_logging:
+            result = runner.invoke(app, ["--debug", "--help"])
+
+        # The debug option should be recognized
+        assert result.exit_code == 0

tests/unit/test_doctor.py

@@ -0,0 +1,109 @@
+"""Tests for CLI doctor module."""
+
+import json
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from code_assistant_manager.cli.doctor import run_doctor_checks
+
+
+@pytest.fixture
+def mock_config(tmp_path):
+    """Create a mock config object."""
+    config_file = tmp_path / "providers.json"
+    config_file.write_text(json.dumps({"providers": []}))
+
+    config = MagicMock()
+    config.config_path = str(config_file)
+    # Add config_data attribute for JSON serialization in doctor checks
+    config.config_data = {"providers": []}
+    return config
+
+
+class TestRunDoctorChecks:
+    """Tests for run_doctor_checks function."""
+
+    def test_doctor_checks_basic_pass(self, mock_config, capsys):
+        """Doctor checks pass with valid installation."""
+        # Mock the dependencies that doctor checks need
+        # Patch at the source module where find_env_file is imported from
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=False)
+
+        captured = capsys.readouterr().out
+        # Should show installation check passed
+        assert "installed" in captured.lower()
+        assert "Python" in captured
+
+    def test_doctor_checks_config_exists(self, mock_config, capsys):
+        """Doctor shows config file exists when it does."""
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=False)
+
+        captured = capsys.readouterr().out
+        assert "Configuration" in captured
+
+    def test_doctor_checks_config_missing(self, tmp_path, capsys):
+        """Doctor reports when config file is missing."""
+        config = MagicMock()
+        config.config_path = str(tmp_path / "nonexistent.json")
+        # Add config_data for JSON serialization even when config file is missing
+        config.config_data = {"providers": []}
+
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(config, verbose=False)
+
+        captured = capsys.readouterr().out
+        assert "Configuration" in captured or "not found" in captured.lower()
+
+    def test_doctor_checks_verbose(self, mock_config, capsys):
+        """Doctor provides additional info in verbose mode."""
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=True)
+
+        captured = capsys.readouterr().out
+        # Verbose mode should still complete
+        assert "installed" in captured.lower()
+
+    def test_doctor_shows_python_version(self, mock_config, capsys):
+        """Doctor shows Python version information."""
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=False)
+
+        captured = capsys.readouterr().out
+        assert "Python" in captured
+        assert sys.version.split()[0] in captured
+
+    def test_doctor_shows_environment_check(self, mock_config, capsys):
+        """Doctor includes environment variables check section."""
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=False)
+
+        captured = capsys.readouterr().out
+        assert "Environment" in captured
+
+    def test_doctor_returns_zero_on_success(self, mock_config):
+        """Doctor returns 0 when all checks pass."""
+        with patch(
+            "code_assistant_manager.env_loader.find_env_file", return_value=None
+        ):
+            result = run_doctor_checks(mock_config, verbose=False)
+
+        # If the basic checks pass (installation, python, config exists)
+        # it should return a low or zero issue count
+        assert isinstance(result, int)