@itmetsam/samurai-framework 0.21.3 → 0.21.5

package/dist/runner/run-test.js

@@ -1,9 +1,8 @@
+import path from "node:path";
 import { takePendingAssertions } from "../assert/expect.js";
 import { Browser } from "../browser/browser.js";
 import { Evidence } from "../browser/evidence.js";
 import { projectDir, readConfig } from "../config/config.js";
-import { createSecretsFixture } from "../config/secrets.js";
-import { createEnvFixture } from "../config/variables.js";
 import logger from "../logger/index.js";
 import { ConnectionClosedError } from "../transport/bidi-connection.js";
 import { judgePageLogs } from "./page-logs-report.js";
@@ -13,7 +12,13 @@ import { isSkipSignal, staticSkip } from "./skip.js";
 import { runOutput } from "./output.js";
 import { testDirOf } from "./test-dir.js";
 import { toTestError } from "./test-error.js";
-import { createInputsFixture, createOutputsFixture, ioOfAttempt, missingOutputs, } from "./test-io.js";
+import { runInTestScope, TestInfoImpl } from "./test-info.js";
+import { applyDeclaredMarks, judgeExpectation } from "./test-annotations.js";
+import { TestTimeout } from "./test-timeout.js";
+import { ioOfAttempt, missingOutputs } from "./test-io.js";
+import { buildTestFixtures } from "./fixtures.js";
+import { FixtureScope } from "./fixture-scope.js";
+import { effectiveUse } from "./use-options.js";
 import { beginOutputs, endOutputs } from "../wait/output-sink.js";
 /**
  * The state of one test run. A test ends once, whichever of finishing, failing, timing out, an abort or a
@@ -46,6 +51,10 @@ class TestOutcome {
             reason: signal.reason,
         });
     }
+    /** The test body ended by itself: a test expected to fail is passed by a failure and failed by a pass */
+    conclude(error, logs) {
+        this.finish(judgeExpectation(this.info, error), logs);
+    }
     finish(error, logs) {
         if (this.ended)
             return;
@@ -53,20 +62,11 @@ class TestOutcome {
         this.reporter.onTestEnd(this.test, this.browser, error, {
             ...logs,
             screenshots: this.evidence?.screenshots,
+            ...this.info?.reportExtras(),
             ...this.io(),
         });
     }
 }
