@uniflowed/test 0.0.0-alpha.9 → 0.2.0

package/worker.js

@@ -49,14 +49,29 @@
 
 import * as output from "./internal/output.js";
 import { AsyncLocalStorage } from "node:async_hooks";
+import process from "node:process";
 import { writeChangedSnapshots } from "./internal/snapshot.js";
 import { createInterface } from "node:readline";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-import { reset } from "./internal/registry.js";
-import { resetModuleState } from "./internal/modules.js";
+import { installInSourceTests } from "./in-source.js";
+import { restoreSharedState } from "./internal/isolation.js";
 import { run } from "./internal/run.js";
 
+// `process` is imported rather than read off the global because this file is
+// the process entry point, and an entry point that names what it depends on is
+// one a reader does not have to trust.
+//
+// It used to be put *on* the global as well. Deno 1.x exposed the object as
+// `node:process` and nothing as `globalThis.process`, and every module this
+// worker reaches that wants the process reads the global: `internal/output.js`
+// replaces `process.stdout.write`, `internal/namespace.js` reads
+// `process.env` for `stubEnv`, and `internal/axe.js` reads `UF_AXE`. The Deno
+// uf starts is 2.8 or newer — `@uniflowed/host/deno-preload` is built on that
+// release's `registerHooks`, and `uf test` refuses anything older — and Deno 2
+// has the global like Node and Bun. A shim for a host uf no longer starts would
+// be a line claiming to be load-bearing while holding nothing up.
+
 /** What `uf` sends for one file. */
 type Request = {|
   readonly file: string,
@@ -137,18 +152,80 @@ function write(event: { readonly [string]: mixed }): void {
  * the `serving` store this runs inside — it is what every event written from
  * this file, or from anything this file leaves behind, is stamped with.
  */
+/**
+ * Whether this is a run of the benchmarks, `uf test --bench`.
+ *
+ * Read from the environment, as snapshot updates are: it is a property of the
+ * run, set once on the worker by `uf`, and not something each request says.
+ */
+function benching(): boolean {
+  const value = (globalThis: $FlowFixMe).process?.env?.UF_TEST_BENCH;
+  return value != null && value !== "" && value !== "0";
+}
+
 async function runFile(request: Request, generation: number): Promise<void> {
   const started = performance.now();
-  reset();
-  // Every module this file stood in for goes back, before the next file can
-  // import one of them and be handed the previous file's stand-in. A worker
-  // serves many files out of one module registry, so this is the difference
-  // between "one file at a time" and "one file's mocks at a time".
-  resetModuleState();
+  // Everything the previous file changed and this package shares with it goes
+  // back: the registry, the stubbed environment and globals, the clock, the
+  // module stand-ins, and the document. What each of those is and why it is on
+  // the list is `internal/isolation.js`, which is one place rather than five
+  // calls here — a worker serves many files out of one process, `uf test` fans
+  // files across workers by size, and a leak therefore makes the *result* of a
+  // suite a function of the timings file rather than of the code under test.
+  // See ubugeeei-prod/uf#417, #581 and #607, which are that sentence three
+  // times over.
+  //
+  // Before the import rather than after the run, so a file that throws while
+  // loading still hands the next one a clean process.
+  restoreSharedState();
+  // Not a restore, and so not on that list: this is the output budget for the
+  // file about to run, rather than something the previous file left behind.
   output.startFile();
 
+  // In-source blocks in *this* file get uf's test API; the same blocks in
+  // every module this file imports get `undefined` and do not register. See
+  // `./in-source.js` for why the marker is a call rather than a constant.
+  const url = pathToFileURL(request.file).href;
+  const uninstallInSourceTests = installInSourceTests(url);
+  try {
+    await runImportedFile(request, generation, url, started);
+  } finally {
+    // For the whole file rather than only for its import. A block reads the
+    // marker at module scope, but a *case body* may read it too — `const
+    // { uft } = import.meta.uf.test` inside an `it` is an ordinary thing to
+    // write — and a marker that answered during the import and not during the
+    // run would be a value that changed under the file that read it.
+    //
+    // Taking it away earlier would not buy the isolation it looks like it
+    // buys: work a finished file left behind can register through a binding it
+    // captured just as easily as through this global, so the thing that keeps
+    // a straggler out of the next file is the registry reset at the top of
+    // this function and the generation stamped on every event, not the
+    // lifetime of one accessor.
+    uninstallInSourceTests();
+  }
+}
+
+/**
+ * The half of [`runFile`] that has a file to run.
+ *
+ * Split out so the caller's `finally` covers the import *and* the run without
+ * either of the two `return`s below escaping it.
+ */
+async function runImportedFile(
+  request: Request,
+  generation: number,
+  url: string,
+  started: number,
+): Promise<void> {
+  let closeNative: (() => Promise<void>) | null = null;
   try {
-    await import(`${pathToFileURL(request.file).href}?uf-run=${generation}`);
+    if (process.env.UF_TEST_TARGET === "react-native") {
+      const { loadNativeFile } = await import("./internal/native-host.js");
+      closeNative = await loadNativeFile(request.file);
+    } else {
+      await import(`${url}?uf-run=${generation}`);
+    }
   } catch (thrown) {
     const error = thrown instanceof Error ? thrown : new Error(String(thrown));
     write({
@@ -164,7 +241,12 @@ async function runFile(request: Request, generation: number): Promise<void> {
   try {
     const absolute = fileURLToPath(pathToFileURL(request.file).href);
     await run(
-      { filter: request.filter ?? null, timeoutMs: request.timeoutMs, file: absolute },
+      {
+        filter: request.filter ?? null,
+        timeoutMs: request.timeoutMs,
+        file: absolute,
+        bench: benching(),
+      },
       (result) => {
         write({
           event: "test",
@@ -180,12 +262,18 @@ async function runFile(request: Request, generation: number): Promise<void> {
     // with forty snapshots would otherwise rewrite its snapshot file forty
     // times, and a crash halfway through would leave a partial one.
     writeChangedSnapshots();
+    await closeNative?.();
     write({
       event: "file",
       status: "completed",
       durationMicros: Math.round((performance.now() - started) * 1000),
     });
   } catch (thrown) {
+    try {
+      await closeNative?.();
+    } catch {
+      // Preserve the original run or teardown failure.
+    }
     const error = thrown instanceof Error ? thrown : new Error(String(thrown));
     write({
       event: "file",
@@ -267,4 +355,21 @@ process.on("unhandledRejection", (reason: mixed) => {
   process.exit(1);
 });
 
+// The same for an exception nothing caught — a server's `error` event with no
+// listener, a throw from a timer callback. Node's default prints the stack to
+// stderr and exits, and all `uf` could then say was that the worker had died:
+// the file that did it went unnamed, and the message was somewhere above the
+// report, unattributed. Reported the way a rejection is, it is the failure of
+// the file whose work threw, with its message and stack in the file's result.
+process.on("uncaughtException", (thrown: mixed) => {
+  const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+  write({
+    event: "file",
+    status: "run-failed",
+    message: `uncaught exception: ${error.message}`,
+    stack: error.stack ?? null,
+  });
+  process.exit(1);
+});
+
 serve();