slicetest 0.2.0 → 0.4.0

package/dist/drivers/mysql.js

@@ -0,0 +1,270 @@
+import mysql from "mysql2/promise";
+/**
+ * Makes rows look like the Postgres driver's, so the same scenarios pass on
+ * both: BOOLEAN (`TINYINT(1)`) columns come back as booleans, BIGINT ids as
+ * numbers when they fit, DATETIME as UTC.
+ */
+const options = {
+    supportBigNumbers: true,
+    bigNumberStrings: false,
+    timezone: "Z",
+    multipleStatements: true,
+    typeCast(field, next) {
+        if (field.type === "TINY" && field.length === 1) {
+            const v = field.string();
+            return v === null ? null : v === "1";
+        }
+        return next();
+    },
+};
+async function connect(url) {
+    const conn = await mysql.createConnection({ uri: url, ...options });
+    // Without a listener, a dropped connection would crash the worker; the next query reports it instead.
+    conn.on("error", () => { });
+    return conn;
+}
+function rowsOf(result) {
+    return Array.isArray(result) ? result : [];
+}
+export class MysqlDriver {
+    conn;
+    #keys = new Map();
+    constructor(conn) {
+        this.conn = conn;
+    }
+    static async connect(url) {
+        return new MysqlDriver(await connect(url));
+    }
+    async query(sql, params = []) {
+        const [rows] = await this.conn.query(sql, params);
+        return rowsOf(rows);
+    }
+    async queryAll(sqls) {
+        if (sqls.length === 0)
+            return [];
+        // With multipleStatements, several SELECTs come back as one array of result sets.
+        const [results] = await this.conn.query(sqls.join(";\n"));
+        return sqls.length === 1 ? [rowsOf(results)] : results.map(rowsOf);
+    }
+    async exec(script) {
+        await this.conn.query(script);
+    }
+    ident(name) {
+        return name
+            .split(".")
+            .map((part) => this.column(part))
+            .join(".");
+    }
+    column(name) {
+        return `\`${name.replace(/`/g, "``")}\``;
+    }
+    param(_n) {
+        return "?";
+    }
+    inList(column, values, params) {
+        if (values.length === 0)
+            return "FALSE";
+        params.push(...values);
+        return `${this.ident(column)} IN (${values.map(() => "?").join(", ")})`;
+    }
+    /**
+     * Base tables in the configured schemas. In MySQL a schema is a database;
+     * `public` (the default) stands for the database the URL points at.
+     */
+    async listTables(schemas, keep) {
+        const [{ current }] = (await this.query("SELECT DATABASE() AS current"));
+        const names = schemas.map((s) => (s === "public" ? current : s));
+        const rows = await this.query(`SELECT t.TABLE_SCHEMA AS \`schema\`, t.TABLE_NAME AS name,
+              (SELECT GROUP_CONCAT(k.COLUMN_NAME ORDER BY k.ORDINAL_POSITION SEPARATOR '\\n')
+                 FROM information_schema.KEY_COLUMN_USAGE k
+                WHERE k.TABLE_SCHEMA = t.TABLE_SCHEMA AND k.TABLE_NAME = t.TABLE_NAME AND k.CONSTRAINT_NAME = 'PRIMARY') AS \`key\`
+         FROM information_schema.TABLES t
+        WHERE t.TABLE_TYPE = 'BASE TABLE' AND t.TABLE_SCHEMA IN (?)
+        ORDER BY 1, 2`, [names]);
+        return rows
+            .map((r) => ({
+            name: r.schema === current ? r.name : `${r.schema}.${r.name}`,
+            quoted: `${this.ident(r.schema)}.${this.ident(r.name)}`,
+            key: r.key ? r.key.split("\n") : [],
+            bare: r.name,
+        }))
+            .filter((t) => !keep.includes(t.bare) && !keep.includes(t.name))
+            .map(({ bare: _, ...t }) => t);
+    }
+    /**
+     * TRUNCATE also restarts AUTO_INCREMENT, but it is DDL and costs a few
+     * milliseconds per table, so only tables that have rows or a used counter are
+     * truncated. Foreign key checks are off for this session only.
+     */
+    async truncate(tables) {
+        if (tables.length === 0)
+            return;
+        const [, , counters, ...filled] = await this.queryAll([
+            // Otherwise information_schema serves AUTO_INCREMENT from a cache that can be a day old.
+            "SET SESSION information_schema_stats_expiry = 0",
+            "SELECT 1",
+            `SELECT CONCAT(TABLE_SCHEMA, '.', TABLE_NAME) AS t, AUTO_INCREMENT AS n FROM information_schema.TABLES WHERE AUTO_INCREMENT > 1`,
+            ...tables.map((t) => `SELECT 1 AS x FROM ${t.quoted} LIMIT 1`),
+        ]);
+        const used = new Set(counters.map((r) => this.ident(String(r.t))));
+        const dirty = tables.filter((t, i) => filled[i].length > 0 || used.has(t.quoted));
+        if (dirty.length === 0)
+            return;
+        await this.conn.query(`SET FOREIGN_KEY_CHECKS = 0; ${dirty.map((t) => `TRUNCATE TABLE ${t.quoted}`).join("; ")}; SET FOREIGN_KEY_CHECKS = 1`);
+    }
+    /** MySQL has no RETURNING: insert, then read the row back by its primary key. */
+    async insert(table, row) {
+        const cols = Object.keys(row);
+        const sql = cols.length === 0
+            ? `INSERT INTO ${this.ident(table)} () VALUES ()`
+            : `INSERT INTO ${this.ident(table)} (${cols.map((c) => this.column(c)).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
+        const [res] = (await this.conn.query(sql, Object.values(row)));
+        const key = await this.#primaryKey(table);
+        const where = {};
+        for (const k of key) {
+            if (k in row)
+                where[k] = row[k];
+            else if (key.length === 1 && res.insertId)
+                where[k] = res.insertId;
+            else
+                return [row];
+        }
+        if (key.length === 0)
+            return [row];
+        const conds = Object.keys(where).map((k) => `${this.column(k)} = ?`);
+        return this.query(`SELECT * FROM ${this.ident(table)} WHERE ${conds.join(" AND ")}`, Object.values(where));
+    }
+    async #primaryKey(table) {
+        let key = this.#keys.get(table);
+        if (!key) {
+            const [schema, name] = table.includes(".") ? table.split(".", 2) : [null, table];
+            const rows = await this.query(`SELECT COLUMN_NAME AS c FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = COALESCE(?, DATABASE()) AND TABLE_NAME = ? AND CONSTRAINT_NAME = 'PRIMARY'
+          ORDER BY ORDINAL_POSITION`, [schema, name]);
+            key = rows.map((r) => r.c);
+            this.#keys.set(table, key);
+        }
+        return key;
+    }
+    async close() {
+        await this.conn.end();
+    }
+}
+function withDatabase(url, database) {
+    const u = new URL(url);
+    u.pathname = `/${database}`;
+    return u.toString();
+}
+function quote(name) {
+    return `\`${name.replace(/`/g, "``")}\``;
+}
+class MysqlAdmin {
+    conn;
+    url;
+    constructor(conn, url) {
+        this.conn = conn;
+        this.url = url;
+    }
+    async databases(prefix) {
+        const [rows] = await this.conn.query("SELECT SCHEMA_NAME AS name FROM information_schema.SCHEMATA");
+        return rowsOf(rows)
+            .map((r) => String(r.name))
+            .filter((n) => n.startsWith(prefix));
+    }
+    async create(name) {
+        await this.conn.query(`CREATE DATABASE ${quote(name)}`);
+    }
+    /**
+     * MySQL has no template databases: recreate each table from `SHOW CREATE
+     * TABLE` (foreign keys included) and copy its rows, then views and triggers.
+     * Stored routines and events are not copied.
+     */
+    async clone(template, name) {
+        await this.create(name);
+        const target = await connect(withDatabase(this.url, name));
+        try {
+            await target.query("SET FOREIGN_KEY_CHECKS = 0");
+            const [tables] = await this.conn.query("SELECT TABLE_NAME AS name, TABLE_TYPE AS type FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME", [template]);
+            const list = rowsOf(tables);
+            for (const t of list.filter((t) => t.type === "BASE TABLE")) {
+                const [[create]] = (await this.conn.query(`SHOW CREATE TABLE ${quote(template)}.${quote(t.name)}`));
+                await target.query(String(create["Create Table"]));
+                const [cols] = await this.conn.query("SELECT COLUMN_NAME AS c FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND EXTRA NOT LIKE '%GENERATED%' ORDER BY ORDINAL_POSITION", [template, t.name]);
+                const names = rowsOf(cols).map((c) => quote(String(c.c))).join(", ");
+                await target.query(`INSERT INTO ${quote(t.name)} (${names}) SELECT ${names} FROM ${quote(template)}.${quote(t.name)}`);
+            }
+            // Views may depend on each other; retry the ones that fail until no progress is made.
+            let views = list.filter((t) => t.type === "VIEW");
+            while (views.length > 0) {
+                const failed = [];
+                let lastError;
+                for (const v of views) {
+                    const [[create]] = (await this.conn.query(`SHOW CREATE VIEW ${quote(template)}.${quote(v.name)}`));
+                    const sql = String(create["Create View"]).split(`${quote(template)}.`).join("");
+                    await target.query(sql).catch((e) => {
+                        failed.push(v);
+                        lastError = e;
+                    });
+                }
+                if (failed.length === views.length)
+                    throw lastError;
+                views = failed;
+            }
+            const [triggers] = await this.conn.query(`SHOW TRIGGERS FROM ${quote(template)}`);
+            for (const trg of rowsOf(triggers)) {
+                const [[create]] = (await this.conn.query(`SHOW CREATE TRIGGER ${quote(template)}.${quote(String(trg.Trigger))}`));
+                await target.query(String(create["SQL Original Statement"]));
+            }
+        }
+        catch (e) {
+            await this.drop(name).catch(() => { });
+            throw e;
+        }
+        finally {
+            await target.end().catch(() => { });
+        }
+    }
+    /** DROP DATABASE waits for open transactions, so disconnect everyone using it first. */
+    async drop(name) {
+        const [rows] = await this.conn.query("SELECT ID AS id FROM information_schema.PROCESSLIST WHERE DB = ? AND ID <> CONNECTION_ID()", [name]);
+        for (const r of rowsOf(rows))
+            await this.conn.query(`KILL ${Number(r.id)}`).catch(() => { });
+        await this.conn.query(`DROP DATABASE IF EXISTS ${quote(name)}`);
+    }
+    async withLock(key, fn) {
+        const lock = key.slice(0, 64);
+        await this.conn.query("SELECT GET_LOCK(?, -1)", [lock]);
+        try {
+            return await fn();
+        }
+        finally {
+            await this.conn.query("SELECT RELEASE_LOCK(?)", [lock]);
+        }
+    }
+    urlFor(name) {
+        return withDatabase(this.url, name);
+    }
+    async close() {
+        await this.conn.end();
+    }
+}
+export const mysqlEngine = {
+    name: "mysql",
+    defaultImage: "mysql:8.4",
+    async startContainer(image, reuse) {
+        const { MySqlContainer } = await import("@testcontainers/mysql").catch(() => {
+            throw new Error("slicetest: starting a MySQL container needs the @testcontainers/mysql package: npm i -D @testcontainers/mysql (or set db.url)");
+        });
+        const definition = new MySqlContainer(image);
+        if (reuse)
+            definition.withReuse();
+        const container = await definition.start();
+        // Root, because slicetest creates and drops databases.
+        return { url: container.getConnectionUri(true), stop: () => container.stop() };
+    },
+    async admin(url) {
+        return new MysqlAdmin(await connect(url), url);
+    },
+    driver: (url) => MysqlDriver.connect(url),
+    atlasUrl: (url) => url,
+};

