Files
clean-architecture-backend-…/scripts/tests/test_verify_remote.py
DongHyeonka eabf31435a
pr / done (pull_request) Successful in 1m56s
fix(verify): index 사본이 mtime을 지켜 같은 초에 고친 파일도 보낸다
문제: run_remote는 보낼 트리를 index 사본으로 만든다. 사본을 -p 없이
복사해 mtime이 복사한 시각이 된다. git은 mtime이 index 파일보다 늦지
않은 항목(racy)만 내용을 다시 읽는데, 사본이 더 새로 보여 그 판단이
사라진다. 그래서 git이 index를 쓴 그 초에 같은 크기로 고친 파일은
사본의 git add가 stat만 보고 빼고, 보낸 트리에서 그 수정이 빠진다
(그 수정뿐이면 HEAD 트리가 간다). 원격의 트리 해시 대조도 같은 틀린
트리를 비교해 통과하고 rc=0이 난다.
프론트 #77이 같은 결함을 고쳤다.

고른 방법: cp -p 한 글자. 버린 안: 빈 index에서 git add로 트리를 새로
만들기 — stat 기록을 안 쓰니 확실하지만 미추적 검사·-u 규칙과 다른
경로가 생기고 큰 repo에서 전체 파일을 해시한다.

시험: test_verify_remote.py에 프론트 시험을 옮겼다. 추적 파일과 index의
mtime을 같은 과거 초로 맞추고 core.trustctime=false로 같은 크기 수정을
만든 뒤, 보낸 트리가 빈 index로 만든 작업 트리와 같은지 본다.

위험: 사본의 mtime과 mode가 원본 index를 따른다. 사본은 mktemp 임시
파일이고 끝나면 지운다. 패치·트리 해시 대조 구조는 그대로다.

검증: python3 -m unittest discover -s scripts/tests 통과. cp로
되돌리면 새 시험이 실패한다(3/3), cp -p로 통과(5/5).
desktop 변이(같은 초·같은 크기·같은 inode로 shared-contract Java를
컴파일이 깨지게 고침) 뒤 verify.sh leaf :shared-contract: main은 HEAD
트리를 보내 rc=0(272 tests), 이 커밋은 수정을 보내 rc=1.
scripts/verify.sh docs rc=0.

Refs: REV-BE-0012
2026-11-21 05:46:25 +09:00

178 lines
7.7 KiB
Python

