coverage-check 0.2.1 → 0.2.2

package/src/patch-coverage.test.mts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { parseLcov } from "./lcov-parser.mts";
-import { parseDiff } from "./diff-parser.mts";
-import { computePatchCoverage } from "./patch-coverage.mts";
-import type { CoverageRule } from "./types.mts";
-
-const rules: CoverageRule[] = [
-  { paths: "backend/**", patch_coverage_min: 90 },
-  { paths: "web/**", patch_coverage_min: 5 },
-];
-
-describe("computePatchCoverage", () => {
-  it("passes when all changed lines are covered", () => {
-    const lcov = parseLcov(`SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n`);
-    const diff: ReturnType<typeof parseDiff> = new Map([["backend/foo.mts", new Set([1, 2])]]);
-    const { buckets } = computePatchCoverage(diff, lcov, rules);
-    const bucket = buckets.find((b) => b.rule === "backend/**")!;
-    expect(bucket.passed).toBe(true);
-    expect(bucket.hit).toBe(2);
-    expect(bucket.coverable).toBe(2);
-  });
-
-  it("fails when coverage drops below threshold", () => {
-    const lcov = parseLcov(
-      `SF:backend/foo.mts\nDA:1,1\nDA:2,1\nDA:3,1\nDA:4,1\nDA:5,1\nDA:6,1\nDA:7,1\nDA:8,1\nDA:9,0\nDA:10,0\nend_of_record\n`,
-    );
-    const diff: ReturnType<typeof parseDiff> = new Map([
-      ["backend/foo.mts", new Set([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])],
-    ]);
-    const { buckets } = computePatchCoverage(diff, lcov, rules);
-    const bucket = buckets.find((b) => b.rule === "backend/**")!;
-    expect(bucket.passed).toBe(false);
-    expect(bucket.hit).toBe(8);
-    expect(bucket.coverable).toBe(10);
-  });
-
-  it("passes vacuously when no coverable changed lines", () => {
-    const lcov = parseLcov(`SF:backend/foo.mts\nDA:1,1\nend_of_record\n`);
-    const diff: ReturnType<typeof parseDiff> = new Map([["backend/foo.mts", new Set([99])]]);
-    const { buckets } = computePatchCoverage(diff, lcov, rules);
-    const bucket = buckets.find((b) => b.rule === "backend/**");
-    expect(!bucket || bucket.passed).toBe(true);
-  });
-
-  it("skips files not in lcov", () => {
-    const lcov = parseLcov(`SF:backend/other.mts\nDA:1,1\nend_of_record\n`);
-    const diff: ReturnType<typeof parseDiff> = new Map([
-      ["backend/missing.mts", new Set([1, 2, 3])],
-    ]);
-    const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
-    expect(buckets).toHaveLength(0);
-    expect(informational).toHaveLength(0);
-  });
-
-  it("routes unmatched files to informational", () => {
-    const lcov = parseLcov(`SF:scripts/ci.mts\nDA:1,0\nend_of_record\n`);
-    const diff: ReturnType<typeof parseDiff> = new Map([["scripts/ci.mts", new Set([1])]]);
-    const { buckets, informational } = computePatchCoverage(diff, lcov, rules);
-    expect(buckets).toHaveLength(0);
-    expect(informational).toHaveLength(1);
-    expect(informational[0]?.file).toBe("scripts/ci.mts");
-  });
-
-  it("accumulates multiple files into the same bucket", () => {
-    // Two backend files → both go into the 'backend/**' bucket
-    const lcov = parseLcov(
-      `SF:backend/a.mts\nDA:1,1\nDA:2,1\nend_of_record\nSF:backend/b.mts\nDA:10,0\nDA:11,0\nend_of_record\n`,
-    );
-    const diff: ReturnType<typeof parseDiff> = new Map([
-      ["backend/a.mts", new Set([1, 2])],
-      ["backend/b.mts", new Set([10, 11])],
-    ]);
-    const { buckets } = computePatchCoverage(diff, lcov, rules);
-    const bucket = buckets.find((b) => b.rule === "backend/**")!;
-    expect(bucket.coverable).toBe(4);
-    expect(bucket.hit).toBe(2);
-    expect(bucket.files).toHaveLength(2);
-  });
-
-  it("reports uncovered lines correctly", () => {
-    const lcov = parseLcov(
-      `SF:backend/svc.mts\nDA:10,1\nDA:11,0\nDA:12,0\nDA:13,1\nend_of_record\n`,
-    );
-    const diff: ReturnType<typeof parseDiff> = new Map([
-      ["backend/svc.mts", new Set([10, 11, 12, 13])],
-    ]);
-    const { buckets } = computePatchCoverage(diff, lcov, rules);
-    const file = buckets[0]?.files[0]!;
-    expect(file.uncoveredLines).toEqual([11, 12]);
-  });
-});

