supercov 2.0.1 → 3.0.1

package/runtime/javascript/nodeTest.mjs

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as native from "node:test";
 import { fileURLToPath } from "node:url";
 import vm from "node:vm";
@@ -86,6 +87,43 @@ function restoreUserError(error, depth = 0) {
     }
     return error;
 }
+// The describe/suite blocks a test is registered in, outermost first. A test
+// is named by them as Vitest, Jest and Playwright name theirs, so two tests
+// with one name in different suites stay apart, and `tests affected --names`
+// gives what --test-name-pattern matches. A store rather than a stack: an
+// async suite registers tests after it awaits.
+const suitePath = new AsyncLocalStorage();
+function suiteName(args, callback) {
+    return typeof args[0] === "string" ? args[0] : callback.name || "<anonymous>";
+}
+function wrappedSuite(original) {
+    const wrapped = function supercovNodeSuite(...args) {
+        const index = callbackIndex(args);
+        if (index < 0)
+            return Reflect.apply(original, this, args);
+        const callback = args[index];
+        const path = [...(suitePath.getStore() ?? []), suiteName(args, callback)];
+        const next = [...args];
+        next[index] = function supercovNodeSuiteCallback(...callbackArgs) {
+            return suitePath.run(path, () => Reflect.apply(callback, this, callbackArgs));
+        };
+        // node:test reports a suite at its direct caller, as it does a test.
+        const registration = registrationAt(callerLocation(supercovNodeSuite));
+        if (registration)
+            return registration(this === undefined ? original : original.bind(this), next);
+        return Reflect.apply(original, this, next);
+    };
+    for (const property of ["skip", "todo", "only"]) {
+        const member = original[property];
+        if (typeof member === "function")
+            Object.defineProperty(wrapped, property, {
+                configurable: true,
+                enumerable: true,
+                value: wrappedSuite(member),
+            });
+    }
+    return wrapped;
+}
 const registrationCounts = new Map();
 function wrappedRegistration(original, parentTestId, forcedStatus) {
     const wrapped = function supercovNodeTest(...args) {
@@ -96,7 +134,9 @@ function wrappedRegistration(original, parentTestId, forcedStatus) {
         const location = callerLocation(supercovNodeTest);
         const identity = {
             runner: "node:test",
-            name: testName(args, callback),
+            name: parentTestId
+                ? testName(args, callback)
+                : [...(suitePath.getStore() ?? []), testName(args, callback)].join(" > "),
             ...(parentTestId ? { parentTestId } : {}),
             ...location,
             // Source-map producers disagree about whether a call expression maps to
@@ -260,8 +300,8 @@ function restoringHook(original, scope, hookName = "hook") {
 }
 export const test = wrappedRegistration(native.test);
 export const it = wrappedRegistration(native.it);
-export const suite = native.suite;
-export const describe = native.describe;
+export const suite = wrappedSuite(native.suite);
+export const describe = wrappedSuite(native.describe);
 export const before = restoringHook(native.before, undefined, "before");
 export const after = restoringHook(native.after, undefined, "after");
 export const beforeEach = restoringHook(native.beforeEach, undefined, "beforeEach");
@@ -270,4 +310,18 @@ export const mock = native.mock;
 export const snapshot = native.snapshot;
 export const run = native.run;
 export const assert = native.assert;
+// node:test hangs its whole API off `test` (test.mock, test.describe,
+// test.expectFailure, test.getTestContext...). What the adapter does not wrap
+// stays the runtime's own.
+const adapted = { it, describe, suite, before, after, beforeEach, afterEach, test };
+for (const property of Object.keys(native.test)) {
+    if (property in test && !(property in adapted))
+        continue;
+    Object.defineProperty(test, property, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value: adapted[property] ?? native.test[property],
+    });
+}
 export default test;

package/runtime/javascript/playwright.mjs

@@ -31,6 +31,35 @@ const targetTestExport = process.env["SUPERCOV_PLAYWRIGHT_TEST_EXPORT"] ??
 const adapter = (targetModule === "@playwright/test"
     ? standardPlaywright
     : await import(__rewriteRelativeImportExtension(targetModule)));
+// A page that loads the application as plain `<script>` files, from a static
+// server, has no bundler to import the runtime the way a module graph would,
+// and instrumented classic scripts read it from a global. Install the same
+// self-contained runtime in every document before any of the page's scripts
+// run. Every copy keys its state on the page's global, so this copy and one a
+// bundler imports record into the same place. Its locals stay inside a
+// function, out of the page's global scope.
+const browserRuntimeSource = readFileSync(new URL("./runtime.mjs", import.meta.url), "utf8");
+const browserRuntimeExport = browserRuntimeSource.lastIndexOf("\nexport {");
+if (/^import\s/m.test(browserRuntimeSource) || browserRuntimeExport < 0)
+    throw new Error("Supercov's browser runtime must stay self-contained");
+const browserRuntimePrelude = `(() => { if (globalThis.__SUPERCOV_DIRECT_RUNTIME__) return;\n${browserRuntimeSource.slice(0, browserRuntimeExport)}\n})();`;
+// A worker blocked in `Atomics.wait` runs no evaluation until the page wakes
+// it, and the page action that wakes it comes after Supercov's own call: an
+// awaited evaluation deadlocked Actual's suite. Every worker evaluation is
+// bounded; one that does not answer in time is left queued, and a test whose
+// worker evidence could not be read is recorded as partial, never as complete.
+const WORKER_ACTIVATION_WAIT_MS = 250;
+const WORKER_SNAPSHOT_WAIT_MS = 5000;
+const WORKER_TIMED_OUT = Symbol("worker did not answer");
+function bounded(promise, milliseconds) {
+    let timer;
+    return Promise.race([
+        promise,
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve(WORKER_TIMED_OUT), milliseconds);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
 const base = (adapter[targetTestExport] ?? adapter.test);
 const baseExpect = adapter.expect;
 const GENERATED_EVIDENCE_DIRECTORY = "__SUPERCOV_EVIDENCE_DIRECTORY__";
@@ -187,6 +216,21 @@ class CoveragePhaseController {
     // closed page cannot be evaluated, so the evidence is taken on the way out.
     earlySnapshots = [];
     snapshottedPages = new WeakSet();
+    snapshottedWorkers = new WeakSet();
+    // Workers that did not answer an evaluation in time. They are not waited
+    // for again until one answers.
+    unresponsiveWorkers = new WeakSet();
+    // Each worker's token, under which it pushes its evidence to its pages
+    // before it blocks in Atomics.wait (see runtime.mjs).
+    workerTokens = new WeakMap();
+    // Workers that answered their registration without Supercov's runtime: a
+    // worker built from a string (a `blob:` URL), or from a script nobody
+    // instrumented. There is no phase to set in them and no evidence to read,
+    // and Actual's blocked ones were most of what each step waited for.
+    workersWithoutRuntime = new WeakSet();
+    // Set when a worker's evidence could not be read: the test's coverage is
+    // then a lower bound.
+    workerEvidenceMissing = false;
     disposed = false;
     // Parameter properties are stateful despite the base ESLint rule treating
     // this as an empty constructor.
@@ -216,21 +260,79 @@ class CoveragePhaseController {
             snapshots.push(...(await this.snapshotPage(page)));
         }
         for (const worker of this.allWorkers()) {
-            const snapshot = await worker
-                .evaluate(() => {
-                const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
-                return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
-            })
-                .catch(() => ({
-                decisions: [],
-                hits: [],
-                events: [],
-            }));
-            snapshots.push(snapshot);
+            if (this.snapshottedWorkers.has(worker))
+                continue;
+            const snapshot = await this.snapshotWorker(worker, this.allPages());
+            if (snapshot)
+                snapshots.push(snapshot);
         }
         this.runtimeSnapshots = snapshots;
         return snapshots;
     }
+    /**
+     * A worker's evidence, or nothing when it cannot be read. A worker that
+     * closed with its page has nothing left to read; one that did not answer
+     * in time is still running and its evidence is missing from this test.
+     */
+    async snapshotWorker(worker, pages) {
+        if (this.workersWithoutRuntime.has(worker)) {
+            // Asked once more, without waiting: it may have loaded an
+            // instrumented script since it was registered.
+            const answer = await bounded(worker
+                .evaluate(() => globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__?.())
+                .catch(() => undefined), WORKER_ACTIVATION_WAIT_MS);
+            if (answer && answer !== WORKER_TIMED_OUT) {
+                this.snapshottedWorkers.add(worker);
+                return answer;
+            }
+            return undefined;
+        }
+        const answer = await bounded(worker
+            .evaluate(() => {
+            const getSnapshot = globalThis.__SUPERCOV_COVERAGE_SNAPSHOT__;
+            return getSnapshot?.() ?? { decisions: [], hits: [], events: [] };
+        })
+            .catch(() => undefined), WORKER_SNAPSHOT_WAIT_MS);
+        if (answer === WORKER_TIMED_OUT) {
+            this.unresponsiveWorkers.add(worker);
+            // Blocked in Atomics.wait, it pushed what it recorded before it
+            // blocked; that is all of it while the push is current.
+            const pushed = await this.pushedWorkerEvidence(worker, pages);
+            if (pushed?.current) {
+                this.snapshottedWorkers.add(worker);
+                return pushed.snapshot;
+            }
+            this.workerEvidenceMissing = true;
+            return pushed?.snapshot;
+        }
+        this.snapshottedWorkers.add(worker);
+        return answer;
+    }
+    /**
+     * A worker's latest push, found by the token it answered with when it was
+     * registered, or else by its URL when no other worker of the page pushed
+     * from the same one: a worker that blocks on its first message may never
+     * have answered at all.
+     */
+    async pushedWorkerEvidence(worker, pages) {
+        const token = this.workerTokens.get(worker);
+        const url = worker.url();
+        for (const page of pages) {
+            const pushed = await bounded(page
+                .evaluate(({ token, url }) => {
+                const entries = globalThis.__SUPERCOV_WORKER_EVIDENCE__?.() ?? [];
+                const byToken = token ? entries.find((entry) => entry.token === token) : undefined;
+                if (byToken)
+                    return byToken;
+                const byUrl = entries.filter((entry) => entry.url === url);
+                return byUrl.length === 1 ? byUrl[0] : undefined;
+            }, { token, url })
+                .catch(() => undefined), WORKER_ACTIVATION_WAIT_MS);
+            if (pushed && pushed !== WORKER_TIMED_OUT)
+                return pushed;
+        }
+        return undefined;
+    }
     async snapshotPage(page) {
         const snapshots = [];
         for (const frame of page.frames()) {
@@ -253,6 +355,16 @@ class CoveragePhaseController {
             return;
         this.snapshottedPages.add(page);
         this.earlySnapshots.push(...(await this.snapshotPage(page)));
+        // A dedicated worker ends with the page that owns it, so it is read
+        // now; read after the page closed, a worker that ran the test's code
+        // reported nothing.
+        for (const worker of page.workers()) {
+            if (this.snapshottedWorkers.has(worker))
+                continue;
+            const snapshot = await this.snapshotWorker(worker, [page]);
+            if (snapshot)
+                this.earlySnapshots.push(snapshot);
+        }
     }
     /**
      * Register every live context the process created outside the wrapped
@@ -299,6 +411,7 @@ class CoveragePhaseController {
         this.contextConfiguredHeaders.set(context, configuredHeaders);
         if (adopted)
             this.adoptedContexts.add(context);
+        await context.addInitScript({ content: browserRuntimePrelude }).catch(() => undefined);
         // A context that outlives its test (a worker-scoped browser fixture)
         // is registered again by every later test, so this script accumulates
         // on it and each new document runs every copy in registration order.
@@ -359,15 +472,19 @@ class CoveragePhaseController {
             return;
         this.workers.add(worker);
         const phaseId = this.requestPhaseId();
-        await worker
+        const registration = await worker
             .evaluate(({ attemptId, scopeHeader, scopeValue, phaseHeader, phase }) => {
             globalThis.__SUPERCOV_MCDC_TEST_ID__ = attemptId;
             if (phase)
                 globalThis.__SUPERCOV_PHASE_ID__ = phase;
             globalThis.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(attemptId, phase);
+            const answer = {
+                token: globalThis.__SUPERCOV_WORKER_TOKEN__,
+                runtime: typeof globalThis.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__ === "function",
+            };
             const originalFetch = globalThis.fetch?.bind(globalThis);
             if (!originalFetch)
-                return;
+                return answer;
             globalThis.fetch = ((input, init) => {
                 const headers = new Headers(init?.headers ??
                     (input instanceof Request ? input.headers : undefined));
@@ -376,6 +493,7 @@ class CoveragePhaseController {
                     headers.set(phaseHeader, phase);
                 return originalFetch(input, { ...init, headers });
             });
+            return answer;
         }, {
             attemptId: this.scope.attemptId,
             scopeHeader: COVERAGE_SCOPE_HEADER,
@@ -384,6 +502,10 @@ class CoveragePhaseController {
             phase: phaseId,
         })
             .catch(() => undefined);
+        if (typeof registration?.token === "string")
+            this.workerTokens.set(worker, registration.token);
+        if (registration?.runtime === false)
+            this.workersWithoutRuntime.add(worker);
     }
     async beginAction(operation) {
         timingCount("beginAction");
@@ -565,10 +687,25 @@ class CoveragePhaseController {
         };
         return scoped;
     }
+    /**
+     * Tell every context, frame, worker and future document of the test about
+     * a new phase. The four go to different targets and none waits on another,
+     * so they run together: an action waits for the slowest instead of their
+     * sum, which was most of what Actual's suite spent under Supercov (47 of
+     * the 43 extra seconds, with the database worker's bounded wait the
+     * largest part).
+     */
     async activateInBrowser(phaseId) {
-        await timed("activate.contextHeaders", () => Promise.all([...this.contexts]
-            .filter((context) => !this.adoptedContexts.has(context))
-            .map((context) => this.updateContextHeaders(context, phaseId))));
+        await Promise.all([
+            timed("activate.contextHeaders", () => Promise.all([...this.contexts]
+                .filter((context) => !this.adoptedContexts.has(context))
+                .map((context) => this.updateContextHeaders(context, phaseId)))),
+            this.activateFrames(phaseId),
+            this.activateWorkers(phaseId),
+            timed("activate.pageScript", () => Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId)))),
+        ]);
+    }
+    async activateFrames(phaseId) {
         await timed("activate.frameEvaluate", () => Promise.all([...this.pages].flatMap((page) => page.frames()).map((frame) => frame
             .evaluate(({ id, attemptId, storageKey, scopeCookie, scopeValue, phaseCookie }) => {
             globalThis.__SUPERCOV_PHASE_ID__ = id;
@@ -595,14 +732,25 @@ class CoveragePhaseController {
             phaseCookie: COVERAGE_PHASE_COOKIE,
         })
             .catch(() => undefined))));
-        await timed("activate.workerEvaluate", () => Promise.all([...this.workers].map((worker) => worker
-            .evaluate((id) => {
-            const coverageGlobal = globalThis;
-            coverageGlobal.__SUPERCOV_PHASE_ID__ = id;
-            coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
-        }, phaseId)
-            .catch(() => undefined))));
-        await timed("activate.pageScript", () => Promise.all([...this.pages].map((page) => this.activatePage(page, phaseId))));
+    }
+    async activateWorkers(phaseId) {
+        await timed("activate.workerEvaluate", () => Promise.all([...this.workers].map(async (worker) => {
+            const activation = worker
+                .evaluate((id) => {
+                const coverageGlobal = globalThis;
+                coverageGlobal.__SUPERCOV_PHASE_ID__ = id;
+                coverageGlobal.__SUPERCOV_ACTIVATE_PROBE_CONTEXT__?.(coverageGlobal.__SUPERCOV_MCDC_TEST_ID__ ?? "unscoped", id);
+            }, phaseId)
+                .then(() => this.unresponsiveWorkers.delete(worker))
+                .catch(() => undefined);
+            // Evaluations run in order, so one left queued still applies this
+            // phase before any later one; it is only not waited for. One with
+            // no runtime has nothing to apply unless it loads some later.
+            if (this.unresponsiveWorkers.has(worker) || this.workersWithoutRuntime.has(worker))
+                return;
+            if ((await bounded(activation, WORKER_ACTIVATION_WAIT_MS)) === WORKER_TIMED_OUT)
+                this.unresponsiveWorkers.add(worker);
+        })));
     }
     async updateContextHeaders(context, phaseId) {
         await context
@@ -804,6 +952,30 @@ globalThis.__SUPERCOV_ASSERTION_PHASE_BRIDGE__ = (operation, source, callback) =
         throw error;
     }
 };
+// The same bridge for an assertion that runs in place: the runtime enters the
+// carrier and calls release when the call returns, finish when it settles.
+globalThis.__SUPERCOV_ASSERTION_PHASE_OPENER__ = (operation, source) => {
+    const controller = activeController;
+    if (!controller || !directRuntime())
+        return undefined;
+    const phase = controller.beginAssertion(operation, source);
+    bridgedAssertionDepth += 1;
+    let held = true;
+    const release = () => {
+        if (held) {
+            held = false;
+            bridgedAssertionDepth -= 1;
+        }
+    };
+    return {
+        carrier: { version: 1, scope: controller.scope, phaseId: phase.id },
+        release,
+        finish: (error) => {
+            release();
+            controller.finish(phase, error);
+        },
+    };
+};
 function activeCoverageHeaders() {
     const controller = activeController;
     if (!controller)
@@ -890,9 +1062,10 @@ function scopedChildOptions(args, optionIndex) {
         : {};
     const options = {
         ...existing,
+        // An env the caller passed is the child's whole environment; only
+        // Supercov's own variables join it. Without one, it inherits ours.
         env: {
-            ...process.env,
-            ...(existing.env ?? {}),
+            ...(existing.env ?? process.env),
             SUPERCOV_RUN_ID: controller.scope.runId,
             [COVERAGE_CARRIER_ENV]: encodeCoverageCarrier({
                 version: 1,
@@ -909,13 +1082,48 @@ function scopedChildOptions(args, optionIndex) {
         scoped[optionIndex] = options;
     return scoped;
 }
+// spawn, fork and execFile take (file, args?, options?, callback?): options
+// follow an argument list, or an explicit null or undefined in its place.
 function childOptionIndex(method, args) {
-    if (method === "spawn" || method === "spawnSync" || method === "fork")
-        return Array.isArray(args[1]) ? 2 : 1;
-    if (method === "execFile" || method === "execFileSync")
-        return Array.isArray(args[1]) ? 2 : 1;
+    if (method === "spawn" ||
+        method === "spawnSync" ||
+        method === "fork" ||
+        method === "execFile" ||
+        method === "execFileSync")
+        return Array.isArray(args[1]) || (args[1] == null && args.length > 2) ? 2 : 1;
     return 1;
 }
+// util.promisify(exec) and util.promisify(execFile) resolve { stdout, stderr }
+// through a function Node keeps on the original, and that function calls the
+// original. A wrapper carries its own, which calls the wrapper, or a promisified
+// call resolves the bare stdout string and skips the wrapper.
+const promisifyCustom = Symbol.for("nodejs.util.promisify.custom");
+function keepPromisifiedShape(original, wrapper) {
+    if (typeof original[promisifyCustom] !== "function")
+        return wrapper;
+    Object.defineProperty(wrapper, promisifyCustom, {
+        configurable: true,
+        value: (...args) => {
+            let settle;
+            let reject;
+            const promise = new Promise((ok, fail) => {
+                settle = ok;
+                reject = fail;
+            });
+            promise.child = wrapper(...args, (error, stdout, stderr) => {
+                if (error !== null) {
+                    error.stdout = stdout;
+                    error.stderr = stderr;
+                    reject(error);
+                }
+                else
+                    settle({ stdout, stderr });
+            });
+            return promise;
+        },
+    });
+    return wrapper;
+}
 function installChildProcessScopePropagation() {
     for (const method of [
         "exec",
@@ -927,9 +1135,9 @@ function installChildProcessScopePropagation() {
         "spawnSync",
     ]) {
         const original = childProcess[method];
-        childProcess[method] = function (...args) {
+        childProcess[method] = keepPromisifiedShape(original, function (...args) {
             return Reflect.apply(original, childProcess, scopedChildOptions(args, childOptionIndex(method, args)));
-        };
+        });
     }
     syncBuiltinESMExports();
 }
@@ -1154,6 +1362,7 @@ const instrumentedFixtures = {
                             explicitKind: process.env["SUPERCOV_TEST_KIND"],
                         }),
                         phases: mergeCollectedPhases(controller.phases, directRuntime()?.takeNodeAssertionPhases(scope) ?? []),
+                        ...(controller.workerEvidenceMissing ? { attribution: "partial" } : {}),
                         browser,
                         server,
                     };

package/runtime/javascript/provenance.mjs

@@ -100,7 +100,7 @@ export function inferTestProvenance({ runner, file, project, explicitKind, }) {
             source: "path",
         };
     }
-    const defaultKind = runner === "vitest" || runner === "jest" || runner === "node:test"
+    const defaultKind = runner === "vitest" || runner === "jest" || runner === "node:test" || runner === "mocha" || runner === "ava" || runner === "tap"
         ? "unit"
         : "unknown";
     return {