hatch-xclam 0.7.0.dev12__py3-none-any.whl → 0.7.1__py3-none-any.whl

tests/integration/test_mcp_kiro_integration.py

@@ -0,0 +1,153 @@
+"""
+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()

tests/regression/__init__.py

@@ -0,0 +1,5 @@
+"""
+Regression tests for Hatch MCP functionality.
+
+These tests validate existing functionality to prevent breaking changes.
+"""

tests/regression/test_mcp_codex_backup_integration.py

@@ -0,0 +1,162 @@
+"""
+Codex MCP Backup Integration Tests
+
+Tests for Codex TOML backup integration including backup creation,
+restoration, and the no_backup parameter.
+"""
+
+import unittest
+import tempfile
+import tomllib
+from pathlib import Path
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.strategies import CodexHostStrategy
+from hatch.mcp_host_config.models import MCPServerConfig, HostConfiguration
+from hatch.mcp_host_config.backup import MCPHostConfigBackupManager, BackupInfo
+
+
+class TestCodexBackupIntegration(unittest.TestCase):
+    """Test suite for Codex backup integration."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.strategy = CodexHostStrategy()
+    
+    @regression_test
+    def test_write_configuration_creates_backup_by_default(self):
+        """Test that write_configuration creates backup by default when file exists."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create initial config
+            initial_toml = """[mcp_servers.old-server]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command',
+                    args=['--test']
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    # Create a real backup manager with custom backup dir
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration (should create backup)
+                    success = self.strategy.write_configuration(new_config, no_backup=False)
+                    self.assertTrue(success)
+                    
+                    # Verify backup was created
+                    backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                    self.assertGreater(len(backup_files), 0, "Backup file should be created")
+    
+    @regression_test
+    def test_write_configuration_skips_backup_when_requested(self):
+        """Test that write_configuration skips backup when no_backup=True."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create initial config
+            initial_toml = """[mcp_servers.old-server]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command'
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration with no_backup=True
+                    success = self.strategy.write_configuration(new_config, no_backup=True)
+                    self.assertTrue(success)
+                    
+                    # Verify no backup was created
+                    if backup_dir.exists():
+                        backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                        self.assertEqual(len(backup_files), 0, "No backup should be created when no_backup=True")
+    
+    @regression_test
+    def test_write_configuration_no_backup_for_new_file(self):
+        """Test that no backup is created when writing to a new file."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Don't create initial file - this is a new file
+            
+            # Create new configuration
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command'
+                )
+            })
+            
+            # Patch paths
+            from unittest.mock import patch
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as MockBackupManager:
+                    real_backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+                    MockBackupManager.return_value = real_backup_manager
+                    
+                    # Write configuration to new file
+                    success = self.strategy.write_configuration(new_config, no_backup=False)
+                    self.assertTrue(success)
+                    
+                    # Verify file was created
+                    self.assertTrue(config_path.exists())
+                    
+                    # Verify no backup was created (nothing to backup)
+                    if backup_dir.exists():
+                        backup_files = list(backup_dir.glob('codex/*.toml.*'))
+                        self.assertEqual(len(backup_files), 0, "No backup for new file")
+    
+    @regression_test
+    def test_codex_hostname_supported_in_backup_system(self):
+        """Test that 'codex' hostname is supported by the backup system."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            backup_dir = Path(tmpdir) / "backups"
+            
+            # Create a config file
+            config_path.write_text("[mcp_servers.test]\ncommand = 'test'\n")
+            
+            # Create backup manager
+            backup_manager = MCPHostConfigBackupManager(backup_root=backup_dir)
+            
+            # Create backup with 'codex' hostname - should not raise validation error
+            result = backup_manager.create_backup(config_path, 'codex')
+            
+            # Verify backup succeeded
+            self.assertTrue(result.success, "Backup with 'codex' hostname should succeed")
+            self.assertIsNotNone(result.backup_path)
+            
+            # Verify backup filename follows pattern
+            backup_filename = result.backup_path.name
+            self.assertTrue(backup_filename.startswith('config.toml.codex.'))
+
+
+if __name__ == '__main__':
+    unittest.main()
+

tests/regression/test_mcp_codex_host_strategy.py

