coverage-check 0.2.1 → 0.2.2

package/src/commands/check.test.mts

@@ -1,870 +0,0 @@
-import { execSync } from "node:child_process";
-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 { main, runCheck } from "./check.mts";
-import { FileSystemSuiteStore } from "../suite-store.mts";
-
-describe("main argument validation", () => {
-  it("returns exit code 2 on unknown flags", async () => {
-    expect(await main(["--unknown-flag"])).toBe(2);
-  });
-
-  it("returns exit code 2 when --pr is not a number", async () => {
-    expect(await main(["--pr", "abc"])).toBe(2);
-  });
-
-  it("returns exit code 2 when --pr is zero", async () => {
-    expect(await main(["--pr", "0"])).toBe(2);
-  });
-
-  it("returns exit code 2 when --pr has trailing non-digit chars", async () => {
-    expect(await main(["--pr", "42abc"])).toBe(2);
-  });
-
-  it("returns exit code 2 when --pr is a decimal", async () => {
-    expect(await main(["--pr", "42.5"])).toBe(2);
-  });
-
-  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", () => {
-  let tmpDir: string;
-  let rulesPath: string;
-  let artifactsDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "coverage-check-main-"));
-    rulesPath = join(tmpDir, "rules.yml");
-    artifactsDir = join(tmpDir, "artifacts");
-    mkdirSync(artifactsDir);
-    writeFileSync(rulesPath, "rules:\n  - paths: backend/**\n    patch_coverage_min: 90\n");
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns 2 when rules file is missing", async () => {
-    expect(
-      await main(["--rules", join(tmpDir, "nonexistent.yml"), "--artifacts", artifactsDir]),
-    ).toBe(2);
-  });
-
-  it("accepts --pr and --repo flags (parse succeeds, fails on missing rules)", async () => {
-    expect(
-      await main([
-        "--rules",
-        join(tmpDir, "nonexistent.yml"),
-        "--pr",
-        "42",
-        "--repo",
-        "owner/repo",
-        "--artifacts",
-        artifactsDir,
-      ]),
-    ).toBe(2);
-  });
-
-  it("accepts --strip-prefix flag", async () => {
-    expect(
-      await main([
-        "--rules",
-        join(tmpDir, "nonexistent.yml"),
-        "--strip-prefix",
-        "/some/path",
-        "--artifacts",
-        artifactsDir,
-      ]),
-    ).toBe(2);
-  });
-
-  it("accepts --suite flag", async () => {
-    expect(
-      await main([
-        "--rules",
-        join(tmpDir, "nonexistent.yml"),
-        "--suite",
-        "backend",
-        "--artifacts",
-        artifactsDir,
-      ]),
-    ).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);
-  });
-
-  it("returns 0 when artifacts directory does not exist (ENOENT silenced)", async () => {
-    expect(await main(["--rules", rulesPath, "--artifacts", join(tmpDir, "does-not-exist")])).toBe(
-      0,
-    );
-  });
-
-  it("returns 2 when git diff fails due to invalid refs", async () => {
-    writeFileSync(join(artifactsDir, "lcov.info"), "SF:backend/foo.mts\nDA:1,1\nend_of_record\n");
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        "INVALID_SHA_XXXXXX",
-        "--head",
-        "INVALID_SHA_YYYYYY",
-      ]),
-    ).toBe(2);
-  });
-
-  it("collects lcov files from nested subdirectories before git diff", async () => {
-    const subDir = join(artifactsDir, "subdir");
-    mkdirSync(subDir);
-    writeFileSync(join(subDir, "lcov.info"), "SF:backend/foo.mts\nDA:1,1\nend_of_record\n");
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        "INVALID_SHA_XXXXXX",
-        "--head",
-        "INVALID_SHA_YYYYYY",
-      ]),
-    ).toBe(2);
-  });
-});
-
-describe("runCheck with suite store", () => {
-  let tmpDir: string;
-  let rulesPath: string;
-  let artifactsDir: string;
-  let storeDir: string;
-  let store: FileSystemSuiteStore;
-  let origCwd: string;
-  let savedGitEnv: Record<string, string | undefined>;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "coverage-check-store-"));
-    rulesPath = join(tmpDir, "rules.yml");
-    artifactsDir = join(tmpDir, "artifacts");
-    storeDir = join(tmpDir, "store");
-    mkdirSync(artifactsDir);
-    mkdirSync(storeDir);
-    writeFileSync(rulesPath, "rules:\n  - paths: backend/**\n    patch_coverage_min: 90\n");
-    store = new FileSystemSuiteStore(storeDir);
-
-    const repoDir = join(tmpDir, "repo");
-    mkdirSync(join(repoDir, "backend"), { recursive: true });
-
-    savedGitEnv = {};
-    for (const key of Object.keys(process.env)) {
-      if (key.startsWith("GIT_")) {
-        savedGitEnv[key] = process.env[key];
-        delete process.env[key];
-      }
-    }
-
-    const git = (cmd: string) =>
-      execSync(cmd, {
-        cwd: repoDir,
-        shell: "/bin/sh",
-        encoding: "utf8",
-        env: {
-          ...process.env,
-          GIT_AUTHOR_NAME: "T",
-          GIT_AUTHOR_EMAIL: "t@t.com",
-          GIT_COMMITTER_NAME: "T",
-          GIT_COMMITTER_EMAIL: "t@t.com",
-        },
-      });
-    git("git init");
-    writeFileSync(join(repoDir, "backend", "foo.mts"), "const a = 1\n");
-    git('git add . && git commit -m "init"');
-
-    origCwd = process.cwd();
-    process.chdir(repoDir);
-  });
-
-  afterEach(() => {
-    process.chdir(origCwd);
-    for (const [key, val] of Object.entries(savedGitEnv)) {
-      if (val !== undefined) process.env[key] = val;
-    }
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns 0 when store has no suites and artifacts is empty", async () => {
-    expect(
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: "HEAD",
-        head: "HEAD",
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: null,
-      }),
-    ).toBe(0);
-  });
-
-  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"), {
-      sha: "test-sha",
-      branch: "main",
-    });
-    expect(
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: "HEAD",
-        head: "HEAD",
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: null,
-      }),
-    ).toBe(0);
-  });
-
-  it("excludes the current suite from the store during check", async () => {
-    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,
-        base: "HEAD",
-        head: "HEAD",
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: "backend",
-      }),
-    ).toBe(0);
-  });
-
-  it("includes non-current suites from the store", async () => {
-    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");
-    expect(
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: "HEAD",
-        head: "HEAD",
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: "backend",
-      }),
-    ).toBe(0);
-  });
-
-  it("handles a store that returns null from get() gracefully", async () => {
-    const nullStore = {
-      async list() {
-        return ["backend"];
-      },
-      async get(_suite: string, _opts?: { sha?: string; branch?: string }) {
-        return null;
-      },
-      async put(
-        _suite: string,
-        _lcov: Buffer,
-        _meta: { sha: string; branch: string },
-      ): Promise<void> {},
-    };
-    expect(
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: "HEAD",
-        head: "HEAD",
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store: nullStore,
-        suite: null,
-      }),
-    ).toBe(0);
-  });
-
-  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"), {
-      sha: "test-sha",
-      branch: "main",
-    });
-
-    const calls: string[][] = [];
-    const gh = async (args: string[]) => {
-      calls.push(args);
-      return "";
-    };
-
-    const origServer = process.env["GITHUB_SERVER_URL"];
-    const origRunId = process.env["GITHUB_RUN_ID"];
-    process.env["GITHUB_SERVER_URL"] = "https://github.com";
-    process.env["GITHUB_RUN_ID"] = "12345";
-
-    try {
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: "HEAD",
-        head: "HEAD",
-        pr: 1,
-        repo: "owner/repo",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: null,
-        gh,
-      });
-      expect(calls.length).toBeGreaterThanOrEqual(1);
-    } finally {
-      if (origServer === undefined) delete process.env["GITHUB_SERVER_URL"];
-      else process.env["GITHUB_SERVER_URL"] = origServer;
-      if (origRunId === undefined) delete process.env["GITHUB_RUN_ID"];
-      else process.env["GITHUB_RUN_ID"] = origRunId;
-    }
-  });
-
-  it("accepts --store and --suite flags via main()", async () => {
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--store",
-        storeDir,
-        "--suite",
-        "backend",
-      ]),
-    ).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", () => {
-  let tmpDir: string;
-  let rulesPath: string;
-  let artifactsDir: string;
-  let repoDir: string;
-  let origCwd: string;
-  let baseSha: string;
-  let headSha: string;
-  let savedGitEnv: Record<string, string | undefined>;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "coverage-check-git-"));
-    rulesPath = join(tmpDir, "rules.yml");
-    artifactsDir = join(tmpDir, "artifacts");
-    mkdirSync(artifactsDir);
-    writeFileSync(rulesPath, "rules:\n  - paths: backend/**\n    patch_coverage_min: 90\n");
-
-    repoDir = join(tmpDir, "repo");
-    mkdirSync(join(repoDir, "backend"), { recursive: true });
-
-    savedGitEnv = {};
-    for (const key of Object.keys(process.env)) {
-      if (key.startsWith("GIT_")) {
-        savedGitEnv[key] = process.env[key];
-        delete process.env[key];
-      }
-    }
-
-    const git = (cmd: string) =>
-      execSync(cmd, {
-        cwd: repoDir,
-        shell: "/bin/sh",
-        encoding: "utf8",
-        env: {
-          ...process.env,
-          GIT_AUTHOR_NAME: "T",
-          GIT_AUTHOR_EMAIL: "t@t.com",
-          GIT_COMMITTER_NAME: "T",
-          GIT_COMMITTER_EMAIL: "t@t.com",
-        },
-      });
-
-    git("git init");
-    writeFileSync(join(repoDir, "backend/foo.mts"), "const a = 1\n");
-    git('git add . && git commit -m "base"');
-    baseSha = git("git rev-parse HEAD").trim();
-
-    writeFileSync(join(repoDir, "backend/foo.mts"), "const a = 1\nconst b = 2\n");
-    git('git add . && git commit -m "head"');
-    headSha = git("git rev-parse HEAD").trim();
-
-    origCwd = process.cwd();
-    process.chdir(repoDir);
-  });
-
-  afterEach(() => {
-    process.chdir(origCwd);
-    for (const [key, val] of Object.entries(savedGitEnv)) {
-      if (val !== undefined) process.env[key] = val;
-    }
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("returns 0 when diff is empty (base equals head)", async () => {
-    writeFileSync(join(artifactsDir, "lcov.info"), "SF:backend/foo.mts\nDA:1,1\nend_of_record\n");
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        "HEAD",
-        "--head",
-        "HEAD",
-      ]),
-    ).toBe(0);
-  });
-
-  it("returns 1 when new lines are uncovered and below threshold", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n",
-    );
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        baseSha,
-        "--head",
-        headSha,
-      ]),
-    ).toBe(1);
-  });
-
-  it("returns 0 when all new lines are covered and above threshold", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
-    );
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        baseSha,
-        "--head",
-        headSha,
-      ]),
-    ).toBe(0);
-  });
-
-  it("writes json output to the path specified by --json", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
-    );
-    const jsonPath = join(tmpDir, "result.json");
-    await main([
-      "--rules",
-      rulesPath,
-      "--artifacts",
-      artifactsDir,
-      "--base",
-      baseSha,
-      "--head",
-      headSha,
-      "--json",
-      jsonPath,
-    ]);
-    const result = JSON.parse(readFileSync(jsonPath, "utf8"));
-    expect(result.passed).toBe(true);
-    expect(Array.isArray(result.buckets)).toBe(true);
-  });
-
-  it("posts PR comment via injectable gh runner on failure", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n",
-    );
-    const calls: string[][] = [];
-    const gh = async (args: string[]) => {
-      calls.push(args);
-      return "";
-    };
-    const result = await runCheck({
-      rules: rulesPath,
-      artifacts: artifactsDir,
-      base: baseSha,
-      head: headSha,
-      pr: 42,
-      repo: "owner/repo",
-      json: null,
-      stripPrefixes: [],
-      store: null,
-      suite: null,
-      gh,
-    });
-    expect(result).toBe(1);
-    expect(calls.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("posts PR comment via injectable gh runner on pass", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,1\nend_of_record\n",
-    );
-    const calls: string[][] = [];
-    const gh = async (args: string[]) => {
-      calls.push(args);
-      return "";
-    };
-    const result = await runCheck({
-      rules: rulesPath,
-      artifacts: artifactsDir,
-      base: baseSha,
-      head: headSha,
-      pr: 42,
-      repo: "owner/repo",
-      json: null,
-      stripPrefixes: [],
-      store: null,
-      suite: null,
-      gh,
-    });
-    expect(result).toBe(0);
-    // On pass with no existing comment, gh is called once (lookup only)
-    expect(calls.length).toBe(1);
-  });
-
-  it("handles gh error gracefully (stderr write, still returns correct exit code)", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n",
-    );
-    const gh = async (_args: string[]): Promise<string> => {
-      throw new Error("network error");
-    };
-    const result = await runCheck({
-      rules: rulesPath,
-      artifacts: artifactsDir,
-      base: baseSha,
-      head: headSha,
-      pr: 42,
-      repo: "owner/repo",
-      json: null,
-      stripPrefixes: [],
-      store: null,
-      suite: null,
-      gh,
-    });
-    expect(result).toBe(1);
-  });
-
-  it.skipIf(
-    process.env.PR_AUTHOR === "dependabot[bot]" ||
-      (!process.env.GH_TOKEN && !process.env.GITHUB_TOKEN),
-  )("attempts pr comment on failure and handles gh error gracefully", async () => {
-    writeFileSync(
-      join(artifactsDir, "lcov.info"),
-      "SF:backend/foo.mts\nDA:1,1\nDA:2,0\nend_of_record\n",
-    );
-    expect(
-      await main([
-        "--rules",
-        rulesPath,
-        "--artifacts",
-        artifactsDir,
-        "--base",
-        baseSha,
-        "--head",
-        headSha,
-        "--pr",
-        "1",
-        "--repo",
-        "owner/NONEXISTENT_REPO_FOR_TEST",
-      ]),
-    ).toBe(1);
-  });
-
-  it("combines store suites with current artifacts for coverage check", async () => {
-    const storeDir = join(tmpDir, "store");
-    mkdirSync(storeDir);
-    const store = new FileSystemSuiteStore(storeDir);
-
-    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\nDA:2,1\nend_of_record\n",
-    );
-
-    expect(
-      await runCheck({
-        rules: rulesPath,
-        artifacts: artifactsDir,
-        base: baseSha,
-        head: headSha,
-        pr: null,
-        repo: "",
-        json: null,
-        stripPrefixes: [],
-        store,
-        suite: "backend",
-      }),
-    ).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"];
-    }
-  });
-});