@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/commit-msg-range.test.ts

@@ -0,0 +1,126 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { afterEach, expect, it } from "vitest";
+import { main } from "./commit-msg.ts";
+import { CONFIG_FILE } from "./config.ts";
+
+/** `repo commit-msg --range` on planted repos. */
+const temps: string[] = [];
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", ["-c", "user.email=a@b", "-c", "user.name=a", ...args], { cwd, encoding: "utf8" }).trim();
+const lines = (n: number) => Array.from({ length: n }, (_, i) => `line ${i}\n`).join("");
+
+/** A repo with a base commit; `commit` adds files and commits with `message`, returning the sha. */
+function plant() {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "commit-range-")));
+  temps.push(root);
+  git(root, "init", "-q", "-b", "main");
+  const commit = (files: Record<string, string | Buffer>, message: string) => {
+    for (const [rel, text] of Object.entries(files)) {
+      fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+      fs.writeFileSync(path.join(root, rel), text);
+    }
+    git(root, "add", "-A");
+    git(root, "commit", "-q", "--no-verify", "-m", message);
+    return git(root, "rev-parse", "HEAD");
+  };
+  const base = commit(
+    { "package.json": JSON.stringify({ name: "app", private: true }), [CONFIG_FILE]: "export default {}\n" },
+    "chore: base",
+  );
+  return { root, commit, base };
+}
+async function range(root: string, ...args: string[]) {
+  const err: string[] = [];
+  const code = await main(args, { cwd: root, stderr: (text) => err.push(text) });
+  return { code, stderr: err.join("") };
+}
+const NEEDS_TEST = "a feat commit must include a test change (a *.test.* or *.spec.* file, or a file under e2e/)";
+const HEADER = 'the header must be "type(scope)!: subject", e.g. "fix(paths): compare hook paths canonically"';
+const USAGE =
+  "repo commit-msg: name the commit message file as git's commit-msg hook does or pass --range <base>..<head>\n";
+
+/** Plants a side branch merged into main with a merge commit on top. */
+function merged(plantd: ReturnType<typeof plant>) {
+  const { root, commit } = plantd;
+  git(root, "checkout", "-q", "-b", "side");
+  commit({ "s.ts": "s\n" }, "chore: side");
+  git(root, "checkout", "-q", "main");
+  commit({ "m.ts": "m\n" }, "chore: main");
+  git(root, "merge", "-q", "--no-ff", "-m", "Merge side", "side");
+}
+
+it("passes a clean range, a lockfile-heavy commit and skips merges", async () => {
+  const planted = plant();
+  const { root, commit, base } = planted;
+  commit({ "a.ts": "a\n", "a.test.ts": "t\n" }, "feat: add a");
+  commit(
+    { "bun.lock": lines(2000), "gen/x.ts": lines(2000), ".gitattributes": "gen/** linguist-generated\n" },
+    "chore: lock",
+  );
+  merged(planted);
+  expect(await range(root, "--range", `${base}..HEAD`)).toEqual({ code: 0, stderr: "" });
+});
+
+it("names sha and subject of each failing commit, oldest first", async () => {
+  const { root, commit, base } = plant();
+  const one = commit({ "a.ts": "a\n" }, "feat: add a");
+  const two = commit({ "b.ts": "b\n" }, "Bad header");
+  const three = commit({ "big.ts": lines(1100) }, "chore: big");
+  const four = commit({ "c.ts": "c\n" }, "chore(Nope): x");
+  const result = await range(root, "--range", `${base}..HEAD`);
+  expect(result.code).toBe(1);
+  expect(result.stderr.split("\n")).toEqual([
+    `commit-msg: ${one.slice(0, 7)} feat: add a: ${NEEDS_TEST}`,
+    `commit-msg: ${two.slice(0, 7)} Bad header: ${HEADER}`,
+    `commit-msg: ${three.slice(0, 7)} chore: big: the commit changes 1100 lines, over the limit of 1000; add a body line saying why, or split it`,
+    `commit-msg: ${four.slice(0, 7)} chore(Nope): x: the scope "Nope" must be lowercase kebab-case`,
+    "",
+  ]);
+});
+
+it("checks HEAD alone for a zero, empty, missing or non-ancestor base", async () => {
+  const { root, commit, base } = plant();
+  git(root, "checkout", "-q", "-b", "other");
+  const other = commit({ "o.ts": "o\n" }, "chore: other");
+  git(root, "checkout", "-q", "main");
+  const bad = commit({ "a.ts": "a\n" }, "feat: add a");
+  const problem = `commit-msg: ${bad.slice(0, 7)} feat: add a: ${NEEDS_TEST}\n`;
+  expect(await range(root, "--range", `${"0".repeat(40)}..HEAD`)).toEqual({ code: 1, stderr: problem });
+  expect(await range(root, "--range", "..HEAD")).toEqual({ code: 1, stderr: problem });
+  expect(await range(root, "--range", `${other}..HEAD`)).toEqual({
+    code: 1,
+    stderr: `commit-msg: ${other.slice(0, 7)} is not an ancestor of HEAD (a force push?); checking HEAD alone\n${problem}`,
+  });
+  const gone = await range(root, "--range", `${"1".repeat(40)}..HEAD`);
+  expect(gone.stderr).toContain("1111111 is not an ancestor of HEAD (a force push?); checking HEAD alone\n");
+  expect(await range(root, "--range", `${base}..`)).toEqual({ code: 1, stderr: problem });
+});
+
+it("checks nothing when the head alone is a merge", async () => {
+  const planted = plant();
+  merged(planted);
+  expect(await range(planted.root, "--range", "..HEAD")).toEqual({ code: 0, stderr: "" });
+});
+
+it("refuses an unknown range and no arguments", async () => {
+  const { root } = plant();
+  const bads = ["nope..HEAD", "HEAD..nope", "HEAD", "a..b..c"];
+  const results = await Promise.all(bads.map((bad) => range(root, "--range", bad)));
+  expect(results).toEqual(
+    bads.map((bad) => ({ code: 1, stderr: `repo commit-msg: no commit range "${bad}"; use <base>..<head>\n` })),
+  );
+  expect(await range(root, "--range")).toEqual({ code: 1, stderr: USAGE });
+  expect(await range(root, "--range", "a..b", "c")).toEqual({ code: 1, stderr: USAGE });
+});
+
+it("refuses on a config it cannot read", async () => {
+  const { root, commit, base } = plant();
+  commit({ [CONFIG_FILE]: "export default { commit: 5 }\n" }, "chore: x");
+  expect((await range(root, "--range", `${base}..HEAD`)).code).toBe(1);
+});

