@uniflowed/test 0.4.0 → 0.6.0

package/internal/browser/page-transport.js

@@ -1,5 +1,6 @@
 // @flow
 import type { BrowserTransport, ControlOptions } from "./cdp.js";
+import { runnerFetch } from "./runner-fetch.js";
 
 export async function createTransport(options: ControlOptions): Promise<BrowserTransport> {
   if (options.executable != null)
@@ -12,7 +13,8 @@ export async function createTransport(options: ControlOptions): Promise<BrowserT
     method: string,
     args: $ReadOnlyArray<mixed> = [],
   ): Promise<$FlowFixMe> {
-    const response = await fetch("/uf-test/browser", {
+    // The platform's `fetch`, not the global a test's request mock replaced.
+    const response = await runnerFetch("/uf-test/browser", {
       method: "POST",
       headers: { "content-type": "application/json", "uf-test-browser": token },
       body: JSON.stringify({ id, method, args }),

package/internal/browser/page.js

@@ -37,6 +37,7 @@
 import * as output from "../output.js";
 import { run } from "../run.js";
 import { installInSourceTests } from "../../in-source.js";
+import { runnerFetch } from "./runner-fetch.js";
 
 /** One file, as the server hands it over. */
 type PageRequest = {
@@ -74,7 +75,9 @@ function flush(): Promise<void> {
   if (already != null) return already;
   if (queue.length === 0) return Promise.resolve();
   const batch = queue.splice(0, queue.length);
-  const sent = fetch("/uf-test/events", {
+  // Not the global: a file that installed a request mock owns that one, and
+  // would answer the runner's report as an unhandled request.
+  const sent = runnerFetch("/uf-test/events", {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify(batch),
@@ -195,7 +198,7 @@ function page(): $FlowFixMe {
 async function serve(): Promise<void> {
   let request: PageRequest;
   try {
-    request = await (await fetch("/uf-test/next")).json();
+    request = await (await runnerFetch("/uf-test/next")).json();
   } catch {
     // The driver has gone. Nothing to report it to.
     return;

package/internal/browser/runner-fetch.js

@@ -0,0 +1,38 @@
+// @flow
+//
+// Internal to `@uniflowed/test`: the `fetch` the browser runner talks to `uf`
+// with.
+//
+// A page reports its results over HTTP — `POST /uf-test/events`, and
+// `POST /uf-test/browser` for `createBrowser` — and the file under test runs
+// in that same page. A file that installs a request mock replaces
+// `globalThis.fetch`, and `@uniflowed/mock`'s default policy rejects every
+// request no handler claimed. Reached through the global, the runner's own
+// requests would be answered by the test's mock: rejected, and the rejection
+// swallowed by the reporter, so the results would never reach `uf test`
+// (ubugeeei-prod/uf#1394).
+//
+// So the harness captures the platform's `fetch` in a classic script that runs
+// before any module — before the runner, and so before any test file could
+// replace it — and the runner's requests go through that capture. A constant
+// captured in this module would depend on when it was first evaluated and on
+// `page.js` and the import map reaching it by the same URL; the harness
+// script depends on neither.
+
+/** Where `server.js`'s harness leaves the platform's `fetch`. */
+export const RUNNER_FETCH: symbol = Symbol.for("uf.test.browser.fetch");
+
+/**
+ * `fetch`, as it was before any test file ran.
+ *
+ * Falls back to the global when nothing was captured, which is a page not
+ * served by `uf test --browser` — there is no test file ahead of it to have
+ * replaced anything.
+ */
+export function runnerFetch(input: RequestInfo, init?: RequestOptions): Promise<Response> {
+  const captured = Reflect.get(globalThis, RUNNER_FETCH);
+  if (typeof captured === "function") {
+    return captured(input, init);
+  }
+  return fetch(input, init);
+}

package/internal/browser/server.js

@@ -639,6 +639,10 @@ function harnessHtml(map: string, browserToken: string): string {
     '<meta charset="utf-8">',
     "<title>uf test</title>",
     `<script>globalThis[Symbol.for("uf.test.browser.token")]=${JSON.stringify(browserToken)}</script>`,
+    // Before any module, so before any test file can replace it: the runner
+    // reports through this `fetch`, never through a mocked global. See
+    // `./runner-fetch.js`.
+    '<script>globalThis[Symbol.for("uf.test.browser.fetch")]=globalThis.fetch.bind(globalThis)</script>',
     `<script type="importmap">${map}</script>`,
     `<script type="module" src="${page}"></script>`,
     "",

package/internal/frames.js

@@ -252,6 +252,14 @@ function sourceMapsForCallSites(): FindSourceMap | false {
     nodeSourceMaps = false;
     return false;
   }
+  // A `uf test` worker whose loader maps lazily holds the maps Node would
+  // have, and answers for them the way `findSourceMap` would; see
+  // `@uniflowed/host`'s `internal/lazy-source-maps.js`.
+  const lazy = host[Symbol.for("@uniflowed/host/source-maps")];
+  if (typeof lazy?.findSourceMap === "function") {
+    nodeSourceMaps = (file) => lazy.findSourceMap(file);
+    return nodeSourceMaps;
+  }
   const findSourceMap = process.getBuiltinModule("node:module")?.findSourceMap;
   nodeSourceMaps =
     typeof findSourceMap === "function"

package/internal/run.js

@@ -75,6 +75,19 @@ export type RunOptions = {|
    * round. `uf test --bench` sets it.
    */
   readonly bench?: boolean,
+  /**
+   * Run only share `index` of `count` of the file's cases, and report nothing
+   * about the rest.
+   *
+   * `uf test` splits a file long enough to hold up a run across several
+   * workers, and each is handed one share: the cases are numbered in the
+   * order the file registered them, and share `index` is the contiguous run
+   * from `index * n / count` to `(index + 1) * n / count`. Every worker
+   * imports the whole file and walks the same tree, so the shares between
+   * them report every case once. A case outside the share is not reported at
+   * all — not as skipped — because another worker is reporting it.
+   */
+  readonly part?: {| readonly index: number, readonly count: number |} | null,
 |};
 
 /** Default budget for one case, matching what most runners use. */
@@ -381,7 +394,7 @@ async function runSuite(
   options: RunOptions,
   onlyMode: boolean,
   emit: (result: Result) => void,
-  state: {| bail: boolean |},
+  state: {| bail: boolean, readonly owned: Set<Case> | null |},
   setUpAncestors: () => Promise<void>,
 ): Promise<boolean> {
   const skipped = context.skipped || node.modifier === "skip" || node.modifier === "todo";
@@ -430,6 +443,10 @@ async function runSuite(
       break;
     }
     if (child.kind !== "suite") {
+      // Another worker's share: it reports this case, and sets up for it.
+      if (state.owned != null && !state.owned.has(child)) {
+        continue;
+      }
       const willRun =
         !inner.skipped &&
         child.modifier !== "skip" &&
@@ -490,6 +507,7 @@ async function runSuite(
 export async function run(options: RunOptions, emit: (result: Result) => void): Promise<void> {
   const root = collected();
   const onlyMode = hasOnly(root, false);
+  const owned = share(root, options.part);
   const context: Context = {
     path: [],
     beforeEach: [],
@@ -497,5 +515,36 @@ export async function run(options: RunOptions, emit: (result: Result) => void):
     skipped: false,
     onlyPath: !onlyMode,
   };
-  await runSuite(root, context, options, onlyMode, emit, { bail: false }, async () => {});
+  await runSuite(root, context, options, onlyMode, emit, { bail: false, owned }, async () => {});
+}
+
+/**
+ * The cases of `part`, or `null` for a run of every case.
+ *
+ * Numbered in the order a walk of the tree meets them, which is the order the
+ * file registered them and the order `runSuite` runs them in — the same in
+ * every worker that imported the file, which is what lets each work out its
+ * own share without being told the others'.
+ */
+function share(
+  root: Suite,
+  part: ?{| readonly index: number, readonly count: number |},
+): Set<Case> | null {
+  if (part == null || part.count < 2) {
+    return null;
+  }
+  const cases: Array<Case> = [];
+  const walk = (node: Suite) => {
+    for (const child of node.children) {
+      if (child.kind === "suite") {
+        walk(child);
+      } else {
+        cases.push(child);
+      }
+    }
+  };
+  walk(root);
+  const from = Math.floor((part.index * cases.length) / part.count);
+  const to = Math.floor(((part.index + 1) * cases.length) / part.count);
+  return new Set(cases.slice(from, to));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/test",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "The test API and worker for `uf test`: describe/it, a full matcher set, and the process uf fans test files out to.",
   "type": "module",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "!*.test.js"
   ],
   "dependencies": {
-    "@uniflowed/host": "0.4.0",
+    "@uniflowed/host": "0.6.0",
     "pixelmatch": "^7.1.0",
     "pngjs": "^7.0.0"
   },

package/worker.js

@@ -86,6 +86,8 @@ type Request = {|
    */
   readonly invalidate?: $ReadOnlyArray<string>,
   readonly filter?: string | null,
+  /** Run only this share of the file's cases; see `RunOptions.part`. */
+  readonly part?: {| readonly index: number, readonly count: number |} | null,
   readonly timeoutMs?: number,
   /**
    * Which request this is, counting from one within this worker.
@@ -259,6 +261,7 @@ async function runImportedFile(
     await run(
       {
         filter: request.filter ?? null,
+        part: request.part ?? null,
         timeoutMs: request.timeoutMs,
         file: absolute,
         bench: benching(),