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

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()

tests/regression/test_mcp_kiro_model_validation.py

@@ -0,0 +1,116 @@
+"""
+Kiro MCP Model Validation Tests
+
+Tests for MCPServerConfigKiro Pydantic model behavior, field validation,
+and Kiro-specific field combinations.
+"""
+
+import unittest
+from typing import Optional, List
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.models import (
+    MCPServerConfigKiro,
+    MCPServerConfigOmni,
+    MCPHostType
+)
+
+
+class TestMCPServerConfigKiro(unittest.TestCase):
+    """Test suite for MCPServerConfigKiro model validation."""
+    
+    @regression_test
+    def test_kiro_model_with_disabled_field(self):
+        """Test Kiro model with disabled field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp", "-m", "default"],
+            disabled=True
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertTrue(config.disabled)
+        self.assertEqual(config.type, "stdio")  # Inferred
+    
+    @regression_test
+    def test_kiro_model_with_auto_approve_tools(self):
+        """Test Kiro model with autoApprove field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            autoApprove=["codebase-retrieval", "fetch"]
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertEqual(len(config.autoApprove), 2)
+        self.assertIn("codebase-retrieval", config.autoApprove)
+        self.assertIn("fetch", config.autoApprove)
+    
+    @regression_test
+    def test_kiro_model_with_disabled_tools(self):
+        """Test Kiro model with disabledTools field."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="python",
+            disabledTools=["dangerous-tool", "risky-tool"]
+        )
+        
+        self.assertEqual(config.command, "python")
+        self.assertEqual(len(config.disabledTools), 2)
+        self.assertIn("dangerous-tool", config.disabledTools)
+    
+    @regression_test
+    def test_kiro_model_all_fields_combined(self):
+        """Test Kiro model with all Kiro-specific fields."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp"],
+            env={"DEBUG": "true"},
+            disabled=False,
+            autoApprove=["codebase-retrieval"],
+            disabledTools=["dangerous-tool"]
+        )
+        
+        # Verify all fields
+        self.assertEqual(config.command, "auggie")
+        self.assertFalse(config.disabled)
+        self.assertEqual(len(config.autoApprove), 1)
+        self.assertEqual(len(config.disabledTools), 1)
+        self.assertEqual(config.env["DEBUG"], "true")
+    
+    @regression_test
+    def test_kiro_model_minimal_configuration(self):
+        """Test Kiro model with minimal configuration."""
+        config = MCPServerConfigKiro(
+            name="kiro-server",
+            command="auggie"
+        )
+        
+        self.assertEqual(config.command, "auggie")
+        self.assertEqual(config.type, "stdio")  # Inferred
+        self.assertIsNone(config.disabled)
+        self.assertIsNone(config.autoApprove)
+        self.assertIsNone(config.disabledTools)
+    
+    @regression_test
+    def test_kiro_model_remote_server_with_kiro_fields(self):
+        """Test Kiro model with remote server and Kiro-specific fields."""
+        config = MCPServerConfigKiro(
+            name="kiro-remote",
+            url="https://api.example.com/mcp",
+            headers={"Authorization": "Bearer token"},
+            disabled=True,
+            autoApprove=["safe-tool"]
+        )
+        
+        self.assertEqual(config.url, "https://api.example.com/mcp")
+        self.assertTrue(config.disabled)
+        self.assertEqual(len(config.autoApprove), 1)
+        self.assertEqual(config.type, "sse")  # Inferred for remote
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/test_mcp_kiro_omni_conversion.py

@@ -0,0 +1,104 @@
+"""
+Kiro MCP Omni Conversion Tests
+
+Tests for conversion from MCPServerConfigOmni to MCPServerConfigKiro
+using the from_omni() method.
+"""
+
+import unittest
+
+from wobble.decorators import regression_test
+
+from hatch.mcp_host_config.models import (
+    MCPServerConfigKiro,
+    MCPServerConfigOmni
+)
+
+
+class TestKiroFromOmniConversion(unittest.TestCase):
+    """Test suite for Kiro from_omni() conversion method."""
+    
+    @regression_test
+    def test_kiro_from_omni_with_supported_fields(self):
+        """Test Kiro from_omni with supported fields."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="auggie",
+            args=["--mcp", "-m", "default"],
+            disabled=True,
+            autoApprove=["codebase-retrieval", "fetch"],
+            disabledTools=["dangerous-tool"]
+        )
+        
+        # Convert to Kiro model
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify all supported fields transferred
+        self.assertEqual(kiro.name, "kiro-server")
+        self.assertEqual(kiro.command, "auggie")
+        self.assertEqual(len(kiro.args), 3)
+        self.assertTrue(kiro.disabled)
+        self.assertEqual(len(kiro.autoApprove), 2)
+        self.assertEqual(len(kiro.disabledTools), 1)
+    
+    @regression_test
+    def test_kiro_from_omni_with_unsupported_fields(self):
+        """Test Kiro from_omni excludes unsupported fields."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="python",
+            disabled=True,  # Kiro field
+            envFile=".env",  # VS Code field (unsupported by Kiro)
+            timeout=30000   # Gemini field (unsupported by Kiro)
+        )
+        
+        # Convert to Kiro model
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify Kiro fields transferred
+        self.assertEqual(kiro.command, "python")
+        self.assertTrue(kiro.disabled)
+        
+        # Verify unsupported fields NOT transferred
+        self.assertFalse(hasattr(kiro, 'envFile') and kiro.envFile is not None)
+        self.assertFalse(hasattr(kiro, 'timeout') and kiro.timeout is not None)
+    
+    @regression_test
+    def test_kiro_from_omni_exclude_unset_behavior(self):
+        """Test that from_omni respects exclude_unset=True."""
+        omni = MCPServerConfigOmni(
+            name="kiro-server",
+            command="auggie"
+            # disabled, autoApprove, disabledTools not set
+        )
+        
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify unset fields remain None
+        self.assertIsNone(kiro.disabled)
+        self.assertIsNone(kiro.autoApprove)
+        self.assertIsNone(kiro.disabledTools)
+    
+    @regression_test
+    def test_kiro_from_omni_remote_server_conversion(self):
+        """Test Kiro from_omni with remote server configuration."""
+        omni = MCPServerConfigOmni(
+            name="kiro-remote",
+            url="https://api.example.com/mcp",
+            headers={"Authorization": "Bearer token"},
+            disabled=False,
+            autoApprove=["safe-tool"]
+        )
+        
+        kiro = MCPServerConfigKiro.from_omni(omni)
+        
+        # Verify remote server fields
+        self.assertEqual(kiro.url, "https://api.example.com/mcp")
+        self.assertEqual(kiro.headers["Authorization"], "Bearer token")
+        self.assertFalse(kiro.disabled)
+        self.assertEqual(len(kiro.autoApprove), 1)
+        self.assertEqual(kiro.type, "sse")  # Inferred for remote
+
+
+if __name__ == '__main__':
+    unittest.main()