-/** What `beforeAll` and `afterAll` hooks get: no page, only what a run knows */
-export function allHookFixtures(run, browserName, workerIndex = 0) {
-    const { settings, secrets } = run;
-    return {
-        browserName,
-        workerIndex,
-        env: createEnvFixture(settings.environment, settings.variables),
-        secrets: createSecretsFixture(settings.environment, secrets),
-    };
-}
 /** Runs one test in one browser and reports it: launch, run the body, judge the page's logs, close the browser */
 export async function runOneTest(test, browserName, run, options, srcDir, reporter, resources = {}) {
     // A test marked skip or fixme never runs, whoever asked for it (a flow's test node, a worker)
@@ -78,25 +78,28 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
     logger.verbose("Starting test: %s in %s", test.name, browserName);
     reporter.onTestStart(test, browserName);
     const outcome = new TestOutcome(reporter, test, browserName);
-    const { settings, secrets } = run;
+    const { settings } = run;
     const timeout = settings.timeout;
     const { resultDir } = runOutput(options, projectDir());
     let browser;
     let page;
-    let timeoutTimer;
+    let customFixtures;
     let onRunAborted;
     const timeoutController = new AbortController();
     let browserGone = () => { };
+    let testTimeout;
     /** Resolves when the time is up or the run is aborted; the test is reported failed then */
     const limit = new Promise((resolve) => {
-        timeoutTimer = setTimeout(() => {
+        // The test can change its own limit (`test.setTimeout`, `test.slow`): the message names the one in force
+        testTimeout = new TestTimeout(timeout, () => {
             outcome.finish({
-                message: `Test timed out after ${timeout / 1000} seconds`,
+                message: `Test timed out after ${(testTimeout?.ms ?? timeout) / 1000} seconds`,
                 type: "timeout",
             });
             timeoutController.abort(new Error("Test timed out"));
             resolve();
-        }, timeout);
+        });
+        testTimeout.start();
         onRunAborted = () => {
             if (timeoutController.signal.aborted)
                 return;
@@ -113,10 +116,12 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
         try {
             // The `beforeAll` hooks come first, before a browser exists
             await resources.allHooks?.ensure(test, browserName);
+            const use = await effectiveUse(test);
             const launched = await Browser.launch(browserName, {
                 port: resources.port ?? options.port ?? DEFAULT_PORT,
                 ...(resources.profileDir && { profileDir: resources.profileDir }),
                 headless: options.headless ?? settings.headless,
+                use,
             }, timeoutController.signal);
             browser = launched.browser;
             // A person closing the window, or the browser crashing: end the test now instead of waiting for a
@@ -133,25 +138,68 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
                 browserGone();
             });
             page = launched.page;
-            outcome.evidence = new Evidence(resultDir, `${browserName}/${testDirOf(test, srcDir)}${resources.attempt ? `/retry-${resources.attempt}` : ""}`);
+            // An empty `use` leaves the browser exactly as it was: no applier, nothing sent
+            const applied = Object.keys(use).length > 0
+                ? await launched.browser.setUse(use, projectDir())
+                : undefined;
+            const testFolder = `${browserName}/${testDirOf(test, srcDir)}${resources.attempt ? `/retry-${resources.attempt}` : ""}`;
+            outcome.evidence = new Evidence(resultDir, testFolder);
             launched.page.setEvidence(outcome.evidence);
-            const fixtures = {
-                page: launched.page,
-                browser: launched.browser,
+            const info = new TestInfoImpl({
+                test,
                 browserName,
                 workerIndex: resources.workerIndex ?? 0,
-                env: createEnvFixture(settings.environment, settings.variables),
-                secrets: createSecretsFixture(settings.environment, secrets),
-                inputs: createInputsFixture(test.inputs, options.inputs),
-                outputs: createOutputsFixture(sink),
-            };
-            await runWithEachHooks(test.suite, fixtures, timeoutController.signal, () => test.function(fixtures));
+                retry: resources.attempt ?? 0,
+                settings: { baseURL: settings.baseURL, timeout },
+                ...(testTimeout && { timeout: testTimeout }),
+                resultDir,
+                outputDir: path.join(resultDir, "attachments", ...testFolder.split("/")),
+            });
+            outcome.info = info;
+            applyDeclaredMarks(info, test);
+            const built = buildTestFixtures({
+                info,
+                launched,
+                browserName,
+                workerIndex: resources.workerIndex ?? 0,
+                run,
+                test,
+                options,
+                sink,
+                device: {
+                    isMobile: applied?.isMobile ?? false,
+                    hasTouch: applied?.hasTouch ?? false,
+                },
+            });
+            // A test written with `test.extend()` gets its custom fixtures set up on demand, and torn down below
+            const custom = test.extension
+                ? new FixtureScope(test.extension, built)
+                : undefined;
+            customFixtures = custom;
+            const fixtures = custom?.fixtures ?? built;
+            let failure;
+            let failed = false;
+            try {
+                await runInTestScope({ info, fixtures }, () => runWithEachHooks(test.suite, fixtures, timeoutController.signal, async () => {
+                    await custom?.prepare(test.function);
+                    return test.function(fixtures);
+                }, (error) => info.bodyDone(error), custom));
+            }
+            catch (err) {
+                failure = err;
+                failed = true;
+            }
+            const cleanup = await custom?.teardown(timeout);
+            if (cleanup && (!failed || isSkipSignal(failure)))
+                throw cleanup;
+            if (failed)
+                throw failure;
             // Already reported as timed out
             if (timeoutController.signal.aborted)
                 return;
             const unawaited = takePendingAssertions();
             if (unawaited.length > 0) {
-                outcome.finish({
+                outcome.conclude({
                     message: unawaited
                         .map((label) => `${label} was not awaited`)
                         .join("\n"),
@@ -162,23 +210,29 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
             // Checked only after a pass: a test that failed first reports its own failure
             const missing = missingOutputs(test.outputs, sink);
             if (missing) {
-                outcome.finish(missing, await judgeLogs(page, true));
+                outcome.conclude(missing, await judgeLogs(page, true));
                 return;
             }
             const verdict = await judgeLogs(page, false);
-            outcome.finish(verdict.error, verdict);
+            outcome.conclude(verdict.error, verdict);
         }
         catch (err) {
             if (timeoutController.signal.aborted)
                 return;
             if (isSkipSignal(err))
                 return outcome.skip(err);
-            outcome.finish(outcome.browserClosed || err instanceof ConnectionClosedError
+            const closed = outcome.browserClosed || err instanceof ConnectionClosedError;
+            const error = closed
                 ? {
                     message: "The browser was closed while the test was running",
                     type: "error",
                 }
-                : toTestError(err), await judgeLogs(page, true));
+                : toTestError(err);
+            const logs = await judgeLogs(page, true);
+            if (closed)
+                outcome.finish(error, logs);
+            else
+                outcome.conclude(error, logs);
         }
     };
     // Open for this attempt only: whatever a capture still saves after the attempt ended is ignored
@@ -188,9 +242,13 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
         await Promise.race([limit, gone, runBody()]);
     }
     finally {
+        // A test cut short (timeout, abort) did not get to its own cleanup: its fixtures are torn down before the browser
+        const late = await customFixtures?.teardown(timeout);
+        if (late)
+            logger.debug("A fixture failed after the test ended", { late });
         endOutputs();
     }
-    clearTimeout(timeoutTimer);
+    testTimeout?.stop();
     if (onRunAborted)
         options.signal?.removeEventListener("abort", onRunAborted);
     takePendingAssertions();

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,4 +1,5 @@
 import type { EachHook, Modifier, Suite } 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;
@@ -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

@@ -80,3 +80,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,103 @@
+import type { AllHook, 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;
+}
+/** `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;