package/cli/commit-msg-red-proof.test.ts

@@ -0,0 +1,147 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { CONFIG_FILE } from "./config.ts";
+import { main } from "./commit-msg.ts";
+import { removePlanted } from "./fixtures/planted-repo.ts";
+import { FAIL, plant, stage } from "./fixtures/red-proof-repo.ts";
+import type { NameStatus, RedProofResult } from "./red-proof.ts";
+
+/** The hook's red-proof step: when it runs, what it refuses, what it prints. */
+afterEach(removePlanted);
+
+const TDD = "export default { tdd: true }\n";
+const PLAIN = { [CONFIG_FILE]: "export default {}\n" };
+const PRIVATE = { name: "p", private: true };
+const PROBLEM = "red-proof: no changed test file fails on HEAD's source (a.test.ts passed); needs a failing one";
+const LINE = "red-proof: 1 of 1 changed test files failed on HEAD";
+
+/** Runs `repo commit-msg` with a red-proof stand-in; what it was given, the exit code and stderr. */
+async function hook(root: string, message: string, result: RedProofResult = { ok: true, line: LINE }) {
+  fs.writeFileSync(path.join(root, ".git", "COMMIT_EDITMSG"), message);
+  const calls: { root: string; change: NameStatus[] }[] = [];
+  const err: string[] = [];
+  const redProof = (at: string, change: NameStatus[]) => (calls.push({ root: at, change }), result);
+  const code = await main([".git/COMMIT_EDITMSG"], { cwd: root, stderr: (text) => err.push(text), redProof });
+  return { calls, code, stderr: err.join("") };
+}
+const feat = (root: string) => hook(root, "feat: add x\n");
+const SRC_AND_TEST = { "src/x.ts": "export const x = 1;\n", "src/x.test.ts": "t\n", "CHANGELOG.md": "# Changelog\n" };
+
+describe("commit-msg red-proof in a public package", () => {
+  it("refuses a feat with the problem in the refused list", async () => {
+    const root = plant(PLAIN);
+    stage(root, SRC_AND_TEST);
+    const result = await hook(root, "feat: add x\n", { ok: false, problem: PROBLEM });
+    expect(result.code).toBe(1);
+    expect(result.stderr).toBe(`commit-msg: the message was refused\n  - ${PROBLEM}\n`);
+    expect(result.calls).toEqual([
+      {
+        root,
+        change: [
+          { status: "A", path: "CHANGELOG.md" },
+          { status: "A", path: "src/x.test.ts" },
+          { status: "A", path: "src/x.ts" },
+        ],
+      },
+    ]);
+  });
+
+  it("lets a fix through and prints the red-proof line", async () => {
+    const root = plant(PLAIN);
+    stage(root, SRC_AND_TEST);
+    expect(await hook(root, "fix: handle x\n")).toMatchObject({ code: 0, stderr: `${LINE}\n` });
+  });
+});
+
+describe("commit-msg red-proof in a test-only change", () => {
+  it("runs from a test-only change, using the test files' owner", async () => {
+    const root = plant(PLAIN);
+    stage(root, { "x.test.ts": "t\n" });
+    expect((await feat(root)).calls).toHaveLength(1);
+  });
+
+  it("does not count a fixture as source, so a private owner of the tests decides", async () => {
+    const root = plant({ ...PLAIN, "package.json": PRIVATE });
+    stage(root, { "fixtures/a.ts": "x\n", "x.test.ts": "t\n" });
+    expect((await feat(root)).calls).toHaveLength(0);
+  });
+});
+
+describe("commit-msg red-proof by package", () => {
+  const mono = () =>
+    plant({
+      ...PLAIN,
+      "package.json": { name: "mono", private: true, workspaces: ["packages/*"] },
+      "packages/pub/package.json": { name: "pub" },
+      "packages/priv/package.json": { name: "priv", private: true },
+    });
+
+  it("runs for a private package only with tdd: true", async () => {
+    const root = mono();
+    stage(root, { "packages/priv/x.ts": "x\n", "packages/priv/x.test.ts": "t\n" });
+    expect((await hook(root, "fix(priv): x\n")).calls).toHaveLength(0);
+    fs.writeFileSync(path.join(root, CONFIG_FILE), TDD);
+    expect((await hook(root, "fix(priv): x\n")).calls).toHaveLength(1);
+  });
+
+  it("runs when any changed source file belongs to a public package", async () => {
+    const root = mono();
+    stage(root, { "packages/priv/x.ts": "x\n", "packages/pub/y.ts": "y\n", "packages/priv/x.test.ts": "t\n" });
+    expect((await hook(root, "feat(pub): y\n")).calls).toHaveLength(1);
+  });
+
+  it("looks at the test files' owners only when no source file changed", async () => {
+    const root = mono();
+    stage(root, { "packages/pub/y.test.ts": "t\n", "packages/priv/x.test.ts": "t\n" });
+    expect((await hook(root, "feat(pub): y\n")).calls).toHaveLength(1);
+  });
+});
+
+describe("commit-msg red-proof in a single-package repo", () => {
+  it("uses the root package.json of a single-package repo, private or not", async () => {
+    const root = plant({ ...PLAIN, "package.json": PRIVATE });
+    stage(root, SRC_AND_TEST);
+    expect((await feat(root)).calls).toHaveLength(0);
+    fs.writeFileSync(path.join(root, "package.json"), '{ "name": "p" }\n');
+    expect((await feat(root)).calls).toHaveLength(1);
+  });
+
+  it("takes a repo with no workerstack.config.ts as tdd false, by its root package.json", async () => {
+    const root = plant({ "package.json": PRIVATE });
+    stage(root, SRC_AND_TEST);
+    expect((await feat(root)).calls).toHaveLength(0);
+    fs.writeFileSync(path.join(root, "package.json"), '{ "name": "p" }\n');
+    expect((await feat(root)).calls).toHaveLength(1);
+  });
+});
+
+describe("commit-msg red-proof never runs", () => {
+  it.each(["test: cover x\n", "docs: x\n", "chore: x\n", "feat: Add x\n", "feat(Bad): x\n"])(
+    "for the message %j: another type, or a header already refused",
+    async (message) => {
+      const root = plant({ [CONFIG_FILE]: TDD });
+      stage(root, SRC_AND_TEST);
+      expect((await hook(root, message)).calls).toEqual([]);
+    },
+  );
+
+  it("when the staged change has no test, which the message check refuses first", async () => {
+    const root = plant({ [CONFIG_FILE]: TDD });
+    stage(root, { "src/x.ts": "x\n" });
+    const result = await feat(root);
+    expect(result.calls).toEqual([]);
+    expect(result.code).toBe(1);
+  });
+});
+
+describe("commit-msg red-proof end to end", () => {
+  it("runs the real vitest on HEAD and lands a feat whose test fails there", async () => {
+    const root = plant(PLAIN);
+    stage(root, { "x.ts": "export const x = 1;\n", "x.test.ts": FAIL, "CHANGELOG.md": "# Changelog\n" });
+    fs.writeFileSync(path.join(root, ".git", "COMMIT_EDITMSG"), "feat: add x\n");
+    const err: string[] = [];
+    expect(await main([".git/COMMIT_EDITMSG"], { cwd: root, stderr: (text) => err.push(text) })).toBe(0);
+    expect(err.join("")).toBe("red-proof: 1 of 1 changed test files failed on HEAD\n");
+  }, 60_000);
+});

