@itmetsam/samurai-framework 0.21.4 → 0.22.0

package/dist/runner/shard.js

@@ -0,0 +1,73 @@
+import { serialBlockOf } from "./serial.js";
+import { suiteChain } from "./suite.js";
+/**
+ * Reads a shard: `"2/4"` (the command line's `--shard`) or `{ current: 2, total: 4 }` (the `shard` run option).
+ * `where` names the source in the error.
+ */
+export function parseShard(value, where) {
+    const shard = shardOf(value);
+    if (shard &&
+        Number.isInteger(shard.current) &&
+        Number.isInteger(shard.total) &&
+        shard.current >= 1 &&
+        shard.current <= shard.total)
+        return { current: shard.current, total: shard.total };
+    const shown = typeof value === "string" ? value : JSON.stringify(value);
+    throw new Error(`${where}: expected current/total with 1 <= current <= total, got ${typeof value === "string" ? `"${shown}"` : String(shown)}`);
+}
+function shardOf(value) {
+    if (typeof value === "string") {
+        const match = /^\s*(\d+)\s*\/\s*(\d+)\s*$/.exec(value);
+        return match
+            ? { current: Number(match[1]), total: Number(match[2]) }
+            : undefined;
+    }
+    if (typeof value === "object" && value !== null) {
+        const { current, total } = value;
+        if (typeof current === "number" && typeof total === "number")
+            return { current, total };
+    }
+    return undefined;
+}
+/**
+ * What a shard keeps together: a serial block is never split, and so is a file, unless `fullyParallel` is on or a
+ * `describe` around the test is in `"parallel"` mode: then the test goes by itself.
+ */
+export function shardGroupOf(test, fullyParallel) {
+    const block = serialBlockOf(test);
+    if (block)
+        return block.key;
+    const alone = fullyParallel === true ||
+        suiteChain(test.suite).some((s) => s.mode === "parallel");
+    return alone ? `test:${test.file}::${test.name}` : `file:${test.file}`;
+}
+/**
+ * The tests of one shard. The groups (in the order their first test comes) are dealt out in order, so the shards are
+ * as equal in tests as whole groups allow: a group goes to the shard that holds its first test when all tests are
+ * cut into `total` equal ranges. The shards are disjoint and together hold every test; the order stays.
+ */
+export function shardTests(tests, { current, total }, groupOf) {
+    const groups = new Map();
+    for (const test of tests) {
+        const key = groupOf(test);
+        const members = groups.get(key);
+        if (members)
+            members.push(test);
+        else
+            groups.set(key, [test]);
+    }
+    const size = Math.floor(tests.length / total);
+    const extra = tests.length - size * total;
+    const index = current - 1;
+    const from = size * index + Math.min(extra, index);
+    const to = from + size + (index < extra ? 1 : 0);
+    const kept = new Set();
+    let first = 0;
+    for (const members of groups.values()) {
+        if (first >= from && first < to)
+            for (const test of members)
+                kept.add(test);
+        first += members.length;
+    }
+    return tests.filter((test) => kept.has(test));
+}

package/dist/runner/steps.d.ts

@@ -0,0 +1,13 @@
+import type { TestStepEntry } from "../types/test.js";
+/** The steps a test has run, in the order they started */
+export declare class StepLog {
+    readonly entries: TestStepEntry[];
+}
+/**
+ * `test.step`: runs `body` as a step of `log`, nested under the step it is called in. The step is listed with how
+ * it ended; a throw fails the step and goes on. A step that outlasts `options.timeout` fails with a timeout error
+ * (its body keeps running, as nothing can stop it).
+ */
+export declare function runStep<T>(log: StepLog, title: unknown, body: unknown, options?: {
+    timeout?: number;
+}): Promise<T>;

package/dist/runner/steps.js

