The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""scripts/ci/check_blob_size.py on real temp git repos: what a PR may add, and what it may not."""
from __future__ import annotations
import os
import subprocess
import sys
from pathlib import Path
import pytest
REPO = Path(__file__).resolve().parents[2]
SCRIPT = REPO / "scripts" / "ci" / "check_blob_size.py"
sys.path.insert(0, str(SCRIPT.parent))
import check_blob_size as cbs
LIMIT = 4096
def _env() -> dict[str, str]:
env = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
env.update(GIT_CONFIG_GLOBAL=os.devnull, GIT_CONFIG_NOSYSTEM="1")
return env
def _git(repo: Path, *args: str) -> str:
proc = subprocess.run(["git", *args], cwd=repo, env=_env(), capture_output=True, text=True,
encoding="utf-8", stdin=subprocess.DEVNULL, timeout=60, check=False)
assert proc.returncode == 0, (args, proc.stderr)
return proc.stdout.strip()
def _binary(n: int, seed: int = 0) -> bytes:
return bytes((i * 7 + seed) % 256 for i in range(n)) # contains NUL bytes: git calls it binary
def _text(n: int, seed: str = "x") -> bytes:
return (seed * 63 + "\n").encode() * (n // 64 + 1)
def _commit(repo: Path, files: dict[str, bytes | None], msg: str = "step") -> str:
for rel, data in files.items():
path = repo / rel
if data is None:
_git(repo, "rm", "-q", "--", rel)
continue
path.parent.mkdir(parents=True, exist_ok=True)
path.write_bytes(data)
_git(repo, "add", "--", rel)
_git(repo, "commit", "-q", "--allow-empty", "-m", msg)
return _git(repo, "rev-parse", "HEAD")
@pytest.fixture
def repo(tmp_path: Path) -> Path:
root = tmp_path / "repo"
root.mkdir()
_git(root, "init", "-q", "-b", "main")
_git(root, "config", "user.email", "[email protected]")
_git(root, "config", "user.name", "t")
_commit(root, {
"big.lock": _text(LIMIT * 3, "l"), # legacy text file already over the limit
"assets/icon.icns": _binary(LIMIT * 2, 1), # legacy binary already over the limit
"assets/small.png": _binary(100, 2),
}, "base")
return root
def _offenders(repo: Path, base: str, head: str | None, allow: frozenset[str] | set[str] = frozenset()):
return [(o.path, o.kind, o.status) for o in cbs.find_offenders(repo, base, head, LIMIT, allow)]
@pytest.mark.parametrize("files, expected", [
# added binary over the limit
({"docs/shot.png": _binary(LIMIT + 1)}, [("docs/shot.png", "binary", "A")]),
# added binary at exactly the limit, and a small one
({"docs/a.png": _binary(LIMIT), "docs/b.png": _binary(10)}, []),
# a modified binary is judged on its new size, legacy or not
({"assets/icon.icns": _binary(LIMIT * 2, 9)}, [("assets/icon.icns", "binary", "M")]),
({"assets/small.png": _binary(LIMIT + 1, 3)}, [("assets/small.png", "binary", "M")]),
# shrinking a legacy binary under the limit passes
({"assets/icon.icns": _binary(LIMIT - 1, 9)}, []),
# a new text file over the limit (fuzz corpus, dumped JSON)
({"r318C_fuzz_new.json": _text(LIMIT + 64)}, [("r318C_fuzz_new.json", "new file", "A")]),
# growing an existing text file is the FILE_LINES ratchet's job, not this check's
({"big.lock": _text(LIMIT * 4, "m")}, []),
# deleting a big file is always fine
({"assets/icon.icns": None}, []),
])
def test_verdict(repo, files, expected):
base = _git(repo, "rev-parse", "HEAD")
head = _commit(repo, files)
assert _offenders(repo, base, head) == expected
def test_pure_move_adds_no_bytes_but_move_with_edit_is_judged(repo):
base = _git(repo, "rev-parse", "HEAD")
(repo / "packaging").mkdir()
(repo / "deps").mkdir()
_git(repo, "mv", "assets/icon.icns", "packaging/icon.icns")
_git(repo, "mv", "big.lock", "deps/big.lock")
moved = _commit(repo, {})
assert _offenders(repo, base, moved) == []
edited = _commit(repo, {"packaging/icon.icns": _binary(LIMIT * 2, 5)})
assert _offenders(repo, base, edited) == [("packaging/icon.icns", "binary", "R")]
def test_content_the_base_already_holds_adds_no_bytes(repo):
# A byte-identical copy shares the blob; so does reverting to a version main still tracks.
base = _git(repo, "rev-parse", "HEAD")
copied = _commit(repo, {"other/icon.icns": (repo / "assets/icon.icns").read_bytes()})
assert _offenders(repo, base, copied) == []
tweaked = _commit(repo, {"other/icon.icns": _binary(LIMIT * 2, 7)})
assert _offenders(repo, copied, tweaked) == [("other/icon.icns", "binary", "M")]
def test_allowlist_exempts_exact_paths_only(repo):
base = _git(repo, "rev-parse", "HEAD")
head = _commit(repo, {"assets/icon.icns": _binary(LIMIT * 2, 9), "assets/icon-dark.icns": _binary(LIMIT * 2, 8)})
allow = {"assets/icon.icns", "assets/"}
assert _offenders(repo, base, head, allow) == [("assets/icon-dark.icns", "binary", "A")]
def test_allowlist_file_ignores_comments_and_blanks(tmp_path):
path = tmp_path / "allow.txt"
path.write_text("# why\n\n apps/a.icns \n# b.png\n", encoding="utf-8")
assert cbs.read_allowlist(path) == {"apps/a.icns"}
assert cbs.read_allowlist(tmp_path / "missing.txt") == set()
def test_working_tree_mode_sees_unstaged_and_untracked_files(repo):
base = _git(repo, "rev-parse", "HEAD")
(repo / "assets/small.png").write_bytes(_binary(LIMIT + 5, 4)) # unstaged edit
(repo / "log.db").write_bytes(_binary(LIMIT + 5, 6)) # untracked
(repo / "dump.txt").write_bytes(_text(LIMIT + 64)) # untracked text
(repo / ".gitignore").write_text("ignored.bin\n", encoding="utf-8")
(repo / "ignored.bin").write_bytes(_binary(LIMIT * 2))
assert sorted(_offenders(repo, base, None)) == [
("assets/small.png", "binary", "M"), ("dump.txt", "new file", "A"), ("log.db", "binary", "A"),
]
def test_untracked_copy_of_base_content_adds_no_bytes(repo):
# Staging the copy would pass (its blob is already in the base); so must leaving it untracked.
base = _git(repo, "rev-parse", "HEAD")
(repo / "copies").mkdir()
(repo / "copies/icon.icns").write_bytes((repo / "assets/icon.icns").read_bytes())
(repo / "copies/big.lock").write_bytes((repo / "big.lock").read_bytes())
(repo / "copies/icon-edited.icns").write_bytes(_binary(LIMIT * 2, 11))
assert _offenders(repo, base, None) == [("copies/icon-edited.icns", "binary", "A")]
_git(repo, "add", "--", "copies/icon.icns", "copies/big.lock")
assert _offenders(repo, base, None) == [("copies/icon-edited.icns", "binary", "A")]
def test_cli_with_head_reads_the_allowlist_from_head_not_the_checkout(repo):
base = _git(repo, "rev-parse", "HEAD")
head = _commit(repo, {".github/blob-size-allowlist.txt": b"pr-assets/kept.png\n",
"pr-assets/kept.png": _binary(LIMIT * 2, 1), "pr-assets/shot.png": _binary(LIMIT * 2, 2)})
# The checkout now exempts the other file and not the one head exempts.
_git(repo, "checkout", "-q", base)
(repo / ".github").mkdir(exist_ok=True)
(repo / ".github/blob-size-allowlist.txt").write_text("pr-assets/shot.png\n", encoding="utf-8")
def run(*extra: str) -> subprocess.CompletedProcess:
return subprocess.run([sys.executable, str(SCRIPT), "--base", base, *extra, "--limit", str(LIMIT)],
cwd=repo, env=_env(), capture_output=True, text=True, encoding="utf-8",
timeout=60, check=False)
proc = run("--head", head)
assert proc.returncode == 1, proc.stdout + proc.stderr
assert "::error file=pr-assets/shot.png::" in proc.stdout
assert "pr-assets/kept.png" not in proc.stdout
# A head without the list exempts nothing, whatever the checkout says.
bare = _commit(repo, {"pr-assets/shot.png": _binary(LIMIT * 2, 2)})
assert run("--head", bare).returncode == 1
# Working-tree mode keeps reading the list from disk.
assert run().returncode == 0
def test_cli_fails_with_fix_text_and_writes_step_summary(repo, tmp_path):
base = _git(repo, "rev-parse", "HEAD")
(repo / ".github").mkdir()
(repo / ".github/blob-size-allowlist.txt").write_text("assets/icon.icns\n", encoding="utf-8")
head = _commit(repo, {".github/blob-size-allowlist.txt": (repo / ".github/blob-size-allowlist.txt").read_bytes(),
"assets/icon.icns": _binary(LIMIT * 2, 9), "pr-assets/shot.png": _binary(LIMIT * 3)})
summary = tmp_path / "summary.md"
env = {**_env(), "GITHUB_STEP_SUMMARY": str(summary)}
proc = subprocess.run([sys.executable, str(SCRIPT), "--base", base, "--head", head, "--limit", str(LIMIT)],
cwd=repo, env=env, capture_output=True, text=True, encoding="utf-8", timeout=60, check=False)
assert proc.returncode == 1, proc.stdout + proc.stderr
assert "::error file=pr-assets/shot.png::" in proc.stdout
assert "assets/icon.icns" not in proc.stdout # allowlisted by the head's own list
assert "blob-size-allowlist.txt" in proc.stdout and "python scripts/ci/check_blob_size.py" in proc.stdout
assert "| `pr-assets/shot.png` | binary | A |" in summary.read_text(encoding="utf-8")
clean = subprocess.run([sys.executable, str(SCRIPT), "--base", head, "--head", head], cwd=repo, env=_env(),
capture_output=True, text=True, encoding="utf-8", timeout=60, check=False)
assert clean.returncode == 0, clean.stdout + clean.stderr
def test_bad_revision_is_a_usage_error_not_a_pass(repo):
proc = subprocess.run([sys.executable, str(SCRIPT), "--base", "no-such-rev", "--head", "HEAD"], cwd=repo,
env=_env(), capture_output=True, text=True, encoding="utf-8", timeout=60, check=False)
assert proc.returncode == 2 and "check_blob_size:" in proc.stderr