package/src/report.mts

@@ -1,78 +0,0 @@
-import type { BucketResult, CoverageCheckResult, FileCoverageResult } from "./types.mts";
-
-export const COMMENT_MARKER = "<!-- coverage-check -->";
-
-export function collapseRanges(lines: number[]): string {
-  if (lines.length === 0) return "";
-  const sorted = [...lines].sort((a, b) => a - b);
-  const ranges: string[] = [];
-  let start = sorted[0]!;
-  let end = start;
-
-  for (let i = 1; i < sorted.length; i++) {
-    const n = sorted[i]!;
-    if (n === end + 1) {
-      end = n;
-    } else {
-      ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
-      start = n;
-      end = n;
-    }
-  }
-  ranges.push(start === end ? `L${start}` : `L${start}-${end}`);
-  return ranges.join(", ");
-}
-
-function pct(bucket: BucketResult): string {
-  if (bucket.coverable === 0) return "—";
-  return `${((bucket.hit / bucket.coverable) * 100).toFixed(1)}% (${bucket.hit}/${bucket.coverable})`;
-}
-
-function renderFileList(files: FileCoverageResult[]): string {
-  return files
-    .filter((f) => f.uncoveredLines.length > 0)
-    .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
-    .join("\n");
-}
-
-export function renderFailureComment(
-  result: CoverageCheckResult,
-  runUrl: string,
-  now: string = new Date().toISOString(),
-): string {
-  const failingBuckets = result.buckets.filter((b) => !b.passed);
-  const table = [
-    "| Workspace rule | Patch coverage | Threshold |",
-    "|---|---|---|",
-    ...failingBuckets.map((b) => `| \`${b.rule}\` | ${pct(b)} | ${b.threshold}% |`),
-  ].join("\n");
-
-  const sections = failingBuckets
-    .map((b) => {
-      const fileList = renderFileList(b.files);
-      return `**\`${b.rule}\`** (threshold ${b.threshold}%):\n${fileList || "_No line-level data available_"}`;
-    })
-    .join("\n\n");
-
-  const informationalLines = result.informational
-    .filter((f) => f.uncoveredLines.length > 0)
-    .map((f) => `- \`${f.file}\`: ${collapseRanges(f.uncoveredLines)}`)
-    .join("\n");
-
-  const informationalSection =
-    informationalLines.length > 0
-      ? `\n<details><summary>Informational (no rule)</summary>\n\n${informationalLines}\n</details>`
-      : "";
-
-  return `${COMMENT_MARKER}
-## Patch coverage gate failed
-
-${table}
-
-### Uncovered lines
-
-${sections}
-${informationalSection}
-
-_Last updated: ${now} · [Workflow run](${runUrl})_`;
-}

package/src/report.test.mts

