hatch-xclam 0.7.0.dev12__py3-none-any.whl → 0.7.1__py3-none-any.whl

tests/regression/test_mcp_kiro_backup_integration.py

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

tests/regression/test_mcp_kiro_cli_integration.py

@@ -0,0 +1,141 @@
+"""
+Kiro MCP CLI Integration Tests
+
+Tests for CLI argument parsing and integration with Kiro-specific arguments.
+"""
+
+import unittest
+from unittest.mock import patch, MagicMock
+
+from wobble.decorators import regression_test
+
+from hatch.cli_hatch import handle_mcp_configure
+
+
+class TestKiroCLIIntegration(unittest.TestCase):
+    """Test suite for Kiro CLI argument integration."""
+    
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @regression_test
+    def test_kiro_cli_with_disabled_flag(self, mock_manager_class):
+        """Test CLI with --disabled flag for Kiro."""
+        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='kiro',
+            server_name='test-server',
+            command='auggie',
+            args=['--mcp'],
+            disabled=True,  # Kiro-specific argument
+            auto_approve=True
+        )
+        
+        self.assertEqual(result, 0)
+        
+        # Verify configure_server was called with Kiro model
+        mock_manager.configure_server.assert_called_once()
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        
+        # Verify Kiro-specific field was set
+        self.assertTrue(server_config.disabled)
+    
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @regression_test
+    def test_kiro_cli_with_auto_approve_tools(self, mock_manager_class):
+        """Test CLI with --auto-approve-tools for Kiro."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_manager.configure_server.return_value = mock_result
+        
+        result = handle_mcp_configure(
+            host='kiro',
+            server_name='test-server',
+            command='auggie',
+            args=['--mcp'],  # Required parameter
+            auto_approve_tools=['codebase-retrieval', 'fetch'],
+            auto_approve=True
+        )
+        
+        self.assertEqual(result, 0)
+        
+        # Verify autoApprove field was set correctly
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(len(server_config.autoApprove), 2)
+        self.assertIn('codebase-retrieval', server_config.autoApprove)
+    
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @regression_test
+    def test_kiro_cli_with_disable_tools(self, mock_manager_class):
+        """Test CLI with --disable-tools for Kiro."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_manager.configure_server.return_value = mock_result
+        
+        result = handle_mcp_configure(
+            host='kiro',
+            server_name='test-server',
+            command='python',
+            args=['server.py'],  # Required parameter
+            disable_tools=['dangerous-tool', 'risky-tool'],
+            auto_approve=True
+        )
+        
+        self.assertEqual(result, 0)
+        
+        # Verify disabledTools field was set correctly
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        self.assertEqual(len(server_config.disabledTools), 2)
+        self.assertIn('dangerous-tool', server_config.disabledTools)
+    
+    @patch('hatch.cli_hatch.MCPHostConfigurationManager')
+    @regression_test
+    def test_kiro_cli_combined_arguments(self, mock_manager_class):
+        """Test CLI with multiple Kiro-specific arguments combined."""
+        mock_manager = MagicMock()
+        mock_manager_class.return_value = mock_manager
+        
+        mock_result = MagicMock()
+        mock_result.success = True
+        mock_manager.configure_server.return_value = mock_result
+        
+        result = handle_mcp_configure(
+            host='kiro',
+            server_name='comprehensive-server',
+            command='auggie',
+            args=['--mcp', '-m', 'default'],
+            disabled=False,
+            auto_approve_tools=['codebase-retrieval'],
+            disable_tools=['dangerous-tool'],
+            auto_approve=True
+        )
+        
+        self.assertEqual(result, 0)
+        
+        # Verify all Kiro fields were set correctly
+        call_args = mock_manager.configure_server.call_args
+        server_config = call_args.kwargs['server_config']
+        
+        self.assertFalse(server_config.disabled)
+        self.assertEqual(len(server_config.autoApprove), 1)
+        self.assertEqual(len(server_config.disabledTools), 1)
+        self.assertIn('codebase-retrieval', server_config.autoApprove)
+        self.assertIn('dangerous-tool', server_config.disabledTools)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/test_mcp_kiro_decorator_registration.py

