coverage-check 0.1.1 → 0.2.1

package/src/commands/store-put.test.mts

@@ -1,21 +1,91 @@
 import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { main, runStorePut } from "./store-put.mts";
 import { FileSystemSuiteStore } from "../suite-store.mts";
 
 describe("main argument parsing", () => {
   it("returns 2 when --suite is missing", async () => {
-    expect(await main(["--store", "/tmp/store"])).toBe(2);
+    expect(await main(["--store", "/tmp/store", "--sha", "abc", "--branch", "main"])).toBe(2);
   });
 
   it("returns 2 when --store is missing", async () => {
-    expect(await main(["--suite", "backend"])).toBe(2);
+    expect(await main(["--suite", "backend", "--sha", "abc", "--branch", "main"])).toBe(2);
+  });
+
+  it("returns 2 when --sha is missing", async () => {
+    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--branch", "main"])).toBe(2);
+  });
+
+  it("returns 2 when --branch is missing", async () => {
+    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--sha", "abc"])).toBe(2);
+  });
+
+  it("returns 2 when a flag token follows as the value (e.g. --suite --store)", async () => {
+    expect(await main(["--suite", "--store"])).toBe(2);
+  });
+
+  it("accepts --store-s3 flag (returns 2 when no lcov files, not unknown-flag error)", async () => {
+    const chunks: string[] = [];
+    vi.spyOn(process.stderr, "write").mockImplementation((c: unknown) => {
+      chunks.push(String(c));
+      return true;
+    });
+    try {
+      expect(
+        await main([
+          "--suite",
+          "backend",
+          "--store-s3",
+          "my-bucket/prefix",
+          "--sha",
+          "abc",
+          "--branch",
+          "main",
+          "--artifacts",
+          "/tmp/__nonexistent_dir__",
+        ]),
+      ).toBe(2);
+      const stderr = chunks.join("");
+      expect(stderr).toContain("no lcov.info files found");
+      expect(stderr).not.toContain("unknown flag");
+    } finally {
+      vi.restoreAllMocks();
+    }
+  });
+
+  it("returns 2 when both --store-fs and --store-s3 are provided", async () => {
+    expect(
+      await main([
+        "--suite",
+        "backend",
+        "--store-fs",
+        "/tmp/s",
+        "--store-s3",
+        "bucket",
+        "--sha",
+        "abc",
+        "--branch",
+        "main",
+      ]),
+    ).toBe(2);
   });
 
   it("returns 2 on unknown flag", async () => {
-    expect(await main(["--suite", "backend", "--store", "/tmp/s", "--unknown"])).toBe(2);
+    expect(
+      await main([
+        "--suite",
+        "backend",
+        "--store",
+        "/tmp/s",
+        "--sha",
+        "abc",
+        "--branch",
+        "main",
+        "--unknown",
+      ]),
+    ).toBe(2);
   });
 
   it("returns 2 when a flag is missing its value", async () => {
@@ -27,6 +97,7 @@ describe("runStorePut", () => {
   let tmpDir: string;
   let artifactsDir: string;
   let storeDir: string;
+  let store: FileSystemSuiteStore;
 
   beforeEach(() => {
     tmpDir = mkdtempSync(join(tmpdir(), "store-put-test-"));
@@ -34,6 +105,7 @@ describe("runStorePut", () => {
     storeDir = join(tmpDir, "store");
     mkdirSync(artifactsDir);
     mkdirSync(storeDir);
+    store = new FileSystemSuiteStore(storeDir);
   });
 
   afterEach(() => {
@@ -44,11 +116,11 @@ describe("runStorePut", () => {
     expect(
       await runStorePut({
         suite: "backend",
-        store: storeDir,
+        store,
         artifacts: artifactsDir,
         stripPrefixes: [],
-        sha: null,
-        ref: null,
+        sha: "abc123",
+        branch: "main",
       }),
     ).toBe(2);
   });
@@ -62,19 +134,18 @@ describe("runStorePut", () => {
     expect(
       await runStorePut({
         suite: "backend",
-        store: storeDir,
+        store,
         artifacts: artifactsDir,
         stripPrefixes: [],
         sha: "abc123",
-        ref: "refs/heads/main",
+        branch: "main",
       }),
     ).toBe(0);
 
-    const store = new FileSystemSuiteStore(storeDir);
     const suites = await store.list();
     expect(suites).toContain("backend");
 
-    const buf = await store.get("backend");
+    const buf = await store.get("backend", { branch: "main" });
     expect(buf).not.toBeNull();
     const lcovText = buf!.toString();
     expect(lcovText).toContain("SF:backend/foo.mts");
@@ -90,22 +161,21 @@ describe("runStorePut", () => {
     expect(
       await runStorePut({
         suite: "backend",
-        store: storeDir,
+        store,
         artifacts: artifactsDir,
         stripPrefixes: [],
-        sha: null,
-        ref: null,
+        sha: "abc123",
+        branch: "main",
       }),
     ).toBe(0);
 
-    const store = new FileSystemSuiteStore(storeDir);
-    const buf = await store.get("backend");
+    const buf = await store.get("backend", { branch: "main" });
     const lcovText = buf!.toString();
     expect(lcovText).toContain("SF:backend/a.mts");
     expect(lcovText).toContain("SF:backend/b.mts");
   });
 
-  it("accepts --strip-prefix flag", async () => {
+  it("accepts --strip-prefix flag via main()", async () => {
     writeFileSync(
       join(artifactsDir, "lcov.info"),
       "SF:/home/runner/work/repo/backend/foo.mts\nDA:1,1\nend_of_record\n",
@@ -121,15 +191,39 @@ describe("runStorePut", () => {
         artifactsDir,
         "--strip-prefix",
         "/home/runner/work/repo",
+        "--sha",
+        "abc123",
+        "--branch",
+        "main",
       ]),
     ).toBe(0);
 
-    const store = new FileSystemSuiteStore(storeDir);
-    const buf = await store.get("backend");
-    // After stripping the prefix, the stored lcov should have the normalized path
+    const buf = await store.get("backend", { branch: "main" });
     expect(buf!.toString()).toContain("SF:backend/foo.mts");
   });
 
+  it("--store-fs is an alias for --store", async () => {
+    writeFileSync(join(artifactsDir, "lcov.info"), "SF:web/app.tsx\nDA:10,1\nend_of_record\n");
+
+    expect(
+      await main([
+        "--suite",
+        "frontend",
+        "--store-fs",
+        storeDir,
+        "--artifacts",
+        artifactsDir,
+        "--sha",
+        "deadbeef",
+        "--branch",
+        "main",
+      ]),
+    ).toBe(0);
+
+    const stored = readFileSync(join(storeDir, "frontend", "sha", "deadbeef", "lcov.info"), "utf8");
+    expect(stored).toContain("SF:web/app.tsx");
+  });
+
   it("round-trips through main() CLI interface", async () => {
     writeFileSync(join(artifactsDir, "lcov.info"), "SF:web/app.tsx\nDA:10,1\nend_of_record\n");
 
@@ -143,12 +237,12 @@ describe("runStorePut", () => {
         artifactsDir,
         "--sha",
         "deadbeef",
-        "--ref",
-        "refs/heads/feat",
+        "--branch",
+        "main",
       ]),
     ).toBe(0);
 
-    const stored = readFileSync(join(storeDir, "frontend", "lcov.info"), "utf8");
+    const stored = readFileSync(join(storeDir, "frontend", "sha", "deadbeef", "lcov.info"), "utf8");
     expect(stored).toContain("SF:web/app.tsx");
   });
 });

package/src/coverage-check.mts

@@ -1,10 +1,12 @@
 export { runCheck } from "./commands/check.mts";
 export { runStorePut } from "./commands/store-put.mts";
 export { FileSystemSuiteStore } from "./suite-store.mts";
+export { S3SuiteStore } from "./s3-suite-store.mts";
 
 export type { CheckArgs } from "./commands/check.mts";
 export type { StorePutArgs } from "./commands/store-put.mts";
 export type { SuiteStore, SuiteMeta } from "./suite-store.mts";
+export type { S3SuiteStoreOptions } from "./s3-suite-store.mts";
 export type {
   CoverageCheckResult,
   BucketResult,

package/src/github-comment.mts

@@ -45,8 +45,8 @@ async function findExistingComment(repo: string, pr: number, gh: GhRunner): Prom
  * Posts or updates the sticky coverage-check comment on a pull request.
  *
  * - On failure: upserts the failure comment body (POST if absent, PATCH if exists).
- * - On pass: if a marker comment exists (from any prior run), replaces it with a
- *   pass body. If no marker comment exists, stays silent.
+ * - On pass with prior comment: deletes the prior comment.
+ * - On pass with no prior comment: stays silent.
  */
 export async function upsertComment(
   body: string,
@@ -57,7 +57,12 @@ export async function upsertComment(
 ): Promise<void> {
   const existingId = await findExistingComment(repo, pr, gh);
 
-  if (passed && existingId === null) return; // nothing to update
+  if (passed && existingId === null) return;
+
+  if (passed && existingId !== null) {
+    await gh(["api", `repos/${repo}/issues/comments/${existingId}`, "-X", "DELETE"]);
+    return;
+  }
 
   if (existingId !== null) {
     await gh([

package/src/github-comment.test.mts

@@ -14,7 +14,6 @@ function makeGh(responses: Record<string, string>): GhRunner & ReturnType<typeof
 }
 
 const FAIL_BODY = `${COMMENT_MARKER}\n## failed`;
-const PASS_BODY = `${COMMENT_MARKER}\n## passed`;
 
 describe("upsertComment", () => {
   it("posts a new comment on failure when none exists", async () => {
@@ -31,16 +30,16 @@ describe("upsertComment", () => {
     expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
   });
 
-  it("patches an existing failure comment to pass body", async () => {
+  it("deletes an existing comment on pass", async () => {
     const gh = makeGh({ "issues/42/comments --paginate": "99\n" });
-    await upsertComment(PASS_BODY, "owner/repo", 42, true, gh);
+    await upsertComment("", "owner/repo", 42, true, gh);
     const calls = gh.mock.calls.map((c) => c[0].join(" "));
-    expect(calls.some((c) => c.includes("comments/99") && c.includes("PATCH"))).toBe(true);
+    expect(calls.some((c) => c.includes("comments/99") && c.includes("DELETE"))).toBe(true);
   });
 
   it("does nothing on pass when no prior comment exists", async () => {
     const gh = makeGh({ "issues/42/comments --paginate": "" });
-    await upsertComment(PASS_BODY, "owner/repo", 42, true, gh);
+    await upsertComment("", "owner/repo", 42, true, gh);
     expect(gh.mock.calls.length).toBe(1);
   });
 

package/src/report.mts

@@ -76,12 +76,3 @@ ${informationalSection}
 
 _Last updated: ${now} · [Workflow run](${runUrl})_`;
 }
-
-export function renderPassComment(runUrl: string, now: string = new Date().toISOString()): string {
-  return `${COMMENT_MARKER}
-## Patch coverage gate passed
-
-All workspace patch-coverage rules met.
-
-_Last updated: ${now} · [Workflow run](${runUrl})_`;
-}

package/src/report.test.mts

@@ -1,10 +1,5 @@
 import { describe, expect, it } from "vitest";
-import {
-  collapseRanges,
-  renderFailureComment,
-  renderPassComment,
-  COMMENT_MARKER,
-} from "./report.mts";
+import { collapseRanges, renderFailureComment, COMMENT_MARKER } from "./report.mts";
 import type { CoverageCheckResult } from "./types.mts";
 
 describe("collapseRanges", () => {
@@ -145,15 +140,3 @@ describe("renderFailureComment", () => {
     expect(comment).toContain("_No line-level data available_");
   });
 });
-
-describe("renderPassComment", () => {
-  it("includes the marker", () => {
-    const comment = renderPassComment("https://example.com/run/1", "2026-01-01T00:00:00.000Z");
-    expect(comment.startsWith(COMMENT_MARKER)).toBe(true);
-  });
-
-  it("says passed", () => {
-    const comment = renderPassComment("https://example.com/run/1", "2026-01-01T00:00:00.000Z");
-    expect(comment).toContain("passed");
-  });
-});

package/src/s3-suite-store.mts

@@ -0,0 +1,138 @@
+import { buffer } from "node:stream/consumers";
+import { Readable } from "node:stream";
+import {
+  GetObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { assertSafePathComponent } from "./suite-store.mts";
+import type { SuiteMeta, SuiteStore } from "./suite-store.mts";
+
+type ClientLike = { send(cmd: object): Promise<unknown> };
+
+export type S3SuiteStoreOptions = {
+  bucket: string;
+  prefix?: string;
+  region?: string;
+  /** Inject a custom S3 client (e.g. for testing). */
+  client?: ClientLike;
+};
+
+export class S3SuiteStore implements SuiteStore {
+  private readonly bucket: string;
+  private readonly prefix: string;
+  private readonly client: ClientLike;
+
+  constructor({ bucket, prefix, region, client }: S3SuiteStoreOptions) {
+    this.bucket = bucket;
+    this.prefix = prefix ? prefix.replace(/\/+$/, "") : "";
+    this.client = client ?? new S3Client({ region });
+  }
+
+  private key(...parts: string[]): string {
+    return this.prefix ? [this.prefix, ...parts].join("/") : parts.join("/");
+  }
+
+  async list(): Promise<string[]> {
+    const pfx = this.prefix ? `${this.prefix}/` : "";
+    const suites: string[] = [];
+    let continuationToken: string | undefined;
+    do {
+      const resp = (await this.client.send(
+        new ListObjectsV2Command({
+          Bucket: this.bucket,
+          Prefix: pfx,
+          Delimiter: "/",
+          ...(continuationToken ? { ContinuationToken: continuationToken } : {}),
+        }),
+      )) as {
+        CommonPrefixes?: { Prefix?: string }[];
+        IsTruncated?: boolean;
+        NextContinuationToken?: string;
+      };
+      suites.push(
+        ...(resp.CommonPrefixes ?? [])
+          .map((cp) => cp.Prefix?.replace(pfx, "").replace(/\/$/, "") ?? "")
+          .filter(Boolean),
+      );
+      continuationToken = resp.IsTruncated ? resp.NextContinuationToken : undefined;
+    } while (continuationToken);
+    return suites;
+  }
+
+  async get(suite: string, opts?: { sha?: string; branch?: string }): Promise<Buffer | null> {
+    assertSafePathComponent(suite, "suite");
+    if (opts?.sha !== undefined) assertSafePathComponent(opts.sha, "sha");
+    let sha = opts?.sha;
+    if (!sha) {
+      const branch = opts?.branch ?? "main";
+      assertSafePathComponent(branch, "branch");
+      try {
+        const resp = (await this.client.send(
+          new GetObjectCommand({
+            Bucket: this.bucket,
+            Key: this.key(suite, "branch", branch, "latest.json"),
+          }),
+        )) as { Body: unknown };
+        const body = await bodyToBuffer(resp.Body);
+        const parsed = (JSON.parse(body.toString("utf8")) as { sha: string }).sha;
+        assertSafePathComponent(parsed, "sha");
+        sha = parsed;
+      } catch (err) {
+        if (isNotFound(err)) return null;
+        throw err;
+      }
+    }
+    try {
+      const resp = (await this.client.send(
+        new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: this.key(suite, "sha", sha, "lcov.info"),
+        }),
+      )) as { Body: unknown };
+      return bodyToBuffer(resp.Body);
+    } catch (err) {
+      if (isNotFound(err)) return null;
+      throw err;
+    }
+  }
+
+  async put(
+    suite: string,
+    lcov: Buffer,
+    meta: SuiteMeta & { sha: string; branch: string },
+  ): Promise<void> {
+    assertSafePathComponent(suite, "suite");
+    assertSafePathComponent(meta.sha, "sha");
+    assertSafePathComponent(meta.branch, "branch");
+    const ts = meta.timestamp ?? new Date().toISOString();
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: this.key(suite, "sha", meta.sha, "lcov.info"),
+        Body: lcov,
+        ContentType: "text/plain",
+      }),
+    );
+    await this.client.send(
+      new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: this.key(suite, "branch", meta.branch, "latest.json"),
+        Body: Buffer.from(JSON.stringify({ sha: meta.sha, timestamp: ts }), "utf8"),
+        ContentType: "application/json",
+      }),
+    );
+  }
+}
+
+function isNotFound(err: unknown): boolean {
+  return err instanceof Error && (err.name === "NoSuchKey" || err.name === "NotFound");
+}
+
+async function bodyToBuffer(body: unknown): Promise<Buffer> {
+  if (body instanceof Readable) return buffer(body);
+  if (body instanceof Uint8Array) return Buffer.from(body);
+  if (body instanceof Blob) return Buffer.from(await body.arrayBuffer());
+  throw new Error("unexpected S3 response body type");
+}