hatch-xclam 0.7.0.dev12__py3-none-any.whl → 0.7.1__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)

tests/test_mcp_cli_all_host_specific_args.py

@@ -15,7 +15,7 @@ from hatch.cli_hatch import handle_mcp_configure, parse_input
 from hatch.mcp_host_config import MCPHostType
 from hatch.mcp_host_config.models import (
     MCPServerConfigGemini, MCPServerConfigCursor, MCPServerConfigVSCode,
-    MCPServerConfigClaude
+    MCPServerConfigClaude, MCPServerConfigCodex
 )
 
 
@@ -298,6 +298,199 @@ class TestToolFilteringArguments(unittest.TestCase):
         self.assertEqual(server_config.excludeTools, ['dangerous_tool'])
 
 
+class TestAllCodexArguments(unittest.TestCase):
+    """Test ALL Codex-specific CLI arguments."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_all_codex_arguments_accepted(self, mock_stdout, mock_manager_class):
+        """Test that all Codex arguments are accepted and passed to model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        # Test STDIO server with Codex-specific STDIO fields
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', '@upstash/context7-mcp'],
+            env_vars=['PATH', 'HOME'],
+            cwd='/workspace',
+            startup_timeout=15,
+            tool_timeout=120,
+            enabled=True,
+            include_tools=['read', 'write'],
+            exclude_tools=['delete'],
+            auto_approve=True
+        )
+
+        # Verify success
+        self.assertEqual(result, 0)
+
+        # Verify configure_server was called
+        mock_manager.configure_server.assert_called_once()
+
+        # Verify server_config is MCPServerConfigCodex
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigCodex)
+
+        # Verify Codex-specific STDIO fields
+        self.assertEqual(server_config.env_vars, ['PATH', 'HOME'])
+        self.assertEqual(server_config.cwd, '/workspace')
+        self.assertEqual(server_config.startup_timeout_sec, 15)
+        self.assertEqual(server_config.tool_timeout_sec, 120)
+        self.assertTrue(server_config.enabled)
+        self.assertEqual(server_config.enabled_tools, ['read', 'write'])
+        self.assertEqual(server_config.disabled_tools, ['delete'])
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_env_vars_list(self, mock_stdout, mock_manager_class):
+        """Test that env_vars accepts multiple values as a list."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            env_vars=['PATH', 'HOME', 'USER'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.env_vars, ['PATH', 'HOME', 'USER'])
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_env_header_parsing(self, mock_stdout, mock_manager_class):
+        """Test that env_header parses KEY=ENV_VAR format correctly."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            env_header=['X-API-Key=API_KEY', 'Authorization=AUTH_TOKEN'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.env_http_headers, {
+            'X-API-Key': 'API_KEY',
+            'Authorization': 'AUTH_TOKEN'
+        })
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_timeout_fields(self, mock_stdout, mock_manager_class):
+        """Test that timeout fields are passed as integers."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            startup_timeout=30,
+            tool_timeout=180,
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(server_config.startup_timeout_sec, 30)
+        self.assertEqual(server_config.tool_timeout_sec, 180)
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_enabled_flag(self, mock_stdout, mock_manager_class):
+        """Test that enabled flag works as boolean."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            enabled=True,
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertTrue(server_config.enabled)
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_codex_reuses_shared_arguments(self, mock_stdout, mock_manager_class):
+        """Test that Codex reuses shared arguments (cwd, include-tools, exclude-tools)."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='codex',
+            server_name='test-server',
+            command='npx',
+            args=['-y', 'package'],
+            cwd='/workspace',
+            include_tools=['tool1', 'tool2'],
+            exclude_tools=['tool3'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+
+        # Verify shared arguments work for Codex STDIO servers
+        self.assertEqual(server_config.cwd, '/workspace')
+        self.assertEqual(server_config.enabled_tools, ['tool1', 'tool2'])
+        self.assertEqual(server_config.disabled_tools, ['tool3'])
+
+
 if __name__ == '__main__':
     unittest.main()
 

tests/test_mcp_cli_direct_management.py

@@ -40,17 +40,19 @@ class TestMCPConfigureCommand(unittest.TestCase):
                     try:
                         result = main()
                         # If main() returns without SystemExit, check the handler was called
-                        # Updated to include ALL host-specific parameters
+                        # Updated to include ALL host-specific parameters (27 total)
                         mock_handler.assert_called_once_with(
                             'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                            None, None, None, None, False, None, None, None, None, None, None, False, False, False
+                            None, None, None, None, False, None, None, None, None, None, None,
+                            False, None, None, None, None, None, False, None, None, False, False, False
                         )
                     except SystemExit as e:
                         # If SystemExit is raised, it should be 0 (success) and handler should have been called
                         if e.code == 0:
                             mock_handler.assert_called_once_with(
                                 'claude-desktop', 'weather-server', 'python', ['weather.py'],
-                                None, None, None, None, False, None, None, None, None, None, None, False, False, False
+                                None, None, None, None, False, None, None, None, None, None, None,
+                                False, None, None, None, None, None, False, None, None, False, False, False
                             )
                         else:
                             self.fail(f"main() exited with code {e.code}, expected 0")
@@ -70,11 +72,12 @@ class TestMCPConfigureCommand(unittest.TestCase):
                 with patch('hatch.cli_hatch.handle_mcp_configure', return_value=0) as mock_handler:
                     try:
                         main()
-                        # Updated to include ALL host-specific parameters
+                        # Updated to include ALL host-specific parameters (27 total)
                         mock_handler.assert_called_once_with(
                             'cursor', 'file-server', None, None,
                             ['API_KEY=secret', 'DEBUG=true'], 'http://localhost:8080',
-                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None, True, True, True
+                            ['Authorization=Bearer token'], None, False, None, None, None, None, None, None,
+                            False, None, None, None, None, None, False, None, None, True, True, True
                         )
                     except SystemExit as e:
                         self.assertEqual(e.code, 0)