claude-dev-env 1.0.0

package/hooks/validators/test_test_safety_checks.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Tests for AST-based test safety validators."""
+
+import tempfile
+from pathlib import Path
+from typing import List
+
+import pytest
+
+from test_safety_checks import (
+    Violation,
+    check_no_skip_decorators,
+    check_debug_guard_in_dev_scripts,
+    main,
+)
+
+
+class TestNoSkipDecorators:
+    """Test detection of skip decorators in test files."""
+
+    def test_detects_pytest_skip_decorator(self) -> None:
+        code = """
+import pytest
+
+@pytest.mark.skip
+def test_something():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 5
+        assert "skip decorator" in violations[0].message.lower()
+
+    def test_detects_pytest_skip_with_reason(self) -> None:
+        code = """
+import pytest
+
+@pytest.mark.skip(reason="not ready")
+def test_something():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 5
+
+    def test_detects_unittest_skip(self) -> None:
+        code = """
+import unittest
+
+class TestCase(unittest.TestCase):
+    @unittest.skip("reason")
+    def test_something(self):
+        pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 6
+
+    def test_detects_skipif_decorator(self) -> None:
+        code = """
+import pytest
+
+@pytest.mark.skipif(True, reason="reason")
+def test_something():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 5
+
+    def test_detects_skipunless_decorator(self) -> None:
+        code = """
+import unittest
+
+class TestCase(unittest.TestCase):
+    @unittest.skipUnless(False, "reason")
+    def test_something(self):
+        pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 6
+
+    def test_detects_multiple_skip_decorators(self) -> None:
+        code = """
+import pytest
+
+@pytest.mark.skip
+def test_one():
+    pass
+
+@pytest.mark.skipif(True, reason="reason")
+def test_two():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 2
+        assert violations[0].line == 5
+        assert violations[1].line == 9
+
+    def test_allows_other_decorators(self) -> None:
+        code = """
+import pytest
+
+@pytest.mark.parametrize("x", [1, 2, 3])
+def test_something(x):
+    pass
+
+@pytest.fixture
+def my_fixture():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 0
+
+    def test_allows_tests_without_decorators(self) -> None:
+        code = """
+def test_something():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 0
+
+    def test_detects_case_insensitive_skip_decorator(self) -> None:
+        """Test that decorator names are matched case-insensitively."""
+        code = """
+import pytest
+
+@pytest.mark.Skip
+def test_something():
+    pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 5
+        assert "skip decorator" in violations[0].message.lower()
+
+    def test_detects_case_insensitive_skipif(self) -> None:
+        """Test that SkipIf is caught."""
+        code = """
+import unittest
+
+class TestCase(unittest.TestCase):
+    @unittest.SkipIf(True, "reason")
+    def test_something(self):
+        pass
+"""
+        violations = check_no_skip_decorators(code, "test_file.py")
+        assert len(violations) == 1
+        assert violations[0].line == 6
+
+
+class TestDebugGuardInDevScripts:
+    """Test detection of missing DEBUG checks in management commands."""
+
+    def test_detects_missing_debug_check(self) -> None:
+        code = """
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        print("Doing dangerous thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(
+            code, "management/commands/dev_tool.py"
+        )
+        assert len(violations) == 1
+        assert "DEBUG" in violations[0].message
+
+    def test_allows_debug_check_at_start(self) -> None:
+        code = """
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        if not settings.DEBUG:
+            raise CommandError("Only for development")
+        print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(
+            code, "management/commands/dev_tool.py"
+        )
+        assert len(violations) == 0
+
+    def test_allows_debug_check_with_return(self) -> None:
+        code = """
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        if not settings.DEBUG:
+            return
+        print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(
+            code, "management/commands/dev_tool.py"
+        )
+        assert len(violations) == 0
+
+    def test_ignores_non_management_commands(self) -> None:
+        code = """
+def some_function():
+    print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(code, "utils/helper.py")
+        assert len(violations) == 0
+
+    def test_ignores_files_outside_management_commands(self) -> None:
+        code = """
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(code, "some/other/path.py")
+        assert len(violations) == 0
+
+    def test_allows_positive_debug_check_with_else_raise(self) -> None:
+        """Test that 'if settings.DEBUG: ... else: raise' is a valid guard."""
+        code = """
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        if settings.DEBUG:
+            print("OK")
+        else:
+            raise CommandError("Development only")
+        print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(
+            code, "management/commands/dev_tool.py"
+        )
+        assert len(violations) == 0
+
+    def test_allows_positive_debug_check_with_else_return(self) -> None:
+        """Test that 'if settings.DEBUG: ... else: return' is a valid guard."""
+        code = """
+from django.core.management.base import BaseCommand
+from django.conf import settings
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        if settings.DEBUG:
+            pass
+        else:
+            return
+        print("Doing thing")
+"""
+        violations = check_debug_guard_in_dev_scripts(
+            code, "management/commands/dev_tool.py"
+        )
+        assert len(violations) == 0
+
+
+class TestViolation:
+    """Test Violation dataclass."""
+
+    def test_violation_creation(self) -> None:
+        v = Violation("test.py", 42, "Test message")
+        assert v.file == "test.py"
+        assert v.line == 42
+        assert v.message == "Test message"
+
+    def test_violation_str(self) -> None:
+        v = Violation("test.py", 42, "Test message")
+        assert str(v) == "test.py:42: Test message"
+
+
+class TestMainFunction:
+    """Test main CLI function."""
+
+    def test_main_with_no_violations(self, tmp_path: Path) -> None:
+        test_file = tmp_path / "test_good.py"
+        test_file.write_text("def test_something():\n    pass\n")
+
+        exit_code = main([str(test_file)])
+        assert exit_code == 0
+
+    def test_main_with_violations(self, tmp_path: Path, capsys) -> None:
+        test_file = tmp_path / "test_bad.py"
+        test_file.write_text("import pytest\n\n@pytest.mark.skip\ndef test_x():\n    pass\n")
+
+        exit_code = main([str(test_file)])
+        assert exit_code == 1
+
+        captured = capsys.readouterr()
+        assert ":4:" in captured.out
+        assert "skip decorator" in captured.out.lower()
+
+    def test_main_with_multiple_files(self, tmp_path: Path) -> None:
+        file1 = tmp_path / "test_good.py"
+        file1.write_text("def test_something():\n    pass\n")
+
+        file2 = tmp_path / "test_bad.py"
+        file2.write_text("import pytest\n\n@pytest.mark.skip\ndef test_x():\n    pass\n")
+
+        exit_code = main([str(file1), str(file2)])
+        assert exit_code == 1
+
+    def test_main_with_management_command(self, tmp_path: Path, capsys) -> None:
+        mgmt_dir = tmp_path / "management" / "commands"
+        mgmt_dir.mkdir(parents=True)
+        cmd_file = mgmt_dir / "dev_tool.py"
+        cmd_file.write_text("""
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    def handle(self, *args, **options):
+        print("Dangerous")
+""")
+
+        exit_code = main([str(cmd_file)])
+        assert exit_code == 1
+
+        captured = capsys.readouterr()
+        assert "DEBUG" in captured.out

