coverage-check 0.1.1 → 0.2.2

package/src/report.test.mts

@@ -1,159 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  collapseRanges,
-  renderFailureComment,
-  renderPassComment,
-  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_");
-  });
-});
-
-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/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/suite-store.mts

@@ -1,62 +0,0 @@
-import { mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import type { SuiteMeta } from "./types.mts";
-
-export type { SuiteMeta };
-
-export interface SuiteStore {
-  /** Returns all suite names currently in the store. */
-  list(): Promise<string[]>;
-  /** Returns the merged LCOV bytes for a suite, or null if absent. */
-  get(suite: string): Promise<Buffer | null>;
-  /** Stores the merged LCOV bytes for a suite, with optional metadata. */
-  put(suite: string, lcov: Buffer, meta?: SuiteMeta): Promise<void>;
-}
-
-/**
- * Filesystem-backed SuiteStore.
- *
- * Layout:
- *   <root>/<suite>/lcov.info    — merged LCOV text
- *   <root>/<suite>/meta.json   — { sha?, ref?, timestamp }
- *
- * Transport is the caller's responsibility (e.g. git orphan branch, S3 sync,
- * GitHub Actions cache). This class only reads/writes local files.
- */
-export class FileSystemSuiteStore implements SuiteStore {
-  private readonly root: string;
-  constructor(root: string) {
-    this.root = root;
-  }
-
-  async list(): Promise<string[]> {
-    try {
-      return readdirSync(this.root, { withFileTypes: true })
-        .filter((e) => e.isDirectory())
-        .map((e) => e.name);
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code === "ENOENT") return [];
-      throw err;
-    }
-  }
-
-  async get(suite: string): Promise<Buffer | null> {
-    const path = join(this.root, suite, "lcov.info");
-    try {
-      return readFileSync(path);
-    } catch (err) {
-      if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
-      throw err;
-    }
-  }
-
-  async put(suite: string, lcov: Buffer, meta: SuiteMeta = {}): Promise<void> {
-    const dir = join(this.root, suite);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "lcov.info"), lcov);
-    writeFileSync(
-      join(dir, "meta.json"),
-      JSON.stringify({ ...meta, timestamp: meta.timestamp ?? new Date().toISOString() }, null, 2),
-    );
-  }
-}

package/src/suite-store.test.mts

