hatch-xclam 0.7.0__py3-none-any.whl

tests/test_mcp_host_config_backup.py

@@ -0,0 +1,257 @@
+"""Tests for MCPHostConfigBackupManager.
+
+This module contains tests for the MCP host configuration backup functionality,
+including backup creation, restoration, and management with host-agnostic design.
+"""
+
+import unittest
+import tempfile
+import shutil
+import json
+from pathlib import Path
+from datetime import datetime
+from unittest.mock import patch, Mock
+
+from wobble.decorators import regression_test, integration_test, slow_test
+from test_data_utils import MCPBackupTestDataLoader
+
+from hatch.mcp_host_config.backup import (
+    MCPHostConfigBackupManager, 
+    BackupInfo, 
+    BackupResult,
+    BackupError
+)
+
+
+class TestMCPHostConfigBackupManager(unittest.TestCase):
+    """Test MCPHostConfigBackupManager core functionality with host-agnostic design."""
+    
+    def setUp(self):
+        """Set up test environment with host-agnostic configurations."""
+        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_mcp_backup_"))
+        self.backup_root = self.temp_dir / "backups"
+        self.config_dir = self.temp_dir / "configs"
+        self.config_dir.mkdir(parents=True)
+        
+        # Initialize test data loader
+        self.test_data = MCPBackupTestDataLoader()
+        
+        # Create host-agnostic test configuration files
+        self.test_configs = {}
+        for hostname in ['claude-desktop', 'vscode', 'cursor', 'lmstudio']:
+            config_data = self.test_data.load_host_agnostic_config("simple_server")
+            config_file = self.config_dir / f"{hostname}_config.json"
+            with open(config_file, 'w') as f:
+                json.dump(config_data, f, indent=2)
+            self.test_configs[hostname] = config_file
+        
+        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.backup_root)
+    
+    def tearDown(self):
+        """Clean up test environment."""
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+    
+    @regression_test
+    def test_backup_directory_creation(self):
+        """Test automatic backup directory creation."""
+        self.assertTrue(self.backup_root.exists())
+        self.assertTrue(self.backup_root.is_dir())
+    
+    @regression_test
+    def test_create_backup_success_all_hosts(self):
+        """Test successful backup creation for all supported host types."""
+        for hostname, config_file in self.test_configs.items():
+            with self.subTest(hostname=hostname):
+                result = self.backup_manager.create_backup(config_file, hostname)
+                
+                # Validate BackupResult Pydantic model
+                self.assertIsInstance(result, BackupResult)
+                self.assertTrue(result.success)
+                self.assertIsNotNone(result.backup_path)
+                self.assertTrue(result.backup_path.exists())
+                self.assertGreater(result.backup_size, 0)
+                self.assertEqual(result.original_size, result.backup_size)
+                
+                # Verify backup filename format (host-agnostic)
+                expected_pattern = rf"mcp\.json\.{hostname}\.\d{{8}}_\d{{6}}_\d{{6}}"
+                self.assertRegex(result.backup_path.name, expected_pattern)
+    
+    @regression_test
+    def test_create_backup_nonexistent_file(self):
+        """Test backup creation with nonexistent source file."""
+        nonexistent = self.config_dir / "nonexistent.json"
+        result = self.backup_manager.create_backup(nonexistent, "claude-desktop")
+        
+        self.assertFalse(result.success)
+        self.assertIsNotNone(result.error_message)
+        self.assertIn("not found", result.error_message.lower())
+    
+    @regression_test
+    def test_backup_content_integrity_host_agnostic(self):
+        """Test backup content matches original for any host configuration format."""
+        hostname = 'claude-desktop'
+        config_file = self.test_configs[hostname]
+        original_content = config_file.read_text()
+        
+        result = self.backup_manager.create_backup(config_file, hostname)
+        
+        self.assertTrue(result.success)
+        backup_content = result.backup_path.read_text()
+        self.assertEqual(original_content, backup_content)
+        
+        # Verify JSON structure is preserved (host-agnostic validation)
+        original_json = json.loads(original_content)
+        backup_json = json.loads(backup_content)
+        self.assertEqual(original_json, backup_json)
+    
+    @regression_test
+    def test_multiple_backups_same_host(self):
+        """Test creating multiple backups for same host."""
+        hostname = 'vscode'
+        config_file = self.test_configs[hostname]
+        
+        # Create first backup
+        result1 = self.backup_manager.create_backup(config_file, hostname)
+        self.assertTrue(result1.success)
+        
+        # Modify config and create second backup
+        modified_config = self.test_data.load_host_agnostic_config("complex_server")
+        with open(config_file, 'w') as f:
+            json.dump(modified_config, f, indent=2)
+        
+        result2 = self.backup_manager.create_backup(config_file, hostname)
+        self.assertTrue(result2.success)
+        
+        # Verify both backups exist and are different
+        self.assertTrue(result1.backup_path.exists())
+        self.assertTrue(result2.backup_path.exists())
+        self.assertNotEqual(result1.backup_path, result2.backup_path)
+    
+    @regression_test
+    def test_list_backups_empty(self):
+        """Test listing backups when none exist."""
+        backups = self.backup_manager.list_backups("claude-desktop")
+        self.assertEqual(len(backups), 0)
+    
+    @regression_test
+    def test_list_backups_pydantic_validation(self):
+        """Test listing backups returns valid Pydantic models."""
+        hostname = 'cursor'
+        config_file = self.test_configs[hostname]
+        
+        # Create multiple backups
+        self.backup_manager.create_backup(config_file, hostname)
+        self.backup_manager.create_backup(config_file, hostname)
+        
+        backups = self.backup_manager.list_backups(hostname)
+        self.assertEqual(len(backups), 2)
+        
+        # Verify BackupInfo Pydantic model validation
+        for backup in backups:
+            self.assertIsInstance(backup, BackupInfo)
+            self.assertEqual(backup.hostname, hostname)
+            self.assertIsInstance(backup.timestamp, datetime)
+            self.assertTrue(backup.file_path.exists())
+            self.assertGreater(backup.file_size, 0)
+            
+            # Test Pydantic serialization
+            backup_dict = backup.dict()
+            self.assertIn('hostname', backup_dict)
+            self.assertIn('timestamp', backup_dict)
+            
+            # Test JSON serialization
+            backup_json = backup.json()
+            self.assertIsInstance(backup_json, str)
+        
+        # Verify sorting (newest first)
+        self.assertGreaterEqual(backups[0].timestamp, backups[1].timestamp)
+    
+    @regression_test
+    def test_backup_validation_unsupported_hostname(self):
+        """Test Pydantic validation rejects unsupported hostnames."""
+        config_file = self.test_configs['claude-desktop']
+        
+        # Test with unsupported hostname
+        result = self.backup_manager.create_backup(config_file, 'unsupported-host')
+        
+        self.assertFalse(result.success)
+        self.assertIn('unsupported', result.error_message.lower())
+    
+    @regression_test
+    def test_multiple_hosts_isolation(self):
+        """Test backup isolation between different host types."""
+        # Create backups for multiple hosts
+        results = {}
+        for hostname, config_file in self.test_configs.items():
+            results[hostname] = self.backup_manager.create_backup(config_file, hostname)
+            self.assertTrue(results[hostname].success)
+        
+        # Verify separate backup directories
+        for hostname in self.test_configs.keys():
+            backups = self.backup_manager.list_backups(hostname)
+            self.assertEqual(len(backups), 1)
+            
+            # Verify backup isolation (different directories)
+            backup_dir = backups[0].file_path.parent
+            self.assertEqual(backup_dir.name, hostname)
+            
+            # Verify no cross-contamination
+            for other_hostname in self.test_configs.keys():
+                if other_hostname != hostname:
+                    other_backups = self.backup_manager.list_backups(other_hostname)
+                    self.assertNotEqual(
+                        backups[0].file_path.parent,
+                        other_backups[0].file_path.parent
+                    )
+    
+    @regression_test
+    def test_clean_backups_older_than_days(self):
+        """Test cleaning backups older than specified days."""
+        hostname = 'lmstudio'
+        config_file = self.test_configs[hostname]
+        
+        # Create backup
+        result = self.backup_manager.create_backup(config_file, hostname)
+        self.assertTrue(result.success)
+        
+        # Mock old backup by modifying timestamp
+        old_backup_path = result.backup_path.parent / "mcp.json.lmstudio.20200101_120000_000000"
+        shutil.copy2(result.backup_path, old_backup_path)
+        
+        # Clean backups older than 1 day (should remove the old one)
+        cleaned_count = self.backup_manager.clean_backups(hostname, older_than_days=1)
+        
+        # Verify old backup was cleaned
+        self.assertGreater(cleaned_count, 0)
+        self.assertFalse(old_backup_path.exists())
+        self.assertTrue(result.backup_path.exists())  # Recent backup should remain
+    
+    @regression_test
+    def test_clean_backups_keep_count(self):
+        """Test cleaning backups to keep only specified count."""
+        hostname = 'claude-desktop'
+        config_file = self.test_configs[hostname]
+        
+        # Create multiple backups
+        for i in range(5):
+            self.backup_manager.create_backup(config_file, hostname)
+        
+        # Verify 5 backups exist
+        backups_before = self.backup_manager.list_backups(hostname)
+        self.assertEqual(len(backups_before), 5)
+        
+        # Clean to keep only 2 backups
+        cleaned_count = self.backup_manager.clean_backups(hostname, keep_count=2)
+        
+        # Verify only 2 backups remain
+        backups_after = self.backup_manager.list_backups(hostname)
+        self.assertEqual(len(backups_after), 2)
+        self.assertEqual(cleaned_count, 3)
+        
+        # Verify newest backups were kept
+        for backup in backups_after:
+            self.assertIn(backup, backups_before[:2])  # Should be the first 2 (newest)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_mcp_host_configuration_manager.py

