@itmetsam/samurai-framework 0.22.0 → 0.22.1

package/dist/runner/fixture-scope.js

@@ -1,65 +1,49 @@
+import { toTestError } from "./test-error.js";
 import { requestedBy } from "./fixture-args.js";
 import { BUILT_IN_FIXTURES, dependencyOf, } from "./fixture-defs.js";
-/** A custom fixture whose setup threw or never called `use` */
-export class FixtureSetupError extends Error {
-    constructor(name, cause) {
-        super(`fixture "${name}" setup failed: ${messageOf(cause)}`);
-        this.name = "FixtureSetupError";
-        if (cause instanceof Error && cause.stack)
-            this.stack = cause.stack;
-    }
-}
-const messageOf = (err) => err instanceof Error ? err.message : String(err);
-/** Runs `setup` until it calls `use`; resolves with the value and the means to finish it */
-function startSetup(def, args) {
-    return new Promise((resolve, reject) => {
-        let release = () => { };
-        const released = new Promise((r) => (release = r));
-        let used = false;
-        let running;
-        const done = () => running ?? Promise.resolve();
-        const use = async (value) => {
-            if (used)
-                throw new Error("use() was called twice");
-            used = true;
-            resolve({ value, release, done });
-            await released;
-        };
-        running = (async () => def.setup?.(args, use))();
-        running.then(() => {
-            if (!used)
-                reject(new Error("the setup never called use()"));
-        }, (err) => {
-            if (!used)
-                reject(err);
-        });
-        // A failure after use() is read by teardown; this keeps it from being reported as unhandled meanwhile
-        running.catch(() => { });
-    });
-}
+import { resolveOptions } from "./fixture-options.js";
+import { outputsOf, stableJson } from "./fixture-outputs.js";
+import { finishWithin, FixtureSetupError, startSetup, } from "./fixture-start.js";
+import { WorkerFixtures } from "./fixture-worker.js";
+import { SkipSignal } from "./skip.js";
+/** The built-in fixtures whose value tells worker fixtures apart (the rest are the same for every test of a worker) */
+const KEYED_BUILT_INS = ["browserName", "workerIndex", "baseURL"];
 /**
  * The custom fixtures of one test run. Fixtures are set up when a test or hook asks for them (by destructuring
  * them), their dependencies first, and torn down in the opposite order. The hooks and the body of a test share
- * one scope, so they see the same instances.
+ * one scope, so they see the same instances. Worker-scoped fixtures come from the worker's `WorkerFixtures`.
  */
 export class FixtureScope {
-    constructor(layers, base) {
+    constructor(layers, base, run = {}) {
         this.layers = layers;
         this.base = base;
+        this.run = run;
         this.values = new Map();
         this.pending = new Map();
+        /** What was set up for this test, last in the order it is torn down */
         this.started = [];
+        /** The key of each worker fixture set up here, which the fixtures that use it build theirs from */
+        this.keys = new Map();
+        this.entries = [];
+        this.entryOf = new Map();
         this.closed = false;
         const own = Object.getOwnPropertyDescriptors(base);
         for (const descriptor of Object.values(own))
             descriptor.configurable = true;
         this.fixtures = Object.defineProperties({}, own);
+        this.ownsWorkers = run.workers === undefined;
+        this.workers = run.workers ?? new WorkerFixtures(60_000);
     }
-    /** Sets up the fixtures marked `auto` */
+    /** Sets up the fixtures marked `auto`, then those `use` attaches */
     async prepareAuto() {
         for (const [name, defs] of this.layers)
             if (defs[defs.length - 1]?.auto)
                 await this.ensure(name, defs.length - 1);
+        for (const name of this.run.attach ?? []) {
+            const defs = this.layers.get(name);
+            if (defs)
+                await this.ensure(name, defs.length - 1);
+        }
     }
     /** Sets up the custom fixtures `fn` destructures from its first parameter */
     async prepare(fn) {
@@ -75,36 +59,38 @@ export class FixtureScope {
                 throw new Error(`extend(): unknown fixture "${name}"`);
         }
     }
+    /** The fixtures this test set up, in the order they were set up, with how each went so far */
+    report() {
+        return this.entries.map((entry) => structuredClone(entry));
+    }
     /**
-     * Finishes the fixtures that were set up, last first, each within `limitMs`. Returns the first error (a
-     * fixture's cleanup threw or ran out of time); the others still run.
+     * Finishes the fixtures that were set up, last first, each within its own `timeout` else `limitMs`. Returns the
+     * first error (a fixture's cleanup threw or ran out of time); the others still run. The worker fixtures of a
+     * scope that has no worker are finished too.
      */
     async teardown(limitMs) {
         this.closed = true;
         let first;
         for (let one = this.started.pop(); one; one = this.started.pop()) {
-            one.release();
-            let timer;
-            try {
-                await Promise.race([
-                    one.done(),
-                    new Promise((_, reject) => {
-                        timer = setTimeout(() => reject(new Error(`timed out after ${limitMs / 1000} seconds`)), limitMs);
-                    }),
-                ]);
-            }
-            catch (err) {
-                first ??= new Error(`fixture "${one.name}" teardown failed: ${messageOf(err)}`);
-                if (err instanceof Error && err.stack)
-                    first.stack = err.stack;
-            }
-            finally {
-                clearTimeout(timer);
-            }
+            const begin = performance.now();
+            const error = await finishWithin(one, limitMs);
+            const entry = this.entryOf.get(one);
+            if (entry)
+                entry.teardown = {
+                    status: error ? "failed" : "passed",
+                    durationMs: performance.now() - begin,
+                    ...(error && { error: toTestError(error) }),
+                };
+            first ??= error;
         }
+        if (this.ownsWorkers)
+            first ??= (await this.workers.closeAll())[0];
         return first;
     }
     ensure(name, level) {
+        const off = this.run.disabled?.get(name);
+        if (off !== undefined)
+            return Promise.reject(new SkipSignal("skip", off));
         const key = `${name}#${level}`;
         let promise = this.pending.get(key);
         if (!promise) {
@@ -129,15 +115,10 @@ export class FixtureScope {
                 }
             }
             let value = def.value;
-            if (def.setup) {
-                const started = await startSetup(def, args);
-                if (this.closed) {
-                    started.release();
-                    throw new Error("the test is already over");
-                }
-                value = started.value;
-                this.started.push({ name, ...started });
-            }
+            if (def.option)
+                value = resolveOptions(def, this.run.options?.[name], this.base);
+            if (def.setup)
+                value = await this.instantiate(def, level, args);
             this.values.set(`${name}#${level}`, value);
             if (level === (this.layers.get(name)?.length ?? 0) - 1)
                 Object.defineProperty(this.fixtures, name, {
@@ -148,9 +129,97 @@ export class FixtureScope {
                 });
         }
         catch (err) {
-            throw err instanceof FixtureSetupError
+            throw err instanceof FixtureSetupError || err instanceof SkipSignal
                 ? err
                 : new FixtureSetupError(name, err);
         }
     }
+    /** Runs the setup function of `def` (for this test, or through the worker) and records how it went */
+    async instantiate(def, level, args) {
+        const entry = {
+            name: def.name,
+            scope: def.scope,
+            setup: { status: "passed", durationMs: 0 },
+        };
+        const begin = performance.now();
+        try {
+            let instance;
+            if (def.scope === "worker") {
+                const key = this.workerKey(def, level);
+                this.keys.set(`${def.name}#${level}`, key);
+                const got = await this.workers.acquire(def, key, () => this.make(def, args));
+                if (got.reused)
+                    entry.setup.status = "skipped";
+                instance = got;
+            }
+            else {
+                instance = await this.make(def, args);
+                if (this.closed) {
+                    instance.started.release();
+                    throw new Error("the test is already over");
+                }
+                this.started.push(instance.started);
+                this.entryOf.set(instance.started, entry);
+            }
+            if (instance.outputs)
+                entry.outputs = instance.outputs;
+            return instance.value;
+        }
+        catch (err) {
+            entry.setup = {
+                status: "failed",
+                durationMs: 0,
+                error: toTestError(new FixtureSetupError(def.name, err)),
+            };
+            throw err;
+        }
+        finally {
+            if (entry.setup.status !== "skipped")
+                entry.setup.durationMs = performance.now() - begin;
+            this.entries.push(entry);
+        }
+    }
+    /** Starts the setup of `def` until it calls `use`, and checks the declared outputs of the value */
+    async make(def, args) {
+        const started = await startSetup(def, args, def.timeout);
+        const finish = {
+            name: def.name,
+            release: started.release,
+            done: started.done,
+            timeout: def.timeout,
+        };
+        try {
+            const outputs = outputsOf(def, started.value);
+            return { value: started.value, started: finish, outputs };
+        }
+        catch (err) {
+            started.release();
+            await started.done().catch(() => undefined);
+            throw err;
+        }
+    }
+    /**
+     * What makes one instance of a worker fixture different from another: the environment, the values of the
+     * option fixtures it reads, the instances of the worker fixtures it uses and the built-ins that differ
+     */
+    workerKey(def, level) {
+        const parts = [this.run.environment ?? ""];
+        for (const dep of def.deps) {
+            const target = dependencyOf(this.layers, def.name, level, dep);
+            if (target === "built-in" || target === undefined) {
+                if (KEYED_BUILT_INS.includes(dep))
+                    parts.push([dep, this.base[dep]]);
+                continue;
+            }
+            const used = this.layers.get(target.name)?.[target.level];
+            if (used?.option)
+                parts.push([
+                    dep,
+                    { ...used.value, ...this.run.options?.[target.name] },
+                ]);
+            else if (used?.scope === "worker")
+                parts.push([dep, this.keys.get(`${target.name}#${target.level}`)]);
+        }
+        return stableJson(parts);
+    }
 }

package/dist/runner/fixture-start.d.ts

@@ -0,0 +1,27 @@
+import type { FixtureDef } from "./fixture-defs.js";
+/** A custom fixture whose setup threw or never called `use` */
+export declare class FixtureSetupError extends Error {
+    constructor(name: string, cause: unknown);
+}
+/** A fixture that is set up: `release` lets its setup function finish, `done` is that function's end */
+export interface Started {
+    name: string;
+    release: () => void;
+    done: () => Promise<void>;
+    /** The fixture's own `timeout` for its teardown */
+    timeout?: number | undefined;
+}
+/**
+ * Runs `setup` until it calls `use`; resolves with the value and the means to finish it. A setup that takes longer
+ * than `limitMs` fails; if it calls `use` later anyway, it is let go at once.
+ */
+export declare function startSetup(def: FixtureDef, args: Record<string, unknown>, limitMs?: number): Promise<{
+    value: unknown;
+    release: () => void;
+    done: () => Promise<void>;
+}>;
+/**
+ * Lets a set-up fixture finish its cleanup, within the fixture's own `timeout` else `limitMs`. Returns the error
+ * (`fixture "x" teardown failed: ...`) when the cleanup threw or ran out of time.
+ */
+export declare function finishWithin(one: Started, limitMs: number): Promise<Error | undefined>;

package/dist/runner/fixture-start.js

@@ -0,0 +1,76 @@
+/** A custom fixture whose setup threw or never called `use` */
+export class FixtureSetupError extends Error {
+    constructor(name, cause) {
+        super(`fixture "${name}" setup failed: ${messageOf(cause)}`);
+        this.name = "FixtureSetupError";
+        if (cause instanceof Error && cause.stack)
+            this.stack = cause.stack;
+    }
+}
+const messageOf = (err) => err instanceof Error ? err.message : String(err);
+/**
+ * Runs `setup` until it calls `use`; resolves with the value and the means to finish it. A setup that takes longer
+ * than `limitMs` fails; if it calls `use` later anyway, it is let go at once.
+ */
+export function startSetup(def, args, limitMs) {
+    return new Promise((resolve, reject) => {
+        let release = () => { };
+        const released = new Promise((r) => (release = r));
+        let used = false;
+        let running;
+        const done = () => running ?? Promise.resolve();
+        const timer = limitMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                release();
+                reject(new Error(`timed out after ${limitMs / 1000} seconds`));
+            }, limitMs);
+        const use = async (value) => {
+            if (used)
+                throw new Error("use() was called twice");
+            used = true;
+            clearTimeout(timer);
+            resolve({ value, release, done });
+            await released;
+        };
+        running = (async () => def.setup?.(args, use))();
+        running.then(() => {
+            clearTimeout(timer);
+            if (!used)
+                reject(new Error("the setup never called use()"));
+        }, (err) => {
+            clearTimeout(timer);
+            if (!used)
+                reject(err);
+        });
+        // A failure after use() is read by teardown; this keeps it from being reported as unhandled meanwhile
+        running.catch(() => { });
+    });
+}
+/**
+ * Lets a set-up fixture finish its cleanup, within the fixture's own `timeout` else `limitMs`. Returns the error
+ * (`fixture "x" teardown failed: ...`) when the cleanup threw or ran out of time.
+ */
+export async function finishWithin(one, limitMs) {
+    one.release();
+    const limit = one.timeout ?? limitMs;
+    let timer;
+    try {
+        await Promise.race([
+            one.done(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`timed out after ${limit / 1000} seconds`)), limit);
+            }),
+        ]);
+        return undefined;
+    }
+    catch (err) {
+        const failure = new Error(`fixture "${one.name}" teardown failed: ${messageOf(err)}`);
+        if (err instanceof Error && err.stack)
+            failure.stack = err.stack;
+        return failure;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/runner/fixture-use.d.ts

@@ -0,0 +1,23 @@
+import type { SamuraiTestConfig } from "../types/config.js";
+import type { RegisteredTestCase } from "../types/test.js";
+import type { FixtureLayers } from "./fixture-defs.js";
+import type { FixtureCatalogEntry } from "./fixture-registry.js";
+/** What the fixture keys of the `use` layers come to for one test */
+export interface ResolvedFixtureUse {
+    /** The fixtures to set up before `beforeEach`, besides the `auto` ones; one the environment turns off is still listed when a later layer insists, and skips the test */
+    attach: string[];
+    /** Option fixture name to its values from `use`, over the fixture's own default */
+    options: Record<string, Record<string, unknown>>;
+    /** Fixtures the run's environment turns off, with the reason a test that needs one is skipped for */
+    disabled: Map<string, string>;
+}
+/**
+ * The fixtures a test gets from `use`: config, then the run's environment, then the group, then `test.use()`, a
+ * later layer winning key by key. The environment's `false` is the exception: it wins over a `true` anywhere, so a
+ * fixture an environment turns off cannot be switched back on for it.
+ */
+export declare function effectiveFixtureUse(test: RegisteredTestCase): Promise<ResolvedFixtureUse>;
+/** Refuses a config whose `use` (config, environments, groups) names a fixture that is not in `config.fixtures` */
+export declare function checkFixtureUseNames(config: SamuraiTestConfig, catalog: readonly FixtureCatalogEntry[]): void;
+/** Refuses a `test.use()` that names a fixture the test's own `test.extend()` does not define */
+export declare function checkTestFixtureUse(use: object, layers: FixtureLayers | undefined): void;

package/dist/runner/fixture-use.js

@@ -0,0 +1,64 @@
+import { FIXTURES_KEY, mergeFixtureUse, pickFixtureUse, } from "../config/fixture-use.js";
+import { peekRunSettings } from "../config/run-settings.js";
+import { useLayers } from "./use-options.js";
+/**
+ * The fixtures a test gets from `use`: config, then the run's environment, then the group, then `test.use()`, a
+ * later layer winning key by key. The environment's `false` is the exception: it wins over a `true` anywhere, so a
+ * fixture an environment turns off cannot be switched back on for it.
+ */
+export async function effectiveFixtureUse(test) {
+    const layers = await useLayers(test);
+    const merged = mergeFixtureUse([
+        layers.config,
+        layers.environment,
+        layers.group,
+        ...layers.tests,
+    ]);
+    const environment = peekRunSettings()?.environment ?? "";
+    const disabled = new Map();
+    for (const [name, on] of Object.entries(mergeFixtureUse([layers.environment]).fixtures))
+        if (!on)
+            disabled.set(name, `Fixture ${name} is turned off in ${environment}`);
+    return {
+        attach: Object.entries(merged.fixtures)
+            .filter(([, on]) => on)
+            .map(([name]) => name),
+        options: merged.options,
+        disabled,
+    };
+}
+const list = (names, none) => names.length > 0 ? names.join(", ") : none;
+/** Throws when a `use` names a fixture or an option fixture that `catalog` does not have */
+function checkPlace(place, use, catalog) {
+    const fixtures = catalog.map((entry) => entry.name);
+    const options = catalog.flatMap((entry) => entry.options?.name ?? []);
+    for (const [key, value] of Object.entries(pickFixtureUse(use))) {
+        if (key === FIXTURES_KEY) {
+            for (const name of Object.keys(value))
+                if (!fixtures.includes(name))
+                    throw new Error(`${place}.fixtures: unknown fixture "${name}". ${fixtures.length > 0 ? `Known fixtures: ${list(fixtures, "")}` : "No fixtures are listed in config.fixtures"}`);
+        }
+        else if (!options.includes(key))
+            throw new Error(`${place}.${key}: unknown option fixture "${key}". ${options.length > 0 ? `Known option fixtures: ${list(options, "")}` : "No option fixtures are listed in config.fixtures"}`);
+    }
+}
+/** Refuses a config whose `use` (config, environments, groups) names a fixture that is not in `config.fixtures` */
+export function checkFixtureUseNames(config, catalog) {
+    checkPlace("config.use", config.use, catalog);
+    for (const [name, environment] of Object.entries(config.environments ?? {}))
+        checkPlace(`config.environments.${name}.use`, environment.use, catalog);
+    config.groups?.forEach((group, index) => checkPlace(`config.groups[${index}].use`, group.use, catalog));
+}
+/** Refuses a `test.use()` that names a fixture the test's own `test.extend()` does not define */
+export function checkTestFixtureUse(use, layers) {
+    for (const [key, value] of Object.entries(pickFixtureUse(use))) {
+        const known = [...(layers?.keys() ?? [])];
+        if (key === FIXTURES_KEY) {
+            for (const name of Object.keys(value))
+                if (!layers?.has(name))
+                    throw new TypeError(`use(): unknown fixture "${name}". ${known.length > 0 ? `This test has: ${known.join(", ")}` : "This test has no fixtures; write it with test.extend()"}`);
+        }
+        else if (!layers?.get(key)?.slice(-1)[0]?.option)
+            throw new TypeError(`use(): unknown option fixture "${key}"`);
+    }
+}

package/dist/runner/fixture-worker.d.ts

@@ -0,0 +1,26 @@
+import type { FixtureDef } from "./fixture-defs.js";
+import { type Started } from "./fixture-start.js";
+/** A worker fixture that is set up: its value, how to finish it, and the outputs the report lists */
+export interface WorkerInstance {
+    value: unknown;
+    started: Started;
+    outputs?: Record<string, string | number | boolean> | undefined;
+}
+/**
+ * The worker-scoped fixtures of one worker. An instance is shared by the tests that need the same definition with
+ * the same key (the environment, the resolved options and the instances it uses), is set up on first use and is
+ * torn down when the worker is done, last set up first.
+ */
+export declare class WorkerFixtures {
+    private readonly limitMs;
+    private readonly byDef;
+    private readonly live;
+    /** `limitMs`: how long a teardown may take when the fixture has no `timeout` of its own */
+    constructor(limitMs: number);
+    /** The instance of `def` under `key`: the one already set up, else the result of `make`. A failed setup is not kept */
+    acquire(def: FixtureDef, key: string, make: () => Promise<WorkerInstance>): Promise<WorkerInstance & {
+        reused: boolean;
+    }>;
+    /** Tears every instance down, last set up first, and returns the errors; a second call has nothing to do */
+    closeAll(): Promise<Error[]>;
+}

package/dist/runner/fixture-worker.js

@@ -0,0 +1,46 @@
+import { finishWithin } from "./fixture-start.js";
+/**
+ * The worker-scoped fixtures of one worker. An instance is shared by the tests that need the same definition with
+ * the same key (the environment, the resolved options and the instances it uses), is set up on first use and is
+ * torn down when the worker is done, last set up first.
+ */
+export class WorkerFixtures {
+    /** `limitMs`: how long a teardown may take when the fixture has no `timeout` of its own */
+    constructor(limitMs) {
+        this.limitMs = limitMs;
+        this.byDef = new Map();
+        this.live = [];
+    }
+    /** The instance of `def` under `key`: the one already set up, else the result of `make`. A failed setup is not kept */
+    async acquire(def, key, make) {
+        let keys = this.byDef.get(def);
+        if (!keys)
+            this.byDef.set(def, (keys = new Map()));
+        const existing = keys.get(key);
+        if (existing)
+            return { ...(await existing), reused: true };
+        const created = make().then((instance) => {
+            this.live.push(instance);
+            return instance;
+        });
+        keys.set(key, created);
+        try {
+            return { ...(await created), reused: false };
+        }
+        catch (err) {
+            keys.delete(key);
+            throw err;
+        }
+    }
+    /** Tears every instance down, last set up first, and returns the errors; a second call has nothing to do */
+    async closeAll() {
+        const errors = [];
+        this.byDef.clear();
+        for (let one = this.live.pop(); one; one = this.live.pop()) {
+            const error = await finishWithin(one.started, this.limitMs);
+            if (error)
+                errors.push(error);
+        }
+        return errors;
+    }
+}

package/dist/runner/prepare-run.js

@@ -2,11 +2,16 @@ import { isShortSecret, registerSecret } from "../config/mask.js";
 import { resolveRunSettings, setRunSettings, } from "../config/run-settings.js";
 import { loadSecrets } from "../config/secrets.js";
 import logger from "../logger/index.js";
+import { fixtureCatalog } from "./fixture-registry.js";
+import { checkFixtureUseNames } from "./fixture-use.js";
 /**
  * Starts a run: picks the environment, loads its secrets and registers every value for masking
  * (all of them, not only the ones a test reads), then makes the settings active.
  */
 export function prepareRun(config, overrides, options = {}) {
+    // A fixture name defined twice refuses the run before any test starts
+    const catalog = fixtureCatalog(config.fixtures ?? []);
+    checkFixtureUseNames(config, catalog);
     const settings = resolveRunSettings(config, overrides);
     const secrets = loadSecrets(settings.environment, options);
     for (const [name, value] of secrets) {

package/dist/runner/registry.js

@@ -1,6 +1,8 @@
 import { fileURLToPath } from "node:url";
 import logger from "../logger/index.js";
 import { extendLayers } from "./fixture-defs.js";
+import { rememberLayers } from "./fixture-registry.js";
+import { checkTestFixtureUse } from "./fixture-use.js";
 import { validateUseOptions } from "../config/use-options.js";
 import { currentStepLog, currentTestInfo, infoFor, skipFromCondition, } from "./test-info.js";
 import { runStep } from "./steps.js";
@@ -150,16 +152,21 @@ export function beforeAll(hook) {
 export function afterAll(hook) {
     addHook(currentSuite(callerFile()), "afterAll", hook);
 }
-/** `test.use(options)`: checked now, applied when each test of the scope runs */
-function use(options) {
-    addUse(currentSuite(callerFile()), validateUseOptions(options));
+/** `test.use(options)` of a test with the fixtures `extension`: checked now, applied when each test of the scope runs */
+function usingFor(extension) {
+    return (options) => {
+        const checked = validateUseOptions(options);
+        // `fixtures` and option fixtures may only name what this test's `test.extend()` defines
+        checkTestFixtureUse(checked, extension);
+        addUse(currentSuite(callerFile()), checked);
+    };
 }
 /**
  * A `test` that registers its tests with the custom fixtures `extension`. The aliases are the same functions as
  * the named exports: they find the spec file from the stack, so they must not be wrapped.
  */
 function makeTest(extension) {
-    return Object.assign(registering("test", undefined, extension), {
+    const made = Object.assign(registering("test", undefined, extension), {
         skip: skipping("skip", extension),
         fixme: skipping("fixme", extension),
         fail: failing(extension),
@@ -168,7 +175,7 @@ function makeTest(extension) {
         step: (title, body, options) => runStep(currentStepLog(), title, body, options),
         only: registering("test.only", "only", extension),
         info: currentTestInfo,
-        use,
+        use: usingFor(extension),
         describe,
         beforeEach,
         afterEach,
@@ -176,6 +183,9 @@ function makeTest(extension) {
         afterAll,
         extend: (fixtures) => makeTest(extendLayers(extension, fixtures)),
     });
+    if (extension)
+        rememberLayers(made, extension);
+    return made;
 }
 export const test = makeTest();
 export function registeredTests() {

package/dist/runner/reporter.d.ts

@@ -1,4 +1,4 @@
-import type { TestAnnotation, TestStepEntry, TestAttachmentEntry, RegisteredTestCase, TestError, TestLogEntry, TestResult, TestRetries, TestSummary } from "../types/test.js";
+import type { TestAnnotation, TestFixtureEntry, TestStepEntry, TestAttachmentEntry, RegisteredTestCase, TestError, TestLogEntry, TestResult, TestRetries, TestSummary } from "../types/test.js";
 import type { SupportedBrowser } from "../types/browser.js";
 import type { Shard } from "./shard.js";
 /** What a run reports while it happens */
@@ -75,6 +75,8 @@ export interface TestEndExtras extends TestRetries {
     annotations?: TestAnnotation[];
     /** The steps the test ran with `test.step` */
     steps?: TestStepEntry[];
+    /** The fixtures the test set up, when it set any up */
+    fixtures?: TestFixtureEntry[];
 }
 export default class TestReporter implements TestSink {
     private testResults;

package/dist/runner/reporter.js

@@ -160,6 +160,7 @@ export default class TestReporter {
             ...(extras?.attachments && { attachments: extras.attachments }),
             ...(extras?.annotations && { annotations: extras.annotations }),
             ...(extras?.steps && { steps: extras.steps }),
+            ...(extras?.fixtures?.length && { fixtures: extras.fixtures }),
             ...(extras?.retry && { retry: extras.retry }),
             ...(extras?.flaky && { flaky: true }),
             ...(extras?.previousAttempts?.length && {

package/dist/runner/run-test.d.ts

@@ -4,6 +4,7 @@ import type { RunnerOptions } from "./options.js";
 import type { AllHooks } from "./all-hooks.js";
 import type { PreparedRun } from "./prepare-run.js";
 import type { TestSink } from "./reporter.js";
+import type { WorkerFixtures } from "./fixture-worker.js";
 /** What a worker gives its tests that the main process does not: its own port and profile, and its number */
 export interface WorkerResources {
     /** The browser's debugging port. @default `options.port`, else DEFAULT_PORT */
@@ -16,6 +17,8 @@ export interface WorkerResources {
     attempt?: number;
     /** The `beforeAll` / `afterAll` hooks of this worker: kept across tests, closed when the worker is done */
     allHooks?: AllHooks;
+    /** The worker-scoped fixtures of this worker: kept across tests, closed when the worker is done */
+    workerFixtures?: WorkerFixtures;
 }
 /** Runs one test in one browser and reports it: launch, run the body, judge the page's logs, close the browser */
 export declare function runOneTest(test: RegisteredTestCase, browserName: SupportedBrowser, run: PreparedRun, options: RunnerOptions, srcDir: string, reporter: TestSink, resources?: WorkerResources): Promise<void>;