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

tests/regression/cli/test_table_formatter.py

@@ -0,0 +1,211 @@
+"""Regression tests for TableFormatter class.
+
+Tests focus on behavioral contracts for table rendering:
+- Column alignment (left, right, center)
+- Auto-width calculation
+- Header and separator rendering
+- Row data handling
+
+Reference: R02 §5 (02-list_output_format_specification_v2.md)
+Reference: R06 §3.6 (06-dependency_analysis_v0.md)
+"""
+
+import pytest
+
+
+class TestColumnDef:
+    """Tests for ColumnDef dataclass."""
+
+    def test_column_def_has_required_fields(self):
+        """ColumnDef must have name, width, and align fields."""
+        from hatch.cli.cli_utils import ColumnDef
+        
+        col = ColumnDef(name="Test", width=10)
+        assert col.name == "Test"
+        assert col.width == 10
+        assert col.align == "left"  # Default alignment
+
+    def test_column_def_accepts_auto_width(self):
+        """ColumnDef width can be 'auto' for auto-calculation."""
+        from hatch.cli.cli_utils import ColumnDef
+        
+        col = ColumnDef(name="Test", width="auto")
+        assert col.width == "auto"
+
+    def test_column_def_accepts_alignment_options(self):
+        """ColumnDef supports left, right, and center alignment."""
+        from hatch.cli.cli_utils import ColumnDef
+        
+        left = ColumnDef(name="Left", width=10, align="left")
+        right = ColumnDef(name="Right", width=10, align="right")
+        center = ColumnDef(name="Center", width=10, align="center")
+        
+        assert left.align == "left"
+        assert right.align == "right"
+        assert center.align == "center"
+
+
+class TestTableFormatter:
+    """Tests for TableFormatter class."""
+
+    def test_table_formatter_accepts_column_definitions(self):
+        """TableFormatter initializes with column definitions."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [
+            ColumnDef(name="Name", width=20),
+            ColumnDef(name="Value", width=10),
+        ]
+        formatter = TableFormatter(columns)
+        assert formatter is not None
+
+    def test_add_row_stores_data(self):
+        """add_row stores row data for rendering."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Col1", width=10)]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["value1"])
+        formatter.add_row(["value2"])
+        
+        # Verify rows are stored (implementation detail, but necessary for render)
+        assert len(formatter._rows) == 2
+
+    def test_render_produces_string_output(self):
+        """render() returns a string with table content."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Name", width=10)]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["Test"])
+        
+        output = formatter.render()
+        assert isinstance(output, str)
+        assert len(output) > 0
+
+    def test_render_includes_header_row(self):
+        """Rendered output includes column headers."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [
+            ColumnDef(name="Name", width=15),
+            ColumnDef(name="Status", width=10),
+        ]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["test-item", "active"])
+        
+        output = formatter.render()
+        assert "Name" in output
+        assert "Status" in output
+
+    def test_render_includes_separator_line(self):
+        """Rendered output includes separator line after headers."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Name", width=10)]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["Test"])
+        
+        output = formatter.render()
+        # Separator uses box-drawing character or dashes
+        assert "─" in output or "-" in output
+
+    def test_render_includes_data_rows(self):
+        """Rendered output includes all added data rows."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Item", width=15)]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["first-item"])
+        formatter.add_row(["second-item"])
+        formatter.add_row(["third-item"])
+        
+        output = formatter.render()
+        assert "first-item" in output
+        assert "second-item" in output
+        assert "third-item" in output
+
+    def test_left_alignment_pads_right(self):
+        """Left-aligned columns pad values on the right."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Name", width=10, align="left")]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["abc"])
+        
+        output = formatter.render()
+        lines = output.strip().split("\n")
+        # Find data row (skip header and separator)
+        data_line = lines[-1]
+        # Left-aligned: value followed by spaces
+        assert "abc" in data_line
+
+    def test_right_alignment_pads_left(self):
+        """Right-aligned columns pad values on the left."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Count", width=10, align="right")]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["42"])
+        
+        output = formatter.render()
+        lines = output.strip().split("\n")
+        data_line = lines[-1]
+        # Right-aligned: spaces followed by value
+        assert "42" in data_line
+
+    def test_auto_width_calculates_from_content(self):
+        """Auto width calculates based on header and data content."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Name", width="auto")]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["short"])
+        formatter.add_row(["much-longer-value"])
+        
+        output = formatter.render()
+        # Output should accommodate the longest value
+        assert "much-longer-value" in output
+
+    def test_empty_table_renders_headers_only(self):
+        """Table with no rows renders headers and separator."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Empty", width=10)]
+        formatter = TableFormatter(columns)
+        
+        output = formatter.render()
+        assert "Empty" in output
+        # Should have header and separator, but no data rows
+
+    def test_multiple_columns_separated(self):
+        """Multiple columns are visually separated."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [
+            ColumnDef(name="Col1", width=10),
+            ColumnDef(name="Col2", width=10),
+            ColumnDef(name="Col3", width=10),
+        ]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["a", "b", "c"])
+        
+        output = formatter.render()
+        assert "Col1" in output
+        assert "Col2" in output
+        assert "Col3" in output
+        assert "a" in output
+        assert "b" in output
+        assert "c" in output
+
+    def test_truncation_with_ellipsis(self):
+        """Values exceeding column width are truncated with ellipsis."""
+        from hatch.cli.cli_utils import TableFormatter, ColumnDef
+        
+        columns = [ColumnDef(name="Name", width=8)]
+        formatter = TableFormatter(columns)
+        formatter.add_row(["very-long-value-that-exceeds-width"])
+        
+        output = formatter.render()
+        # Should truncate and add ellipsis
+        assert "…" in output or "..." in output

tests/regression/mcp/test_field_filtering.py

@@ -0,0 +1,162 @@
+"""Regression tests for field filtering (name/type exclusion).
+
+Test IDs: RF-01 to RF-07 (per 02-test_architecture_rebuild_v0.md)
+Scope: Prevent `name` and `type` field leakage in serialized output.
+"""
+
+import unittest
+
+from hatch.mcp_host_config.models import MCPServerConfig
+from hatch.mcp_host_config.adapters import (
+    ClaudeAdapter,
+    CodexAdapter,
+    CursorAdapter,
+    GeminiAdapter,
+    KiroAdapter,
+    VSCodeAdapter,
+)
+
+
+class TestFieldFiltering(unittest.TestCase):
+    """Regression tests for field filtering (RF-01 to RF-07).
+    
+    These tests ensure:
+    - `name` is NEVER in serialized output (it's Hatch metadata, not host config)
+    - `type` behavior varies by host (some include, some exclude)
+    """
+
+    def setUp(self):
+        """Create test configs for use across tests."""
+        # Config WITH type (for hosts that support type field)
+        self.stdio_config_with_type = MCPServerConfig(
+            name="test-server",
+            command="python",
+            args=["server.py"],
+            type="stdio",
+        )
+
+        # Config WITHOUT type (for hosts that don't support type field)
+        self.stdio_config_no_type = MCPServerConfig(
+            name="test-server",
+            command="python",
+            args=["server.py"],
+        )
+
+        self.sse_config_with_type = MCPServerConfig(
+            name="sse-server",
+            url="https://example.com/mcp",
+            type="sse",
+        )
+
+        self.sse_config_no_type = MCPServerConfig(
+            name="sse-server",
+            url="https://example.com/mcp",
+        )
+
+    def test_RF01_name_never_in_gemini_output(self):
+        """RF-01: `name` never appears in Gemini serialized output."""
+        adapter = GeminiAdapter()
+        result = adapter.serialize(self.stdio_config_no_type)
+
+        self.assertNotIn("name", result)
+
+    def test_RF02_name_never_in_claude_output(self):
+        """RF-02: `name` never appears in Claude serialized output."""
+        adapter = ClaudeAdapter()
+        result = adapter.serialize(self.stdio_config_with_type)
+
+        self.assertNotIn("name", result)
+
+    def test_RF03_type_not_in_gemini_output(self):
+        """RF-03: `type` should NOT be in Gemini output.
+
+        Gemini's config format infers type from the presence of
+        command/url/httpUrl fields.
+        """
+        adapter = GeminiAdapter()
+        result = adapter.serialize(self.stdio_config_no_type)
+
+        self.assertNotIn("type", result)
+
+    def test_RF04_type_not_in_kiro_output(self):
+        """RF-04: `type` should NOT be in Kiro output.
+
+        Kiro's config format infers type from the presence of
+        command/url fields.
+        """
+        adapter = KiroAdapter()
+        result = adapter.serialize(self.stdio_config_no_type)
+
+        self.assertNotIn("type", result)
+
+    def test_RF05_type_not_in_codex_output(self):
+        """RF-05: `type` should NOT be in Codex output.
+
+        Codex TOML format doesn't use type field - it uses section headers.
+        """
+        adapter = CodexAdapter()
+        result = adapter.serialize(self.stdio_config_no_type)
+
+        self.assertNotIn("type", result)
+
+    def test_RF06_type_IS_in_claude_output(self):
+        """RF-06: `type` SHOULD be in Claude output.
+
+        Claude Desktop/Code explicitly uses the type field for transport.
+        """
+        adapter = ClaudeAdapter()
+        result = adapter.serialize(self.stdio_config_with_type)
+
+        self.assertIn("type", result)
+        self.assertEqual(result["type"], "stdio")
+
+    def test_RF07_type_IS_in_vscode_output(self):
+        """RF-07: `type` SHOULD be in VS Code output.
+
+        VS Code explicitly uses the type field for transport.
+        """
+        adapter = VSCodeAdapter()
+        result = adapter.serialize(self.stdio_config_with_type)
+
+        self.assertIn("type", result)
+        self.assertEqual(result["type"], "stdio")
+
+    def test_name_never_in_any_adapter_output(self):
+        """Comprehensive test: `name` never appears in ANY adapter output.
+
+        Uses appropriate config for each adapter (with/without type field).
+        """
+        type_supporting_adapters = [
+            ClaudeAdapter(),
+            CursorAdapter(),
+            VSCodeAdapter(),
+        ]
+
+        type_rejecting_adapters = [
+            CodexAdapter(),
+            GeminiAdapter(),
+            KiroAdapter(),
+        ]
+
+        for adapter in type_supporting_adapters:
+            with self.subTest(adapter=adapter.host_name):
+                result = adapter.serialize(self.stdio_config_with_type)
+                self.assertNotIn("name", result)
+
+        for adapter in type_rejecting_adapters:
+            with self.subTest(adapter=adapter.host_name):
+                result = adapter.serialize(self.stdio_config_no_type)
+                self.assertNotIn("name", result)
+
+    def test_cursor_type_behavior(self):
+        """Test Cursor type field behavior (same as VS Code)."""
+        adapter = CursorAdapter()
+        result = adapter.serialize(self.stdio_config_with_type)
+
+        # Cursor should include type like VS Code
+        self.assertIn("type", result)
+
+
+if __name__ == "__main__":
+    unittest.main()
+

tests/test_cli_version.py

@@ -20,7 +20,8 @@ from io import StringIO
 # Add parent directory to path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
-from hatch.cli_hatch import main, get_hatch_version
+from hatch.cli_hatch import main
+from hatch.cli.cli_utils import get_hatch_version
 
 try:
     from wobble.decorators import regression_test, integration_test
@@ -41,7 +42,7 @@ class TestVersionCommand(unittest.TestCase):
     @regression_test
     def test_get_hatch_version_retrieves_from_metadata(self):
         """Test get_hatch_version() retrieves version from importlib.metadata."""
-        with patch('hatch.cli_hatch.version', return_value='0.7.0-dev.3') as mock_version:
+        with patch('hatch.cli.cli_utils.version', return_value='0.7.0-dev.3') as mock_version:
             result = get_hatch_version()
 
             self.assertEqual(result, '0.7.0-dev.3')
@@ -52,7 +53,7 @@ class TestVersionCommand(unittest.TestCase):
         """Test get_hatch_version() handles PackageNotFoundError gracefully."""
         from importlib.metadata import PackageNotFoundError
 
-        with patch('hatch.cli_hatch.version', side_effect=PackageNotFoundError()):
+        with patch('hatch.cli.cli_utils.version', side_effect=PackageNotFoundError()):
             result = get_hatch_version()
 
             self.assertEqual(result, 'unknown (development mode)')
@@ -63,7 +64,8 @@ class TestVersionCommand(unittest.TestCase):
         test_args = ['hatch', '--version']
         
         with patch('sys.argv', test_args):
-            with patch('hatch.cli_hatch.get_hatch_version', return_value='0.7.0-dev.3'):
+            # Patch at point of use in __main__ (imported from cli_utils)
+            with patch('hatch.cli.__main__.get_hatch_version', return_value='0.7.0-dev.3'):
                 with patch('sys.stdout', new_callable=StringIO) as mock_stdout:
                     with self.assertRaises(SystemExit) as cm:
                         main()
@@ -98,7 +100,7 @@ class TestVersionCommand(unittest.TestCase):
         test_args = ['hatch', 'package', 'add', 'test-package', '-v', '1.0.0']
         
         with patch('sys.argv', test_args):
-            with patch('hatch.cli_hatch.HatchEnvironmentManager') as mock_env:
+            with patch('hatch.environment_manager.HatchEnvironmentManager') as mock_env:
                 mock_env_instance = MagicMock()
                 mock_env.return_value = mock_env_instance
                 mock_env_instance.add_package_to_environment.return_value = True

tests/test_data/fixtures/cli_reporter_fixtures.py

@@ -0,0 +1,184 @@
+"""Test fixtures for ResultReporter and ConversionReport integration tests.
+
+This module provides reusable ConversionReport and FieldOperation samples
+for testing the CLI reporter infrastructure. Fixtures are defined as Python
+objects for type safety and IDE support.
+
+Reference: R05 §4.2 (05-test_definition_v0.md)
+
+Fixture Categories:
+    - Single field operation samples (one per operation type)
+    - ConversionReport samples (various scenarios)
+
+Usage:
+    from tests.test_data.fixtures.cli_reporter_fixtures import (
+        REPORT_MIXED_OPERATIONS,
+        FIELD_OP_UPDATED,
+    )
+
+    def test_all_fields_mapped_no_data_loss(self):
+        reporter = ResultReporter("test")
+        reporter.add_from_conversion_report(REPORT_MIXED_OPERATIONS)
+        assert len(reporter.consequences[0].children) == 4
+"""
+
+from hatch.mcp_host_config.reporting import ConversionReport, FieldOperation
+from hatch.mcp_host_config.models import MCPHostType
+
+
+# =============================================================================
+# Single Field Operation Samples (one per operation type)
+# =============================================================================
+
+FIELD_OP_UPDATED = FieldOperation(
+    field_name="command",
+    operation="UPDATED",
+    old_value=None,
+    new_value="python"
+)
+"""Field operation: UPDATED - field value changed from None to 'python'."""
+
+FIELD_OP_UPDATED_WITH_OLD = FieldOperation(
+    field_name="command",
+    operation="UPDATED",
+    old_value="node",
+    new_value="python"
+)
+"""Field operation: UPDATED - field value changed from 'node' to 'python'."""
+
+FIELD_OP_UNSUPPORTED = FieldOperation(
+    field_name="timeout",
+    operation="UNSUPPORTED",
+    new_value=30
+)
+"""Field operation: UNSUPPORTED - field not supported by target host."""
+
+FIELD_OP_UNCHANGED = FieldOperation(
+    field_name="env",
+    operation="UNCHANGED",
+    new_value={}
+)
+"""Field operation: UNCHANGED - field value remained the same."""
+
+
+# =============================================================================
+# ConversionReport Samples
+# =============================================================================
+
+REPORT_SINGLE_UPDATE = ConversionReport(
+    operation="create",
+    server_name="test-server",
+    target_host=MCPHostType.CLAUDE_DESKTOP,
+    field_operations=[FIELD_OP_UPDATED]
+)
+"""ConversionReport: Single field update (create operation)."""
+
+REPORT_MIXED_OPERATIONS = ConversionReport(
+    operation="update",
+    server_name="weather-server",
+    target_host=MCPHostType.CURSOR,
+    field_operations=[
+        FieldOperation(
+            field_name="command",
+            operation="UPDATED",
+            old_value="node",
+            new_value="python"
+        ),
+        FieldOperation(
+            field_name="args",
+            operation="UPDATED",
+            old_value=[],
+            new_value=["server.py"]
+        ),
+        FieldOperation(
+            field_name="env",
+            operation="UNCHANGED",
+            new_value={"API_KEY": "***"}
+        ),
+        FieldOperation(
+            field_name="timeout",
+            operation="UNSUPPORTED",
+            new_value=60
+        ),
+    ]
+)
+"""ConversionReport: Mixed field operations (update operation).
+
+Contains:
+- 2 UPDATED fields (command, args)
+- 1 UNCHANGED field (env)
+- 1 UNSUPPORTED field (timeout)
+"""
+
+REPORT_EMPTY_FIELDS = ConversionReport(
+    operation="create",
+    server_name="minimal-server",
+    target_host=MCPHostType.VSCODE,
+    field_operations=[]
+)
+"""ConversionReport: Empty field operations list (edge case)."""
+
+REPORT_ALL_UNSUPPORTED = ConversionReport(
+    operation="migrate",
+    server_name="legacy-server",
+    source_host=MCPHostType.CLAUDE_DESKTOP,
+    target_host=MCPHostType.KIRO,
+    field_operations=[
+        FieldOperation(
+            field_name="trust",
+            operation="UNSUPPORTED",
+            new_value=True
+        ),
+        FieldOperation(
+            field_name="cwd",
+            operation="UNSUPPORTED",
+            new_value="/app"
+        ),
+    ]
+)
+"""ConversionReport: All fields unsupported (migrate operation)."""
+
+REPORT_ALL_UNCHANGED = ConversionReport(
+    operation="update",
+    server_name="stable-server",
+    target_host=MCPHostType.CLAUDE_DESKTOP,
+    field_operations=[
+        FieldOperation(
+            field_name="command",
+            operation="UNCHANGED",
+            new_value="python"
+        ),
+        FieldOperation(
+            field_name="args",
+            operation="UNCHANGED",
+            new_value=["server.py"]
+        ),
+    ]
+)
+"""ConversionReport: All fields unchanged (no-op update)."""
+
+REPORT_DRY_RUN = ConversionReport(
+    operation="create",
+    server_name="preview-server",
+    target_host=MCPHostType.CURSOR,
+    field_operations=[
+        FieldOperation(
+            field_name="command",
+            operation="UPDATED",
+            old_value=None,
+            new_value="python"
+        ),
+    ],
+    dry_run=True
+)
+"""ConversionReport: Dry-run mode enabled."""
+
+REPORT_WITH_ERROR = ConversionReport(
+    operation="create",
+    server_name="failed-server",
+    target_host=MCPHostType.VSCODE,
+    success=False,
+    error_message="Configuration file not found",
+    field_operations=[]
+)
+"""ConversionReport: Failed operation with error message."""