지금은 지켜야 할 규칙이 모두 문서에만 있다. 포맷·레이어 위반·문서 검사 실패는 desktop 게이트에서야 보이고, 이미 적용된 migration을 고쳐도 desktop의 AppliedMigrationImmutabilityTest가 돌 때까지 아무도 모른다. 소유자가 2026-11-07에 편집 훅이 그 파일 하나만 Gradle 없이 포맷·린트하고, 전체 검사는 턴 끝 넛지로, 되돌릴 수 없는 것만 막기로 정했다 (design-docs harness/01-harness-design.md 5절, 13절 Q6·Q7). scripts/hooks/hooks.py 하나에 이벤트 넷(표준 라이브러리만): - pre-edit H13: 편집 대상이 applied-migrations.sha256에 있는 migration이면 종료 코드 2로 막고 새 버전 파일을 더하라고 안내한다. - post-edit 포맷: src/**/*.java 한 파일을 google-java-format으로 맞춘다. 버전은 카탈로그 googleJavaFormat, jar는 Gradle 캐시에 이미 있는 것만 쓰고(받거나 설치하지 않음), 옵션은 Spotless 단계와 같게 --skip-reflowing-long-strings --replace. 이 옵션으로 Spotless 대상 파일 전부를 dry-run 하면 차이가 0이었다(차이는 Spotless를 쓰지 않는 build-logic뿐이라 훅도 제외한다). 파일이 바뀌면 다시 읽으라고 알린다. - post-edit N1: registry로 leaf를 찾고 import를 순수성 목록 (DomainPurityArchitectureTest, verifyApplicationCoreDependencyPurity와 같은 패키지)과 allowed_dependencies 전이 closure에 대 본다. - post-edit N2: 문서 편집 뒤 check-work-docs·check-docs의 실패 줄. - post-bash·stop N5: Java를 고친 뒤 ssh desktop gradlew 실행이 없으면 턴 끝을 한 번 막고 desktop 검증이나 못 돌린 이유를 쓰라고 한다. - 권한: 실제 .env·.env.local·.env.lane 읽기·쓰기 deny(예시 파일은 둠). 버린 대안: 편집 훅에서 검사 안 하기(설계 권함, 소유자가 자료 쪽으로 정함), 편집마다 desktop 원격 실행(왕복 비용), checkstyle 한 파일 (Gradle 없이 classpath를 맞출 수 없다. 린트는 N1이 맡는다). 위험: 이 세션에서 settings.json을 바꿔도 훅은 돌지 않았다. 훅은 세션이 시작할 때 읽힌다. 그래서 settings.json이 부르는 명령에 같은 입력을 넣어 확인했다. N1은 게이트의 일부만 본다. 정본은 architectureCheck다. 검증: python3 -m unittest discover -s scripts/tests rc=0(훅 시험 29, 그중 실제 포매터 시험은 이 노트북 캐시의 1.35.0 jar로 돌았다). 변이 시험: 조건 10개를 하나씩 끈 사본마다 시험이 1~2건 실패했다. 실제 운영 소스 3,230개에 N1을 돌려 걸림 0. 편집 한 번 훅 시간 Java 0.3초, 문서 1.2초. check-docs·check-work-docs·check-repo-layout rc=0. BREAKING CHANGE: 파생 서비스에도 같은 훅과 .env deny가 걸린다. docs/upgrade/2026-11-harness.md 2절 4행.
401 lines
21 KiB
Python
401 lines
21 KiB
Python
"""scripts/hooks/hooks.py의 시험. 고장 낸 입력에서 알림·차단이 나오고, 맞는 입력에서 조용한지 본다.
|
|
|
|
python3 -m unittest discover -s scripts/tests
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import importlib.util
|
|
import io
|
|
import json
|
|
import os
|
|
import stat
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import textwrap
|
|
import unittest
|
|
from contextlib import redirect_stderr, redirect_stdout
|
|
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
SCRIPTS = Path(__file__).resolve().parent.parent
|
|
REPO = SCRIPTS.parent
|
|
_spec = importlib.util.spec_from_file_location("hooks", SCRIPTS / "hooks/hooks.py")
|
|
hooks = importlib.util.module_from_spec(_spec)
|
|
sys.modules["hooks"] = hooks
|
|
_spec.loader.exec_module(hooks)
|
|
|
|
REGISTRY = {"modules": [
|
|
{"id": "domain-core", "gradle_path": ":domain-core", "source_path": "src/domain-core", "allowed_dependencies": []},
|
|
{"id": "shared-contract", "gradle_path": ":shared-contract", "source_path": "src/shared-contract",
|
|
"allowed_dependencies": []},
|
|
{"id": "application-core", "gradle_path": ":application-core", "source_path": "src/application-core",
|
|
"allowed_dependencies": ["domain-core", "shared-contract"]},
|
|
{"id": "adapter-inbound-web", "gradle_path": ":adapter:inbound:web", "source_path": "src/adapter/inbound/web",
|
|
"allowed_dependencies": ["application-core"]},
|
|
{"id": "adapter-outbound-persistence-jpa", "gradle_path": ":adapter:outbound:persistence-jpa",
|
|
"source_path": "src/adapter/outbound/persistence-jpa", "allowed_dependencies": ["application-core"]},
|
|
]}
|
|
PACKAGES = {
|
|
"src/domain-core": "dev/caskeleton/domain/order/Order.java",
|
|
"src/shared-contract": "dev/caskeleton/shared/error/ApiErrorCode.java",
|
|
"src/application-core": "dev/caskeleton/application/order/PlaceOrderUseCase.java",
|
|
"src/adapter/inbound/web": "dev/caskeleton/adapter/inbound/web/order/OrderRequest.java",
|
|
"src/adapter/outbound/persistence-jpa": "dev/caskeleton/adapter/outbound/persistence/order/OrderEntity.java",
|
|
}
|
|
|
|
|
|
class Repository:
|
|
"""A throwaway project with a registry, one class per leaf and the migration manifest."""
|
|
|
|
def __init__(self) -> None:
|
|
self._directory = tempfile.TemporaryDirectory()
|
|
self.root = Path(self._directory.name).resolve()
|
|
self.write(hooks.REGISTRY, json.dumps(REGISTRY))
|
|
for leaf, source in PACKAGES.items():
|
|
package = Path(source).parent.as_posix().replace("/", ".")
|
|
self.write(f"{leaf}/src/main/java/{source}", f"package {package};\n\nclass {Path(source).stem} {{}}\n")
|
|
self.write(hooks.MIGRATION_MANIFEST,
|
|
"# comment line\n" + "a" * 64 + " jpa/core/V1__initialize_or_adopt.sql\n")
|
|
self.write(hooks.CATALOG, 'googleJavaFormat = "1.35.0"\n')
|
|
|
|
def write(self, path: str, text: str) -> Path:
|
|
target = self.root / path
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
target.write_text(text, encoding="utf-8")
|
|
return target
|
|
|
|
def payload(self, path: str, tool: str = "Edit", **extra) -> dict:
|
|
return {"session_id": "s1", "cwd": str(self.root), "tool_name": tool,
|
|
"tool_input": {"file_path": str(self.root / path)}, **extra}
|
|
|
|
def close(self) -> None:
|
|
self._directory.cleanup()
|
|
|
|
|
|
def run_event(event: str, payload: dict, environment: dict | None = None) -> tuple[int, str, str]:
|
|
out, err = io.StringIO(), io.StringIO()
|
|
with mock.patch.dict(os.environ, environment or {}, clear=False), \
|
|
mock.patch.object(sys, "stdin", io.StringIO(json.dumps(payload))), redirect_stdout(out), redirect_stderr(err):
|
|
os.environ.pop("CLAUDE_PROJECT_DIR", None)
|
|
code = hooks.main([event])
|
|
return code, out.getvalue(), err.getvalue()
|
|
|
|
|
|
def fake_cache(home: Path, version: str = "1.35.0") -> Path:
|
|
"""A Gradle user home whose module cache holds the jars the formatter looks for."""
|
|
cache = home / "caches/modules-2/files-2.1"
|
|
for group, artifact_version in (("com.google.googlejavaformat/google-java-format", version),
|
|
("com.google.guava/guava", "33.6.0-jre"),
|
|
("com.google.guava/guava", "33.2.1-android"),
|
|
("com.google.guava/failureaccess", "1.0.3")):
|
|
artifact = group.rsplit("/", 1)[1]
|
|
jar = cache / group / artifact_version / "0123abcd" / f"{artifact}-{artifact_version}.jar"
|
|
jar.parent.mkdir(parents=True, exist_ok=True)
|
|
jar.write_bytes(b"jar")
|
|
return cache
|
|
|
|
|
|
def fake_java(folder: Path, body: str) -> str:
|
|
"""A `java` on PATH that records its arguments in args.json, then runs `body` (Python) on the file."""
|
|
folder.mkdir(parents=True, exist_ok=True)
|
|
script = folder / "java"
|
|
script.write_text(textwrap.dedent(f"""\
|
|
#!{sys.executable}
|
|
import json, sys
|
|
from pathlib import Path
|
|
Path({str(folder / 'args.json')!r}).write_text(json.dumps(sys.argv[1:]))
|
|
target = Path(sys.argv[-1])
|
|
{body}
|
|
"""), encoding="utf-8")
|
|
script.chmod(script.stat().st_mode | stat.S_IXUSR)
|
|
return f"{folder}{os.pathsep}{os.environ.get('PATH', '')}"
|
|
|
|
|
|
def added_context(stdout: str) -> str:
|
|
return json.loads(stdout)["hookSpecificOutput"]["additionalContext"] if stdout else ""
|
|
|
|
|
|
class RepositoryTestCase(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self.repo = Repository()
|
|
self.addCleanup(self.repo.close)
|
|
# The formatter is tested on its own; elsewhere a `java` that changes nothing keeps post-edit quiet.
|
|
self.cache = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.cache.cleanup)
|
|
home = Path(self.cache.name)
|
|
fake_cache(home)
|
|
self.environment = {"GRADLE_USER_HOME": str(home), "PATH": fake_java(home / "quiet-java", "pass")}
|
|
|
|
|
|
class MigrationGuardTest(RepositoryTestCase):
|
|
"""H13 — PreToolUse blocks an edit of an applied migration, and only that."""
|
|
|
|
MIGRATION = "src/adapter/outbound/persistence-jpa/src/main/resources/db/migration/jpa/core/V1__initialize_or_adopt.sql"
|
|
|
|
def test_editing_an_applied_migration_is_blocked_with_the_way_out(self) -> None:
|
|
self.repo.write(self.MIGRATION, "create table x();\n")
|
|
code, _, err = run_event("pre-edit", self.repo.payload(self.MIGRATION))
|
|
self.assertEqual(code, 2)
|
|
self.assertIn("[H13 적용된 migration 편집 금지]", err)
|
|
self.assertIn("새 버전 파일", err)
|
|
|
|
def test_a_migration_in_another_leaf_is_found_by_its_manifest_key(self) -> None:
|
|
path = "src/adapter/outbound/persistence-fileserver/src/main/resources/db/migration/jpa/core/V1__initialize_or_adopt.sql"
|
|
self.assertEqual(run_event("pre-edit", self.repo.payload(path, tool="Write"))[0], 2)
|
|
|
|
def test_a_new_migration_version_is_allowed(self) -> None:
|
|
path = self.MIGRATION.replace("V1__initialize_or_adopt", "V3__add_column")
|
|
self.assertEqual(run_event("pre-edit", self.repo.payload(path, tool="Write")), (0, "", ""))
|
|
|
|
def test_other_files_and_other_tools_are_allowed(self) -> None:
|
|
self.assertEqual(run_event("pre-edit", self.repo.payload("docs/x.md"))[0], 0)
|
|
self.assertEqual(run_event("pre-edit", self.repo.payload(self.MIGRATION, tool="Read"))[0], 0)
|
|
|
|
|
|
class FormatterTest(RepositoryTestCase):
|
|
"""The formatter runs one JVM on one file with the jar Gradle cached; it never downloads one."""
|
|
|
|
SOURCE = "src/domain-core/src/main/java/dev/caskeleton/domain/order/Order.java"
|
|
|
|
def fake_cache(self, version: str = "1.35.0") -> Path:
|
|
return fake_cache(Path(tempfile.mkdtemp(dir=self.cache.name)), version)
|
|
|
|
def fake_java(self, body: str) -> dict:
|
|
folder = Path(tempfile.mkdtemp(dir=self.cache.name))
|
|
self.args_file = folder / "args.json"
|
|
return {"PATH": fake_java(folder, body)}
|
|
|
|
def test_the_classpath_is_the_catalog_version_and_the_newest_jre_guava(self) -> None:
|
|
classpath, version = hooks.formatter_classpath(self.repo.root, self.fake_cache())
|
|
self.assertEqual(version, "1.35.0")
|
|
self.assertEqual([jar.name for jar in classpath],
|
|
["google-java-format-1.35.0.jar", "guava-33.6.0-jre.jar", "failureaccess-1.0.3.jar"])
|
|
|
|
def test_a_cache_without_the_catalog_version_skips_and_says_so(self) -> None:
|
|
lines = hooks.format_java(self.repo.root, self.SOURCE, self.fake_cache(version="1.28.0"))
|
|
self.assertEqual(len(lines), 1)
|
|
self.assertIn("google-java-format 1.35.0 jar가 Gradle 캐시", lines[0])
|
|
self.assertIn("받거나 설치하지 않는다", lines[0])
|
|
|
|
def test_the_formatter_gets_the_spotless_flags_and_the_one_file(self) -> None:
|
|
cache = self.fake_cache()
|
|
with mock.patch.dict(os.environ, self.fake_java("pass")):
|
|
self.assertEqual(hooks.format_java(self.repo.root, self.SOURCE, cache), [])
|
|
args = json.loads(self.args_file.read_text())
|
|
self.assertEqual(args[-3:], ["--skip-reflowing-long-strings", "--replace", str(self.repo.root / self.SOURCE)])
|
|
self.assertIn("com.google.googlejavaformat.java.Main", args)
|
|
|
|
def test_a_rewritten_file_tells_the_model_to_read_it_again(self) -> None:
|
|
cache = self.fake_cache()
|
|
with mock.patch.dict(os.environ, self.fake_java("target.write_text(target.read_text() + '\\n')")):
|
|
lines = hooks.format_java(self.repo.root, self.SOURCE, cache)
|
|
self.assertEqual(len(lines), 1)
|
|
self.assertIn("다시 읽는다", lines[0])
|
|
|
|
def test_a_formatter_error_is_reported_with_its_first_lines(self) -> None:
|
|
cache = self.fake_cache()
|
|
body = "sys.stderr.write('Order.java:3:1: error: class, interface, enum, or record expected\\n'); sys.exit(1)"
|
|
with mock.patch.dict(os.environ, self.fake_java(body)):
|
|
lines = hooks.format_java(self.repo.root, self.SOURCE, cache)
|
|
self.assertIn("읽지 못했다", lines[0])
|
|
self.assertIn("error: class, interface", lines[1])
|
|
|
|
def test_a_skipped_format_is_said_once_per_session(self) -> None:
|
|
environment = {"GRADLE_USER_HOME": str(Path(tempfile.mkdtemp(dir=self.cache.name)))}
|
|
first = added_context(run_event("post-edit", self.repo.payload(self.SOURCE), environment)[1])
|
|
second = run_event("post-edit", self.repo.payload(self.SOURCE), environment)[1]
|
|
self.assertIn("포맷을 건너뛰었다", first)
|
|
self.assertEqual(second, "")
|
|
|
|
def test_build_logic_and_non_java_files_are_not_formatted(self) -> None:
|
|
self.assertFalse(hooks.wants_format("src/build-logic/src/main/java/A.java"))
|
|
self.assertFalse(hooks.wants_format("src/app/build/generated/A.java"))
|
|
self.assertFalse(hooks.wants_format("docs/a.md"))
|
|
self.assertTrue(hooks.wants_format(self.SOURCE))
|
|
|
|
@unittest.skipUnless(hooks.formatter_classpath(REPO, hooks.gradle_cache())[0], "no google-java-format jar in the Gradle cache")
|
|
def test_the_real_formatter_matches_spotless_on_a_badly_indented_file(self) -> None:
|
|
# Only on a machine whose Gradle cache holds the catalog version (the owner's laptop).
|
|
self.repo.write(self.SOURCE, "package dev.caskeleton.domain.order;\nimport java.util.List;\n"
|
|
"class Order{ List<String> lines(){return List.of(\"a\");}}\n")
|
|
lines = hooks.format_java(self.repo.root, self.SOURCE, hooks.gradle_cache())
|
|
self.assertIn("다시 썼다", lines[0])
|
|
self.assertEqual((self.repo.root / self.SOURCE).read_text(), textwrap.dedent("""\
|
|
package dev.caskeleton.domain.order;
|
|
|
|
import java.util.List;
|
|
|
|
class Order {
|
|
List<String> lines() {
|
|
return List.of("a");
|
|
}
|
|
}
|
|
"""))
|
|
|
|
|
|
class BoundaryNudgeTest(RepositoryTestCase):
|
|
"""N1 — imports of one main source against the registry and the purity lists."""
|
|
|
|
def nudge(self, leaf: str, relative: str, imports: str) -> str:
|
|
package = Path(relative).parent.as_posix().replace("/", ".")
|
|
path = f"{leaf}/src/main/java/{relative}"
|
|
self.repo.write(path, f"package {package};\n\n{imports}\nclass {Path(relative).stem} {{}}\n")
|
|
code, out, _ = run_event("post-edit", self.repo.payload(path), self.environment)
|
|
self.assertEqual(code, 0)
|
|
return added_context(out)
|
|
|
|
def test_spring_in_the_domain_is_hard_stop_1(self) -> None:
|
|
text = self.nudge("src/domain-core", "dev/caskeleton/domain/order/Line.java",
|
|
"import org.springframework.stereotype.Component;")
|
|
self.assertIn("HARD-STOP 1 의심: `domain-core`가 `org.springframework.stereotype.Component`", text)
|
|
self.assertIn("architectureCheck", text)
|
|
|
|
def test_an_inbound_dto_in_the_application_is_hard_stop_3(self) -> None:
|
|
text = self.nudge("src/application-core", "dev/caskeleton/application/order/Place.java",
|
|
"import dev.caskeleton.adapter.inbound.web.order.OrderRequest;")
|
|
self.assertIn("HARD-STOP 3 의심: `dev.caskeleton.adapter.inbound.web.order.OrderRequest`는 leaf "
|
|
"`adapter-inbound-web`의 것인데 `application-core`", text)
|
|
|
|
def test_a_persistence_entity_in_a_controller_is_hard_stop_2(self) -> None:
|
|
text = self.nudge("src/adapter/inbound/web", "dev/caskeleton/adapter/inbound/web/order/OrderController.java",
|
|
"import dev.caskeleton.adapter.outbound.persistence.order.OrderEntity;\n"
|
|
"import org.springframework.data.repository.CrudRepository;")
|
|
self.assertIn("HARD-STOP 2 의심: `dev.caskeleton.adapter.outbound.persistence.order.OrderEntity`", text)
|
|
self.assertIn("HARD-STOP 2 의심: `adapter-inbound-web`가 `org.springframework.data.repository.CrudRepository`", text)
|
|
|
|
def test_a_transitive_registry_edge_nested_and_static_imports_pass(self) -> None:
|
|
text = self.nudge("src/adapter/inbound/web", "dev/caskeleton/adapter/inbound/web/order/OrderController.java",
|
|
"import dev.caskeleton.application.order.PlaceOrderUseCase;\n"
|
|
"import dev.caskeleton.domain.order.Order.Line;\n"
|
|
"import static dev.caskeleton.shared.error.ApiErrorCode.of;\n"
|
|
"import dev.caskeleton.domain.order.*;\n"
|
|
"import org.springframework.web.bind.annotation.RestController;")
|
|
self.assertEqual(text, "")
|
|
|
|
def test_test_sources_and_files_outside_any_leaf_are_not_checked(self) -> None:
|
|
path = "src/domain-core/src/test/java/dev/caskeleton/domain/order/OrderTest.java"
|
|
self.repo.write(path, "package dev.caskeleton.domain.order;\nimport org.springframework.util.Assert;\nclass OrderTest {}\n")
|
|
self.assertEqual(hooks.boundary_findings(self.repo.root, path, (self.repo.root / path).read_text()), [])
|
|
self.assertEqual(hooks.boundary_findings(self.repo.root, "src/other/src/main/java/A.java", "import org.springframework.X;"), [])
|
|
|
|
|
|
class DocumentNudgeTest(RepositoryTestCase):
|
|
"""N2 — a document edit runs the two document checks and passes on their failure lines."""
|
|
|
|
def checks(self, work_docs_failures: list[str], docs_failures: list[str]) -> None:
|
|
for name, failures in (("check-work-docs.py", work_docs_failures), ("check-docs.py", docs_failures)):
|
|
body = "import sys\n" + "".join(f"print({' ' + line!r}, file=sys.stderr)\n" for line in failures)
|
|
body += "sys.exit(1)\n" if failures else ""
|
|
self.repo.write(f"scripts/{name}", body)
|
|
|
|
def test_failures_naming_the_edited_document_come_back(self) -> None:
|
|
self.checks(["docs/guide.md:3: broken relative link 'x.md'", "docs/other.md:1: history ID"],
|
|
["[link] docs/guide.md:3: 없는 곳을 가리키는 상대 링크다: x.md"])
|
|
self.repo.write("docs/guide.md", "# 안내\n")
|
|
code, out, _ = run_event("post-edit", self.repo.payload("docs/guide.md"), self.environment)
|
|
text = added_context(out)
|
|
self.assertEqual(code, 0)
|
|
self.assertIn("문서 검사 알림(N2) docs/guide.md", text)
|
|
self.assertIn("broken relative link 'x.md'", text)
|
|
self.assertIn("없는 곳을 가리키는 상대 링크다", text)
|
|
self.assertNotIn("docs/other.md", text)
|
|
self.assertNotIn("print(", text)
|
|
|
|
def test_failures_elsewhere_are_shown_when_none_names_the_document(self) -> None:
|
|
self.checks(["AGENTS.md: 41 lines, limit 40"], [])
|
|
self.repo.write("docs/guide.md", "# 안내\n")
|
|
text = added_context(run_event("post-edit", self.repo.payload("docs/guide.md"), self.environment)[1])
|
|
self.assertIn("AGENTS.md: 41 lines, limit 40", text)
|
|
|
|
def test_passing_checks_add_nothing(self) -> None:
|
|
self.checks([], [])
|
|
self.repo.write("docs/guide.md", "# 안내\n")
|
|
self.assertEqual(run_event("post-edit", self.repo.payload("docs/guide.md"), self.environment), (0, "", ""))
|
|
|
|
|
|
class TurnEndNudgeTest(RepositoryTestCase):
|
|
"""N5 — Java edited and no desktop Gradle run since: the turn end says so once."""
|
|
|
|
SOURCE = "src/domain-core/src/main/java/dev/caskeleton/domain/order/Order.java"
|
|
|
|
def edit_java(self) -> None:
|
|
run_event("post-edit", self.repo.payload(self.SOURCE), self.environment)
|
|
|
|
def stop(self, **extra) -> dict | None:
|
|
out = run_event("stop", {"session_id": "s1", "cwd": str(self.repo.root), **extra})[1]
|
|
return json.loads(out) if out else None
|
|
|
|
def bash(self, command: str) -> None:
|
|
run_event("post-bash", {"session_id": "s1", "cwd": str(self.repo.root), "tool_name": "Bash",
|
|
"tool_input": {"command": command}})
|
|
|
|
def test_a_java_edit_blocks_the_turn_end_once_with_the_reason(self) -> None:
|
|
self.edit_java()
|
|
first = self.stop()
|
|
self.assertEqual(first["decision"], "block")
|
|
self.assertIn(f"Java 파일 1개를 고쳤고(`{self.SOURCE}`)", first["reason"])
|
|
self.assertIn("HARD-STOP 6", first["reason"])
|
|
self.assertIsNone(self.stop())
|
|
|
|
def test_a_desktop_gradle_run_clears_the_pending_edits(self) -> None:
|
|
self.edit_java()
|
|
self.bash("ssh -o BatchMode=yes desktop 'cd ~/w && flock /tmp/claude-gates/heavy.lock ./gradlew :domain-core:check'")
|
|
self.assertIsNone(self.stop())
|
|
|
|
def test_a_laptop_command_or_another_host_does_not_count(self) -> None:
|
|
self.edit_java()
|
|
self.bash("git log --oneline -1 && echo gradlew")
|
|
self.bash("ssh buildbox ./gradlew check")
|
|
self.assertEqual(self.stop()["decision"], "block")
|
|
|
|
def test_a_new_java_edit_after_the_reminder_reminds_again(self) -> None:
|
|
self.edit_java()
|
|
self.stop()
|
|
self.edit_java()
|
|
self.assertEqual(self.stop()["decision"], "block")
|
|
|
|
def test_an_active_stop_hook_never_blocks_again(self) -> None:
|
|
self.edit_java()
|
|
self.assertIsNone(self.stop(stop_hook_active=True))
|
|
|
|
def test_no_java_edit_no_reminder(self) -> None:
|
|
self.assertIsNone(self.stop())
|
|
|
|
|
|
class SettingsWiringTest(unittest.TestCase):
|
|
"""The committed project settings call these hooks on the events they are written for."""
|
|
|
|
def setUp(self) -> None:
|
|
self.settings = json.loads((REPO / ".claude/settings.json").read_text(encoding="utf-8"))
|
|
|
|
def commands(self, event: str, matcher: str | None) -> list[str]:
|
|
groups = [group for group in self.settings["hooks"][event] if group.get("matcher") == matcher]
|
|
return [hook["command"] for group in groups for hook in group["hooks"]]
|
|
|
|
def test_every_event_calls_its_hook(self) -> None:
|
|
script = 'python3 "$CLAUDE_PROJECT_DIR"/scripts/hooks/hooks.py'
|
|
self.assertEqual(self.commands("PreToolUse", "Edit|Write|MultiEdit"), [f"{script} pre-edit"])
|
|
self.assertEqual(self.commands("PostToolUse", "Edit|Write|MultiEdit"), [f"{script} post-edit"])
|
|
self.assertEqual(self.commands("PostToolUse", "Bash"), [f"{script} post-bash"])
|
|
self.assertEqual(self.commands("Stop", None), [f"{script} stop"])
|
|
|
|
def test_real_env_files_are_denied_and_the_examples_are_not(self) -> None:
|
|
deny = self.settings["permissions"]["deny"]
|
|
for name in (".env", ".env.local", ".env.lane"):
|
|
self.assertIn(f"Read(**/{name})", deny)
|
|
self.assertIn(f"Edit(**/{name})", deny)
|
|
self.assertFalse([rule for rule in deny if "example" in rule or rule.endswith(".env.*)")])
|
|
|
|
def test_the_hook_script_runs_from_the_command_line(self) -> None:
|
|
with tempfile.TemporaryDirectory() as project:
|
|
result = subprocess.run([sys.executable, str(SCRIPTS / "hooks/hooks.py"), "stop"], input="{}",
|
|
capture_output=True, text=True, cwd=project,
|
|
env={**os.environ, "CLAUDE_PROJECT_DIR": project})
|
|
self.assertEqual((result.returncode, result.stdout), (0, ""))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|