coverage-check 0.1.1 → 0.2.1

package/src/commands/check.test.mts

@@ -30,6 +30,38 @@ describe("main argument validation", () => {
   it("returns exit code 2 when a flag is missing its value", async () => {
     expect(await main(["--rules"])).toBe(2);
   });
+
+  it("returns exit code 2 when a flag token follows as the value (e.g. --rules --pr)", async () => {
+    expect(await main(["--rules", "--pr"])).toBe(2);
+  });
+
+  it("returns exit code 2 when --pr is set but repo is empty", async () => {
+    const saved = process.env["GITHUB_REPOSITORY"];
+    delete process.env["GITHUB_REPOSITORY"];
+    try {
+      expect(await main(["--pr", "42"])).toBe(2);
+    } finally {
+      if (saved !== undefined) process.env["GITHUB_REPOSITORY"] = saved;
+      else delete process.env["GITHUB_REPOSITORY"];
+    }
+  });
+
+  it("uses fallback defaults when GITHUB_REPOSITORY/REF_NAME/STEP_SUMMARY are unset", async () => {
+    const saved: Record<string, string | undefined> = {};
+    for (const key of ["GITHUB_REPOSITORY", "GITHUB_REF_NAME", "GITHUB_STEP_SUMMARY"]) {
+      saved[key] = process.env[key];
+      delete process.env[key];
+    }
+    try {
+      // Any call exercises the default-init lines; unknown flag triggers parse error
+      expect(await main(["--unknown-flag"])).toBe(2);
+    } finally {
+      for (const [k, v] of Object.entries(saved)) {
+        if (v !== undefined) process.env[k] = v;
+        else delete process.env[k];
+      }
+    }
+  });
 });
 
 describe("main integration", () => {
@@ -96,6 +128,47 @@ describe("main integration", () => {
     ).toBe(2);
   });
 
+  it("accepts --branch flag", async () => {
+    expect(
+      await main([
+        "--rules",
+        join(tmpDir, "nonexistent.yml"),
+        "--branch",
+        "main",
+        "--artifacts",
+        artifactsDir,
+      ]),
+    ).toBe(2);
+  });
+
+  it("returns 2 when both --store-fs and --store-s3 are provided", async () => {
+    expect(
+      await main([
+        "--rules",
+        join(tmpDir, "nonexistent.yml"),
+        "--artifacts",
+        artifactsDir,
+        "--store-fs",
+        "/tmp/store",
+        "--store-s3",
+        "my-bucket",
+      ]),
+    ).toBe(2);
+  });
+
+  it("accepts --store-s3 flag (parse succeeds, fails on missing rules)", async () => {
+    expect(
+      await main([
+        "--rules",
+        join(tmpDir, "nonexistent.yml"),
+        "--artifacts",
+        artifactsDir,
+        "--store-s3",
+        "my-bucket/prefix",
+      ]),
+    ).toBe(2);
+  });
+
   it("returns 0 when no coverage data found — skips git entirely", async () => {
     expect(await main(["--rules", rulesPath, "--artifacts", artifactsDir])).toBe(0);
   });
@@ -160,7 +233,6 @@ describe("runCheck with suite store", () => {
     writeFileSync(rulesPath, "rules:\n  - paths: backend/**\n    patch_coverage_min: 90\n");
     store = new FileSystemSuiteStore(storeDir);
 
-    // Set up a minimal git repo so HEAD is valid for diff tests
     const repoDir = join(tmpDir, "repo");
     mkdirSync(join(repoDir, "backend"), { recursive: true });
 
@@ -219,7 +291,10 @@ describe("runCheck with suite store", () => {
   });
 
   it("returns 0 when store has suites but diff is empty (base=head)", async () => {
-    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"));
+    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
     expect(
       await runCheck({
         rules: rulesPath,
@@ -237,15 +312,18 @@ describe("runCheck with suite store", () => {
   });
 
   it("excludes the current suite from the store during check", async () => {
-    // Store has "backend" suite with coverage; current artifacts is empty
-    // With --suite=backend, the stored backend coverage should be excluded
-    await store.put("backend", Buffer.from("SF:backend/foo.mts\nDA:1,1\nend_of_record\n"));
-    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"));
-
+    await store.put("backend", Buffer.from("SF:backend/foo.mts\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
+    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
     expect(
       await runCheck({
         rules: rulesPath,
-        artifacts: artifactsDir, // empty
+        artifacts: artifactsDir,
         base: "HEAD",
         head: "HEAD",
         pr: null,
@@ -253,16 +331,17 @@ describe("runCheck with suite store", () => {
         json: null,
         stripPrefixes: [],
         store,
-        suite: "backend", // excludes the stored backend suite
+        suite: "backend",
       }),
     ).toBe(0);
   });
 
   it("includes non-current suites from the store", async () => {
-    // Put a "frontend" suite in the store; artifacts has backend coverage
-    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"));
+    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
     writeFileSync(join(artifactsDir, "lcov.info"), "SF:backend/foo.mts\nDA:1,1\nend_of_record\n");
-    // With suite=backend, frontend from store should still be merged
     expect(
       await runCheck({
         rules: rulesPath,
@@ -280,17 +359,19 @@ describe("runCheck with suite store", () => {
   });
 
   it("handles a store that returns null from get() gracefully", async () => {
-    // Custom store: list returns a suite, but get returns null (e.g. file was deleted)
     const nullStore = {
       async list() {
         return ["backend"];
       },
-      async get(_suite: string) {
+      async get(_suite: string, _opts?: { sha?: string; branch?: string }) {
         return null;
       },
-      async put() {},
+      async put(
+        _suite: string,
+        _lcov: Buffer,
+        _meta: { sha: string; branch: string },
+      ): Promise<void> {},
     };
-    // No local artifacts + store returns null → no reports → return 0
     expect(
       await runCheck({
         rules: rulesPath,
@@ -308,7 +389,10 @@ describe("runCheck with suite store", () => {
   });
 
   it("constructs a real runUrl when GITHUB_SERVER_URL and GITHUB_RUN_ID are set", async () => {
-    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"));
+    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
 
     const calls: string[][] = [];
     const gh = async (args: string[]) => {
@@ -322,7 +406,6 @@ describe("runCheck with suite store", () => {
     process.env["GITHUB_RUN_ID"] = "12345";
 
     try {
-      // With frontend from store and empty diff (HEAD=HEAD), passes
       await runCheck({
         rules: rulesPath,
         artifacts: artifactsDir,
@@ -336,7 +419,6 @@ describe("runCheck with suite store", () => {
         suite: null,
         gh,
       });
-      // gh was called (lookup for existing comment)
       expect(calls.length).toBeGreaterThanOrEqual(1);
     } finally {
       if (origServer === undefined) delete process.env["GITHUB_SERVER_URL"];
@@ -347,7 +429,6 @@ describe("runCheck with suite store", () => {
   });
 
   it("accepts --store and --suite flags via main()", async () => {
-    // --store and --suite valid flags, no lcov → returns 0
     expect(
       await main([
         "--rules",
@@ -361,6 +442,21 @@ describe("runCheck with suite store", () => {
       ]),
     ).toBe(0);
   });
+
+  it("accepts --store-fs flag as alias for --store", async () => {
+    expect(
+      await main([
+        "--rules",
+        rulesPath,
+        "--artifacts",
+        artifactsDir,
+        "--store-fs",
+        storeDir,
+        "--suite",
+        "backend",
+      ]),
+    ).toBe(0);
+  });
 });
 
 describe("with a real git repo and a known diff", () => {
@@ -527,7 +623,6 @@ describe("with a real git repo and a known diff", () => {
       gh,
     });
     expect(result).toBe(1);
-    // gh was called: first to look up existing comment, then to post
     expect(calls.length).toBeGreaterThanOrEqual(1);
   });
 
@@ -580,7 +675,6 @@ describe("with a real git repo and a known diff", () => {
       suite: null,
       gh,
     });
-    // Still returns 1 even though gh call failed
     expect(result).toBe(1);
   });
 
@@ -615,10 +709,11 @@ describe("with a real git repo and a known diff", () => {
     mkdirSync(storeDir);
     const store = new FileSystemSuiteStore(storeDir);
 
-    // Store has frontend coverage (unrelated to the diff)
-    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"));
+    await store.put("frontend", Buffer.from("SF:web/app.tsx\nDA:1,1\nend_of_record\n"), {
+      sha: "test-sha",
+      branch: "main",
+    });
 
-    // Current artifacts has backend coverage (line 2 now covered)
     writeFileSync(
       join(artifactsDir, "lcov.info"),
       "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
@@ -639,4 +734,137 @@ describe("with a real git repo and a known diff", () => {
       }),
     ).toBe(0);
   });
+
+  it("writes step summary when summaryFile is provided", async () => {
+    const summaryFile = join(tmpDir, "summary.md");
+    writeFileSync(summaryFile, "");
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
+    );
+    await runCheck({
+      rules: rulesPath,
+      artifacts: artifactsDir,
+      base: baseSha,
+      head: headSha,
+      pr: null,
+      repo: "",
+      json: null,
+      stripPrefixes: [],
+      store: null,
+      suite: "backend",
+      summaryFile,
+    });
+    const content = readFileSync(summaryFile, "utf8");
+    expect(content).toContain("Coverage summary");
+  });
+
+  it("does not write step summary when summaryFile is null even if env var is set", async () => {
+    const summaryFile = join(tmpDir, "should-not-exist.md");
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
+    );
+    const origEnv = process.env["GITHUB_STEP_SUMMARY"];
+    process.env["GITHUB_STEP_SUMMARY"] = summaryFile;
+    try {
+      await runCheck({
+        rules: rulesPath,
+        artifacts: artifactsDir,
+        base: baseSha,
+        head: headSha,
+        pr: null,
+        repo: "",
+        json: null,
+        stripPrefixes: [],
+        store: null,
+        suite: "backend",
+        summaryFile: null,
+      });
+    } finally {
+      if (origEnv === undefined) delete process.env["GITHUB_STEP_SUMMARY"];
+      else process.env["GITHUB_STEP_SUMMARY"] = origEnv;
+    }
+    expect(() => readFileSync(summaryFile, "utf8")).toThrow();
+  });
+
+  it("uses N/A runUrl when GITHUB_SERVER_URL and GITHUB_RUN_ID are unset", async () => {
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
+    );
+    const savedServer = process.env["GITHUB_SERVER_URL"];
+    const savedRunId = process.env["GITHUB_RUN_ID"];
+    delete process.env["GITHUB_SERVER_URL"];
+    delete process.env["GITHUB_RUN_ID"];
+    try {
+      await runCheck({
+        rules: rulesPath,
+        artifacts: artifactsDir,
+        base: baseSha,
+        head: headSha,
+        pr: null,
+        repo: "",
+        json: null,
+        stripPrefixes: [],
+        store: null,
+        suite: "backend",
+      });
+    } finally {
+      if (savedServer !== undefined) process.env["GITHUB_SERVER_URL"] = savedServer;
+      else delete process.env["GITHUB_SERVER_URL"];
+      if (savedRunId !== undefined) process.env["GITHUB_RUN_ID"] = savedRunId;
+      else delete process.env["GITHUB_RUN_ID"];
+    }
+  });
+
+  it("returns 2 when writeSummary throws (unwritable summaryFile path)", async () => {
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
+    );
+    // Pass the tmp directory itself as summaryFile — appendFileSync on a dir throws EISDIR
+    expect(
+      await runCheck({
+        rules: rulesPath,
+        artifacts: artifactsDir,
+        base: baseSha,
+        head: headSha,
+        pr: null,
+        repo: "",
+        json: null,
+        stripPrefixes: [],
+        store: null,
+        suite: "backend",
+        summaryFile: tmpDir,
+      }),
+    ).toBe(2);
+  });
+
+  it("does not write summary when summaryFile is undefined and GITHUB_STEP_SUMMARY is unset", async () => {
+    writeFileSync(
+      join(artifactsDir, "lcov.info"),
+      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
+    );
+    const savedSummary = process.env["GITHUB_STEP_SUMMARY"];
+    delete process.env["GITHUB_STEP_SUMMARY"];
+    try {
+      await runCheck({
+        rules: rulesPath,
+        artifacts: artifactsDir,
+        base: baseSha,
+        head: headSha,
+        pr: null,
+        repo: "",
+        json: null,
+        stripPrefixes: [],
+        store: null,
+        suite: "backend",
+        summaryFile: undefined,
+      });
+    } finally {
+      if (savedSummary !== undefined) process.env["GITHUB_STEP_SUMMARY"] = savedSummary;
+      else delete process.env["GITHUB_STEP_SUMMARY"];
+    }
+  });
 });

package/src/commands/store-put.mts

@@ -2,35 +2,40 @@ import { readFileSync } from "node:fs";
 import { parseLcov } from "../lcov-parser.mts";
 import { mergeLcov, toLcov } from "../lcov-merge.mts";
 import { collectLcovFiles, buildStripPrefixes } from "../load-artifacts.mts";
-import { FileSystemSuiteStore } from "../suite-store.mts";
+import { makeStore } from "../store-factory.mts";
+import { assertSafePathComponent } from "../suite-store.mts";
+import type { SuiteStore } from "../suite-store.mts";
 
 const stdout = (msg: string) => process.stdout.write(`${msg}\n`);
 const stderr = (msg: string) => process.stderr.write(`${msg}\n`);
 
 export type StorePutArgs = {
   suite: string;
-  store: string;
+  store: SuiteStore;
   artifacts: string;
   stripPrefixes: string[];
-  sha: string | null;
-  ref: string | null;
+  sha: string;
+  branch: string;
 };
 
 function parseArgs(argv: string[]): StorePutArgs {
-  const args: StorePutArgs = {
+  let storeFs: string | null = null;
+  let storeS3: string | null = null;
+  const args = {
     suite: "",
-    store: "",
     artifacts: "./coverage-artifacts",
-    stripPrefixes: [],
-    sha: null,
-    ref: null,
+    stripPrefixes: [] as string[],
+    sha: "",
+    branch: "",
   };
 
   for (let i = 0; i < argv.length; i++) {
     const flag = argv[i]!;
     const next = argv[i + 1];
     const val = (): string => {
-      if (next === undefined) throw new Error(`${flag} requires a value`);
+      if (next === undefined || next.startsWith("--")) {
+        throw new Error(`${flag} requires a value`);
+      }
       i++;
       return next;
     };
@@ -39,7 +44,11 @@ function parseArgs(argv: string[]): StorePutArgs {
         args.suite = val();
         break;
       case "--store":
-        args.store = val();
+      case "--store-fs":
+        storeFs = val();
+        break;
+      case "--store-s3":
+        storeS3 = val();
         break;
       case "--artifacts":
         args.artifacts = val();
@@ -50,8 +59,8 @@ function parseArgs(argv: string[]): StorePutArgs {
       case "--sha":
         args.sha = val();
         break;
-      case "--ref":
-        args.ref = val();
+      case "--branch":
+        args.branch = val();
         break;
       default:
         throw new Error(`unknown flag: ${flag}`);
@@ -59,8 +68,16 @@ function parseArgs(argv: string[]): StorePutArgs {
   }
 
   if (!args.suite) throw new Error("--suite is required");
-  if (!args.store) throw new Error("--store is required");
-  return args;
+  if (storeFs && storeS3) throw new Error("--store-fs and --store-s3 are mutually exclusive");
+  if (!storeFs && !storeS3) throw new Error("--store-fs/--store or --store-s3 is required");
+  if (!args.sha) throw new Error("--sha is required");
+  if (!args.branch) throw new Error("--branch is required");
+  assertSafePathComponent(args.suite, "suite");
+  assertSafePathComponent(args.sha, "sha");
+  assertSafePathComponent(args.branch, "branch");
+
+  const store = makeStore({ fs: storeFs, s3: storeS3 })!;
+  return { ...args, store };
 }
 
 export async function main(argv: string[]): Promise<number> {
@@ -68,8 +85,7 @@ export async function main(argv: string[]): Promise<number> {
   try {
     args = parseArgs(argv);
   } catch (err) {
-    /* c8 ignore next */
-    stderr(`coverage-check store-put: ${err instanceof Error ? err.message : err}`);
+    stderr(`coverage-check store-put: ${String(err)}`);
     return 2;
   }
   return runStorePut(args);
@@ -87,14 +103,13 @@ export async function runStorePut(args: StorePutArgs): Promise<number> {
   const merged = mergeLcov(reports);
   const lcovText = toLcov(merged);
 
-  const store = new FileSystemSuiteStore(args.store);
-  await store.put(args.suite, Buffer.from(lcovText, "utf8"), {
-    sha: args.sha ?? undefined,
-    ref: args.ref ?? undefined,
+  await args.store.put(args.suite, Buffer.from(lcovText, "utf8"), {
+    sha: args.sha,
+    branch: args.branch,
   });
 
   stdout(
-    `coverage-check store-put: stored suite "${args.suite}" (${lcovFiles.length} file(s)) → ${args.store}`,
+    `coverage-check store-put: stored suite "${args.suite}" (${lcovFiles.length} file(s)) sha=${args.sha} branch=${args.branch}`,
   );
   return 0;
 }