claude-dev-env 1.60.0 → 1.61.0

package/hooks/blocking/test_code_rules_enforcer_annotations.py

@@ -320,3 +320,243 @@ def test_should_flag_undefaulted_fixture_before_defaulted_one() -> None:
     )
 
 
+def test_should_flag_unused_known_fixture_parameter_in_test_file() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_omits_config(tmp_path: Path) -> None:\n"
+        "    command = build_command('module.py', None)\n"
+        "    assert command[-1] == 'module.py'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"Expected unused tmp_path fixture parameter flagged, got: {issues}"
+
+
+def test_should_not_flag_used_known_fixture_parameter() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_includes_config(tmp_path: Path) -> None:\n"
+        "    config_file = tmp_path / 'pyproject.toml'\n"
+        "    assert config_file.name == 'pyproject.toml'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A referenced fixture parameter must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_ordinary_test_parameter() -> None:
+    source = "def test_thing(some_value):\n    return 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Only known pytest fixtures are checked, not arbitrary params, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_outside_test_files() -> None:
+    source = "def build(tmp_path):\n    return 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"This check applies to test files only, got: {issues}"
+    )
+
+
+def test_should_flag_unused_monkeypatch_fixture_parameter() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    assert build_command('m.py', None)[-1] == 'm.py'\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "monkeypatch" in each_issue for each_issue in issues
+    ), f"Expected unused monkeypatch fixture parameter flagged, got: {issues}"
+
+
+def test_should_count_attribute_access_as_fixture_use() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Attribute access on the fixture counts as a use, got: {issues}"
+    )
+
+
+def test_should_count_nested_function_reference_as_fixture_use() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_board(tmp_path: Path) -> None:\n"
+        "    def inner() -> Path:\n"
+        "        return tmp_path\n"
+        "    assert inner().name\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A reference inside a nested function counts as a use, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_in_decorated_fixture_function() -> None:
+    source = (
+        "import pytest\n"
+        "from pathlib import Path\n"
+        "@pytest.fixture\n"
+        "def board(tmp_path: Path) -> int:\n"
+        "    return 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture composing another fixture by injection alone is intentional "
+        f"and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_count_comprehension_reference_as_fixture_use() -> None:
+    source = (
+        "import pytest\n"
+        "def test_log_lines(caplog: pytest.LogCaptureFixture) -> None:\n"
+        "    messages = [each_record.message for each_record in caplog.records]\n"
+        "    assert messages == []\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A reference inside a comprehension counts as a use, got: {issues}"
+    )
+
+
+def test_should_not_flag_unused_fixture_in_decorated_test_named_function() -> None:
+    source = (
+        "import pytest\n"
+        "from pathlib import Path\n"
+        "@pytest.fixture\n"
+        "def test_board(tmp_path: Path) -> int:\n"
+        "    return 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A @pytest.fixture-decorated function named test_* is a fixture, not a "
+        f"test, and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_fixture_param_on_nested_test_named_helper() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_outer(tmp_path: Path) -> None:\n"
+        "    assert tmp_path\n"
+        "    def test_inner(tmp_path) -> None:\n"
+        "        return None\n"
+        "    test_inner(tmp_path)\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture-named parameter on a function nested inside a test body is a "
+        f"local helper argument pytest never injects, got: {issues}"
+    )
+
+
+def test_should_count_augmented_assignment_as_fixture_reference() -> None:
+    source = "def test_aug(request) -> None:\n    request += 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"An augmented assignment to the fixture references it, got: {issues}"
+    )
+
+
+def test_should_count_del_as_fixture_reference() -> None:
+    source = "def test_d(tmp_path: Path) -> None:\n    del tmp_path\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A del of the fixture references it, got: {issues}"
+    )
+
+
+def test_should_flag_unused_fixture_parameter_on_class_method() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "class TestThing:\n"
+        "    def test_method(self, tmp_path: Path) -> None:\n"
+        "        assert 1 == 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"An unused fixture on a class-body test method must be flagged, got: {issues}"
+
+
+def test_should_flag_unused_fixture_parameter_on_nested_class_method() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "class TestOuter:\n"
+        "    class TestInner:\n"
+        "        def test_method(self, tmp_path: Path) -> None:\n"
+        "            assert 1 == 1\n"
+    )
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"An unused fixture on a nested-class test method must be flagged, got: {issues}"
+
+
+def test_should_flag_fixture_when_body_only_plain_assigns_it() -> None:
+    source = "def test_x(tmp_path: Path) -> None:\n    tmp_path = 1\n"
+    issues = code_rules_enforcer.check_unused_known_pytest_fixture_parameters(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue for each_issue in issues
+    ), f"A plain Store target is not a reference, so tmp_path is unused, got: {issues}"
+
+
+def test_annotation_check_skips_fixture_param_on_function_nested_in_test() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_outer(tmp_path: Path) -> None:\n"
+        "    def inner(tmp_path) -> None:\n"
+        "        return None\n"
+        "    inner(tmp_path)\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A fixture-named param on a function nested in a test body is not an "
+        f"injection site, and the correctly annotated outer param is fine, "
+        f"got: {issues}"
+    )
+
+

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -77,6 +77,7 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
         "check_return_annotations",
         "check_skip_decorators_in_tests",
         "check_string_literal_magic",