package/hooks/validators/test_todo_checks.py

@@ -0,0 +1,39 @@
+"""Tests for TODO/FIXME detection."""
+
+import pytest
+
+from todo_checks import check_untracked_todos
+from validator_base import Violation
+
+
+GOOD_TODO_WITH_ISSUE = '''
+def process():
+    pass
+'''
+
+BAD_TODO_WITHOUT_ISSUE = '''
+def process():
+    pass
+'''
+
+
+class TestUntrackedTodos:
+    def test_no_todo_passes(self) -> None:
+        violations = check_untracked_todos(GOOD_TODO_WITH_ISSUE, "test.py")
+        assert violations == []
+
+    def test_todo_without_issue_fails(self) -> None:
+        code = "# TODO: fix this later\ndef foo(): pass"
+        violations = check_untracked_todos(code, "test.py")
+        assert len(violations) == 1
+        assert "TODO" in violations[0].message
+
+    def test_todo_with_issue_passes(self) -> None:
+        code = "# TODO #123: fix this later\ndef foo(): pass"
+        violations = check_untracked_todos(code, "test.py")
+        assert violations == []
+
+    def test_fixme_without_issue_fails(self) -> None:
+        code = "# FIXME: broken\ndef foo(): pass"
+        violations = check_untracked_todos(code, "test.py")
+        assert len(violations) == 1