"""scripts/verify.sh `--on <호스트>`의 시험. 원격으로 보내는 패치가 추적 파일의 변경과 stage한 새 파일뿐인지,
미추적 파일이 있으면 아무것도 보내지 않고 이름을 찍고 멈추는지(rc=5), 트리 줄이 HEAD 트리와 같은지 말하는지,
index를 쓴 그 초에 같은 크기로 고친 파일도 보내는지 본다.
ssh는 가짜다. 패치를 받는 호출(`cat > /tmp/<id>.patch`)이면 받은 것을 파일에 쓰고, 원격 실행(`bash -s`)이면 입력을
버리고 0으로 끝난다. Gradle·네트워크를 쓰지 않는다. 가짜 ssh와 그 기록은 시험 repo 밖에 두어 미추적 파일로 잡히지
않게 한다.
python3 -m unittest discover -s scripts/tests
"""
from __future__ import annotations
import os
import shutil
import subprocess
import tempfile
import time
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
SCRIPT = ROOT / "scripts/verify.sh"
# The developer's global git settings (hooks, signing, excludes) must not reach the throwaway repository.
GIT_ENV = {
**os.environ,
"GIT_CONFIG_GLOBAL": os.devnull,
"GIT_CONFIG_NOSYSTEM": "1",
"GIT_AUTHOR_NAME": "test",
"GIT_AUTHOR_EMAIL": "test@example.invalid",
"GIT_COMMITTER_NAME": "test",
"GIT_COMMITTER_EMAIL": "test@example.invalid",
}
FAKE_SSH = """#!/bin/sh
printf '%s\\n' "$*" >> "$FAKE_SSH_CALLS"
case "$2" in
"cat > "*) cat > "$FAKE_SSH_PATCH" ;;
*) cat > /dev/null ;;
esac
"""
class RemoteVerifyTest(unittest.TestCase):
"""A repository whose first commit holds this verify.sh, a tracked document and a .gitignore for build/."""
def setUp(self) -> None:
directory = tempfile.TemporaryDirectory()
self.addCleanup(directory.cleanup)
self.repo = Path(directory.name) / "repo"
self.outside = Path(directory.name) / "outside"
self.outside.mkdir()
self.git("init", "-q", "-b", "main", str(self.repo), cwd=Path(directory.name))
(self.repo / "scripts").mkdir()
shutil.copy2(SCRIPT, self.repo / "scripts/verify.sh")
self.write("docs/guide.md", "# guide\n")
self.write(".gitignore", "build/\n")
self.git("add", "-A")
self.git("commit", "-q", "-m", "first")
self.ssh = self.outside / "ssh"
self.ssh.write_text(FAKE_SSH, encoding="utf-8")
self.ssh.chmod(0o755)
self.calls = self.outside / "calls"
self.patch = self.outside / "patch"
def git(self, *args: str, cwd: Path | None = None) -> str:
return subprocess.run(["git", *args], cwd=cwd or self.repo, env=GIT_ENV, check=True,
capture_output=True, text=True).stdout.strip()
def write(self, path: str, text: str) -> None:
target = self.repo / path
target.parent.mkdir(parents=True, exist_ok=True)
target.write_text(text, encoding="utf-8")
def verify(self, *extra: str) -> subprocess.CompletedProcess[str]:
env = {**GIT_ENV, "VERIFY_SSH": str(self.ssh), "VERIFY_BASE_REF": "HEAD",
"FAKE_SSH_CALLS": str(self.calls), "FAKE_SSH_PATCH": str(self.patch)}
return subprocess.run(["bash", "scripts/verify.sh", "pr", "--on", "fake", *extra], cwd=self.repo, env=env,
capture_output=True, text=True, timeout=60)
def sent_patch(self) -> str:
return self.patch.read_text(encoding="utf-8")
def test_an_untracked_file_stops_it_before_anything_is_sent(self) -> None:
self.write("probe-untracked.txt", "left behind\n")
result = self.verify()
self.assertEqual(5, result.returncode, result.stderr)
self.assertIn("probe-untracked.txt", result.stderr)
self.assertFalse(self.calls.exists(), "ssh must not be called")
def test_include_untracked_sends_the_untracked_file(self) -> None:
self.write("probe-untracked.txt", "meant to go\n")
result = self.verify("--include-untracked")
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn("probe-untracked.txt", self.sent_patch())
def test_a_tracked_change_is_sent_and_the_tree_line_says_it_differs_from_head(self) -> None:
self.write("docs/guide.md", "# guide\n\nchanged line\n")
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn("+changed line", self.sent_patch())
self.assertIn("다름", result.stderr)
def test_a_staged_new_file_is_sent(self) -> None:
self.write("docs/new.md", "# new\n")
self.git("add", "docs/new.md")
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn("docs/new.md", self.sent_patch())
def test_an_ignored_file_does_not_stop_it_and_is_not_sent(self) -> None:
self.write("build/output.txt", "generated\n")
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertNotIn("build/output.txt", self.sent_patch())
def test_a_file_listed_in_info_exclude_does_not_stop_it_and_is_not_sent(self) -> None:
self.write("notes/mine.txt", "personal\n")
(self.repo / ".git/info").mkdir(parents=True, exist_ok=True)
(self.repo / ".git/info/exclude").write_text("notes/\n", encoding="utf-8")
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertNotIn("notes/mine.txt", self.sent_patch())
def test_an_edit_git_sees_only_by_reading_the_file_is_sent_too(self) -> None:
"""REV-BE-0012. 같은 크기로 고친 파일의 stat이 index 기록과 같으면, git은 index 파일보다 늦지 않은 항목(racy)만
내용을 읽어 수정을 본다. 보낼 트리를 만드는 index 사본이 mtime을 잃으면 그 항목이 racy가 아니게 되어 사본의
`git add`가 수정을 빼고, 원격은 HEAD 트리를 작업 트리라며 돌린다. 프론트 #77 시험을 옮겼다."""
edited = self.repo / "docs/guide.md"
# 시각을 손으로 정해 매번 같은 결과를 낸다. ctime은 고친 초에 따라 기록과 같기도 달라서 보지 않게 한다.
self.git("config", "core.trustctime", "false")
old = int(time.time()) - 3600
os.utime(edited, (old, old))
self.git("update-index", "--refresh")
edited.write_text("# GUIDE\n", encoding="utf-8")
os.utime(edited, (old, old))
# git이 index를 쓴 그 초에 파일을 같은 크기로 고친 상태다.
os.utime(self.repo / ".git/index", (old, old))
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn(f"트리 {self.working_tree()[:12]}(", result.stderr)
self.assertIn("+# GUIDE", self.sent_patch())
# 진짜 index는 건드리지 않는다: 수정은 stage되지 않은 채 남는다.
self.assertEqual("docs/guide.md", self.git("diff", "--name-only"))
def working_tree(self) -> str:
"""작업 트리의 트리 해시. 빈 index에서 만들어 index의 stat 기록에 기대지 않는다."""
env = {**GIT_ENV, "GIT_INDEX_FILE": str(self.outside / "fresh-index")}
subprocess.run(["git", "add", "-A"], cwd=self.repo, env=env, check=True, capture_output=True)
return subprocess.run(["git", "write-tree"], cwd=self.repo, env=env, check=True, capture_output=True,
text=True).stdout.strip()
def test_a_clean_tree_says_it_is_the_head_tree(self) -> None:
result = self.verify()
self.assertEqual(0, result.returncode, result.stderr)
self.assertIn("HEAD 트리와 같음", result.stderr)
self.assertEqual("", self.sent_patch())
if __name__ == "__main__":
unittest.main()