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

tests/regression/cli/test_consequence_type.py

@@ -0,0 +1,298 @@
+"""Regression tests for ConsequenceType enum.
+
+This module tests:
+- ConsequenceType enum completeness (all 16 types defined)
+- Tense-aware label properties (prompt_label, result_label)
+- Color properties (prompt_color, result_color)
+- Irregular verb handling (SET, EXISTS, UNCHANGED)
+
+Reference: R05 §3.2 (05-test_definition_v0.md)
+Reference: R06 §3.2 (06-dependency_analysis_v0.md)
+Reference: R03 §2 (03-mutation_output_specification_v0.md)
+"""
+
+import unittest
+
+
+class TestConsequenceTypeEnum(unittest.TestCase):
+    """Tests for ConsequenceType enum completeness and structure.
+    
+    Reference: R06 §3.2 - ConsequenceType interface contract
+    """
+
+    def test_consequence_type_enum_exists(self):
+        """ConsequenceType enum should be importable from cli_utils."""
+        from hatch.cli.cli_utils import ConsequenceType
+        self.assertTrue(hasattr(ConsequenceType, '__members__'))
+
+    def test_consequence_type_has_all_constructive_types(self):
+        """ConsequenceType should have all constructive action types (Green)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        constructive_types = ['CREATE', 'ADD', 'CONFIGURE', 'INSTALL', 'INITIALIZE']
+        for type_name in constructive_types:
+            self.assertTrue(
+                hasattr(ConsequenceType, type_name),
+                f"ConsequenceType missing constructive type: {type_name}"
+            )
+
+    def test_consequence_type_has_recovery_type(self):
+        """ConsequenceType should have RESTORE recovery type (Blue)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        self.assertTrue(hasattr(ConsequenceType, 'RESTORE'))
+
+    def test_consequence_type_has_all_destructive_types(self):
+        """ConsequenceType should have all destructive action types (Red)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        destructive_types = ['REMOVE', 'DELETE', 'CLEAN']
+        for type_name in destructive_types:
+            self.assertTrue(
+                hasattr(ConsequenceType, type_name),
+                f"ConsequenceType missing destructive type: {type_name}"
+            )
+
+    def test_consequence_type_has_all_modification_types(self):
+        """ConsequenceType should have all modification action types (Yellow)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        modification_types = ['SET', 'UPDATE']
+        for type_name in modification_types:
+            self.assertTrue(
+                hasattr(ConsequenceType, type_name),
+                f"ConsequenceType missing modification type: {type_name}"
+            )
+
+    def test_consequence_type_has_transfer_type(self):
+        """ConsequenceType should have SYNC transfer type (Magenta)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        self.assertTrue(hasattr(ConsequenceType, 'SYNC'))
+
+    def test_consequence_type_has_informational_type(self):
+        """ConsequenceType should have VALIDATE informational type (Cyan)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        self.assertTrue(hasattr(ConsequenceType, 'VALIDATE'))
+
+    def test_consequence_type_has_all_noop_types(self):
+        """ConsequenceType should have all no-op action types (Gray)."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        noop_types = ['SKIP', 'EXISTS', 'UNCHANGED']
+        for type_name in noop_types:
+            self.assertTrue(
+                hasattr(ConsequenceType, type_name),
+                f"ConsequenceType missing no-op type: {type_name}"
+            )
+
+    def test_consequence_type_total_count(self):
+        """ConsequenceType should have exactly 16 members."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        # 5 constructive + 1 recovery + 3 destructive + 2 modification + 
+        # 1 transfer + 1 informational + 3 noop = 16
+        self.assertEqual(
+            len(ConsequenceType), 16,
+            f"Expected 16 consequence types, got {len(ConsequenceType)}"
+        )
+
+
+class TestConsequenceTypeProperties(unittest.TestCase):
+    """Tests for ConsequenceType tense-aware properties.
+    
+    Reference: R05 §3.2 - ConsequenceType Behavior test group
+    """
+
+    def test_all_types_have_prompt_label(self):
+        """All ConsequenceType members should have prompt_label property."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        for ct in ConsequenceType:
+            self.assertTrue(
+                hasattr(ct, 'prompt_label'),
+                f"{ct.name} missing prompt_label property"
+            )
+            self.assertIsInstance(ct.prompt_label, str)
+            self.assertTrue(
+                len(ct.prompt_label) > 0,
+                f"{ct.name}.prompt_label should not be empty"
+            )
+
+    def test_all_types_have_result_label(self):
+        """All ConsequenceType members should have result_label property."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        for ct in ConsequenceType:
+            self.assertTrue(
+                hasattr(ct, 'result_label'),
+                f"{ct.name} missing result_label property"
+            )
+            self.assertIsInstance(ct.result_label, str)
+            self.assertTrue(
+                len(ct.result_label) > 0,
+                f"{ct.name}.result_label should not be empty"
+            )
+
+    def test_all_types_have_prompt_color(self):
+        """All ConsequenceType members should have prompt_color property."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        for ct in ConsequenceType:
+            self.assertTrue(
+                hasattr(ct, 'prompt_color'),
+                f"{ct.name} missing prompt_color property"
+            )
+            self.assertIsInstance(ct.prompt_color, Color)
+
+    def test_all_types_have_result_color(self):
+        """All ConsequenceType members should have result_color property."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        for ct in ConsequenceType:
+            self.assertTrue(
+                hasattr(ct, 'result_color'),
+                f"{ct.name} missing result_color property"
+            )
+            self.assertIsInstance(ct.result_color, Color)
+
+    def test_irregular_verbs_prompt_equals_result(self):
+        """Irregular verbs (SET, EXISTS, UNCHANGED) should have same prompt and result labels."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        irregular_verbs = [
+            ConsequenceType.SET,
+            ConsequenceType.EXISTS,
+            ConsequenceType.UNCHANGED,
+        ]
+        
+        for ct in irregular_verbs:
+            self.assertEqual(
+                ct.prompt_label, ct.result_label,
+                f"{ct.name} is irregular: prompt_label should equal result_label"
+            )
+
+    def test_regular_verbs_result_ends_with_ed(self):
+        """Regular verbs should have result_label ending with 'ED'."""
+        from hatch.cli.cli_utils import ConsequenceType
+        
+        # Irregular verbs that don't follow -ED pattern
+        irregular = {'SET', 'EXISTS', 'UNCHANGED'}
+        
+        for ct in ConsequenceType:
+            if ct.name not in irregular:
+                self.assertTrue(
+                    ct.result_label.endswith('ED'),
+                    f"{ct.name}.result_label '{ct.result_label}' should end with 'ED'"
+                )
+
+
+class TestConsequenceTypeColorSemantics(unittest.TestCase):
+    """Tests for ConsequenceType color semantic correctness.
+    
+    Reference: R03 §4.3 - Verb-to-Color mapping
+    """
+
+    def test_constructive_types_use_green(self):
+        """Constructive types should use green colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        constructive = [
+            ConsequenceType.CREATE,
+            ConsequenceType.ADD,
+            ConsequenceType.CONFIGURE,
+            ConsequenceType.INSTALL,
+            ConsequenceType.INITIALIZE,
+        ]
+        
+        for ct in constructive:
+            self.assertEqual(
+                ct.prompt_color, Color.GREEN_DIM,
+                f"{ct.name} prompt_color should be GREEN_DIM"
+            )
+            self.assertEqual(
+                ct.result_color, Color.GREEN,
+                f"{ct.name} result_color should be GREEN"
+            )
+
+    def test_recovery_type_uses_blue(self):
+        """RESTORE should use blue colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        self.assertEqual(ConsequenceType.RESTORE.prompt_color, Color.BLUE_DIM)
+        self.assertEqual(ConsequenceType.RESTORE.result_color, Color.BLUE)
+
+    def test_destructive_types_use_red(self):
+        """Destructive types should use red colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        destructive = [
+            ConsequenceType.REMOVE,
+            ConsequenceType.DELETE,
+            ConsequenceType.CLEAN,
+        ]
+        
+        for ct in destructive:
+            self.assertEqual(
+                ct.prompt_color, Color.RED_DIM,
+                f"{ct.name} prompt_color should be RED_DIM"
+            )
+            self.assertEqual(
+                ct.result_color, Color.RED,
+                f"{ct.name} result_color should be RED"
+            )
+
+    def test_modification_types_use_yellow(self):
+        """Modification types should use yellow colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        modification = [
+            ConsequenceType.SET,
+            ConsequenceType.UPDATE,
+        ]
+        
+        for ct in modification:
+            self.assertEqual(
+                ct.prompt_color, Color.YELLOW_DIM,
+                f"{ct.name} prompt_color should be YELLOW_DIM"
+            )
+            self.assertEqual(
+                ct.result_color, Color.YELLOW,
+                f"{ct.name} result_color should be YELLOW"
+            )
+
+    def test_transfer_type_uses_magenta(self):
+        """SYNC should use magenta colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        self.assertEqual(ConsequenceType.SYNC.prompt_color, Color.MAGENTA_DIM)
+        self.assertEqual(ConsequenceType.SYNC.result_color, Color.MAGENTA)
+
+    def test_informational_type_uses_cyan(self):
+        """VALIDATE should use cyan colors."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        self.assertEqual(ConsequenceType.VALIDATE.prompt_color, Color.CYAN_DIM)
+        self.assertEqual(ConsequenceType.VALIDATE.result_color, Color.CYAN)
+
+    def test_noop_types_use_gray(self):
+        """No-op types should use gray colors (same for prompt and result)."""
+        from hatch.cli.cli_utils import ConsequenceType, Color
+        
+        noop = [
+            ConsequenceType.SKIP,
+            ConsequenceType.EXISTS,
+            ConsequenceType.UNCHANGED,
+        ]
+        
+        for ct in noop:
+            self.assertEqual(
+                ct.prompt_color, Color.GRAY,
+                f"{ct.name} prompt_color should be GRAY"
+            )
+            self.assertEqual(
+                ct.result_color, Color.GRAY,
+                f"{ct.name} result_color should be GRAY"
+            )
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/regression/cli/test_error_formatting.py

@@ -0,0 +1,328 @@
+"""Regression tests for error formatting infrastructure.
+
+This module tests:
+- HatchArgumentParser error formatting
+- ValidationError exception class
+- format_validation_error utility
+- format_info utility
+
+Reference: R13 §4.2.1 (13-error_message_formatting_v0.md) - HatchArgumentParser
+Reference: R13 §4.2.2 (13-error_message_formatting_v0.md) - ValidationError
+Reference: R13 §4.3 (13-error_message_formatting_v0.md) - Utilities
+Reference: R13 §6.1 (13-error_message_formatting_v0.md) - Argparse error catalog
+"""
+
+import unittest
+import subprocess
+import sys
+
+
+class TestHatchArgumentParser(unittest.TestCase):
+    """Tests for HatchArgumentParser error formatting.
+    
+    Reference: R13 §4.2.1 - Custom ArgumentParser
+    Reference: R13 §6.1 - Argparse error catalog
+    """
+
+    def test_argparse_error_has_error_prefix(self):
+        """Argparse errors should have [ERROR] prefix."""
+        from hatch.cli.__main__ import HatchArgumentParser
+        import io
+        
+        parser = HatchArgumentParser(prog="test")
+        
+        # Capture stderr
+        captured = io.StringIO()
+        try:
+            parser.error("test error message")
+        except SystemExit:
+            pass
+        
+        # The error method writes to stderr and exits
+        # We need to test via subprocess for proper capture
+        result = subprocess.run(
+            [sys.executable, "-c", 
+             "from hatch.cli.__main__ import HatchArgumentParser; "
+             "p = HatchArgumentParser(); p.error('test error')"],
+            capture_output=True,
+            text=True
+        )
+        
+        self.assertIn("[ERROR]", result.stderr)
+
+    def test_argparse_error_unrecognized_argument(self):
+        """Unrecognized argument error should have [ERROR] prefix."""
+        result = subprocess.run(
+            [sys.executable, "-m", "hatch.cli", "--invalid-arg"],
+            capture_output=True,
+            text=True
+        )
+        
+        self.assertIn("[ERROR]", result.stderr)
+        self.assertIn("unrecognized arguments", result.stderr)
+
+    def test_argparse_error_exit_code_2(self):
+        """Argparse errors should exit with code 2."""
+        result = subprocess.run(
+            [sys.executable, "-m", "hatch.cli", "--invalid-arg"],
+            capture_output=True,
+            text=True
+        )
+        
+        self.assertEqual(result.returncode, 2)
+
+    def test_argparse_error_no_ansi_in_pipe(self):
+        """Argparse errors should not have ANSI codes when piped."""
+        result = subprocess.run(
+            [sys.executable, "-m", "hatch.cli", "--invalid-arg"],
+            capture_output=True,
+            text=True
+        )
+        
+        # When piped (capture_output=True), stdout is not a TTY
+        # so ANSI codes should not be present
+        self.assertNotIn("\033[", result.stderr)
+
+    def test_hatch_argument_parser_class_exists(self):
+        """HatchArgumentParser class should be importable."""
+        from hatch.cli.__main__ import HatchArgumentParser
+        import argparse
+        
+        self.assertTrue(issubclass(HatchArgumentParser, argparse.ArgumentParser))
+
+    def test_hatch_argument_parser_has_error_method(self):
+        """HatchArgumentParser should have overridden error method."""
+        from hatch.cli.__main__ import HatchArgumentParser
+        import argparse
+        
+        parser = HatchArgumentParser()
+        
+        # Check that error method is overridden (not the same as base class)
+        self.assertIsNot(
+            HatchArgumentParser.error,
+            argparse.ArgumentParser.error
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()
+
+
+class TestValidationError(unittest.TestCase):
+    """Tests for ValidationError exception class.
+    
+    Reference: R13 §4.2.2 - ValidationError interface
+    Reference: R13 §7.2 - ValidationError contract
+    """
+
+    def test_validation_error_attributes(self):
+        """ValidationError should have message, field, and suggestion attributes."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        error = ValidationError(
+            "Test message",
+            field="--host",
+            suggestion="Use valid host"
+        )
+        
+        self.assertEqual(error.message, "Test message")
+        self.assertEqual(error.field, "--host")
+        self.assertEqual(error.suggestion, "Use valid host")
+
+    def test_validation_error_str_returns_message(self):
+        """ValidationError str() should return message."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        error = ValidationError("Test message")
+        self.assertEqual(str(error), "Test message")
+
+    def test_validation_error_optional_field(self):
+        """ValidationError field should be optional."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        error = ValidationError("Test message")
+        self.assertIsNone(error.field)
+
+    def test_validation_error_optional_suggestion(self):
+        """ValidationError suggestion should be optional."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        error = ValidationError("Test message")
+        self.assertIsNone(error.suggestion)
+
+    def test_validation_error_is_exception(self):
+        """ValidationError should be an Exception subclass."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        self.assertTrue(issubclass(ValidationError, Exception))
+
+    def test_validation_error_can_be_raised(self):
+        """ValidationError should be raisable."""
+        from hatch.cli.cli_utils import ValidationError
+        
+        with self.assertRaises(ValidationError) as context:
+            raise ValidationError("Test error", field="--host")
+        
+        self.assertEqual(context.exception.message, "Test error")
+        self.assertEqual(context.exception.field, "--host")
+
+
+class TestFormatValidationError(unittest.TestCase):
+    """Tests for format_validation_error utility.
+    
+    Reference: R13 §4.3 - format_validation_error
+    """
+
+    def test_format_validation_error_basic(self):
+        """format_validation_error should print [ERROR] prefix."""
+        from hatch.cli.cli_utils import ValidationError, format_validation_error
+        import io
+        import sys
+        
+        error = ValidationError("Test error message")
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_validation_error(error)
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertIn("[ERROR]", output)
+        self.assertIn("Test error message", output)
+
+    def test_format_validation_error_with_field(self):
+        """format_validation_error should print field if provided."""
+        from hatch.cli.cli_utils import ValidationError, format_validation_error
+        import io
+        import sys
+        
+        error = ValidationError("Test error", field="--host")
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_validation_error(error)
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertIn("Field: --host", output)
+
+    def test_format_validation_error_with_suggestion(self):
+        """format_validation_error should print suggestion if provided."""
+        from hatch.cli.cli_utils import ValidationError, format_validation_error
+        import io
+        import sys
+        
+        error = ValidationError("Test error", suggestion="Use valid host")
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_validation_error(error)
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertIn("Suggestion: Use valid host", output)
+
+    def test_format_validation_error_full(self):
+        """format_validation_error should print all fields when provided."""
+        from hatch.cli.cli_utils import ValidationError, format_validation_error
+        import io
+        import sys
+        
+        error = ValidationError(
+            "Invalid host 'vsc'",
+            field="--host",
+            suggestion="Supported hosts: claude-desktop, vscode"
+        )
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_validation_error(error)
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertIn("[ERROR]", output)
+        self.assertIn("Invalid host 'vsc'", output)
+        self.assertIn("Field: --host", output)
+        self.assertIn("Suggestion: Supported hosts: claude-desktop, vscode", output)
+
+    def test_format_validation_error_no_color_in_non_tty(self):
+        """format_validation_error should not include ANSI codes when not in TTY."""
+        from hatch.cli.cli_utils import ValidationError, format_validation_error
+        import io
+        import sys
+        
+        error = ValidationError("Test error")
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_validation_error(error)
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertNotIn("\033[", output)
+
+
+class TestFormatInfo(unittest.TestCase):
+    """Tests for format_info utility.
+    
+    Reference: R13-B §B.6.2 - Operation cancelled normalization
+    """
+
+    def test_format_info_basic(self):
+        """format_info should print [INFO] prefix."""
+        from hatch.cli.cli_utils import format_info
+        import io
+        import sys
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_info("Operation cancelled")
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertIn("[INFO]", output)
+        self.assertIn("Operation cancelled", output)
+
+    def test_format_info_no_color_in_non_tty(self):
+        """format_info should not include ANSI codes when not in TTY."""
+        from hatch.cli.cli_utils import format_info
+        import io
+        import sys
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_info("Test message")
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue()
+        self.assertNotIn("\033[", output)
+
+    def test_format_info_output_format(self):
+        """format_info output should match expected format."""
+        from hatch.cli.cli_utils import format_info
+        import io
+        import sys
+        
+        captured = io.StringIO()
+        sys.stdout = captured
+        try:
+            format_info("Test message")
+        finally:
+            sys.stdout = sys.__stdout__
+        
+        output = captured.getvalue().strip()
+        self.assertEqual(output, "[INFO] Test message")