hatch-xclam 0.7.0__py3-none-any.whl

tests/test_mcp_sync_functionality.py

@@ -0,0 +1,316 @@
+"""
+Test suite for MCP synchronization functionality (Phase 3f).
+
+This module contains comprehensive tests for the advanced synchronization
+features including cross-environment and cross-host synchronization.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch, call
+from pathlib import Path
+import tempfile
+import json
+from typing import Dict, List, Optional
+
+# Import test decorators from wobble framework
+from wobble import integration_test, regression_test
+
+# Import the modules we'll be testing
+from hatch.mcp_host_config.host_management import MCPHostConfigurationManager, MCPHostType
+from hatch.mcp_host_config.models import (
+    EnvironmentData, MCPServerConfig, SyncResult, ConfigurationResult
+)
+from hatch.cli_hatch import handle_mcp_sync, parse_host_list, main
+
+
+class TestMCPSyncConfigurations(unittest.TestCase):
+    """Test suite for MCPHostConfigurationManager.sync_configurations() method."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.manager = MCPHostConfigurationManager()
+
+        # We'll use mocks instead of real data objects to avoid validation issues
+    
+    @regression_test
+    def test_sync_from_environment_to_single_host(self):
+        """Test basic environment-to-host synchronization."""
+        with patch.object(self.manager, 'sync_configurations') as mock_sync:
+            mock_result = SyncResult(
+                success=True,
+                results=[ConfigurationResult(success=True, hostname="claude-desktop")],
+                servers_synced=2,
+                hosts_updated=1
+            )
+            mock_sync.return_value = mock_result
+
+            result = self.manager.sync_configurations(
+                from_env="test-env",
+                to_hosts=["claude-desktop"]
+            )
+
+            self.assertTrue(result.success)
+            self.assertEqual(result.servers_synced, 2)
+            self.assertEqual(result.hosts_updated, 1)
+            mock_sync.assert_called_once()
+    
+    @integration_test(scope="component")
+    def test_sync_from_environment_to_multiple_hosts(self):
+        """Test environment-to-multiple-hosts synchronization."""
+        with patch.object(self.manager, 'sync_configurations') as mock_sync:
+            mock_result = SyncResult(
+                success=True,
+                results=[
+                    ConfigurationResult(success=True, hostname="claude-desktop"),
+                    ConfigurationResult(success=True, hostname="cursor")
+                ],
+                servers_synced=4,
+                hosts_updated=2
+            )
+            mock_sync.return_value = mock_result
+
+            result = self.manager.sync_configurations(
+                from_env="test-env",
+                to_hosts=["claude-desktop", "cursor"]
+            )
+
+            self.assertTrue(result.success)
+            self.assertEqual(result.servers_synced, 4)
+            self.assertEqual(result.hosts_updated, 2)
+    
+    @integration_test(scope="component")
+    def test_sync_from_host_to_host(self):
+        """Test host-to-host configuration synchronization."""
+        # This test will validate the new host-to-host sync functionality
+        # that needs to be implemented
+        with patch.object(self.manager.host_registry, 'get_strategy') as mock_get_strategy:
+            mock_strategy = MagicMock()
+            mock_strategy.read_configuration.return_value = MagicMock()
+            mock_strategy.write_configuration.return_value = True
+            mock_get_strategy.return_value = mock_strategy
+            
+            # Mock the sync_configurations method that we'll implement
+            with patch.object(self.manager, 'sync_configurations') as mock_sync:
+                mock_result = SyncResult(
+                    success=True,
+                    results=[ConfigurationResult(success=True, hostname="cursor")],
+                    servers_synced=2,
+                    hosts_updated=1
+                )
+                mock_sync.return_value = mock_result
+                
+                result = self.manager.sync_configurations(
+                    from_host="claude-desktop",
+                    to_hosts=["cursor"]
+                )
+                
+                self.assertTrue(result.success)
+                self.assertEqual(result.hosts_updated, 1)
+    
+    @integration_test(scope="component")
+    def test_sync_with_server_name_filter(self):
+        """Test synchronization with specific server names."""
+        with patch.object(self.manager, 'sync_configurations') as mock_sync:
+            mock_result = SyncResult(
+                success=True,
+                results=[ConfigurationResult(success=True, hostname="claude-desktop")],
+                servers_synced=1,  # Only one server due to filtering
+                hosts_updated=1
+            )
+            mock_sync.return_value = mock_result
+            
+            result = self.manager.sync_configurations(
+                from_env="test-env",
+                to_hosts=["claude-desktop"],
+                servers=["weather-toolkit"]
+            )
+            
+            self.assertTrue(result.success)
+            self.assertEqual(result.servers_synced, 1)
+    
+    @integration_test(scope="component")
+    def test_sync_with_pattern_filter(self):
+        """Test synchronization with regex pattern filter."""
+        with patch.object(self.manager, 'sync_configurations') as mock_sync:
+            mock_result = SyncResult(
+                success=True,
+                results=[ConfigurationResult(success=True, hostname="claude-desktop")],
+                servers_synced=1,  # Only servers matching pattern
+                hosts_updated=1
+            )
+            mock_sync.return_value = mock_result
+            
+            result = self.manager.sync_configurations(
+                from_env="test-env",
+                to_hosts=["claude-desktop"],
+                pattern="weather-.*"
+            )
+            
+            self.assertTrue(result.success)
+            self.assertEqual(result.servers_synced, 1)
+    
+    @regression_test
+    def test_sync_invalid_source_environment(self):
+        """Test synchronization with non-existent source environment."""
+        with patch.object(self.manager, 'sync_configurations') as mock_sync:
+            mock_result = SyncResult(
+                success=False,
+                results=[ConfigurationResult(
+                    success=False, 
+                    hostname="claude-desktop",
+                    error_message="Environment 'nonexistent' not found"
+                )],
+                servers_synced=0,
+                hosts_updated=0
+            )
+            mock_sync.return_value = mock_result
+            
+            result = self.manager.sync_configurations(
+                from_env="nonexistent",
+                to_hosts=["claude-desktop"]
+            )
+            
+            self.assertFalse(result.success)
+            self.assertEqual(result.servers_synced, 0)
+    
+    @regression_test
+    def test_sync_no_source_specified(self):
+        """Test synchronization without source specification."""
+        with self.assertRaises(ValueError) as context:
+            self.manager.sync_configurations(to_hosts=["claude-desktop"])
+        
+        self.assertIn("Must specify either from_env or from_host", str(context.exception))
+    
+    @regression_test
+    def test_sync_both_sources_specified(self):
+        """Test synchronization with both env and host sources."""
+        with self.assertRaises(ValueError) as context:
+            self.manager.sync_configurations(
+                from_env="test-env",
+                from_host="claude-desktop",
+                to_hosts=["cursor"]
+            )
+        
+        self.assertIn("Cannot specify both from_env and from_host", str(context.exception))
+
+
+class TestMCPSyncCommandParsing(unittest.TestCase):
+    """Test suite for MCP sync command argument parsing."""
+    
+    @regression_test
+    def test_sync_command_basic_parsing(self):
+        """Test basic sync command argument parsing."""
+        test_args = [
+            'hatch', 'mcp', 'sync', 
+            '--from-env', 'test-env', 
+            '--to-host', 'claude-desktop'
+        ]
+        
+        with patch('sys.argv', test_args):
+            with patch('hatch.cli_hatch.HatchEnvironmentManager'):
+                with patch('hatch.cli_hatch.handle_mcp_sync', return_value=0) as mock_handler:
+                    try:
+                        main()
+                        mock_handler.assert_called_once_with(
+                            from_env='test-env',
+                            from_host=None,
+                            to_hosts='claude-desktop',
+                            servers=None,
+                            pattern=None,
+                            dry_run=False,
+                            auto_approve=False,
+                            no_backup=False
+                        )
+                    except SystemExit as e:
+                        self.assertEqual(e.code, 0)
+    
+    @regression_test
+    def test_sync_command_with_filters(self):
+        """Test sync command with server filters."""
+        test_args = [
+            'hatch', 'mcp', 'sync',
+            '--from-env', 'test-env',
+            '--to-host', 'claude-desktop,cursor',
+            '--servers', 'weather-api,file-manager',
+            '--dry-run'
+        ]
+        
+        with patch('sys.argv', test_args):
+            with patch('hatch.cli_hatch.HatchEnvironmentManager'):
+                with patch('hatch.cli_hatch.handle_mcp_sync', return_value=0) as mock_handler:
+                    try:
+                        main()
+                        mock_handler.assert_called_once_with(
+                            from_env='test-env',
+                            from_host=None,
+                            to_hosts='claude-desktop,cursor',
+                            servers='weather-api,file-manager',
+                            pattern=None,
+                            dry_run=True,
+                            auto_approve=False,
+                            no_backup=False
+                        )
+                    except SystemExit as e:
+                        self.assertEqual(e.code, 0)
+
+
+class TestMCPSyncCommandHandler(unittest.TestCase):
+    """Test suite for MCP sync command handler."""
+    
+    @integration_test(scope="component")
+    def test_handle_sync_environment_to_host(self):
+        """Test sync handler for environment-to-host operation."""
+        with patch('hatch.cli_hatch.MCPHostConfigurationManager') as mock_manager_class:
+            mock_manager = MagicMock()
+            mock_result = SyncResult(
+                success=True,
+                results=[ConfigurationResult(success=True, hostname="claude-desktop")],
+                servers_synced=2,
+                hosts_updated=1
+            )
+            mock_manager.sync_configurations.return_value = mock_result
+            mock_manager_class.return_value = mock_manager
+
+            with patch('builtins.print') as mock_print:
+                with patch('hatch.cli_hatch.parse_host_list') as mock_parse:
+                    with patch('hatch.cli_hatch.request_confirmation', return_value=True) as mock_confirm:
+                        from hatch.mcp_host_config.models import MCPHostType
+                        mock_parse.return_value = [MCPHostType.CLAUDE_DESKTOP]
+
+                        result = handle_mcp_sync(
+                            from_env="test-env",
+                            to_hosts="claude-desktop"
+                        )
+
+                        self.assertEqual(result, 0)
+                        mock_manager.sync_configurations.assert_called_once()
+                        mock_confirm.assert_called_once()
+
+                        # Verify success output
+                        print_calls = [call[0][0] for call in mock_print.call_args_list]
+                        self.assertTrue(any("[SUCCESS] Synchronization completed" in call for call in print_calls))
+    
+    @integration_test(scope="component")
+    def test_handle_sync_dry_run(self):
+        """Test sync handler dry-run functionality."""
+        with patch('builtins.print') as mock_print:
+            with patch('hatch.cli_hatch.parse_host_list') as mock_parse:
+                from hatch.mcp_host_config.models import MCPHostType
+                mock_parse.return_value = [MCPHostType.CLAUDE_DESKTOP]
+
+                result = handle_mcp_sync(
+                    from_env="test-env",
+                    to_hosts="claude-desktop",
+                    dry_run=True
+                )
+
+                self.assertEqual(result, 0)
+
+                # Verify dry-run output
+                print_calls = [call[0][0] for call in mock_print.call_args_list]
+                self.assertTrue(any("[DRY RUN] Would synchronize" in call for call in print_calls))
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_mcp_user_feedback_reporting.py

