slicetest 0.7.0 → 0.8.0

package/dist/global-setup.js

@@ -38,7 +38,7 @@ export default async function setup(project) {
         }
         finally {
             if (coverageDir)
-                await reportCoverage(opts, coverageDir);
+                await reportCoverage(opts, coverageDir, await partialRun(project));
             if (usageDir)
                 await reportUsage(opts, usageDir);
             if (recordDir)
@@ -102,7 +102,30 @@ async function startDatabase(opts, builds) {
         },
     };
 }
-async function reportCoverage(opts, dir) {
+/**
+ * Why this run covers only part of the suite (a file or name filter, tags, a shard), or undefined for a full run.
+ * Coverage then says little about the suite, so `minCoverage` isn't enforced and the cache for `gen --uncovered` is kept.
+ */
+export async function partialRun(project) {
+    try {
+        const config = project.vitest.config;
+        if (config.testNamePattern)
+            return `only scenarios matching ${config.testNamePattern}`;
+        if (process.env.SLICETEST_TAGS)
+            return `only tags ${process.env.SLICETEST_TAGS}`;
+        if (config.shard)
+            return "one shard";
+        const all = (await project.globTestFiles()).testFiles.length;
+        const ran = project.vitest.state.getFiles().filter((f) => f.projectName === project.name).length;
+        if (ran > 0 && ran < all)
+            return `${ran} of ${all} files`;
+    }
+    catch {
+        // An API this Vitest version lacks: treat the run as complete, as before.
+    }
+    return undefined;
+}
+async function reportCoverage(opts, dir, partial) {
     try {
         const hits = new Set();
         for (const file of await readdir(dir)) {
@@ -117,11 +140,12 @@ async function reportCoverage(opts, dir) {
         const report = formatCoverage(spec, hits);
         // For `slicetest gen --uncovered`.
         const cache = coverageCacheFile(opts.root);
-        await mkdir(path.dirname(cache), { recursive: true }).then(() => writeFile(cache, JSON.stringify([...hits]))).catch(() => { });
-        console.log(`\n${report.text}\n`);
+        if (!partial)
+            await mkdir(path.dirname(cache), { recursive: true }).then(() => writeFile(cache, JSON.stringify([...hits]))).catch(() => { });
+        console.log(`\n${report.text}${partial ? `\n(partial run: ${partial}; openapi.minCoverage is checked on full runs)` : ""}\n`);
         await appendSummary(report.markdown);
         const min = opts.openapi.minCoverage;
-        if (min !== undefined && report.percent < min) {
+        if (min !== undefined && report.percent < min && !partial) {
             // Not thrown: Vitest reports teardown errors as a crash. The failing exit code is what CI needs.
             const message = `OpenAPI coverage ${report.percent}% is below openapi.minCoverage (${min}%)`;
             console.error(`slicetest: ${message}\n`);

package/dist/http.d.ts

@@ -11,11 +11,15 @@ export interface HttpResponse {
     /** Wall-clock time of the request in milliseconds. */
     durationMs: number;
 }
+type QueryValue = string | number | boolean;
 export interface RequestOptions {
     headers?: Record<string, string>;
-    query?: Record<string, string | number | boolean | undefined>;
+    /** A list repeats the parameter: `{ tag: ["a", "b"] }` is `?tag=a&tag=b`. */
+    query?: Record<string, QueryValue | QueryValue[] | undefined>;
     /** Follow redirects instead of returning the 3xx response. Default false. */
     follow?: boolean;
+    /** Fail the request when the app hasn't answered within this many ms, naming it, instead of the whole test timing out. */
+    timeout?: number;
 }
 /** Per-scenario state shared by a client and every client derived from it with `with()`. */
 declare class Session {
@@ -35,8 +39,12 @@ export declare class HttpClient {
     constructor(baseUrl: string, defaults?: RequestOptions, session?: Session);
     /** A client that adds `opts` (e.g. an auth header) to every request, sharing this one's cookies. */
     with(opts: RequestOptions): HttpClient;
-    /** Wrap fields to be sent as `application/x-www-form-urlencoded`. */
-    form(fields: Record<string, string | number | boolean>): URLSearchParams;
+    /**
+     * Wrap fields to be sent as `application/x-www-form-urlencoded`. A list repeats the key (`to=a&to=b`,
+     * as an HTML form sends it), and nested objects use bracket keys (`metadata[order]=7`,
+     * `items[0][price]=p_1`), as Rails, PHP and Stripe read them. `null` / `undefined` are left out.
+     */
+    form(fields: Record<string, unknown>): URLSearchParams;
     get(path: string, opts?: RequestOptions): Promise<HttpResponse>;
     head(path: string, opts?: RequestOptions): Promise<HttpResponse>;
     delete(path: string, opts?: RequestOptions): Promise<HttpResponse>;

package/dist/http.js

@@ -1,4 +1,4 @@
-import { formRequest } from "./form.js";
+import { encodeForm, formRequest } from "./form.js";
 import { lookupHost } from "./intercept.js";
 import { timeline } from "./timeline.js";
 import { signWebhook, webhookBody } from "./webhook.js";
@@ -34,9 +34,13 @@ export class HttpClient {
     with(opts) {
         return new HttpClient(this.baseUrl, merge(this.defaults, opts), this.#session);
     }
-    /** Wrap fields to be sent as `application/x-www-form-urlencoded`. */
+    /**
+     * Wrap fields to be sent as `application/x-www-form-urlencoded`. A list repeats the key (`to=a&to=b`,
+     * as an HTML form sends it), and nested objects use bracket keys (`metadata[order]=7`,
+     * `items[0][price]=p_1`), as Rails, PHP and Stripe read them. `null` / `undefined` are left out.
+     */
     form(fields) {
-        return new URLSearchParams(Object.entries(fields).map(([k, v]) => [k, String(v)]));
+        return encodeForm(fields);
     }
     get(path, opts) {
         return this.request("GET", path, undefined, opts);
@@ -84,8 +88,9 @@ export class HttpClient {
      * `{ invalidSignature: true }` and `{ stale: true }` make deliveries the app must refuse.
      */
     webhook(path, payload, opts) {
-        const { body, type } = webhookBody(payload);
-        return this.request("POST", path, body, { headers: { "content-type": type, ...signWebhook(body, opts), ...opts.headers } });
+        const { body, type } = webhookBody(payload, opts.provider);
+        const url = opts.url ?? new URL(path, this.baseUrl).href;
+        return this.request("POST", path, body, { headers: { "content-type": type, ...signWebhook(body, { ...opts, url }), ...opts.headers } });
     }
     /**
      * Send a GraphQL operation to the app: `http.graphql("query { poll(id: 1) { title } }")`,
@@ -122,9 +127,17 @@ export class HttpClient {
         if (url.origin !== new URL(this.baseUrl).origin) {
             throw new Error(`slicetest: http only talks to the app under test; "${path}" resolves to ${url.origin}`);
         }
-        for (const [k, v] of Object.entries(opts.query ?? {}))
-            if (v !== undefined)
+        for (const [k, v] of Object.entries(opts.query ?? {})) {
+            if (v === undefined)
+                continue;
+            if (Array.isArray(v)) {
+                url.searchParams.delete(k);
+                for (const item of v)
+                    url.searchParams.append(k, String(item));
+            }
+            else
                 url.searchParams.set(k, String(v));
+        }
         let res = await this.#send(method, url, body, opts);
         for (let hops = 0; opts.follow && REDIRECTS.has(res.status) && hops < 20; hops++) {
             const location = res.headers.get("location");
@@ -171,14 +184,14 @@ export class HttpClient {
         const started = performance.now();
         let res;
         try {
-            res = await fetch(target, { method, headers, body: payload, redirect: "manual" });
+            res = await fetch(target, { method, headers, body: payload, redirect: "manual", signal: opts.timeout ? AbortSignal.timeout(opts.timeout) : undefined });
         }
         catch (e) {
             const cause = e.cause?.code;
             const failed = { method, url: url.pathname + url.search, status: 0, headers: new Headers(), text: `${e}${cause ? ` (${cause})` : ""}`, json: undefined, durationMs: Math.round(performance.now() - started) };
             timeline.set(failed, { start: started, end: performance.now() });
             this.#record(failed);
-            throw e;
+            throw new Error(`slicetest: ${method} ${failed.url}: ${requestFailure(e, cause, opts.timeout)}`, { cause: e });
         }
         if (!stub)
             for (const cookie of res.headers.getSetCookie())
@@ -292,6 +305,16 @@ function pathMatches(requestPath, cookiePath) {
         return false;
     return cookiePath.endsWith("/") || requestPath[cookiePath.length] === "/";
 }
+/** Why a request got no response, in terms of what to look at. */
+function requestFailure(e, code, timeout) {
+    if (e.name === "TimeoutError")
+        return `no response within ${timeout}ms (http timeout); the app may be waiting on a stub with a delay, a lock or a slow query`;
+    if (code === "ECONNREFUSED")
+        return "connection refused: the app isn't listening (it may have crashed; its output is below)";
+    if (code === "ECONNRESET" || code === "UND_ERR_SOCKET")
+        return "the app closed the connection without answering (did it crash or exit?)";
+    return `${e.message}${code ? ` (${code})` : ""}`;
+}
 function merge(a, b) {
     return {
         ...a,

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 export { scenario } from "./scenario.js";
+export type { ScenarioOptions } from "./scenario.js";
 export { mask } from "./trace.js";
 export type { Trace, MaskOptions } from "./trace.js";
 export type { ScenarioContext } from "./runtime.js";
-export type { Db, Row, Where, RowsOptions, Changes, TableChanges } from "./db.js";
-export type { Stub, RecordedCall, StubResponse, Responder, MatchOptions, RouteBuilder, GraphQLRouteBuilder, ChaosOptions, ServerSentEvent } from "./stub.js";
+export type { Db, Row, Where, RowsOptions, Changes, TableChanges, ChangesOptions } from "./db.js";
+export type { Stub, RecordedCall, StubResponse, Responder, MatchOptions, RouteBuilder, GraphQLRouteBuilder, ChaosOptions, ServerSentEvent, UploadedFile } from "./stub.js";
 export type { GraphQLCall } from "./graphql.js";
 export { sse } from "./stub.js";
 export type { HttpClient, HttpResponse, RequestOptions } from "./http.js";
@@ -15,4 +16,4 @@ export type { Issuer, TokenOptions, AuthOptions } from "./auth.js";
 export { normalizeSql, type Query, type QueryList } from "./query-log.js";
 export { signWebhook, type WebhookOptions, type WebhookProvider, type HmacScheme } from "./webhook.js";
 export type { SlicetestOptions, ContainerOptions } from "./config.js";
-export type {} from "./matchers.js";
+export type { OrderedCall } from "./matchers.js";

package/dist/list.d.ts

@@ -0,0 +1,26 @@
+export interface ListedScenario {
+    file: string;
+    line: number;
+    name: string;
+    tags: string[];
+    /** `skip`, `only`, or what `--tag` / `-t` leave out. */
+    status: "run" | "skip" | "only" | "filtered";
+    /** Rows of `each`: the scenario runs once per row. */
+    rows: number;
+    steps: number;
+}
+/**
+ * The YAML scenarios under `root`, without starting anything: for a quick look at what a run
+ * would do, which `--tag` / `-t` select, and for tools (`--json`). Files that don't parse are
+ * reported in `errors` with their line, as a run would report them.
+ */
+export declare function listScenarios(root: string, opts?: {
+    filters?: string[];
+    name?: string;
+    tags?: string;
+}): Promise<{
+    scenarios: ListedScenario[];
+    errors: string[];
+}>;
+/** One line per scenario, grouped by file. */
+export declare function formatList({ scenarios, errors }: Awaited<ReturnType<typeof listScenarios>>): string;

package/dist/list.js

@@ -0,0 +1,71 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { tagsSelected } from "./scenario.js";
+import { parseScenarioFile } from "./yaml.js";
+const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "target", "vendor", ".venv", "venv"]);
+async function scenarioFiles(dir, out = []) {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith("."))
+                await scenarioFiles(path.join(dir, entry.name), out);
+        }
+        else if (/\.scenario\.ya?ml$/.test(entry.name))
+            out.push(path.join(dir, entry.name));
+    }
+    return out.sort();
+}
+/**
+ * The YAML scenarios under `root`, without starting anything: for a quick look at what a run
+ * would do, which `--tag` / `-t` select, and for tools (`--json`). Files that don't parse are
+ * reported in `errors` with their line, as a run would report them.
+ */
+export async function listScenarios(root, opts = {}) {
+    const scenarios = [];
+    const errors = [];
+    const pattern = opts.name ? new RegExp(opts.name) : undefined;
+    for (const file of await scenarioFiles(root)) {
+        const rel = path.relative(root, file).split(path.sep).join("/");
+        if (opts.filters?.length && !opts.filters.some((f) => rel.includes(f)))
+            continue;
+        try {
+            const doc = parseScenarioFile(await readFile(file, "utf8"), rel);
+            for (const sc of doc.scenarios) {
+                const tags = sc.tags ?? [];
+                const selected = tagsSelected(tags, opts.tags) && (!pattern || pattern.test(sc.name));
+                scenarios.push({
+                    file: rel,
+                    line: sc.line,
+                    name: sc.name,
+                    tags,
+                    status: sc.skip ? "skip" : !selected ? "filtered" : sc.only ? "only" : "run",
+                    rows: sc.each?.length ?? 1,
+                    steps: doc.setup.length + sc.steps.length,
+                });
+            }
+        }
+        catch (e) {
+            errors.push(e.message);
+        }
+    }
+    return { scenarios, errors };
+}
+/** One line per scenario, grouped by file. */
+export function formatList({ scenarios, errors }) {
+    const lines = [];
+    let file = "";
+    for (const s of scenarios) {
+        if (s.file !== file) {
+            file = s.file;
+            lines.push(file);
+        }
+        const mark = { run: "  ", only: "▶ ", skip: "- ", filtered: "· " }[s.status];
+        const rows = s.rows > 1 ? ` ×${s.rows}` : "";
+        const tags = s.tags.length ? `  [${s.tags.join(", ")}]` : "";
+        lines.push(`  ${mark}${s.name}${rows}${tags}  (line ${s.line}, ${s.steps} steps)`);
+    }
+    const runs = scenarios.filter((s) => s.status === "run" || s.status === "only").reduce((n, s) => n + s.rows, 0);
+    lines.push("", `${scenarios.length} scenario(s) in ${new Set(scenarios.map((s) => s.file)).size} file(s); ${runs} run(s) selected.`);
+    if (errors.length)
+        lines.push("", "Files with mistakes:", ...errors.map((e) => `  ${e.split("\n")[0]}`));
+    return `${lines.join("\n")}\n`;
+}

package/dist/matchers.d.ts

@@ -1,11 +1,18 @@
 import { type Where } from "./db.js";
 import type { HttpResponse } from "./http.js";
 import { type MatchOptions } from "./stub.js";
+/** One expected call for `toHaveReceivedInOrder`: `[stub, method, path, match?]`. */
+export type OrderedCall = [stub: string, method: string, path: string | RegExp, match?: MatchOptions];
 interface SlicetestMatchers<R = unknown> {
     /** The stub received at least one call matching `method path` (and `match`, if given). */
     toHaveReceived(method: string, path: string | RegExp, match?: MatchOptions): R;
     /** The stub received exactly `n` calls matching `method path`. */
     toHaveReceivedTimes(n: number, method?: string, path?: string | RegExp, match?: MatchOptions): R;
+    /**
+     * On the scenario's `stub` accessor: the calls happened in this order, across stubs (other calls
+     * may come in between): `expect(stub).toHaveReceivedInOrder([["stripe", "POST", "/v1/charges"], ["mail", "POST", "/send"]])`.
+     */
+    toHaveReceivedInOrder(calls: OrderedCall[]): R;
     /** The stub received a GraphQL request for `operation` (with `variables` as a subset, if given). */
     toHaveReceivedGraphQL(operation: string | RegExp, variables?: unknown): R;
     /** A GraphQL response without `errors`, whose `data` contains `expected` (if given). The failure message shows the errors. */

package/dist/matchers.js

@@ -3,6 +3,7 @@ import { Db } from "./db.js";
 import { describeGraphQL } from "./graphql.js";
 import { schemaProblems } from "./schema.js";
 import { Stub, subset } from "./stub.js";
+import { timeline } from "./timeline.js";
 const MAX_SHOWN = 5;
 function describeCalls(calls) {
     if (calls.length === 0)
@@ -63,6 +64,39 @@ expect.extend({
             expected: n,
         };
     },
+    toHaveReceivedInOrder(received, expected) {
+        if (typeof received !== "function")
+            throw new TypeError("slicetest: toHaveReceivedInOrder takes the scenario's stub accessor: expect(stub).toHaveReceivedInOrder([...])");
+        const stubOf = received;
+        const startOf = (c) => timeline.get(c)?.start ?? 0;
+        let after = -Infinity;
+        let failedAt = -1;
+        for (const [i, [name, method, path, match]] of expected.entries()) {
+            const next = stubOf(name)
+                .calls(method, path, match)
+                .map(startOf)
+                .filter((t) => t > after)
+                .sort((a, b) => a - b)[0];
+            if (next === undefined) {
+                failedAt = i;
+                break;
+            }
+            after = next;
+        }
+        const names = [...new Set(expected.map(([n]) => n))];
+        const all = names
+            .flatMap((n) => stubOf(n).calls().map((c) => ({ n, c })))
+            .sort((a, b) => startOf(a.c) - startOf(b.c))
+            .map(({ n, c }) => `  ${n}: ${c.graphql ? describeGraphQL(c.graphql) : `${c.method} ${c.path}`}`);
+        const label = ([n, m, p, match]) => `${n}: ${m} ${p}${match && Object.keys(match).length ? ` with ${JSON.stringify(match, (_, v) => (v instanceof RegExp ? String(v) : v))}` : ""}`;
+        return {
+            pass: failedAt === -1,
+            message: () => failedAt === -1
+                ? `expected the stubs not to receive, in this order:\n${expected.map((e) => `  ${label(e)}`).join("\n")}`
+                : `expected the stubs to receive, in this order:\n${expected.map((e, i) => `  ${i === failedAt ? "✗" : i < failedAt ? "✓" : " "} ${label(e)}`).join("\n")}\n` +
+                    `${failedAt === 0 ? "the first call never came" : `no matching call came after #${failedAt}`}. Calls received, in order:\n${all.join("\n") || "  (no calls)"}`,
+        };
+    },
     toHaveReceivedGraphQL(received, operation, variables) {
         assertStub(received);
         const pass = received.calls("*", undefined, { graphql: { operation, variables } }).length > 0;

package/dist/record.d.ts

@@ -1,6 +1,6 @@
 import type { Changes } from "./db.js";
 import type { ScenarioContext } from "./runtime.js";
-import type { RecordedCall } from "./stub.js";
+import { type RecordedCall } from "./stub.js";
 /**
  * `npx slicetest record`: use the app for real (a browser, curl, a mobile
  * client) through a proxy, and get the session back as a YAML scenario: the

package/dist/record.js

@@ -3,6 +3,7 @@ import { writeFile } from "node:fs/promises";
 import http from "node:http";
 import path from "node:path";
 import { stringify } from "yaml";
+import { parseForm } from "./stub.js";
 import { mask } from "./trace.js";
 export const SESSION_ENV = "SLICETEST_RECORD_SESSION";
 /** Requests a browser makes on its own, not part of what the scenario is about. */
@@ -113,8 +114,9 @@ export function buildScenario(exchanges, calls, changes, { name = "recorded sess
         if (x.body) {
             if (/json/i.test(x.contentType ?? ""))
                 step.json = parse(reqBody, "application/json");
+            // Nested and repeated fields survive: `form:` is encoded back the same way on replay.
             else if (/x-www-form-urlencoded/i.test(x.contentType ?? ""))
-                step.form = Object.fromEntries(new URLSearchParams(reqBody));
+                step.form = parseForm(reqBody);
             else
                 step.body = reqBody;
         }

package/dist/runtime.js

@@ -124,6 +124,7 @@ export class Runtime {
                 ? await Db.connect(await engine.driver(url), url, {
                     schemas: opts.db.schemas,
                     keep: opts.db.keep,
+                    ignoreChanges: opts.db.ignoreChanges,
                     seedFile: opts.db.seed && path.resolve(opts.root, opts.db.seed),
                 })
                 : noDatabase();

package/dist/scenario.d.ts

@@ -1,15 +1,25 @@
 import type { Runtime, ScenarioContext } from "./runtime.js";
 export declare function setRuntime(runtime: Runtime | undefined): void;
 type Body = (ctx: ScenarioContext) => Promise<void> | void;
+export interface ScenarioOptions {
+    timeout?: number;
+    /** Labels to select scenarios by: `npx slicetest --tag smoke`, or `SLICETEST_TAGS=smoke,!slow` with Vitest. */
+    tags?: string[];
+}
+/**
+ * Whether a scenario with `tags` runs under `filter` (`SLICETEST_TAGS`): comma- or space-separated tags,
+ * any of which it must have, and `!tag`s it must not have. No filter runs everything.
+ */
+export declare function tagsSelected(tags?: readonly string[], filter?: string | undefined): boolean;
 /**
  * A test that runs against the real app. The database is reset to the
  * migrated schema (plus seed) and stubs are cleared before each scenario.
  */
-export declare const scenario: ((name: string, body: Body, timeout?: number) => void) & {
-    only: (name: string, body: Body, timeout?: number) => void;
-    skip: (name: string, body: Body, timeout?: number) => void;
+export declare const scenario: ((name: string, body: Body, options?: number | ScenarioOptions) => void) & {
+    only: (name: string, body: Body, options?: number | ScenarioOptions) => void;
+    skip: (name: string, body: Body, options?: number | ScenarioOptions) => void;
     todo: (name: string) => void;
     /** Same scenario for each row: `scenario.each(rows)("name %s", async (row, ctx) => ...)`. */
-    each<T>(rows: readonly T[]): (name: string, body: (row: T, ctx: ScenarioContext) => Promise<void> | void, timeout?: number) => void;
+    each<T>(rows: readonly T[]): (name: string, body: (row: T, ctx: ScenarioContext) => Promise<void> | void, options?: number | ScenarioOptions) => void;
 };
 export {};

package/dist/scenario.js

@@ -6,25 +6,41 @@ const slot = globalThis;
 export function setRuntime(runtime) {
     slot[KEY] = runtime;
 }
+/**
+ * Whether a scenario with `tags` runs under `filter` (`SLICETEST_TAGS`): comma- or space-separated tags,
+ * any of which it must have, and `!tag`s it must not have. No filter runs everything.
+ */
+export function tagsSelected(tags = [], filter = process.env.SLICETEST_TAGS) {
+    const terms = (filter ?? "").split(/[\s,]+/).filter(Boolean);
+    const excluded = terms.filter((t) => t.startsWith("!")).map((t) => t.slice(1));
+    const wanted = terms.filter((t) => !t.startsWith("!"));
+    if (tags.some((t) => excluded.includes(t)))
+        return false;
+    return wanted.length === 0 || tags.some((t) => wanted.includes(t));
+}
 function define(register) {
-    return (name, body, timeout) => register(name, async ({ onTestFailed, task }) => {
-        const runtime = slot[KEY];
-        if (!runtime) {
-            throw new Error("slicetest: runtime not started. Add the slicetest() plugin to your vitest config.");
-        }
-        if (task.concurrent) {
-            throw new Error("slicetest: scenarios share one app and database per file, so they can't run concurrently. Remove .concurrent / sequence.concurrent.");
-        }
-        const file = task.file?.filepath ?? task.file?.name ?? "";
-        onTestFailed(async () => {
-            console.error(`--- slicetest ---\n${await runtime.diagnostics()}\n-----------------`);
-            await runtime.reportDiagram(file, task.name, true);
-        });
-        await runtime.beforeScenario();
-        await body(runtime.context());
-        await runtime.afterScenario();
-        await runtime.reportDiagram(file, task.name, false);
-    }, timeout);
+    return (name, body, options) => {
+        const { timeout, tags } = typeof options === "number" ? { timeout: options, tags: undefined } : (options ?? {});
+        // Scenarios the tag filter leaves out show as skipped, so the filter is visible in the summary.
+        return (tagsSelected(tags) ? register : test.skip)(name, async ({ onTestFailed, task }) => {
+            const runtime = slot[KEY];
+            if (!runtime) {
+                throw new Error("slicetest: runtime not started. Add the slicetest() plugin to your vitest config.");
+            }
+            if (task.concurrent) {
+                throw new Error("slicetest: scenarios share one app and database per file, so they can't run concurrently. Remove .concurrent / sequence.concurrent.");
+            }
+            const file = task.file?.filepath ?? task.file?.name ?? "";
+            onTestFailed(async () => {
+                console.error(`--- slicetest ---\n${await runtime.diagnostics()}\n-----------------`);
+                await runtime.reportDiagram(file, task.name, true);
+            });
+            await runtime.beforeScenario();
+            await body(runtime.context());
+            await runtime.afterScenario();
+            await runtime.reportDiagram(file, task.name, false);
+        }, timeout);
+    };
 }
 /**
  * A test that runs against the real app. The database is reset to the
@@ -36,10 +52,10 @@ export const scenario = Object.assign(define(test), {
     todo: (name) => test.todo(name),
     /** Same scenario for each row: `scenario.each(rows)("name %s", async (row, ctx) => ...)`. */
     each(rows) {
-        return (name, body, timeout) => {
+        return (name, body, options) => {
             rows.forEach((row, i) => {
                 const title = format(name, row, i);
-                define(test)(title, (ctx) => body(row, ctx), timeout);
+                define(test)(title, (ctx) => body(row, ctx), options);
             });
         };
     },

package/dist/stub.d.ts

@@ -8,6 +8,13 @@ export interface RecordedCall {
     body: string;
     /** Parsed JSON body, or undefined when the body isn't JSON. */
     json: any;
+    /**
+     * Fields of an `application/x-www-form-urlencoded` body (Stripe, Twilio, OAuth token requests),
+     * with bracket keys nested as the providers read them: `metadata[order]=7&items[0][price]=p_1`
+     * is `{ metadata: { order: "7" }, items: [{ price: "p_1" }] }`. For `multipart/form-data`, the
+     * fields with files as `{ filename, type, size, text }`. Undefined for other bodies.
+     */
+    form?: Record<string, unknown>;
     /** Values captured by `:name` segments of the matching route's path. */
     params: Record<string, string>;
     /** Whether a registered route answered this call. */
@@ -71,6 +78,8 @@ export interface MatchOptions {
     query?: Record<string, Matcher>;
     headers?: Record<string, Matcher>;
     json?: unknown;
+    /** Subset of a form-encoded body's fields (`call.form`). Numbers and booleans compare as the strings sent. */
+    form?: Record<string, unknown>;
     body?: Matcher;
     /** A GraphQL request for this operation (its name, or a RegExp), with `variables` as a subset. */
     graphql?: {
@@ -173,4 +182,17 @@ export declare class Stub {
 }
 /** `expected` is contained in `actual`: objects compare key by key, arrays element-wise. */
 export declare function subset(expected: unknown, actual: unknown): boolean;
+/**
+ * A form body as nested fields, the way Rack, PHP and Stripe read bracket keys: `a[b]=1` is
+ * `{ a: { b: "1" } }`, `a[]=1&a[]=2` and `a[0]=1&a[1]=2` are arrays, and a plain key sent
+ * twice (`to=1&to=2`) becomes an array too.
+ */
+export declare function parseForm(body: string): Record<string, unknown>;
+/** A file in a multipart body, as `call.form` shows it. `text` only for text, JSON, XML and CSV files. */
+export interface UploadedFile {
+    filename: string;
+    type: string;
+    size: number;
+    text?: string;
+}
 export {};