@@ -0,0 +1,71 @@
+"""
+Kiro MCP Decorator Registration Tests
+
+Tests for automatic strategy registration via @register_host_strategy decorator.
+"""
+
+import unittest
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.host_management import MCPHostRegistry
+from hatch.mcp_host_config.models import MCPHostType
+
+
+class TestKiroDecoratorRegistration(unittest.TestCase):
+    """Test suite for Kiro decorator registration."""
+    
+    @regression_test
+    def test_kiro_strategy_registration(self):
+        """Test that KiroHostStrategy is properly registered."""
+        # Import strategies to trigger registration
+        import hatch.mcp_host_config.strategies
+        
+        # Verify Kiro is registered
+        self.assertIn(MCPHostType.KIRO, MCPHostRegistry._strategies)
+        
+        # Verify correct strategy class
+        strategy_class = MCPHostRegistry._strategies[MCPHostType.KIRO]
+        self.assertEqual(strategy_class.__name__, "KiroHostStrategy")
+    
+    @regression_test
+    def test_kiro_strategy_instantiation(self):
+        """Test that Kiro strategy can be instantiated."""
+        # Import strategies to trigger registration
+        import hatch.mcp_host_config.strategies
+        
+        strategy = MCPHostRegistry.get_strategy(MCPHostType.KIRO)
+        
+        # Verify strategy instance
+        self.assertIsNotNone(strategy)
+        self.assertEqual(strategy.__class__.__name__, "KiroHostStrategy")
+    
+    @regression_test
+    def test_kiro_in_host_detection(self):
+        """Test that Kiro appears in host detection."""
+        # Import strategies to trigger registration
+        import hatch.mcp_host_config.strategies
+        
+        # Get all registered host types
+        registered_hosts = list(MCPHostRegistry._strategies.keys())
+        
+        # Verify Kiro is included
+        self.assertIn(MCPHostType.KIRO, registered_hosts)
+    
+    @regression_test
+    def test_kiro_registry_consistency(self):
+        """Test that Kiro registration is consistent across calls."""
+        # Import strategies to trigger registration
+        import hatch.mcp_host_config.strategies
+        
+        # Get strategy multiple times
+        strategy1 = MCPHostRegistry.get_strategy(MCPHostType.KIRO)
+        strategy2 = MCPHostRegistry.get_strategy(MCPHostType.KIRO)
+        
+        # Verify same class (not necessarily same instance)
+        self.assertEqual(strategy1.__class__, strategy2.__class__)
+        self.assertEqual(strategy1.__class__.__name__, "KiroHostStrategy")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/test_mcp_kiro_host_strategy.py