package/cli/commit-msg-repo.test.ts

@@ -0,0 +1,153 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { CONFIG_FILE } from "./config.ts";
+import { NAME_A_SOURCE } from "./commit-range.constants.ts";
+import { main } from "./commit-msg.ts";
+import { commitChange, stagedChange } from "./staged-change.ts";
+
+/** `repo commit-msg` and the staged change it reads, on temp repos. */
+const OVER = "the commit changes 1240 lines, over the limit of 1000; add a body line saying why, or split it";
+
+const temps: string[] = [];
+afterEach(() => {
+  for (const dir of temps.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+});
+const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", ["-c", "user.email=a@b", "-c", "user.name=a", ...args], { cwd, encoding: "utf8" });
+const lines = (n: number) => Array.from({ length: n }, (_, i) => `line ${i}\n`).join("");
+const put = (root: string, files: Record<string, string | Buffer>) => {
+  for (const [rel, text] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), text);
+  }
+};
+const tempDir = () => {
+  const dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "commit-msg-")));
+  temps.push(dir);
+  return dir;
+};
+
+/** A temp repo with `base` committed and `staged` written and added on top. */
+function repo(base: Record<string, string | Buffer>, staged: Record<string, string | Buffer>): string {
+  const root = tempDir();
+  git(root, "init", "-q");
+  put(root, {
+    "package.json": JSON.stringify({ name: "app", private: true }),
+    [CONFIG_FILE]: "export default {}\n",
+    ...base,
+  });
+  git(root, "add", "-A");
+  git(root, "commit", "-q", "--no-verify", "-m", "base");
+  put(root, staged);
+  git(root, "add", "-A");
+  return root;
+}
+
+describe("stagedChange", () => {
+  it("counts staged insertions and deletions, and lists every staged path", () => {
+    const root = repo({ "a.ts": lines(10), "old.ts": lines(3) }, { "a.ts": lines(4), "b.test.ts": lines(5) });
+    git(root, "mv", "old.ts", "new.ts");
+    expect(stagedChange(root)).toEqual({ files: ["a.ts", "b.test.ts", "new.ts"], changedLines: 11 });
+  });
+
+  it("leaves out lockfiles, the lint baseline, binaries and linguist-generated paths", () => {
+    const skipped = ["bun.lock", "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "api/bun.lock"];
+    const staged = Object.fromEntries(
+      [...skipped, ".repo/lint-baseline.json", "gen/out.ts"].map((rel) => [rel, lines(50)]),
+    );
+    const root = repo(
+      { ".gitattributes": "gen/** linguist-generated\n" },
+      { ...staged, "bun.lockb": Buffer.from([0, 1, 2]), "img.bin": Buffer.from([0, 9, 0]), "src/a.ts": lines(7) },
+    );
+    expect(stagedChange(root).changedLines).toBe(7);
+  });
+
+  it("reads linguist-generated from the staged .gitattributes", () => {
+    const root = repo({}, { ".gitattributes": "gen/** linguist-generated=true\n", "gen/out.ts": lines(50) });
+    expect(stagedChange(root).changedLines).toBe(1);
+  });
+
+  it("finds nothing staged outside a git repo", () => {
+    expect(stagedChange(tempDir())).toEqual({ files: [], changedLines: 0 });
+    expect(commitChange(tempDir(), "HEAD")).toEqual({ files: [], changedLines: 0 });
+  });
+});
+
+/** Runs `repo commit-msg` on `message` in `root`; its exit code and what it printed. */
+async function commitMsg(root: string, message: string) {
+  fs.writeFileSync(path.join(root, ".git", "COMMIT_EDITMSG"), message);
+  const err: string[] = [];
+  const code = await main([".git/COMMIT_EDITMSG"], { cwd: root, stderr: (text) => err.push(text) });
+  return { code, stderr: err.join("") };
+}
+const refused = (...problems: string[]) => ({
+  code: 1,
+  stderr: `commit-msg: the message was refused\n${problems.map((problem) => `  - ${problem}\n`).join("")}`,
+});
+const PASSED = { code: 0, stderr: "" };
+const NEEDS_TEST = "a feat commit must include a test change (a *.test.* or *.spec.* file, or a file under e2e/)";
+
+describe("repo commit-msg scopes", () => {
+  it("takes scopes from the last segment of each workspace package name, or its folder", async () => {
+    const root = repo(
+      {
+        "package.json": JSON.stringify({ name: "mono", private: true, workspaces: ["packages/*"] }),
+        "packages/api/package.json": JSON.stringify({ name: "@acme/api" }),
+        "packages/app/package.json": "{}",
+      },
+      { "src/x.test.ts": "x\n" },
+    );
+    expect(await commitMsg(root, "feat(web): add x\n")).toEqual(
+      refused('unknown scope "web"; use a workspace package name or one of repo, deps, ci (api, app)'),
+    );
+    expect(await commitMsg(root, "feat(api): add x\n")).toEqual(PASSED);
+    expect(await commitMsg(root, "chore(deps): bump\n")).toEqual(PASSED);
+  });
+
+  it("lets a single-package repo use any kebab scope, and still needs a test for a feat", async () => {
+    const root = repo({}, { "src/x.ts": "x\n" });
+    expect(await commitMsg(root, "chore(web): x\n")).toEqual(PASSED);
+    expect(await commitMsg(root, "feat(web): x\n")).toEqual(refused(NEEDS_TEST));
+  });
+});
+
+describe("repo commit-msg size and setup", () => {
+  it("refuses an oversized commit until its message says why, at the configured limit", async () => {
+    const root = repo({}, { "src/a.ts": lines(1236), "src/a.test.ts": lines(4) });
+    expect(await commitMsg(root, "fix: handle y\n")).toEqual(refused(OVER));
+    expect(await commitMsg(root, "fix: handle y\n\nReformat from the oxfmt upgrade.\n")).toEqual(PASSED);
+    put(root, { [CONFIG_FILE]: "export default { commit: { maxChangedLines: 1500 } }\n" });
+    expect(await commitMsg(root, "fix: handle y\n")).toEqual(PASSED);
+  });
+
+  it("says how to call it, and refuses on a config it cannot read", async () => {
+    const write = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    expect(await main(["a", "b"])).toBe(1);
+    expect(write).toHaveBeenCalledWith(NAME_A_SOURCE);
+    write.mockRestore();
+    const err: string[] = [];
+    expect(await main([], { cwd: os.tmpdir(), stderr: (text) => err.push(text) })).toBe(1);
+    expect(err).toEqual([NAME_A_SOURCE]);
+    const root = repo({}, { [CONFIG_FILE]: "export default { commit: 5 }\n" });
+    expect(await commitMsg(root, "chore: x\n")).toEqual({
+      code: 1,
+      stderr: "repo commit-msg: workerstack.config.ts: commit: must be an object like { maxChangedLines: 1000 }\n",
+    });
+  });
+
+  it("checks with the defaults where there is no config", async () => {
+    const root = repo({}, { "src/a.ts": lines(1240) });
+    fs.rmSync(path.join(root, CONFIG_FILE));
+    expect(await commitMsg(root, "chore: x\n")).toEqual(refused(OVER));
+  });
+});
+
+it("repo commit-msg refuses on a package.json it cannot read, naming it", async () => {
+  const root = repo({}, { "package.json": "{ nope" });
+  const result = await commitMsg(root, "chore: x\n");
+  expect(result.code).toBe(1);
+  expect(result.stderr).toMatch(/^repo commit-msg: package\.json: /);
+});

package/cli/commit-msg.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { checkCommitMessage } from "./commit-msg.ts";
+import { isTestFile } from "./test-files.ts";
+
+const ok = (message: string, stagedFiles: string[] = ["src/a.test.ts"], scopes?: string[]) =>
+  checkCommitMessage(message, { stagedFiles, scopes, changedLines: 0, maxChangedLines: 1000 });
+const sized = (message: string, changedLines: number) =>
+  checkCommitMessage(message, { stagedFiles: [], changedLines, maxChangedLines: 1000 });
+const OVER = "the commit changes 1240 lines, over the limit of 1000; add a body line saying why, or split it";
+
+describe("checkCommitMessage", () => {
+  it("accepts every listed type", () => {
+    for (const type of ["feat", "fix", "perf", "refactor", "test", "docs", "build", "ci", "chore", "revert"]) {
+      expect(ok(`${type}: do the thing`)).toEqual([]);
+    }
+  });
+
+  it("accepts a scope and a breaking marker", () => {
+    expect(ok("feat(paths)!: drop the old spelling")).toEqual([]);
+  });
+
+  it("rejects a header that is not type(scope)!: subject", () => {
+    expect(ok("added stuff")).toEqual([
+      'the header must be "type(scope)!: subject", e.g. "fix(paths): compare hook paths canonically"',
+    ]);
+  });
+
+  it("rejects an unknown type", () => {
+    expect(ok("feature: x")).toEqual([
+      'unknown type "feature"; use one of feat, fix, perf, refactor, test, docs, build, ci, chore, revert',
+    ]);
+  });
+
+  it("rejects a scope outside the workspace when scopes are given", () => {
+    expect(ok("chore(nope): x", [], ["backend"])).toEqual([
+      'unknown scope "nope"; use a workspace package name or one of repo, deps, ci (backend)',
+    ]);
+    expect(ok("fix(backend): x", ["a.test.ts"], ["backend"])).toEqual([]);
+    expect(ok("chore(deps): x", [], ["backend"])).toEqual([]);
+  });
+
+  it("rejects a scope that is not lowercase kebab-case", () => {
+    expect(ok("fix(Paths): x")).toEqual(['the scope "Paths" must be lowercase kebab-case']);
+  });
+
+  it("rejects a subject that is capitalised, ends in a period or makes the header too long", () => {
+    expect(ok("fix: Compare paths")).toEqual(["the subject must start lowercase"]);
+    expect(ok("fix: compare paths.")).toEqual(["the subject must not end with a period"]);
+    expect(ok(`fix: ${"a".repeat(96)}`)).toEqual(["the header is 101 characters; keep it to 100"]);
+  });
+
+  it("needs a test change for feat and fix", () => {
+    expect(ok("feat: x", ["src/a.ts"])).toEqual([
+      "a feat commit must include a test change (a *.test.* or *.spec.* file, or a file under e2e/)",
+    ]);
+    expect(ok("fix: x", [])).toEqual([
+      "a fix commit must include a test change (a *.test.* or *.spec.* file, or a file under e2e/)",
+    ]);
+    expect(ok("docs: x", [])).toEqual([]);
+  });
+
+  it("treats a BREAKING CHANGE footer like a breaking marker", () => {
+    expect(ok("refactor: x\n\nBREAKING CHANGE: gone", [])).toEqual([]);
+  });
+
+  it("ignores git's comment lines and leading blank lines", () => {
+    expect(ok("\n# Please enter the commit message\nchore: x\n# On branch main", [])).toEqual([]);
+  });
+
+  it("rejects an empty message", () => {
+    expect(ok("# only comments\n", [])).toEqual(["the commit message is empty"]);
+  });
+
+  it("lets git's own merge commits through", () => {
+    expect(ok("Merge branch 'x' into main", [])).toEqual([]);
+  });
+});
+
+describe("isTestFile", () => {
+  it("knows test files", () => {
+    expect(isTestFile("cli/a.test.ts")).toBe(true);
+    expect(isTestFile("src/a.spec.tsx")).toBe(true);
+    expect(isTestFile("e2e/run.ts")).toBe(true);
+    expect(isTestFile("packages/x/e2e/run.ts")).toBe(true);
+    expect(isTestFile("src/attest.ts")).toBe(false);
+  });
+});
+
+describe("the commit size limit", () => {
+  it("refuses a commit over the limit with no body, and takes a body line as the reason", () => {
+    expect(sized("chore: x", 1000)).toEqual([]);
+    expect(sized("chore: x", 1240)).toEqual([OVER]);
+    expect(sized("chore: x\n\nReformat from the oxfmt upgrade.", 1240)).toEqual([]);
+  });
+
+  it("does not take a comment or git's verbose diff as the reason", () => {
+    expect(sized("chore: x\n\n# why\n", 1240)).toEqual([OVER]);
+    const verbose = "chore: x\n# ------------------------ >8 ------------------------\ndiff --git a/x b/x\n+y\n";
+    expect(sized(verbose, 1240)).toEqual([OVER]);
+  });
+});