@specific.dev/spectest 0.131.14 → 0.131.15

package/dist/coverage-next.js

@@ -9,7 +9,11 @@ export const NEXT_COVERAGE_HELPER_PATH = "/spectest/next-coverage.cjs";
 export const NEXT_COVERAGE_HELPER = String.raw `"use strict";
 const fs = require("node:fs"), path = require("node:path");
 const options = JSON.parse(process.env.SPECTEST_NEXT_COVERAGE_OPTIONS || "{}");
-const app = path.resolve(options.appDir || ".");
+// Preloads run again in spawned Node processes. Carry the original runtime
+// root into children instead of interpreting appDir against each child's cwd.
+const root = process.env.SPECTEST_COVERAGE_ROOT || process.cwd();
+process.env.SPECTEST_COVERAGE_ROOT = root;
+const app = path.resolve(root, options.appDir || ".");
 const dist = path.resolve(app, options.distDir || ".next");
 function manifest() { return JSON.parse(fs.readFileSync(path.join(dist, "required-server-files.json"), "utf8")); }
 function launcher(m) {
@@ -17,7 +21,7 @@ function launcher(m) {
   if (m.config.output !== "standalone" || !fs.existsSync(file)) return null;
   const text = fs.readFileSync(file, "utf8");
   if (!text.includes("__NEXT_PRIVATE_STANDALONE_CONFIG") || !text.includes("next/dist/server/lib/start-server")) return null;
-  return path.relative(process.cwd(), file);
+  return path.relative(root, file);
 }
 try {
   const file = launcher(manifest());
@@ -50,7 +54,8 @@ const GENERATED_SOURCES = [
     "*/data:* <text/javascript>", // Turbopack virtual modules, including action proxies.
     "*/.next-internal/server/app/*/actions.js (server actions loader)",
     "*/app/*--route-entry.js",
-    "*/app/*.mjs (structured image object)",
+    "*/*.mjs (structured image object)",
+    "*/*.mjs (structured image object with data url)",
 ];
 /** Server + browser coverage for a built Next app. Build-time maps are required;
  * enable native Next source maps and retain them in the runtime image.

package/dist/coverage.js

@@ -339,9 +339,13 @@ export const NODE_COVERAGE_HOOK = `"use strict";
   if (!bunRuntime) post("Debugger.enable", { maxScriptsCacheSize: 16 * 1024 * 1024 });
 
   const GENERATED = new Map();
+  // Generated names are service-root-relative unit identities, not paths
+  // relative to a wrapper's child process. Preserve that root through execs.
+  const generatedRoot = process.env.SPECTEST_COVERAGE_ROOT || process.cwd();
+  process.env.SPECTEST_COVERAGE_ROOT = generatedRoot;
   try {
     for (const file of JSON.parse(process.env.SPECTEST_COVERAGE_GENERATED_FILES || "[]")) {
-      GENERATED.set(url.pathToFileURL(path.resolve(file)).href, file);
+      GENERATED.set(url.pathToFileURL(path.resolve(generatedRoot, file)).href, file);
     }
   } catch (e) {}
   const generatedUnits = new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.131.14",
+  "version": "0.131.15",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/coverage-next.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from "bun:test";
 import { next, NEXT_COVERAGE_HELPER, NEXT_COVERAGE_HELPER_PATH, type NextBuildMetadata } from "./coverage-next.js";
-import { applyCoverageAdapters, resolveCoverageSourceOptions, attachCoverageSourceOptions, node, browser, type CoverageSourceContext } from "./coverage.js";
+import { applyCoverageAdapters, resolveCoverageSourceOptions, attachCoverageSourceOptions, node, browser, NODE_COVERAGE_HOOK, NODE_COVERAGE_SCRIPTS_SUBDIR, NODE_COVERAGE_MARKERS_SUBDIR, type CoverageSourceContext } from "./coverage.js";
 import { applyCoverageDelta, encodeCoverageBundle } from "./harness/coverage.js";
 import { gunzipSync } from "node:zlib";
 import { promises as fs } from "node:fs";