@@ -0,0 +1,214 @@
+"""
+Kiro MCP Host Strategy Tests
+
+Tests for KiroHostStrategy implementation including path resolution,
+configuration read/write, and host detection.
+"""
+
+import unittest
+import json
+from unittest.mock import patch, mock_open, MagicMock
+from pathlib import Path
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.strategies import KiroHostStrategy
+from hatch.mcp_host_config.models import MCPServerConfig, HostConfiguration
+
+# Import test data loader from local tests module
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+from test_data_utils import MCPHostConfigTestDataLoader
+
+
+class TestKiroHostStrategy(unittest.TestCase):
+    """Test suite for KiroHostStrategy implementation."""
+    
+    def setUp(self):
+        """Set up test environment."""
+        self.strategy = KiroHostStrategy()
+        self.test_data_loader = MCPHostConfigTestDataLoader()
+    
+    @regression_test
+    def test_kiro_config_path_resolution(self):
+        """Test Kiro configuration path resolution."""
+        config_path = self.strategy.get_config_path()
+        
+        # Verify path structure (use normalized path for cross-platform compatibility)
+        self.assertIsNotNone(config_path)
+        normalized_path = str(config_path).replace('\\', '/')
+        self.assertTrue(normalized_path.endswith('.kiro/settings/mcp.json'))
+        self.assertEqual(config_path.name, 'mcp.json')
+    
+    @regression_test
+    def test_kiro_config_key(self):
+        """Test Kiro configuration key."""
+        config_key = self.strategy.get_config_key()
+        self.assertEqual(config_key, "mcpServers")
+    
+    @regression_test
+    def test_kiro_server_config_validation(self):
+        """Test Kiro server configuration validation."""
+        # Test local server validation
+        local_config = MCPServerConfig(
+            command="auggie",
+            args=["--mcp"]
+        )
+        self.assertTrue(self.strategy.validate_server_config(local_config))
+        
+        # Test remote server validation
+        remote_config = MCPServerConfig(
+            url="https://api.example.com/mcp"
+        )
+        self.assertTrue(self.strategy.validate_server_config(remote_config))
+        
+        # Test invalid configuration (should raise ValidationError during creation)
+        with self.assertRaises(Exception):  # Pydantic ValidationError
+            invalid_config = MCPServerConfig()
+            self.strategy.validate_server_config(invalid_config)
+    
+    @patch('pathlib.Path.exists')
+    @regression_test
+    def test_kiro_host_availability_detection(self, mock_exists):
+        """Test Kiro host availability detection."""
+        # Test when Kiro directory exists
+        mock_exists.return_value = True
+        self.assertTrue(self.strategy.is_host_available())
+        
+        # Test when Kiro directory doesn't exist
+        mock_exists.return_value = False
+        self.assertFalse(self.strategy.is_host_available())
+    
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('pathlib.Path.exists')
+    @patch('json.load')
+    @regression_test
+    def test_kiro_read_configuration_success(self, mock_json_load, mock_exists, mock_file):
+        """Test successful Kiro configuration reading."""
+        # Mock file exists and JSON content
+        mock_exists.return_value = True
+        mock_json_load.return_value = {
+            "mcpServers": {
+                "augment": {
+                    "command": "auggie",
+                    "args": ["--mcp", "-m", "default"],
+                    "autoApprove": ["codebase-retrieval"]
+                }
+            }
+        }
+        
+        config = self.strategy.read_configuration()
+        
+        # Verify configuration structure
+        self.assertIsInstance(config, HostConfiguration)
+        self.assertIn("augment", config.servers)
+        
+        server = config.servers["augment"]
+        self.assertEqual(server.command, "auggie")
+        self.assertEqual(len(server.args), 3)
+    
+    @patch('pathlib.Path.exists')
+    @regression_test
+    def test_kiro_read_configuration_file_not_exists(self, mock_exists):
+        """Test Kiro configuration reading when file doesn't exist."""
+        mock_exists.return_value = False
+        
+        config = self.strategy.read_configuration()
+        
+        # Should return empty configuration
+        self.assertIsInstance(config, HostConfiguration)
+        self.assertEqual(len(config.servers), 0)
+    
+    @patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager')
+    @patch('hatch.mcp_host_config.strategies.AtomicFileOperations')
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('pathlib.Path.exists')
+    @patch('pathlib.Path.mkdir')
+    @patch('json.load')
+    @regression_test
+    def test_kiro_write_configuration_success(self, mock_json_load, mock_mkdir, 
+                                            mock_exists, mock_file, mock_atomic_ops_class, mock_backup_manager_class):
+        """Test successful Kiro configuration writing."""
+        # Mock existing file with other settings
+        mock_exists.return_value = True
+        mock_json_load.return_value = {
+            "otherSettings": {"theme": "dark"},
+            "mcpServers": {}
+        }
+        
+        # Mock backup and atomic operations
+        mock_backup_manager = MagicMock()
+        mock_backup_manager_class.return_value = mock_backup_manager
+        
+        mock_atomic_ops = MagicMock()
+        mock_atomic_ops_class.return_value = mock_atomic_ops
+        
+        # Create test configuration
+        server_config = MCPServerConfig(
+            command="auggie",
+            args=["--mcp"]
+        )
+        config = HostConfiguration(servers={"test-server": server_config})
+        
+        result = self.strategy.write_configuration(config)
+        
+        # Verify success
+        self.assertTrue(result)
+        
+        # Verify atomic write was called
+        mock_atomic_ops.atomic_write_with_backup.assert_called_once()
+        
+        # Verify configuration structure in the call
+        call_args = mock_atomic_ops.atomic_write_with_backup.call_args
+        written_data = call_args[1]['data']  # keyword argument 'data'
+        self.assertIn("otherSettings", written_data)  # Preserved
+        self.assertIn("mcpServers", written_data)     # Updated
+        self.assertIn("test-server", written_data["mcpServers"])
+    
+    @patch('hatch.mcp_host_config.strategies.MCPHostConfigBackupManager')
+    @patch('hatch.mcp_host_config.strategies.AtomicFileOperations')
+    @patch('builtins.open', new_callable=mock_open)
+    @patch('pathlib.Path.exists')
+    @patch('pathlib.Path.mkdir')
+    @regression_test
+    def test_kiro_write_configuration_new_file(self, mock_mkdir, mock_exists, 
+                                             mock_file, mock_atomic_ops_class, mock_backup_manager_class):
+        """Test Kiro configuration writing when file doesn't exist."""
+        # Mock file doesn't exist
+        mock_exists.return_value = False
+        
+        # Mock backup and atomic operations
+        mock_backup_manager = MagicMock()
+        mock_backup_manager_class.return_value = mock_backup_manager
+        
+        mock_atomic_ops = MagicMock()
+        mock_atomic_ops_class.return_value = mock_atomic_ops
+        
+        # Create test configuration
+        server_config = MCPServerConfig(
+            command="auggie",
+            args=["--mcp"]
+        )
+        config = HostConfiguration(servers={"new-server": server_config})
+        
+        result = self.strategy.write_configuration(config)
+        
+        # Verify success
+        self.assertTrue(result)
+        
+        # Verify directory creation was attempted
+        mock_mkdir.assert_called_once()
+        
+        # Verify atomic write was called
+        mock_atomic_ops.atomic_write_with_backup.assert_called_once()
+        
+        # Verify configuration structure
+        call_args = mock_atomic_ops.atomic_write_with_backup.call_args
+        written_data = call_args[1]['data']  # keyword argument 'data'
+        self.assertIn("mcpServers", written_data)
+        self.assertIn("new-server", written_data["mcpServers"])
+
+
+if __name__ == '__main__':
+    unittest.main()