Files
clean-architecture-backend-…/scripts/tests/test_hooks.py
T
DongHyeonka 6a792b8144 refactor(layout)!: 옮긴 경로를 부르는 곳을 모두 새 배치에 맞춘다
문제: 앞 커밋이 Gradle 루트를 저장소 루트로 옮기고 계층 폴더를 묶었다.
빌드 스크립트·build-logic·시험·workflow·스크립트·문서가 아직 옛 배치
(Gradle 루트 = src/)를 가정해 빌드가 되지 않는다.

고른 방법:
- Gradle 경로와 registry id는 그대로 둔다(:app-bootstrap, :application-core,
  :composition:*). registry의 source_path만 새 폴더를 가리킨다. 폴더에 맞춘
  이름(:domain:core, :application:core)은 프로젝트 이름 core가 둘이 되어
  boot jar의 BOOT-INF/lib와 기본 capability가 겹치고, 파생 서비스의 모든
  project(':…') 줄을 바꾸게 한다.
- registry는 gradle/modules.json, 시험 이미지 목록은
  gradle/container-images.properties: 버전 카탈로그 옆, 빌드가 고정하는 것.
  config/는 코드 검사 도구 설정만 둔다.
- build-logic: settings·architecture 플러그인의 저장소 루트를 Gradle 루트로
  (getParentFile 제거). config contract의 파일 트리는 src/만 훑는다(루트를
  훑으면 docs·.claude/worktrees까지 줍는다).
- 빌드 스크립트: rootProject.projectDir.parentFile → rootProject.projectDir,
  rootProject.file('../…') → rootProject.file('…'), 옛 src 기준 include에
  src/를 붙인다. notification API surface의 application-notification 소스
  루트를 새 폴더로(놓치면 272개 타입이 surface에서 말없이 빠진다).
- 시험: 옛 src 기준 모듈 목록과 ../ 개수를 고친다. 없는 폴더를 말없이
  건너뛰던 목록(MessagingAuthority, NotificationPayloadAtRest 등)을 새
  폴더로, FileserverDocumentationCoverageTest는 Gradle 경로 → 폴더를
  registry로 찾는다. Docker 계약은 WORKDIR /build, 새 jar 경로.
- Docker: 빌드 context를 저장소 루트로, .dockerignore는 허용 목록으로 다시
  써서 전에 context였던 것만 들어가게 한다. compose의 build.context는 .,
  env_file은 ./.env.
- workflow: working-directory: src 기본값과 그것을 되돌리던 줄을 지운다.
- scripts: verify.sh, ci/*, bootstrap-local, new-feature,
  verify-feature-scaffold, mongo 검증, hooks, check-repo-layout 허용 목록.
  check-docs의 경로 검사는 build-logic/·gradle/로 시작하는 경로도 본다.
- 문서: AGENTS.md 지도, README 구조 표, leaf AGENTS.md의 cd src, gates·
  operate·결정 색인, src/bootstrap/AGENTS.md를 조립 계층 family 규칙으로
  다시 쓴다. 기록 문서(docs/design·history·reviews, 지난 upgrade 안내,
  capability-status 제거 표)는 머리 블록만 고친다. 파생 서비스용 안내
  docs/upgrade/2026-11-relayout.md를 더한다.

위험: bootRun working dir가 저장소 루트가 되어 .env와 상대 경로 설정이
루트 기준이다. 루트 .env는 compose 보간에도 읽힌다(upgrade 안내 5절).
파생 서비스는 태그 pre-relayout-2026-11까지 받은 뒤 이 묶음을 받는다.

검증: desktop에서 캐시 없이 scripts/verify.sh docs·pr·main·release,
compose smoke 18 lane, 빠른 시작(scripts/verify.sh app). 결과는 PR 본문.
구조 리뷰(arch-reviewer) 지적 5건을 반영했다.

BREAKING CHANGE: Gradle은 저장소 루트에서 돈다(cd src 없음). registry는
gradle/modules.json, 이미지 빌드 context는 저장소 루트다. 옛 경로 → 새 경로
표는 docs/upgrade/2026-11-relayout.md.
Refs: design-docs repo-structure/01-backend-layout.md 6.1절 가-2·가-3
2026-11-11 22:15:42 +09:00

406 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("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_owned_library_in_the_application_is_flagged(self) -> None:
text = self.nudge("src/application/core", "dev/caskeleton/application/order/Notify.java",
"import dev.cakit.messaging.api.MessageEnvelope;")
self.assertIn("`application-core`가 `dev.cakit.messaging.api.MessageEnvelope`", 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()