claude-dev-env 1.58.0 → 1.60.0

package/hooks/blocking/test_code_rules_enforcer_annotations.py

@@ -95,3 +95,228 @@ def test_should_skip_return_check_in_test_files() -> None:
     assert issues == [], f"Test files must be exempt, got: {issues}"
 
 
+def test_should_flag_unannotated_known_fixture_in_test_file() -> None:
+    source = "def test_board(tmp_path):\n    assert tmp_path.exists()\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected unannotated tmp_path fixture flagged, got: {issues}"
+
+
+def test_should_not_flag_annotated_known_fixture_in_test_file() -> None:
+    source = (
+        "from pathlib import Path\n"
+        "def test_board(tmp_path: Path) -> None:\n"
+        "    assert tmp_path.exists()\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], f"Annotated tmp_path must not be flagged, got: {issues}"
+
+
+def test_should_not_flag_ordinary_test_parameter() -> None:
+    source = "def test_thing(some_value):\n    assert some_value\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Ordinary test params stay exempt; only known fixtures are checked, "
+        f"got: {issues}"
+    )
+
+
+def test_should_not_flag_known_fixture_name_outside_test_files() -> None:
+    source = "def build(monkeypatch):\n    return monkeypatch\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, PRODUCTION_FILE_PATH
+    )
+    assert issues == [], (
+        f"Non-test files are covered by the broad parameter check, not this one, "
+        f"got: {issues}"
+    )
+
+
+def test_should_flag_unannotated_monkeypatch_fixture() -> None:
+    source = "def test_env(monkeypatch):\n    monkeypatch.setenv('A', 'B')\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "monkeypatch" in each_issue and "MonkeyPatch" in each_issue
+        for each_issue in issues
+    ), f"Expected unannotated monkeypatch fixture flagged, got: {issues}"
+
+
+def test_should_not_flag_known_fixture_in_non_test_helper() -> None:
+    source = "def render_view(request):\n    return request.path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Ordinary helper (non-test, non-fixture) must not be flagged, got: {issues}"
+    )
+
+
+def test_should_flag_unannotated_fixture_in_decorated_fixture() -> None:
+    source = (
+        "import pytest\n"
+        "@pytest.fixture\n"
+        "def board(tmp_path):\n"
+        "    return tmp_path\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected unannotated tmp_path in @pytest.fixture-decorated function flagged, got: {issues}"
+
+
+def test_should_flag_known_fixture_with_wrong_annotation() -> None:
+    source = "def test_board(tmp_path: str):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected wrongly annotated tmp_path: str flagged, got: {issues}"
+
+
+def test_should_flag_known_fixture_with_unrelated_annotation() -> None:
+    source = "def test_board(tmp_path: int):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"Expected wrongly annotated tmp_path: int flagged, got: {issues}"
+
+
+def test_should_not_flag_correctly_annotated_qualified_fixture() -> None:
+    source = (
+        "import pytest\n"
+        "def test_env(monkeypatch: pytest.MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"Correctly annotated monkeypatch must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_dotted_pathlib_path_fixture_annotation() -> None:
+    source = (
+        "import pathlib\n"
+        "def test_board(tmp_path: pathlib.Path) -> None:\n"
+        "    assert tmp_path.exists()\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"tmp_path: pathlib.Path is an equally-correct spelling, got: {issues}"
+    )
+
+
+def test_should_not_flag_bare_tail_of_qualified_fixture_annotation() -> None:
+    source = (
+        "from pytest import MonkeyPatch\n"
+        "def test_env(monkeypatch: MonkeyPatch) -> None:\n"
+        "    monkeypatch.setenv('A', 'B')\n"
+    )
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"monkeypatch: MonkeyPatch matches the qualified expected tail, got: {issues}"
+    )
+
+
+def test_should_not_flag_forward_reference_fixture_annotation() -> None:
+    source = 'def test_board(tmp_path: "Path") -> None:\n    assert tmp_path\n'
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f'A forward-ref "Path" annotation must not be flagged, got: {issues}'
+    )
+
+
+def test_should_not_flag_star_arg_fixture_name() -> None:
+    source = "def test_board(*tmp_path):\n    assert tmp_path\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A *vararg sharing a fixture name is not an injection site, got: {issues}"
+    )
+
+
+def test_should_not_flag_double_star_arg_fixture_name() -> None:
+    source = "def test_env(**monkeypatch):\n    assert monkeypatch\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A **kwarg sharing a fixture name is not an injection site, got: {issues}"
+    )
+
+
+def test_should_not_flag_positional_only_fixture_name() -> None:
+    source = "def test_board(tmp_path, /):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A positional-only param cannot receive a keyword-injected fixture, got: {issues}"
+    )
+
+
+def test_should_flag_keyword_only_fixture_name() -> None:
+    source = "def test_board(*, tmp_path):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"A keyword-only fixture is still an injection site, got: {issues}"
+
+
+def test_should_not_flag_defaulted_fixture_name() -> None:
+    source = "def test_board(tmp_path=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A defaulted param is not fixture-injected and must not be flagged, got: {issues}"
+    )
+
+
+def test_should_not_flag_defaulted_keyword_only_fixture_name() -> None:
+    source = "def test_board(*, tmp_path=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert issues == [], (
+        f"A defaulted keyword-only param is not fixture-injected, got: {issues}"
+    )
+
+
+def test_should_flag_undefaulted_fixture_before_defaulted_one() -> None:
+    source = "def test_board(tmp_path, capsys=None):\n    pass\n"
+    issues = code_rules_enforcer.check_known_pytest_fixture_annotations(
+        source, TEST_FILE_PATH
+    )
+    assert any(
+        "tmp_path" in each_issue and "Path" in each_issue for each_issue in issues
+    ), f"An undefaulted leading fixture stays an injection site, got: {issues}"
+    assert not any("capsys" in each_issue for each_issue in issues), (
+        f"The trailing defaulted param must not be flagged, got: {issues}"
+    )
+
+

