hatch-xclam 0.7.0__py3-none-any.whl

tests/test_hatch_installer.py

@@ -0,0 +1,179 @@
+import unittest
+import tempfile
+import shutil
+import logging
+from pathlib import Path
+from datetime import datetime
+
+from wobble.decorators import regression_test, integration_test, slow_test
+
+from hatch.installers.hatch_installer import HatchInstaller
+from hatch.package_loader import HatchPackageLoader
+from hatch_validator.package_validator import HatchPackageValidator
+from hatch_validator.package.package_service import PackageService
+
+from hatch.installers.installation_context import InstallationStatus
+
+class TestHatchInstaller(unittest.TestCase):
+    """Tests for the HatchInstaller using dummy packages from Hatching-Dev."""
+
+    @classmethod
+    def setUpClass(cls):
+        # Path to Hatching-Dev dummy packages
+        cls.hatch_dev_path = Path(__file__).parent.parent.parent / "Hatching-Dev"
+        assert cls.hatch_dev_path.exists(), f"Hatching-Dev directory not found at {cls.hatch_dev_path}"
+
+        # Build a mock registry from Hatching-Dev packages (pattern from test_package_validator.py)
+        cls.registry_data = cls._build_test_registry(cls.hatch_dev_path)
+        cls.validator = HatchPackageValidator(registry_data=cls.registry_data)
+        cls.package_loader = HatchPackageLoader()
+        cls.installer = HatchInstaller()
+
+    @staticmethod
+    def _build_test_registry(hatch_dev_path):
+        registry = {
+            "registry_schema_version": "1.1.0",
+            "last_updated": datetime.now().isoformat(),
+            "repositories": [
+                {
+                    "name": "Hatch-Dev",
+                    "url": "file://" + str(hatch_dev_path),
+                    "packages": [],
+                    "last_indexed": datetime.now().isoformat()
+                }
+            ]
+        }
+        # Use self-contained test packages instead of external Hatching-Dev
+        from test_data_utils import TestDataLoader
+        test_loader = TestDataLoader()
+
+        pkg_names = [
+            "base_pkg", "utility_pkg", "python_dep_pkg",
+            "circular_dep_pkg", "circular_dep_pkg_b", "complex_dep_pkg",
+            "simple_dep_pkg", "invalid_dep_pkg", "version_conflict_pkg"
+        ]
+        for pkg_name in pkg_names:
+            # Map to self-contained package locations
+            if pkg_name in ["base_pkg", "utility_pkg"]:
+                pkg_path = test_loader.packages_dir / "basic" / pkg_name
+            elif pkg_name in ["complex_dep_pkg", "simple_dep_pkg", "python_dep_pkg"]:
+                pkg_path = test_loader.packages_dir / "dependencies" / pkg_name
+            elif pkg_name in ["circular_dep_pkg", "circular_dep_pkg_b", "invalid_dep_pkg", "version_conflict_pkg"]:
+                pkg_path = test_loader.packages_dir / "error_scenarios" / pkg_name
+            else:
+                pkg_path = test_loader.packages_dir / pkg_name
+            if pkg_path.exists():
+                metadata_path = pkg_path / "hatch_metadata.json"
+                if metadata_path.exists():
+                    with open(metadata_path, 'r') as f:
+                        import json
+                        metadata = json.load(f)
+                        pkg_entry = {
+                            "name": metadata.get("name", pkg_name),
+                            "description": metadata.get("description", ""),
+                            "category": "development",
+                            "tags": metadata.get("tags", []),
+                            "latest_version": metadata.get("version", "1.0.0"),
+                            "versions": [
+                                {
+                                    "version": metadata.get("version", "1.0.0"),
+                                    "release_uri": f"file://{pkg_path}",
+                                    "author": {
+                                        "GitHubID": metadata.get("author", {}).get("name", "test_user"),
+                                        "email": metadata.get("author", {}).get("email", "test@example.com")
+                                    },
+                                    "added_date": datetime.now().isoformat(),
+                                    "hatch_dependencies_added": [
+                                        {
+                                            "name": dep["name"],
+                                            "version_constraint": dep.get("version_constraint", "")
+                                        }
+                                        for dep in metadata.get("hatch_dependencies", [])
+                                    ],
+                                    "python_dependencies_added": [
+                                        {
+                                            "name": dep["name"],
+                                            "version_constraint": dep.get("version_constraint", ""),
+                                            "package_manager": dep.get("package_manager", "pip")
+                                        }
+                                        for dep in metadata.get("python_dependencies", [])
+                                    ],
+                                }
+                            ]
+                        }
+                        registry["repositories"][0]["packages"].append(pkg_entry)
+        return registry
+
+    def setUp(self):
+        # Create a temporary directory for installs
+        self.temp_dir = tempfile.mkdtemp()
+        self.target_dir = Path(self.temp_dir) / "target"
+        self.target_dir.mkdir(parents=True, exist_ok=True)
+
+    def tearDown(self):
+        shutil.rmtree(self.temp_dir)
+
+    @regression_test
+    def test_installer_can_install_and_uninstall(self):
+        """Test the full install and uninstall cycle for a dummy Hatch package using the installer."""
+        pkg_name = "base_pkg"
+        from test_data_utils import TestDataLoader
+        test_loader = TestDataLoader()
+        pkg_path = test_loader.packages_dir / "basic" / pkg_name
+        metadata_path = pkg_path / "hatch_metadata.json"
+        with open(metadata_path, 'r') as f:
+            import json
+            metadata = json.load(f)
+        dependency = {
+            "name": pkg_name,
+            "version_constraint": metadata.get("version", "1.0.0"),
+            "resolved_version": metadata.get("version", "1.0.0"),
+            "type": "hatch",
+            "uri": f"file://{pkg_path}"
+        }
+        # Prepare a minimal InstallationContext
+        class DummyContext:
+            environment_path = str(self.target_dir)
+        context = DummyContext()
+        # Install
+        result = self.installer.install(dependency, context)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED)
+        installed_path = Path(result.installed_path)
+        self.assertTrue(installed_path.exists())
+        # Uninstall
+        uninstall_result = self.installer.uninstall(dependency, context)
+        self.assertEqual(uninstall_result.status, InstallationStatus.COMPLETED)
+        self.assertFalse(installed_path.exists())
+
+    @regression_test
+    def test_installer_rejects_invalid_dependency(self):
+        """Test that the installer rejects dependencies missing required fields."""
+        invalid_dep = {"name": "foo"}  # Missing required fields
+        self.assertFalse(self.installer.validate_dependency(invalid_dep))
+
+    @regression_test
+    def test_installation_error_on_missing_uri(self):
+        """Test that the installer raises InstallationError if no URI is provided."""
+        pkg_name = "base_pkg"
+        dependency = {
+            "name": pkg_name,
+            "version_constraint": "1.0.0",
+            "resolved_version": "1.0.0",
+            "type": "hatch"
+        }
+        class DummyContext:
+            environment_path = str(self.target_dir)
+        context = DummyContext()
+        with self.assertRaises(Exception):
+            self.installer.install(dependency, context)
+
+    @regression_test
+    def test_can_install_method(self):
+        """Test the can_install method for correct dependency type recognition."""
+        dep = {"type": "hatch"}
+        self.assertTrue(self.installer.can_install(dep))
+        dep2 = {"type": "python"}
+        self.assertFalse(self.installer.can_install(dep2))
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_installer_base.py

