slicetest 0.9.0 → 0.10.0

package/dist/drivers/postgres.js

@@ -1,4 +1,5 @@
 import pg from "pg";
+import { loadContainers } from "../container-runtime.js";
 const INT8 = 20;
 /** int8 columns (bigserial ids, count(*)) come back as numbers when they fit, instead of strings. */
 const types = {
@@ -88,6 +89,24 @@ export class PostgresDriver {
             : `INSERT INTO ${this.ident(table)} (${cols.map((c) => this.ident(c)).join(", ")}) VALUES (${cols.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING *`;
         return this.query(sql, Object.values(row));
     }
+    /** Columns backed by a sequence, per table: looked up once, since most inserts don't give their ids. */
+    #sequenced = new Map();
+    async syncSequences(table, columns) {
+        const name = this.ident(table);
+        let owned = this.#sequenced.get(name);
+        if (!owned) {
+            owned = await this.query(`SELECT a.attname AS col, pg_get_serial_sequence($1, a.attname) AS seq
+           FROM pg_attribute a
+          WHERE a.attrelid = to_regclass($1) AND a.attnum > 0 AND NOT a.attisdropped AND pg_get_serial_sequence($1, a.attname) IS NOT NULL`, [name]);
+            this.#sequenced.set(name, owned);
+        }
+        // An empty table restarts at 1; otherwise the next value follows the largest id.
+        for (const { col, seq } of owned) {
+            if (columns && !columns.includes(col))
+                continue;
+            await this.query(`SELECT setval($1, COALESCE(MAX(${this.column(col)}), 1), MAX(${this.column(col)}) IS NOT NULL) FROM ${name}`, [seq]);
+        }
+    }
     async describe(table) {
         const [{ oid } = { oid: null }] = await this.query("SELECT to_regclass($1)::oid AS oid", [this.ident(table)]);
         if (oid === null)
@@ -168,7 +187,7 @@ export const postgres = {
     name: "postgres",
     defaultImage: "postgres:17-alpine",
     async startContainer(image, reuse) {
-        const { PostgreSqlContainer } = await import("@testcontainers/postgresql");
+        const { PostgreSqlContainer } = await loadContainers(() => import("@testcontainers/postgresql"));
         const definition = new PostgreSqlContainer(image);
         // A reused container is left running and found again by its configuration on the next run.
         if (reuse)

package/dist/exit.d.ts

@@ -0,0 +1 @@
+export declare function onProcessExit(hook: () => void): void;

package/dist/exit.js

@@ -0,0 +1,28 @@
+// One listener per process, not per copy of the package (many Vitest projects ended in Node's "11 exit
+// listeners" warning). Vitest ends a worker with SIGTERM, which skips `exit` and left worker-scope apps running.
+const KEY = Symbol.for("slicetest.exitHooks");
+export function onProcessExit(hook) {
+    const g = globalThis;
+    if (!g[KEY]) {
+        const hooks = (g[KEY] = new Set());
+        const run = () => {
+            for (const h of hooks) {
+                try {
+                    h();
+                }
+                catch { }
+            }
+            hooks.clear();
+        };
+        process.once("exit", run);
+        // Sent again only when nobody else listens: its default action then ends the process as before.
+        for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+            process.once(signal, () => {
+                run();
+                if (process.listenerCount(signal) === 0)
+                    process.kill(process.pid, signal);
+            });
+        }
+    }
+    g[KEY].add(hook);
+}

package/dist/form.d.ts

@@ -33,6 +33,7 @@ interface Control {
     /** For select: its options. */
     options: {
         value: string;
+        label: string;
         selected: boolean;
         disabled: boolean;
     }[];

package/dist/form.js

@@ -8,7 +8,11 @@
 const TAG = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][\w-]*)((?:\s+[^\s=>/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*)\s*\/?>/g;
 const ATTR = /([^\s=>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
 const RAW_TEXT = new Set(["script", "style", "template"]);
-const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", "#39": "'" };
+const ENTITIES = {
+    amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", "#39": "'",
+    copy: "©", reg: "®", trade: "™", hellip: "…", mdash: "—", ndash: "–", laquo: "«", raquo: "»",
+    lsquo: "‘", rsquo: "’", ldquo: "“", rdquo: "”", yen: "¥", euro: "€", middot: "·", times: "×",
+};
 export function decodeEntities(s) {
     return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+\d*);/gi, (m, e) => {
         if (e[0] === "#") {
@@ -52,8 +56,8 @@ export function parseForms(html) {
     const closeOption = (end) => {
         if (!option || !select)
             return;
-        const value = option.attrs.value ?? textOf(html.slice(option.start, end));
-        select.options.push({ value, selected: "selected" in option.attrs, disabled: "disabled" in option.attrs || groupDisabled });
+        const label = textOf(html.slice(option.start, end));
+        select.options.push({ value: option.attrs.value ?? label, label, selected: "selected" in option.attrs, disabled: "disabled" in option.attrs || groupDisabled });
         option = undefined;
     };
     TAG.lastIndex = 0;
@@ -192,13 +196,15 @@ export function formRequest(html, opts = {}) {
         if (value instanceof Blob)
             files.set(name, value);
         else
-            typed.set(name, typeof value === "boolean" ? value : (Array.isArray(value) ? value : [value]).map(String));
+            typed.set(name, typeof value === "boolean" ? value : offered(form, name, (Array.isArray(value) ? value : [value]).map(String)));
     }
     // The successful controls, in document order (HTML's "constructing the entry list").
     // A typed value replaces what the page had: text for a field, the checked state for
     // checkboxes and radios (true / false, or the values to check), the options of a select.
     const entries = [];
     const done = new Set();
+    // A name shared by checkboxes and a hidden field (Rails' check_box sends `0` unless the box is checked): typing checks the boxes.
+    const boxed = new Set(form.controls.filter((c) => c.tag === "input" && ["checkbox", "radio"].includes(c.attrs.type?.toLowerCase() ?? "")).map((c) => c.attrs.name));
     for (const c of form.controls) {
         const name = c.attrs.name;
         if (c === button && c.attrs.type?.toLowerCase() === "image") {
@@ -225,7 +231,7 @@ export function formRequest(html, opts = {}) {
             done.add(name);
             continue;
         }
-        const want = typed.get(name);
+        const want = type === "checkbox" || type === "radio" || !boxed.has(name) ? typed.get(name) : undefined;
         if (type === "checkbox" || type === "radio") {
             const value = c.attrs.value ?? "on";
             const checked = want === undefined ? "checked" in c.attrs : typeof want === "boolean" ? want : want.includes(value);
@@ -253,7 +259,10 @@ export function formRequest(html, opts = {}) {
                     entries.push([name, o.value]);
         }
         else
-            entries.push([name, c.attrs.value ?? ""]);
+            entries.push([name, type === "hidden" && name === "_charset_" ? "UTF-8" : (c.attrs.value ?? "")]);
+        // Text controls with a `dirname` also send their direction; left-to-right is what a test page has.
+        if (c.attrs.dirname && (c.tag === "textarea" || ["text", "search", "tel", "url", "email"].includes(type)))
+            entries.push([c.attrs.dirname, "ltr"]);
     }
     const pick = (attr) => (button && button.attrs[`form${attr}`] !== undefined ? button.attrs[`form${attr}`] : form.attrs[attr]);
     const method = (pick("method") ?? "get").toUpperCase() === "POST" ? "POST" : "GET";
@@ -263,6 +272,12 @@ export function formRequest(html, opts = {}) {
         throw new Error(`slicetest: submit: the form sends ${method === "GET" ? "a GET" : "urlencoded"} data, which can't carry files; a browser would send only the file name. Upload forms need method="post" enctype="multipart/form-data"`);
     }
     // Outside multipart, a file field is sent as its file name (empty when none was chosen), as browsers do.
+    // Browsers send line breaks as CRLF; URLSearchParams would keep a bare "\n".
+    for (const e of entries) {
+        e[0] = crlf(e[0]);
+        if (typeof e[1] === "string")
+            e[1] = crlf(e[1]);
+    }
     const plain = () => new URLSearchParams(entries.map(([k, v]) => [k, typeof v === "string" ? v : (v.name ?? "")]));
     if (method === "GET")
         return { method, action: `${action.replace(/[?#].*$/, "")}?${plain()}` };
@@ -277,6 +292,35 @@ export function formRequest(html, opts = {}) {
     }
     return { method, action, body };
 }
+const crlf = (s) => s.replace(/\r\n|\r|\n/g, "\r\n");
+/**
+ * Typed values for a select, radios or checkboxes, checked against what the page offers: a browser can't pick
+ * anything else. A select option may be named by its label too; it is sent as its value.
+ */
+function offered(form, name, values) {
+    const controls = form.controls.filter((c) => c.attrs.name === name && !("disabled" in c.attrs));
+    const select = controls.find((c) => c.tag === "select");
+    if (select) {
+        const usable = select.options.filter((o) => !o.disabled);
+        return values.map((v) => {
+            const o = usable.find((x) => x.value === v) ?? usable.find((x) => x.label === v);
+            if (o)
+                return o.value;
+            const off = select.options.filter((x) => x.disabled).map((x) => x.value);
+            throw new Error(`slicetest: submit: the select "${name}" has no option ${JSON.stringify(v)} (options: ${usable.map((x) => `${x.value} ${JSON.stringify(x.label)}`).join(", ") || "none"}${off.length ? `; disabled: ${off.join(", ")}` : ""})`);
+        });
+    }
+    for (const type of ["radio", "checkbox"]) {
+        const boxes = controls.filter((c) => c.tag === "input" && c.attrs.type?.toLowerCase() === type);
+        if (!boxes.length)
+            continue;
+        const have = boxes.map((c) => c.attrs.value ?? "on");
+        const bad = values.find((v) => !have.includes(v));
+        if (bad !== undefined)
+            throw new Error(`slicetest: submit: no ${type === "radio" ? "radio button" : "checkbox"} "${name}" has the value ${JSON.stringify(bad)} (values: ${have.join(", ")})`);
+    }
+    return values;
+}
 /** Fields as `application/x-www-form-urlencoded`: lists repeat the key, nested objects use bracket keys (`metadata[order]`). */
 export function encodeForm(fields) {
     const out = new URLSearchParams();

package/dist/har.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { mergeRecordings, redactRequest } from "./recording.js";
+import { mergeRecordings, queryOf, redactRequest } from "./recording.js";
 const KEPT_HEADERS = ["content-type", "location", "retry-after", "link", "etag"];
 const TEXTUAL = /json|text|xml|javascript|x-www-form-urlencoded|graphql/i;
 export function harEntries(har, file = "the HAR file") {
@@ -26,7 +26,7 @@ export function toRecording(entry, upstream) {
     // Preflights are the browser's; aborted and blocked requests (status 0) have no answer to replay.
     if (method === "OPTIONS" || !entry.response || !entry.response.status)
         return "skipped";
-    const query = Object.fromEntries([...url.searchParams.entries()].sort(([a], [b]) => a.localeCompare(b)));
+    const query = queryOf(url.searchParams);
     const sent = entry.request.postData?.text;
     const json = parse(sent);
     const request = redactRequest({

package/dist/http.d.ts

@@ -26,8 +26,8 @@ export declare function parseEvents(text: string): ServerEvent[];
 type QueryValue = string | number | boolean;
 export interface RequestOptions {
     headers?: Record<string, string>;
-    /** A list repeats the parameter: `{ tag: ["a", "b"] }` is `?tag=a&tag=b`. */
-    query?: Record<string, QueryValue | QueryValue[] | undefined>;
+    /** A list repeats the parameter: `{ tag: ["a", "b"] }` is `?tag=a&tag=b`. `null` and `undefined` are left out. */
+    query?: Record<string, QueryValue | null | (QueryValue | null)[] | 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. */
@@ -40,7 +40,11 @@ declare class Session {
     cookies: Map<string, string>;
     /** The Path each cookie was set for; a cookie without one (added by hand) goes everywhere. */
     cookiePaths: Map<string, string>;
+    /** When a cookie set with Max-Age or Expires stops being sent (epoch ms). */
+    cookieExpiry: Map<string, number>;
     history: HttpResponse[];
+    /** Every request of the scenario, for trace() and diagrams; `history` keeps only the last few for failure output. */
+    requests: HttpResponse[];
     listeners: ((res: HttpResponse) => void)[];
 }
 /** HTTP client bound to the app under test. Keeps cookies for the duration of a scenario. */
@@ -102,11 +106,13 @@ export declare class HttpClient {
     onResponse(fn: (res: HttpResponse) => void): void;
     /** Let redirects to `host` continue to the stub at `stubUrl`, as they would to the real host in a browser. */
     intercept(host: string, stubUrl: string): void;
-    /** Cookies the app has set during this scenario. Mutations are sent with later requests. */
+    /** Cookies the app has set during this scenario (minus expired ones). Mutations are sent with later requests. */
     get cookies(): Map<string, string>;
     clearCookies(): void;
     /** Requests made during the current scenario, oldest first (last 20). */
     get history(): readonly HttpResponse[];
+    /** Every request made during the current scenario, oldest first. */
+    get requests(): readonly HttpResponse[];
     /** Start a new scenario: forget cookies and history. */
     reset(): void;
 }

package/dist/http.js

@@ -44,7 +44,11 @@ class Session {
     cookies = new Map();
     /** The Path each cookie was set for; a cookie without one (added by hand) goes everywhere. */
     cookiePaths = new Map();
+    /** When a cookie set with Max-Age or Expires stops being sent (epoch ms). */
+    cookieExpiry = new Map();
     history = [];
+    /** Every request of the scenario, for trace() and diagrams; `history` keeps only the last few for failure output. */
+    requests = [];
     listeners = [];
 }
 const HISTORY = 20;
@@ -158,17 +162,21 @@ export class HttpClient {
      */
     async request(method, path, body, options = {}) {
         const opts = merge(this.defaults, options);
+        // Fetch upper-cases get and put but not patch, so `request("patch", …)` went out as "patch".
+        method = method.toUpperCase();
         let url = new URL(path, this.baseUrl);
         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)
+            // `null` too: a value captured from JSON (`next_cursor: null`) would otherwise go out as the text "null".
+            if (v === undefined || v === null)
                 continue;
             if (Array.isArray(v)) {
                 url.searchParams.delete(k);
                 for (const item of v)
-                    url.searchParams.append(k, String(item));
+                    if (item !== null && item !== undefined)
+                        url.searchParams.append(k, String(item));
             }
             else
                 url.searchParams.set(k, String(v));
@@ -182,8 +190,9 @@ export class HttpClient {
             // Like a browser: on to the app, or to a host a stub stands in for; anywhere else is returned.
             if (next.origin !== new URL(this.baseUrl).origin && lookupHost(this.#session.external, next.hostname) === undefined)
                 break;
-            // 307/308 repeat the request as it was; the others turn it into a GET without a body, like browsers do.
-            if (res.status !== 307 && res.status !== 308 && method !== "HEAD") {
+            // Fetch's rules: 303 makes anything but HEAD a GET, 301/302 only a POST; the rest repeat the request as it was.
+            const toGet = res.status === 303 ? method !== "HEAD" : (res.status === 301 || res.status === 302) && method === "POST";
+            if (toGet) {
                 method = "GET";
                 body = undefined;
             }
@@ -275,6 +284,7 @@ export class HttpClient {
         this.#session.listeners.push(fn);
     }
     #record(res) {
+        this.#session.requests.push(res);
         this.#session.history.push(res);
         if (this.#session.history.length > HISTORY)
             this.#session.history.shift();
@@ -283,25 +293,44 @@ export class HttpClient {
     intercept(host, stubUrl) {
         this.#session.external.set(host.toLowerCase(), stubUrl);
     }
-    /** Cookies the app has set during this scenario. Mutations are sent with later requests. */
+    /** Cookies the app has set during this scenario (minus expired ones). Mutations are sent with later requests. */
     get cookies() {
+        this.#dropExpired();
         return this.#session.cookies;
     }
     clearCookies() {
         this.#session.cookies.clear();
         this.#session.cookiePaths.clear();
+        this.#session.cookieExpiry.clear();
+    }
+    #dropExpired() {
+        const { cookies, cookiePaths, cookieExpiry } = this.#session;
+        const now = Date.now();
+        for (const [name, at] of cookieExpiry) {
+            if (at > now)
+                continue;
+            cookies.delete(name);
+            cookiePaths.delete(name);
+            cookieExpiry.delete(name);
+        }
     }
     /** Requests made during the current scenario, oldest first (last 20). */
     get history() {
         return this.#session.history;
     }
+    /** Every request made during the current scenario, oldest first. */
+    get requests() {
+        return this.#session.requests;
+    }
     /** Start a new scenario: forget cookies and history. */
     reset() {
         this.clearCookies();
         this.#session.history = [];
+        this.#session.requests = [];
     }
     /** Cookies whose Path covers `requestPath`, longest Path first as browsers send them (RFC 6265 5.4). */
     #cookieHeader(requestPath) {
+        this.#dropExpired();
         const { cookies, cookiePaths } = this.#session;
         return [...cookies]
             .map(([name, value]) => ({ name, value, path: cookiePaths.get(name) ?? "/" }))
@@ -336,10 +365,16 @@ export class HttpClient {
         if (expired) {
             this.#session.cookies.delete(name);
             this.#session.cookiePaths.delete(name);
+            this.#session.cookieExpiry.delete(name);
         }
         else {
             this.#session.cookies.set(name, pair.slice(eq + 1).trim());
             this.#session.cookiePaths.set(name, cookiePath ?? defaultCookiePath(requestPath));
+            const until = maxAge !== undefined && !Number.isNaN(maxAge) ? Date.now() + maxAge * 1000 : expires !== undefined && !Number.isNaN(expires) ? expires : undefined;
+            if (until === undefined)
+                this.#session.cookieExpiry.delete(name);
+            else
+                this.#session.cookieExpiry.set(name, until);
         }
     }
 }

package/dist/init.js

@@ -114,11 +114,19 @@ export async function detect(root) {
     const appRoot = path.join(root, appDir);
     const has = (p) => existsSync(path.join(appRoot, p));
     const read = async (p) => (has(p) ? readFile(path.join(appRoot, p), "utf8") : "");
-    const pkg = has("package.json") ? JSON.parse(await read("package.json")) : undefined;
+    const readJson = async (name) => {
+        try {
+            return JSON.parse(await read(name));
+        }
+        catch (e) {
+            throw new Error(`slicetest init: ${name} isn't valid JSON (${e.message}); fix it, or run init from the folder of the app`);
+        }
+    };
+    const pkg = has("package.json") ? (await readJson("package.json")) : undefined;
     const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
     const python = `${await read("requirements.txt")}\n${await read("pyproject.toml")}`.toLowerCase();
     const gemfile = await read("Gemfile");
-    const composer = has("composer.json") ? JSON.parse(await read("composer.json")) : undefined;
+    const composer = has("composer.json") ? (await readJson("composer.json")) : undefined;
     const php = { ...composer?.require, ...composer?.["require-dev"] };
     const laravel = !!php["laravel/framework"] && has("artisan");
     const symfony = !laravel && !!php["symfony/framework-bundle"] && has("bin/console");
@@ -609,6 +617,7 @@ export async function init(root, { force = false } = {}) {
     }
     const { config, notes } = await detect(root);
     const header = [
+        "# yaml-language-server: $schema=https://unpkg.com/slicetest/schema/config.schema.json",
         "# slicetest config, generated by `npx slicetest init`. Paths are relative to this file.",
         "# Everything the Vitest plugin accepts works here: https://github.com/revo1290/slicetest#configuration-reference",
         "#",

package/dist/list.d.ts

@@ -18,6 +18,7 @@ export declare function listScenarios(root: string, opts?: {
     filters?: string[];
     name?: string;
     tags?: string;
+    include?: string[];
 }): Promise<{
     scenarios: ListedScenario[];
     errors: string[];

package/dist/list.js

@@ -1,7 +1,13 @@
 import { readdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { tagsSelected } from "./scenario.js";
-import { parseScenarioFile } from "./yaml.js";
+import { parseScenarioFile, scenarioTitle } from "./yaml.js";
+function matchesGlob(file, glob) {
+    const match = path.matchesGlob;
+    if (!match)
+        throw new Error("slicetest list: the config's include needs Node.js 20.17 or later (path.matchesGlob)");
+    return match(file, glob.replace(/^\.\//, ""));
+}
 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 })) {
@@ -25,20 +31,27 @@ export async function listScenarios(root, opts = {}) {
     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.include && !opts.include.some((glob) => matchesGlob(rel, glob)))
+            continue;
         if (opts.filters?.length && !opts.filters.some((f) => rel.includes(f)))
             continue;
         try {
             const doc = parseScenarioFile(await readFile(file, "utf8"), rel);
+            // Vitest's `.only` runs only the focused tests of that file; one the tag filter leaves out is registered as skipped.
+            const focused = doc.scenarios.some((sc) => sc.only && !sc.skip && tagsSelected(sc.tags ?? [], opts.tags));
             for (const sc of doc.scenarios) {
                 const tags = sc.tags ?? [];
-                const selected = tagsSelected(tags, opts.tags) && (!pattern || pattern.test(sc.name));
+                // `-t` is matched against the title each row runs under (`vote {{c}}` → `vote a`).
+                const titles = sc.each ? sc.each.map((row, i) => scenarioTitle(sc.name, row, i)) : [sc.name];
+                const rows = pattern ? titles.filter((t) => pattern.test(t)).length : titles.length;
+                const selected = tagsSelected(tags, opts.tags) && rows > 0 && (!focused || !!sc.only);
                 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,
+                    rows: selected ? rows : titles.length,
                     steps: doc.setup.length + sc.steps.length,
                 });
             }

package/dist/mail.d.ts

@@ -47,7 +47,7 @@ export declare class Mailbox {
      * The first message matching `filter`, waiting up to `within` ms for the app
      * to send it. Fails with the messages that did arrive.
      */
-    waitFor(filter?: MailFilter, { within }?: {
+    waitFor(filter?: MailFilter, { within: wanted }?: {
         within?: number | undefined;
     }): Promise<Mail>;
     /** One line per message received this scenario, for failure output. */

package/dist/mail.js

@@ -1,3 +1,5 @@
+import { waitBudget } from "./deadline.js";
+import { decodeEntities } from "./form.js";
 import net from "node:net";
 export class Mailbox {
     server;
@@ -37,7 +39,8 @@ export class Mailbox {
      * The first message matching `filter`, waiting up to `within` ms for the app
      * to send it. Fails with the messages that did arrive.
      */
-    async waitFor(filter = {}, { within = 5000 } = {}) {
+    async waitFor(filter = {}, { within: wanted = 5000 } = {}) {
+        const { ms: within, note } = waitBudget(wanted);
         const deadline = Date.now() + within;
         for (;;) {
             const found = this.messages(filter)[0];
@@ -45,7 +48,7 @@ export class Mailbox {
                 return found;
             const left = deadline - Date.now();
             if (left <= 0)
-                throw new Error(`slicetest: no mail matching ${describeFilter(filter)} within ${within}ms\n${this.describe()}`);
+                throw new Error(`slicetest: no mail matching ${describeFilter(filter)} within ${within}ms${note}\n${this.describe()}`);
             await new Promise((resolve) => {
                 const done = () => {
                     clearTimeout(timer);
@@ -283,11 +286,8 @@ function htmlToText(html) {
         .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")
         .replace(/<br\s*\/?>|<\/p>/gi, "\n")
         .replace(/<[^>]+>/g, "")
-        .replace(/&amp;/g, "&")
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
+        // One pass: replacing `&amp;` first turned the text `&lt;` (sent as `&amp;lt;`) into `<`.
+        .replace(/&[^;\s]+;/g, (e) => decodeEntities(e))
         .trim();
 }
 function links(s) {

package/dist/matchers.d.ts

@@ -32,8 +32,8 @@ interface SlicetestMatchers<R = unknown> {
     toSetCookie(name: string, attributes?: Record<string, unknown>): R;
     /** The response arrived within `ms` milliseconds (measured from sending the request to reading the whole body). */
     toRespondWithin(ms: number): R;
-    /** An array of responses has exactly these status counts, e.g. `{ 201: 1, 409: 9 }`. */
-    toHaveStatuses(counts: Record<number, number>): R;
+    /** An array of responses has exactly these status counts, e.g. `{ 201: 1, 409: 9 }`; classes count the rest: `{ 201: 1, "4xx": 9 }`. */
+    toHaveStatuses(counts: Partial<Record<number | `${1 | 2 | 3 | 4 | 5}xx`, number>>): R;
     /** Async: the table has at least one row matching `where` (`count` for an exact number). */
     toHaveRow(table: string, where?: Where, count?: number): Promise<void>;
 }
@@ -44,5 +44,6 @@ declare module "vitest" {
 /** A status code, a class (`"2xx"`), or a list of either: `[200, 204]`, `["2xx", 304]`. */
 export type ExpectedStatus = number | string | (number | string)[];
 export declare function statusMatches(expected: ExpectedStatus, actual: number): boolean;
-export declare function statusCounts(responses: HttpResponse[]): Record<number, number>;
+/** Responses counted under their code when `keys` lists it, else under their class (`4xx`) when that is listed. */
+export declare function statusCounts(responses: HttpResponse[], keys?: string[]): Record<string, number>;
 export {};

package/dist/matchers.js

@@ -41,14 +41,20 @@ export function statusMatches(expected, actual) {
 function describeStatus(expected) {
     return Array.isArray(expected) ? `one of ${expected.join(", ")}` : String(expected);
 }
-export function statusCounts(responses) {
+/** Responses counted under their code when `keys` lists it, else under their class (`4xx`) when that is listed. */
+export function statusCounts(responses, keys = []) {
     const out = {};
-    for (const r of responses)
-        out[r.status] = (out[r.status] ?? 0) + 1;
+    for (const r of responses) {
+        const code = String(r.status);
+        const key = keys.includes(code) ? code : keys.includes(`${code[0]}xx`) ? `${code[0]}xx` : code;
+        out[key] = (out[key] ?? 0) + 1;
+    }
     return out;
 }
 function fmtCounts(c) {
-    return `{ ${Object.entries(c).map(([k, n]) => `${k}: ${n}`).join(", ")} }`;
+    // In status order, a class before its codes; object order would put every code before every class.
+    const rank = (k) => (/xx$/.test(k) ? Number(k[0]) * 100 - 0.5 : Number(k));
+    return `{ ${Object.entries(c).sort(([a], [b]) => rank(a) - rank(b)).map(([k, n]) => `${k}: ${n}`).join(", ")} }`;
 }
 /** One example response per status, which is usually what explains the odd one out. */
 function describeResponses(responses) {
@@ -210,8 +216,14 @@ expect.extend({
     toHaveStatuses(received, counts) {
         if (!Array.isArray(received))
             throw new TypeError("slicetest: toHaveStatuses expects an array of responses, e.g. from http.concurrently()");
-        const actual = statusCounts(received);
-        const expected = Object.fromEntries(Object.entries(counts).filter(([, n]) => n > 0).map(([k, n]) => [Number(k), n]));
+        const keys = Object.keys(counts).map((k) => {
+            const key = k.trim().toLowerCase();
+            if (!/^\d{3}$|^[1-5]xx$/.test(key))
+                throw new TypeError(`slicetest: a status is a code (201) or a class ("2xx"), got ${JSON.stringify(k)}`);
+            return key;
+        });
+        const actual = statusCounts(received, keys);
+        const expected = Object.fromEntries(Object.entries(counts).filter((entry) => (entry[1] ?? 0) > 0).map(([k, n]) => [k.trim().toLowerCase(), n]));
         const pass = this.equals(actual, expected);
         return {
             pass,

package/dist/openapi.d.ts

@@ -30,6 +30,8 @@ export interface Message {
     /** Parsed JSON when the body is JSON, else the raw text. */
     body: unknown;
     query?: URLSearchParams;
+    /** Header names in lower case, as Node delivers them; undefined skips the check for required header parameters. */
+    headers?: Record<string, string | string[] | undefined>;
 }
 export declare class OpenApiSpec {
     #private;