@@ -18,6 +18,64 @@ function context(): CoverageSourceContext {
 }
 
 describe("Next adapter", () => {
+  test.each(["next", "node"])("%s preserves generated unit identity through children with different working directories", async (kind) => {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "next-child-cov-"));
+    try {
+      const app = path.join(dir, "ops"), reports = path.join(dir, "reports");
+      const helper = path.join(dir, "next-coverage.cjs"), hook = path.join(dir, "coverage-hook.cjs");
+      for (const folder of ["ops/.next/server", "ops/.next/static", "elsewhere", `reports/${NODE_COVERAGE_SCRIPTS_SUBDIR}`, `reports/${NODE_COVERAGE_MARKERS_SUBDIR}`]) {
+        await fs.mkdir(path.join(dir, folder), {recursive:true});
+      }
+      await fs.writeFile(helper, NEXT_COVERAGE_HELPER);
+      await fs.writeFile(hook, NODE_COVERAGE_HOOK);
+      await fs.writeFile(path.join(app, ".next/required-server-files.json"), JSON.stringify({config:{output:"standalone"}}));
+      for (const folder of ["server", "static"]) await fs.writeFile(path.join(app, `.next/${folder}/a.js.map`), "{}");
+      const launcher = '// __NEXT_PRIVATE_STANDALONE_CONFIG next/dist/server/lib/start-server\nrequire("./authored.cjs");\n';
+      await fs.writeFile(path.join(app, "server.js"), launcher);
+      await fs.writeFile(path.join(app, "authored.cjs"), "globalThis.applicationRan = true;\n");
+      await fs.writeFile(path.join(app, "bridge.cjs"), `
+        const {execFileSync} = require("node:child_process");
+        execFileSync(process.execPath, [${JSON.stringify(path.join(app,"server.js"))}], {cwd:${JSON.stringify(path.join(dir,"elsewhere"))}, stdio:"inherit"});
+      `);
+      await fs.writeFile(path.join(dir, "wrapper.cjs"), `
+        const {execFileSync} = require("node:child_process");
+        execFileSync(process.execPath, [${JSON.stringify(path.join(app,"bridge.cjs"))}], {cwd:${JSON.stringify(app)}, stdio:"inherit"});
+      `);
+      const adapter = kind === "next" ? next({appDir:"ops"}) : node({generated:["ops/server.js"]});
+      const configured = applyCoverageAdapters("web", {image, coverage:{adapters:[adapter]}});
+      const env = {...process.env, ...configured.env,
+        SPECTEST_COVERAGE_DIR:reports,
+        NODE_OPTIONS: `${kind === "next" ? `--require ${helper} ` : ""}--require ${hook}`,
+      } as NodeJS.ProcessEnv;
+      const ctx: CoverageSourceContext = {
+        service:"web", signal:new AbortController().signal,
+        projectFiles:async()=>[], readProjectFile:async()=>null,
+        exec:async command=>({stdout:execFileSync("sh", ["-c", command.replaceAll(NEXT_COVERAGE_HELPER_PATH, helper)], {cwd:dir,env,stdio:["ignore","pipe","pipe"]}).toString(),stderr:""}),
+      };
+      const inventory = (await adapter.inventory!(ctx)).filter(unit=>unit.startsWith("generated:"));
+      expect(inventory).toHaveLength(1);
+      expect(inventory[0]).toMatch(/^generated:web:ops\/server.js#[a-f0-9]{64}$/);
+      execFileSync("node", [path.join(dir,"wrapper.cjs")], {cwd:dir,env,stdio:["ignore","pipe","pipe"]});
+      const dumps = await Promise.all((await fs.readdir(reports)).filter(n=>/^node-.*\.json$/.test(n)).map(async n=>JSON.parse(await fs.readFile(path.join(reports,n),"utf8"))));
+      const urls = dumps.flatMap(d=>d.result.map((s:{url:string})=>s.url));
+      const units = new Set(dumps.flatMap(d=>d.units ?? []).filter((unit:string)=>unit.startsWith("generated:")));
+      expect([...units]).toEqual(inventory);
+      expect(urls.some(url=>url.endsWith("/ops/server.js"))).toBe(false);
+      expect(urls.some(url=>url.endsWith("/ops/authored.cjs"))).toBe(true);
+      expect(urls.some(url=>url.endsWith("/wrapper.cjs"))).toBe(true);
+    } finally { await fs.rm(dir, {recursive:true,force:true}); }
+  });
+
+  test("image wrapper exclusions cover monorepo public assets and are archived on both report types", async () => {
+    const policies = await resolveCoverageSourceOptions([next({appDir:"ops"})], context());
+    const capture = attachCoverageSourceOptions({reports:[{name:"node-1.json"},{name:"browser.lcov"}]}, policies);
+    for (const report of capture.reports) {
+      expect(report.sourceOptions!.excludeSources).toContain("*/*.mjs (structured image object)");
+      expect(report.sourceOptions!.excludeSources).toContain("*/*.mjs (structured image object with data url)");
+      expect(report.sourceOptions!.excludeSources).not.toContain("*/public/*");
+    }
+  });
+
   test("one adapter configures both collectors, uses its declared source root, and owns only its reports", async () => {
     const adapter = next({sourceRoot:"packages"});
     const configured = applyCoverageAdapters("web", {image,coverage:{adapters:[adapter]}});

package/src/coverage-next.ts

@@ -21,7 +21,11 @@ export const NEXT_COVERAGE_HELPER_PATH = "/spectest/next-coverage.cjs";
 export const NEXT_COVERAGE_HELPER = String.raw`"use strict";
 const fs = require("node:fs"), path = require("node:path");
 const options = JSON.parse(process.env.SPECTEST_NEXT_COVERAGE_OPTIONS || "{}");
-const app = path.resolve(options.appDir || ".");
+// Preloads run again in spawned Node processes. Carry the original runtime
+// root into children instead of interpreting appDir against each child's cwd.
+const root = process.env.SPECTEST_COVERAGE_ROOT || process.cwd();
+process.env.SPECTEST_COVERAGE_ROOT = root;
+const app = path.resolve(root, options.appDir || ".");
 const dist = path.resolve(app, options.distDir || ".next");
 function manifest() { return JSON.parse(fs.readFileSync(path.join(dist, "required-server-files.json"), "utf8")); }
 function launcher(m) {
@@ -29,7 +33,7 @@ function launcher(m) {
   if (m.config.output !== "standalone" || !fs.existsSync(file)) return null;
   const text = fs.readFileSync(file, "utf8");
   if (!text.includes("__NEXT_PRIVATE_STANDALONE_CONFIG") || !text.includes("next/dist/server/lib/start-server")) return null;
-  return path.relative(process.cwd(), file);
+  return path.relative(root, file);
 }
 try {
   const file = launcher(manifest());
@@ -69,7 +73,8 @@ const GENERATED_SOURCES = [
   "*/data:* <text/javascript>", // Turbopack virtual modules, including action proxies.
   "*/.next-internal/server/app/*/actions.js (server actions loader)",
   "*/app/*--route-entry.js",
-  "*/app/*.mjs (structured image object)",
+  "*/*.mjs (structured image object)",
+  "*/*.mjs (structured image object with data url)",
 ];
 
 /** Server + browser coverage for a built Next app. Build-time maps are required;

package/src/coverage.test.ts

@@ -246,7 +246,9 @@ const hasNode = await new Promise<boolean>((resolve) => {
   p.on("exit", (code) => resolve(code === 0));
 });
 
-const SERVER_JS = "function tick() { return 1 }\nsetInterval(tick, 5); process.stdout.write('up\\n');\n";
+// Readiness must follow the first tick; otherwise a fast capture can win the
+// race against the timer and correctly report that tick has not run yet.
+const SERVER_JS = "function tick() { return 1 }\ntick(); setInterval(tick, 5); process.stdout.write('up\\n');\n";
 // A wrapper that spawns the real server as a child node process and
 // waits on it — what `pnpm exec`, `npm run` and the `tsx` binary do.
 // It takes its child down with it on SIGTERM, so the test leaves no
@@ -334,7 +336,7 @@ describe.if(hasNode)("nodeCoverage hook (real node)", () => {
       expect(fns.every((f) => f.some((_, i) => i % 3 === 2 && f[i]! > 0))).toBe(true);
       const rec = (await records(dir)).get(`file://${path.join(dir, "server.js")}`)!;
       expect(ranNames(dump, rec).sort()).toEqual(["", "tick"]);
-      expect(rec.lineLengths).toEqual([28, 51, 0]);
+      expect(rec.lineLengths).toEqual([28, 59, 0]);
       expect(rec.functions.map((f) => f[0])).toEqual(["", "tick"]);
       expect(rec.sourceMap).toBeNull();
       expect(dump.result[0]!.spectestScript).toBeDefined();

package/src/coverage.ts

@@ -517,9 +517,13 @@ export const NODE_COVERAGE_HOOK = `"use strict";
   if (!bunRuntime) post("Debugger.enable", { maxScriptsCacheSize: 16 * 1024 * 1024 });
 
   const GENERATED = new Map();
+  // Generated names are service-root-relative unit identities, not paths
+  // relative to a wrapper's child process. Preserve that root through execs.
+  const generatedRoot = process.env.SPECTEST_COVERAGE_ROOT || process.cwd();
+  process.env.SPECTEST_COVERAGE_ROOT = generatedRoot;
   try {
     for (const file of JSON.parse(process.env.SPECTEST_COVERAGE_GENERATED_FILES || "[]")) {
-      GENERATED.set(url.pathToFileURL(path.resolve(file)).href, file);
+      GENERATED.set(url.pathToFileURL(path.resolve(generatedRoot, file)).href, file);
     }
   } catch (e) {}
   const generatedUnits = new Map();