claude-dev-env 1.0.0

package/hooks/validators/test_health_check.py

@@ -0,0 +1,57 @@
+"""Tests for validator health checks."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from health_check import (
+    ValidatorHealth,
+    check_validator_exists,
+    check_all_validators,
+    get_validator_version,
+)
+
+
+class TestValidatorExists:
+    def test_existing_validator_healthy(self) -> None:
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_file:
+            temp_file.write(b"print('hello')")
+            temp_path = Path(temp_file.name)
+
+        try:
+            result = check_validator_exists(temp_path)
+            assert result.healthy is True
+            assert result.error is None
+        finally:
+            temp_path.unlink()
+
+    def test_missing_validator_unhealthy(self) -> None:
+        result = check_validator_exists(Path("/nonexistent/validator.py"))
+        assert result.healthy is False
+        assert "not found" in result.error.lower()
+
+
+class TestCheckAllValidators:
+    def test_returns_all_validator_statuses(self) -> None:
+        validators_dir = Path(__file__).parent
+        results = check_all_validators(validators_dir)
+        assert isinstance(results, dict)
+        assert "python_style_checks" in results
+
+
+class TestGetValidatorVersion:
+    def test_version_changes_when_content_changes(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+            validator_file = temp_path / "python_style_checks.py"
+
+            validator_file.write_text("# version 1")
+            version1 = get_validator_version(temp_path)
+
+            validator_file.write_text("# version 2 - different content")
+            version2 = get_validator_version(temp_path)
+
+            assert version1 != version2
+            assert isinstance(version1, str)
+            assert len(version1) > 0

package/hooks/validators/test_magic_value_checks.py

@@ -0,0 +1,63 @@
+"""Tests for magic value detection."""
+
+import ast
+
+import pytest
+
+from magic_value_checks import (
+    check_magic_values,
+)
+from validator_base import Violation
+
+
+GOOD_NAMED_CONSTANTS = '''
+API_TIMEOUT_MS = 5000
+HASH_DELIMITER = "__"
+
+def process():
+    timeout = API_TIMEOUT_MS
+    return f"key{HASH_DELIMITER}value"
+'''
+
+BAD_MAGIC_NUMBER = '''
+def process():
+    timeout = 5000
+    return timeout
+'''
+
+ALLOWED_SMALL_NUMBERS = '''
+def process():
+    count = 0
+    increment = 1
+    doubled = count * 2
+    return count + 1
+'''
+
+ALLOWED_EMPTY_STRING = '''
+def process():
+    result = ""
+    return result
+'''
+
+
+class TestMagicValues:
+    def test_named_constants_pass(self) -> None:
+        tree = ast.parse(GOOD_NAMED_CONSTANTS)
+        violations = check_magic_values(tree, "test.py")
+        assert violations == []
+
+    def test_magic_number_fails(self) -> None:
+        tree = ast.parse(BAD_MAGIC_NUMBER)
+        violations = check_magic_values(tree, "test.py")
+        assert len(violations) == 1
+        assert "5000" in violations[0].message
+
+    def test_small_numbers_allowed(self) -> None:
+        tree = ast.parse(ALLOWED_SMALL_NUMBERS)
+        violations = check_magic_values(tree, "test.py")
+        assert violations == []
+
+    def test_empty_string_allowed(self) -> None:
+        tree = ast.parse(ALLOWED_EMPTY_STRING)
+        violations = check_magic_values(tree, "test.py")
+        assert violations == []

package/hooks/validators/test_mypy_integration.py

@@ -0,0 +1,27 @@
+"""Tests for mypy integration module."""
+
+from pathlib import Path
+from unittest.mock import patch
+
+from mypy_integration import MypyResult, check_mypy_available, run_mypy_check
+
+
+def test_mypy_result_dataclass() -> None:
+    """Test MypyResult dataclass creation."""
+    result = MypyResult(passed=True, output="test", error_count=0)
+    assert result.passed is True
+    assert result.output == "test"
+    assert result.error_count == 0
+
+
+def test_check_mypy_available_returns_false_when_not_installed() -> None:
+    """Test that check_mypy_available returns False when mypy not found."""
+    with patch("subprocess.run", side_effect=FileNotFoundError):
+        assert check_mypy_available() is False
+
+
+def test_run_mypy_check_returns_passed_for_empty_files() -> None:
+    """Test that run_mypy_check passes with no files."""
+    result = run_mypy_check([])
+    assert result.passed is True
+    assert "No files" in result.output

package/hooks/validators/test_output_formatter.py

@@ -0,0 +1,150 @@
+"""Tests for output formatting."""
+
+import pytest
+
+from output_formatter import (
+    OutputFormatter,
+    OutputMode,
+    format_violation_with_context,
+    colorize,
+    group_violations_by_file,
+    format_grouped_violations,
+    ViolationDict,
+    ValidatorResultDict,
+)
+
+
+class TestColorize:
+    def test_colorize_pass(self) -> None:
+        result = colorize("PASS", "green")
+        assert "PASS" in result
+
+    def test_colorize_fail(self) -> None:
+        result = colorize("FAIL", "red")
+        assert "FAIL" in result
+
+    def test_colorize_disabled(self) -> None:
+        result = colorize("PASS", "green", enabled=False)
+        assert result == "PASS"
+
+
+class TestFormatViolationWithContext:
+    def test_shows_surrounding_lines(self) -> None:
+        source = '''line 1
+line 2
+line 3 with error
+line 4
+line 5'''
+        result = format_violation_with_context(
+            source=source,
+            line_num=3,
+            message="Error on line 3",
+            context_lines=1,
+        )
+        assert "line 2" in result
+        assert "line 3 with error" in result
+        assert "line 4" in result
+
+    def test_highlights_error_line(self) -> None:
+        source = '''line 1
+line 2
+line 3 with error
+line 4'''
+        result = format_violation_with_context(
+            source=source,
+            line_num=3,
+            message="Error",
+            context_lines=1,
+        )
+        assert ">" in result or "3" in result
+
+
+class TestOutputFormatter:
+    def test_json_mode_output(self) -> None:
+        formatter = OutputFormatter(mode=OutputMode.JSON)
+        results: list[ValidatorResultDict] = [
+            {"name": "Test", "checks": "1", "passed": True, "output": "OK"}
+        ]
+        output = formatter.format_results(results)
+        assert '"name"' in output
+        assert '"passed"' in output
+
+    def test_text_mode_output(self) -> None:
+        formatter = OutputFormatter(mode=OutputMode.TEXT)
+        results: list[ValidatorResultDict] = [
+            {"name": "Test", "checks": "1", "passed": True, "output": "OK"}
+        ]
+        output = formatter.format_results(results)
+        assert "Test" in output
+        assert "PASS" in output or "OK" in output
+
+    def test_effective_use_colors_false_when_disabled(self) -> None:
+        formatter = OutputFormatter(mode=OutputMode.TEXT, use_colors=False)
+        assert formatter.effective_use_colors is False
+
+    def test_formatter_is_immutable(self) -> None:
+        formatter = OutputFormatter(mode=OutputMode.TEXT)
+        with pytest.raises(AttributeError):
+            formatter.mode = OutputMode.JSON
+
+
+class TestJsonFlag:
+    def test_json_flag_produces_valid_json(self) -> None:
+        import json
+        import subprocess
+
+        result = subprocess.run(
+            ["python", "run_all_validators.py", "--json"],
+            capture_output=True,
+            text=True,
+            cwd=os.path.dirname(os.path.abspath(__file__)),
+        )
+
+        output = result.stdout.strip()
+        parsed = json.loads(output)
+        assert "results" in parsed
+        assert isinstance(parsed["results"], list)
+
+
+class TestGroupViolationsByFile:
+    def test_groups_violations_by_file_path(self) -> None:
+        violations: list[ViolationDict] = [
+            {"file": "a.py", "line": 1, "message": "error 1"},
+            {"file": "b.py", "line": 2, "message": "error 2"},
+            {"file": "a.py", "line": 3, "message": "error 3"},
+        ]
+        grouped = group_violations_by_file(violations)
+
+        assert len(grouped) == 2
+        assert len(grouped["a.py"]) == 2
+        assert len(grouped["b.py"]) == 1
+
+    def test_empty_list_returns_empty_dict(self) -> None:
+        grouped = group_violations_by_file([])
+        assert grouped == {}
+
+
+class TestFormatGroupedViolations:
+    def test_formats_with_file_headers(self) -> None:
+        violations: list[ViolationDict] = [
+            {"file": "a.py", "line": 1, "message": "error 1"},
+            {"file": "a.py", "line": 3, "message": "error 2"},
+        ]
+        grouped = group_violations_by_file(violations)
+        output = format_grouped_violations(grouped, use_colors=False)
+
+        assert "a.py" in output
+        assert "Line 1:" in output
+        assert "Line 3:" in output
+
+    def test_sorts_violations_by_line_number(self) -> None:
+        violations: list[ViolationDict] = [
+            {"file": "a.py", "line": 10, "message": "later"},
+            {"file": "a.py", "line": 2, "message": "earlier"},
+        ]
+        grouped = group_violations_by_file(violations)
+        output = format_grouped_violations(grouped, use_colors=False)
+
+        earlier_pos = output.find("Line 2:")
+        later_pos = output.find("Line 10:")
+        assert earlier_pos < later_pos

package/hooks/validators/test_pr_reference_checks.py

@@ -0,0 +1,41 @@
+"""Tests for PR/commit reference detection in comments."""
+
+from pathlib import Path
+
+import pytest
+
+from pr_reference_checks import (
+    check_pr_references,
+    validate_file,
+)
+from validator_base import Violation
+
+
+GOOD_NO_REFERENCES = '''
+def process():
+    result = calculate()
+    return result
+'''
+
+
+class TestPrReferences:
+    def test_no_references_pass(self) -> None:
+        violations = check_pr_references(GOOD_NO_REFERENCES, "test.py")
+        assert violations == []
+
+    def test_pr_reference_in_comment_fails(self) -> None:
+        code = "# Fixed in PR #99\ndef foo(): pass"
+        violations = check_pr_references(code, "test.py")
+        assert len(violations) == 1
+        assert "PR" in violations[0].message
+
+    def test_commit_reference_fails(self) -> None:
+        code = "# See commit abc123\ndef foo(): pass"
+        violations = check_pr_references(code, "test.py")
+        assert len(violations) == 1
+        assert "commit" in violations[0].message.lower()
+
+    def test_issue_hash_reference_fails(self) -> None:
+        code = "# Addresses #17\ndef foo(): pass"
+        violations = check_pr_references(code, "test.py")
+        assert len(violations) == 1

package/hooks/validators/test_python_antipattern_checks.py

@@ -0,0 +1,113 @@
+"""Tests for Python anti-pattern detection."""
+
+import ast
+
+import pytest
+
+from python_antipattern_checks import (
+    check_mutable_default_args,
+    check_bare_except,
+    check_print_in_production,
+)
+from validator_base import Violation
+
+
+GOOD_NONE_DEFAULT = '''
+def process(items=None):
+    if items is None:
+        items = []
+    return items
+'''
+
+BAD_MUTABLE_DEFAULT = '''
+def process(items=[]):
+    return items
+'''
+
+BAD_DICT_DEFAULT = '''
+def process(config={}):
+    return config
+'''
+
+GOOD_SPECIFIC_EXCEPT = '''
+def process():
+    try:
+        do_work()
+    except ValueError:
+        handle_error()
+'''
+
+BAD_BARE_EXCEPT = '''
+def process():
+    try:
+        do_work()
+    except:
+        handle_error()
+'''
+
+GOOD_LOGGING = '''
+import logging
+
+def process():
+    logging.info("Processing")
+'''
+
+BAD_PRINT = '''
+def process():
+    print("Debug info")
+'''
+
+TEST_FILE_WITH_PRINT = '''
+def test_something():
+    print("Test output")
+    assert True
+'''
+
+
+class TestMutableDefaultArgs:
+    def test_none_default_passes(self) -> None:
+        tree = ast.parse(GOOD_NONE_DEFAULT)
+        violations = check_mutable_default_args(tree, "test.py")
+        assert violations == []
+
+    def test_list_default_fails(self) -> None:
+        tree = ast.parse(BAD_MUTABLE_DEFAULT)
+        violations = check_mutable_default_args(tree, "test.py")
+        assert len(violations) == 1
+        assert "mutable" in violations[0].message.lower()
+
+    def test_dict_default_fails(self) -> None:
+        tree = ast.parse(BAD_DICT_DEFAULT)
+        violations = check_mutable_default_args(tree, "test.py")
+        assert len(violations) == 1
+
+
+class TestBareExcept:
+    def test_specific_except_passes(self) -> None:
+        tree = ast.parse(GOOD_SPECIFIC_EXCEPT)
+        violations = check_bare_except(tree, "test.py")
+        assert violations == []
+
+    def test_bare_except_fails(self) -> None:
+        tree = ast.parse(BAD_BARE_EXCEPT)
+        violations = check_bare_except(tree, "test.py")
+        assert len(violations) == 1
+        assert "bare" in violations[0].message.lower() or "except" in violations[0].message.lower()
+
+
+class TestPrintInProduction:
+    def test_logging_passes(self) -> None:
+        tree = ast.parse(GOOD_LOGGING)
+        violations = check_print_in_production(tree, "utils.py")
+        assert violations == []
+
+    def test_print_fails(self) -> None:
+        tree = ast.parse(BAD_PRINT)
+        violations = check_print_in_production(tree, "utils.py")
+        assert len(violations) == 1
+        assert "print" in violations[0].message.lower()
+
+    def test_print_in_test_file_allowed(self) -> None:
+        tree = ast.parse(TEST_FILE_WITH_PRINT)
+        violations = check_print_in_production(tree, "test_utils.py")
+        assert violations == []