"""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 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 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()