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

tests/test_mcp_atomic_operations.py

@@ -1,276 +0,0 @@
-"""Tests for MCP atomic file operations.
-
-This module contains tests for atomic file operations and backup-aware
-operations with host-agnostic design.
-"""
-
-import unittest
-import tempfile
-import shutil
-import json
-from pathlib import Path
-from unittest.mock import patch, mock_open
-
-from wobble.decorators import regression_test
-from test_data_utils import MCPBackupTestDataLoader
-
-from hatch.mcp_host_config.backup import (
-    AtomicFileOperations, 
-    MCPHostConfigBackupManager,
-    BackupAwareOperation,
-    BackupError
-)
-
-
-class TestAtomicFileOperations(unittest.TestCase):
-    """Test atomic file operations with host-agnostic design."""
-    
-    def setUp(self):
-        """Set up test environment."""
-        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_atomic_"))
-        self.test_file = self.temp_dir / "test_config.json"
-        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.temp_dir / "backups")
-        self.atomic_ops = AtomicFileOperations()
-        self.test_data = MCPBackupTestDataLoader()
-    
-    def tearDown(self):
-        """Clean up test environment."""
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
-    @regression_test
-    def test_atomic_write_success_host_agnostic(self):
-        """Test successful atomic write with any JSON configuration format."""
-        test_data = self.test_data.load_host_agnostic_config("complex_server")
-        
-        result = self.atomic_ops.atomic_write_with_backup(
-            self.test_file, test_data, self.backup_manager, "claude-desktop"
-        )
-        
-        self.assertTrue(result)
-        self.assertTrue(self.test_file.exists())
-        
-        # Verify content (host-agnostic)
-        with open(self.test_file) as f:
-            written_data = json.load(f)
-        self.assertEqual(written_data, test_data)
-    
-    @regression_test
-    def test_atomic_write_with_existing_file(self):
-        """Test atomic write with existing file creates backup."""
-        # Create initial file
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        # Update with atomic write
-        new_data = self.test_data.load_host_agnostic_config("complex_server")
-        result = self.atomic_ops.atomic_write_with_backup(
-            self.test_file, new_data, self.backup_manager, "vscode"
-        )
-        
-        self.assertTrue(result)
-        
-        # Verify backup was created
-        backups = self.backup_manager.list_backups("vscode")
-        self.assertEqual(len(backups), 1)
-        
-        # Verify backup contains original data
-        with open(backups[0].file_path) as f:
-            backup_data = json.load(f)
-        self.assertEqual(backup_data, initial_data)
-        
-        # Verify file contains new data
-        with open(self.test_file) as f:
-            current_data = json.load(f)
-        self.assertEqual(current_data, new_data)
-    
-    @regression_test
-    def test_atomic_write_skip_backup(self):
-        """Test atomic write with backup skipped."""
-        # Create initial file
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        # Update with atomic write, skipping backup
-        new_data = self.test_data.load_host_agnostic_config("complex_server")
-        result = self.atomic_ops.atomic_write_with_backup(
-            self.test_file, new_data, self.backup_manager, "cursor", skip_backup=True
-        )
-        
-        self.assertTrue(result)
-        
-        # Verify no backup was created
-        backups = self.backup_manager.list_backups("cursor")
-        self.assertEqual(len(backups), 0)
-        
-        # Verify file contains new data
-        with open(self.test_file) as f:
-            current_data = json.load(f)
-        self.assertEqual(current_data, new_data)
-    
-    @regression_test
-    def test_atomic_write_failure_rollback(self):
-        """Test atomic write failure triggers rollback."""
-        # Create initial file
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        # Mock file write failure after backup creation
-        with patch('builtins.open', side_effect=[
-            # First call succeeds (backup creation)
-            open(self.test_file, 'r'),
-            # Second call fails (atomic write)
-            PermissionError("Access denied")
-        ]):
-            with self.assertRaises(BackupError):
-                self.atomic_ops.atomic_write_with_backup(
-                    self.test_file, {"new": "data"}, self.backup_manager, "lmstudio"
-                )
-        
-        # Verify original file is unchanged
-        with open(self.test_file) as f:
-            current_data = json.load(f)
-        self.assertEqual(current_data, initial_data)
-    
-    @regression_test
-    def test_atomic_copy_success(self):
-        """Test successful atomic copy operation."""
-        source_file = self.temp_dir / "source.json"
-        target_file = self.temp_dir / "target.json"
-        
-        test_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(source_file, 'w') as f:
-            json.dump(test_data, f)
-        
-        result = self.atomic_ops.atomic_copy(source_file, target_file)
-        
-        self.assertTrue(result)
-        self.assertTrue(target_file.exists())
-        
-        # Verify content integrity
-        with open(target_file) as f:
-            copied_data = json.load(f)
-        self.assertEqual(copied_data, test_data)
-    
-    @regression_test
-    def test_atomic_copy_failure_cleanup(self):
-        """Test atomic copy failure cleans up temporary files."""
-        source_file = self.temp_dir / "source.json"
-        target_file = self.temp_dir / "target.json"
-        
-        test_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(source_file, 'w') as f:
-            json.dump(test_data, f)
-        
-        # Mock copy failure
-        with patch('shutil.copy2', side_effect=PermissionError("Access denied")):
-            result = self.atomic_ops.atomic_copy(source_file, target_file)
-        
-        self.assertFalse(result)
-        self.assertFalse(target_file.exists())
-        
-        # Verify no temporary files left behind
-        temp_files = list(self.temp_dir.glob("*.tmp"))
-        self.assertEqual(len(temp_files), 0)
-
-
-class TestBackupAwareOperation(unittest.TestCase):
-    """Test backup-aware operation API."""
-    
-    def setUp(self):
-        """Set up test environment."""
-        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_backup_aware_"))
-        self.test_file = self.temp_dir / "test_config.json"
-        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.temp_dir / "backups")
-        self.test_data = MCPBackupTestDataLoader()
-    
-    def tearDown(self):
-        """Clean up test environment."""
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
-    @regression_test
-    def test_prepare_backup_success(self):
-        """Test explicit backup preparation."""
-        # Create initial configuration
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        # Test backup-aware operation
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        # Test explicit backup preparation
-        backup_result = operation.prepare_backup(self.test_file, "gemini", no_backup=False)
-        self.assertIsNotNone(backup_result)
-        self.assertTrue(backup_result.success)
-        
-        # Verify backup was created
-        backups = self.backup_manager.list_backups("gemini")
-        self.assertEqual(len(backups), 1)
-    
-    @regression_test
-    def test_prepare_backup_no_backup_mode(self):
-        """Test no-backup mode."""
-        # Create initial configuration
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        # Test no-backup mode
-        no_backup_result = operation.prepare_backup(self.test_file, "claude-code", no_backup=True)
-        self.assertIsNone(no_backup_result)
-        
-        # Verify no backup was created
-        backups = self.backup_manager.list_backups("claude-code")
-        self.assertEqual(len(backups), 0)
-    
-    @regression_test
-    def test_prepare_backup_failure_raises_exception(self):
-        """Test backup preparation failure raises BackupError."""
-        # Test with nonexistent file
-        nonexistent_file = self.temp_dir / "nonexistent.json"
-        
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        with self.assertRaises(BackupError):
-            operation.prepare_backup(nonexistent_file, "vscode", no_backup=False)
-    
-    @regression_test
-    def test_rollback_on_failure_success(self):
-        """Test successful rollback functionality."""
-        # Create initial configuration
-        initial_data = self.test_data.load_host_agnostic_config("simple_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(initial_data, f)
-        
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        # Create backup
-        backup_result = operation.prepare_backup(self.test_file, "cursor", no_backup=False)
-        self.assertTrue(backup_result.success)
-        
-        # Modify file (simulate failed operation)
-        modified_data = self.test_data.load_host_agnostic_config("complex_server")
-        with open(self.test_file, 'w') as f:
-            json.dump(modified_data, f)
-        
-        # Test rollback functionality
-        rollback_success = operation.rollback_on_failure(backup_result, self.test_file, "cursor")
-        self.assertTrue(rollback_success)
-    
-    @regression_test
-    def test_rollback_on_failure_no_backup(self):
-        """Test rollback with no backup result."""
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        # Test rollback with None backup result
-        rollback_success = operation.rollback_on_failure(None, self.test_file, "lmstudio")
-        self.assertFalse(rollback_success)
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/test_mcp_backup_integration.py

@@ -1,308 +0,0 @@
-"""Tests for MCP backup system integration.
-
-This module contains integration tests for the backup system with existing
-Hatch infrastructure and end-to-end workflows.
-"""
-
-import unittest
-import tempfile
-import shutil
-import json
-import time
-from pathlib import Path
-from unittest.mock import Mock, patch
-
-from wobble.decorators import integration_test, slow_test, regression_test
-from test_data_utils import MCPBackupTestDataLoader
-
-from hatch.mcp_host_config.backup import (
-    MCPHostConfigBackupManager, 
-    BackupAwareOperation,
-    BackupInfo,
-    BackupResult
-)
-
-
-class TestMCPBackupIntegration(unittest.TestCase):
-    """Test backup system integration with existing Hatch infrastructure."""
-    
-    def setUp(self):
-        """Set up integration test environment."""
-        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_integration_"))
-        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.temp_dir / "backups")
-        self.test_data = MCPBackupTestDataLoader()
-        
-        # Create test configuration files
-        self.config_dir = self.temp_dir / "configs"
-        self.config_dir.mkdir(parents=True)
-        
-        self.test_configs = {}
-        for hostname in ['claude-desktop', 'claude-code', 'vscode', 'cursor']:
-            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
-    
-    def tearDown(self):
-        """Clean up integration test environment."""
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
-    @integration_test(scope="component")
-    def test_complete_backup_restore_cycle(self):
-        """Test complete backup creation and restoration cycle."""
-        hostname = 'claude-desktop'
-        config_file = self.test_configs[hostname]
-        
-        # Create backup
-        backup_result = self.backup_manager.create_backup(config_file, hostname)
-        self.assertTrue(backup_result.success)
-        
-        # Modify original file
-        modified_data = self.test_data.load_host_agnostic_config("complex_server")
-        with open(config_file, 'w') as f:
-            json.dump(modified_data, f)
-        
-        # Verify file was modified
-        with open(config_file) as f:
-            current_data = json.load(f)
-        self.assertEqual(current_data, modified_data)
-        
-        # Restore from backup (placeholder - actual restore would need host config paths)
-        restore_success = self.backup_manager.restore_backup(hostname)
-        self.assertTrue(restore_success)  # Currently returns True as placeholder
-    
-    @integration_test(scope="component")
-    def test_multi_host_backup_management(self):
-        """Test backup management across multiple hosts."""
-        # 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
-            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
-                    )
-    
-    @integration_test(scope="end_to_end")
-    def test_backup_with_configuration_update_workflow(self):
-        """Test backup integration with configuration update operations."""
-        hostname = 'vscode'
-        config_file = self.test_configs[hostname]
-        
-        # Simulate configuration update with backup
-        original_data = self.test_data.load_host_agnostic_config("simple_server")
-        updated_data = self.test_data.load_host_agnostic_config("complex_server")
-        
-        # Ensure original data is in file
-        with open(config_file, 'w') as f:
-            json.dump(original_data, f)
-        
-        # Simulate update operation with backup
-        backup_result = self.backup_manager.create_backup(config_file, hostname)
-        self.assertTrue(backup_result.success)
-        
-        # Update configuration
-        with open(config_file, 'w') as f:
-            json.dump(updated_data, f)
-        
-        # Verify backup contains original data
-        backups = self.backup_manager.list_backups(hostname)
-        self.assertEqual(len(backups), 1)
-        
-        with open(backups[0].file_path) as f:
-            backup_data = json.load(f)
-        self.assertEqual(backup_data, original_data)
-        
-        # Verify current file has updated data
-        with open(config_file) as f:
-            current_data = json.load(f)
-        self.assertEqual(current_data, updated_data)
-    
-    @integration_test(scope="service")
-    def test_backup_system_with_existing_test_utilities(self):
-        """Test backup system integration with existing test utilities."""
-        # Use existing TestDataLoader patterns
-        test_config = self.test_data.load_host_agnostic_config("complex_server")
-        
-        # Test backup creation with complex configuration
-        config_path = self.temp_dir / "complex_config.json"
-        with open(config_path, 'w') as f:
-            json.dump(test_config, f)
-        
-        result = self.backup_manager.create_backup(config_path, "lmstudio")
-        self.assertTrue(result.success)
-        
-        # Verify integration with existing test data patterns
-        self.assertIsInstance(test_config, dict)
-        self.assertIn("servers", test_config)
-        
-        # Verify backup content matches test data
-        with open(result.backup_path) as f:
-            backup_content = json.load(f)
-        self.assertEqual(backup_content, test_config)
-    
-    @integration_test(scope="component")
-    def test_backup_aware_operation_workflow(self):
-        """Test backup-aware operation following environment manager patterns."""
-        hostname = 'cursor'
-        config_file = self.test_configs[hostname]
-        
-        # Test backup-aware operation following existing patterns
-        operation = BackupAwareOperation(self.backup_manager)
-        
-        # Simulate environment manager update workflow
-        backup_result = operation.prepare_backup(config_file, hostname, no_backup=False)
-        self.assertTrue(backup_result.success)
-        
-        # Verify backup was created following existing patterns
-        backups = self.backup_manager.list_backups(hostname)
-        self.assertEqual(len(backups), 1)
-        self.assertEqual(backups[0].hostname, hostname)
-        
-        # Test rollback capability
-        rollback_success = operation.rollback_on_failure(backup_result, config_file, hostname)
-        self.assertTrue(rollback_success)
-
-
-class TestMCPBackupPerformance(unittest.TestCase):
-    """Test backup system performance characteristics."""
-    
-    def setUp(self):
-        """Set up performance test environment."""
-        self.temp_dir = Path(tempfile.mkdtemp(prefix="test_performance_"))
-        self.backup_manager = MCPHostConfigBackupManager(backup_root=self.temp_dir / "backups")
-        self.test_data = MCPBackupTestDataLoader()
-    
-    def tearDown(self):
-        """Clean up performance test environment."""
-        shutil.rmtree(self.temp_dir, ignore_errors=True)
-    
-    @slow_test
-    @regression_test
-    def test_backup_performance_large_config(self):
-        """Test backup performance with larger configuration files."""
-        # Create large host-agnostic configuration
-        large_config = {"servers": {}}
-        for i in range(1000):
-            large_config["servers"][f"server_{i}"] = {
-                "command": f"python_{i}",
-                "args": [f"arg_{j}" for j in range(10)]
-            }
-        
-        config_file = self.temp_dir / "large_config.json"
-        with open(config_file, 'w') as f:
-            json.dump(large_config, f)
-        
-        start_time = time.time()
-        result = self.backup_manager.create_backup(config_file, "gemini")
-        duration = time.time() - start_time
-        
-        self.assertTrue(result.success)
-        self.assertLess(duration, 1.0)  # Should complete within 1 second
-    
-    @regression_test
-    def test_pydantic_validation_performance(self):
-        """Test Pydantic model validation performance."""
-        hostname = "claude-desktop"
-        config_data = self.test_data.load_host_agnostic_config("simple_server")
-        config_file = self.temp_dir / "test_config.json"
-        
-        with open(config_file, 'w') as f:
-            json.dump(config_data, f)
-        
-        start_time = time.time()
-        
-        # Create backup (includes Pydantic validation)
-        result = self.backup_manager.create_backup(config_file, hostname)
-        
-        # List backups (includes Pydantic model creation)
-        backups = self.backup_manager.list_backups(hostname)
-        
-        duration = time.time() - start_time
-        
-        self.assertTrue(result.success)
-        self.assertEqual(len(backups), 1)
-        self.assertLess(duration, 0.1)  # Pydantic operations should be fast
-    
-    @regression_test
-    def test_concurrent_backup_operations(self):
-        """Test concurrent backup operations for different hosts."""
-        import threading
-        
-        results = {}
-        config_files = {}
-        
-        # Create test configurations for different hosts
-        for hostname in ['claude-desktop', 'vscode', 'cursor', 'lmstudio']:
-            config_data = self.test_data.load_host_agnostic_config("simple_server")
-            config_file = self.temp_dir / f"{hostname}_config.json"
-            with open(config_file, 'w') as f:
-                json.dump(config_data, f)
-            config_files[hostname] = config_file
-        
-        def create_backup_thread(hostname, config_file):
-            results[hostname] = self.backup_manager.create_backup(config_file, hostname)
-        
-        # Start concurrent backup operations
-        threads = []
-        for hostname, config_file in config_files.items():
-            thread = threading.Thread(target=create_backup_thread, args=(hostname, config_file))
-            threads.append(thread)
-            thread.start()
-        
-        # Wait for all threads to complete
-        for thread in threads:
-            thread.join(timeout=5.0)
-        
-        # Verify all operations succeeded
-        for hostname in config_files.keys():
-            self.assertIn(hostname, results)
-            self.assertTrue(results[hostname].success)
-    
-    @regression_test
-    def test_backup_list_performance_many_backups(self):
-        """Test backup listing performance with many backup files."""
-        hostname = "claude-code"
-        config_data = self.test_data.load_host_agnostic_config("simple_server")
-        config_file = self.temp_dir / "test_config.json"
-        
-        with open(config_file, 'w') as f:
-            json.dump(config_data, f)
-        
-        # Create many backups
-        for i in range(50):
-            result = self.backup_manager.create_backup(config_file, hostname)
-            self.assertTrue(result.success)
-        
-        # Test listing performance
-        start_time = time.time()
-        backups = self.backup_manager.list_backups(hostname)
-        duration = time.time() - start_time
-        
-        self.assertEqual(len(backups), 50)
-        self.assertLess(duration, 0.1)  # Should be fast even with many backups
-        
-        # Verify all backups are valid Pydantic models
-        for backup in backups:
-            self.assertIsInstance(backup, BackupInfo)
-            self.assertEqual(backup.hostname, hostname)
-
-
-if __name__ == '__main__':
-    unittest.main()