@specific.dev/spectest 0.79.2 → 0.81.0

package/src/coverage.test.ts

@@ -4,27 +4,27 @@ 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,
+  attachSourceMaps,
+  lineLengthsOf,
+  resolveSourceMapFromContainer,
+  sourceMappingUrlOf,
   browser,
   command,
   coverageReportsMode,
   compactV8Document,
-  compactV8Reports,
-  COVERAGE_CONTAINER_DIR,
   node,
-  nodeCoverageConvertCommand,
-  nodeCoverageToolsAvailable,
-  nodeCoverageToolsDir,
+  prepareV8Reports,
+  removeShippedV8Reports,
+  resetNodeCoverageMemory,
+  scriptExecuted,
   validateCoverage,
   type CoverageCaptureContext,
 } from "./coverage.js";
@@ -99,58 +99,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();
   });
 });
 
@@ -166,9 +197,99 @@ function fakeCtx(dir: string, signal = new AbortController().signal): CoverageCa
     async writeReport(name, content) {
       await fs.writeFile(path.join(dir, name), content);
     },
+    async readContainerFile(p) {
+      return fs.readFile(p).catch(() => null);
+    },
   };
 }
 
+describe("source maps by reference", () => {
+  test("lineLengthsOf matches Node's shape: \\n splits, \\r stays, last line counted", () => {
+    expect(lineLengthsOf("ab\ncde\r\n\nf")).toEqual([2, 4, 0, 1]);
+    expect(lineLengthsOf("")).toEqual([0]);
+    expect(lineLengthsOf("x\n")).toEqual([1, 0]);
+  });
+  test("sourceMappingUrlOf takes the last comment", () => {
+    expect(sourceMappingUrlOf("a\n//# sourceMappingURL=a.js.map\nb\n//# sourceMappingURL=b.js.map\n")).toBe("b.js.map");
+    expect(sourceMappingUrlOf("//@ sourceMappingURL=old.map")).toBe("old.map");
+    expect(sourceMappingUrlOf("no map here")).toBeNull();
+  });
+  test("resolves the map a comment names, drops sourcesContent, computes line lengths", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
+    await fs.mkdir(path.join(dir, "maps"));
+    await fs.writeFile(path.join(dir, "cli.js"), "const a = 1;\nconsole.log(a);\n//# sourceMappingURL=maps/cli.map\n");
+    await fs.writeFile(
+      path.join(dir, "maps", "cli.map"),
+      JSON.stringify({ version: 3, sources: ["../src/cli.ts"], mappings: "AAAA;AACA", names: [], sourcesContent: ["x"] }),
+    );
+    const entry = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "cli.js")}`);
+    expect(entry).not.toBeNull();
+    expect(entry!.url).toBe(`file://${path.join(dir, "maps", "cli.map")}`);
+    expect(entry!.data).toEqual({ version: 3, sources: ["../src/cli.ts"], mappings: "AAAA;AACA", names: [] });
+    expect(entry!.lineLengths).toEqual([12, 15, 33, 0]);
+  });
+  test("with no comment, <script>.map next to the script is the map", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
+    await fs.writeFile(path.join(dir, "cli.js"), "x();\n");
+    await fs.writeFile(path.join(dir, "cli.js.map"), JSON.stringify({ version: 3, sources: ["cli.ts"], mappings: "AAAA" }));
+    const entry = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "cli.js")}`);
+    expect(entry!.url).toBe(`file://${path.join(dir, "cli.js.map")}`);
+    expect(entry!.data).toEqual({ version: 3, sources: ["cli.ts"], mappings: "AAAA" });
+  });
+  test("resolves an inline data: URL map; no map, no file, or a foreign URL is null", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covmap-"));
+    const map = JSON.stringify({ version: 3, sources: ["a.ts"], mappings: "AAAA" });
+    await fs.writeFile(
+      path.join(dir, "inline.js"),
+      `x();\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(map).toString("base64")}\n`,
+    );
+    const inline = await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "inline.js")}`);
+    expect(inline!.url).toBeNull();
+    expect(inline!.data).toEqual({ version: 3, sources: ["a.ts"], mappings: "AAAA" });
+    await fs.writeFile(path.join(dir, "bare.js"), "x();\n");
+    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "bare.js")}`)).toBeNull();
+    await fs.writeFile(path.join(dir, "gone.js"), "x();\n//# sourceMappingURL=gone.js.map\n");
+    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "gone.js")}`)).toBeNull();
+    await fs.writeFile(path.join(dir, "http.js"), "x();\n//# sourceMappingURL=https://cdn.test/x.map\n");
+    expect(await resolveSourceMapFromContainer(fakeCtx(dir), `file://${path.join(dir, "http.js")}`)).toBeNull();
+    expect(await resolveSourceMapFromContainer(fakeCtx(dir), "node:fs")).toBeNull();
+    const noRead = { ...fakeCtx(dir), readContainerFile: undefined };
+    expect(await resolveSourceMapFromContainer(noRead, `file://${path.join(dir, "inline.js")}`)).toBeNull();
+  });
+  test("attachSourceMaps: a map once, a stub after, a missing map looked up once", async () => {
+    const calls: string[] = [];
+    const entry = { url: null, data: { version: 3, sources: ["a.ts"], mappings: "AAAA" }, lineLengths: [4] };
+    const resolve = async (url: string) => {
+      calls.push(url);
+      return url.endsWith("/a.js") ? entry : null;
+    };
+    const shipped = new Map<string, string>();
+    const missing = new Set<string>();
+    const dump = () => ({
+      result: [
+        { url: "file:///app/a.js", ...ran },
+        { url: "file:///app/b.js", ...ran },
+      ],
+    });
+    const first = dump() as Record<string, unknown>;
+    expect(await attachSourceMaps(first, resolve, shipped, missing)).toBe(1);
+    const c1 = first["source-map-cache"] as Record<string, Record<string, unknown>>;
+    expect(c1["file:///app/a.js"][SOURCE_MAP_HASH_KEY]).toMatch(/^sha256:/);
+    expect(c1["file:///app/a.js"].lineLengths).toEqual([4]);
+    expect("file:///app/b.js" in c1).toBe(false);
+    expect(calls).toEqual(["file:///app/a.js", "file:///app/b.js"]);
+    const second = dump() as Record<string, unknown>;
+    expect(await attachSourceMaps(second, resolve, shipped, missing)).toBe(0);
+    const c2 = second["source-map-cache"] as Record<string, Record<string, unknown>>;
+    expect(c2["file:///app/a.js"]).toEqual({ [SOURCE_MAP_REF_KEY]: c1["file:///app/a.js"][SOURCE_MAP_HASH_KEY] });
+    expect(calls.length).toBe(2); // b.js is not asked again
+    // A dump that carries its own entry is left alone.
+    const own = { ...dump(), "source-map-cache": { "file:///app/b.js": { data: { mappings: "" }, lineLengths: [1] } } } as Record<string, unknown>;
+    expect(await attachSourceMaps(own, resolve, shipped, missing)).toBe(0);
+    expect(calls.length).toBe(2);
+  });
+});
+
 describe("browserCoverage", () => {
   test("writes an empty lcov when nothing ran for the service", async () => {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-cov-"));
@@ -257,8 +378,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");
     }
@@ -360,106 +485,48 @@ describe.if(hasNode)("nodeCoverage hook (real node)", () => {
     }
   });
 
-  test("no process and no dump: an empty report is written, once", async () => {
+  test("a CLI built with an external map and no comment gets its map from the file next to the script, once per branch", async () => {
+    // Node caches a map it finds through a sourceMappingURL comment into
+    // every dump under NODE_V8_COVERAGE, flag or no flag (checked: the
+    // entry then carries Node's resolved `sources` and `sourceRoot`).
+    // Without the comment the dump has no map and the adapter reads
+    // `cli.js.map` from the container.
+    resetNodeCoverageMemory();
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covhook-"));
-    await node().capture!(fakeCtx(dir));
-    await node().capture!(fakeCtx(dir));
-    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");
+    await fs.writeFile(path.join(dir, "cli.js"), "function used() { return 1 }\nused();\n");
+    await fs.writeFile(path.join(dir, "cli.js.map"), JSON.stringify({ version: 3, sources: ["cli.ts"], mappings: "AAAA;AACA", sourcesContent: ["src"] }));
+    const url = `file://${path.join(dir, "cli.js")}`;
+    for (let i = 0; i < 2; i++) {
       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);
-    });
+      await node().capture!(fakeCtx(dir));
+      const [name] = (await reportsIn(dir)).filter((n) => n !== NODE_COVERAGE_EMPTY_REPORT);
+      const doc = JSON.parse(await fs.readFile(path.join(dir, name!), "utf8")) as {
+        result: { url: string }[];
+        "source-map-cache": Record<string, Record<string, unknown>>;
+      };
+      expect(doc.result.map((x) => x.url)).toEqual([url]);
+      const entry = doc["source-map-cache"][url]!;
+      if (i === 0) {
+        expect(entry[SOURCE_MAP_HASH_KEY]).toMatch(/^sha256:/);
+        expect(entry.data).toEqual({ version: 3, sources: ["cli.ts"], mappings: "AAAA;AACA" });
+        expect(entry.lineLengths).toEqual([28, 7, 0]);
+      } else {
+        expect(Object.keys(entry)).toEqual([SOURCE_MAP_REF_KEY]);
+      }
+    }
+    resetNodeCoverageMemory();
+  });
+
+  test("no process and no dump: an empty report is written, once", async () => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-covhook-"));
+    await node().capture!(fakeCtx(dir));
+    await node().capture!(fakeCtx(dir));
+    expect(await reportsIn(dir)).toEqual([NODE_COVERAGE_EMPTY_REPORT]);
   });
 });