claude-dev-env 1.34.0 → 1.35.0

package/hooks/blocking/test_code_rules_enforcer_annotations.py

@@ -0,0 +1,97 @@
+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"
+TEST_FILE_PATH = "packages/app/tests/test_foo.py"
+
+
+def test_should_flag_parameter_without_annotation() -> None:
+    source = "def consume(value) -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_parameter_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("value" in each_issue for each_issue in issues), (
+        f"Expected unannotated parameter flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_annotated_parameters() -> None:
+    source = (
+        "def consume(value: int, label: str = 'default') -> None:\n    return None\n"
+    )
+    issues = code_rules_enforcer.check_parameter_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Expected no issues for annotated params, got: {issues}"
+
+
+def test_should_exempt_self_and_cls_parameters() -> None:
+    source = (
+        "class Foo:\n"
+        "    def method(self, value: int) -> None:\n"
+        "        return None\n"
+        "    @classmethod\n"
+        "    def factory(cls, value: int) -> 'Foo':\n"
+        "        return cls()\n"
+    )
+    issues = code_rules_enforcer.check_parameter_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"self/cls must be exempt from annotation requirement, got: {issues}"
+    )
+
+
+def test_should_flag_class_method_parameter_without_annotation() -> None:
+    source = "class Foo:\n    def method(self, value) -> None:\n        return None\n"
+    issues = code_rules_enforcer.check_parameter_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("value" in each_issue for each_issue in issues), (
+        f"Expected method param flagged, got: {issues}"
+    )
+
+
+def test_should_skip_parameter_check_in_test_files() -> None:
+    source = "def consume(value) -> None:\n    return None\n"
+    issues = code_rules_enforcer.check_parameter_annotations(source, TEST_FILE_PATH)
+    assert issues == [], f"Test files must be exempt, got: {issues}"
+
+
+def test_should_flag_function_without_return_annotation() -> None:
+    source = "def fetch(url: str):\n    return url\n"
+    issues = code_rules_enforcer.check_return_annotations(source, PRODUCTION_FILE_PATH)
+    assert any("fetch" in each_issue for each_issue in issues), (
+        f"Expected function without return type flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_function_with_return_annotation() -> None:
+    source = "def fetch(url: str) -> str:\n    return url\n"
+    issues = code_rules_enforcer.check_return_annotations(source, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Function with return type must not be flagged, got: {issues}"
+
+
+def test_should_flag_async_function_without_return_annotation() -> None:
+    source = "async def fetch(url: str):\n    return url\n"
+    issues = code_rules_enforcer.check_return_annotations(source, PRODUCTION_FILE_PATH)
+    assert any("fetch" in each_issue for each_issue in issues), (
+        f"Expected async function without return type flagged, got: {issues}"
+    )
+
+
+def test_should_skip_return_check_in_test_files() -> None:
+    source = "def fetch(url: str):\n    return url\n"
+    issues = code_rules_enforcer.check_return_annotations(source, TEST_FILE_PATH)
+    assert issues == [], f"Test files must be exempt, got: {issues}"
+
+

package/hooks/blocking/test_code_rules_enforcer_collection_prefix.py

@@ -0,0 +1,137 @@
+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}"
+    )

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,3 @@ 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:
-    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

@@ -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"

package/hooks/blocking/test_code_rules_enforcer_inline_literal_collections.py