@@ -0,0 +1,67 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { checkTimeout } from "./test-timeout.js";
+import { isSkipSignal } from "./skip.js";
+/** The steps a test has run, in the order they started */
+export class StepLog {
+    constructor() {
+        this.entries = [];
+    }
+}
+/** The step being run: a step started inside it is listed under it */
+const running = new AsyncLocalStorage();
+const UNFINISHED = "the test ended before the step finished";
+/**
+ * `test.step`: runs `body` as a step of `log`, nested under the step it is called in. The step is listed with how
+ * it ended; a throw fails the step and goes on. A step that outlasts `options.timeout` fails with a timeout error
+ * (its body keeps running, as nothing can stop it).
+ */
+export async function runStep(log, title, body, options) {
+    if (typeof title !== "string" || title === "")
+        throw new TypeError("step(): the title must be a non-empty string");
+    if (typeof body !== "function")
+        throw new TypeError("step(): needs a function as its second argument");
+    const limit = options?.timeout === undefined
+        ? 0
+        : checkTimeout("step()", options.timeout);
+    // Listed as unfinished until it ends, so a test cut short still shows where it stopped
+    const entry = {
+        title,
+        status: "failed",
+        duration: 0,
+        error: UNFINISHED,
+    };
+    const parent = running.getStore();
+    if (parent)
+        (parent.steps ??= []).push(entry);
+    else
+        log.entries.push(entry);
+    const started = Date.now();
+    let timer;
+    try {
+        const call = Promise.resolve().then(() => running.run(entry, body));
+        const value = limit === 0
+            ? await call
+            : await Promise.race([
+                call,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error(`step ${JSON.stringify(title)} timed out after ${limit} ms`)), limit);
+                }),
+            ]);
+        entry.status = "passed";
+        delete entry.error;
+        return value;
+    }
+    catch (error) {
+        if (isSkipSignal(error)) {
+            entry.status = "skipped";
+            delete entry.error;
+        }
+        else
+            entry.error = error instanceof Error ? error.message : String(error);
+        throw error;
+    }
+    finally {
+        clearTimeout(timer);
+        entry.duration = Date.now() - started;
+    }
+}

package/dist/runner/suite.d.ts

@@ -1,11 +1,12 @@
-import type { EachHook, Modifier, Suite } from "../types/test.js";
+import type { EachHook, Modifier, Suite, SuiteMode } from "../types/test.js";
+import type { UseOptions } from "../types/use.js";
 /** The four hook lists a suite can hold */
 export type HookKind = "beforeEach" | "afterEach" | "beforeAll" | "afterAll";
-export declare function newSuite(title?: string, parent?: Suite, modifier?: Modifier, reason?: string): Suite;
+export declare function newSuite(title?: string, parent?: Suite, modifier?: Modifier, reason?: string, mode?: SuiteMode): Suite;
 /** The suite a test or hook written now belongs to: the innermost open `describe`, else the file's own */
 export declare function currentSuite(file: string): Suite;
 /** Opens a `describe` block under the current suite; `leaveSuite` closes it */
-export declare function enterSuite(file: string, title: string, modifier?: Modifier, reason?: string): Suite;
+export declare function enterSuite(file: string, title: string, modifier?: Modifier, reason?: string, mode?: SuiteMode): Suite;
 export declare function leaveSuite(): void;
 /** Forgets every suite: a run registers its specs afresh */
 export declare function resetSuites(): void;
@@ -28,3 +29,7 @@ export declare function beforeEachOf(suite: Suite): EachHook[];
 export declare function afterEachOf(suite: Suite): EachHook[];
 /** Adds a hook to the suite being registered */
 export declare function addHook<K extends HookKind>(suite: Suite, kind: K, hook: NonNullable<Suite[K]>[number]): void;
+/** Adds the options of a `test.use()` to the suite being registered */
+export declare function addUse(suite: Suite, options: UseOptions): void;
+/** The `test.use()` options that apply to a test, outermost suite first: merge them in this order */
+export declare function useOf(suite: Suite): UseOptions[];

package/dist/runner/suite.js

@@ -2,12 +2,13 @@
 const roots = new Map();
 /** The `describe` blocks being registered, outermost first */
 const open = [];
