slicetest 0.1.0 → 0.2.0

package/dist/openapi.js

@@ -0,0 +1,305 @@
+import { readFile } from "node:fs/promises";
+import { Ajv } from "ajv";
+import { Ajv2020 } from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
+import { parse } from "yaml";
+const addFormats = (addFormatsModule.default ?? addFormatsModule);
+const METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+/**
+ * An OpenAPI 3.0 / 3.1 document, used to check that real traffic matches it:
+ * the app's responses against the app's own spec, and the app's calls to a
+ * stubbed service (and the stub's canned replies) against that service's spec.
+ */
+export class OpenApiSpec {
+    file;
+    doc;
+    #ajv;
+    #validators = new Map();
+    #ops = [];
+    #basePaths;
+    #documentOrder = [];
+    constructor(file, doc) {
+        this.file = file;
+        this.doc = doc;
+        const v31 = String(doc.openapi ?? "").startsWith("3.1");
+        this.#ajv = v31 ? new Ajv2020({ strict: false, allErrors: true }) : new Ajv({ strict: false, allErrors: true });
+        addFormats(this.#ajv);
+        for (const f of ["int32", "int64", "float", "double", "byte", "binary", "password"])
+            this.#ajv.addFormat(f, true);
+        this.#ajv.addSchema(v31 ? doc : nullableToType(structuredClone(doc)), "spec");
+        for (const [template, item] of Object.entries(doc.paths ?? {})) {
+            for (const method of METHODS)
+                if (item[method])
+                    this.#documentOrder.push({ template, method, op: item[method] });
+        }
+        // Concrete segments before templated ones, so /polls/new wins over /polls/{id}.
+        const templates = Object.keys(doc.paths ?? {}).sort((a, b) => a.split("{").length - b.split("{").length);
+        for (const template of templates) {
+            const re = new RegExp(`^${template.split(/\{[^}]+\}/).map(escape).join("[^/]+")}/?$`);
+            for (const method of METHODS) {
+                const op = doc.paths[template][method];
+                if (op)
+                    this.#ops.push({ re, op: { template, method, op } });
+            }
+        }
+        // Paths in the spec are relative to the server URL, e.g. /v1 for https://api.example.com/v1.
+        this.#basePaths = [
+            ...new Set((doc.servers ?? [])
+                .map((s) => new URL(s.url ?? "/", "http://x").pathname.replace(/\/$/, ""))
+                .filter(Boolean)),
+        ];
+    }
+    /** `file` is read; `label` (default: `file`) is how messages refer to it. */
+    static async load(file, label = file) {
+        let doc;
+        try {
+            doc = parse(await readFile(file, "utf8"));
+        }
+        catch (e) {
+            throw new Error(`slicetest: can't read OpenAPI spec ${label}: ${e.message}`);
+        }
+        if (!doc || typeof doc !== "object" || !("openapi" in doc)) {
+            throw new Error(`slicetest: ${label} is not an OpenAPI 3 document (no "openapi" field)`);
+        }
+        return new OpenApiSpec(label, doc);
+    }
+    find(method, path) {
+        const m = method.toLowerCase();
+        for (const candidate of [path, ...this.#basePaths.filter((b) => path.startsWith(b)).map((b) => path.slice(b.length) || "/")]) {
+            const hit = this.#ops.find((o) => o.op.method === m && o.re.test(candidate));
+            if (hit)
+                return hit.op;
+        }
+        return undefined;
+    }
+    /** Problems with a response to `method path`; empty when it matches the spec. */
+    /** The documented response (`200`, `4XX`, `default`) that `status` falls under, for coverage. */
+    responseKey(method, path, status) {
+        const found = this.find(method, path);
+        if (!found)
+            return undefined;
+        const key = pickResponse(found.op.responses ?? {}, status);
+        return key && `${method.toUpperCase()} ${found.template} ${key}`;
+    }
+    /** Every documented response as `METHOD /template key`, in document order. */
+    responseKeys() {
+        return this.#documentOrder.flatMap(({ template, method, op }) => Object.keys(op.responses ?? {}).map((key) => `${method.toUpperCase()} ${template} ${key}`));
+    }
+    checkResponse(method, path, res) {
+        const found = this.find(method, path);
+        if (!found)
+            return [`${method} ${path} is not in ${this.file}`];
+        const { template, op } = found;
+        const status = String(res.status);
+        const responses = op.responses ?? {};
+        const key = pickResponse(responses, res.status ?? 0);
+        if (!key)
+            return [`${method} ${template} responded ${status}, which ${this.file} doesn't document (documented: ${Object.keys(responses).join(", ") || "none"})`];
+        const [response, at] = this.#resolve(responses[key], ["paths", template, found.method, "responses", key]);
+        return this.#checkContent(response?.content, res, [...at, "content"], `${method} ${template} → ${status}`);
+    }
+    /**
+     * A response the real service could send to `method path`: the lowest
+     * documented 2xx, with its example if the spec has one, else a value built
+     * from its schema. Undefined when the operation isn't in the spec.
+     */
+    exampleResponse(method, path) {
+        const found = this.find(method, path);
+        if (!found)
+            return undefined;
+        const responses = found.op.responses ?? {};
+        const key = Object.keys(responses)
+            .filter((k) => /^2\d\d$/.test(k))
+            .sort()[0] ?? Object.keys(responses).find((k) => /^2xx$/i.test(k));
+        if (!key)
+            return undefined;
+        const status = key.length === 3 && /^\d+$/.test(key) ? Number(key) : 200;
+        const response = this.#deref(responses[key]);
+        const content = response?.content ?? {};
+        const media = Object.keys(content).find(isJson) ?? Object.keys(content)[0];
+        if (!media)
+            return { status };
+        const m = content[media] ?? {};
+        const named = m.examples && Object.values(m.examples)[0];
+        const body = m.example !== undefined
+            ? m.example
+            : named !== undefined
+                ? (this.#deref(named)?.value ?? null)
+                : this.#sample(m.schema);
+        return { status, headers: { "content-type": media === "*/*" ? "application/json" : media }, body: isJson(media) ? body : String(body ?? "") };
+    }
+    /** A value that satisfies `schema` (as far as a simple walk can): examples, defaults, enums, then types. */
+    #sample(schema, depth = 0) {
+        const s = this.#deref(schema);
+        if (!s || typeof s !== "object" || depth > 8)
+            return null;
+        if (s.example !== undefined)
+            return s.example;
+        if (Array.isArray(s.examples) && s.examples.length)
+            return s.examples[0];
+        if (s.default !== undefined)
+            return s.default;
+        if (s.const !== undefined)
+            return s.const;
+        if (Array.isArray(s.enum) && s.enum.length)
+            return s.enum[0];
+        if (Array.isArray(s.allOf)) {
+            return Object.assign({}, ...s.allOf.map((part) => this.#sample(part, depth + 1)).filter((v) => v && typeof v === "object"));
+        }
+        const first = s.oneOf?.[0] ?? s.anyOf?.[0];
+        if (first)
+            return this.#sample(first, depth + 1);
+        const type = Array.isArray(s.type) ? s.type.find((t) => t !== "null") : s.type;
+        switch (type ?? (s.properties ? "object" : s.items ? "array" : undefined)) {
+            case "object":
+                return Object.fromEntries(Object.entries(s.properties ?? {}).map(([k, v]) => [k, this.#sample(v, depth + 1)]));
+            case "array":
+                return Array.from({ length: Math.max(1, s.minItems ?? 1) }, () => this.#sample(s.items, depth + 1));
+            case "integer":
+            case "number":
+                return typeof s.minimum === "number" ? s.minimum : typeof s.exclusiveMinimum === "number" ? s.exclusiveMinimum + 1 : 0;
+            case "boolean":
+                return true;
+            case "string":
+                return sampleString(s);
+            default:
+                return null;
+        }
+    }
+    /** Problems with a request the app sent to `method path`. */
+    checkRequest(method, path, req) {
+        const found = this.find(method, path);
+        if (!found)
+            return [`${method} ${path} is not in ${this.file}`];
+        const { template, op } = found;
+        const errors = [];
+        const params = [...(this.doc.paths[template].parameters ?? []), ...(op.parameters ?? [])].map((p) => this.#deref(p));
+        for (const p of params) {
+            if (p?.in === "query" && p.required && !req.query?.has(p.name))
+                errors.push(`${method} ${template}: required query parameter "${p.name}" is missing`);
+        }
+        const [body, at] = this.#resolve(op.requestBody, ["paths", template, found.method, "requestBody"]);
+        if (!body)
+            return errors;
+        if (req.body === "" || req.body === undefined) {
+            if (body.required)
+                errors.push(`${method} ${template}: the request body is required`);
+            return errors;
+        }
+        return [...errors, ...this.#checkContent(body.content, req, [...at, "content"], `${method} ${template} request`)];
+    }
+    #checkContent(content, msg, pointer, label) {
+        if (!content || Object.keys(content).length === 0)
+            return [];
+        const type = (msg.contentType ?? "").split(";")[0].trim().toLowerCase();
+        // Without a content-type (e.g. a stub replying with a bare string) there's nothing to hold the body to.
+        if (!type)
+            return [];
+        const media = Object.keys(content).find((k) => k.toLowerCase() === type) ??
+            Object.keys(content).find((k) => k.endsWith("/*") && type.startsWith(k.slice(0, -1))) ??
+            Object.keys(content).find((k) => k === "*/*");
+        if (!media)
+            return [`${label}: content-type "${type || "(none)"}" is not one of ${Object.keys(content).join(", ")}`];
+        if (!content[media]?.schema || !isJson(media))
+            return [];
+        if (typeof msg.body === "string")
+            return [`${label}: body is not valid JSON`];
+        const validate = this.#validator([...pointer, media, "schema"]);
+        if (validate(msg.body))
+            return [];
+        return (validate.errors ?? []).slice(0, 5).map((e) => `${label}: ${e.instancePath || "body"} ${e.message}${e.params && "additionalProperty" in e.params ? ` "${e.params.additionalProperty}"` : ""}`);
+    }
+    #validator(pointer) {
+        const ref = `spec#/${pointer.map((p) => p.replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
+        let v = this.#validators.get(ref);
+        if (!v) {
+            v = this.#ajv.compile({ $ref: ref });
+            this.#validators.set(ref, v);
+        }
+        return v;
+    }
+    /** Follow a local `$ref` such as `#/components/responses/NotFound`. */
+    #deref(node) {
+        return this.#resolve(node, [])[0];
+    }
+    /** The node behind any `$ref`s, and its location in the document (for compiling schemas under it). */
+    #resolve(node, at, depth = 0) {
+        if (!node || typeof node.$ref !== "string" || !node.$ref.startsWith("#/") || depth > 10)
+            return [node, at];
+        const pointer = node.$ref
+            .slice(2)
+            .split("/")
+            .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+        const target = pointer.reduce((cur, key) => cur?.[key], this.doc);
+        return this.#resolve(target, pointer, depth + 1);
+    }
+}
+const FORMATS = {
+    "date-time": "2026-01-01T00:00:00Z",
+    date: "2026-01-01",
+    time: "00:00:00Z",
+    email: "user@example.com",
+    uri: "https://example.com",
+    url: "https://example.com",
+    uuid: "00000000-0000-4000-8000-000000000000",
+    hostname: "example.com",
+    ipv4: "192.0.2.1",
+    ipv6: "2001:db8::1",
+};
+function sampleString(s) {
+    const base = (s.format && FORMATS[s.format]) ?? "string";
+    return base.length >= (s.minLength ?? 0) ? base : base.padEnd(s.minLength, "x");
+}
+function pickResponse(responses, status) {
+    const s = String(status);
+    return [s, `${s[0]}XX`, `${s[0]}xx`, "default"].find((k) => k in responses);
+}
+/**
+ * Coverage report: which documented responses the scenarios produced.
+ * `hits` are `responseKey()` values collected from every worker.
+ */
+export function formatCoverage(spec, hits) {
+    const keys = spec.responseKeys();
+    const byOp = new Map();
+    for (const k of keys) {
+        const i = k.lastIndexOf(" ");
+        const op = k.slice(0, i);
+        byOp.set(op, [...(byOp.get(op) ?? []), k.slice(i + 1)]);
+    }
+    const width = Math.max(0, ...[...byOp.keys()].map((op) => op.indexOf(" ") > -1 ? op.length - op.indexOf(" ") - 1 : 0));
+    const lines = [...byOp].map(([op, statuses]) => {
+        const i = op.indexOf(" ");
+        const marks = statuses.map((s) => `${s} ${hits.has(`${op} ${s}`) ? "✓" : "✗"}`).join("  ");
+        return `  ${op.slice(0, i).padEnd(6)} ${op.slice(i + 1).padEnd(width)}  ${marks}`;
+    });
+    const covered = keys.filter((k) => hits.has(k)).length;
+    const percent = keys.length ? Math.round((covered / keys.length) * 100) : 100;
+    return { covered, total: keys.length, percent, text: `slicetest: OpenAPI coverage (${spec.file}): ${covered}/${keys.length} documented responses (${percent}%)\n${lines.join("\n")}` };
+}
+function isJson(media) {
+    return /[/+]json$/i.test(media) || media === "*/*";
+}
+function escape(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** OpenAPI 3.0's `nullable: true` → JSON Schema's `type: [T, "null"]`. */
+function nullableToType(node) {
+    if (Array.isArray(node))
+        return node.map(nullableToType);
+    if (!node || typeof node !== "object")
+        return node;
+    for (const [k, v] of Object.entries(node))
+        node[k] = nullableToType(v);
+    if (node.nullable === true) {
+        if (node.enum && !node.enum.includes(null))
+            node.enum = [...node.enum, null];
+        if (typeof node.type === "string")
+            node.type = [node.type, "null"];
+        else if (!node.type) {
+            const inner = { ...node };
+            delete inner.nullable;
+            return { anyOf: [inner, { type: "null" }] };
+        }
+    }
+    return node;
+}

package/dist/provided.d.ts

@@ -6,6 +6,7 @@ declare module "vitest" {
             adminUrl: string;
             template: string;
             prefix: string;
+            coverageDir?: string;
         };
     }
 }

package/dist/runtime.d.ts

@@ -8,27 +8,33 @@ export interface ScenarioContext {
     db: Db;
     stub: (name: string) => Stub;
     app: App;
+    /** A process from the `services` option: its `url`, `logs()` and `waitForLog()`. */
+    service: (name: string) => App;
 }
 /** Everything one test file needs: its own database, stub servers and app process. */
 export declare class Runtime {
     #private;
     app: App;
+    readonly services: Map<string, App>;
     readonly db: Db;
     readonly stubs: Map<string, Stub>;
     private readonly opts;
     private readonly vars;
+    private readonly specs;
+    private readonly coverageDir?;
     private constructor();
     get http(): HttpClient;
     static start(opts: ResolvedOptions, shared: {
         adminUrl: string;
         template: string;
         prefix: string;
+        coverageDir?: string;
     }): Promise<Runtime>;
     context(): ScenarioContext;
     beforeScenario(): Promise<void>;
     /** Failures that the scenario body can't see on its own. */
     afterScenario(): Promise<void>;
     /** What happened during the current scenario, printed when it fails. */
-    diagnostics(): string;
+    diagnostics(): Promise<string>;
     stop(): Promise<void>;
 }

package/dist/runtime.js

@@ -1,37 +1,81 @@
+import { randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
 import path from "node:path";
-import pg from "pg";
 import { App } from "./app.js";
-import { Db, withDatabase } from "./db.js";
+import { Db, formatChanges } from "./db.js";
+import { engineFor } from "./drivers/index.js";
 import { formatHistory, HttpClient } from "./http.js";
+import { OpenApiSpec } from "./openapi.js";
 import { Stub } from "./stub.js";
 /** Everything one test file needs: its own database, stub servers and app process. */
 export class Runtime {
     app;
+    services;
     db;
     stubs;
     opts;
     vars;
-    #logMark = 0;
+    specs;
+    coverageDir;
     #http;
-    constructor(app, db, stubs, opts, vars) {
+    /** Responses from the app that don't match its OpenAPI spec, this scenario. */
+    #contract = [];
+    /** Documented responses seen in this file, for the run's coverage report. */
+    #covered = new Set();
+    constructor(app, services, db, stubs, opts, vars, specs, coverageDir) {
         this.app = app;
+        this.services = services;
         this.db = db;
         this.stubs = stubs;
         this.opts = opts;
         this.vars = vars;
-        this.#http = new HttpClient(app.url, opts.http);
+        this.specs = specs;
+        this.coverageDir = coverageDir;
+        this.#http = this.#client();
+    }
+    #client() {
+        const http = new HttpClient(this.app.url, this.opts.http);
+        const spec = this.specs.app;
+        if (spec) {
+            http.onResponse((res) => {
+                try {
+                    const path = res.url.split("?")[0];
+                    const key = spec.responseKey(res.method, path, res.status);
+                    if (key)
+                        this.#covered.add(key);
+                    this.#contract.push(...spec.checkResponse(res.method, path, message(res)));
+                }
+                catch (e) {
+                    this.#contract.push(`${res.method} ${res.url}: couldn't check against ${spec.file}: ${e.message}`);
+                }
+            });
+        }
+        return http;
     }
     get http() {
         return this.#http;
     }
     static async start(opts, shared) {
-        const url = await ensureWorkerDatabase(shared.adminUrl, shared.template, shared.prefix);
+        const engine = engineFor(opts);
+        const url = await ensureWorkerDatabase(engine, shared.adminUrl, shared.template, shared.prefix);
         const stubs = new Map();
+        const services = new Map();
         let db;
         try {
+            // Loaded first: a broken spec should fail before anything is started.
+            const specs = {
+                app: opts.openapi.app ? await OpenApiSpec.load(path.resolve(opts.root, opts.openapi.app), opts.openapi.app) : undefined,
+                stubs: new Map(),
+            };
+            for (const [name, file] of Object.entries(opts.openapi.stubs))
+                specs.stubs.set(name, await OpenApiSpec.load(path.resolve(opts.root, file), file));
             for (const name of opts.stubs)
                 stubs.set(name, await Stub.start(name));
-            db = await Db.connect(url, {
+            for (const name of opts.openapi.autoReply) {
+                const spec = specs.stubs.get(name);
+                stubs.get(name).fallback((call) => spec.exampleResponse(call.method, call.path));
+            }
+            db = await Db.connect(await engine.driver(url), url, {
                 schemas: opts.db.schemas,
                 keep: opts.db.keep,
                 seedFile: opts.db.seed && path.resolve(opts.root, opts.db.seed),
@@ -39,10 +83,17 @@ export class Runtime {
             const vars = { "db.url": url };
             for (const [name, stub] of stubs)
                 vars[`stub.${name}`] = stub.url;
+            for (const [name, service] of Object.entries(opts.services)) {
+                const started = await App.start(service, opts.root, vars, `service.${name}`);
+                services.set(name, started);
+                vars[`service.${name}`] = started.url;
+                vars[`service.${name}.port`] = String(started.port);
+            }
             const app = await App.start(opts.app, opts.root, vars);
-            return new Runtime(app, db, stubs, opts, vars);
+            return new Runtime(app, services, db, stubs, opts, vars, specs, shared.coverageDir);
         }
         catch (e) {
+            await Promise.all([...services.values()].map((s) => s.stop()));
             await db?.close();
             await Promise.all([...stubs.values()].map((s) => s.close()));
             throw e;
@@ -60,29 +111,80 @@ export class Runtime {
                 }
                 return stub;
             },
+            service: (name) => {
+                const service = this.services.get(name);
+                if (!service) {
+                    throw new Error(`slicetest: unknown service "${name}". Declared services: ${[...this.services.keys()].join(", ") || "(none)"}`);
+                }
+                return service;
+            },
         };
     }
+    /** The app and every service, for checks that apply to all of them. */
+    #processes() {
+        return [this.app, ...this.services.values()];
+    }
     async beforeScenario() {
-        // A crash already failed the scenario that caused it; give the next one a fresh app.
+        // A crash already failed the scenario that caused it; give the next one a fresh process.
+        for (const [name, service] of this.services) {
+            if (!service.exited)
+                continue;
+            await service.stop();
+            this.services.set(name, await App.start(this.opts.services[name], this.opts.root, this.vars, `service.${name}`, service.port));
+        }
         if (this.app.exited) {
             await this.app.stop();
             this.app = await App.start(this.opts.app, this.opts.root, this.vars);
-            this.#http = new HttpClient(this.app.url, this.opts.http);
+            this.#http = this.#client();
         }
+        this.#contract = [];
         await this.db.reset();
         for (const stub of this.stubs.values())
             stub.reset();
         this.http.reset();
-        this.#logMark = this.app.mark();
+        for (const p of this.#processes())
+            p.beginScenario();
     }
     /** Failures that the scenario body can't see on its own. */
     async afterScenario() {
-        await this.app.settle();
+        await Promise.all(this.#processes().map((p) => p.settle()));
         this.#assertAlive();
         const unmatched = this.#unmatched();
         if (unmatched.length > 0) {
             throw new Error(`slicetest: the app called stubbed services with no matching route:\n${unmatched.join("\n")}`);
         }
+        const contract = this.#contractViolations();
+        if (contract.length > 0) {
+            throw new Error(`slicetest: traffic doesn't match the OpenAPI spec:\n${contract.map((c) => `  ${c}`).join("\n")}`);
+        }
+    }
+    /** The app's responses against its spec, and its calls to stubs (and the stubs' replies) against theirs. */
+    #contractViolations() {
+        const out = this.#contract.map((c) => `app: ${c}`);
+        for (const [name, spec] of this.specs.stubs) {
+            for (const call of this.stubs.get(name).calls()) {
+                try {
+                    out.push(...this.#checkStubCall(name, spec, call));
+                }
+                catch (e) {
+                    out.push(`app → ${name}: ${call.method} ${call.path}: couldn't check against ${spec.file}: ${e.message}`);
+                }
+            }
+        }
+        return [...new Set(out)];
+    }
+    #checkStubCall(name, spec, call) {
+        if (!call.matched)
+            return []; // already reported as an unmatched call
+        const req = { contentType: header(call.headers["content-type"]), body: call.json ?? call.body, query: call.query };
+        const out = spec.checkRequest(call.method, call.path, req).map((c) => `app → ${name}: ${c}`);
+        const res = call.response;
+        if (res) {
+            const body = res.body ? (parseJson(res.body) ?? res.body) : "";
+            const problems = spec.checkResponse(call.method, call.path, { status: res.status, contentType: res.headers["content-type"], body });
+            out.push(...problems.map((c) => `stub ${name} reply (the real service wouldn't answer this way): ${c}`));
+        }
+        return out;
     }
     #unmatched() {
         return [...this.stubs.values()].flatMap((s) => {
@@ -97,23 +199,43 @@ export class Runtime {
         });
     }
     /** What happened during the current scenario, printed when it fails. */
-    diagnostics() {
+    async diagnostics() {
         const sections = [];
-        const exit = this.app.exited;
-        if (exit)
-            sections.push(`the app exited (code ${exit.code}, signal ${exit.signal}); it will be restarted for the next scenario`);
+        for (const p of this.#processes()) {
+            const exit = p.exited;
+            if (exit)
+                sections.push(`the ${p.label} exited (code ${exit.code}, signal ${exit.signal}); it will be restarted for the next scenario`);
+        }
         const unmatched = this.#unmatched();
         if (unmatched.length > 0)
             sections.push(`stub calls with no matching route:\n${unmatched.join("\n")}`);
+        const contract = this.#contractViolations();
+        if (contract.length > 0)
+            sections.push(`OpenAPI mismatches:\n${contract.map((c) => `  ${c}`).join("\n")}`);
         if (this.http.history.length > 0)
             sections.push(`requests to the app:\n${formatHistory(this.http.history)}`);
-        const logs = this.app.logs(this.#logMark);
+        try {
+            const changes = formatChanges(await this.db.changesSinceStart());
+            sections.push(changes ? `database changes during this scenario:\n${changes}` : "database changes during this scenario: (none)");
+        }
+        catch (e) {
+            sections.push(`database changes during this scenario: unavailable (${e.message})`);
+        }
+        const logs = this.app.scenarioLogs();
         sections.push(logs ? `app output during this scenario:\n${logs}` : "app output during this scenario: (none)");
+        for (const [name, service] of this.services) {
+            const out = service.scenarioLogs();
+            sections.push(out ? `service ${name} output during this scenario:\n${out}` : `service ${name} output during this scenario: (none)`);
+        }
         return sections.join("\n\n");
     }
     async stop() {
+        if (this.coverageDir && this.#covered.size > 0) {
+            await writeFile(path.join(this.coverageDir, `${process.pid}-${randomUUID()}.json`), JSON.stringify([...this.#covered])).catch(() => { });
+        }
         const results = await Promise.allSettled([
             this.app.stop(),
+            ...[...this.services.values()].map((s) => s.stop()),
             this.db.close(),
             ...[...this.stubs.values()].map((s) => s.close()),
         ]);
@@ -122,24 +244,37 @@ export class Runtime {
             throw failed.reason;
     }
     #assertAlive() {
-        const exit = this.app.exited;
-        if (exit) {
-            throw new Error(`slicetest: app process exited (code ${exit.code}, signal ${exit.signal})\n${this.app.logs()}`);
+        for (const p of this.#processes()) {
+            const exit = p.exited;
+            if (exit)
+                throw new Error(`slicetest: ${p.label} process exited (code ${exit.code}, signal ${exit.signal})\n${p.logs()}`);
         }
     }
 }
 /** One database per vitest worker, cloned from the migrated template and reused across its test files. */
-async function ensureWorkerDatabase(adminUrl, template, prefix) {
+async function ensureWorkerDatabase(engine, adminUrl, template, prefix) {
     const name = `${prefix}_w${process.env.VITEST_POOL_ID ?? process.pid}`;
-    const admin = new pg.Client({ connectionString: adminUrl });
-    await admin.connect();
+    const admin = await engine.admin(adminUrl);
     try {
-        const { rowCount } = await admin.query("SELECT 1 FROM pg_database WHERE datname = $1", [name]);
-        if (!rowCount)
-            await admin.query(`CREATE DATABASE "${name}" TEMPLATE "${template}"`);
+        if (!(await admin.databases(name)).includes(name))
+            await admin.clone(template, name);
+        return admin.urlFor(name);
     }
     finally {
-        await admin.end();
+        await admin.close();
+    }
+}
+function message(res) {
+    return { status: res.status, contentType: res.headers.get("content-type") ?? undefined, body: res.json ?? res.text };
+}
+function header(v) {
+    return Array.isArray(v) ? v[0] : v;
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
     }
-    return withDatabase(adminUrl, name);
 }

package/dist/scenario.js

@@ -15,8 +15,8 @@ function define(register) {
         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.");
         }
-        onTestFailed(() => {
-            console.error(`--- slicetest ---\n${runtime.diagnostics()}\n-----------------`);
+        onTestFailed(async () => {
+            console.error(`--- slicetest ---\n${await runtime.diagnostics()}\n-----------------`);
         });
         await runtime.beforeScenario();
         await body(runtime.context());