kubectl-mcp-server 1.16.0__py3-none-any.whl → 1.18.0__py3-none-any.whl

tests/test_config.py

@@ -0,0 +1,386 @@
+"""Tests for configuration management module."""
+
+import os
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+
+class TestServerConfig:
+    """Test ServerConfig dataclass."""
+
+    def test_default_values(self):
+        """Test default configuration values."""
+        from kubectl_mcp_tool.config.schema import ServerConfig
+
+        config = ServerConfig()
+        assert config.transport == "streamable-http"
+        assert config.host == "127.0.0.1"
+        assert config.port == 8000
+        assert config.debug is False
+        assert config.log_file is None
+
+    def test_custom_values(self):
+        """Test custom configuration values."""
+        from kubectl_mcp_tool.config.schema import ServerConfig
+
+        config = ServerConfig(
+            transport="stdio",
+            host="0.0.0.0",
+            port=9000,
+            debug=True,
+            log_file="/var/log/mcp.log",
+        )
+        assert config.transport == "stdio"
+        assert config.host == "0.0.0.0"
+        assert config.port == 9000
+        assert config.debug is True
+        assert config.log_file == "/var/log/mcp.log"
+
+    def test_invalid_transport(self):
+        """Test validation rejects invalid transport."""
+        from kubectl_mcp_tool.config.schema import ServerConfig
+
+        with pytest.raises(ValueError, match="Invalid transport"):
+            ServerConfig(transport="invalid")
+
+    def test_invalid_port(self):
+        """Test validation rejects invalid port."""
+        from kubectl_mcp_tool.config.schema import ServerConfig
+
+        with pytest.raises(ValueError, match="Invalid port"):
+            ServerConfig(port=0)
+
+        with pytest.raises(ValueError, match="Invalid port"):
+            ServerConfig(port=70000)
+
+
+class TestSafetyConfig:
+    """Test SafetyConfig dataclass."""
+
+    def test_default_values(self):
+        """Test default safety configuration."""
+        from kubectl_mcp_tool.config.schema import SafetyConfig
+
+        config = SafetyConfig()
+        assert config.mode == "normal"
+        assert config.confirm_destructive is False
+        assert config.max_delete_count == 10
+        assert "kube-system" in config.blocked_namespaces
+
+    def test_valid_modes(self):
+        """Test all valid safety modes."""
+        from kubectl_mcp_tool.config.schema import SafetyConfig
+
+        for mode in ["normal", "read-only", "disable-destructive"]:
+            config = SafetyConfig(mode=mode)
+            assert config.mode == mode
+
+    def test_invalid_mode(self):
+        """Test validation rejects invalid mode."""
+        from kubectl_mcp_tool.config.schema import SafetyConfig
+
+        with pytest.raises(ValueError, match="Invalid safety mode"):
+            SafetyConfig(mode="invalid")
+
+
+class TestBrowserConfig:
+    """Test BrowserConfig dataclass."""
+
+    def test_default_values(self):
+        """Test default browser configuration."""
+        from kubectl_mcp_tool.config.schema import BrowserConfig
+
+        config = BrowserConfig()
+        assert config.enabled is False
+        assert config.provider == "local"
+        assert config.headed is False
+        assert config.timeout == 60
+
+    def test_valid_providers(self):
+        """Test all valid browser providers."""
+        from kubectl_mcp_tool.config.schema import BrowserConfig
+
+        for provider in ["local", "browserbase", "browseruse", "cdp"]:
+            config = BrowserConfig(provider=provider)
+            assert config.provider == provider
+
+    def test_invalid_provider(self):
+        """Test validation rejects invalid provider."""
+        from kubectl_mcp_tool.config.schema import BrowserConfig
+
+        with pytest.raises(ValueError, match="Invalid browser provider"):
+            BrowserConfig(provider="invalid")
+
+
+class TestMetricsConfig:
+    """Test MetricsConfig dataclass."""
+
+    def test_default_values(self):
+        """Test default metrics configuration."""
+        from kubectl_mcp_tool.config.schema import MetricsConfig
+
+        config = MetricsConfig()
+        assert config.enabled is False
+        assert config.endpoint == "/metrics"
+        assert config.sample_rate == 1.0
+
+    def test_invalid_sample_rate(self):
+        """Test validation rejects invalid sample rate."""
+        from kubectl_mcp_tool.config.schema import MetricsConfig
+
+        with pytest.raises(ValueError, match="Invalid sample_rate"):
+            MetricsConfig(sample_rate=1.5)
+
+        with pytest.raises(ValueError, match="Invalid sample_rate"):
+            MetricsConfig(sample_rate=-0.1)
+
+
+class TestValidateConfig:
+    """Test validate_config function."""
+
+    def test_valid_config(self):
+        """Test validation passes for valid config."""
+        from kubectl_mcp_tool.config.schema import validate_config
+
+        config = {
+            "server": {"transport": "stdio", "port": 8000},
+            "safety": {"mode": "read-only"},
+            "browser": {"provider": "browserbase"},
+            "metrics": {"sample_rate": 0.5},
+        }
+        errors = validate_config(config)
+        assert errors == []
+
+    def test_invalid_config(self):
+        """Test validation catches errors."""
+        from kubectl_mcp_tool.config.schema import validate_config
+
+        config = {
+            "server": {"transport": "invalid", "port": 0},
+            "safety": {"mode": "invalid"},
+            "browser": {"provider": "invalid"},
+            "metrics": {"sample_rate": 2.0},
+        }
+        errors = validate_config(config)
+        assert len(errors) == 5
+
+
+class TestConfigPaths:
+    """Test get_config_paths function."""
+
+    def test_default_paths(self):
+        """Test default config paths."""
+        from kubectl_mcp_tool.config.loader import get_config_paths
+
+        paths = get_config_paths()
+        assert "config_dir" in paths
+        assert "main_config" in paths
+        assert "drop_in_dir" in paths
+        assert paths["main_config"].name == "config.toml"
+        assert paths["drop_in_dir"].name == "config.d"
+
+    def test_xdg_config_home(self):
+        """Test XDG_CONFIG_HOME is respected."""
+        from kubectl_mcp_tool.config.loader import get_config_paths
+
+        with patch.dict(os.environ, {"XDG_CONFIG_HOME": "/custom/config"}):
+            paths = get_config_paths()
+            assert str(paths["config_dir"]).startswith("/custom/config")
+
+
+class TestDeepMerge:
+    """Test _deep_merge function."""
+
+    def test_simple_merge(self):
+        """Test simple dictionary merge."""
+        from kubectl_mcp_tool.config.loader import _deep_merge
+
+        base = {"a": 1, "b": 2}
+        override = {"b": 3, "c": 4}
+        result = _deep_merge(base, override)
+        assert result == {"a": 1, "b": 3, "c": 4}
+
+    def test_nested_merge(self):
+        """Test nested dictionary merge."""
+        from kubectl_mcp_tool.config.loader import _deep_merge
+
+        base = {"a": {"x": 1, "y": 2}, "b": 3}
+        override = {"a": {"y": 20, "z": 30}}
+        result = _deep_merge(base, override)
+        assert result == {"a": {"x": 1, "y": 20, "z": 30}, "b": 3}
+
+
+class TestEnvOverrides:
+    """Test _apply_env_overrides function."""
+
+    def test_server_port_override(self):
+        """Test MCP_SERVER_PORT environment override."""
+        from kubectl_mcp_tool.config.loader import _apply_env_overrides
+
+        with patch.dict(os.environ, {"MCP_SERVER_PORT": "9000"}):
+            result = _apply_env_overrides({})
+            assert result["server"]["port"] == 9000
+
+    def test_safety_mode_override(self):
+        """Test MCP_SAFETY_MODE environment override."""
+        from kubectl_mcp_tool.config.loader import _apply_env_overrides
+
+        with patch.dict(os.environ, {"MCP_SAFETY_MODE": "read-only"}):
+            result = _apply_env_overrides({})
+            assert result["safety"]["mode"] == "read-only"
+
+    def test_browser_enabled_override(self):
+        """Test MCP_BROWSER_ENABLED environment override."""
+        from kubectl_mcp_tool.config.loader import _apply_env_overrides
+
+        with patch.dict(os.environ, {"MCP_BROWSER_ENABLED": "true"}):
+            result = _apply_env_overrides({})
+            assert result["browser"]["enabled"] is True
+
+    def test_debug_override(self):
+        """Test MCP_DEBUG environment override."""
+        from kubectl_mcp_tool.config.loader import _apply_env_overrides
+
+        with patch.dict(os.environ, {"MCP_DEBUG": "1"}):
+            result = _apply_env_overrides({})
+            assert result["server"]["debug"] is True
+
+
+class TestLoadConfig:
+    """Test load_config function."""
+
+    def test_load_default_config(self):
+        """Test loading config with defaults."""
+        from kubectl_mcp_tool.config.loader import load_config
+
+        config = load_config(skip_env=True)
+        assert config.server.transport == "streamable-http"
+        assert config.server.port == 8000
+        assert config.safety.mode == "normal"
+
+    def test_load_from_file(self):
+        """Test loading config from TOML file."""
+        pytest.importorskip("tomli", reason="tomli required for TOML parsing")
+        from kubectl_mcp_tool.config.loader import load_config
+
+        with tempfile.NamedTemporaryFile(suffix=".toml", delete=False, mode="w") as f:
+            f.write("""
+[server]
+port = 9999
+debug = true
+
+[safety]
+mode = "read-only"
+""")
+            f.flush()
+
+            try:
+                config = load_config(config_file=f.name, skip_env=True)
+                assert config.server.port == 9999
+                assert config.server.debug is True
+                assert config.safety.mode == "read-only"
+            finally:
+                os.unlink(f.name)
+
+    def test_env_overrides_applied(self):
+        """Test environment overrides are applied."""
+        from kubectl_mcp_tool.config.loader import load_config
+
+        with patch.dict(os.environ, {"MCP_SERVER_PORT": "7777"}):
+            config = load_config()
+            assert config.server.port == 7777
+
+
+class TestGetConfig:
+    """Test get_config function."""
+
+    def test_get_config_singleton(self):
+        """Test get_config returns same instance."""
+        from kubectl_mcp_tool.config import loader
+
+        # Reset global config
+        loader._config = None
+
+        config1 = loader.get_config()
+        config2 = loader.get_config()
+        assert config1 is config2
+
+
+class TestReloadConfig:
+    """Test reload_config function."""
+
+    def test_reload_config(self):
+        """Test configuration reload."""
+        from kubectl_mcp_tool.config import loader
+
+        # Load initial config
+        loader._config = None
+        config1 = loader.load_config(skip_env=True)
+
+        # Reload
+        config2 = loader.reload_config()
+        assert config2 is not None
+        assert config2.server.port == config1.server.port
+
+    def test_reload_callback(self):
+        """Test reload callbacks are called."""
+        from kubectl_mcp_tool.config import loader
+
+        callback_called = []
+
+        def callback(config):
+            callback_called.append(config)
+
+        loader._config = None
+        loader.load_config(skip_env=True)
+        loader.register_reload_callback(callback)
+
+        try:
+            loader.reload_config()
+            assert len(callback_called) == 1
+        finally:
+            loader.unregister_reload_callback(callback)
+
+
+class TestSighupHandler:
+    """Test SIGHUP handler setup."""
+
+    def test_setup_sighup_handler(self):
+        """Test SIGHUP handler can be installed."""
+        import sys
+
+        from kubectl_mcp_tool.config.loader import setup_sighup_handler
+
+        if sys.platform == "win32":
+            result = setup_sighup_handler()
+            assert result is False
+        else:
+            result = setup_sighup_handler()
+            assert result is True
+
+
+class TestConfigDataclass:
+    """Test Config root dataclass."""
+
+    def test_config_has_all_sections(self):
+        """Test Config has all expected sections."""
+        from kubectl_mcp_tool.config.schema import Config
+
+        config = Config()
+        assert hasattr(config, "server")
+        assert hasattr(config, "safety")
+        assert hasattr(config, "browser")
+        assert hasattr(config, "metrics")
+        assert hasattr(config, "logging")
+        assert hasattr(config, "kubernetes")
+        assert hasattr(config, "custom")
+
+    def test_config_custom_section(self):
+        """Test Config custom section for unknown keys."""
+        from kubectl_mcp_tool.config.schema import Config
+
+        config = Config(custom={"my_plugin": {"setting": "value"}})
+        assert config.custom["my_plugin"]["setting"] == "value"

