@specific.dev/spectest 0.79.2 → 0.80.0

package/src/coverage.test.ts

@@ -4,27 +4,23 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import {
-  NODE_COVERAGE_C8_BIN,
-  NODE_COVERAGE_DUMPS_SUBDIR,
   NODE_COVERAGE_HOOK,
   NODE_COVERAGE_EMPTY_REPORT,
-  NODE_COVERAGE_LCOV,
-  NODE_COVERAGE_TOOLS_CONTAINER_DIR,
   NODE_COVERAGE_HOOK_PATH,
   NODE_COVERAGE_SOCKET_PREFIX,
-  absoluteLcovPaths,
+  SOURCE_MAP_HASH_KEY,
+  SOURCE_MAP_REF_KEY,
   applyCoverageAdapters,
   appendEnvFlag,
   browser,
   command,
   coverageReportsMode,
   compactV8Document,
-  compactV8Reports,
-  COVERAGE_CONTAINER_DIR,
   node,
-  nodeCoverageConvertCommand,
-  nodeCoverageToolsAvailable,
-  nodeCoverageToolsDir,
+  prepareV8Reports,
+  removeShippedV8Reports,
+  resetNodeCoverageMemory,
+  scriptExecuted,
   validateCoverage,
   type CoverageCaptureContext,
 } from "./coverage.js";
@@ -99,58 +95,89 @@ describe("applyCoverageAdapters", () => {
   });
 });
 
