hatch-xclam 0.7.1.dev3__py3-none-any.whl → 0.8.0.dev1__py3-none-any.whl

tests/unit/mcp/test_adapter_protocol.py

@@ -0,0 +1,138 @@
+"""Unit tests for MCP Host Adapter protocol compliance.
+
+Test IDs: AP-01 to AP-06 (per 02-test_architecture_rebuild_v0.md)
+Scope: Verify all adapters satisfy BaseAdapter protocol contract.
+"""
+
+import unittest
+from typing import Dict, Any
+
+from hatch.mcp_host_config.models import MCPServerConfig, MCPHostType
+from hatch.mcp_host_config.adapters import (
+    get_adapter,
+    BaseAdapter,
+    ClaudeAdapter,
+    CodexAdapter,
+    CursorAdapter,
+    GeminiAdapter,
+    KiroAdapter,
+    LMStudioAdapter,
+    VSCodeAdapter,
+)
+
+
+# All adapter classes to test
+ALL_ADAPTERS = [
+    ClaudeAdapter,
+    CodexAdapter,
+    CursorAdapter,
+    GeminiAdapter,
+    KiroAdapter,
+    LMStudioAdapter,
+    VSCodeAdapter,
+]
+
+# Map host types to their expected adapter classes
+HOST_ADAPTER_MAP = {
+    MCPHostType.CLAUDE_DESKTOP: ClaudeAdapter,
+    MCPHostType.CLAUDE_CODE: ClaudeAdapter,
+    MCPHostType.CODEX: CodexAdapter,
+    MCPHostType.CURSOR: CursorAdapter,
+    MCPHostType.GEMINI: GeminiAdapter,
+    MCPHostType.KIRO: KiroAdapter,
+    MCPHostType.LMSTUDIO: LMStudioAdapter,
+    MCPHostType.VSCODE: VSCodeAdapter,
+}
+
+
+class TestAdapterProtocol(unittest.TestCase):
+    """Tests for adapter protocol compliance (AP-01 to AP-06)."""
+
+    def test_AP01_all_adapters_have_get_supported_fields(self):
+        """AP-01: All adapters have `get_supported_fields()` returning frozenset."""
+        for adapter_cls in ALL_ADAPTERS:
+            adapter = adapter_cls()
+            with self.subTest(adapter=adapter_cls.__name__):
+                self.assertTrue(
+                    hasattr(adapter, 'get_supported_fields'),
+                    f"{adapter_cls.__name__} missing 'get_supported_fields'"
+                )
+                self.assertTrue(
+                    callable(adapter.get_supported_fields),
+                    f"{adapter_cls.__name__}.get_supported_fields is not callable"
+                )
+                supported = adapter.get_supported_fields()
+                self.assertIsInstance(
+                    supported, frozenset,
+                    f"{adapter_cls.__name__}.get_supported_fields() did not return frozenset"
+                )
+
+    def test_AP02_all_adapters_have_validate(self):
+        """AP-02: All adapters have callable `validate()` method."""
+        for adapter_cls in ALL_ADAPTERS:
+            adapter = adapter_cls()
+            with self.subTest(adapter=adapter_cls.__name__):
+                self.assertTrue(
+                    hasattr(adapter, 'validate'),
+                    f"{adapter_cls.__name__} missing 'validate'"
+                )
+                self.assertTrue(
+                    callable(adapter.validate),
+                    f"{adapter_cls.__name__}.validate is not callable"
+                )
+
+    def test_AP03_all_adapters_have_serialize(self):
+        """AP-03: All adapters have callable `serialize()` method."""
+        for adapter_cls in ALL_ADAPTERS:
+            adapter = adapter_cls()
+            with self.subTest(adapter=adapter_cls.__name__):
+                self.assertTrue(
+                    hasattr(adapter, 'serialize'),
+                    f"{adapter_cls.__name__} missing 'serialize'"
+                )
+                self.assertTrue(
+                    callable(adapter.serialize),
+                    f"{adapter_cls.__name__}.serialize is not callable"
+                )
+
+    def test_AP04_serialize_never_returns_name(self):
+        """AP-04: `serialize()` never returns `name` field for any adapter."""
+        config = MCPServerConfig(name="test-server", command="python")
+        
+        for adapter_cls in ALL_ADAPTERS:
+            adapter = adapter_cls()
+            with self.subTest(adapter=adapter_cls.__name__):
+                result = adapter.serialize(config)
+                self.assertNotIn(
+                    "name", result,
+                    f"{adapter_cls.__name__}.serialize() returned 'name' field"
+                )
+
+    def test_AP05_serialize_never_returns_none_values(self):
+        """AP-05: `serialize()` returns no None values."""
+        config = MCPServerConfig(name="test-server", command="python")
+        
+        for adapter_cls in ALL_ADAPTERS:
+            adapter = adapter_cls()
+            with self.subTest(adapter=adapter_cls.__name__):
+                result = adapter.serialize(config)
+                for key, value in result.items():
+                    self.assertIsNotNone(
+                        value,
+                        f"{adapter_cls.__name__}.serialize() returned None for '{key}'"
+                    )
+
+    def test_AP06_get_adapter_returns_correct_type(self):
+        """AP-06: get_adapter() returns correct adapter for each host type."""
+        for host_type, expected_cls in HOST_ADAPTER_MAP.items():
+            with self.subTest(host=host_type.value):
+                adapter = get_adapter(host_type)
+                self.assertIsInstance(
+                    adapter, expected_cls,
+                    f"get_adapter({host_type}) returned {type(adapter)}, expected {expected_cls}"
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()
+

tests/unit/mcp/test_adapter_registry.py

@@ -0,0 +1,158 @@
+"""Unit tests for adapter registry.
+
+Test IDs: AR-01 to AR-08 (per 02-test_architecture_rebuild_v0.md)
+Scope: Registry initialization, adapter lookup, registration.
+"""
+
+import unittest
+
+from hatch.mcp_host_config.adapters import (
+    AdapterRegistry,
+    get_adapter,
+    get_default_registry,
+    BaseAdapter,
+    ClaudeAdapter,
+    CodexAdapter,
+    CursorAdapter,
+    GeminiAdapter,
+    KiroAdapter,
+    LMStudioAdapter,
+    VSCodeAdapter,
+)
+
+
+class TestAdapterRegistry(unittest.TestCase):
+    """Tests for AdapterRegistry class (AR-01 to AR-08)."""
+
+    def setUp(self):
+        """Create a fresh registry for each test."""
+        self.registry = AdapterRegistry()
+
+    def test_AR01_registry_has_all_default_hosts(self):
+        """AR-01: Registry initializes with all default host adapters."""
+        expected_hosts = {
+            "claude-desktop",
+            "claude-code",
+            "codex",
+            "cursor",
+            "gemini",
+            "kiro",
+            "lmstudio",
+            "vscode",
+        }
+        
+        actual_hosts = set(self.registry.get_supported_hosts())
+        
+        self.assertEqual(actual_hosts, expected_hosts)
+
+    def test_AR02_get_adapter_returns_correct_type(self):
+        """AR-02: get_adapter() returns adapter with matching host_name."""
+        test_cases = [
+            ("claude-desktop", ClaudeAdapter),
+            ("claude-code", ClaudeAdapter),
+            ("codex", CodexAdapter),
+            ("cursor", CursorAdapter),
+            ("gemini", GeminiAdapter),
+            ("kiro", KiroAdapter),
+            ("lmstudio", LMStudioAdapter),
+            ("vscode", VSCodeAdapter),
+        ]
+        
+        for host_name, expected_cls in test_cases:
+            with self.subTest(host=host_name):
+                adapter = self.registry.get_adapter(host_name)
+                self.assertIsInstance(adapter, expected_cls)
+                self.assertEqual(adapter.host_name, host_name)
+
+    def test_AR03_get_adapter_raises_for_unknown_host(self):
+        """AR-03: get_adapter() raises KeyError for unknown host."""
+        with self.assertRaises(KeyError) as context:
+            self.registry.get_adapter("unknown-host")
+        
+        self.assertIn("unknown-host", str(context.exception))
+        self.assertIn("Supported hosts", str(context.exception))
+
+    def test_AR04_has_adapter_returns_true_for_registered(self):
+        """AR-04: has_adapter() returns True for registered hosts."""
+        for host_name in self.registry.get_supported_hosts():
+            with self.subTest(host=host_name):
+                self.assertTrue(self.registry.has_adapter(host_name))
+
+    def test_AR05_has_adapter_returns_false_for_unknown(self):
+        """AR-05: has_adapter() returns False for unknown hosts."""
+        self.assertFalse(self.registry.has_adapter("unknown-host"))
+
+    def test_AR06_register_adds_new_adapter(self):
+        """AR-06: register() adds a new adapter to registry."""
+        # Create a custom adapter for testing
+        class CustomAdapter(BaseAdapter):
+            @property
+            def host_name(self):
+                return "custom-host"
+            
+            def get_supported_fields(self):
+                return frozenset({"command", "args"})
+            
+            def validate(self, config):
+                pass
+            
+            def serialize(self, config):
+                return {"command": config.command}
+        
+        custom = CustomAdapter()
+        self.registry.register(custom)
+        
+        self.assertTrue(self.registry.has_adapter("custom-host"))
+        self.assertIs(self.registry.get_adapter("custom-host"), custom)
+
+    def test_AR07_register_raises_for_duplicate(self):
+        """AR-07: register() raises ValueError for duplicate host name."""
+        # Try to register another Claude adapter
+        duplicate = ClaudeAdapter(variant="desktop")
+        
+        with self.assertRaises(ValueError) as context:
+            self.registry.register(duplicate)
+        
+        self.assertIn("claude-desktop", str(context.exception))
+        self.assertIn("already registered", str(context.exception))
+
+    def test_AR08_unregister_removes_adapter(self):
+        """AR-08: unregister() removes adapter from registry."""
+        self.assertTrue(self.registry.has_adapter("claude-desktop"))
+        
+        self.registry.unregister("claude-desktop")
+        
+        self.assertFalse(self.registry.has_adapter("claude-desktop"))
+
+    def test_unregister_raises_for_unknown(self):
+        """unregister() raises KeyError for unknown host."""
+        with self.assertRaises(KeyError):
+            self.registry.unregister("unknown-host")
+
+
+class TestGlobalRegistryFunctions(unittest.TestCase):
+    """Tests for global registry convenience functions."""
+
+    def test_get_default_registry_returns_singleton(self):
+        """get_default_registry() returns same instance on multiple calls."""
+        registry1 = get_default_registry()
+        registry2 = get_default_registry()
+        
+        self.assertIs(registry1, registry2)
+
+    def test_get_adapter_uses_default_registry(self):
+        """get_adapter() function uses the default registry."""
+        adapter = get_adapter("claude-desktop")
+        
+        self.assertIsInstance(adapter, ClaudeAdapter)
+        self.assertEqual(adapter.host_name, "claude-desktop")
+
+    def test_get_adapter_raises_for_unknown(self):
+        """get_adapter() function raises KeyError for unknown host."""
+        with self.assertRaises(KeyError):
+            get_adapter("unknown-host")
+
+
+if __name__ == "__main__":
+    unittest.main()
+

tests/unit/mcp/test_config_model.py

@@ -0,0 +1,146 @@
+"""Unit tests for MCPServerConfig unified model.
+
+Test IDs: UM-01 to UM-07 (per 02-test_architecture_rebuild_v0.md)
+Scope: Unified model validation, field defaults, transport configuration.
+"""
+
+import unittest
+from pydantic import ValidationError
+
+from hatch.mcp_host_config.models import MCPServerConfig
+
+
+class TestMCPServerConfig(unittest.TestCase):
+    """Tests for MCPServerConfig unified model (UM-01 to UM-07)."""
+
+    def test_UM01_valid_stdio_config(self):
+        """UM-01: Valid stdio config with command field."""
+        config = MCPServerConfig(name="test", command="python")
+        
+        self.assertEqual(config.command, "python")
+        self.assertTrue(config.is_local_server)
+        self.assertFalse(config.is_remote_server)
+
+    def test_UM02_valid_sse_config(self):
+        """UM-02: Valid SSE config with url field."""
+        config = MCPServerConfig(name="test", url="https://example.com/mcp")
+        
+        self.assertEqual(config.url, "https://example.com/mcp")
+        self.assertFalse(config.is_local_server)
+        self.assertTrue(config.is_remote_server)
+
+    def test_UM03_valid_http_config_gemini(self):
+        """UM-03: Valid HTTP config with httpUrl field (Gemini-style)."""
+        config = MCPServerConfig(name="test", httpUrl="https://example.com/http")
+        
+        self.assertEqual(config.httpUrl, "https://example.com/http")
+        # httpUrl is considered remote
+        self.assertTrue(config.is_remote_server)
+
+    def test_UM04_allows_command_and_url(self):
+        """UM-04: Unified model allows both command and url (adapters validate)."""
+        # The unified model is permissive - adapters enforce host-specific rules
+        config = MCPServerConfig(name="test", command="python", url="https://example.com")
+        
+        self.assertEqual(config.command, "python")
+        self.assertEqual(config.url, "https://example.com")
+
+    def test_UM05_reject_no_transport(self):
+        """UM-05: Reject config with no transport specified."""
+        with self.assertRaises(ValidationError) as context:
+            MCPServerConfig(name="test")
+        
+        self.assertIn("At least one transport must be specified", str(context.exception))
+
+    def test_UM06_accept_all_fields(self):
+        """UM-06: Accept config with many fields set."""
+        config = MCPServerConfig(
+            name="full-server",
+            command="python",
+            args=["-m", "server"],
+            env={"API_KEY": "secret"},
+            type="stdio",
+            cwd="/workspace",
+            timeout=30000,
+        )
+        
+        self.assertEqual(config.name, "full-server")
+        self.assertEqual(config.args, ["-m", "server"])
+        self.assertEqual(config.env, {"API_KEY": "secret"})
+        self.assertEqual(config.type, "stdio")
+        self.assertEqual(config.cwd, "/workspace")
+        self.assertEqual(config.timeout, 30000)
+
+    def test_UM07_extra_fields_allowed(self):
+        """UM-07: Extra/unknown fields are allowed (extra='allow')."""
+        # Create config with extra fields via model_construct to bypass validation
+        config = MCPServerConfig.model_construct(
+            name="test",
+            command="python",
+            unknown_field="value"
+        )
+        
+        # The model should allow extra fields
+        self.assertEqual(config.command, "python")
+
+    def test_url_format_validation(self):
+        """Test URL format validation - must start with http:// or https://."""
+        with self.assertRaises(ValidationError) as context:
+            MCPServerConfig(name="test", url="ftp://example.com")
+        
+        self.assertIn("URL must start with http:// or https://", str(context.exception))
+
+    def test_command_whitespace_stripped(self):
+        """Test command field strips leading/trailing whitespace."""
+        config = MCPServerConfig(name="test", command="  python  ")
+        
+        self.assertEqual(config.command, "python")
+
+    def test_command_empty_rejected(self):
+        """Test empty command (after stripping) is rejected."""
+        with self.assertRaises(ValidationError):
+            MCPServerConfig(name="test", command="   ")
+
+    def test_serialization_roundtrip(self):
+        """Test JSON serialization roundtrip."""
+        config = MCPServerConfig(
+            name="roundtrip-test",
+            command="python",
+            args=["server.py"],
+            env={"KEY": "value"},
+        )
+        
+        # Serialize to dict
+        data = config.model_dump(exclude_none=True)
+        
+        # Reconstruct from dict
+        reconstructed = MCPServerConfig.model_validate(data)
+        
+        self.assertEqual(reconstructed.name, config.name)
+        self.assertEqual(reconstructed.command, config.command)
+        self.assertEqual(reconstructed.args, config.args)
+        self.assertEqual(reconstructed.env, config.env)
+
+
+class TestMCPServerConfigProperties(unittest.TestCase):
+    """Tests for MCPServerConfig computed properties."""
+
+    def test_is_local_server_with_command(self):
+        """Local server detection with command."""
+        config = MCPServerConfig(name="test", command="python")
+        self.assertTrue(config.is_local_server)
+
+    def test_is_remote_server_with_url(self):
+        """Remote server detection with url."""
+        config = MCPServerConfig(name="test", url="https://example.com")
+        self.assertTrue(config.is_remote_server)
+
+    def test_is_remote_server_with_httpUrl(self):
+        """Remote server detection with httpUrl."""
+        config = MCPServerConfig(name="test", httpUrl="https://example.com/http")
+        self.assertTrue(config.is_remote_server)
+
+
+if __name__ == "__main__":
+    unittest.main()
+

hatch_xclam-0.7.1.dev3.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-hatch = hatch.cli_hatch:main

tests/integration/test_mcp_kiro_integration.py

@@ -1,153 +0,0 @@
-"""
-Kiro MCP Integration Tests
-
-End-to-end integration tests combining CLI, model conversion, and strategy operations.
-"""
-
-import unittest
-from unittest.mock import patch, MagicMock
-
-from wobble.decorators import integration_test
-
-from hatch.cli_hatch import handle_mcp_configure
-from hatch.mcp_host_config.models import (
-    HOST_MODEL_REGISTRY,
-    MCPHostType,
-    MCPServerConfigKiro
-)
-
-
-class TestKiroIntegration(unittest.TestCase):
-    """Test suite for end-to-end Kiro integration."""
-    
-    @integration_test(scope="component")
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    def test_kiro_end_to_end_configuration(self, mock_manager_class):
-        """Test complete Kiro configuration workflow."""
-        # Setup mocks
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-        
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_manager.configure_server.return_value = mock_result
-        
-        # Execute CLI command with Kiro-specific arguments
-        result = handle_mcp_configure(
-            host='kiro',
-            server_name='augment-server',
-            command='auggie',
-            args=['--mcp', '-m', 'default'],
-            disabled=False,
-            auto_approve_tools=['codebase-retrieval', 'fetch'],
-            disable_tools=['dangerous-tool'],
-            auto_approve=True
-        )
-        
-        # Verify success
-        self.assertEqual(result, 0)
-        
-        # Verify configuration manager was called
-        mock_manager.configure_server.assert_called_once()
-        
-        # Verify server configuration
-        call_args = mock_manager.configure_server.call_args
-        server_config = call_args.kwargs['server_config']
-        
-        # Verify all Kiro-specific fields
-        self.assertFalse(server_config.disabled)
-        self.assertEqual(len(server_config.autoApprove), 2)
-        self.assertEqual(len(server_config.disabledTools), 1)
-        self.assertIn('codebase-retrieval', server_config.autoApprove)
-        self.assertIn('dangerous-tool', server_config.disabledTools)
-    
-    @integration_test(scope="system")
-    def test_kiro_host_model_registry_integration(self):
-        """Test Kiro integration with HOST_MODEL_REGISTRY."""
-        # Verify Kiro is in registry
-        self.assertIn(MCPHostType.KIRO, HOST_MODEL_REGISTRY)
-        
-        # Verify correct model class
-        model_class = HOST_MODEL_REGISTRY[MCPHostType.KIRO]
-        self.assertEqual(model_class.__name__, "MCPServerConfigKiro")
-        
-        # Test model instantiation
-        model_instance = model_class(
-            name="test-server",
-            command="auggie",
-            disabled=True
-        )
-        self.assertTrue(model_instance.disabled)
-    
-    @integration_test(scope="component")
-    def test_kiro_model_to_strategy_workflow(self):
-        """Test workflow from model creation to strategy operations."""
-        # Import to trigger registration
-        import hatch.mcp_host_config.strategies
-        from hatch.mcp_host_config.host_management import MCPHostRegistry
-        
-        # Create Kiro model
-        kiro_model = MCPServerConfigKiro(
-            name="workflow-test",
-            command="auggie",
-            args=["--mcp"],
-            disabled=False,
-            autoApprove=["codebase-retrieval"]
-        )
-        
-        # Get Kiro strategy
-        strategy = MCPHostRegistry.get_strategy(MCPHostType.KIRO)
-        
-        # Verify strategy can validate the model
-        self.assertTrue(strategy.validate_server_config(kiro_model))
-        
-        # Verify model fields are accessible
-        self.assertEqual(kiro_model.command, "auggie")
-        self.assertFalse(kiro_model.disabled)
-        self.assertIn("codebase-retrieval", kiro_model.autoApprove)
-    
-    @integration_test(scope="end_to_end")
-    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
-    def test_kiro_complete_lifecycle(self, mock_manager_class):
-        """Test complete Kiro server lifecycle: create, configure, validate."""
-        # Setup mocks
-        mock_manager = MagicMock()
-        mock_manager_class.return_value = mock_manager
-        
-        mock_result = MagicMock()
-        mock_result.success = True
-        mock_manager.configure_server.return_value = mock_result
-        
-        # Step 1: Configure server via CLI
-        result = handle_mcp_configure(
-            host='kiro',
-            server_name='lifecycle-test',
-            command='auggie',
-            args=['--mcp', '-w', '.'],
-            disabled=False,
-            auto_approve_tools=['codebase-retrieval'],
-            auto_approve=True
-        )
-        
-        # Verify CLI success
-        self.assertEqual(result, 0)
-        
-        # Step 2: Verify configuration manager interaction
-        mock_manager.configure_server.assert_called_once()
-        call_args = mock_manager.configure_server.call_args
-        
-        # Step 3: Verify server configuration structure
-        server_config = call_args.kwargs['server_config']
-        self.assertEqual(server_config.name, 'lifecycle-test')
-        self.assertEqual(server_config.command, 'auggie')
-        self.assertIn('--mcp', server_config.args)
-        self.assertIn('-w', server_config.args)
-        self.assertFalse(server_config.disabled)
-        self.assertIn('codebase-retrieval', server_config.autoApprove)
-        
-        # Step 4: Verify model type
-        self.assertIsInstance(server_config, MCPServerConfigKiro)
-
-
-if __name__ == '__main__':
-    unittest.main()