tests/test_mcp_integration.py

@@ -0,0 +1,251 @@
+"""Integration tests for MCP server with safety, observability, and config modules."""
+
+import pytest
+import os
+import tempfile
+from unittest.mock import patch, MagicMock
+
+
+class TestMCPServerIntegration:
+    """Test MCP server integration with safety, observability, and config modules."""
+
+    def test_import_mcp_server(self):
+        """Test that MCP server can be imported without errors."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        assert MCPServer is not None
+
+    def test_mcp_server_init_default(self):
+        """Test MCP server initialization with defaults."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.safety import SafetyMode, get_safety_mode, set_safety_mode
+
+        # Reset to normal mode
+        set_safety_mode(SafetyMode.NORMAL)
+
+        server = MCPServer("test-server")
+        assert server.name == "test-server"
+        assert get_safety_mode() == SafetyMode.NORMAL
+
+    def test_mcp_server_init_read_only(self):
+        """Test MCP server initialization with read-only mode."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.safety import SafetyMode, get_safety_mode, set_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        server = MCPServer("test-server", read_only=True)
+        assert server.name == "test-server"
+        assert get_safety_mode() == SafetyMode.READ_ONLY
+        assert server.non_destructive is True
+
+    def test_mcp_server_init_disable_destructive(self):
+        """Test MCP server initialization with disable-destructive mode."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.safety import SafetyMode, get_safety_mode, set_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        server = MCPServer("test-server", disable_destructive=True)
+        assert server.name == "test-server"
+        assert get_safety_mode() == SafetyMode.DISABLE_DESTRUCTIVE
+        assert server.non_destructive is True
+
+    def test_mcp_server_init_with_config_file(self):
+        """Test MCP server initialization with config file."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.safety import SafetyMode, set_safety_mode, get_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        # Create a temporary config file with valid transport
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.toml', delete=False) as f:
+            f.write("""
+[server]
+transport = "stdio"
+port = 9000
+
+[safety]
+mode = "read-only"
+""")
+            config_file = f.name
+
+        try:
+            server = MCPServer("test-server", config_file=config_file)
+            assert server.name == "test-server"
+            assert server.config is not None
+            # Config file sets read-only mode
+            assert get_safety_mode() == SafetyMode.READ_ONLY
+        finally:
+            os.unlink(config_file)
+
+    def test_mcp_server_has_stats_collector(self):
+        """Test MCP server has stats collector initialized."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.safety import SafetyMode, set_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        server = MCPServer("test-server")
+        assert server._stats is not None
+        # Can get stats
+        stats = server._stats.get_stats()
+        assert "uptime_seconds" in stats
+        assert "tool_calls_total" in stats
+
+    def test_mcp_server_reload_callback(self):
+        """Test MCP server registers reload callback."""
+        from kubectl_mcp_tool.mcp_server import MCPServer
+        from kubectl_mcp_tool.config import reload_config
+        from kubectl_mcp_tool.safety import SafetyMode, set_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        server = MCPServer("test-server")
+
+        # Reload config should not raise
+        # The callback is registered and will be called
+        try:
+            reload_config()
+        except Exception:
+            # Config files may not exist, which is fine
+            pass
+
+    def test_cli_parameters_read_only(self):
+        """Test CLI parameters for read-only mode."""
+        from kubectl_mcp_tool.safety import SafetyMode, set_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        # Verify the set_safety_mode works as expected
+        set_safety_mode(SafetyMode.READ_ONLY)
+        from kubectl_mcp_tool.safety import get_safety_mode
+        assert get_safety_mode() == SafetyMode.READ_ONLY
+
+    def test_cli_parameters_disable_destructive(self):
+        """Test CLI parameters for disable-destructive mode."""
+        from kubectl_mcp_tool.safety import SafetyMode, set_safety_mode, get_safety_mode
+
+        # Reset to normal mode first
+        set_safety_mode(SafetyMode.NORMAL)
+
+        set_safety_mode(SafetyMode.DISABLE_DESTRUCTIVE)
+        assert get_safety_mode() == SafetyMode.DISABLE_DESTRUCTIVE
+
+
+class TestMCPServerObservability:
+    """Test observability integration in MCP server."""
+
+    def test_stats_collector_integration(self):
+        """Test stats collector is available in MCP server."""
+        from kubectl_mcp_tool.observability import get_stats_collector
+
+        stats = get_stats_collector()
+        assert stats is not None
+
+        # Record some calls
+        stats.record_tool_call("integration_test_tool", success=True, duration=0.1)
+        tool_stats = stats.get_tool_stats("integration_test_tool")
+        assert tool_stats is not None
+        assert tool_stats["calls"] >= 1
+        assert tool_stats["errors"] == 0
+
+    def test_metrics_availability(self):
+        """Test Prometheus metrics availability check."""
+        from kubectl_mcp_tool.observability import is_prometheus_available, get_metrics
+
+        # Check availability (may or may not be installed)
+        available = is_prometheus_available()
+
+        if available:
+            metrics = get_metrics()
+            assert isinstance(metrics, str)
+
+
+class TestMCPServerConfig:
+    """Test config integration in MCP server."""
+
+    def test_load_config(self):
+        """Test config loading."""
+        from kubectl_mcp_tool.config import load_config
+
+        config = load_config()
+        assert config is not None
+        assert hasattr(config, 'server')
+        assert hasattr(config, 'safety')
+        assert hasattr(config, 'browser')
+
+    def test_config_reload_callbacks(self):
+        """Test config reload callback registration."""
+        from kubectl_mcp_tool.config import (
+            register_reload_callback,
+            unregister_reload_callback,
+        )
+
+        callback_called = []
+
+        def test_callback(config):
+            callback_called.append(config)
+
+        register_reload_callback(test_callback)
+
+        # Unregister to clean up
+        unregister_reload_callback(test_callback)
+
+        # Verify unregister worked
+        assert len(callback_called) == 0  # Not called since we unregistered
+
+
+class TestMCPServerSafety:
+    """Test safety mode integration in MCP server."""
+
+    def test_safety_mode_info(self):
+        """Test safety mode info retrieval."""
+        from kubectl_mcp_tool.safety import (
+            SafetyMode,
+            set_safety_mode,
+            get_mode_info,
+        )
+
+        set_safety_mode(SafetyMode.NORMAL)
+        info = get_mode_info()
+        assert info["mode"] == "normal"
+        assert "description" in info
+        assert info["blocked_operations"] == []
+
+        set_safety_mode(SafetyMode.READ_ONLY)
+        info = get_mode_info()
+        assert info["mode"] == "read_only"
+        assert len(info["blocked_operations"]) > 0
+
+    def test_operation_allowed_check(self):
+        """Test operation allowed check."""
+        from kubectl_mcp_tool.safety import (
+            SafetyMode,
+            set_safety_mode,
+            is_operation_allowed,
+        )
+
+        set_safety_mode(SafetyMode.NORMAL)
+        allowed, reason = is_operation_allowed("delete_pod")
+        assert allowed is True
+        assert reason == ""
+
+        set_safety_mode(SafetyMode.READ_ONLY)
+        allowed, reason = is_operation_allowed("delete_pod")
+        assert allowed is False
+        assert "blocked" in reason.lower()
+
+        set_safety_mode(SafetyMode.DISABLE_DESTRUCTIVE)
+        allowed, reason = is_operation_allowed("delete_pod")
+        assert allowed is False
+        assert "blocked" in reason.lower()
+
+        # Non-destructive write should be allowed
+        allowed, reason = is_operation_allowed("create_deployment")
+        assert allowed is True