@itmetsam/samurai-framework 0.21.5 → 0.22.0

package/dist/runner/run-test.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { takePendingAssertions } from "../assert/expect.js";
 import { Browser } from "../browser/browser.js";
-import { Evidence } from "../browser/evidence.js";
+import { cleanName, Evidence } from "../browser/evidence.js";
 import { projectDir, readConfig } from "../config/config.js";
 import logger from "../logger/index.js";
 import { ConnectionClosedError } from "../transport/bidi-connection.js";
@@ -18,6 +18,7 @@ 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 { RequestFixture } from "./request-fixture.js";
 import { effectiveUse } from "./use-options.js";
 import { beginOutputs, endOutputs } from "../wait/output-sink.js";
 /**
@@ -84,6 +85,7 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
     let browser;
     let page;
     let customFixtures;
+    let requestFixture;
     let onRunAborted;
     const timeoutController = new AbortController();
     let browserGone = () => { };
@@ -142,7 +144,7 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
             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}` : ""}`;
+            const testFolder = `${browserName}${test.group === undefined ? "" : `/${cleanName(test.group)}`}/${testDirOf(test, srcDir)}${resources.attempt ? `/retry-${resources.attempt}` : ""}`;
             outcome.evidence = new Evidence(resultDir, testFolder);
             launched.page.setEvidence(outcome.evidence);
             const info = new TestInfoImpl({
@@ -157,7 +159,9 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
             });
             outcome.info = info;
             applyDeclaredMarks(info, test);
+            requestFixture = new RequestFixture(settings.baseURL, use);
             const built = buildTestFixtures({
+                request: requestFixture,
                 info,
                 launched,
                 browserName,
@@ -246,6 +250,7 @@ export async function runOneTest(test, browserName, run, options, srcDir, report
         const late = await customFixtures?.teardown(timeout);
         if (late)
             logger.debug("A fixture failed after the test ended", { late });
+        await requestFixture?.dispose();
         endOutputs();
     }
     testTimeout?.stop();

package/dist/runner/run.d.ts

@@ -48,6 +48,7 @@ export declare function listGroups(options?: RunTestsOptions): Promise<ResolvedG
 export { BROWSER_NAMES, checkBrowserList } from "../config/browsers.js";
 export { parseWorkers } from "../config/workers.js";
 export { parseRetries } from "../config/retries.js";
+export { parseShard, type Shard } from "./shard.js";
 export type { RunEvent } from "./reporter.js";
 export type { Modifier, TestError, TestResult, TestSummary, } from "../types/test.js";
 export type { ResolvedGroup } from "./groups.js";

package/dist/runner/run.js

@@ -70,4 +70,5 @@ export async function listGroups(options = {}) {
 export { BROWSER_NAMES, checkBrowserList } from "../config/browsers.js";
 export { parseWorkers } from "../config/workers.js";
 export { parseRetries } from "../config/retries.js";
+export { parseShard } from "./shard.js";
 export { DEFAULT_PORT } from "./ports.js";

package/dist/runner/select.d.ts

@@ -15,10 +15,21 @@ export declare function isSelected(name: string, { grep, testNames }: Pick<Runne
 export declare function idOf(test: RegisteredTestCase, srcDir: string): string;
 /** Imports the spec files once and resolves the config's groups against what they registered */
 export declare function loadSpecs(testFiles: string[]): Promise<LoadedSpecs>;
-/** The tests the options select: by `group`, `testNames` and `grep` */
+/** The group names the options select, once each and in the order given; none when no group is selected */
+export declare function groupNamesOf(group: RunnerOptions["group"]): string[];
+/** The tests the options select: by `group` (in any of them), `testNames` and `grep`; each test once */
 export declare function selectTests({ all, groups, srcDir }: LoadedSpecs, options: RunnerOptions): RegisteredTestCase[];
 /**
- * The browsers the run uses: the options' (`--browser`), else the selected group's, else the project's, else
- * Firefox
+ * The runs of the selected tests: without a selected group, the tests as they are; else one copy per selected group
+ * that holds the test (its `group` set), the first group's tests first
  */
-export declare function browsersOfRun(groups: ResolvedGroup[], options: RunnerOptions): Promise<SupportedBrowser[]>;
+export declare function expandByGroup(selected: RegisteredTestCase[], { groups, srcDir }: LoadedSpecs, options: RunnerOptions): RegisteredTestCase[];
+/**
+ * The browsers a run of a test uses: the options' (`--browser`), else its group's, else the project's, else Firefox
+ */
+export declare function browserPlan(groups: ResolvedGroup[], options: RunnerOptions): Promise<{
+    /** Every browser of the run, in the order they run */
+    browsers: SupportedBrowser[];
+    /** The browsers one run of a test uses */
+    browsersOf(test: RegisteredTestCase): SupportedBrowser[];
+}>;