@@ -1,142 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { collapseRanges, renderFailureComment, COMMENT_MARKER } from "./report.mts";
-import type { CoverageCheckResult } from "./types.mts";
-
-describe("collapseRanges", () => {
-  it("returns empty string for empty input", () => {
-    expect(collapseRanges([])).toBe("");
-  });
-
-  it("renders a single line", () => {
-    expect(collapseRanges([5])).toBe("L5");
-  });
-
-  it("collapses consecutive lines into a range", () => {
-    expect(collapseRanges([3, 4, 5])).toBe("L3-5");
-  });
-
-  it("separates non-consecutive lines with commas", () => {
-    expect(collapseRanges([3, 4, 7, 9, 10])).toBe("L3-4, L7, L9-10");
-  });
-
-  it("handles unsorted input", () => {
-    expect(collapseRanges([10, 1, 2])).toBe("L1-2, L10");
-  });
-});
-
-describe("renderFailureComment", () => {
-  const result: CoverageCheckResult = {
-    passed: false,
-    buckets: [
-      {
-        rule: "backend/**",
-        threshold: 90,
-        coverable: 10,
-        hit: 8,
-        passed: false,
-        files: [
-          {
-            file: "backend/services/foo.mts",
-            coverable: 5,
-            hit: 3,
-            uncoveredLines: [11, 12],
-            rule: "backend/**",
-          },
-        ],
-      },
-    ],
-    informational: [],
-  };
-
-  it("includes the marker", () => {
-    const comment = renderFailureComment(
-      result,
-      "https://example.com/run/1",
-      "2026-01-01T00:00:00.000Z",
-    );
-    expect(comment.startsWith(COMMENT_MARKER)).toBe(true);
-  });
-
-  it("includes failing bucket in the table", () => {
-    const comment = renderFailureComment(
-      result,
-      "https://example.com/run/1",
-      "2026-01-01T00:00:00.000Z",
-    );
-    expect(comment).toContain("backend/**");
-    expect(comment).toContain("90%");
-  });
-
-  it("includes uncovered lines", () => {
-    const comment = renderFailureComment(
-      result,
-      "https://example.com/run/1",
-      "2026-01-01T00:00:00.000Z",
-    );
-    expect(comment).toContain("backend/services/foo.mts");
-    expect(comment).toContain("L11-12");
-  });
-
-  it("renders informational section when unmatched files have uncovered lines", () => {
-    const resultWithInfo: CoverageCheckResult = {
-      ...result,
-      informational: [
-        { file: "scripts/misc.mts", coverable: 3, hit: 1, uncoveredLines: [4, 5], rule: null },
-      ],
-    };
-    const comment = renderFailureComment(
-      resultWithInfo,
-      "https://example.com/run/1",
-      "2026-01-01T00:00:00.000Z",
-    );
-    expect(comment).toContain("Informational (no rule)");
-    expect(comment).toContain("scripts/misc.mts");
-    expect(comment).toContain("L4-5");
-  });
-
-  it("renders — when bucket has no coverable lines", () => {
-    const resultNoCoverable: CoverageCheckResult = {
-      passed: false,
-      buckets: [
-        {
-          rule: "backend/**",
-          threshold: 90,
-          coverable: 0,
-          hit: 0,
-          passed: false,
-          files: [],
-        },
-      ],
-      informational: [],
-    };
-    const comment = renderFailureComment(resultNoCoverable, "N/A", "2026-01-01T00:00:00.000Z");
-    expect(comment).toContain("—");
-  });
-
-  it("renders _No line-level data available_ when bucket files have no uncovered lines", () => {
-    const resultNoLines: CoverageCheckResult = {
-      passed: false,
-      buckets: [
-        {
-          rule: "backend/**",
-          threshold: 90,
-          coverable: 5,
-          hit: 4,
-          passed: false,
-          files: [
-            {
-              file: "backend/foo.mts",
-              coverable: 5,
-              hit: 4,
-              uncoveredLines: [],
-              rule: "backend/**",
-            },
-          ],
-        },
-      ],
-      informational: [],
-    };
-    const comment = renderFailureComment(resultNoLines, "N/A", "2026-01-01T00:00:00.000Z");
-    expect(comment).toContain("_No line-level data available_");
-  });
-});

package/src/rules.mts

@@ -1,34 +0,0 @@
-/* c8 ignore next */
-import { readFileSync } from "node:fs";
-import { matchesGlob } from "node:path";
-import yaml from "js-yaml";
-import type { CoverageRule, CoverageRules } from "./types.mts";
-
-export function loadRules(rulesPath: string): CoverageRule[] {
-  const text = readFileSync(rulesPath, "utf8");
-  const parsed = yaml.load(text) as CoverageRules;
-  if (!Array.isArray(parsed?.rules)) {
-    throw new Error(`${rulesPath}: expected a 'rules' array`);
-  }
-  for (let i = 0; i < parsed.rules.length; i++) {
-    const rule = parsed.rules[i] as Partial<CoverageRule>;
-    if (typeof rule?.paths !== "string") {
-      throw new Error(`${rulesPath}: rule[${i}].paths must be a string`);
-    }
-    const min = rule.patch_coverage_min;
-    if (!Number.isFinite(min) || (min as number) < 0 || (min as number) > 100) {
-      throw new Error(
-        `${rulesPath}: rule[${i}].patch_coverage_min must be a number between 0 and 100`,
-      );
-    }
-  }
-  return parsed.rules;
-}
-
-/** Returns the first matching rule for a repo-root-relative file path, or null. */
-export function matchRule(file: string, rules: CoverageRule[]): CoverageRule | null {
-  for (const rule of rules) {
-    if (matchesGlob(file, rule.paths)) return rule;
-  }
-  return null;
-}