+const ran = { functions: [{ functionName: "", ranges: [{ startOffset: 0, endOffset: 10, count: 1 }] }] };
+const idle = { functions: [{ functionName: "", ranges: [{ startOffset: 0, endOffset: 10, count: 0 }] }] };
+
 describe("compactV8Document", () => {
   const doc = {
     result: [
-      { scriptId: "1", url: "file:///app/src/a.ts", functions: [] },
-      { scriptId: "2", url: "file:///app/node_modules/x/index.js", functions: [] },
-      { scriptId: "3", url: "node:fs", functions: [] },
-      { scriptId: "5", url: "file:///root/.cache/node/corepack/v1/pnpm/10.0.0/dist/pnpm.cjs", functions: [] },
-      { scriptId: "4", url: "", functions: [] },
+      { scriptId: "1", url: "file:///app/src/a.ts", ...ran },
+      { scriptId: "2", url: "file:///app/node_modules/x/index.js", ...ran },
+      { scriptId: "3", url: "node:fs", ...ran },
+      { scriptId: "5", url: "file:///root/.cache/node/corepack/v1/pnpm/10.0.0/dist/pnpm.cjs", ...ran },
+      { scriptId: "6", url: "file:///app/src/idle.ts", ...idle },
+      { scriptId: "4", url: "", ...ran },
     ],
     "source-map-cache": {
       "file:///app/src/a.ts": { lineLengths: [1], data: { mappings: "AAAA", sources: ["a.ts"], sourcesContent: ["x"] }, url: null },
+      "file:///app/src/idle.ts": { lineLengths: [1], data: { mappings: "AAAA", sources: ["idle.ts"] }, url: null },
       "file:///app/node_modules/x/index.js": { lineLengths: [1], data: { mappings: "AAAA" }, url: null },
     },
   };
-  test("keeps app scripts and their maps, drops the rest and sourcesContent", () => {
+  type Cache = Record<string, Record<string, unknown>>;
+
+  test("scriptExecuted: any range count above zero", () => {
+    expect(scriptExecuted(ran)).toBe(true);
+    expect(scriptExecuted(idle)).toBe(false);
+    expect(scriptExecuted({})).toBe(false);
+  });
+  test("keeps app scripts that ran and their maps, drops the rest and sourcesContent", () => {
     const out = compactV8Document(doc) as typeof doc;
     expect(out.result.map((s) => s.url)).toEqual(["file:///app/src/a.ts"]);
-    expect(Object.keys(out["source-map-cache"])).toEqual(["file:///app/src/a.ts"]);
-    expect(out["source-map-cache"]["file:///app/src/a.ts"].data).toEqual({ mappings: "AAAA", sources: ["a.ts"] });
-  });
-  test("keepSourcesContent keeps the sources for the in-container conversion", () => {
-    const out = compactV8Document(doc, { keepSourcesContent: true }) as typeof doc;
-    expect(out["source-map-cache"]["file:///app/src/a.ts"].data).toEqual({
-      mappings: "AAAA",
-      sources: ["a.ts"],
-      sourcesContent: ["x"],
-    });
+    const cache = out["source-map-cache"] as unknown as Cache;
+    expect(Object.keys(cache)).toEqual(["file:///app/src/a.ts"]);
+    expect(cache["file:///app/src/a.ts"].data).toEqual({ mappings: "AAAA", sources: ["a.ts"] });
+    expect(cache["file:///app/src/a.ts"][SOURCE_MAP_HASH_KEY]).toMatch(/^sha256:[0-9a-f]{64}$/);
+    expect(cache["file:///app/src/a.ts"][SOURCE_MAP_REF_KEY]).toBeUndefined();
   });
-  test("absoluteLcovPaths makes c8's root-relative SF records container paths", () => {
-    expect(absoluteLcovPaths("TN:\nSF:app/src/a.ts\nDA:1,1\nend_of_record\nSF:/abs.js\nend_of_record\n")).toBe(
-      "TN:\nSF:/app/src/a.ts\nDA:1,1\nend_of_record\nSF:/abs.js\nend_of_record\n",
-    );
-    expect(absoluteLcovPaths("")).toBe("TN:\n");
-    expect(absoluteLcovPaths("  \n")).toBe("TN:\n");
+  test("a map shipped earlier on the branch becomes a stub that refers to its hash", () => {
+    const shipped = new Map<string, string>();
+    const first = compactV8Document(doc, shipped) as typeof doc;
+    const hash = (first["source-map-cache"] as unknown as Cache)["file:///app/src/a.ts"][SOURCE_MAP_HASH_KEY];
+    expect(shipped.get("file:///app/src/a.ts")).toBe(hash as string);
+    const second = compactV8Document(doc, shipped) as typeof doc;
+    expect((second["source-map-cache"] as unknown as Cache)["file:///app/src/a.ts"]).toEqual({ [SOURCE_MAP_REF_KEY]: hash });
+    // The hash is over the compacted entry, so the same map with its
+    // sources dropped is the same map; a changed map ships again.
+    const changed = {
+      ...doc,
+      "source-map-cache": { "file:///app/src/a.ts": { lineLengths: [2], data: { mappings: "AAAC", sources: ["a.ts"] }, url: null } },
+    };
+    const third = compactV8Document(changed, shipped) as typeof doc;
+    const entry = (third["source-map-cache"] as unknown as Cache)["file:///app/src/a.ts"];
+    expect(entry[SOURCE_MAP_REF_KEY]).toBeUndefined();
+    expect(entry[SOURCE_MAP_HASH_KEY]).not.toBe(hash);
   });
   test("a dump with no app script keeps an empty result and no cache", () => {
     const out = compactV8Document({ result: [doc.result[2]], "source-map-cache": doc["source-map-cache"] });
     expect(out.result).toEqual([]);
     expect("source-map-cache" in out).toBe(false);
   });
-  test("compactV8Reports rewrites coverage-*.json once and leaves other files alone", async () => {
+  test("prepareV8Reports compacts coverage-*.json once, ships maps once, and the next capture removes them", async () => {
+    resetNodeCoverageMemory();
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-cov-"));
     await fs.writeFile(path.join(dir, "coverage-1-2-0.json"), JSON.stringify(doc));
     await fs.writeFile(path.join(dir, "browser.lcov"), "TN:\n");
-    await compactV8Reports(dir);
-    const back = JSON.parse(await fs.readFile(path.join(dir, "coverage-1-2-0.json"), "utf8")) as { result: unknown[] };
+    const stats = await prepareV8Reports(dir);
+    expect(stats.dumps).toBe(1);
+    expect(stats.bytesOut).toBeLessThan(stats.bytesIn);
+    const back = JSON.parse(await fs.readFile(path.join(dir, "coverage-1-2-0.json"), "utf8")) as typeof doc;
     expect(back.result.length).toBe(1);
+    expect((back["source-map-cache"] as unknown as Cache)["file:///app/src/a.ts"][SOURCE_MAP_HASH_KEY]).toBeDefined();
     expect(await fs.readFile(path.join(dir, "browser.lcov"), "utf8")).toBe("TN:\n");
-    // Idempotent and cheap: a second pass is a no-op on the same file.
+    // Shipped: a second pass leaves it alone, even when it is not JSON any more.
     await fs.writeFile(path.join(dir, "coverage-1-2-0.json"), "not json");
-    await compactV8Reports(dir);
+    expect((await prepareV8Reports(dir)).dumps).toBe(0);
     expect(await fs.readFile(path.join(dir, "coverage-1-2-0.json"), "utf8")).toBe("not json");
+    // A later dump of the same script carries a stub for the map.
+    await fs.writeFile(path.join(dir, "coverage-1-3-0.json"), JSON.stringify(doc));
+    expect((await prepareV8Reports(dir)).dumps).toBe(1);
+    const later = JSON.parse(await fs.readFile(path.join(dir, "coverage-1-3-0.json"), "utf8")) as typeof doc;
+    expect(Object.keys((later["source-map-cache"] as unknown as Cache)["file:///app/src/a.ts"])).toEqual([SOURCE_MAP_REF_KEY]);
+    // The next capture starts by removing what shipped; other files stay.
+    await removeShippedV8Reports(dir);
+    expect((await fs.readdir(dir)).sort()).toEqual(["browser.lcov"]);
+    resetNodeCoverageMemory();
   });
 });
 
@@ -257,8 +284,12 @@ describe.if(hasNode)("nodeCoverage hook (real node)", () => {
       expect((await socketsIn(dir)).length).toBe(1); // its socket is gone with it
       expect((await reportsIn(dir)).length).toBe(2); // its exit-time report is there
 
+      // The next capture ships only what is new: the first dump goes,
+      // the short process's exit dump and the server's fresh dump stay.
       await node().capture!(fakeCtx(dir));
-      expect((await reportsIn(dir)).length).toBe(3);
+      const next = await reportsIn(dir);
+      expect(next.length).toBe(2);
+      expect(next).not.toContain(reports[0]!);
     } finally {
       server.kill("SIGKILL");
     }
@@ -367,99 +398,3 @@ describe.if(hasNode)("nodeCoverage hook (real node)", () => {
     expect(await reportsIn(dir)).toEqual([NODE_COVERAGE_EMPTY_REPORT]);
   });
 });
-
-// The conversion to lcov against a real `node` and a real `c8` tree.
-// Golden ships the tree at /opt/spectest/coverage-tools; on a dev box
-// point SPECTEST_C8_TEST_DIR at one (`bun install --linker=hoisted` of
-// `c8` in a scratch dir). Skipped where either is missing. The exec here
-// is the container's `sh -c` with the container paths rewritten to this
-// directory: the command is exactly what a container runs.
-const c8TestDir = process.env.SPECTEST_C8_TEST_DIR || "/opt/spectest/coverage-tools";
-const hasC8 = await fs
-  .access(path.join(c8TestDir, NODE_COVERAGE_C8_BIN))
-  .then(() => true)
-  .catch(() => false);
-
-describe.if(hasNode && hasC8)("nodeCoverage → lcov (real node + c8)", () => {
-  function c8Ctx(dir: string): CoverageCaptureContext {
-    return {
-      ...fakeCtx(dir),
-      async exec(command: string) {
-        const local = command
-          .replaceAll(NODE_COVERAGE_TOOLS_CONTAINER_DIR, c8TestDir)
-          .replaceAll(COVERAGE_CONTAINER_DIR, dir);
-        return new Promise((resolve, reject) => {
-          const p = spawn("sh", ["-c", local], { stdio: ["ignore", "pipe", "pipe"] });
-          let out = "";
-          p.stdout!.on("data", (b: Buffer) => (out += b));
-          p.stderr!.on("data", (b: Buffer) => (out += b));
-          p.on("exit", (code) => (code === 0 ? resolve({ stdout: out, stderr: "" }) : reject(new Error(out))));
-        });
-      },
-    };
-  }
-  async function withTools<T>(f: () => Promise<T>): Promise<T> {
-    const prior = process.env.SPECTEST_COVERAGE_TOOLS_DIR;
-    process.env.SPECTEST_COVERAGE_TOOLS_DIR = c8TestDir;
-    try {
-      return await f();
-    } finally {
-      if (prior === undefined) delete process.env.SPECTEST_COVERAGE_TOOLS_DIR;
-      else process.env.SPECTEST_COVERAGE_TOOLS_DIR = prior;
-    }
-  }
-
-  test("the tools dir is found through the override, and the command is the container's", async () => {
-    await withTools(async () => {
-      expect(nodeCoverageToolsDir()).toBe(c8TestDir);
-      expect(await nodeCoverageToolsAvailable()).toBe(true);
-    });
-    expect(nodeCoverageConvertCommand()).toBe(
-      `cd / && env -u NODE_V8_COVERAGE -u NODE_OPTIONS node ${NODE_COVERAGE_TOOLS_CONTAINER_DIR}/${NODE_COVERAGE_C8_BIN} report --temp-directory ${COVERAGE_CONTAINER_DIR}/${NODE_COVERAGE_DUMPS_SUBDIR} --reporter=lcovonly --reports-dir ${COVERAGE_CONTAINER_DIR}/.c8`,
-    );
-  });
-
-  test("dumps are converted to node.lcov, the delta of this capture; the raw dumps never ship", async () => {
-    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covc8-"));
-    const hook = path.join(dir, "coverage-hook.cjs");
-    await fs.writeFile(hook, NODE_COVERAGE_HOOK);
-    await fs.writeFile(path.join(dir, "cli.js"), "function used() { return 1 }\nfunction unused() { return 2 }\nused();\n");
-    await withTools(async () => {
-      // Nothing ran yet: an empty lcov, no exec.
-      await node().capture!(c8Ctx(dir));
-      expect(await fs.readFile(path.join(dir, NODE_COVERAGE_LCOV), "utf8")).toBe("TN:\n");
-      const cli = spawn("node", [path.join(dir, "cli.js")], {
-        env: { ...process.env, NODE_V8_COVERAGE: dir, NODE_OPTIONS: `--require ${hook}` },
-        stdio: "ignore",
-      });
-      expect(await new Promise<number | null>((r) => cli.on("exit", r))).toBe(0);
-      await node().capture!(c8Ctx(dir));
-      const lcov = await fs.readFile(path.join(dir, NODE_COVERAGE_LCOV), "utf8");
-      expect(lcov).toContain(`SF:${path.join(dir, "cli.js")}\n`);
-      expect(lcov).toMatch(/FNDA:1,used/);
-      expect(lcov).toMatch(/FNDA:0,unused/);
-      // The hook itself is not the app's code.
-      expect(lcov).not.toContain("coverage-hook.cjs");
-      // Raw dumps moved under the hidden .v8/ dir: the visible reports
-      // are the lcov alone.
-      const visible = (await fs.readdir(dir)).filter((n) => !n.startsWith(".") && n.startsWith("coverage-") && n.endsWith(".json"));
-      expect(visible).toEqual([]);
-      const dumps = (await fs.readdir(path.join(dir, NODE_COVERAGE_DUMPS_SUBDIR))).filter((n) => n.endsWith(".json"));
-      expect(dumps.length).toBe(1);
-      // Nothing new since: the next capture is an empty report, not the
-      // previous one again — the lcov is a delta.
-      await node().capture!(c8Ctx(dir));
-      expect(await fs.readFile(path.join(dir, NODE_COVERAGE_LCOV), "utf8")).toBe("TN:\n");
-      // A new run is a new delta on its own: counts of 1, not 2.
-      const again = spawn("node", [path.join(dir, "cli.js")], {
-        env: { ...process.env, NODE_V8_COVERAGE: dir, NODE_OPTIONS: `--require ${hook}` },
-        stdio: "ignore",
-      });
-      await new Promise((r) => again.on("exit", r));
-      await node().capture!(c8Ctx(dir));
-      const lcov2 = await fs.readFile(path.join(dir, NODE_COVERAGE_LCOV), "utf8");
-      expect(lcov2).toMatch(/FNDA:1,used/);
-      expect((await fs.readdir(path.join(dir, NODE_COVERAGE_DUMPS_SUBDIR))).filter((n) => n.endsWith(".json")).length).toBe(1);
-    });
-  });
-});