kubectl-mcp-server 1.13.0__py3-none-any.whl → 1.14.0__py3-none-any.whl

tests/test_browser.py

@@ -172,8 +172,8 @@ class TestBrowserToolFunctions:
         assert "browser_screenshot" in tool_names
 
     @pytest.mark.unit
-    def test_all_19_browser_tools_registered(self):
-        """Verify all 19 browser tools are registered."""
+    def test_all_26_browser_tools_registered(self):
+        """Verify all 26 browser tools are registered (v0.7+)."""
         from kubectl_mcp_tool.tools.browser import register_browser_tools
         from fastmcp import FastMCP
         import asyncio
@@ -182,9 +182,10 @@ class TestBrowserToolFunctions:
         register_browser_tools(server, non_destructive=False)
 
         tools = asyncio.run(server.list_tools())
-        assert len(tools) == 19, f"Expected 19 browser tools, got {len(tools)}"
+        assert len(tools) == 26, f"Expected 26 browser tools, got {len(tools)}"
 
         expected_tools = [
+            # Core browser tools
             "browser_open",
             "browser_snapshot",
             "browser_click",
@@ -194,6 +195,15 @@ class TestBrowserToolFunctions:
             "browser_get_url",
             "browser_wait",
             "browser_close",
+            # NEW v0.7 tools
+            "browser_connect_cdp",
+            "browser_install",
+            "browser_set_provider",
+            "browser_session_list",
+            "browser_session_switch",
+            "browser_open_with_headers",
+            "browser_set_viewport",
+            # K8s integration tools
             "browser_test_ingress",
             "browser_screenshot_service",
             "browser_screenshot_grafana",
@@ -211,6 +221,157 @@ class TestBrowserToolFunctions:
         assert not missing, f"Missing browser tools: {missing}"
 
 
+class TestBrowserV07Features:
+    """Tests for agent-browser v0.7 features."""
+
+    @pytest.mark.unit
+    def test_get_global_options_empty(self):
+        """Test _get_global_options with no env vars set."""
+        from kubectl_mcp_tool.tools.browser import _get_global_options
+
+        with patch.dict(os.environ, {}, clear=True):
+            # Need to reload to pick up cleared env
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            opts = browser_module._get_global_options()
+            # Should return empty list when no env vars set
+            assert isinstance(opts, list)
+
+    @pytest.mark.unit
+    def test_get_global_options_with_provider(self):
+        """Test _get_global_options with cloud provider."""
+        with patch.dict(os.environ, {"MCP_BROWSER_PROVIDER": "browserbase"}):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            opts = browser_module._get_global_options()
+            assert "-p" in opts
+            assert "browserbase" in opts
+
+    @pytest.mark.unit
+    def test_get_global_options_with_profile(self):
+        """Test _get_global_options with persistent profile."""
+        with patch.dict(os.environ, {"MCP_BROWSER_PROFILE": "~/.k8s-browser"}):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            opts = browser_module._get_global_options()
+            assert "--profile" in opts
+
+    @pytest.mark.unit
+    def test_get_global_options_with_session(self):
+        """Test _get_global_options with session name."""
+        with patch.dict(os.environ, {"MCP_BROWSER_SESSION": "test-session"}):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            opts = browser_module._get_global_options()
+            assert "--session" in opts
+            assert "test-session" in opts
+
+    @pytest.mark.unit
+    def test_get_global_options_with_headed(self):
+        """Test _get_global_options with headed mode."""
+        with patch.dict(os.environ, {"MCP_BROWSER_HEADED": "true"}):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            opts = browser_module._get_global_options()
+            assert "--headed" in opts
+
+    @pytest.mark.unit
+    def test_is_transient_error(self):
+        """Test transient error detection."""
+        from kubectl_mcp_tool.tools.browser import _is_transient_error
+
+        # Transient errors
+        assert _is_transient_error("ECONNREFUSED") is True
+        assert _is_transient_error("Connection refused") is True
+        assert _is_transient_error("ETIMEDOUT") is True
+        assert _is_transient_error("timeout occurred") is True
+
+        # Non-transient errors
+        assert _is_transient_error("File not found") is False
+        assert _is_transient_error("Invalid argument") is False
+
+    @pytest.mark.unit
+    def test_run_browser_with_retry_success(self):
+        """Test retry logic with successful result."""
+        from kubectl_mcp_tool.tools.browser import _run_browser_with_retry
+
+        with patch("kubectl_mcp_tool.tools.browser._run_browser") as mock_run:
+            mock_run.return_value = {"success": True, "output": "OK"}
+
+            result = _run_browser_with_retry(["open", "https://example.com"])
+
+            assert result["success"] is True
+            # Should only call once on success
+            assert mock_run.call_count == 1
+
+    @pytest.mark.unit
+    def test_run_browser_with_retry_transient_error(self):
+        """Test retry logic with transient error."""
+        from kubectl_mcp_tool.tools.browser import _run_browser_with_retry
+
+        with patch("kubectl_mcp_tool.tools.browser._run_browser") as mock_run:
+            with patch("time.sleep"):  # Skip actual sleep
+                # First two calls fail with transient error, third succeeds
+                mock_run.side_effect = [
+                    {"success": False, "error": "ECONNREFUSED"},
+                    {"success": False, "error": "ECONNREFUSED"},
+                    {"success": True, "output": "OK"},
+                ]
+
+                result = _run_browser_with_retry(["open", "https://example.com"], max_retries=3)
+
+                assert result["success"] is True
+                assert mock_run.call_count == 3
+
+    @pytest.mark.unit
+    def test_run_browser_with_retry_non_transient_error(self):
+        """Test retry logic with non-transient error (no retry)."""
+        from kubectl_mcp_tool.tools.browser import _run_browser_with_retry
+
+        with patch("kubectl_mcp_tool.tools.browser._run_browser") as mock_run:
+            mock_run.return_value = {"success": False, "error": "Invalid argument"}
+
+            result = _run_browser_with_retry(["open", "https://example.com"])
+
+            assert result["success"] is False
+            # Should not retry non-transient errors
+            assert mock_run.call_count == 1
+
+    @pytest.mark.unit
+    def test_debug_mode(self):
+        """Test debug logging."""
+        with patch.dict(os.environ, {"MCP_BROWSER_DEBUG": "true"}):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            assert browser_module.MCP_BROWSER_DEBUG is True
+
+    @pytest.mark.unit
+    def test_retry_configuration(self):
+        """Test retry configuration from environment."""
+        with patch.dict(os.environ, {
+            "MCP_BROWSER_MAX_RETRIES": "5",
+            "MCP_BROWSER_RETRY_DELAY": "2000"
+        }):
+            import importlib
+            import kubectl_mcp_tool.tools.browser as browser_module
+            importlib.reload(browser_module)
+
+            assert browser_module.MCP_BROWSER_MAX_RETRIES == 5
+            assert browser_module.MCP_BROWSER_RETRY_DELAY == 2000
+
+
 class TestK8sIntegration:
     """Tests for Kubernetes-specific browser tools."""
 
@@ -340,10 +501,11 @@ class TestServerIntegration:
                         tools = asyncio.run(server.server.list_tools())
                         tool_names = [t.name for t in tools]
 
-                        # Should have browser tools (127 + 19 = 146)
+                        # Should have browser tools (127 + 26 = 153)
                         assert "browser_open" in tool_names
                         assert "browser_screenshot" in tool_names
-                        assert len(tools) == 146, f"Expected 146 tools (127 + 19), got {len(tools)}"
+                        assert "browser_connect_cdp" in tool_names  # v0.7 tool
+                        assert len(tools) == 153, f"Expected 153 tools (127 + 26), got {len(tools)}"
 
 
 import asyncio

tests/test_cli.py

@@ -0,0 +1,299 @@
+"""Unit tests for the enhanced CLI module."""
+
+import pytest
+import os
+import sys
+import json
+from unittest.mock import patch, MagicMock
+from io import StringIO
+
+
+class TestCliErrors:
+    """Tests for CLI error handling module."""
+
+    @pytest.mark.unit
+    def test_error_code_values(self):
+        """Test ErrorCode enum values."""
+        from kubectl_mcp_tool.cli.errors import ErrorCode
+
+        assert ErrorCode.SUCCESS == 0
+        assert ErrorCode.CLIENT_ERROR == 1
+        assert ErrorCode.SERVER_ERROR == 2
+        assert ErrorCode.K8S_ERROR == 3
+        assert ErrorCode.BROWSER_ERROR == 4
+        assert ErrorCode.NETWORK_ERROR == 5
+
+    @pytest.mark.unit
+    def test_cli_error_dataclass(self):
+        """Test CliError dataclass."""
+        from kubectl_mcp_tool.cli.errors import CliError, ErrorCode
+
+        error = CliError(
+            code=ErrorCode.CLIENT_ERROR,
+            type="TEST_ERROR",
+            message="Test message",
+            details="Test details",
+            suggestion="Test suggestion"
+        )
+
+        assert error.code == ErrorCode.CLIENT_ERROR
+        assert error.type == "TEST_ERROR"
+        assert error.message == "Test message"
+        assert error.details == "Test details"
+        assert error.suggestion == "Test suggestion"
+
+    @pytest.mark.unit
+    def test_format_cli_error(self):
+        """Test format_cli_error function."""
+        from kubectl_mcp_tool.cli.errors import CliError, ErrorCode, format_cli_error
+
+        error = CliError(
+            code=ErrorCode.CLIENT_ERROR,
+            type="TEST_ERROR",
+            message="Something went wrong",
+            details="More info here",
+            suggestion="Try this instead"
+        )
+
+        formatted = format_cli_error(error)
+
+        assert "Error [TEST_ERROR]: Something went wrong" in formatted
+        assert "Details: More info here" in formatted
+        assert "Suggestion: Try this instead" in formatted
+
+    @pytest.mark.unit
+    def test_tool_not_found_error(self):
+        """Test tool_not_found_error factory."""
+        from kubectl_mcp_tool.cli.errors import tool_not_found_error, ErrorCode
+
+        error = tool_not_found_error("nonexistent_tool", ["get_pods", "list_namespaces"])
+
+        assert error.code == ErrorCode.CLIENT_ERROR
+        assert error.type == "TOOL_NOT_FOUND"
+        assert "nonexistent_tool" in error.message
+        assert "get_pods" in error.details
+
+    @pytest.mark.unit
+    def test_invalid_json_error(self):
+        """Test invalid_json_error factory."""
+        from kubectl_mcp_tool.cli.errors import invalid_json_error, ErrorCode
+
+        error = invalid_json_error("{invalid json}", "Expecting value")
+
+        assert error.code == ErrorCode.CLIENT_ERROR
+        assert error.type == "INVALID_JSON"
+        assert "Expecting value" in error.details
+
+    @pytest.mark.unit
+    def test_unknown_subcommand_error(self):
+        """Test unknown_subcommand_error factory with suggestions."""
+        from kubectl_mcp_tool.cli.errors import unknown_subcommand_error
+
+        # Test known alias
+        error = unknown_subcommand_error("run")
+        assert "call" in error.suggestion
+
+        # Test unknown command
+        error = unknown_subcommand_error("unknown")
+        assert "help" in error.suggestion.lower()
+
+    @pytest.mark.unit
+    def test_browser_not_found_error(self):
+        """Test browser_not_found_error factory."""
+        from kubectl_mcp_tool.cli.errors import browser_not_found_error, ErrorCode
+
+        error = browser_not_found_error()
+
+        assert error.code == ErrorCode.BROWSER_ERROR
+        assert "agent-browser" in error.message
+        assert "npm install" in error.suggestion
+
+
+class TestCliOutput:
+    """Tests for CLI output formatting module."""
+
+    @pytest.mark.unit
+    def test_should_colorize_respects_no_color(self):
+        """Test that NO_COLOR env var disables colors."""
+        from kubectl_mcp_tool.cli.output import should_colorize
+
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            assert should_colorize() is False
+
+    @pytest.mark.unit
+    def test_format_tools_list_json(self):
+        """Test format_tools_list with JSON output."""
+        from kubectl_mcp_tool.cli.output import format_tools_list
+
+        tools = [
+            {"name": "get_pods", "description": "Get pods", "category": "pods"},
+            {"name": "list_namespaces", "description": "List namespaces", "category": "core"},
+        ]
+
+        result = format_tools_list(tools, as_json=True)
+        parsed = json.loads(result)
+
+        assert len(parsed) == 2
+        assert parsed[0]["name"] == "get_pods"
+
+    @pytest.mark.unit
+    def test_format_tools_list_text(self):
+        """Test format_tools_list with text output."""
+        from kubectl_mcp_tool.cli.output import format_tools_list
+
+        tools = [
+            {"name": "get_pods", "description": "Get pods", "category": "pods"},
+        ]
+
+        # Disable colors for predictable output
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            result = format_tools_list(tools, with_descriptions=True)
+
+        assert "get_pods" in result
+        assert "Get pods" in result
+
+    @pytest.mark.unit
+    def test_format_tool_schema(self):
+        """Test format_tool_schema function."""
+        from kubectl_mcp_tool.cli.output import format_tool_schema
+
+        tool = {
+            "name": "get_pods",
+            "description": "Get pods in a namespace",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "namespace": {"type": "string", "description": "Namespace name"}
+                },
+                "required": ["namespace"]
+            }
+        }
+
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            result = format_tool_schema(tool)
+
+        assert "get_pods" in result
+        assert "Get pods in a namespace" in result
+        assert "namespace" in result
+        assert "required" in result
+
+    @pytest.mark.unit
+    def test_format_server_info(self):
+        """Test format_server_info function."""
+        from kubectl_mcp_tool.cli.output import format_server_info
+
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            result = format_server_info(
+                version="1.14.0",
+                tool_count=127,
+                resource_count=8,
+                prompt_count=8,
+                context="minikube"
+            )
+
+        assert "1.14.0" in result
+        assert "127" in result
+        assert "minikube" in result
+
+    @pytest.mark.unit
+    def test_format_doctor_results(self):
+        """Test format_doctor_results function."""
+        from kubectl_mcp_tool.cli.output import format_doctor_results
+
+        checks = [
+            {"name": "kubectl", "status": "ok", "version": "v1.28.0"},
+            {"name": "helm", "status": "warning", "details": "Not installed"},
+            {"name": "kubernetes", "status": "error", "details": "Connection failed"},
+        ]
+
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            result = format_doctor_results(checks)
+
+        assert "kubectl" in result
+        assert "v1.28.0" in result
+        assert "Some checks failed" in result
+
+
+class TestCliCommands:
+    """Tests for CLI command handlers."""
+
+    @pytest.mark.unit
+    def test_main_help(self):
+        """Test that --help works."""
+        from kubectl_mcp_tool.cli.cli import main
+
+        with patch.object(sys, 'argv', ['kubectl-mcp-server', '--help']):
+            with pytest.raises(SystemExit) as exc_info:
+                main()
+            # argparse exits with 0 for --help
+            assert exc_info.value.code == 0
+
+    @pytest.mark.unit
+    def test_get_tool_category(self):
+        """Test tool category detection."""
+        from kubectl_mcp_tool.cli.cli import _get_tool_category
+
+        assert _get_tool_category("get_pods") == "pods"
+        assert _get_tool_category("list_deployments") == "deployments"
+        assert _get_tool_category("helm_install") == "helm"
+        assert _get_tool_category("browser_open") == "browser"
+        assert _get_tool_category("unknown_tool") == "other"
+
+    @pytest.mark.unit
+    def test_cmd_doctor_checks_kubectl(self):
+        """Test that doctor command checks for kubectl."""
+        from kubectl_mcp_tool.cli.cli import cmd_doctor
+
+        args = MagicMock()
+        args.json = True
+
+        # Mock shutil.which to simulate kubectl present
+        with patch("shutil.which") as mock_which:
+            mock_which.side_effect = lambda x: f"/usr/bin/{x}" if x == "kubectl" else None
+
+            with patch("subprocess.run") as mock_run:
+                mock_run.return_value = MagicMock(
+                    returncode=0,
+                    stdout='{"clientVersion": {"gitVersion": "v1.28.0"}}'
+                )
+
+                with patch("kubectl_mcp_tool.cli.cli.format_doctor_results") as mock_format:
+                    mock_format.return_value = "{}"
+                    cmd_doctor(args)
+
+                # Should have called shutil.which for kubectl
+                mock_which.assert_any_call("kubectl")
+
+
+class TestCliIntegration:
+    """Integration tests for CLI module."""
+
+    @pytest.mark.unit
+    def test_cli_module_imports(self):
+        """Test that all CLI modules can be imported."""
+        from kubectl_mcp_tool.cli import (
+            main,
+            CliError,
+            ErrorCode,
+            format_cli_error,
+            format_tools_list,
+            format_server_info,
+        )
+
+        assert main is not None
+        assert CliError is not None
+        assert ErrorCode is not None
+
+    @pytest.mark.unit
+    def test_error_str_representation(self):
+        """Test CliError __str__ method."""
+        from kubectl_mcp_tool.cli.errors import CliError, ErrorCode
+
+        error = CliError(
+            code=ErrorCode.CLIENT_ERROR,
+            type="TEST",
+            message="Test message"
+        )
+
+        assert "TEST" in str(error)
+        assert "Test message" in str(error)