hatch-xclam 0.7.0.dev13__py3-none-any.whl → 0.7.1.dev1__py3-none-any.whl

tests/regression/test_mcp_kiro_model_validation.py

@@ -0,0 +1,116 @@
+"""
+Kiro MCP Model Validation Tests
+
+Tests for MCPServerConfigKiro Pydantic model behavior, field validation,
+and Kiro-specific field combinations.
+"""
+
+import unittest
+from typing import Optional, List
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.models import (
+    MCPServerConfigKiro,
+    MCPServerConfigOmni,
+    MCPHostType
+)
+
+
+class TestMCPServerConfigKiro(unittest.TestCase):
+    """Test suite for MCPServerConfigKiro model validation."""
+    
+    @regression_test
+    def test_kiro_model_with_disabled_field(self):
+        """Test Kiro model with disabled field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp", "-m", "default"],
+            disabled=True
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertTrue(config.disabled)
+        self.assertEqual(config.type, "stdio")  # Inferred
+    
+    @regression_test
+    def test_kiro_model_with_auto_approve_tools(self):
+        """Test Kiro model with autoApprove field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            autoApprove=["codebase-retrieval", "fetch"]
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertEqual(len(config.autoApprove), 2)
+        self.assertIn("codebase-retrieval", config.autoApprove)
+        self.assertIn("fetch", config.autoApprove)
+    
+    @regression_test
+    def test_kiro_model_with_disabled_tools(self):
+        """Test Kiro model with disabledTools field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="python",
+            disabledTools=["dangerous-tool", "risky-tool"]
+        )
+        
+        self.assertEqual(config.command, "python")
+        self.assertEqual(len(config.disabledTools), 2)
+        self.assertIn("dangerous-tool", config.disabledTools)
+    
+    @regression_test
+    def test_kiro_model_all_fields_combined(self):
+        """Test Kiro model with all Kiro-specific fields."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp"],
+            env={"DEBUG": "true"},
+            disabled=False,
+            autoApprove=["codebase-retrieval"],
+            disabledTools=["dangerous-tool"]
+        )
+        
+        # Verify all fields
+        self.assertEqual(config.command, "auggie")
+        self.assertFalse(config.disabled)
+        self.assertEqual(len(config.autoApprove), 1)
+        self.assertEqual(len(config.disabledTools), 1)
+        self.assertEqual(config.env["DEBUG"], "true")
+    
+    @regression_test
+    def test_kiro_model_minimal_configuration(self):
+        """Test Kiro model with minimal configuration."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie"
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertEqual(config.type, "stdio")  # Inferred
+        self.assertIsNone(config.disabled)
+        self.assertIsNone(config.autoApprove)
+        self.assertIsNone(config.disabledTools)
+    
+    @regression_test
+    def test_kiro_model_remote_server_with_kiro_fields(self):
+        """Test Kiro model with remote server and Kiro-specific fields."""
+        config = MCPServerConfigKiro(
+            name="kiro-remote",
+            url="https://api.example.com/mcp",
+            headers={"Authorization": "Bearer token"},
+            disabled=True,
+            autoApprove=["safe-tool"]
+        )
+        
+        self.assertEqual(config.url, "https://api.example.com/mcp")
+        self.assertTrue(config.disabled)
+        self.assertEqual(len(config.autoApprove), 1)
+        self.assertEqual(config.type, "sse")  # Inferred for remote
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/test_mcp_kiro_omni_conversion.py

@@ -0,0 +1,104 @@
+"""
+Kiro MCP Omni Conversion Tests
+
+Tests for conversion from MCPServerConfigOmni to MCPServerConfigKiro
+using the from_omni() method.
+"""
+
+import unittest
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.models import (
+    MCPServerConfigKiro,
+    MCPServerConfigOmni
+)
+
+
+class TestKiroFromOmniConversion(unittest.TestCase):
+    """Test suite for Kiro from_omni() conversion method."""
+    
+    @regression_test
+    def test_kiro_from_omni_with_supported_fields(self):
+        """Test Kiro from_omni with supported fields."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp", "-m", "default"],
+            disabled=True,
+            autoApprove=["codebase-retrieval", "fetch"],
+            disabledTools=["dangerous-tool"]
+        )
+        
+        # Convert to Kiro model
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify all supported fields transferred
+        self.assertEqual(kiro.name, "kiro-server")
+        self.assertEqual(kiro.command, "auggie")
+        self.assertEqual(len(kiro.args), 3)
+        self.assertTrue(kiro.disabled)
+        self.assertEqual(len(kiro.autoApprove), 2)
+        self.assertEqual(len(kiro.disabledTools), 1)
+    
+    @regression_test
+    def test_kiro_from_omni_with_unsupported_fields(self):
+        """Test Kiro from_omni excludes unsupported fields."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="python",
+            disabled=True,  # Kiro field
+            envFile=".env",  # VS Code field (unsupported by Kiro)
+            timeout=30000   # Gemini field (unsupported by Kiro)
+        )
+        
+        # Convert to Kiro model
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify Kiro fields transferred
+        self.assertEqual(kiro.command, "python")
+        self.assertTrue(kiro.disabled)
+        
+        # Verify unsupported fields NOT transferred
+        self.assertFalse(hasattr(kiro, 'envFile') and kiro.envFile is not None)
+        self.assertFalse(hasattr(kiro, 'timeout') and kiro.timeout is not None)
+    
+    @regression_test
+    def test_kiro_from_omni_exclude_unset_behavior(self):
+        """Test that from_omni respects exclude_unset=True."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="auggie"
+            # disabled, autoApprove, disabledTools not set
+        )
+        
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify unset fields remain None
+        self.assertIsNone(kiro.disabled)
+        self.assertIsNone(kiro.autoApprove)
+        self.assertIsNone(kiro.disabledTools)
+    
+    @regression_test
+    def test_kiro_from_omni_remote_server_conversion(self):
+        """Test Kiro from_omni with remote server configuration."""
+        omni = MCPServerConfigOmni(
+            name="kiro-remote",
+            url="https://api.example.com/mcp",
+            headers={"Authorization": "Bearer token"},
+            disabled=False,
+            autoApprove=["safe-tool"]
+        )
+        
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify remote server fields
+        self.assertEqual(kiro.url, "https://api.example.com/mcp")
+        self.assertEqual(kiro.headers["Authorization"], "Bearer token")
+        self.assertFalse(kiro.disabled)
+        self.assertEqual(len(kiro.autoApprove), 1)
+        self.assertEqual(kiro.type, "sse")  # Inferred for remote
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_data_utils.py