-export function newSuite(title, parent, modifier, reason) {
+export function newSuite(title, parent, modifier, reason, mode) {
     return {
         ...(title !== undefined && { title }),
         ...(parent && { parent }),
         ...(modifier && { modifier }),
         ...(reason !== undefined && { reason }),
+        ...(mode && { mode }),
     };
 }
 /** The suite a test or hook written now belongs to: the innermost open `describe`, else the file's own */
@@ -23,8 +24,8 @@ export function currentSuite(file) {
     return root;
 }
 /** Opens a `describe` block under the current suite; `leaveSuite` closes it */
-export function enterSuite(file, title, modifier, reason) {
-    const suite = newSuite(title, currentSuite(file), modifier, reason);
+export function enterSuite(file, title, modifier, reason, mode) {
+    const suite = newSuite(title, currentSuite(file), modifier, reason, mode);
     open.push(suite);
     return suite;
 }
@@ -80,3 +81,11 @@ export function afterEachOf(suite) {
 export function addHook(suite, kind, hook) {
     (suite[kind] ??= []).push(hook);
 }
+/** Adds the options of a `test.use()` to the suite being registered */
+export function addUse(suite, options) {
+    (suite.use ??= []).push(options);
+}
+/** The `test.use()` options that apply to a test, outermost suite first: merge them in this order */
+export function useOf(suite) {
+    return suiteChain(suite).flatMap((s) => s.use ?? []);
+}

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

@@ -0,0 +1,16 @@
+import type { RegisteredTestCase, Suite, TestError, TestFixtures, TestInfo } from "../types/test.js";
+type Condition = boolean | ((fixtures: TestFixtures) => boolean);
+/**
+ * `test.fail(...)` and `test.slow(...)` without a title. In a running test or hook it marks that test when the
+ * condition holds (no condition: always). In a `describe` block, or at the top of a file, it marks every test of
+ * `suite` instead, and the condition must be a boolean as no test runs yet.
+ */
+export declare function markTests(type: "fail" | "slow", suite: () => Suite, condition?: Condition, description?: string): void;
+/** Applies what the test and the suites around it declared (`test.fail("t", fn)`, `test.slow(true)` in a `describe`) */
+export declare function applyDeclaredMarks(info: TestInfo, test: Pick<RegisteredTestCase, "suite" | "expectedFail">): void;
+/**
+ * What a test that ends by itself is reported as, given what it is expected to do: a test expected to fail is
+ * passed by a failure and failed by a pass. A timeout is never the failure it was waiting for.
+ */
+export declare function judgeExpectation(info: TestInfo | undefined, error: TestError | undefined): TestError | undefined;
+export {};

package/dist/runner/test-annotations.js

@@ -0,0 +1,47 @@
+import { conditionHolds, infoFor, runningScope } from "./test-info.js";
+/**
+ * `test.fail(...)` and `test.slow(...)` without a title. In a running test or hook it marks that test when the
+ * condition holds (no condition: always). In a `describe` block, or at the top of a file, it marks every test of
+ * `suite` instead, and the condition must be a boolean as no test runs yet.
+ */
+export function markTests(type, suite, condition = true, description) {
+    const label = `${type}()`;
+    if (description !== undefined && typeof description !== "string")
+        throw new TypeError(`${label}: the reason must be a string`);
+    if (runningScope()) {
+        if (conditionHolds(label, condition))
+            infoFor(label)[type](true, description);
+        return;
+    }
+    if (typeof condition === "function")
+        throw new Error(`${label}: a condition function needs a running test`);
+    if (!condition)
+        return;
+    const target = suite();
+    (target.marks ??= []).push({
+        type,
+        ...(description !== undefined && { description }),
+    });
+}
+/** Applies what the test and the suites around it declared (`test.fail("t", fn)`, `test.slow(true)` in a `describe`) */
+export function applyDeclaredMarks(info, test) {
+    const chain = [];
+    for (let s = test.suite; s; s = s.parent)
+        chain.unshift(s);
+    for (const suite of chain)
+        for (const mark of suite.marks ?? [])
+            info[mark.type](true, mark.description);
+    if (test.expectedFail)
+        info.fail(true, test.expectedFail.description);
+}
+/**
+ * What a test that ends by itself is reported as, given what it is expected to do: a test expected to fail is
+ * passed by a failure and failed by a pass. A timeout is never the failure it was waiting for.
+ */
+export function judgeExpectation(info, error) {
+    if (info?.expectedStatus !== "failed")
+        return error;
+    if (!error)
+        return { message: "expected to fail, but passed", type: "error" };
+    return error.type === "timeout" ? error : undefined;
+}

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

@@ -0,0 +1,115 @@
+import type { AllHook, SuiteMode, TestCaseBase, TestDetails, TestInfo, TestOptions } from "../types/test.js";
+import type { UseOptions } from "../types/use.js";
+import type { FixtureDefinitions, FixturesOf, MergeFixtures } from "../types/extend.js";
+/** What the registry keeps of a test body; the fixtures it gets are those of the test it was written for */
+export type Body = TestCaseBase["function"];
+/** The fixtures of tests made by `test.extend()`: none for the plain `test` */
+export type NoFixtures = Record<never, never>;
+/** A test body or hook that gets the built-in fixtures and the custom ones `X` */
+export type BodyOf<X> = (fixtures: FixturesOf<X>) => Promise<void>;
+export type HookOf<X> = (fixtures: FixturesOf<X>) => Promise<void> | void;
+/** `test(title, fn)`, `test.skip(title, fn)`, `test.skip(condition, reason)` and the other forms */
+export interface TestFunction<X = NoFixtures> {
+    (title: string, fn: BodyOf<X>): void;
+    (title: string, options: TestOptions, fn: BodyOf<X>): void;
+    /** Registers a test that is not run */
+    skip: SkipFunction<X>;
+    /** Registers a test that is not run because it is known to be broken */
+    fixme: SkipFunction<X>;
+    /**
+     * Registers a test that is expected to fail (`test.fail("title", fn)`): it is reported as passed when it fails and
+     * as failed when it passes. Inside a test or hook, `test.fail()` or `test.fail(condition, reason)` marks the running
+     * test the same way; in a `describe` block, `test.fail(true, reason)` marks every test in it.
+     */
+    fail: FailFunction<X>;
+    /**
+     * Triples the timeout of the running test (`test.slow()`, `test.slow(condition, reason)`); in a `describe` block
+     * `test.slow(true, reason)` does it for every test in it
+     */
+    slow: ConditionFunction<X>;
+    /** Sets the timeout, in milliseconds, of the running test (0: none); the time already spent counts */
+    setTimeout: (ms: number) => void;
+    /**
+     * Runs `body` as a named step of the running test and returns its value; steps nest, and the report lists them
+     * with their status, duration and error. A step that throws fails and rethrows.
+     */
+    step: StepFunction;
+    /** Runs only this test (and the other `only` ones) */
+    only: {
+        (title: string, fn: BodyOf<X>): void;
+        (title: string, options: TestOptions, fn: BodyOf<X>): void;
+    };
+    /** The running test's info, in the test and its hooks; throws outside one */
+    info: () => TestInfo;
+    /**
+     * Sets the `use` options (locale, colorScheme, storageState, ...) for the `describe` block it is written in, or for
+     * the whole file at the top level, whether before or after the tests. An inner block wins over an outer one, and
+     * both win over config `use`.
+     */
+    use: (options: UseOptions) => void;
+    /** `describe`, under the name other frameworks use */
+    describe: DescribeFunction;
+    /** `beforeEach`, as `test.beforeEach` */
+    beforeEach: (hook: HookOf<X>) => void;
+    /** `afterEach`, as `test.afterEach` */
+    afterEach: (hook: HookOf<X>) => void;
+    /** `beforeAll`, as `test.beforeAll` */
+    beforeAll: (hook: AllHook) => void;
+    /** `afterAll`, as `test.afterAll` */
+    afterAll: (hook: AllHook) => void;
+    /**
+     * A `test` that also has the fixtures you define: each is a value, or a function `async ({ page }, use) => {
+     * ...set up; await use(value); ...clean up }` that may use the built-in fixtures and the other ones. A fixture is
+     * set up when a test or hook destructures it, and cleaned up after the test and its `afterEach` hooks. Write
+     * `[fixture, { auto: true }]` to set it up for every test. A fixture with the name of a built-in one replaces it.
+     */
+    extend<T extends object>(fixtures: FixtureDefinitions<T, X>): TestFunction<MergeFixtures<X, T>>;
+}
+/**
+ * With a title and a body it registers a skipped test, `{ reason }` saying why; with a condition it skips the
+ * running test when the condition is true
+ */
+export interface SkipFunction<X> {
+    (title: string, fn: BodyOf<X>): void;
+    (title: string, options: TestOptions, fn: BodyOf<X>): void;
+    /** A function gets the test's fixtures (`({ browserName }) => browserName === "firefox"`) */
+    (condition: boolean | ((fixtures: FixturesOf<X>) => boolean), reason?: string): void;
+}
+/** `describe.skip` and `describe.fixme`: every test inside gets the modifier, and `{ reason }` says why */
+export interface DescribeSkipFunction {
+    (title: string, fn: () => void): void;
+    (title: string, details: TestDetails, fn: () => void): void;
+}
+/** `describe(title, fn)` and the same with a modifier on every test inside */
+export interface DescribeFunction {
+    (title: string, fn: () => void): void;
+    skip: DescribeSkipFunction;
+    fixme: DescribeSkipFunction;
+    only(title: string, fn: () => void): void;
+    /**
+     * Sets how the tests of the `describe` block it is written in (of the file, at the top level) run:
+     * `"serial"` runs them in order on one worker and skips the rest after a failure, `"parallel"` lets them run on
+     * different workers even when the config does not, `"default"` follows the config's `fullyParallel`
+     */
+    configure(options: {
+        mode: SuiteMode;
+    }): void;
+    /** A `describe` block in `"serial"` mode */
+    serial(title: string, fn: () => void): void;
+    /** A `describe` block in `"parallel"` mode */
+    parallel(title: string, fn: () => void): void;
+}
+/** `test.fail()` and `test.slow()`: with a condition (a function gets the test's fixtures), or none for "always" */
+export interface ConditionFunction<X> {
+    (): void;
+    (condition: boolean | ((fixtures: FixturesOf<X>) => boolean), reason?: string): void;
+}
+/** `test.fail("title", fn)` registers a test expected to fail; the other forms mark the running test */
+export interface FailFunction<X> extends ConditionFunction<X> {
+    (title: string, fn: BodyOf<X>): void;
+    (title: string, options: TestOptions, fn: BodyOf<X>): void;
+}
+/** `test.step(title, body, { timeout })` */
+export type StepFunction = <T>(title: string, body: () => Promise<T> | T, options?: {
+    timeout?: number;
+}) => Promise<T>;

package/dist/runner/test-function.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,104 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { RegisteredTestCase, TestAnnotation, TestAttachment, TestError, TestFixtures, TestInfo, TestStepEntry } from "../types/test.js";
+import { type AttachInput } from "./attachments.js";
+import { StepLog } from "./steps.js";
+import { TestTimeout } from "./test-timeout.js";
+/** What the running test's info needs of the run */
+export interface TestInfoSources {
+    test: RegisteredTestCase;
+    browserName: SupportedBrowser;
+    workerIndex: number;
+    /** The attempt, counting from 0 */
+    retry: number;
+    settings: {
+        baseURL: string | undefined;
+        timeout: number;
+    };
+    /** The run's result folder: attachment paths in the report are relative to it */
+    resultDir: string;
+    outputDir: string;
+    /** The test's time limit, which the info can change; without it the info only keeps the number */
+    timeout?: TestTimeout;
+}
+/** What a report entry lists from the info, besides the rest of its extras */
+export interface InfoReportExtras {
+    attachments?: {
+        name: string;
+        contentType: string;
+        path: string;
+    }[];
+    annotations?: TestAnnotation[];
+    steps?: TestStepEntry[];
+}
+/** The `TestInfo` of one attempt of a test. The runner creates it, the test only reads it. */
+export declare class TestInfoImpl implements TestInfo {
+    readonly title: string;
+    readonly titlePath: string[];
+    readonly file: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly retry: number;
+    readonly workerIndex: number;
+    readonly project: {
+        name: string;
+    };
+    readonly config: {
+        baseURL: string | undefined;
+        timeout: number;
+    };
+    annotations: TestAnnotation[];
+    expectedStatus: TestInfo["expectedStatus"];
+    /** The steps the test ran with `test.step` */
+    readonly stepLog: StepLog;
+    readonly errors: TestError[];
+    readonly outputDir: string;
+    private readonly saved;
+    private readonly used;
+    private readonly started;
+    private ended;
+    private result;
+    private readonly resultDir;
+    private readonly limit;
+    constructor(from: TestInfoSources);
+    get timeout(): number;
+    setTimeout(ms: number): void;
+    slow(condition?: boolean, description?: string): void;
+    fail(condition?: boolean, description?: string): void;
+    skip(condition?: boolean, description?: string): void;
+    fixme(condition?: boolean, description?: string): void;
+    private annotated;
+    private note;
+    get status(): TestInfo["status"];
+    get duration(): number;
+    get attachments(): readonly TestAttachment[];
+    attach(name: string, options: AttachInput): Promise<void>;
+    /** The body (with its `beforeEach` hooks) ended: `error` is what it threw, if anything. Runs before the `afterEach` hooks. */
+    bodyDone(error: unknown): void;
+    /** The fields a report entry adds for this attempt: nothing when there is nothing to list */
+    reportExtras(): InfoReportExtras;
+}
+/** The running test: its info and its fixtures (a condition function of `test.skip` gets them) */
+export interface TestScope {
+    info: TestInfo;
+    fixtures: TestFixtures;
+}
+/** Runs `fn` (the body and hooks of one test) so that `test.info()` and `test.skip(fn)` find the test */
+export declare function runInTestScope<T>(scope: TestScope, fn: () => T): T;
+/** `test.info()` */
+export declare function currentTestInfo(): TestInfo;
+/** The running test's scope, if a test (or one of its hooks) is running */
+export declare function runningScope(): TestScope | undefined;
+/** The running test's info for `label` (`setTimeout()`); throws when no test is running */
+export declare function infoFor(label: string): TestInfo;
+/** The running test's steps; throws when no test is running */
+export declare function currentStepLog(): StepLog;
+/**
+ * Whether a condition of `test.skip`, `test.fail` or `test.slow` holds: a boolean as it is, a function called with
+ * the running test's fixtures (it must be synchronous). `label` starts the errors (`test.skip()`).
+ */
+export declare function conditionHolds(label: string, condition: boolean | ((fixtures: TestFixtures) => boolean)): boolean;
+/**
+ * `test.skip(condition, reason)` and `test.fixme(...)` from inside a test or its hooks: throws the skip signal
+ * when `condition` is true, or when it is a function and returns something truthy.
+ */
+export declare function skipFromCondition(annotation: "skip" | "fixme", condition: boolean | ((fixtures: TestFixtures) => boolean), reason?: string): void;

package/dist/runner/test-info.js

@@ -0,0 +1,170 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import path from "node:path";
+import { saveAttachment } from "./attachments.js";
+import { isSkipSignal, SkipSignal } from "./skip.js";
+import { StepLog } from "./steps.js";
+import { toTestError } from "./test-error.js";
+import { checkTimeout, TestTimeout } from "./test-timeout.js";
+/** The `TestInfo` of one attempt of a test. The runner creates it, the test only reads it. */
+export class TestInfoImpl {
+    constructor(from) {
+        this.annotations = [];
+        this.expectedStatus = "passed";
+        /** The steps the test ran with `test.step` */
+        this.stepLog = new StepLog();
+        this.errors = [];
+        this.saved = [];
+        this.used = new Set();
+        this.started = Date.now();
+        const { test } = from;
+        this.title = test.titlePath[test.titlePath.length - 1] ?? test.name;
+        this.titlePath = [...test.titlePath];
+        this.file = test.file;
+        if (test.line !== undefined)
+            this.line = test.line;
+        if (test.column !== undefined)
+            this.column = test.column;
+        this.retry = from.retry;
+        this.workerIndex = from.workerIndex;
+        // A run for a group is named after it (as a Playwright project is), else after the browser
+        this.project = { name: test.group ?? from.browserName };
+        this.config = { ...from.settings };
+        this.resultDir = from.resultDir;
+        this.outputDir = from.outputDir;
+        this.limit =
+            from.timeout ?? new TestTimeout(from.settings.timeout, () => { });
+    }
+    get timeout() {
+        return this.limit.ms;
+    }
+    setTimeout(ms) {
+        this.limit.set(checkTimeout("setTimeout()", ms));
+    }
+    slow(condition = true, description) {
+        if (!condition || this.annotated("slow"))
+            return;
+        this.note("slow", description);
+        this.limit.set(this.limit.ms * 3);
+    }
+    fail(condition = true, description) {
+        if (!condition)
+            return;
+        this.expectedStatus = "failed";
+        if (!this.annotated("fail"))
+            this.note("fail", description);
+    }
+    skip(condition = true, description) {
+        if (condition)
+            throw new SkipSignal("skip", description);
+    }
+    fixme(condition = true, description) {
+        if (condition)
+            throw new SkipSignal("fixme", description);
+    }
+    annotated(type) {
+        return this.annotations.some((a) => a.type === type);
+    }
+    note(type, description) {
+        this.annotations.push({
+            type,
+            ...(description !== undefined && { description }),
+        });
+    }
+    get status() {
+        return this.result;
+    }
+    get duration() {
+        return (this.ended ?? Date.now()) - this.started;
+    }
+    get attachments() {
+        return this.saved;
+    }
+    async attach(name, options) {
+        this.saved.push(await saveAttachment(this.outputDir, this.used, name, options));
+    }
+    /** The body (with its `beforeEach` hooks) ended: `error` is what it threw, if anything. Runs before the `afterEach` hooks. */
+    bodyDone(error) {
+        this.ended = Date.now();
+        if (error === undefined)
+            this.result = "passed";
+        else if (isSkipSignal(error))
+            this.result = "skipped";
+        else {
+            this.result = "failed";
+            this.errors.push(toTestError(error));
+        }
+    }
+    /** The fields a report entry adds for this attempt: nothing when there is nothing to list */
+    reportExtras() {
+        return {
+            ...(this.saved.length > 0 && {
+                attachments: this.saved.map((a) => ({
+                    name: a.name,
+                    contentType: a.contentType,
+                    path: path.relative(this.resultDir, a.path).split(path.sep).join("/"),
+                })),
+            }),
+            ...(this.annotations.length > 0 && {
+                annotations: this.annotations.map((a) => ({ ...a })),
+            }),
+            ...(this.stepLog.entries.length > 0 && {
+                steps: structuredClone(this.stepLog.entries),
+            }),
+        };
+    }
+}
+const scopes = new AsyncLocalStorage();
+/** Runs `fn` (the body and hooks of one test) so that `test.info()` and `test.skip(fn)` find the test */
+export function runInTestScope(scope, fn) {
+    return scopes.run(scope, fn);
+}
+/** `test.info()` */
+export function currentTestInfo() {
+    const scope = scopes.getStore();
+    if (!scope)
+        throw new Error("info(): no test is running");
+    return scope.info;
+}
+/** The running test's scope, if a test (or one of its hooks) is running */
+export function runningScope() {
+    return scopes.getStore();
+}
+/** The running test's info for `label` (`setTimeout()`); throws when no test is running */
+export function infoFor(label) {
+    const scope = scopes.getStore();
+    if (!scope)
+        throw new Error(`${label}: no test is running`);
+    return scope.info;
+}
+/** The running test's steps; throws when no test is running */
+export function currentStepLog() {
+    const info = infoFor("step()");
+    if (!(info instanceof TestInfoImpl))
+        throw new Error("step(): no test is running");
+    return info.stepLog;
+}
+/**
+ * Whether a condition of `test.skip`, `test.fail` or `test.slow` holds: a boolean as it is, a function called with
+ * the running test's fixtures (it must be synchronous). `label` starts the errors (`test.skip()`).
+ */
+export function conditionHolds(label, condition) {
+    if (typeof condition !== "function")
+        return Boolean(condition);
+    const scope = scopes.getStore();
+    if (!scope)
+        throw new Error(`${label}: a condition function needs a running test`);
+    const result = condition(scope.fixtures);
+    if (result instanceof Promise) {
+        result.catch(() => { });
+        throw new Error(`${label}: the condition function must be synchronous`);
+    }
+    return Boolean(result);
+}
+/**
+ * `test.skip(condition, reason)` and `test.fixme(...)` from inside a test or its hooks: throws the skip signal
+ * when `condition` is true, or when it is a function and returns something truthy.
+ */
+export function skipFromCondition(annotation, condition, reason) {
+    if (conditionHolds(`test.${annotation}()`, condition))
+        throw new SkipSignal(annotation, reason);
+}