package/hooks/validators/test_type_safety_checks.py

@@ -0,0 +1,85 @@
+"""Tests for type safety checks."""
+
+import ast
+
+import pytest
+
+from type_safety_checks import (
+    check_missing_type_hints,
+    check_any_type,
+)
+from validator_base import Violation
+
+
+GOOD_FULLY_TYPED = '''
+def process(items: list[str]) -> int:
+    return len(items)
+'''
+
+BAD_NO_RETURN_TYPE = '''
+def process(items: list[str]):
+    return len(items)
+'''
+
+BAD_NO_PARAM_TYPE = '''
+def process(items) -> int:
+    return len(items)
+'''
+
+GOOD_NO_ANY = '''
+from typing import List
+
+def process(items: List[str]) -> int:
+    return len(items)
+'''
+
+BAD_ANY_TYPE = '''
+from typing import Any
+
+def process(items: Any) -> int:
+    return len(items)
+'''
+
+BAD_ANY_RETURN = '''
+from typing import Any, List
+
+def process(items: List[str]) -> Any:
+    return items[0]
+'''
+
+
+class TestMissingTypeHints:
+    def test_fully_typed_passes(self) -> None:
+        tree = ast.parse(GOOD_FULLY_TYPED)
+        violations = check_missing_type_hints(tree, "test.py")
+        assert violations == []
+
+    def test_missing_return_type_fails(self) -> None:
+        tree = ast.parse(BAD_NO_RETURN_TYPE)
+        violations = check_missing_type_hints(tree, "test.py")
+        assert len(violations) == 1
+        assert "return" in violations[0].message.lower()
+
+    def test_missing_param_type_fails(self) -> None:
+        tree = ast.parse(BAD_NO_PARAM_TYPE)
+        violations = check_missing_type_hints(tree, "test.py")
+        assert len(violations) == 1
+        assert "items" in violations[0].message or "parameter" in violations[0].message.lower()
+
+
+class TestAnyType:
+    def test_no_any_passes(self) -> None:
+        tree = ast.parse(GOOD_NO_ANY)
+        violations = check_any_type(tree, "test.py")
+        assert violations == []
+
+    def test_any_param_fails(self) -> None:
+        tree = ast.parse(BAD_ANY_TYPE)
+        violations = check_any_type(tree, "test.py")
+        assert len(violations) == 1
+        assert "Any" in violations[0].message
+
+    def test_any_return_fails(self) -> None:
+        tree = ast.parse(BAD_ANY_RETURN)
+        violations = check_any_type(tree, "test.py")
+        assert len(violations) == 1

package/hooks/validators/test_useless_test_checks.py

@@ -0,0 +1,55 @@
+"""Tests for useless test detection."""
+
+import ast
+
+import pytest
+
+from useless_test_checks import (
+    check_useless_tests,
+)
+from validator_base import Violation
+
+
+GOOD_BEHAVIOR_TEST = '''
+def test_calculate_total():
+    result = calculate_total([10, 20, 30])
+    assert result == 60
+'''
+
+BAD_CALLABLE_CHECK = '''
+def test_function_exists():
+    assert callable(process_data)
+'''
+
+BAD_EXISTENCE_CHECK = '''
+def test_constant_exists():
+    assert hasattr(module, "CONSTANT")
+'''
+
+BAD_CONSTANT_VALUE_TEST = '''
+def test_constant_value():
+    assert CACHE_DIR == "cache"
+'''
+
+
+class TestUselessTests:
+    def test_behavior_test_passes(self) -> None:
+        tree = ast.parse(GOOD_BEHAVIOR_TEST)
+        violations = check_useless_tests(tree, "test_example.py")
+        assert violations == []
+
+    def test_callable_check_fails(self) -> None:
+        tree = ast.parse(BAD_CALLABLE_CHECK)
+        violations = check_useless_tests(tree, "test_example.py")
+        assert len(violations) == 1
+        assert "callable" in violations[0].message.lower()
+
+    def test_existence_check_fails(self) -> None:
+        tree = ast.parse(BAD_EXISTENCE_CHECK)
+        violations = check_useless_tests(tree, "test_example.py")
+        assert len(violations) == 1
+
+    def test_constant_value_test_fails(self) -> None:
+        tree = ast.parse(BAD_CONSTANT_VALUE_TEST)
+        violations = check_useless_tests(tree, "test_example.py")
+        assert len(violations) == 1

