hatch-xclam 0.7.0__py3-none-any.whl

tests/test_mcp_backup_integration.py

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

tests/test_mcp_cli_all_host_specific_args.py

@@ -0,0 +1,303 @@
+"""
+Tests for ALL host-specific CLI arguments in MCP configure command.
+
+This module tests that:
+1. All host-specific arguments are accepted for all hosts
+2. Unsupported fields are reported as "UNSUPPORTED" in conversion reports
+3. All new arguments (httpUrl, includeTools, excludeTools, inputs) work correctly
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+from io import StringIO
+
+from hatch.cli_hatch import handle_mcp_configure, parse_input
+from hatch.mcp_host_config import MCPHostType
+from hatch.mcp_host_config.models import (
+    MCPServerConfigGemini, MCPServerConfigCursor, MCPServerConfigVSCode,
+    MCPServerConfigClaude
+)
+
+
+class TestAllGeminiArguments(unittest.TestCase):
+    """Test ALL Gemini-specific CLI arguments."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_all_gemini_arguments_accepted(self, mock_stdout, mock_manager_class):
+        """Test that all Gemini arguments are accepted and passed to model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='gemini',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            timeout=30000,
+            trust=True,
+            cwd='/workspace',
+            http_url='https://api.example.com/mcp',
+            include_tools=['tool1', 'tool2'],
+            exclude_tools=['dangerous_tool'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        
+        # Verify all fields were passed to Gemini model
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigGemini)
+        self.assertEqual(server_config.timeout, 30000)
+        self.assertEqual(server_config.trust, True)
+        self.assertEqual(server_config.cwd, '/workspace')
+        self.assertEqual(server_config.httpUrl, 'https://api.example.com/mcp')
+        self.assertEqual(server_config.includeTools, ['tool1', 'tool2'])
+        self.assertEqual(server_config.excludeTools, ['dangerous_tool'])
+
+
+class TestUnsupportedFieldReporting(unittest.TestCase):
+    """Test that unsupported fields are reported correctly, not rejected."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_gemini_args_on_vscode_show_unsupported(self, mock_stdout, mock_manager_class):
+        """Test that Gemini-specific args on VS Code show as UNSUPPORTED."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='vscode',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            timeout=30000,  # Gemini-only field
+            trust=True,     # Gemini-only field
+            auto_approve=True
+        )
+
+        # Should succeed (not return error code 1)
+        self.assertEqual(result, 0)
+        
+        # Check that output contains "UNSUPPORTED" for Gemini fields
+        output = mock_stdout.getvalue()
+        self.assertIn('UNSUPPORTED', output)
+        self.assertIn('timeout', output)
+        self.assertIn('trust', output)
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_vscode_inputs_on_gemini_show_unsupported(self, mock_stdout, mock_manager_class):
+        """Test that VS Code inputs on Gemini show as UNSUPPORTED."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='gemini',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            input=['promptString,api-key,API Key,password=true'],  # VS Code-only field
+            auto_approve=True
+        )
+
+        # Should succeed (not return error code 1)
+        self.assertEqual(result, 0)
+        
+        # Check that output contains "UNSUPPORTED" for inputs field
+        output = mock_stdout.getvalue()
+        self.assertIn('UNSUPPORTED', output)
+        self.assertIn('inputs', output)
+
+
+class TestVSCodeInputsParsing(unittest.TestCase):
+    """Test VS Code inputs parsing."""
+
+    def test_parse_input_basic(self):
+        """Test basic input parsing."""
+        input_list = ['promptString,api-key,GitHub Personal Access Token']
+        result = parse_input(input_list)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]['type'], 'promptString')
+        self.assertEqual(result[0]['id'], 'api-key')
+        self.assertEqual(result[0]['description'], 'GitHub Personal Access Token')
+        self.assertNotIn('password', result[0])
+
+    def test_parse_input_with_password(self):
+        """Test input parsing with password flag."""
+        input_list = ['promptString,api-key,API Key,password=true']
+        result = parse_input(input_list)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]['password'], True)
+
+    def test_parse_input_multiple(self):
+        """Test parsing multiple inputs."""
+        input_list = [
+            'promptString,api-key,API Key,password=true',
+            'promptString,db-url,Database URL'
+        ]
+        result = parse_input(input_list)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result), 2)
+
+    def test_parse_input_none(self):
+        """Test parsing None inputs."""
+        result = parse_input(None)
+        self.assertIsNone(result)
+
+    def test_parse_input_empty(self):
+        """Test parsing empty inputs list."""
+        result = parse_input([])
+        self.assertIsNone(result)
+
+
+class TestVSCodeInputsIntegration(unittest.TestCase):
+    """Test VS Code inputs integration with configure command."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_vscode_inputs_passed_to_model(self, mock_manager_class):
+        """Test that parsed inputs are passed to VS Code model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='vscode',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            input=['promptString,api-key,API Key,password=true'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        
+        # Verify inputs were passed to VS Code model
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigVSCode)
+        self.assertIsNotNone(server_config.inputs)
+        self.assertEqual(len(server_config.inputs), 1)
+        self.assertEqual(server_config.inputs[0]['id'], 'api-key')
+
+
+class TestHttpUrlArgument(unittest.TestCase):
+    """Test --http-url argument for Gemini."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_http_url_passed_to_gemini(self, mock_manager_class):
+        """Test that httpUrl is passed to Gemini model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='gemini',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            http_url='https://api.example.com/mcp',
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        
+        # Verify httpUrl was passed to Gemini model
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigGemini)
+        self.assertEqual(server_config.httpUrl, 'https://api.example.com/mcp')
+
+
+class TestToolFilteringArguments(unittest.TestCase):
+    """Test --include-tools and --exclude-tools arguments for Gemini."""
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_include_tools_passed_to_gemini(self, mock_manager_class):
+        """Test that includeTools is passed to Gemini model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='gemini',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            include_tools=['tool1', 'tool2', 'tool3'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        
+        # Verify includeTools was passed to Gemini model
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigGemini)
+        self.assertEqual(server_config.includeTools, ['tool1', 'tool2', 'tool3'])
+
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    def test_exclude_tools_passed_to_gemini(self, mock_manager_class):
+        """Test that excludeTools is passed to Gemini model."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_result.backup_path = None
+        mock_manager.configure_server.return_value = mock_result
+
+        result = handle_mcp_configure(
+            host='gemini',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],
+            exclude_tools=['dangerous_tool'],
+            auto_approve=True
+        )
+
+        self.assertEqual(result, 0)
+        
+        # Verify excludeTools was passed to Gemini model
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertIsInstance(server_config, MCPServerConfigGemini)
+        self.assertEqual(server_config.excludeTools, ['dangerous_tool'])
+
+
+if __name__ == '__main__':
+    unittest.main()
+