package/src/rules.test.mts

@@ -1,98 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { loadRules, matchRule } from "./rules.mts";
-import type { CoverageRule } from "./types.mts";
-
-const rules: CoverageRule[] = [
-  { paths: "cloudflare-worker/**", patch_coverage_min: 100 },
-  { paths: "lambdas/**", patch_coverage_min: 100 },
-  { paths: "web/lib/api/**", patch_coverage_min: 100 },
-  { paths: "backend/**", patch_coverage_min: 90 },
-  { paths: "web/**", patch_coverage_min: 5 },
-];
-
-describe("matchRule", () => {
-  it("matches cloudflare-worker files", () => {
-    expect(matchRule("cloudflare-worker/src/index.mts", rules)?.patch_coverage_min).toBe(100);
-  });
-
-  it("matches the more-specific web/lib/api/** before web/**", () => {
-    expect(matchRule("web/lib/api/client.mts", rules)?.patch_coverage_min).toBe(100);
-  });
-
-  it("matches web/** for non-api web files", () => {
-    expect(matchRule("web/components/Foo.tsx", rules)?.patch_coverage_min).toBe(5);
-  });
-
-  it("matches backend/**", () => {
-    expect(matchRule("backend/services/foo.mts", rules)?.patch_coverage_min).toBe(90);
-  });
-
-  it("returns null for unmatched paths", () => {
-    expect(matchRule("ci/ci-local.mts", rules)).toBeNull();
-    expect(matchRule("docs/README.md", rules)).toBeNull();
-  });
-
-  it("matches lambdas/**", () => {
-    expect(matchRule("lambdas/handler.mts", rules)?.patch_coverage_min).toBe(100);
-  });
-});
-
-describe("loadRules", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "coverage-check-rules-"));
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  function write(name: string, content: string) {
-    const path = join(tmpDir, name);
-    writeFileSync(path, content, "utf8");
-    return path;
-  }
-
-  it("loads a valid rules file", () => {
-    const path = write("rules.yml", "rules:\n  - paths: backend/**\n    patch_coverage_min: 90\n");
-    expect(loadRules(path)).toEqual([{ paths: "backend/**", patch_coverage_min: 90 }]);
-  });
-
-  it("throws when rules is not an array", () => {
-    const path = write("rules.yml", "rules: not-an-array\n");
-    expect(() => loadRules(path)).toThrow("expected a 'rules' array");
-  });
-
-  it("throws when a rule paths field is missing", () => {
-    const path = write("rules.yml", "rules:\n  - patch_coverage_min: 90\n");
-    expect(() => loadRules(path)).toThrow("rule[0].paths must be a string");
-  });
-
-  it("throws when patch_coverage_min is out of range", () => {
-    const path = write("rules.yml", "rules:\n  - paths: backend/**\n    patch_coverage_min: 150\n");
-    expect(() => loadRules(path)).toThrow(
-      "rule[0].patch_coverage_min must be a number between 0 and 100",
-    );
-  });
-
-  it("throws when patch_coverage_min is not a number", () => {
-    const path = write(
-      "rules.yml",
-      "rules:\n  - paths: backend/**\n    patch_coverage_min: 'high'\n",
-    );
-    expect(() => loadRules(path)).toThrow(
-      "rule[0].patch_coverage_min must be a number between 0 and 100",
-    );
-  });
-
-  it("throws when patch_coverage_min is negative", () => {
-    const path = write("rules.yml", "rules:\n  - paths: backend/**\n    patch_coverage_min: -1\n");
-    expect(() => loadRules(path)).toThrow(
-      "rule[0].patch_coverage_min must be a number between 0 and 100",
-    );
-  });
-});

package/src/s3-suite-store.mts

@@ -1,138 +0,0 @@
-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");
-}