package/hooks/validators/test_validator_base.py

@@ -0,0 +1,26 @@
+"""Tests for shared validator base types."""
+
+import pytest
+
+from validator_base import Violation
+
+
+class TestViolation:
+    def test_violation_str_format(self) -> None:
+        violation = Violation(file="test.py", line=42, message="Test message")
+        assert str(violation) == "test.py:42: Test message"
+
+    def test_violation_is_immutable(self) -> None:
+        violation = Violation(file="test.py", line=42, message="Test message")
+        with pytest.raises(AttributeError):
+            violation.file = "other.py"
+
+    def test_violation_equality(self) -> None:
+        v1 = Violation(file="test.py", line=42, message="Test message")
+        v2 = Violation(file="test.py", line=42, message="Test message")
+        assert v1 == v2
+
+    def test_violation_hashable(self) -> None:
+        violation = Violation(file="test.py", line=42, message="Test message")
+        violation_set = {violation}
+        assert violation in violation_set

package/hooks/validators/test_verify_paths.py

@@ -0,0 +1,34 @@
+"""Tests for validator path verification script."""
+
+import pytest
+
+
+def test_extract_validator_paths_finds_validator_references() -> None:
+    """Test that validator references are extracted from markdown content."""
+    from verify_paths import extract_validator_paths
+
+    content = """
+    **Validator:** `validators/import_checks.py`
+    Some text here.
+    **Validator:** `validators/style_checks.py`
+    """
+
+    result = extract_validator_paths(content)
+
+    assert "import_checks.py" in result
+    assert "style_checks.py" in result
+
+
+def test_extract_validator_paths_deduplicates() -> None:
+    """Test that duplicate validator references are deduplicated."""
+    from verify_paths import extract_validator_paths
+
+    content = """
+    **Validator:** `validators/import_checks.py`
+    **Validator:** `validators/import_checks.py`
+    **Validator:** `validators/import_checks.py`
+    """
+
+    result = extract_validator_paths(content)
+
+    assert result.count("import_checks.py") == 1

package/hooks/validators/todo_checks.py

@@ -0,0 +1,59 @@
+"""TODO/FIXME tracking validator.
+
+Implements check 36: TODO without issue reference.
+"""
+
+import re
+import sys
+from pathlib import Path
+from typing import List
+
+from validator_base import Violation
+
+
+TODO_PATTERN = re.compile(r"#\s*(TODO|FIXME)\b(?!.*#\d+)", re.IGNORECASE)
+
+
+def check_untracked_todos(source: str, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+    lines = source.splitlines()
+
+    for line_num, line in enumerate(lines, start=1):
+        if TODO_PATTERN.search(line):
+            violations.append(
+                Violation(
+                    filename,
+                    line_num,
+                    "TODO/FIXME without issue reference - add #<issue_number>",
+                )
+            )
+
+    return violations
+
+
+def validate_file(file_path: Path) -> List[Violation]:
+    filename = str(file_path)
+    try:
+        source = file_path.read_text(encoding="utf-8")
+    except Exception as error:
+        return [Violation(filename, 0, f"Error reading file: {error}")]
+
+    return check_untracked_todos(source, filename)
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        return 1
+
+    all_violations: List[Violation] = []
+    for file_arg in sys.argv[1:]:
+        all_violations.extend(validate_file(Path(file_arg)))
+
+    for violation in all_violations:
+        print(violation)
+
+    return 1 if all_violations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())