package/hooks/blocking/test_code_rules_enforcer_cap_meta.py

@@ -70,6 +70,7 @@ KNOWN_UNCAPPED_CHECKS_PENDING_REVIEW: frozenset[str] = frozenset(
         "check_file_global_constants_use_count",
         "check_imports_at_top",
         "check_inline_literal_collections",
+        "check_known_pytest_fixture_annotations",
         "check_library_print",
         "check_loop_variable_naming",
         "check_parameter_annotations",

package/hooks/blocking/test_code_rules_enforcer_cross_skill_duplicate.py

@@ -0,0 +1,146 @@
+"""Tests for the cross-skill duplicate-helper advisory.
+
+PR #233 on JonEcho/python-automation copied a Chrome-launch helper from the
+``stp-recolor`` skill's ``scripts`` directory into the ``iconize-and-recolor-stp``
+skill's ``scripts`` directory. The two skills install on their own, so a shared
+module would couple them and break independent install; the copy is a defensible
+skill-isolation tradeoff. ``advise_cross_skill_duplicate_helper`` surfaces that
+copy as a non-blocking ``[CODE_RULES advisory]`` on stderr so a reviewer confirms
+the copy was intentional, without denying the write.
+
+The tests build a real ``skills/<name>/scripts`` layout on disk and run the
+advisory against it, so they exercise the on-disk cross-skill scan rather than a
+stubbed view of the filesystem.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import pathlib
+import shutil
+import sys
+import tempfile
+from collections.abc import Iterator
+
+import pytest
+
+_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_duplicate_body",
+    _HOOK_DIRECTORY / "code_rules_duplicate_body.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)
+advise_cross_skill_duplicate_helper = _hook_module.advise_cross_skill_duplicate_helper
+
+
+CHROME_HELPER_SOURCE = (
+    "import winreg\n"
+    "from pathlib import Path\n"
+    "\n"
+    "chrome_app_paths_key = r'SOFTWARE\\Microsoft\\App Paths\\chrome.exe'\n"
+    "chrome_fallback_paths = ('C:/chrome.exe',)\n"
+    "\n"
+    "def _chrome_executable() -> Path | None:\n"
+    "    for each_root in (winreg.HKEY_CURRENT_USER, winreg.HKEY_LOCAL_MACHINE):\n"
+    "        try:\n"
+    "            registered = winreg.QueryValue(each_root, chrome_app_paths_key)\n"
+    "        except OSError:\n"
+    "            continue\n"
+    "        registered_path = Path(registered)\n"
+    "        if registered_path.exists():\n"
+    "            return registered_path\n"
+    "    for each_fallback in chrome_fallback_paths:\n"
+    "        fallback_path = Path(each_fallback)\n"
+    "        if fallback_path.exists():\n"
+    "            return fallback_path\n"
+    "    return None\n"
+)
+
+
+@pytest.fixture
+def skills_root() -> Iterator[pathlib.Path]:
+    base_directory = pathlib.Path(tempfile.mkdtemp())
+    skills_directory = base_directory / "skills"
+    skills_directory.mkdir()
+    try:
+        yield skills_directory
+    finally:
+        shutil.rmtree(base_directory, ignore_errors=False)
+
+
+def _make_skill_scripts(skills_directory: pathlib.Path, skill_name: str) -> pathlib.Path:
+    scripts_directory = skills_directory / skill_name / "scripts"
+    scripts_directory.mkdir(parents=True)
+    return scripts_directory
+
+
+def test_advises_when_helper_copied_from_another_skill(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    target_scripts = _make_skill_scripts(skills_root, "iconize-and-recolor-stp")
+    target_file = target_scripts / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    captured = capsys.readouterr()
+    assert "[CODE_RULES advisory]" in captured.err, (
+        f"Expected a cross-skill advisory on stderr, got: {captured.err!r}"
+    )
+    assert "_chrome_executable" in captured.err, (
+        f"Expected the duplicated function named, got: {captured.err!r}"
+    )
+    assert "stp-recolor" in captured.err, f"Expected the source skill named, got: {captured.err!r}"
+
+
+def test_advisory_does_not_block(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    target_scripts = _make_skill_scripts(skills_root, "iconize-and-recolor-stp")
+    target_file = target_scripts / "combine_report.py"
+
+    returned = advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    assert returned is None, "The advisory returns nothing so it never enters the deny path"
+
+
+def test_no_advisory_within_one_skill(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    scripts_directory = _make_skill_scripts(skills_root, "stp-recolor")
+    (scripts_directory / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    sibling_file = scripts_directory / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(sibling_file))
+
+    captured = capsys.readouterr()
+    assert captured.err == "", (
+        "Within one skill the blocking gate covers the copy; the cross-skill "
+        f"advisory must stay silent, got: {captured.err!r}"
+    )
+
+
+def test_no_advisory_outside_a_skill_scripts_directory(
+    skills_root: pathlib.Path, capsys: pytest.CaptureFixture[str]
+) -> None:
+    source_scripts = _make_skill_scripts(skills_root, "stp-recolor")
+    (source_scripts / "palette_board.py").write_text(CHROME_HELPER_SOURCE, encoding="utf-8")
+    non_skill_directory = skills_root.parent / "elsewhere"
+    non_skill_directory.mkdir()
+    target_file = non_skill_directory / "combine_report.py"
+
+    advise_cross_skill_duplicate_helper(CHROME_HELPER_SOURCE, str(target_file))
+
+    captured = capsys.readouterr()
+    assert captured.err == "", (
+        f"A file outside a skill scripts directory draws no advisory, got: {captured.err!r}"
+    )