@@ -1,115 +0,0 @@
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { FileSystemSuiteStore } from "./suite-store.mts";
-
-describe("FileSystemSuiteStore", () => {
-  let tmpDir: string;
-  let store: FileSystemSuiteStore;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "suite-store-"));
-    store = new FileSystemSuiteStore(tmpDir);
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  describe("list()", () => {
-    it("returns empty array when store root does not exist", async () => {
-      const missing = new FileSystemSuiteStore(join(tmpDir, "nonexistent"));
-      expect(await missing.list()).toEqual([]);
-    });
-
-    it("returns empty array for an empty store", async () => {
-      expect(await store.list()).toEqual([]);
-    });
-
-    it("returns suite names after putting suites", async () => {
-      await store.put("backend", Buffer.from("SF:foo\nend_of_record\n"));
-      await store.put("frontend", Buffer.from("SF:bar\nend_of_record\n"));
-      const suites = await store.list();
-      expect(suites).toContain("backend");
-      expect(suites).toContain("frontend");
-      expect(suites).toHaveLength(2);
-    });
-
-    it("ignores non-directory entries in the root", async () => {
-      await store.put("backend", Buffer.from("SF:foo\nend_of_record\n"));
-      // The lcov.info inside backend dir should not appear as a suite
-      const suites = await store.list();
-      expect(suites).not.toContain("lcov.info");
-      expect(suites).not.toContain("meta.json");
-    });
-
-    it("rethrows non-ENOENT errors", async () => {
-      const badStore = new FileSystemSuiteStore("\0invalid");
-      await expect(badStore.list()).rejects.toThrow();
-    });
-  });
-
-  describe("get()", () => {
-    it("returns null for a missing suite", async () => {
-      expect(await store.get("nonexistent")).toBeNull();
-    });
-
-    it("returns the LCOV buffer after put()", async () => {
-      const lcov = Buffer.from("SF:backend/foo.mts\nDA:1,1\nend_of_record\n");
-      await store.put("backend", lcov);
-      const result = await store.get("backend");
-      expect(result).not.toBeNull();
-      expect(result!.toString()).toBe(lcov.toString());
-    });
-
-    it("rethrows non-ENOENT errors from readFileSync", async () => {
-      const badStore = new FileSystemSuiteStore("\0invalid");
-      await expect(badStore.get("suite")).rejects.toThrow();
-    });
-  });
-
-  describe("put()", () => {
-    it("writes lcov.info and meta.json", async () => {
-      const lcov = Buffer.from("SF:foo.mts\nDA:1,5\nend_of_record\n");
-      await store.put("backend", lcov, { sha: "abc123", ref: "refs/heads/main" });
-
-      const lcovPath = join(tmpDir, "backend", "lcov.info");
-      const metaPath = join(tmpDir, "backend", "meta.json");
-      expect(readFileSync(lcovPath).toString()).toBe(lcov.toString());
-
-      const meta = JSON.parse(readFileSync(metaPath, "utf8"));
-      expect(meta.sha).toBe("abc123");
-      expect(meta.ref).toBe("refs/heads/main");
-      expect(typeof meta.timestamp).toBe("string");
-    });
-
-    it("uses the provided timestamp in meta.json", async () => {
-      await store.put("backend", Buffer.from(""), { timestamp: "2026-01-01T00:00:00.000Z" });
-      const meta = JSON.parse(readFileSync(join(tmpDir, "backend", "meta.json"), "utf8"));
-      expect(meta.timestamp).toBe("2026-01-01T00:00:00.000Z");
-    });
-
-    it("creates a default timestamp when none is provided", async () => {
-      const before = new Date().toISOString();
-      await store.put("backend", Buffer.from(""));
-      const meta = JSON.parse(readFileSync(join(tmpDir, "backend", "meta.json"), "utf8"));
-      const after = new Date().toISOString();
-      expect(meta.timestamp >= before).toBe(true);
-      expect(meta.timestamp <= after).toBe(true);
-    });
-
-    it("creates parent directories recursively", async () => {
-      const nested = new FileSystemSuiteStore(join(tmpDir, "deep", "nested", "store"));
-      await nested.put("backend", Buffer.from("SF:foo\nend_of_record\n"));
-      expect(await nested.list()).toContain("backend");
-    });
-
-    it("overwrites an existing suite", async () => {
-      await store.put("backend", Buffer.from("v1"));
-      await store.put("backend", Buffer.from("v2"));
-      const result = await store.get("backend");
-      expect(result!.toString()).toBe("v2");
-    });
-  });
-});

package/src/types.mts

@@ -1,43 +0,0 @@
-export type CoverageRule = {
-  paths: string;
-  patch_coverage_min: number;
-};
-
-export type CoverageRules = {
-  rules: CoverageRule[];
-};
-
-/** Map from repo-root-relative file path to map of line number → hit count. */
-export type LcovData = Map<string, Map<number, number>>;
-
-/** Map from repo-root-relative file path to set of added/modified line numbers. */
-export type DiffLines = Map<string, Set<number>>;
-
-export type FileCoverageResult = {
-  file: string;
-  coverable: number;
-  hit: number;
-  uncoveredLines: number[];
-  rule: string | null;
-};
-
-export type BucketResult = {
-  rule: string;
-  threshold: number;
-  coverable: number;
-  hit: number;
-  files: FileCoverageResult[];
-  passed: boolean;
-};
-
-export type CoverageCheckResult = {
-  buckets: BucketResult[];
-  informational: FileCoverageResult[];
-  passed: boolean;
-};
-
-export type SuiteMeta = {
-  sha?: string;
-  ref?: string;
-  timestamp?: string;
-};