@@ -292,6 +292,25 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
         with open(config_path, 'r') as f:
             return json.load(f)
 
+    def load_kiro_mcp_config(self, config_type: str = "empty") -> Dict[str, Any]:
+        """Load Kiro-specific MCP configuration templates.
+        
+        Args:
+            config_type: Type of Kiro configuration to load
+                - "empty": Empty mcpServers configuration
+                - "with_server": Single server with all Kiro fields
+                - "complex": Multi-server with mixed configurations
+        
+        Returns:
+            Kiro MCP configuration dictionary
+        """
+        config_path = self.mcp_host_configs_dir / f"kiro_mcp_{config_type}.json"
+        if not config_path.exists():
+            self._create_kiro_mcp_config(config_type)
+
+        with open(config_path, 'r') as f:
+            return json.load(f)
+
     def _create_host_config_template(self, host_type: str, config_type: str):
         """Create host-specific configuration templates with inheritance patterns."""
         templates = {
@@ -364,6 +383,50 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
                         "args": ["server.py"]
                     }
                 }
+            },
+
+            # Kiro family templates
+            "kiro_simple": {
+                "mcpServers": {
+                    "test_server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    }
+                }
+            },
+            "kiro_with_server": {
+                "mcpServers": {
+                    "existing-server": {
+                        "command": "auggie",
+                        "args": ["--mcp", "-m", "default", "-w", "."],
+                        "env": {"DEBUG": "true"},
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval", "fetch"],
+                        "disabledTools": ["dangerous-tool"]
+                    }
+                }
+            },
+            "kiro_complex": {
+                "mcpServers": {
+                    "local-server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    },
+                    "remote-server": {
+                        "url": "https://api.example.com/mcp",
+                        "headers": {"Authorization": "Bearer token"},
+                        "disabled": True,
+                        "disabledTools": ["risky-tool"]
+                    }
+                },
+                "otherSettings": {
+                    "theme": "dark",
+                    "fontSize": 14
+                }
             }
         }
 
@@ -470,3 +533,48 @@ class MCPHostConfigTestDataLoader(TestDataLoader):
         config_path = self.mcp_host_configs_dir / f"mcp_server_{server_type}.json"
         with open(config_path, 'w') as f:
             json.dump(config, f, indent=2)
+
+    def _create_kiro_mcp_config(self, config_type: str):
+        """Create Kiro-specific MCP configuration templates."""
+        templates = {
+            "empty": {
+                "mcpServers": {}
+            },
+            "with_server": {
+                "mcpServers": {
+                    "existing-server": {
+                        "command": "auggie",
+                        "args": ["--mcp", "-m", "default", "-w", "."],
+                        "env": {"DEBUG": "true"},
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval", "fetch"],
+                        "disabledTools": ["dangerous-tool"]
+                    }
+                }
+            },
+            "complex": {
+                "mcpServers": {
+                    "local-server": {
+                        "command": "auggie",
+                        "args": ["--mcp"],
+                        "disabled": False,
+                        "autoApprove": ["codebase-retrieval"]
+                    },
+                    "remote-server": {
+                        "url": "https://api.example.com/mcp",
+                        "headers": {"Authorization": "Bearer token"},
+                        "disabled": True,
+                        "disabledTools": ["risky-tool"]
+                    }
+                },
+                "otherSettings": {
+                    "theme": "dark",
+                    "fontSize": 14
+                }
+            }
+        }
+        
+        config = templates.get(config_type, {"mcpServers": {}})
+        config_path = self.mcp_host_configs_dir / f"kiro_mcp_{config_type}.json"
+        with open(config_path, 'w') as f:
+            json.dump(config, f, indent=2)