@@ -0,0 +1,331 @@
+"""
+Test suite for MCP host configuration manager.
+
+This module tests the core configuration manager with consolidated models
+and integration with backup system.
+"""
+
+import unittest
+import sys
+from pathlib import Path
+import tempfile
+import json
+import os
+
+# Add the parent directory to the path to import wobble
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+try:
+    from wobble.decorators import regression_test, integration_test
+except ImportError:
+    # Fallback decorators if wobble is not available
+    def regression_test(func):
+        return func
+    
+    def integration_test(scope="component"):
+        def decorator(func):
+            return func
+        return decorator
+
+from test_data_utils import MCPHostConfigTestDataLoader
+from hatch.mcp_host_config.host_management import MCPHostConfigurationManager, MCPHostRegistry, register_host_strategy
+from hatch.mcp_host_config.models import MCPHostType, MCPServerConfig, HostConfiguration, ConfigurationResult, SyncResult
+from hatch.mcp_host_config.strategies import MCPHostStrategy
+
+
+class TestMCPHostConfigurationManager(unittest.TestCase):
+    """Test suite for MCP host configuration manager."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.test_data_loader = MCPHostConfigTestDataLoader()
+        self.temp_dir = tempfile.mkdtemp()
+        self.temp_config_path = Path(self.temp_dir) / "test_config.json"
+        
+        # Clear registry before each test
+        MCPHostRegistry._strategies.clear()
+        MCPHostRegistry._instances.clear()
+        
+        # Store temp_config_path for strategy access
+        temp_config_path = self.temp_config_path
+
+        # Register test strategy
+        @register_host_strategy(MCPHostType.CLAUDE_DESKTOP)
+        class TestStrategy(MCPHostStrategy):
+            def get_config_path(self):
+                return temp_config_path
+
+            def is_host_available(self):
+                return True
+
+            def read_configuration(self):
+                if temp_config_path.exists():
+                    with open(temp_config_path, 'r') as f:
+                        data = json.load(f)
+
+                    servers = {}
+                    if "mcpServers" in data:
+                        for name, config in data["mcpServers"].items():
+                            servers[name] = MCPServerConfig(**config)
+
+                    return HostConfiguration(servers=servers)
+                else:
+                    return HostConfiguration(servers={})
+
+            def write_configuration(self, config, no_backup=False):
+                try:
+                    # Convert MCPServerConfig objects to dict
+                    servers_dict = {}
+                    for name, server_config in config.servers.items():
+                        servers_dict[name] = server_config.model_dump(exclude_none=True)
+
+                    # Create configuration data
+                    config_data = {"mcpServers": servers_dict}
+
+                    # Write to file
+                    with open(temp_config_path, 'w') as f:
+                        json.dump(config_data, f, indent=2)
+
+                    return True
+                except Exception:
+                    return False
+
+            def validate_server_config(self, server_config):
+                return True
+        
+        self.manager = MCPHostConfigurationManager()
+        self.temp_config_path = self.temp_config_path
+    
+    def tearDown(self):
+        """Clean up test environment."""
+        # Clean up temp files
+        if self.temp_config_path.exists():
+            self.temp_config_path.unlink()
+        os.rmdir(self.temp_dir)
+        
+        # Clear registry after each test
+        MCPHostRegistry._strategies.clear()
+        MCPHostRegistry._instances.clear()
+    
+    @regression_test
+    def test_configure_server_success(self):
+        """Test successful server configuration."""
+        server_config_data = self.test_data_loader.load_mcp_server_config("local")
+        server_config = MCPServerConfig(**server_config_data)
+        # Add name attribute for the manager to use
+        server_config.name = "test_server"
+
+        result = self.manager.configure_server(
+            server_config=server_config,
+            hostname="claude-desktop"
+        )
+
+        self.assertIsInstance(result, ConfigurationResult)
+        if not result.success:
+            print(f"Configuration failed: {result.error_message}")
+        self.assertTrue(result.success)
+        self.assertIsNone(result.error_message)
+        self.assertEqual(result.hostname, "claude-desktop")
+        self.assertEqual(result.server_name, "test_server")
+
+        # Verify configuration was written
+        self.assertTrue(self.temp_config_path.exists())
+
+        # Verify configuration content
+        with open(self.temp_config_path, 'r') as f:
+            config_data = json.load(f)
+
+        self.assertIn("mcpServers", config_data)
+        self.assertIn("test_server", config_data["mcpServers"])
+        self.assertEqual(config_data["mcpServers"]["test_server"]["command"], "python")
+    
+    @regression_test
+    def test_configure_server_unknown_host_type(self):
+        """Test configuration with unknown host type."""
+        server_config_data = self.test_data_loader.load_mcp_server_config("local")
+        server_config = MCPServerConfig(**server_config_data)
+        server_config.name = "test_server"
+
+        # Clear registry to simulate unknown host type
+        MCPHostRegistry._strategies.clear()
+
+        result = self.manager.configure_server(
+            server_config=server_config,
+            hostname="claude-desktop"
+        )
+
+        self.assertIsInstance(result, ConfigurationResult)
+        self.assertFalse(result.success)
+        self.assertIsNotNone(result.error_message)
+        self.assertIn("Unknown host type", result.error_message)
+    
+    @regression_test
+    def test_configure_server_validation_failure(self):
+        """Test configuration with validation failure."""
+        # Create server config that will fail validation at the strategy level
+        server_config_data = self.test_data_loader.load_mcp_server_config("local")
+        server_config = MCPServerConfig(**server_config_data)
+        server_config.name = "test_server"
+
+        # Override the test strategy to always fail validation
+        @register_host_strategy(MCPHostType.CLAUDE_DESKTOP)
+        class FailingValidationStrategy(MCPHostStrategy):
+            def get_config_path(self):
+                return self.temp_config_path
+
+            def is_host_available(self):
+                return True
+
+            def read_configuration(self):
+                return HostConfiguration(servers={})
+
+            def write_configuration(self, config, no_backup=False):
+                return True
+
+            def validate_server_config(self, server_config):
+                return False  # Always fail validation
+
+        result = self.manager.configure_server(
+            server_config=server_config,
+            hostname="claude-desktop"
+        )
+
+        self.assertIsInstance(result, ConfigurationResult)
+        self.assertFalse(result.success)
+        self.assertIsNotNone(result.error_message)
+        self.assertIn("Server configuration invalid", result.error_message)
+    
+    @regression_test
+    def test_remove_server_success(self):
+        """Test successful server removal."""
+        # First configure a server
+        server_config_data = self.test_data_loader.load_mcp_server_config("local")
+        server_config = MCPServerConfig(**server_config_data)
+        server_config.name = "test_server"
+
+        self.manager.configure_server(
+            server_config=server_config,
+            hostname="claude-desktop"
+        )
+
+        # Verify server exists
+        with open(self.temp_config_path, 'r') as f:
+            config_data = json.load(f)
+        self.assertIn("test_server", config_data["mcpServers"])
+
+        # Remove server
+        result = self.manager.remove_server(
+            server_name="test_server",
+            hostname="claude-desktop"
+        )
+
+        self.assertIsInstance(result, ConfigurationResult)
+        self.assertTrue(result.success)
+        self.assertIsNone(result.error_message)
+
+        # Verify server was removed
+        with open(self.temp_config_path, 'r') as f:
+            config_data = json.load(f)
+        self.assertNotIn("test_server", config_data["mcpServers"])
+    
+    @regression_test
+    def test_remove_server_not_found(self):
+        """Test removing non-existent server."""
+        result = self.manager.remove_server(
+            server_name="nonexistent_server",
+            hostname="claude-desktop"
+        )
+
+        self.assertIsInstance(result, ConfigurationResult)
+        self.assertFalse(result.success)
+        self.assertIsNotNone(result.error_message)
+        self.assertIn("Server 'nonexistent_server' not found", result.error_message)
+    
+    @regression_test
+    def test_sync_environment_to_hosts_success(self):
+        """Test successful environment synchronization."""
+        from hatch.mcp_host_config.models import EnvironmentData, EnvironmentPackageEntry, PackageHostConfiguration
+        from datetime import datetime
+
+        # Create test environment data
+        server_config_data = self.test_data_loader.load_mcp_server_config("local")
+        server_config = MCPServerConfig(**server_config_data)
+
+        host_config = PackageHostConfiguration(
+            config_path="~/test/config.json",
+            configured_at=datetime.fromisoformat("2025-09-21T10:00:00.000000"),
+            last_synced=datetime.fromisoformat("2025-09-21T10:00:00.000000"),
+            server_config=server_config
+        )
+
+        package = EnvironmentPackageEntry(
+            name="test-package",
+            version="1.0.0",
+            type="hatch",
+            source="github:user/test-package",
+            installed_at=datetime.fromisoformat("2025-09-21T10:00:00.000000"),
+            configured_hosts={"claude-desktop": host_config}
+        )
+
+        env_data = EnvironmentData(
+            name="test_env",
+            description="Test environment",
+            created_at=datetime.fromisoformat("2025-09-21T10:00:00.000000"),
+            packages=[package]
+        )
+
+        # Sync environment to hosts
+        result = self.manager.sync_environment_to_hosts(
+            env_data=env_data,
+            target_hosts=["claude-desktop"]
+        )
+
+        self.assertIsInstance(result, SyncResult)
+        self.assertTrue(result.success)
+        self.assertEqual(result.servers_synced, 1)
+        self.assertEqual(result.hosts_updated, 1)
+        self.assertEqual(len(result.results), 1)
+
+        # Verify configuration was written
+        self.assertTrue(self.temp_config_path.exists())
+
+        # Verify configuration content
+        with open(self.temp_config_path, 'r') as f:
+            config_data = json.load(f)
+
+        self.assertIn("mcpServers", config_data)
+        self.assertIn("test-package", config_data["mcpServers"])
+        self.assertEqual(config_data["mcpServers"]["test-package"]["command"], "python")
+
+    @regression_test
+    def test_sync_environment_to_hosts_no_servers(self):
+        """Test environment synchronization with no servers."""
+        from hatch.mcp_host_config.models import EnvironmentData
+        from datetime import datetime
+
+        # Create empty environment data
+        env_data = EnvironmentData(
+            name="empty_env",
+            description="Empty environment",
+            created_at=datetime.fromisoformat("2025-09-21T10:00:00.000000"),
+            packages=[]
+        )
+
+        # Sync environment to hosts
+        result = self.manager.sync_environment_to_hosts(
+            env_data=env_data,
+            target_hosts=["claude-desktop"]
+        )
+
+        self.assertIsInstance(result, SyncResult)
+        self.assertTrue(result.success)  # Success even with no servers
+        self.assertEqual(result.servers_synced, 0)
+        self.assertEqual(result.hosts_updated, 1)
+        self.assertEqual(len(result.results), 1)
+
+        # Verify result message
+        self.assertEqual(result.results[0].error_message, "No servers to sync")
+
+
+if __name__ == '__main__':
+    unittest.main()