claude-dev-env 2.18.0 → 2.20.0

package/hooks/blocking/test_code_rules_enforcer_zero_payload_alias_hook_routing.py

@@ -14,16 +14,12 @@ the target path the same way it would for the real directory.
 
 from __future__ import annotations
 
-import contextlib
-import io
 import json
 import pathlib
 import shutil
-import subprocess
 import sys
 import tempfile
 from collections.abc import Iterator
-from types import SimpleNamespace
 
 import pytest
 
@@ -35,10 +31,10 @@ if str(_HOOKS_PARENT) not in sys.path:
     sys.path.insert(0, str(_HOOKS_PARENT))
 
 from code_rules_enforcer import main  # noqa: E402
-
-code_rules_enforcer = SimpleNamespace(main=main, sys=sys)
-
-_ENFORCER_SCRIPT_PATH = _HOOK_DIRECTORY / "code_rules_enforcer.py"
+from code_rules_enforcer_test_support import (  # noqa: E402
+    run_precheck,
+    run_write_entrypoint,
+)
 
 PASS_THROUGH_ALIAS_SOURCE = (
     "def find_bare_path_segments(content: str) -> set[str]:\n"
@@ -62,39 +58,8 @@ def hook_blocking_dir() -> Iterator[pathlib.Path]:
         shutil.rmtree(base_directory, ignore_errors=False)
 
 
-def _run_main_with_write_payload(
-    file_path: str,
-    content: str,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> str:
-    """Drive ``main()`` through its stdin entry point for a Write and return stdout.
-
-    Args:
-        file_path: The on-disk path the Write targets.
-        content: The whole-file body the Write would create.
-        monkeypatch: The fixture used to redirect ``sys.stdin``.
-        capsys: The fixture used to capture the deny payload on stdout.
-
-    Returns:
-        The captured stdout, which holds the deny payload when violations fire.
-    """
-    write_payload = json.dumps(
-        {
-            "tool_name": "Write",
-            "tool_input": {"file_path": file_path, "content": content},
-        }
-    )
-    monkeypatch.setattr(code_rules_enforcer.sys, "stdin", io.StringIO(write_payload))
-    with contextlib.suppress(SystemExit):
-        code_rules_enforcer.main([])
-    return capsys.readouterr().out
-
-
 def test_write_of_pass_through_alias_into_hook_directory_denies(
     hook_blocking_dir: pathlib.Path,
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
 ) -> None:
     """A Write that introduces a pass-through alias into a hook file is denied.
 
@@ -103,14 +68,16 @@ def test_write_of_pass_through_alias_into_hook_directory_denies(
     directory its docstring names as the motivating case — at the PreToolUse Write
     point, not only through ``validate_content``."""
     new_file = hook_blocking_dir / "new_blocker.py"
-    stdout = _run_main_with_write_payload(
-        str(new_file), PASS_THROUGH_ALIAS_SOURCE, monkeypatch, capsys
+    captured_stdout, _exit_code = run_write_entrypoint(
+        main,
+        str(new_file),
+        PASS_THROUGH_ALIAS_SOURCE,
     )
-    assert stdout != "", (
+    assert captured_stdout != "", (
         "A pass-through alias written into a hook-infrastructure file must produce "
         "a deny payload, got empty stdout"
     )
-    deny_payload = json.loads(stdout)
+    deny_payload = json.loads(captured_stdout)
     decision = deny_payload["hookSpecificOutput"]["permissionDecision"]
     reason = deny_payload["hookSpecificOutput"]["permissionDecisionReason"]
     assert decision == "deny", f"expected deny, got: {decision!r}"
@@ -121,31 +88,18 @@ def test_write_of_pass_through_alias_into_hook_directory_denies(
 
 def test_precheck_of_pass_through_alias_at_hook_target_exits_nonzero(
     hook_blocking_dir: pathlib.Path,
-    tmp_path_factory: pytest.TempPathFactory,
+    tmp_path: pathlib.Path,
 ) -> None:
     """The pre-check CLI flags a pass-through alias judged at a hook-infrastructure target.
 
     Driving the real ``--check`` argv path proves the gate's pre-check mode also
     routes a hook ``.py`` target through the zero-payload-alias check rather than
     exiting clean on the blanket hook-infrastructure exemption."""
-    staging_directory = tmp_path_factory.mktemp("staging")
+    staging_directory = tmp_path
     candidate_file = staging_directory / "candidate.py"
     candidate_file.write_text(PASS_THROUGH_ALIAS_SOURCE, encoding="utf-8")
     target_path = str(hook_blocking_dir / "new_blocker.py")
-    completed = subprocess.run(
-        [
-            sys.executable,
-            str(_ENFORCER_SCRIPT_PATH),
-            "--check",
-            str(candidate_file),
-            "--as",
-            target_path,
-        ],
-        input="",
-        capture_output=True,
-        text=True,
-        check=False,
-    )
+    completed = run_precheck(candidate_file, target_path, None)
     assert completed.returncode == 1, (
         "a pass-through alias at a hook target must exit nonzero, got: "
         f"{completed.returncode}, stdout: {completed.stdout!r}, "