hatch-xclam 0.7.1.dev3__py3-none-any.whl → 0.8.0.dev1__py3-none-any.whl

tests/test_mcp_sync_functionality.py

@@ -1,316 +0,0 @@
-"""
-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

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