claude-dev-env 1.34.1 → 1.36.0

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -0,0 +1,173 @@
+"""Meta-test asserting every check_* function in code_rules_enforcer follows the cap convention.
+
+Bot reviewers on PR #232 flagged check_existence_check_tests,
+check_constant_equality_tests, and check_unused_optional_parameters for
+returning unbounded issue lists, which produces a spammy blocking
+payload when a single file has many violations of the same kind.
+
+The convention is: every check_* function should either apply an
+explicit cap (the meta-test treats a function as capped when its source
+contains a ``MAX_`` constant name or uses ``itertools.islice`` for bounded
+iteration), or be explicitly listed below as a known-uncapped check
+along with the reason, or appear in VOID_ADVISORY_CHECK_FUNCTION_NAMES
+when the function is annotated ``-> None`` and never contributes issues to the
+blocking payload (stderr-only advisories). New check_* functions added to the
+module without consideration will trip this test.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import pathlib
+import sys
+
+
+_HOOK_DIRECTORY = pathlib.Path(__file__).parent
+if str(_HOOK_DIRECTORY) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIRECTORY))
+
+_hook_spec = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIRECTORY / "code_rules_enforcer.py",
+)
+assert _hook_spec is not None
+assert _hook_spec.loader is not None
+_hook_module = importlib.util.module_from_spec(_hook_spec)
+_hook_spec.loader.exec_module(_hook_module)
+
+VOID_ADVISORY_CHECK_FUNCTION_NAMES: frozenset[str] = frozenset(
+    {
+        "check_duplicated_format_patterns",
+        "check_incomplete_mocks",
+    }
+)
+
+KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
+    {
+        "check_boolean_naming",
+        "check_collection_prefix",
+        "check_comment_changes",
+        "check_comments_javascript",
+        "check_comments_python",
+        "check_constant_equality_tests",
+        "check_constants_outside_config",
+        "check_constants_outside_config_advisory",
+        "check_e2e_test_naming",
+        "check_existence_check_tests",
+        "check_file_global_constants_use_count",
+        "check_fstring_structural_literals",
+        "check_imports_at_top",
+        "check_inline_literal_collections",
+        "check_library_print",
+        "check_logging_fstrings",
+        "check_loop_variable_naming",
+        "check_magic_values",
+        "check_parameter_annotations",
+        "check_return_annotations",
+        "check_skip_decorators_in_tests",
+        "check_string_literal_magic",
+        "check_type_escape_hatches",
+        "check_unused_optional_parameters",
+        "check_windows_api_none",
+    }
+)
+
+CAP_TOKEN_FRAGMENTS: tuple[str, ...] = ("MAX_", "islice")
+
+
+def _all_check_function_names() -> list[str]:
+    return [
+        each_attribute_name
+        for each_attribute_name in dir(_hook_module)
+        if each_attribute_name.startswith("check_")
+        and callable(getattr(_hook_module, each_attribute_name))
+    ]
+
+
+def _function_source_contains_cap(function_name: str) -> bool:
+    function_object = getattr(_hook_module, function_name)
+    function_source = inspect.getsource(function_object)
+    return any(
+        each_fragment in function_source for each_fragment in CAP_TOKEN_FRAGMENTS
+    )
+
+
+def test_every_check_function_either_caps_or_is_explicitly_pending() -> None:
+    all_check_names = set(_all_check_function_names())
+    capped_check_names = {
+        each_name
+        for each_name in all_check_names
+        if _function_source_contains_cap(each_name)
+    }
+    uncapped_check_names = all_check_names - capped_check_names
+    unexpected_uncapped = (
+        uncapped_check_names
+        - KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW
+        - VOID_ADVISORY_CHECK_FUNCTION_NAMES
+    )
+    assert unexpected_uncapped == set(), (
+        f"New check_* functions added without a cap and not on the pending-review list: "
+        f"{sorted(unexpected_uncapped)}. Either add a MAX_* cap or islice-bounded loop in "
+        f"source, or explicitly add the function to KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW with "
+        f"a reason in the test header docstring, or list it in VOID_ADVISORY_CHECK_FUNCTION_NAMES "
+        f"when it is annotated -> None and emits only stderr guidance."
+    )
+
+
+def test_pending_review_set_does_not_grow_silently() -> None:
+    all_check_names = set(_all_check_function_names())
+    stale_pending = KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW - all_check_names
+    assert stale_pending == set(), (
+        f"KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW lists functions that no longer exist: "
+        f"{sorted(stale_pending)}. Either restore the function or remove it from the list."
+    )
+
+
+def test_pending_review_set_excludes_functions_that_already_match_cap_heuristic() -> None:
+    all_check_names = set(_all_check_function_names())
+    pending_that_exist = KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW & all_check_names
+    capped_but_still_pending = {
+        each_name
+        for each_name in pending_that_exist
+        if _function_source_contains_cap(each_name)
+    }
+    assert capped_but_still_pending == set(), (
+        f"KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW must not list checks that already satisfy the "
+        f"cap heuristic (would hide a later cap removal): {sorted(capped_but_still_pending)}. "
+        f"Remove those names from the pending set after capping."
+    )
+
+
+def test_void_advisory_checks_are_registered_and_disjoint() -> None:
+    all_check_names = set(_all_check_function_names())
+    assert VOID_ADVISORY_CHECK_FUNCTION_NAMES <= all_check_names, (
+        f"VOID_ADVISORY_CHECK_FUNCTION_NAMES references missing names: "
+        f"{sorted(VOID_ADVISORY_CHECK_FUNCTION_NAMES - all_check_names)}"
+    )
+    for each_name in VOID_ADVISORY_CHECK_FUNCTION_NAMES:
+        function_object = getattr(_hook_module, each_name)
+        return_annotation = inspect.signature(function_object).return_annotation
+        assert return_annotation is None, (
+            f"VOID_ADVISORY_CHECK_FUNCTION_NAMES must list only advisory-only checks annotated "
+            f"with -> None (stderr-only, never block). {each_name!r} has return annotation "
+            f"{return_annotation!r}."
+        )
+    overlap = VOID_ADVISORY_CHECK_FUNCTION_NAMES & KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW
+    assert overlap == set(), (
+        f"Void-advisory checks must not also appear on the uncapped pending list: "
+        f"{sorted(overlap)}"
+    )
+
+
+def test_already_capped_checks_stay_capped() -> None:
+    capped_baseline: frozenset[str] = frozenset(
+        {
+            "check_banned_identifiers",
+        }
+    )
+    for each_name in capped_baseline:
+        assert _function_source_contains_cap(each_name), (
+            f"{each_name} previously had a cap reference and now does not. "
+            f"Caps protect blocking output from spamming reviewers — restore it."
+        )

package/hooks/blocking/test_code_rules_enforcer_collection_prefix.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+from pathlib import Path
+import importlib.util
+
+ENFORCER_PATH = Path(__file__).resolve().parent / "code_rules_enforcer.py"
+specification = importlib.util.spec_from_file_location(
+    "code_rules_enforcer", ENFORCER_PATH
+)
+code_rules_enforcer = importlib.util.module_from_spec(specification)
+specification.loader.exec_module(code_rules_enforcer)
+
+PRODUCTION_FILE_PATH = "packages/app/services/foo.py"
+
+
+def test_should_flag_bare_set_parameter_without_all_prefix() -> None:
+    source = "def consume(numbers: set[int]) -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected bare set[int] parameter flagged, got: {issues}"
+    )
+
+
+def test_should_flag_pep604_union_set_with_none_right() -> None:
+    source = "def consume(numbers: set[int] | None = None) -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected set[int] | None parameter flagged, got: {issues}"
+    )
+
+
+def test_should_flag_pep604_union_set_with_none_left() -> None:
+    source = "def consume(numbers: None | set[int] = None) -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected None | set[int] parameter flagged, got: {issues}"
+    )
+
+
+def test_should_flag_optional_set_parameter() -> None:
+    source = (
+        "from typing import Optional\n"
+        "\n"
+        "def consume(numbers: Optional[set[int]] = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected Optional[set[int]] parameter flagged, got: {issues}"
+    )
+
+
+def test_should_flag_union_set_with_none_parameter() -> None:
+    source = (
+        "from typing import Union\n"
+        "\n"
+        "def consume(numbers: Union[set[int], None] = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected Union[set[int], None] parameter flagged, got: {issues}"
+    )
+
+
+def test_should_flag_pep604_union_dict_parameter() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "\n"
+        "def consume(per_path: dict[Path, set[int]] | None = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("per_path" in each_issue for each_issue in issues), (
+        f"Expected dict[..] | None parameter flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_pep604_union_when_param_has_all_prefix() -> None:
+    source = (
+        "def consume(all_numbers: set[int] | None = None) -> None:\n    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert not any("all_numbers" in each_issue for each_issue in issues), (
+        f"all_-prefixed parameter must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_optional_when_param_uses_x_by_y_pattern() -> None:
+    source = (
+        "from typing import Optional\n"
+        "\n"
+        "def consume(price_by_product: Optional[dict[str, int]] = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert not any("price_by_product" in each_issue for each_issue in issues), (
+        f"X_by_Y-pattern parameter must not be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_qualified_typing_optional_set_parameter() -> None:
+    source = (
+        "import typing\n"
+        "\n"
+        "def consume(numbers: typing.Optional[set[int]] = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected typing.Optional[set[int]] (ast.Attribute outer subscript) flagged, got: {issues}"
+    )
+
+
+def test_should_flag_qualified_typing_union_with_none_parameter() -> None:
+    source = (
+        "import typing\n"
+        "\n"
+        "def consume(numbers: typing.Union[set[int], None] = None) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("numbers" in each_issue for each_issue in issues), (
+        f"Expected typing.Union[set[int], None] (ast.Attribute outer subscript) flagged, got: {issues}"
+    )
+
+
+def test_should_flag_module_level_qualified_typing_optional_constant() -> None:
+    source = (
+        "import typing\n"
+        "\n"
+        "RAW_NUMBERS: typing.Optional[set[int]] = None\n"
+    )
+    issues = code_rules_enforcer.check_collection_prefix(source, PRODUCTION_FILE_PATH)
+    assert any("RAW_NUMBERS" in each_issue for each_issue in issues), (
+        f"Expected typing.Optional[set[int]] module-level constant flagged, got: {issues}"
+    )
+
+
+def test_should_flag_function_local_double_all_prefix() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    all_all_permission_rules = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_permission_rules" in each_issue for each_issue in issues), (
+        f"PR #289 finding: stuttering all_all_ must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_module_level_double_all_uppercase() -> None:
+    source = "ALL_ALL_PROVIDERS = []\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("ALL_ALL_PROVIDERS" in each_issue for each_issue in issues), (
+        f"Stuttering ALL_ALL_ at module scope must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_triple_all_prefix_stuttering() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    all_all_all_things = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_all_things" in each_issue for each_issue in issues), (
+        f"Triple all_ stuttering must be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_single_all_prefix() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    all_users = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Single all_ prefix is correct usage, must not flag, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_in_function_parameter() -> None:
+    source = (
+        "def consume(all_all_users: list) -> None:\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_users" in each_issue for each_issue in issues), (
+        f"Stuttering parameter name must be flagged, got: {issues}"
+    )
+
+
+def test_should_skip_stuttering_check_in_test_files() -> None:
+    source = (
+        "def test_something() -> None:\n"
+        "    all_all_results = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, "packages/app/tests/test_foo.py"
+    )
+    assert issues == [], f"Test files exempt, got: {issues}"
+
+
+def test_should_not_flag_all_all_when_used_as_substring() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    install_all_users = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"'all_all_' as substring inside install_all_users must not flag, got: {issues}"
+    )
+
+
+def test_should_flag_underscore_prefixed_uppercase_double_all() -> None:
+    source = "_ALL_ALL_PROVIDERS = []\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_ALL_ALL_PROVIDERS" in each_issue for each_issue in issues), (
+        f"Stuttering _ALL_ALL_ private constant must be flagged (regex symmetry), got: {issues}"
+    )
+
+
+def test_should_flag_underscore_prefixed_lowercase_double_all() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    _all_all_permission_rules = []\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("_all_all_permission_rules" in each_issue for each_issue in issues), (
+        f"Stuttering _all_all_ private local must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_function_name() -> None:
+    source = "def all_all_process() -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_process" in each_issue for each_issue in issues), (
+        f"Stuttering function name must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_async_function_name() -> None:
+    source = "async def all_all_fetch() -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_fetch" in each_issue for each_issue in issues), (
+        f"Stuttering async function name must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_walrus_target() -> None:
+    source = (
+        "def grant() -> None:\n"
+        "    if (all_all_result := compute()):\n"
+        "        return None\n"
+        "def compute() -> int:\n"
+        "    return 0\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_result" in each_issue for each_issue in issues), (
+        f"Stuttering walrus target must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_comprehension_target() -> None:
+    source = (
+        "def grant() -> list[int]:\n"
+        "    return [all_all_item for all_all_item in range(10)]\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_item" in each_issue for each_issue in issues), (
+        f"Stuttering comprehension target must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_import_as_alias() -> None:
+    source = "import collections as all_all_collections\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_collections" in each_issue for each_issue in issues), (
+        f"Stuttering import-as alias must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_from_import_as_alias() -> None:
+    source = "from collections import OrderedDict as all_all_ordered\n"
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_ordered" in each_issue for each_issue in issues), (
+        f"Stuttering from-import as alias must be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_stuttering_class_name() -> None:
+    source = (
+        "class all_all_models:\n"
+        "    value = 1\n"
+    )
+    issues = code_rules_enforcer.check_stuttering_collection_prefix(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("all_all_models" in each_issue for each_issue in issues), (
+        f"Stuttering class name must be flagged, got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_config_path.py

@@ -83,26 +83,6 @@ def test_should_produce_blocking_for_module_level_upper_snake_outside_config() -
     assert any("MAX_RETRIES" in issue for issue in blocking_issues)
 
 
-def test_should_include_file_path_in_advisory_stderr_output() -> None:
-    source = (
-        "def fetch_data():\n"
-        "    MAX_RETRIES = 3\n"
-        "    for attempt in range(MAX_RETRIES):\n"
-        "        pass\n"
-    )
-    captured_stderr = io.StringIO()
-    old_stderr = sys.stderr
-    sys.stderr = captured_stderr
-    try:
-        code_rules_enforcer.validate_content(source, PRODUCTION_FILE_PATH, "")
-    finally:
-        sys.stderr = old_stderr
-    advisory_output = captured_stderr.getvalue()
-    assert PRODUCTION_FILE_PATH in advisory_output, (
-        f"Advisory stderr must include the file path; got: {advisory_output!r}"
-    )
-
-
 def test_should_produce_stable_ordering_sorted_by_line_number() -> None:
     source = (
         "ALPHA_CONSTANT = 1\n"

package/hooks/blocking/test_code_rules_enforcer_constant_equality.py

@@ -110,21 +110,43 @@ def test_should_not_flag_non_test_function() -> None:
     assert issues == [], f"Expected no issues for non-test function, got: {issues}"
 
 
-def test_stops_at_max_issues_per_check() -> None:
+def test_should_flag_literal_on_left_with_constant_on_right() -> 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"
+        'CACHE_DIR = "cache"\n'
         "\n"
-        "def test_gamma() -> None:\n    assert GAMMA == 3\n"
+        "def test_cache_dir_right() -> None:\n"
+        '    assert "cache" == CACHE_DIR\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 'cache' == CACHE_DIR flagged equally — equality is commutative, got: {issues}"
+    )
+
+
+def test_should_flag_numeric_literal_on_left_with_constant_on_right() -> None:
+    source = (
+        "MAX_SIZE = 100\n"
         "\n"
-        "def test_delta() -> None:\n    assert DELTA == 4\n"
+        "def test_max_size_right() -> None:\n"
+        "    assert 100 == MAX_SIZE\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 100 == MAX_SIZE flagged equally, got: {issues}"
+    )
+
+
+def test_should_not_flag_two_upper_snake_constants_compared() -> None:
+    source = (
+        "EXPECTED = 5\n"
+        "ACTUAL = 5\n"
         "\n"
-        "def test_epsilon() -> None:\n    assert EPSILON == 5\n"
+        "def test_two_constants() -> None:\n"
+        "    assert EXPECTED == ACTUAL\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}"
+    assert issues == [], (
+        f"Two-constant comparison is not constant-vs-literal, must not flag, got: {issues}"
     )
+
+

package/hooks/blocking/test_code_rules_enforcer_existence_checks.py

@@ -101,24 +101,6 @@ def test_should_not_flag_non_test_function_with_existence_check() -> None:
     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"