@@ -0,0 +1,221 @@
+import sys
+import unittest
+import logging
+import tempfile
+import shutil
+from pathlib import Path
+from unittest.mock import Mock
+from typing import Dict, Any, List
+
+from wobble.decorators import regression_test, integration_test, slow_test
+
+# Import path management removed - using test_data_utils for test dependencies
+
+from hatch.installers.installer_base import (
+    DependencyInstaller,
+    InstallationError
+)
+
+from hatch.installers.installation_context import (
+    InstallationContext, 
+    InstallationResult,
+    InstallationStatus
+)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("hatch.installer_interface_tests")
+
+class MockInstaller(DependencyInstaller):
+    """Mock installer for testing the base interface."""
+    
+    @property
+    def installer_type(self) -> str:
+        return "mock"
+    
+    @property
+    def supported_schemes(self) -> List[str]:
+        return ["test", "mock"]
+    
+    def can_install(self, dependency: Dict[str, Any]) -> bool:
+        return dependency.get("type") == "mock"
+    
+    def install(self, dependency: Dict[str, Any], context: InstallationContext,
+                progress_callback=None) -> InstallationResult:
+        return InstallationResult(
+            dependency_name=dependency["name"],
+            status=InstallationStatus.COMPLETED,
+            installed_path=context.environment_path / dependency["name"],
+            installed_version=dependency["resolved_version"]
+        )
+
+class BaseInstallerTests(unittest.TestCase):
+    """Tests for the DependencyInstaller base class interface."""
+    
+    def setUp(self):
+        """Set up test environment before each test."""
+        # Create a temporary directory for test environments
+        self.temp_dir = tempfile.mkdtemp()
+        self.env_path = Path(self.temp_dir) / "test_env"
+        self.env_path.mkdir(parents=True, exist_ok=True)
+        
+        # Create a mock installer instance for testing
+        self.installer = MockInstaller()
+        
+        # Create test context
+        self.context = InstallationContext(
+            environment_path=self.env_path,
+            environment_name="test_env"
+        )
+        
+        logger.info(f"Set up test environment at {self.temp_dir}")
+    
+    def tearDown(self):
+        """Clean up test environment after each test."""
+        if hasattr(self, 'temp_dir') and Path(self.temp_dir).exists():
+            shutil.rmtree(self.temp_dir, ignore_errors=True)
+            logger.info(f"Cleaned up test environment at {self.temp_dir}")
+    @regression_test
+    def test_installation_context_creation(self):
+        """Test that InstallationContext can be created with required fields."""
+        context = InstallationContext(
+            environment_path=Path("/test/env"),
+            environment_name="test_env"
+        )
+        self.assertEqual(context.environment_path, Path("/test/env"), f"Expected environment_path=/test/env, got {context.environment_path}")
+        self.assertEqual(context.environment_name, "test_env", f"Expected environment_name='test_env', got {context.environment_name}")
+        self.assertTrue(context.parallel_enabled, f"Expected parallel_enabled=True, got {context.parallel_enabled}")  # Default value
+        self.assertEqual(context.get_config("nonexistent", "default"), "default", f"Expected default config fallback, got {context.get_config('nonexistent', 'default')}")
+        logger.info("InstallationContext creation test passed")
+    @regression_test
+    def test_installation_context_with_config(self):
+        """Test InstallationContext with extra configuration."""
+        context = InstallationContext(
+            environment_path=Path("/test/env"),
+            environment_name="test_env",
+            extra_config={"custom_setting": "value"}
+        )
+        self.assertEqual(context.get_config("custom_setting"), "value", f"Expected custom_setting='value', got {context.get_config('custom_setting')}")
+        self.assertEqual(context.get_config("missing_key", "fallback"), "fallback", f"Expected fallback for missing_key, got {context.get_config('missing_key', 'fallback')}")
+        logger.info("InstallationContext with config test passed")
+    @regression_test
+    def test_installation_result_creation(self):
+        """Test that InstallationResult can be created."""
+        result = InstallationResult(
+            dependency_name="test_package",
+            status=InstallationStatus.COMPLETED,
+            installed_path=Path("/env/test_package"),
+            installed_version="1.0.0"
+        )
+        self.assertEqual(result.dependency_name, "test_package", f"Expected dependency_name='test_package', got {result.dependency_name}")
+        self.assertEqual(result.status, InstallationStatus.COMPLETED, f"Expected status=COMPLETED, got {result.status}")
+        self.assertEqual(result.installed_path, Path("/env/test_package"), f"Expected installed_path=/env/test_package, got {result.installed_path}")
+        self.assertEqual(result.installed_version, "1.0.0", f"Expected installed_version='1.0.0', got {result.installed_version}")
+        logger.info("InstallationResult creation test passed")
+    @regression_test
+    def test_installation_error(self):
+        """Test InstallationError creation and attributes."""
+        error = InstallationError(
+            message="Installation failed",
+            dependency_name="test_package",
+            error_code="DOWNLOAD_FAILED"
+        )
+        self.assertEqual(error.message, "Installation failed", f"Expected error message 'Installation failed', got '{error.message}'")
+        self.assertEqual(error.dependency_name, "test_package", f"Expected dependency_name='test_package', got {error.dependency_name}")
+        self.assertEqual(error.error_code, "DOWNLOAD_FAILED", f"Expected error_code='DOWNLOAD_FAILED', got {error.error_code}")
+        logger.info("InstallationError test passed")
+    @regression_test
+    def test_mock_installer_interface(self):
+        """Test that MockInstaller implements the interface correctly."""
+        # Test properties
+        self.assertEqual(self.installer.installer_type, "mock", f"Expected installer_type='mock', got {self.installer.installer_type}")
+        self.assertEqual(self.installer.supported_schemes, ["test", "mock"], f"Expected supported_schemes=['test', 'mock'], got {self.installer.supported_schemes}")
+        # Test can_install
+        mock_dep = {"type": "mock", "name": "test"}
+        non_mock_dep = {"type": "other", "name": "test"}
+        self.assertTrue(self.installer.can_install(mock_dep), f"Expected can_install to be True for {mock_dep}")
+        self.assertFalse(self.installer.can_install(non_mock_dep), f"Expected can_install to be False for {non_mock_dep}")
+        logger.info("MockInstaller interface test passed")
+    @regression_test
+    def test_mock_installer_install(self):
+        """Test the install method of MockInstaller."""
+        dependency = {
+            "name": "test_package",
+            "type": "mock",
+            "version_constraint": ">=1.0.0",
+            "resolved_version": "1.2.0"
+        }
+        result = self.installer.install(dependency, self.context)
+        self.assertEqual(result.dependency_name, "test_package", f"Expected dependency_name='test_package', got {result.dependency_name}")
+        self.assertEqual(result.status, InstallationStatus.COMPLETED, f"Expected status=COMPLETED, got {result.status}")
+        self.assertEqual(result.installed_path, self.env_path / "test_package", f"Expected installed_path={self.env_path / 'test_package'}, got {result.installed_path}")
+        self.assertEqual(result.installed_version, "1.2.0", f"Expected installed_version='1.2.0', got {result.installed_version}")
+        logger.info("MockInstaller install test passed")
+    @regression_test
+    def test_mock_installer_validation(self):
+        """Test dependency validation."""
+        valid_dep = {
+            "name": "test",
+            "version_constraint": ">=1.0.0",
+            "resolved_version": "1.0.0"
+        }
+        invalid_dep = {
+            "name": "test"
+            # Missing required fields
+        }
+        self.assertTrue(self.installer.validate_dependency(valid_dep), f"Expected valid dependency to pass validation: {valid_dep}")
+        self.assertFalse(self.installer.validate_dependency(invalid_dep), f"Expected invalid dependency to fail validation: {invalid_dep}")
+        logger.info("MockInstaller validation test passed")
+    @regression_test
+    def test_mock_installer_get_installation_info(self):
+        """Test getting installation information."""
+        dependency = {
+            "name": "test_package",
+            "type": "mock",
+            "resolved_version": "1.0.0"
+        }
+        info = self.installer.get_installation_info(dependency, self.context)
+        self.assertEqual(info["installer_type"], "mock", f"Expected installer_type='mock', got {info['installer_type']}")
+        self.assertEqual(info["dependency_name"], "test_package", f"Expected dependency_name='test_package', got {info['dependency_name']}")
+        self.assertEqual(info["resolved_version"], "1.0.0", f"Expected resolved_version='1.0.0', got {info['resolved_version']}")
+        self.assertEqual(info["target_path"], str(self.env_path), f"Expected target_path={self.env_path}, got {info['target_path']}")
+        self.assertTrue(info["supported"], f"Expected supported=True, got {info['supported']}")
+        logger.info("MockInstaller get_installation_info test passed")
+    @regression_test
+    def test_mock_installer_uninstall_not_implemented(self):
+        """Test that uninstall raises NotImplementedError by default."""
+        dependency = {"name": "test", "type": "mock"}
+        with self.assertRaises(NotImplementedError, msg="Expected NotImplementedError for uninstall on MockInstaller"):
+            self.installer.uninstall(dependency, self.context)
+        logger.info("MockInstaller uninstall NotImplementedError test passed")
+    @regression_test
+    def test_installation_status_enum(self):
+        """Test InstallationStatus enum values."""
+        self.assertEqual(InstallationStatus.PENDING.value, "pending", f"Expected PENDING='pending', got {InstallationStatus.PENDING.value}")
+        self.assertEqual(InstallationStatus.IN_PROGRESS.value, "in_progress", f"Expected IN_PROGRESS='in_progress', got {InstallationStatus.IN_PROGRESS.value}")
+        self.assertEqual(InstallationStatus.COMPLETED.value, "completed", f"Expected COMPLETED='completed', got {InstallationStatus.COMPLETED.value}")
+        self.assertEqual(InstallationStatus.FAILED.value, "failed", f"Expected FAILED='failed', got {InstallationStatus.FAILED.value}")
+        self.assertEqual(InstallationStatus.ROLLED_BACK.value, "rolled_back", f"Expected ROLLED_BACK='rolled_back', got {InstallationStatus.ROLLED_BACK.value}")
+        logger.info("InstallationStatus enum test passed")
+    @regression_test
+    def test_progress_callback_support(self):
+        """Test that installer accepts progress callback."""
+        dependency = {
+            "name": "test_package",
+            "type": "mock",
+            "resolved_version": "1.0.0"
+        }
+        callback_called = []
+        def progress_callback(progress: float, message: str = ""):
+            callback_called.append((progress, message))
+        # Install with callback - should not raise error
+        result = self.installer.install(dependency, self.context, progress_callback)
+        self.assertEqual(result.status, InstallationStatus.COMPLETED, f"Expected status=COMPLETED, got {result.status}")
+        logger.info("Progress callback support test passed")
+
+if __name__ == "__main__":
+    # Run the tests
+    unittest.main(verbosity=2)

tests/test_mcp_atomic_operations.py

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