claude-dev-env 1.29.3 → 1.30.0

package/hooks/blocking/test_code_rules_enforcer_constant_equality.py

@@ -0,0 +1,130 @@
+"""Tests for constant-value test detection.
+
+Tests that assert a constant equals a literal cover nothing about
+behavior and should be deleted.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+TEST_FILE_PATH = "packages/app/tests/test_constants.py"
+PRODUCTION_FILE_PATH = "packages/app/services/feature.py"
+
+
+def test_should_flag_test_asserting_constant_equals_literal() -> None:
+    source = (
+        'CACHE_DIR = "cache"\n'
+        "\n"
+        "def test_cache_dir_value() -> None:\n"
+        '    assert CACHE_DIR == "cache"\n'
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert any("constant" in issue.lower() for issue in issues), (
+        f"Expected constant-value test issue, got: {issues}"
+    )
+
+
+def test_should_flag_test_with_single_upper_snake_equality() -> None:
+    source = (
+        "MAX_SIZE = 100\n"
+        "\n"
+        "def test_max_size_is_100() -> None:\n"
+        "    assert MAX_SIZE == 100\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert any("constant" in issue.lower() for issue in issues), (
+        f"Expected constant-value test issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_test_asserting_computed_result() -> None:
+    source = (
+        "def test_compute_returns_expected() -> None:\n"
+        "    computed_value = compute()\n"
+        "    assert computed_value == EXPECTED_OUTPUT\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for behavior test, got: {issues}"
+
+
+def test_should_not_flag_test_with_multiple_assertions() -> None:
+    source = (
+        "TIMEOUT = 30\n"
+        "\n"
+        "def test_timeout_used_in_connection() -> None:\n"
+        "    assert TIMEOUT == 30\n"
+        "    connection = connect(timeout=TIMEOUT)\n"
+        "    assert connection.is_alive()\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for multi-assertion test, got: {issues}"
+
+
+def test_should_not_flag_in_production_files() -> None:
+    source = (
+        "CACHE_DIR = 'cache'\n"
+        "\n"
+        "def test_something() -> None:\n"
+        "    assert CACHE_DIR == 'cache'\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues in production file, got: {issues}"
+
+
+def test_should_include_line_number_in_issue() -> None:
+    source = (
+        '\n\ndef test_my_constant_value() -> None:\n    assert MY_CONST == "value"\n'
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert any("Line 3" in issue for issue in issues), (
+        f"Expected 'Line 3' in issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_non_test_function() -> None:
+    source = (
+        "TIMEOUT = 30\n"
+        "\n"
+        "def check_constant_value() -> None:\n"
+        "    assert TIMEOUT == 30\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for non-test function, got: {issues}"
+
+
+def test_stops_at_max_issues_per_check() -> None:
+    source = (
+        "ALPHA = 1\nBETA = 2\nGAMMA = 3\nDELTA = 4\nEPSILON = 5\n"
+        "\n"
+        "def test_alpha() -> None:\n    assert ALPHA == 1\n"
+        "\n"
+        "def test_beta() -> None:\n    assert BETA == 2\n"
+        "\n"
+        "def test_gamma() -> None:\n    assert GAMMA == 3\n"
+        "\n"
+        "def test_delta() -> None:\n    assert DELTA == 4\n"
+        "\n"
+        "def test_epsilon() -> None:\n    assert EPSILON == 5\n"
+    )
+    issues = code_rules_enforcer.check_constant_equality_tests(source, TEST_FILE_PATH)
+    assert len(issues) == code_rules_enforcer.MAX_ISSUES_PER_CHECK, (
+        f"Expected exactly MAX_ISSUES_PER_CHECK issues, got {len(issues)}: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_existence_checks.py

@@ -0,0 +1,134 @@
+"""Tests for existence-check test detection.
+
+Tests that only assert callable(x), hasattr(m, 'name'), or
+x is not None without any behavior validation are useless and
+should be deleted or replaced.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+TEST_FILE_PATH = "packages/app/tests/test_feature.py"
+PRODUCTION_FILE_PATH = "packages/app/services/feature.py"
+
+
+def test_should_flag_test_with_only_callable_assertion() -> None:
+    source = "def test_function_exists() -> None:\n    assert callable(my_function)\n"
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert any("existence" in issue.lower() for issue in issues), (
+        f"Expected existence-check issue, got: {issues}"
+    )
+
+
+def test_should_flag_test_with_only_hasattr_assertion() -> None:
+    source = (
+        "def test_module_has_attribute() -> None:\n"
+        '    assert hasattr(module, "my_attr")\n'
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert any("existence" in issue.lower() for issue in issues), (
+        f"Expected existence-check issue, got: {issues}"
+    )
+
+
+def test_should_flag_test_with_only_is_not_none_assertion() -> None:
+    source = (
+        "def test_instance_created() -> None:\n"
+        "    instance = MyClass()\n"
+        "    assert instance is not None\n"
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert any("existence" in issue.lower() for issue in issues), (
+        f"Expected existence-check issue for is-not-None test, got: {issues}"
+    )
+
+
+def test_should_not_flag_test_with_behavior_assertions() -> None:
+    source = (
+        "def test_function_returns_expected_value() -> None:\n"
+        "    actual_result = compute(input_value)\n"
+        "    assert actual_result == expected_value\n"
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for behavior test, got: {issues}"
+
+
+def test_should_not_flag_test_with_multiple_assertions() -> None:
+    source = (
+        "def test_function_callable_and_returns_int() -> None:\n"
+        "    assert callable(my_function)\n"
+        "    assert isinstance(my_function(), int)\n"
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for multi-assertion test, got: {issues}"
+
+
+def test_should_not_flag_existence_checks_in_production_files() -> None:
+    source = "def test_function_exists() -> None:\n    assert callable(my_function)\n"
+    issues = code_rules_enforcer.check_existence_check_tests(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues in production file, got: {issues}"
+
+
+def test_should_include_line_number_in_issue() -> None:
+    source = "\n\ndef test_callable_check() -> None:\n    assert callable(func)\n"
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert any("Line 3" in issue for issue in issues), (
+        f"Expected 'Line 3' in issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_non_test_function_with_existence_check() -> None:
+    source = "def helper_with_callable_check() -> None:\n    assert callable(func)\n"
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for non-test function, got: {issues}"
+
+
+def test_stops_at_max_issues_per_check() -> None:
+    source = (
+        "def test_one() -> None:\n    assert callable(func_one)\n"
+        "\n"
+        "def test_two() -> None:\n    assert callable(func_two)\n"
+        "\n"
+        "def test_three() -> None:\n    assert callable(func_three)\n"
+        "\n"
+        "def test_four() -> None:\n    assert callable(func_four)\n"
+        "\n"
+        "def test_five() -> None:\n    assert callable(func_five)\n"
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert len(issues) == code_rules_enforcer.MAX_ISSUES_PER_CHECK, (
+        f"Expected exactly MAX_ISSUES_PER_CHECK issues, got {len(issues)}: {issues}"
+    )
+
+
+def test_should_not_flag_outer_test_when_nested_helper_contains_existence_check() -> None:
+    source = (
+        "def test_outer_behavior() -> None:\n"
+        "    if True:\n"
+        "        def nested_helper() -> None:\n"
+        "            assert callable(some_function)\n"
+        "    assert 1 + 1 == 2\n"
+    )
+    issues = code_rules_enforcer.check_existence_check_tests(source, TEST_FILE_PATH)
+    assert issues == [], (
+        f"Expected no issues: nested helper's callable assertion must not count"
+        f" against the outer test, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_skip_decorators.py

@@ -0,0 +1,150 @@
+"""Tests for skip-decorator detection in test files.
+
+Tests must fail on missing dependencies rather than silently skip.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_enforcer_module() -> ModuleType:
+    module_path = Path(__file__).parent / "code_rules_enforcer.py"
+    spec = importlib.util.spec_from_file_location("code_rules_enforcer", module_path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+code_rules_enforcer = _load_enforcer_module()
+
+TEST_FILE_PATH = "packages/app/tests/test_feature.py"
+PRODUCTION_FILE_PATH = "packages/app/services/feature.py"
+
+
+def test_should_flag_pytest_mark_skip_on_test_function() -> None:
+    source = (
+        "import pytest\n"
+        "\n"
+        "@pytest.mark.skip(reason='missing dep')\n"
+        "def test_something() -> None:\n"
+        "    assert True\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("skip" in issue.lower() for issue in issues), (
+        f"Expected skip decorator issue, got: {issues}"
+    )
+
+
+def test_should_flag_pytest_mark_skipif_on_test_function() -> None:
+    source = (
+        "import pytest\n"
+        "\n"
+        "@pytest.mark.skipif(condition, reason='missing')\n"
+        "def test_other() -> None:\n"
+        "    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("skip" in issue.lower() for issue in issues), (
+        f"Expected skipif decorator issue, got: {issues}"
+    )
+
+
+def test_should_flag_unittest_skip_on_test_function() -> None:
+    source = (
+        "import unittest\n"
+        "\n"
+        "@unittest.skip('not ready')\n"
+        "def test_thing() -> None:\n"
+        "    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("skip" in issue.lower() for issue in issues), (
+        f"Expected unittest.skip issue, got: {issues}"
+    )
+
+
+def test_should_flag_skip_if_missing_dependency_decorator() -> None:
+    source = (
+        "@skip_if_missing_dependency('requests')\n"
+        "def test_with_requests() -> None:\n"
+        "    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("skip" in issue.lower() for issue in issues), (
+        f"Expected skip_if_missing_dependency issue, got: {issues}"
+    )
+
+
+def test_should_not_flag_skip_decorators_on_non_test_functions() -> None:
+    source = (
+        "@pytest.mark.skip(reason='broken')\ndef helper_function() -> None:\n    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert issues == [], f"Expected no issues for non-test function, got: {issues}"
+
+
+def test_should_not_flag_skip_decorators_in_production_files() -> None:
+    source = (
+        "@pytest.mark.skip(reason='missing dep')\n"
+        "def test_something() -> None:\n"
+        "    assert True\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues in production file, got: {issues}"
+
+
+def test_should_include_line_number_in_issue_message() -> None:
+    source = (
+        "import pytest\n"
+        "\n"
+        "@pytest.mark.skip(reason='missing dep')\n"
+        "def test_flagged() -> None:\n"
+        "    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("Line 3" in issue for issue in issues), (
+        f"Expected 'Line 3' in issue, got: {issues}"
+    )
+
+
+def test_should_flag_decorator_with_skip_in_name() -> None:
+    source = "@skip_slow_tests\ndef test_slow() -> None:\n    pass\n"
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert any("skip" in issue.lower() for issue in issues), (
+        f"Expected skip-named decorator issue, got: {issues}"
+    )
+
+
+def test_stops_at_max_issues_per_check() -> None:
+    source = (
+        "import pytest\n"
+        "\n"
+        "@pytest.mark.skip(reason='a')\n"
+        "def test_one() -> None:\n"
+        "    pass\n"
+        "\n"
+        "@pytest.mark.skip(reason='b')\n"
+        "def test_two() -> None:\n"
+        "    pass\n"
+        "\n"
+        "@pytest.mark.skip(reason='c')\n"
+        "def test_three() -> None:\n"
+        "    pass\n"
+        "\n"
+        "@pytest.mark.skip(reason='d')\n"
+        "def test_four() -> None:\n"
+        "    pass\n"
+        "\n"
+        "@pytest.mark.skip(reason='e')\n"
+        "def test_five() -> None:\n"
+        "    pass\n"
+    )
+    issues = code_rules_enforcer.check_skip_decorators_in_tests(source, TEST_FILE_PATH)
+    assert len(issues) == code_rules_enforcer.MAX_ISSUES_PER_CHECK