@@ -0,0 +1,155 @@
+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"
+TEST_FILE_PATH = "packages/app/tests/test_foo.py"
+CONFIG_FILE_PATH = "packages/app/config/constants.py"
+
+
+def test_should_flag_set_literal_with_three_string_constants_in_function_body() -> None:
+    source = (
+        "def is_known(value: str) -> bool:\n"
+        "    return value in {'true', 'false', 'none'}\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 1, f"Expected 3-element set flagged, got: {issues}"
+
+
+def test_should_flag_list_literal_with_five_string_constants_in_function_body() -> None:
+    source = (
+        "def is_code_path(suffix: str) -> bool:\n"
+        "    return suffix in ['.py', '.js', '.ts', '.tsx', '.jsx']\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 1, f"Expected 5-element list flagged, got: {issues}"
+
+
+def test_should_not_flag_two_element_set_literal() -> None:
+    source = "def is_binary(value: str) -> bool:\n    return value in {'on', 'off'}\n"
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"2-element literal must not be flagged, got: {issues}"
+
+
+def test_should_not_flag_literal_with_variable_references() -> None:
+    source = (
+        "def consume(a: int, b: int, c: int, d: int) -> list[int]:\n"
+        "    return [a, b, c, d]\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Variable-reference literal must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_module_level_literal() -> None:
+    source = "ALL_VALID_KEYS = {'true', 'false', 'none'}\n"
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Module-level literal must not be flagged by inline-collection check, got: {issues}"
+    )
+
+
+def test_should_skip_in_test_files() -> None:
+    source = (
+        "def test_something() -> None:\n"
+        "    keys = {'true', 'false', 'none'}\n"
+        "    assert 'true' in keys\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], f"Test files exempt, got: {issues}"
+
+
+def test_should_skip_in_config_files() -> None:
+    source = "def known_keys() -> set[str]:\n    return {'true', 'false', 'none'}\n"
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, CONFIG_FILE_PATH
+    )
+    assert issues == [], f"Config files exempt (they own such tables), got: {issues}"
+
+
+def test_should_flag_multiple_inline_collections_in_same_function() -> None:
+    source = (
+        "def consume(value: str) -> bool:\n"
+        "    return value in {'a', 'b', 'c'} or value in {'x', 'y', 'z'}\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 2, f"Expected 2 flagged literals, got: {issues}"
+
+
+def test_should_not_flag_default_argument_set_literal() -> None:
+    source = (
+        "def consume(keys: set[str] = {'a', 'b', 'c'}) -> set[str]:\n"
+        "    return keys\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Default argument value (signature, not body) must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_default_argument_list_literal() -> None:
+    source = (
+        "def consume(suffixes: list[str] = ['.py', '.js', '.ts']) -> list[str]:\n"
+        "    return suffixes\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Default argument list (signature, not body) must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_default_arg_set_of_nested_function_from_outer_scan() -> None:
+    source = (
+        "def outer() -> None:\n"
+        "    def inner(keys: set[str] = {'a', 'b', 'c'}) -> set[str]:\n"
+        "        return keys\n"
+        "    return None\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Nested function's default-arg set (signature) must not be flagged from outer scan, got: {issues}"
+    )
+
+
+def test_should_still_flag_set_literal_in_nested_function_body() -> None:
+    source = (
+        "def outer() -> bool:\n"
+        "    def inner(value: str) -> bool:\n"
+        "        return value in {'a', 'b', 'c'}\n"
+        "    return inner('a')\n"
+    )
+    issues = code_rules_enforcer.check_inline_literal_collections(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert len(issues) == 1, (
+        f"Inner function's body set literal must be flagged exactly once (no duplicate from outer walk), got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_loop_variable_naming.py

@@ -0,0 +1,110 @@
+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"
+TEST_FILE_PATH = "packages/app/tests/test_foo.py"
+
+
+def test_should_flag_loop_variable_without_each_prefix() -> None:
+    source = "def consume() -> None:\n    for marker in []:\n        return None\n"
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("marker" in each_issue for each_issue in issues), (
+        f"Expected 'marker' loop variable flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_loop_variable_with_each_prefix() -> None:
+    source = "def consume() -> None:\n    for each_marker in []:\n        return None\n"
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"each_marker must not be flagged, got: {issues}"
+
+
+def test_should_exempt_index_letters_i_j_k() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    for i in range(3):\n"
+        "        for j in range(3):\n"
+        "            for k in range(3):\n"
+        "                return None\n"
+    )
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"i/j/k must be exempt, got: {issues}"
+
+
+def test_should_flag_bare_each_without_subject() -> None:
+    source = "def consume() -> None:\n    for each in []:\n        return None\n"
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("each" in each_issue for each_issue in issues), (
+        f"Expected bare 'each' flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_tuple_unpacking_targets() -> None:
+    source = (
+        "def consume() -> None:\n"
+        "    for key, value in {}.items():\n"
+        "        return None\n"
+    )
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Tuple-unpack targets exempt, got: {issues}"
+
+
+def test_should_not_flag_list_comprehension_target() -> None:
+    source = "def consume() -> None:\n    return [x for x in []]\n"
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], f"Comprehension target exempt, got: {issues}"
+
+
+def test_should_skip_in_test_files() -> None:
+    source = "def test_consume() -> None:\n    for marker in []:\n        return None\n"
+    issues = code_rules_enforcer.check_loop_variable_naming(source, TEST_FILE_PATH)
+    assert issues == [], f"Test files exempt, got: {issues}"
+
+
+def test_should_flag_async_for_loop_variable() -> None:
+    source = (
+        "async def consume() -> None:\n"
+        "    async for marker in stream():\n"
+        "        return None\n"
+    )
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert any("marker" in each_issue for each_issue in issues), (
+        f"Expected async-for variable flagged, got: {issues}"
+    )
+
+
+def test_should_exempt_underscore_throwaway_loop_variable() -> None:
+    source = (
+        "def consume(count: int) -> None:\n"
+        "    for _ in range(count):\n"
+        "        return None\n"
+    )
+    issues = code_rules_enforcer.check_loop_variable_naming(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Throwaway '_' loop variable must be exempt (Python idiom for 'value intentionally unused'), got: {issues}"
+    )

package/hooks/blocking/test_code_rules_enforcer_naming_pattern.py

@@ -148,19 +148,6 @@ def test_should_skip_workflow_registry_files() -> None:
     assert issues == []
 
 
-def test_should_cap_issues_at_three() -> None:
-    source = (
-        "def f() -> None:\n"
-        "    one = True\n"
-        "    two = False\n"
-        "    three = True\n"
-        "    four = False\n"
-        "    five = True\n"
-    )
-    issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)
-    assert len(issues) == 3
-
-
 def test_should_not_flag_syntax_error_as_issue() -> None:
     source = "def f(:\n    valid = True\n"
     issues = check_boolean_naming(source, PRODUCTION_FILE_PATH)

package/hooks/blocking/test_code_rules_enforcer_skip_decorators.py

@@ -122,29 +122,3 @@ def test_should_flag_decorator_with_skip_in_name() -> None:
     )
 
 
-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