@@ -0,0 +1,359 @@
+"""
+Test suite for MCP user feedback reporting system.
+
+This module tests the FieldOperation and ConversionReport models,
+generate_conversion_report() function, and display_report() function.
+"""
+
+import unittest
+import sys
+from pathlib import Path
+from io import StringIO
+
+# Add the parent directory to the path to import wobble
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+try:
+    from wobble.decorators import regression_test
+except ImportError:
+    # Fallback decorator if wobble is not available
+    def regression_test(func):
+        return func
+
+from hatch.mcp_host_config.reporting import (
+    FieldOperation,
+    ConversionReport,
+    generate_conversion_report,
+    display_report
+)
+from hatch.mcp_host_config.models import (
+    MCPServerConfigOmni,
+    MCPHostType
+)
+
+
+class TestFieldOperation(unittest.TestCase):
+    """Test suite for FieldOperation model."""
+    
+    @regression_test
+    def test_field_operation_updated_str_representation(self):
+        """Test UPDATED operation string representation."""
+        field_op = FieldOperation(
+            field_name="command",
+            operation="UPDATED",
+            old_value="old_command",
+            new_value="new_command"
+        )
+        
+        result = str(field_op)
+        
+        # Verify ASCII arrow used (not Unicode)
+        self.assertIn("-->", result)
+        self.assertNotIn("→", result)
+        
+        # Verify format
+        self.assertEqual(result, "command: UPDATED 'old_command' --> 'new_command'")
+    
+    @regression_test
+    def test_field_operation_updated_with_none_old_value(self):
+        """Test UPDATED operation with None old_value (field added)."""
+        field_op = FieldOperation(
+            field_name="timeout",
+            operation="UPDATED",
+            old_value=None,
+            new_value=30000
+        )
+        
+        result = str(field_op)
+        
+        # Verify None is displayed
+        self.assertEqual(result, "timeout: UPDATED None --> 30000")
+    
+    @regression_test
+    def test_field_operation_unsupported_str_representation(self):
+        """Test UNSUPPORTED operation string representation."""
+        field_op = FieldOperation(
+            field_name="envFile",
+            operation="UNSUPPORTED",
+            new_value=".env"
+        )
+        
+        result = str(field_op)
+        
+        # Verify format
+        self.assertEqual(result, "envFile: UNSUPPORTED")
+    
+    @regression_test
+    def test_field_operation_unchanged_str_representation(self):
+        """Test UNCHANGED operation string representation."""
+        field_op = FieldOperation(
+            field_name="name",
+            operation="UNCHANGED",
+            new_value="my-server"
+        )
+        
+        result = str(field_op)
+        
+        # Verify format
+        self.assertEqual(result, "name: UNCHANGED 'my-server'")
+
+
+class TestConversionReport(unittest.TestCase):
+    """Test suite for ConversionReport model."""
+    
+    @regression_test
+    def test_conversion_report_create_operation(self):
+        """Test ConversionReport with create operation."""
+        report = ConversionReport(
+            operation="create",
+            server_name="my-server",
+            target_host=MCPHostType.GEMINI,
+            field_operations=[
+                FieldOperation(field_name="command", operation="UPDATED", old_value=None, new_value="python")
+            ]
+        )
+        
+        self.assertEqual(report.operation, "create")
+        self.assertEqual(report.server_name, "my-server")
+        self.assertEqual(report.target_host, MCPHostType.GEMINI)
+        self.assertTrue(report.success)
+        self.assertIsNone(report.error_message)
+        self.assertEqual(len(report.field_operations), 1)
+        self.assertFalse(report.dry_run)
+    
+    @regression_test
+    def test_conversion_report_update_operation(self):
+        """Test ConversionReport with update operation."""
+        report = ConversionReport(
+            operation="update",
+            server_name="my-server",
+            target_host=MCPHostType.VSCODE,
+            field_operations=[
+                FieldOperation(field_name="command", operation="UPDATED", old_value="old", new_value="new"),
+                FieldOperation(field_name="name", operation="UNCHANGED", new_value="my-server")
+            ]
+        )
+        
+        self.assertEqual(report.operation, "update")
+        self.assertEqual(len(report.field_operations), 2)
+    
+    @regression_test
+    def test_conversion_report_migrate_operation(self):
+        """Test ConversionReport with migrate operation."""
+        report = ConversionReport(
+            operation="migrate",
+            server_name="my-server",
+            source_host=MCPHostType.GEMINI,
+            target_host=MCPHostType.VSCODE,
+            field_operations=[]
+        )
+        
+        self.assertEqual(report.operation, "migrate")
+        self.assertEqual(report.source_host, MCPHostType.GEMINI)
+        self.assertEqual(report.target_host, MCPHostType.VSCODE)
+
+
+class TestGenerateConversionReport(unittest.TestCase):
+    """Test suite for generate_conversion_report() function."""
+    
+    @regression_test
+    def test_generate_report_create_operation_all_supported(self):
+        """Test generate_conversion_report for create with all supported fields."""
+        omni = MCPServerConfigOmni(
+            name="gemini-server",
+            command="npx",
+            args=["-y", "server"],
+            cwd="/path/to/dir",
+            timeout=30000
+        )
+        
+        report = generate_conversion_report(
+            operation="create",
+            server_name="gemini-server",
+            target_host=MCPHostType.GEMINI,
+            omni=omni
+        )
+        
+        # Verify all fields are UPDATED (create operation)
+        self.assertEqual(report.operation, "create")
+        self.assertEqual(report.server_name, "gemini-server")
+        self.assertEqual(report.target_host, MCPHostType.GEMINI)
+        
+        # All set fields should be UPDATED
+        updated_ops = [op for op in report.field_operations if op.operation == "UPDATED"]
+        self.assertEqual(len(updated_ops), 5)  # name, command, args, cwd, timeout
+        
+        # No unsupported fields
+        unsupported_ops = [op for op in report.field_operations if op.operation == "UNSUPPORTED"]
+        self.assertEqual(len(unsupported_ops), 0)
+    
+    @regression_test
+    def test_generate_report_create_operation_with_unsupported(self):
+        """Test generate_conversion_report with unsupported fields."""
+        omni = MCPServerConfigOmni(
+            name="gemini-server",
+            command="python",
+            cwd="/path/to/dir",  # Gemini field
+            envFile=".env"  # VS Code field (unsupported by Gemini)
+        )
+        
+        report = generate_conversion_report(
+            operation="create",
+            server_name="gemini-server",
+            target_host=MCPHostType.GEMINI,
+            omni=omni
+        )
+        
+        # Verify Gemini fields are UPDATED
+        updated_ops = [op for op in report.field_operations if op.operation == "UPDATED"]
+        updated_fields = {op.field_name for op in updated_ops}
+        self.assertIn("name", updated_fields)
+        self.assertIn("command", updated_fields)
+        self.assertIn("cwd", updated_fields)
+        
+        # Verify VS Code field is UNSUPPORTED
+        unsupported_ops = [op for op in report.field_operations if op.operation == "UNSUPPORTED"]
+        self.assertEqual(len(unsupported_ops), 1)
+        self.assertEqual(unsupported_ops[0].field_name, "envFile")
+    
+    @regression_test
+    def test_generate_report_update_operation(self):
+        """Test generate_conversion_report for update operation."""
+        old_config = MCPServerConfigOmni(
+            name="my-server",
+            command="python",
+            args=["old.py"]
+        )
+        
+        new_omni = MCPServerConfigOmni(
+            name="my-server",
+            command="python",
+            args=["new.py"]
+        )
+        
+        report = generate_conversion_report(
+            operation="update",
+            server_name="my-server",
+            target_host=MCPHostType.GEMINI,
+            omni=new_omni,
+            old_config=old_config
+        )
+        
+        # Verify name and command are UNCHANGED
+        unchanged_ops = [op for op in report.field_operations if op.operation == "UNCHANGED"]
+        unchanged_fields = {op.field_name for op in unchanged_ops}
+        self.assertIn("name", unchanged_fields)
+        self.assertIn("command", unchanged_fields)
+        
+        # Verify args is UPDATED
+        updated_ops = [op for op in report.field_operations if op.operation == "UPDATED"]
+        self.assertEqual(len(updated_ops), 1)
+        self.assertEqual(updated_ops[0].field_name, "args")
+        self.assertEqual(updated_ops[0].old_value, ["old.py"])
+        self.assertEqual(updated_ops[0].new_value, ["new.py"])
+    
+    @regression_test
+    def test_generate_report_dynamic_field_derivation(self):
+        """Test that generate_conversion_report uses dynamic field derivation."""
+        omni = MCPServerConfigOmni(
+            name="test-server",
+            command="python"
+        )
+        
+        # Generate report for Gemini
+        report_gemini = generate_conversion_report(
+            operation="create",
+            server_name="test-server",
+            target_host=MCPHostType.GEMINI,
+            omni=omni
+        )
+        
+        # All fields should be UPDATED (no unsupported)
+        unsupported_ops = [op for op in report_gemini.field_operations if op.operation == "UNSUPPORTED"]
+        self.assertEqual(len(unsupported_ops), 0)
+
+
+class TestDisplayReport(unittest.TestCase):
+    """Test suite for display_report() function."""
+    
+    @regression_test
+    def test_display_report_create_operation(self):
+        """Test display_report for create operation."""
+        report = ConversionReport(
+            operation="create",
+            server_name="my-server",
+            target_host=MCPHostType.GEMINI,
+            field_operations=[
+                FieldOperation(field_name="command", operation="UPDATED", old_value=None, new_value="python")
+            ]
+        )
+        
+        # Capture stdout
+        captured_output = StringIO()
+        sys.stdout = captured_output
+        
+        display_report(report)
+        
+        sys.stdout = sys.__stdout__
+        output = captured_output.getvalue()
+        
+        # Verify header
+        self.assertIn("Server 'my-server' created for host", output)
+        self.assertIn("gemini", output.lower())
+        
+        # Verify field operation displayed
+        self.assertIn("command: UPDATED", output)
+    
+    @regression_test
+    def test_display_report_update_operation(self):
+        """Test display_report for update operation."""
+        report = ConversionReport(
+            operation="update",
+            server_name="my-server",
+            target_host=MCPHostType.VSCODE,
+            field_operations=[
+                FieldOperation(field_name="args", operation="UPDATED", old_value=["old.py"], new_value=["new.py"])
+            ]
+        )
+        
+        # Capture stdout
+        captured_output = StringIO()
+        sys.stdout = captured_output
+        
+        display_report(report)
+        
+        sys.stdout = sys.__stdout__
+        output = captured_output.getvalue()
+        
+        # Verify header
+        self.assertIn("Server 'my-server' updated for host", output)
+    
+    @regression_test
+    def test_display_report_dry_run(self):
+        """Test display_report for dry-run mode."""
+        report = ConversionReport(
+            operation="create",
+            server_name="my-server",
+            target_host=MCPHostType.GEMINI,
+            field_operations=[],
+            dry_run=True
+        )
+        
+        # Capture stdout
+        captured_output = StringIO()
+        sys.stdout = captured_output
+        
+        display_report(report)
+        
+        sys.stdout = sys.__stdout__
+        output = captured_output.getvalue()
+        
+        # Verify dry-run header and footer
+        self.assertIn("[DRY RUN]", output)
+        self.assertIn("Preview of changes", output)
+        self.assertIn("No changes were made", output)
+
+
+if __name__ == '__main__':
+    unittest.main()
+