package/dist/runner/select.js

@@ -53,25 +53,51 @@ export async function loadSpecs(testFiles) {
     const all = await registerAll(testFiles);
     return { all, ...(await resolveAll(all)) };
 }
-/** The tests the options select: by `group`, `testNames` and `grep` */
+/** The group names the options select, once each and in the order given; none when no group is selected */
+export function groupNamesOf(group) {
+    return [...new Set(group === undefined ? [] : [group].flat())];
+}
+/** The tests the options select: by `group` (in any of them), `testNames` and `grep`; each test once */
 export function selectTests({ all, groups, srcDir }, options) {
-    const { group } = options;
+    const names = groupNamesOf(options.group);
     let inGroup = () => true;
-    if (group !== undefined) {
-        const members = new Set(findGroup(groups, group).testIds);
+    if (names.length > 0) {
+        const members = new Set(names.flatMap((name) => findGroup(groups, name).testIds));
         inGroup = (test) => members.has(idOf(test, srcDir));
     }
     return all.filter((test) => inGroup(test) && isSelected(test.name, options));
 }
 /**
- * The browsers the run uses: the options' (`--browser`), else the selected group's, else the project's, else
- * Firefox
+ * The runs of the selected tests: without a selected group, the tests as they are; else one copy per selected group
+ * that holds the test (its `group` set), the first group's tests first
+ */
+export function expandByGroup(selected, { groups, srcDir }, options) {
+    const names = groupNamesOf(options.group);
+    if (names.length === 0)
+        return selected;
+    return names.flatMap((name) => {
+        const members = new Set(findGroup(groups, name).testIds);
+        return selected
+            .filter((test) => members.has(idOf(test, srcDir)))
+            .map((test) => ({ ...test, group: name }));
+    });
+}
+/**
+ * The browsers a run of a test uses: the options' (`--browser`), else its group's, else the project's, else Firefox
  */
-export async function browsersOfRun(groups, options) {
-    const { browsers: flag, group } = options;
+export async function browserPlan(groups, options) {
+    const { browsers: flag } = options;
     const config = await loadRawConfig();
-    const ofGroup = group !== undefined && !(flag && flag.length > 0)
-        ? findGroup(groups, group).browsers
-        : undefined;
-    return browsersFor({ flag, group: ofGroup, project: config.browsers });
+    const names = groupNamesOf(options.group);
+    const flagged = flag && flag.length > 0;
+    const ofGroup = new Map(names.map((name) => [name, findGroup(groups, name).browsers]));
+    const project = browsersFor({ flag, project: config.browsers });
+    const forGroup = (name) => flagged ? project : (ofGroup.get(name) ?? project);
+    const browsers = [
+        ...new Set(names.length > 0 ? names.flatMap(forGroup) : project),
+    ];
+    return {
+        browsers,
+        browsersOf: (test) => test.group === undefined ? project : forGroup(test.group),
+    };
 }

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

@@ -0,0 +1,23 @@
+import type { SupportedBrowser } from "../types/browser.js";
+import type { RegisteredTestCase } from "../types/test.js";
+import type { TestSink } from "./reporter.js";
+/** One attempt at one test of the block, reporting to `sink` */
+export type BlockTest = (test: RegisteredTestCase, sink: TestSink, attempt: number) => Promise<void>;
+export interface SerialBlockRun {
+    tests: RegisteredTestCase[];
+    browser: SupportedBrowser;
+    retries: number;
+    signal: AbortSignal | undefined;
+    runTest: BlockTest;
+    /** Called before the block starts again after a failure: closes what the block's tests share (`afterAll`) */
+    restart(): Promise<void>;
+    sink: TestSink;
+}
+/**
+ * Runs the tests of a serial block in order. After a failure the rest of the block is reported as skipped; with
+ * `retries`, the whole block then runs again from its first test (after `restart`), up to `retries` times.
+ * Without retries every test is reported as it ends. With them the ends are held until the block's last attempt is
+ * known, as `runWithRetries` does for one test: each test ends once, with `retry` saying which attempt that was.
+ * An aborted run is never run again.
+ */
+export declare function serialBlockRun(run: SerialBlockRun): Promise<void>;

package/dist/runner/serial-run.js

@@ -0,0 +1,88 @@
+import { SERIAL_SKIP_REASON } from "./serial.js";
+import { staticSkip } from "./skip.js";
+/**
+ * Runs the tests of a serial block in order. After a failure the rest of the block is reported as skipped; with
+ * `retries`, the whole block then runs again from its first test (after `restart`), up to `retries` times.
+ * Without retries every test is reported as it ends. With them the ends are held until the block's last attempt is
+ * known, as `runWithRetries` does for one test: each test ends once, with `retry` saying which attempt that was.
+ * An aborted run is never run again.
+ */
+export async function serialBlockRun(run) {
+    const { tests, browser, retries, signal, sink } = run;
+    const live = retries === 0;
+    const previous = tests.map(() => []);
+    for (let attempt = 0;; attempt++) {
+        const ended = [];
+        let failedAt = -1;
+        for (const [at, test] of tests.entries()) {
+            const skip = staticSkip(test);
+            if (skip) {
+                sink.onTestSkipped(test, browser, skip);
+                continue;
+            }
+            if (signal?.aborted) {
+                for (const rest of tests.slice(at)) {
+                    if (staticSkip(rest))
+                        continue;
+                    sink.onTestStart(rest, browser);
+                    sink.onTestEnd(rest, browser, {
+                        message: "Run aborted",
+                        type: "error",
+                    });
+                }
+                return;
+            }
+            const attemptSink = {
+                onTestStart: (t, b) => sink.onTestStart(t, b, attempt > 0 ? attempt : undefined),
+                onTestEnd: (t, b, error, extras) => {
+                    ended[at] = { error, extras };
+                    if (live)
+                        sink.onTestEnd(t, b, error, extras);
+                },
+                onTestSkipped: (t, b, why) => sink.onTestSkipped(t, b, why),
+            };
+            await run.runTest(test, attemptSink, attempt);
+            if (ended[at]?.error) {
+                failedAt = at;
+                break;
+            }
+        }
+        const error = ended[failedAt]?.error;
+        if (error &&
+            attempt < retries &&
+            !signal?.aborted &&
+            error.message !== "Run aborted") {
+            previous[failedAt].push(error);
+            await run.restart();
+            continue;
+        }
+        if (!live)
+            flush(run, ended, previous, attempt);
+        if (failedAt >= 0)
+            for (const rest of tests.slice(failedAt + 1)) {
+                const skip = staticSkip(rest) ?? {
+                    annotation: "skip",
+                    reason: SERIAL_SKIP_REASON,
+                };
+                sink.onTestSkipped(rest, browser, skip);
+            }
+        return;
+    }
+}
+/** Reports the held ends of the last attempt, each saying which attempt it was and what failed before */
+function flush({ tests, browser, sink }, ended, previous, attempt) {
+    for (const [at, test] of tests.entries()) {
+        const end = ended[at];
+        if (!end)
+            continue;
+        const before = previous[at];
+        sink.onTestEnd(test, browser, end.error, {
+            ...end.extras,
+            ...(attempt > 0 && {
+                retry: attempt,
+                previousAttempts: [...before],
+                ...(!end.error && before.length > 0 && { flaky: true }),
+            }),
+        });
+    }
+}

package/dist/runner/serial.d.ts

@@ -0,0 +1,34 @@
+import type { RegisteredTestCase, Suite } from "../types/test.js";
+/** Why a test of a serial block did not run: an earlier test of the block failed */
+export declare const SERIAL_SKIP_REASON = "serial: an earlier test failed";
+/** `describe.configure(options)`: sets the mode of the suite the call is written in */
+export declare function configureSuite(suite: Suite, options: unknown): void;
+/** A group of tests that run in order on one worker; if one fails, the rest of the block is skipped */
+export interface SerialBlock {
+    /** The file and the `describe` titles of the block's outermost serial suite; the same in every process */
+    key: string;
+    /** The outermost suite in serial mode */
+    suite: Suite;
+}
+/** The serial block a test belongs to: the outermost suite around it in `"serial"` mode, else none */
+export declare function serialBlockOf(test: RegisteredTestCase): SerialBlock | undefined;
+/** The tests that must run one after the other on one worker, in the order they are listed */
+export interface RunUnit {
+    /** The same for every test of the unit, in every process */
+    key: string;
+    /** A serial block: a failure skips the rest and a retry runs the whole block again */
+    serial: boolean;
+}
+/**
+ * The unit a test runs in. A serial block is one. With `fullyParallel: false` every other test is in the unit of
+ * its file, unless a suite around it is in `"parallel"` mode. Otherwise (`true`, or not set: the tests of a file
+ * go to workers one by one) there is no unit.
+ */
+export declare function unitOf(test: RegisteredTestCase, fullyParallel: boolean | undefined): RunUnit | undefined;
+/** Tests that follow each other and belong to one serial block (`block`), or one test outside any block */
+export interface Chunk {
+    block?: SerialBlock;
+    tests: RegisteredTestCase[];
+}
+/** Splits a list of tests into serial blocks and the free tests between them, keeping the order */
+export declare function chunkBySerialBlock(tests: RegisteredTestCase[]): Chunk[];

package/dist/runner/serial.js

@@ -0,0 +1,63 @@
+import { suiteChain } from "./suite.js";
+/** Why a test of a serial block did not run: an earlier test of the block failed */
+export const SERIAL_SKIP_REASON = "serial: an earlier test failed";
+const MODES = ["default", "parallel", "serial"];
+/** `describe.configure(options)`: sets the mode of the suite the call is written in */
+export function configureSuite(suite, options) {
+    if (typeof options !== "object" || options === null)
+        throw new TypeError("describe.configure(): expected an options object like { mode: 'serial' }");
+    const { mode, ...rest } = options;
+    const unknown = Object.keys(rest);
+    if (unknown.length > 0)
+        throw new TypeError(`describe.configure(): unknown option "${unknown[0]}" (only mode is supported)`);
+    if (!MODES.includes(mode))
+        throw new TypeError(`describe.configure(): mode must be "default", "parallel" or "serial", got ${JSON.stringify(mode)}`);
+    if (mode === "default")
+        delete suite.mode;
+    else
+        suite.mode = mode;
+}
+const groupSuffix = (test) => test.group === undefined ? "" : `@${test.group}`;
+/** The serial block a test belongs to: the outermost suite around it in `"serial"` mode, else none */
+export function serialBlockOf(test) {
+    const suite = suiteChain(test.suite).find((s) => s.mode === "serial");
+    if (!suite)
+        return undefined;
+    const titles = suiteChain(suite).flatMap((s) => s.title === undefined ? [] : [s.title]);
+    // The same block run for two groups is two blocks
+    return {
+        key: `serial:${test.file}::${titles.join(" > ")}${groupSuffix(test)}`,
+        suite,
+    };
+}
+/**
+ * The unit a test runs in. A serial block is one. With `fullyParallel: false` every other test is in the unit of
+ * its file, unless a suite around it is in `"parallel"` mode. Otherwise (`true`, or not set: the tests of a file
+ * go to workers one by one) there is no unit.
+ */
+export function unitOf(test, fullyParallel) {
+    const block = serialBlockOf(test);
+    if (block)
+        return { key: block.key, serial: true };
+    if (fullyParallel !== false)
+        return undefined;
+    const nearest = suiteChain(test.suite)
+        .reverse()
+        .find((s) => s.mode === "parallel");
+    return nearest
+        ? undefined
+        : { key: `file:${test.file}${groupSuffix(test)}`, serial: false };
+}
+/** Splits a list of tests into serial blocks and the free tests between them, keeping the order */
+export function chunkBySerialBlock(tests) {
+    const chunks = [];
+    for (const test of tests) {
+        const block = serialBlockOf(test);
+        const last = chunks[chunks.length - 1];
+        if (block && last?.block?.key === block.key)
+            last.tests.push(test);
+        else
+            chunks.push({ ...(block && { block }), tests: [test] });
+    }
+    return chunks;
+}

package/dist/runner/shard.d.ts

@@ -0,0 +1,22 @@
+import type { RegisteredTestCase } from "../types/test.js";
+/** One slice of a run split over several machines: slice `current` of `total`, counting from 1 */
+export interface Shard {
+    current: number;
+    total: number;
+}
+/**
+ * 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 declare function parseShard(value: unknown, where: string): Shard;
+/**
+ * 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 declare function shardGroupOf(test: RegisteredTestCase, fullyParallel: boolean | undefined): string;
+/**
+ * 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 declare function shardTests(tests: RegisteredTestCase[], { current, total }: Shard, groupOf: (test: RegisteredTestCase) => string): RegisteredTestCase[];

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/suite.d.ts

@@ -1,12 +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;

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;
 }

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

@@ -1,4 +1,4 @@
-import type { AllHook, TestCaseBase, TestDetails, TestInfo, TestOptions } from "../types/test.js";
+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 */
@@ -86,6 +86,18 @@ export interface DescribeFunction {
     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> {

package/dist/runner/test-info.js

@@ -26,7 +26,8 @@ export class TestInfoImpl {
             this.column = test.column;
         this.retry = from.retry;
         this.workerIndex = from.workerIndex;
-        this.project = { name: from.browserName };
+        // 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;

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

@@ -39,6 +39,7 @@ export default class TestRunner {
      * was also written to the report. With more than one worker the tests run at the same time in worker processes.
      */
     start(): Promise<import("../types/test.js").TestSummary>;
+    private execute;
     /** Whether anything but the default says how many workers to use */
     private workersAsked;
     /** The pool of a run: up to `workers` worker processes that read the same project and settings as this run */