package/dist/drivers/sqlite.d.ts

@@ -0,0 +1,23 @@
+import type { Driver, Engine, Row, Table } from "./driver.js";
+/** `sqlite:///tmp/a.db` → `/tmp/a.db`; `sqlite:///C:/x/a.db` → `C:/x/a.db`. Plain paths pass through. */
+export declare function sqlitePath(url: string): string;
+export declare function sqliteUrl(file: string): string;
+export declare class SqliteDriver implements Driver {
+    private readonly db;
+    private constructor();
+    static connect(url: string): Promise<SqliteDriver>;
+    query<T extends Row = Row>(sql: string, params?: unknown[]): Promise<T[]>;
+    queryAll(sqls: string[]): Promise<Row[][]>;
+    exec(script: string): Promise<void>;
+    ident(name: string): string;
+    column(name: string): string;
+    param(n: number): string;
+    inList(column: string, values: unknown[], params: unknown[]): string;
+    /** SQLite has one schema per file (`main`), so `schemas` doesn't apply. */
+    listTables(_schemas: string[], keep: string[]): Promise<Table[]>;
+    /** DELETE, then forget AUTOINCREMENT counters. Foreign keys are off for this connection only. */
+    truncate(tables: Table[]): Promise<void>;
+    insert(table: string, row: Row): Promise<Row[]>;
+    close(): Promise<void>;
+}
+export declare const sqliteEngine: Engine;

