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

tests/regression/test_mcp_codex_backup_integration.py

@@ -1,162 +0,0 @@
-"""
-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

@@ -1,163 +0,0 @@
-"""
-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

@@ -1,117 +0,0 @@
-"""
-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/regression/test_mcp_kiro_backup_integration.py

@@ -1,241 +0,0 @@
-"""Tests for Kiro MCP backup integration.
-
-This module tests the integration between KiroHostStrategy and the backup system,
-ensuring that Kiro configurations are properly backed up during write operations.
-"""
-
-import json
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-from wobble.decorators import regression_test
-
-from hatch.mcp_host_config.strategies import KiroHostStrategy
-from hatch.mcp_host_config.models import HostConfiguration, MCPServerConfig
-from hatch.mcp_host_config.backup import MCPHostConfigBackupManager, BackupResult
-
-
-class TestKiroBackupIntegration(unittest.TestCase):
-    """Test Kiro backup integration with host strategy."""
-    
-    def setUp(self):
-        """Set up test environment."""
-        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_kiro_backup_"))
-        self.config_dir = self.temp_dir / ".kiro" / "settings"
-        self.config_dir.mkdir(parents=True)
-        self.config_file = self.config_dir / "mcp.json"
-        
-        self.backup_dir = self.temp_dir / "backups"
-        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.backup_dir)
-        
-        self.strategy = KiroHostStrategy()
-    
-    def tearDown(self):
-        """Clean up test environment."""
-        import shutil
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
-    @regression_test
-    def test_write_configuration_creates_backup_by_default(self):
-        """Test that write_configuration creates backup by default when file exists."""
-        # Create initial configuration
-        initial_config = {
-            "mcpServers": {
-                "existing-server": {
-                    "command": "uvx",
-                    "args": ["existing-package"]
-                }
-            },
-            "otherSettings": {
-                "theme": "dark"
-            }
-        }
-        
-        with open(self.config_file, 'w') as f:
-            json.dump(initial_config, f, indent=2)
-        
-        # Create new configuration to write
-        server_config = MCPServerConfig(
-            command="uvx",
-            args=["new-package"]
-        )
-        host_config = HostConfiguration(servers={"new-server": server_config})
-        
-        # Mock the strategy's get_config_path to return our test file
-        # Mock the backup manager creation to use our test backup manager
-        with patch.object(self.strategy, 'get_config_path', return_value=self.config_file), \
-             patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager', return_value=self.backup_manager):
-            # Write configuration (should create backup)
-            result = self.strategy.write_configuration(host_config, no_backup=False)
-        
-        # Verify write succeeded
-        self.assertTrue(result)
-        
-        # Verify backup was created
-        backups = self.backup_manager.list_backups("kiro")
-        self.assertEqual(len(backups), 1)
-        
-        # Verify backup contains original content
-        backup_content = json.loads(backups[0].file_path.read_text())
-        self.assertEqual(backup_content, initial_config)
-        
-        # Verify new configuration was written
-        new_content = json.loads(self.config_file.read_text())
-        self.assertIn("new-server", new_content["mcpServers"])
-        self.assertEqual(new_content["otherSettings"], {"theme": "dark"})  # Preserved
-    
-    @regression_test
-    def test_write_configuration_skips_backup_when_requested(self):
-        """Test that write_configuration skips backup when no_backup=True."""
-        # Create initial configuration
-        initial_config = {
-            "mcpServers": {
-                "existing-server": {
-                    "command": "uvx",
-                    "args": ["existing-package"]
-                }
-            }
-        }
-        
-        with open(self.config_file, 'w') as f:
-            json.dump(initial_config, f, indent=2)
-        
-        # Create new configuration to write
-        server_config = MCPServerConfig(
-            command="uvx",
-            args=["new-package"]
-        )
-        host_config = HostConfiguration(servers={"new-server": server_config})
-        
-        # Mock the strategy's get_config_path to return our test file
-        # Mock the backup manager creation to use our test backup manager
-        with patch.object(self.strategy, 'get_config_path', return_value=self.config_file), \
-             patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager', return_value=self.backup_manager):
-            # Write configuration with no_backup=True
-            result = self.strategy.write_configuration(host_config, no_backup=True)
-        
-        # Verify write succeeded
-        self.assertTrue(result)
-        
-        # Verify no backup was created
-        backups = self.backup_manager.list_backups("kiro")
-        self.assertEqual(len(backups), 0)
-        
-        # Verify new configuration was written
-        new_content = json.loads(self.config_file.read_text())
-        self.assertIn("new-server", new_content["mcpServers"])
-    
-    @regression_test
-    def test_write_configuration_no_backup_for_new_file(self):
-        """Test that no backup is created when writing to a new file."""
-        # Ensure config file doesn't exist
-        self.assertFalse(self.config_file.exists())
-        
-        # Create configuration to write
-        server_config = MCPServerConfig(
-            command="uvx",
-            args=["new-package"]
-        )
-        host_config = HostConfiguration(servers={"new-server": server_config})
-        
-        # Mock the strategy's get_config_path to return our test file
-        # Mock the backup manager creation to use our test backup manager
-        with patch.object(self.strategy, 'get_config_path', return_value=self.config_file), \
-             patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager', return_value=self.backup_manager):
-            # Write configuration
-            result = self.strategy.write_configuration(host_config, no_backup=False)
-        
-        # Verify write succeeded
-        self.assertTrue(result)
-        
-        # Verify no backup was created (file didn't exist)
-        backups = self.backup_manager.list_backups("kiro")
-        self.assertEqual(len(backups), 0)
-        
-        # Verify configuration was written
-        self.assertTrue(self.config_file.exists())
-        new_content = json.loads(self.config_file.read_text())
-        self.assertIn("new-server", new_content["mcpServers"])
-    
-    @regression_test
-    def test_backup_failure_prevents_write(self):
-        """Test that backup failure prevents configuration write."""
-        # Create initial configuration
-        initial_config = {
-            "mcpServers": {
-                "existing-server": {
-                    "command": "uvx",
-                    "args": ["existing-package"]
-                }
-            }
-        }
-        
-        with open(self.config_file, 'w') as f:
-            json.dump(initial_config, f, indent=2)
-        
-        # Create new configuration to write
-        server_config = MCPServerConfig(
-            command="uvx",
-            args=["new-package"]
-        )
-        host_config = HostConfiguration(servers={"new-server": server_config})
-        
-        # Mock backup manager to fail
-        with patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager') as mock_backup_class:
-            mock_backup_manager = MagicMock()
-            mock_backup_manager.create_backup.return_value = BackupResult(
-                success=False,
-                error_message="Backup failed"
-            )
-            mock_backup_class.return_value = mock_backup_manager
-            
-            # Mock the strategy's get_config_path to return our test file
-            with patch.object(self.strategy, 'get_config_path', return_value=self.config_file):
-                # Write configuration (should fail due to backup failure)
-                result = self.strategy.write_configuration(host_config, no_backup=False)
-        
-        # Verify write failed
-        self.assertFalse(result)
-        
-        # Verify original configuration is unchanged
-        current_content = json.loads(self.config_file.read_text())
-        self.assertEqual(current_content, initial_config)
-    
-    @regression_test
-    def test_kiro_hostname_supported_in_backup_system(self):
-        """Test that 'kiro' hostname is supported by the backup system."""
-        # Create test configuration file
-        test_config = {
-            "mcpServers": {
-                "test-server": {
-                    "command": "uvx",
-                    "args": ["test-package"]
-                }
-            }
-        }
-        
-        with open(self.config_file, 'w') as f:
-            json.dump(test_config, f, indent=2)
-        
-        # Test backup creation with 'kiro' hostname
-        result = self.backup_manager.create_backup(self.config_file, "kiro")
-        
-        # Verify backup succeeded
-        self.assertTrue(result.success)
-        self.assertIsNotNone(result.backup_path)
-        self.assertTrue(result.backup_path.exists())
-        
-        # Verify backup filename format
-        expected_pattern = r"mcp\.json\.kiro\.\d{8}_\d{6}_\d{6}"
-        import re
-        self.assertRegex(result.backup_path.name, expected_pattern)
-        
-        # Verify backup content
-        backup_content = json.loads(result.backup_path.read_text())
-        self.assertEqual(backup_content, test_config)
-
-
-if __name__ == '__main__':
-    unittest.main()