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

tests/regression/test_mcp_codex_model_validation.py

@@ -0,0 +1,117 @@
+"""
+Codex MCP Model Validation Tests
+
+Tests for MCPServerConfigCodex model validation including Codex-specific fields,
+Omni conversion, and registry integration.
+"""
+
+import unittest
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.models import (
+    MCPServerConfigCodex, MCPServerConfigOmni, MCPHostType, HOST_MODEL_REGISTRY
+)
+
+
+class TestCodexModelValidation(unittest.TestCase):
+    """Test suite for Codex model validation."""
+    
+    @regression_test
+    def test_codex_specific_fields_accepted(self):
+        """Test that Codex-specific fields are accepted in MCPServerConfigCodex."""
+        # Create model with Codex-specific fields
+        config = MCPServerConfigCodex(
+            command="npx",
+            args=["-y", "package"],
+            env={"API_KEY": "test"},
+            # Codex-specific fields
+            env_vars=["PATH", "HOME"],
+            cwd="/workspace",
+            startup_timeout_sec=10,
+            tool_timeout_sec=60,
+            enabled=True,
+            enabled_tools=["read", "write"],
+            disabled_tools=["delete"],
+            bearer_token_env_var="AUTH_TOKEN",
+            http_headers={"X-Custom": "value"},
+            env_http_headers={"X-Auth": "AUTH_VAR"}
+        )
+        
+        # Verify all fields are accessible
+        self.assertEqual(config.command, "npx")
+        self.assertEqual(config.env_vars, ["PATH", "HOME"])
+        self.assertEqual(config.cwd, "/workspace")
+        self.assertEqual(config.startup_timeout_sec, 10)
+        self.assertEqual(config.tool_timeout_sec, 60)
+        self.assertTrue(config.enabled)
+        self.assertEqual(config.enabled_tools, ["read", "write"])
+        self.assertEqual(config.disabled_tools, ["delete"])
+        self.assertEqual(config.bearer_token_env_var, "AUTH_TOKEN")
+        self.assertEqual(config.http_headers, {"X-Custom": "value"})
+        self.assertEqual(config.env_http_headers, {"X-Auth": "AUTH_VAR"})
+    
+    @regression_test
+    def test_codex_from_omni_conversion(self):
+        """Test MCPServerConfigCodex.from_omni() conversion."""
+        # Create Omni model with Codex-specific fields
+        omni = MCPServerConfigOmni(
+            command="npx",
+            args=["-y", "package"],
+            env={"API_KEY": "test"},
+            # Codex-specific fields
+            env_vars=["PATH"],
+            startup_timeout_sec=15,
+            tool_timeout_sec=90,
+            enabled=True,
+            enabled_tools=["read"],
+            disabled_tools=["write"],
+            bearer_token_env_var="TOKEN",
+            headers={"X-Test": "value"},  # Universal field (maps to http_headers in Codex)
+            env_http_headers={"X-Env": "VAR"},
+            # Non-Codex fields (should be excluded)
+            envFile="/path/to/env",  # VS Code specific
+            disabled=True  # Kiro specific
+        )
+        
+        # Convert to Codex model
+        codex = MCPServerConfigCodex.from_omni(omni)
+        
+        # Verify Codex fields transferred correctly
+        self.assertEqual(codex.command, "npx")
+        self.assertEqual(codex.env_vars, ["PATH"])
+        self.assertEqual(codex.startup_timeout_sec, 15)
+        self.assertEqual(codex.tool_timeout_sec, 90)
+        self.assertTrue(codex.enabled)
+        self.assertEqual(codex.enabled_tools, ["read"])
+        self.assertEqual(codex.disabled_tools, ["write"])
+        self.assertEqual(codex.bearer_token_env_var, "TOKEN")
+        self.assertEqual(codex.http_headers, {"X-Test": "value"})
+        self.assertEqual(codex.env_http_headers, {"X-Env": "VAR"})
+        
+        # Verify non-Codex fields excluded (should not have these attributes)
+        with self.assertRaises(AttributeError):
+            _ = codex.envFile
+        with self.assertRaises(AttributeError):
+            _ = codex.disabled
+    
+    @regression_test
+    def test_host_model_registry_contains_codex(self):
+        """Test that HOST_MODEL_REGISTRY contains Codex model."""
+        # Verify CODEX is in registry
+        self.assertIn(MCPHostType.CODEX, HOST_MODEL_REGISTRY)
+        
+        # Verify it maps to correct model class
+        self.assertEqual(
+            HOST_MODEL_REGISTRY[MCPHostType.CODEX],
+            MCPServerConfigCodex
+        )
+        
+        # Verify we can instantiate from registry
+        model_class = HOST_MODEL_REGISTRY[MCPHostType.CODEX]
+        instance = model_class(command="test")
+        self.assertIsInstance(instance, MCPServerConfigCodex)
+
+
+if __name__ == '__main__':
+    unittest.main()
+

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)