package/dist/drivers/sqlite.js

@@ -0,0 +1,203 @@
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, open, readdir, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+let loaded;
+/** `node:sqlite` warns that it's experimental on every import; that's noise in test output. */
+function load() {
+    return (loaded ??= (async () => {
+        const emit = process.emitWarning;
+        process.emitWarning = ((warning, ...rest) => {
+            if (String(typeof warning === "string" ? warning : warning.message).includes("SQLite"))
+                return;
+            emit.call(process, warning, ...rest);
+        });
+        try {
+            return await import("node:sqlite");
+        }
+        catch {
+            throw new Error(`slicetest: db.engine "sqlite" needs Node.js 22.5 or later (node:sqlite); this is ${process.versions.node}`);
+        }
+        finally {
+            process.emitWarning = emit;
+        }
+    })());
+}
+/** `sqlite:///tmp/a.db` → `/tmp/a.db`; `sqlite:///C:/x/a.db` → `C:/x/a.db`. Plain paths pass through. */
+export function sqlitePath(url) {
+    if (!url.startsWith("sqlite:"))
+        return url;
+    const p = decodeURIComponent(url.replace(/^sqlite:(\/\/)?/, "").replace(/[?#].*$/, ""));
+    return /^\/[a-zA-Z]:[\\/]/.test(p) ? p.slice(1) : p;
+}
+export function sqliteUrl(file) {
+    const p = path.resolve(file).replace(/\\/g, "/");
+    return `sqlite://${p.startsWith("/") ? "" : "/"}${p}`;
+}
+/** Values node:sqlite can't bind are stored the way an app would store them. */
+function bind(v) {
+    if (typeof v === "boolean")
+        return v ? 1 : 0;
+    if (v instanceof Date)
+        return v.toISOString();
+    if (v !== null && typeof v === "object" && !(v instanceof Uint8Array))
+        return JSON.stringify(v);
+    return v === undefined ? null : v;
+}
+async function openDb(file) {
+    const { DatabaseSync } = await load();
+    const db = new DatabaseSync(file);
+    // The app may be writing; wait for its lock instead of failing with SQLITE_BUSY.
+    db.exec("PRAGMA busy_timeout = 5000");
+    return db;
+}
+export class SqliteDriver {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async connect(url) {
+        return new SqliteDriver(await openDb(sqlitePath(url)));
+    }
+    async query(sql, params = []) {
+        const stmt = this.db.prepare(sql);
+        const values = params.map(bind);
+        // Rows come with a null prototype; plain objects compare and print as expected.
+        return stmt.columns().length === 0 ? (stmt.run(...values), []) : stmt.all(...values).map((r) => ({ ...r }));
+    }
+    async queryAll(sqls) {
+        return Promise.all(sqls.map((s) => this.query(s)));
+    }
+    async exec(script) {
+        this.db.exec(script);
+    }
+    ident(name) {
+        return name
+            .split(".")
+            .map((part) => this.column(part))
+            .join(".");
+    }
+    column(name) {
+        return `"${name.replace(/"/g, '""')}"`;
+    }
+    param(n) {
+        return `?${n}`;
+    }
+    inList(column, values, params) {
+        if (values.length === 0)
+            return "0";
+        const start = params.length;
+        params.push(...values);
+        return `${this.ident(column)} IN (${values.map((_, i) => `?${start + i + 1}`).join(", ")})`;
+    }
+    /** SQLite has one schema per file (`main`), so `schemas` doesn't apply. */
+    async listTables(_schemas, keep) {
+        const rows = await this.query(`SELECT m.name AS name,
+              (SELECT group_concat(name, char(10)) FROM (SELECT name FROM pragma_table_info(m.name) WHERE pk > 0 ORDER BY pk)) AS key
+         FROM sqlite_master m
+        WHERE m.type = 'table' AND m.name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+        ORDER BY 1`);
+        return rows
+            .filter((r) => !keep.includes(r.name) && !keep.includes(`main.${r.name}`))
+            .map((r) => ({ name: r.name, quoted: this.ident(r.name), key: r.key ? r.key.split("\n") : [] }));
+    }
+    /** DELETE, then forget AUTOINCREMENT counters. Foreign keys are off for this connection only. */
+    async truncate(tables) {
+        if (tables.length === 0)
+            return;
+        const sequence = (await this.query("SELECT 1 FROM sqlite_master WHERE name = 'sqlite_sequence'")).length > 0;
+        const names = tables.map((t) => `'${t.name.replace(/'/g, "''")}'`).join(", ");
+        this.db.exec(`PRAGMA foreign_keys = OFF; BEGIN IMMEDIATE; ${tables.map((t) => `DELETE FROM ${t.quoted};`).join(" ")}` +
+            `${sequence ? ` DELETE FROM sqlite_sequence WHERE name IN (${names});` : ""} COMMIT; PRAGMA foreign_keys = ON;`);
+    }
+    async insert(table, row) {
+        const cols = Object.keys(row);
+        const sql = cols.length === 0
+            ? `INSERT INTO ${this.ident(table)} DEFAULT VALUES RETURNING *`
+            : `INSERT INTO ${this.ident(table)} (${cols.map((c) => this.column(c)).join(", ")}) VALUES (${cols.map((_, i) => `?${i + 1}`).join(", ")}) RETURNING *`;
+        return this.query(sql, Object.values(row));
+    }
+    async close() {
+        this.db.close();
+    }
+}
+class SqliteAdmin {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    #file(name) {
+        return path.join(this.dir, `${name}.db`);
+    }
+    async databases(prefix) {
+        return (await readdir(this.dir)).filter((f) => f.endsWith(".db") && f.startsWith(prefix)).map((f) => f.slice(0, -3));
+    }
+    async create(name) {
+        const db = await openDb(this.#file(name));
+        // Persisted in the file: the app and slicetest can then read and write at the same time.
+        db.exec("PRAGMA journal_mode = WAL");
+        db.close();
+    }
+    async clone(template, name) {
+        const db = await openDb(this.#file(template));
+        try {
+            db.prepare("VACUUM INTO ?").run(this.#file(name));
+        }
+        finally {
+            db.close();
+        }
+        const copy = await openDb(this.#file(name));
+        copy.exec("PRAGMA journal_mode = WAL");
+        copy.close();
+    }
+    async drop(name) {
+        for (const suffix of ["", "-wal", "-shm", "-journal"])
+            await rm(this.#file(name) + suffix, { force: true });
+    }
+    /** A lock file, for runs sharing the directory (with `reuse`). */
+    async withLock(key, fn) {
+        const lock = path.join(this.dir, `${key}.lock`);
+        const deadline = Date.now() + 120_000;
+        for (;;) {
+            try {
+                await (await open(lock, "wx")).close();
+                break;
+            }
+            catch (e) {
+                if (e.code !== "EEXIST" || Date.now() > deadline)
+                    throw e;
+                await new Promise((r) => setTimeout(r, 100));
+            }
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            await rm(lock, { force: true });
+        }
+    }
+    urlFor(name) {
+        return sqliteUrl(this.#file(name));
+    }
+    async close() { }
+}
+export const sqliteEngine = {
+    name: "sqlite",
+    defaultImage: "",
+    local: true,
+    /** No container: a directory of database files, kept between runs with `reuse`. */
+    async startContainer(_image, reuse) {
+        await load();
+        const dir = reuse ? path.join(os.tmpdir(), "slicetest-sqlite") : await mkdtemp(path.join(os.tmpdir(), "slicetest-sqlite-"));
+        await mkdir(dir, { recursive: true });
+        return { url: sqliteUrl(dir), stop: () => rm(dir, { recursive: true, force: true }) };
+    },
+    async admin(url) {
+        const dir = sqlitePath(url);
+        if (!existsSync(dir))
+            await mkdir(dir, { recursive: true });
+        return new SqliteAdmin(dir);
+    },
+    driver: (url) => SqliteDriver.connect(url),
+    atlasUrl: (url) => `sqlite://${sqlitePath(url)}`,
+};

package/dist/gen.d.ts

@@ -0,0 +1,24 @@
+/** Where the last run's OpenAPI coverage is kept for `slicetest gen --uncovered`. */
+export declare function coverageCacheFile(root: string): string;
+export interface GenOptions {
+    /** The app's spec, relative to `root`. */
+    spec: string;
+    /** Directory for the scenario files, relative to `root`. Default `scenarios`. */
+    out?: string;
+    /** Only responses the last run didn't produce. */
+    uncovered?: boolean;
+    force?: boolean;
+}
+/**
+ * Scenario skeletons for the documented responses of an OpenAPI spec, one
+ * `<resource>.gen.scenario.yaml` per first path segment. A 2xx response gets a
+ * runnable scenario, with a request built from the spec and, when the path
+ * needs an id, a step that creates the resource first through the collection's
+ * POST. Other responses become skipped scenarios: a to-do list of the states
+ * the tests still have to arrange.
+ */
+export declare function gen(root: string, opts: GenOptions): Promise<{
+    written: string[];
+    skipped: string[];
+    count: number;
+}>;

package/dist/gen.js

@@ -0,0 +1,116 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stringify } from "yaml";
+import { OpenApiSpec } from "./openapi.js";
+/** Where the last run's OpenAPI coverage is kept for `slicetest gen --uncovered`. */
+export function coverageCacheFile(root) {
+    return path.join(root, "node_modules", ".cache", "slicetest", "openapi-coverage.json");
+}
+/**
+ * Scenario skeletons for the documented responses of an OpenAPI spec, one
+ * `<resource>.gen.scenario.yaml` per first path segment. A 2xx response gets a
+ * runnable scenario, with a request built from the spec and, when the path
+ * needs an id, a step that creates the resource first through the collection's
+ * POST. Other responses become skipped scenarios: a to-do list of the states
+ * the tests still have to arrange.
+ */
+export async function gen(root, opts) {
+    const spec = await OpenApiSpec.load(path.resolve(root, opts.spec), opts.spec);
+    const ops = spec.operations();
+    let covered = new Set();
+    if (opts.uncovered) {
+        const cache = coverageCacheFile(root);
+        if (!existsSync(cache))
+            throw new Error("slicetest: no coverage from a previous run yet. Run the scenarios once (with `openapi` set), then `slicetest gen --uncovered`.");
+        covered = new Set(JSON.parse(await readFile(cache, "utf8")));
+    }
+    const files = new Map();
+    let count = 0;
+    for (const op of ops) {
+        for (const key of op.responses) {
+            if (covered.has(`${op.method} ${op.template} ${key}`))
+                continue;
+            const resource = op.template.split("/").find((s) => s && !s.startsWith("{")) ?? "root";
+            const list = files.get(resource) ?? [];
+            list.push(scenarioFor(op, key, ops));
+            files.set(resource, list);
+            count++;
+        }
+    }
+    const dir = path.resolve(root, opts.out ?? "scenarios");
+    const written = [];
+    const skipped = [];
+    for (const [resource, scenarios] of files) {
+        const file = path.join(dir, `${resource}.gen.scenario.yaml`);
+        const rel = path.relative(root, file);
+        if (existsSync(file) && !opts.force) {
+            skipped.push(rel);
+            continue;
+        }
+        const header = [
+            "# yaml-language-server: $schema=https://unpkg.com/slicetest/schema/scenario.schema.json",
+            `# Generated by \`slicetest gen\` from ${opts.spec}${opts.uncovered ? " (responses the last run didn't cover)" : ""}.`,
+            "# Requests are built from the spec's examples and schemas: adjust them to your data, then drop the `skip`s one by one.",
+            "",
+        ].join("\n");
+        await mkdir(dir, { recursive: true });
+        await writeFile(file, header + stringify({ scenarios }, { lineWidth: 0, aliasDuplicateObjects: false }));
+        written.push(rel);
+    }
+    return { written, skipped, count };
+}
+function scenarioFor(op, key, all) {
+    const steps = [];
+    let pathText = op.template;
+    const success = /^2/.test(key);
+    let unresolved = false;
+    for (const [name, sample] of Object.entries(op.pathParams)) {
+        const creator = success ? creatorFor(op, name, all) : undefined;
+        if (creator) {
+            steps.push(requestStep(creator.op, creator.op.template, { status: Number(creator.status) }, { [name]: `json.${creator.field}` }));
+            pathText = pathText.replace(`{${name}}`, `{{${name}}}`);
+        }
+        else {
+            pathText = pathText.replace(`{${name}}`, encodeURIComponent(String(sample ?? 1)));
+            unresolved = true;
+        }
+    }
+    const status = /^\d{3}$/.test(key) ? Number(key) : undefined;
+    // Two error responses need no arranging: a made-up id is not found, and an empty body is invalid.
+    const notFound = status === 404 && Object.keys(op.pathParams).length > 0;
+    const invalid = (status === 400 || status === 422) && isFilledObject(op.json);
+    steps.push(requestStep(invalid ? { ...op, json: {} } : op, pathText, { status }));
+    const name = `${op.method} ${op.template} → ${key}${op.summary ? ` (${op.summary})` : ""}`;
+    const runnable = success ? !unresolved : notFound || invalid;
+    return runnable ? { name, steps } : { name: `${name} — TODO: arrange the state that produces this`, skip: true, steps };
+}
+/**
+ * The POST on the collection above `template` whose success response carries
+ * the value for `param`: `{id}` in `/polls/{id}/votes` comes from `POST /polls`'s `id`.
+ */
+function creatorFor(op, param, all) {
+    const i = op.template.indexOf(`{${param}}`);
+    const collection = op.template.slice(0, i).replace(/\/$/, "");
+    const post = all.find((o) => o.method === "POST" && o.template === collection);
+    if (!post)
+        return undefined;
+    const field = [param, "id"].find((f) => post.createdFields.includes(f));
+    const status = post.responses.filter((k) => /^2\d\d$/.test(k)).sort()[0];
+    return field && status ? { op: post, field, status } : undefined;
+}
+function requestStep(op, pathText, expect, capture) {
+    const step = { request: `${op.method} ${pathText}` };
+    if (Object.keys(op.query).length)
+        step.query = Object.fromEntries(Object.entries(op.query).map(([k, v]) => [k, String(v)]));
+    if (op.json !== undefined)
+        step.json = op.json;
+    if (expect.status)
+        step.expect = { status: expect.status };
+    if (capture)
+        step.capture = capture;
+    return step;
+}
+function isFilledObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0;
+}