@@ -0,0 +1,163 @@
+"""
+Codex MCP Host Strategy Tests
+
+Tests for CodexHostStrategy implementation including path resolution,
+configuration read/write, TOML handling, and host detection.
+"""
+
+import unittest
+import tempfile
+import tomllib
+from unittest.mock import patch, mock_open, MagicMock
+from pathlib import Path
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.strategies import CodexHostStrategy
+from hatch.mcp_host_config.models import MCPServerConfig, HostConfiguration
+
+# Import test data loader from local tests module
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from test_data_utils import MCPHostConfigTestDataLoader
+
+
+class TestCodexHostStrategy(unittest.TestCase):
+    """Test suite for CodexHostStrategy implementation."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.strategy = CodexHostStrategy()
+        self.test_data_loader = MCPHostConfigTestDataLoader()
+    
+    @regression_test
+    def test_codex_config_path_resolution(self):
+        """Test Codex configuration path resolution."""
+        config_path = self.strategy.get_config_path()
+        
+        # Verify path structure (use normalized path for cross-platform compatibility)
+        self.assertIsNotNone(config_path)
+        normalized_path = str(config_path).replace('\\', '/')
+        self.assertTrue(normalized_path.endswith('.codex/config.toml'))
+        self.assertEqual(config_path.name, 'config.toml')
+        self.assertEqual(config_path.suffix, '.toml')  # Verify TOML extension
+    
+    @regression_test
+    def test_codex_config_key(self):
+        """Test Codex configuration key."""
+        config_key = self.strategy.get_config_key()
+        # Codex uses underscore, not camelCase
+        self.assertEqual(config_key, "mcp_servers")
+        self.assertNotEqual(config_key, "mcpServers")  # Verify different from other hosts
+    
+    @regression_test
+    def test_codex_server_config_validation_stdio(self):
+        """Test Codex STDIO server configuration validation."""
+        # Test local server validation
+        local_config = MCPServerConfig(
+            command="npx",
+            args=["-y", "package"]
+        )
+        self.assertTrue(self.strategy.validate_server_config(local_config))
+    
+    @regression_test
+    def test_codex_server_config_validation_http(self):
+        """Test Codex HTTP server configuration validation."""
+        # Test remote server validation
+        remote_config = MCPServerConfig(
+            url="https://api.example.com/mcp"
+        )
+        self.assertTrue(self.strategy.validate_server_config(remote_config))
+    
+    @patch('pathlib.Path.exists')
+    @regression_test
+    def test_codex_host_availability_detection(self, mock_exists):
+        """Test Codex host availability detection."""
+        # Test when Codex directory exists
+        mock_exists.return_value = True
+        self.assertTrue(self.strategy.is_host_available())
+        
+        # Test when Codex directory doesn't exist
+        mock_exists.return_value = False
+        self.assertFalse(self.strategy.is_host_available())
+    
+    @regression_test
+    def test_codex_read_configuration_success(self):
+        """Test successful Codex TOML configuration reading."""
+        # Load test data
+        test_toml_path = Path(__file__).parent.parent / "test_data" / "codex" / "valid_config.toml"
+        
+        with patch.object(self.strategy, 'get_config_path', return_value=test_toml_path):
+            config = self.strategy.read_configuration()
+            
+            # Verify configuration was read
+            self.assertIsInstance(config, HostConfiguration)
+            self.assertIn('context7', config.servers)
+            
+            # Verify server details
+            server = config.servers['context7']
+            self.assertEqual(server.command, 'npx')
+            self.assertEqual(server.args, ['-y', '@upstash/context7-mcp'])
+            
+            # Verify nested env section was parsed correctly
+            self.assertIsNotNone(server.env)
+            self.assertEqual(server.env.get('MY_VAR'), 'value')
+    
+    @regression_test
+    def test_codex_read_configuration_file_not_exists(self):
+        """Test Codex configuration reading when file doesn't exist."""
+        non_existent_path = Path("/non/existent/path/config.toml")
+        
+        with patch.object(self.strategy, 'get_config_path', return_value=non_existent_path):
+            config = self.strategy.read_configuration()
+            
+            # Should return empty configuration without error
+            self.assertIsInstance(config, HostConfiguration)
+            self.assertEqual(len(config.servers), 0)
+    
+    @regression_test
+    def test_codex_write_configuration_preserves_features(self):
+        """Test that write_configuration preserves [features] section."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            config_path = Path(tmpdir) / "config.toml"
+            
+            # Create initial config with features section
+            initial_toml = """[features]
+rmcp_client = true
+
+[mcp_servers.existing]
+command = "old-command"
+"""
+            config_path.write_text(initial_toml)
+            
+            # Create new configuration to write
+            new_config = HostConfiguration(servers={
+                'new-server': MCPServerConfig(
+                    command='new-command',
+                    args=['--test']
+                )
+            })
+            
+            # Write configuration
+            with patch.object(self.strategy, 'get_config_path', return_value=config_path):
+                success = self.strategy.write_configuration(new_config, no_backup=True)
+                self.assertTrue(success)
+            
+            # Read back and verify features section preserved
+            with open(config_path, 'rb') as f:
+                result_data = tomllib.load(f)
+            
+            # Verify features section preserved
+            self.assertIn('features', result_data)
+            self.assertTrue(result_data['features'].get('rmcp_client'))
+            
+            # Verify new server added
+            self.assertIn('mcp_servers', result_data)
+            self.assertIn('new-server', result_data['mcp_servers'])
+            self.assertEqual(result_data['mcp_servers']['new-server']['command'], 'new-command')
+
+
+if __name__ == '__main__':
+    unittest.main()
+

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()
+