+        "check_unused_known_pytest_fixture_parameters",
         "check_unused_optional_parameters",
     }
 )

package/hooks/blocking/test_code_rules_enforcer_dispatch_wiring.py

@@ -0,0 +1,82 @@
+"""Meta-test asserting every check_* function is dispatched from validate_content.
+
+The per-check test modules each prove one ``check_*`` function flags the right
+violation, but none proves the enforcer actually calls that function. A refactor
+that drops a dispatch line from ``validate_content`` leaves every per-check test
+green while the check stops firing at Write/Edit time — the precise failure mode
+that would let a dead module-level constant (the ``MEDIUM_TEXT`` class) or an
+orphan CSS class slip past the gate again.
+
+This module reads ``validate_content``'s source and asserts every ``check_*``
+attribute on the enforcer module appears in it. A check that is intentionally
+not wired must be listed in ``KNOWN_UNDISPATCHED_CHECKS`` with a reason in this
+docstring; no such checks exist today. The companion ``test_code_rules_enforcer_
+cap_meta.py`` guards the payload-cap convention; this module guards the wiring.
+"""
+
+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_specification = importlib.util.spec_from_file_location(
+    "code_rules_enforcer",
+    _HOOK_DIRECTORY / "code_rules_enforcer.py",
+)
+assert _hook_specification is not None
+assert _hook_specification.loader is not None
+_hook_module = importlib.util.module_from_spec(_hook_specification)
+_hook_specification.loader.exec_module(_hook_module)
+
+KNOWN_UNDISPATCHED_CHECKS: frozenset[str] = frozenset()
+
+
+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 _validate_content_source() -> str:
+    return inspect.getsource(_hook_module.validate_content)
+
+
+def test_every_check_function_is_called_in_validate_content() -> None:
+    all_check_names = set(_all_check_function_names())
+    validate_content_source = _validate_content_source()
+    undispatched_check_names = {
+        each_name for each_name in all_check_names if each_name not in validate_content_source
+    }
+    unexpected_undispatched = undispatched_check_names - KNOWN_UNDISPATCHED_CHECKS
+    assert unexpected_undispatched == set(), (
+        f"check_* functions are imported but never called in validate_content: "
+        f"{sorted(unexpected_undispatched)}. Wire each into validate_content so the "
+        f"check fires at Write/Edit time, or list it in KNOWN_UNDISPATCHED_CHECKS "
+        f"with a reason in the test header docstring."
+    )
+
+
+def test_dead_module_constant_check_stays_wired() -> None:
+    validate_content_source = _validate_content_source()
+    assert "check_dead_module_constants" in validate_content_source, (
+        "check_dead_module_constants must stay dispatched from validate_content so a "
+        "dead exported constant (the MEDIUM_TEXT class) is blocked at Write/Edit time."
+    )
+
+
+def test_known_undispatched_set_lists_only_existing_checks() -> None:
+    all_check_names = set(_all_check_function_names())
+    stale_names = KNOWN_UNDISPATCHED_CHECKS - all_check_names
+    assert stale_names == set(), (
+        f"KNOWN_UNDISPATCHED_CHECKS lists functions that no longer exist: "
+        f"{sorted(stale_names)}. Restore the function or remove it from the set."
+    )

package/hooks/blocking/test_code_rules_enforcer_orphan_css_class.py

@@ -0,0 +1,196 @@
+"""Unit tests for the orphan-CSS-class check in code_rules_enforcer hook."""
+
+import importlib.util
+import pathlib
+import sys
+import tempfile
+import textwrap
+from collections.abc import Iterator
+from pathlib import Path
+
+import pytest
+
+_HOOK_DIR = pathlib.Path(__file__).parent
+if str(_HOOK_DIR) not in sys.path:
+    sys.path.insert(0, str(_HOOK_DIR))
+
+hook_spec = importlib.util.spec_from_file_location(
+    "code_rules_orphan_css_class",
+    _HOOK_DIR / "code_rules_orphan_css_class.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)
+check_orphan_css_classes = hook_module.check_orphan_css_classes
+
+PRODUCTION_FILE_PATH = "packages/app/render/report.py"
+TEST_FILE_PATH = "packages/app/render/test_report.py"
+
+MARKUP_WITH_ORPHAN = (
+    "def render() -> str:\n"
+    '    style = "<style>.card { color: red; }</style>"\n'
+    '    body = \'<div class="card">x</div><div class="ghost">y</div>\'\n'
+    "    return style + body\n"
+)
+
+MARKUP_ALL_DEFINED = (
+    "def render() -> str:\n"
+    '    style = "<style>.card { color: red; } .row { margin: 0; }</style>"\n'
+    '    body = \'<div class="card"><span class="row">x</span></div>\'\n'
+    "    return style + body\n"
+)
+
+
+def test_should_flag_class_with_no_matching_selector() -> None:
+    issues = check_orphan_css_classes(MARKUP_WITH_ORPHAN, PRODUCTION_FILE_PATH)
+    assert any("'ghost'" in each_issue for each_issue in issues), (
+        f"Expected 'ghost' flagged as orphan, got: {issues}"
+    )
+
+
+def test_should_not_flag_class_with_matching_selector() -> None:
+    issues = check_orphan_css_classes(MARKUP_WITH_ORPHAN, PRODUCTION_FILE_PATH)
+    assert not any("'card'" in each_issue for each_issue in issues), (
+        f"'card' has a .card selector and must not flag, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_every_class_is_defined() -> None:
+    issues = check_orphan_css_classes(MARKUP_ALL_DEFINED, PRODUCTION_FILE_PATH)
+    assert issues == [], f"Every class is defined; expected no issues, got: {issues}"
+
+
+def test_should_flag_each_class_in_a_multi_class_attribute() -> None:
+    content = (
+        "def render() -> str:\n"
+        '    style = "<style>.pf { padding: 0; }</style>"\n'
+        "    body = '<div class=\"pf problem\">x</div>'\n"
+        "    return style + body\n"
+    )
+    issues = check_orphan_css_classes(content, PRODUCTION_FILE_PATH)
+    assert any("'problem'" in each_issue for each_issue in issues), (
+        f"Second class 'problem' in the attribute must flag, got: {issues}"
+    )
+    assert not any("'pf'" in each_issue for each_issue in issues), (
+        f"First class 'pf' has a selector and must not flag, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_no_style_block_present() -> None:
+    content = "def render() -> str:\n    return '<div class=\"card\">x</div>'\n"
+    issues = check_orphan_css_classes(content, PRODUCTION_FILE_PATH)
+    assert issues == [], (
+        f"No <style> source nearby; the stylesheet lives outside the scan, got: {issues}"
+    )
+
+
+def test_should_not_flag_when_no_class_attribute_present() -> None:
+    content = (
+        'def render() -> str:\n    return "<style>.card { color: red; }</style><div>x</div>"\n'
+    )
+    issues = check_orphan_css_classes(content, PRODUCTION_FILE_PATH)
+    assert issues == [], f"No class attribute in markup; got: {issues}"
+
+
+def test_should_skip_test_files() -> None:
+    issues = check_orphan_css_classes(MARKUP_WITH_ORPHAN, TEST_FILE_PATH)
+    assert issues == [], f"Test files are exempt; got: {issues}"
+
+
+def test_should_include_line_number_and_class_name() -> None:
+    issues = check_orphan_css_classes(MARKUP_WITH_ORPHAN, PRODUCTION_FILE_PATH)
+    orphan_issue = next(each for each in issues if "'ghost'" in each)
+    assert "Line 3" in orphan_issue, (
+        f"Orphan 'ghost' sits on line 3 of the markup; got: {orphan_issue}"
+    )
+
+
+def test_should_report_each_orphan_class_once() -> None:
+    content = (
+        "def render() -> str:\n"
+        '    style = "<style>.card { color: red; }</style>"\n'
+        "    a = '<div class=\"ghost\">x</div>'\n"
+        "    b = '<div class=\"ghost\">y</div>'\n"
+        "    return style + a + b\n"
+    )
+    issues = check_orphan_css_classes(content, PRODUCTION_FILE_PATH)
+    ghost_issues = [each for each in issues if "'ghost'" in each]
+    assert len(ghost_issues) == 1, f"A repeated orphan class reports once; got: {ghost_issues}"
+
+
+def test_should_handle_syntax_error_gracefully() -> None:
+    content = "def broken(\n    this is not python\n"
+    issues = check_orphan_css_classes(content, PRODUCTION_FILE_PATH)
+    assert issues == [], f"A syntax error yields no issues; got: {issues}"
+
+
+_SIBLING_MARKUP_SOURCE = textwrap.dedent(
+    """\
+    from report_constants import HTML_STYLE_BLOCK
+
+
+    def render() -> str:
+        body = (
+            '<details class="appendix">'
+            '<div class="appendix-body">x</div></details>'
+        )
+        return HTML_STYLE_BLOCK + body
+    """
+)
+
+
+@pytest.fixture
+def production_render_package() -> Iterator[Path]:
+    """Yield a neutrally named package directory for the markup and constants modules.
+
+    pytest's ``tmp_path`` carries the test function name, so any path under it
+    holds a ``test_`` segment that the enforcer's ``is_test_file`` predicate
+    matches and exempts. A package created under the default ``tempfile`` prefix
+    keeps that segment out of the path, so the cross-module orphan-class check
+    runs against the markup module as production code.
+
+    Yields:
+        A freshly created package directory, removed when the test finishes.
+    """
+    with tempfile.TemporaryDirectory() as base_directory:
+        package_directory = Path(base_directory) / "render"
+        package_directory.mkdir()
+        yield package_directory
+
+
+def test_should_resolve_selectors_from_a_sibling_module(
+    production_render_package: Path,
+) -> None:
+    constants_module = production_render_package / "report_constants.py"
+    constants_module.write_text(
+        'HTML_STYLE_BLOCK = "<style>.appendix { margin: 0; }'
+        ' .appendix-body { padding: 0; }</style>"\n',
+        encoding="utf-8",
+    )
+    markup_module = production_render_package / "report.py"
+    markup_module.write_text(_SIBLING_MARKUP_SOURCE, encoding="utf-8")
+    issues = check_orphan_css_classes(_SIBLING_MARKUP_SOURCE, str(markup_module))
+    assert issues == [], (
+        f"A sibling module defines every selector; expected no issues, got: {issues}"
+    )
+
+
+def test_should_flag_orphan_even_when_a_sibling_defines_other_selectors(
+    production_render_package: Path,
+) -> None:
+    constants_module = production_render_package / "report_constants.py"
+    constants_module.write_text(
+        'HTML_STYLE_BLOCK = "<style>.appendix { margin: 0; }</style>"\n',
+        encoding="utf-8",
+    )
+    markup_module = production_render_package / "report.py"
+    markup_module.write_text(_SIBLING_MARKUP_SOURCE, encoding="utf-8")
+    issues = check_orphan_css_classes(_SIBLING_MARKUP_SOURCE, str(markup_module))
+    assert any("'appendix-body'" in each_issue for each_issue in issues), (
+        f"'appendix-body' has no selector in any sibling; must flag, got: {issues}"
+    )
+    assert not any(
+        "'appendix'" in each_issue and "appendix-body" not in each_issue
+        for each_issue in issues
+    ), f"'appendix' is defined in the sibling and must not flag, got: {issues}"