slicetest 0.3.0 → 0.5.0

package/dist/webhook.js

@@ -0,0 +1,52 @@
+import { createHmac, randomUUID } from "node:crypto";
+const hmac = (algorithm, key, data) => createHmac(algorithm, key).update(data);
+/**
+ * The headers a provider sends with `body`, signed with `secret` the way its
+ * SDK verifies them: Stripe's `Stripe-Signature`, GitHub's
+ * `X-Hub-Signature-256`, Slack's `v0` signature, Shopify's base64 HMAC and
+ * Standard Webhooks (Svix, Resend, Clerk, …).
+ */
+export function signWebhook(body, opts) {
+    const now = Math.floor(Date.now() / 1000);
+    const ts = opts.timestamp ?? (opts.stale ? now - 600 : now);
+    const secret = opts.invalidSignature ? `${opts.secret}-not-the-real-secret` : opts.secret;
+    const p = opts.provider;
+    if (typeof p === "object") {
+        if (!p.header)
+            throw new Error("slicetest: a custom webhook provider needs `header`, e.g. { header: \"X-Signature\", prefix: \"sha256=\" }");
+        return { [p.header]: `${p.prefix ?? ""}${hmac(p.algorithm ?? "sha256", secret, body).digest(p.encoding ?? "hex")}` };
+    }
+    switch (p) {
+        case "stripe":
+            return { "stripe-signature": `t=${ts},v1=${hmac("sha256", secret, `${ts}.${body}`).digest("hex")}` };
+        case "github":
+            return {
+                "x-hub-signature-256": `sha256=${hmac("sha256", secret, body).digest("hex")}`,
+                "x-github-event": opts.event ?? "ping",
+                "x-github-delivery": randomUUID(),
+            };
+        case "slack":
+            return { "x-slack-request-timestamp": String(ts), "x-slack-signature": `v0=${hmac("sha256", secret, `v0:${ts}:${body}`).digest("hex")}` };
+        case "shopify":
+            return {
+                "x-shopify-hmac-sha256": hmac("sha256", secret, body).digest("base64"),
+                ...(opts.event ? { "x-shopify-topic": opts.event } : {}),
+                "x-shopify-webhook-id": randomUUID(),
+            };
+        case "standard": {
+            const id = opts.id ?? `msg_${randomUUID().replace(/-/g, "")}`;
+            const key = secret.startsWith("whsec_") ? Buffer.from(secret.slice(6), "base64") : Buffer.from(secret);
+            return { "webhook-id": id, "webhook-timestamp": String(ts), "webhook-signature": `v1,${hmac("sha256", key, `${id}.${ts}.${body}`).digest("base64")}` };
+        }
+        default:
+            throw new Error(`slicetest: unknown webhook provider ${JSON.stringify(p)} (expected stripe, github, slack, shopify, standard or { header, prefix, encoding })`);
+    }
+}
+/** The bytes to send and their content type: objects as JSON, URLSearchParams as a form (Slack commands), strings as-is. */
+export function webhookBody(payload) {
+    if (typeof payload === "string")
+        return { body: payload, type: "application/json" };
+    if (payload instanceof URLSearchParams)
+        return { body: payload.toString(), type: "application/x-www-form-urlencoded" };
+    return { body: JSON.stringify(payload ?? {}), type: "application/json" };
+}

package/dist/yaml-runtime.d.ts

@@ -1,3 +1,4 @@
+import "./provided.js";
 import "./matchers.js";
 import type { YamlFile } from "./yaml.js";
 type Vars = Record<string, unknown>;

package/dist/yaml-runtime.js

@@ -1,7 +1,10 @@
-import { expect } from "vitest";
+import { expect, inject } from "vitest";
+import { recordYamlFailure } from "./ci.js";
+import "./provided.js";
 import { formatChanges } from "./db.js";
 import "./matchers.js";
 import { scenario } from "./scenario.js";
+import { signWebhook, webhookBody } from "./webhook.js";
 /** Registers the scenarios of one parsed YAML file. Called from the module the plugin generates for it. */
 export function defineYamlScenarios(doc) {
     for (const sc of doc.scenarios) {
@@ -17,11 +20,17 @@ async function runSteps(doc, sc, steps, ctx, vars) {
     for (const [i, step] of steps.entries()) {
         try {
             // A log step waits by itself; `within` is its timeout.
-            await retry("within" in step && !("log" in step) ? step.within : undefined, () => runStep(step, ctx, vars));
+            // Log and mail steps wait by themselves; `within` is their timeout.
+            await retry("within" in step && !("log" in step) && !("mail" in step) ? step.within : undefined, () => runStep(step, ctx, vars));
         }
         catch (e) {
             const label = step.name ?? describeStep(step);
             const where = `${doc.file}:${step.line} (${sc.name}, step ${i + 1}: ${label})`;
+            const ciDir = inject("slicetestDb")?.ciDir;
+            if (ciDir && doc.path) {
+                const message = (e instanceof Error ? e.message : String(e)).replace(/\x1b\[[0-9;]*m/g, "");
+                await recordYamlFailure(ciDir, { file: doc.path, line: step.line, scenario: sc.name, step: `step ${i + 1}: ${label}`, message }).catch(() => { });
+            }
             if (e instanceof Error) {
                 e.message = `${where}\n${e.message}`;
                 throw e;
@@ -32,13 +41,17 @@ async function runSteps(doc, sc, steps, ctx, vars) {
 }
 function describeStep(step) {
     if ("request" in step)
-        return step.request;
+        return step.concurrency ? `${step.request} ×${step.concurrency}` : step.request;
     if ("stub" in step)
         return `stub ${step.stub} ${step.on}`;
     if ("received" in step)
         return `received ${step.received}${step.call ? ` ${step.call}` : ""}`;
     if ("insert" in step)
         return `insert ${step.insert}`;
+    if ("make" in step)
+        return `make ${step.make}`;
+    if ("chaos" in step)
+        return `chaos ${step.chaos}`;
     if ("db" in step)
         return `db ${step.db}`;
     if ("changes" in step)
@@ -47,6 +60,8 @@ function describeStep(step) {
         return "checkpoint";
     if ("snapshot" in step)
         return "snapshot";
+    if ("mail" in step)
+        return `mail${Object.entries(step.mail).map(([k, v]) => ` ${k}: ${JSON.stringify(v)}`).join(",")}`;
     if ("log" in step)
         return `log ${step.from ? `from ${step.from} ` : ""}/${step.log}/`;
     return "sql";
@@ -84,6 +99,24 @@ async function runStep(step, ctx, vars) {
         await target.waitForLog(new RegExp(interpolate(step.log, vars)), step.within ?? 5000);
         return;
     }
+    if ("mail" in step) {
+        const filter = Object.fromEntries(Object.entries(interpolate(step.mail, vars)).map(([k, v]) => {
+            const re = v && typeof v === "object" && "$regex" in v ? new RegExp(String(v.$regex)) : undefined;
+            return [k, re ?? String(v)];
+        }));
+        const box = ctx.mail;
+        await retry(step.within ?? 5000, async () => {
+            const found = box.messages(filter);
+            if (step.times === undefined ? found.length === 0 : found.length !== step.times) {
+                const want = step.times === undefined ? "at least one message" : `${step.times} message(s)`;
+                throw new Error(`expected ${want} matching ${JSON.stringify(step.mail)}, got ${found.length}\n${box.describe()}`);
+            }
+        });
+        const last = box.last(filter);
+        if (last)
+            capture(step.capture, last, vars);
+        return;
+    }
     if ("changes" in step) {
         const actual = await ctx.db.changes();
         const expected = interpolate(step.changes, vars);
@@ -131,28 +164,56 @@ async function runStep(step, ctx, vars) {
     if ("request" in step) {
         const [method, rawPath] = splitCall(step.request);
         const path = interpolate(rawPath, vars);
+        const headers = interpolate(step.headers, vars);
         const opts = {
-            headers: interpolate(step.headers, vars),
+            headers: step.auth ? { ...ctx.auth.header(step.auth === true ? {} : interpolate(step.auth, vars)), ...headers } : headers,
             query: interpolate(step.query, vars),
             follow: step.follow,
         };
-        const body = step.json !== undefined
+        let body = step.json !== undefined
             ? interpolate(step.json, vars)
             : step.form !== undefined
                 ? ctx.http.form(interpolate(step.form, vars))
                 : interpolate(step.body, vars);
-        const res = await ctx.http.request(method, path, body, opts);
+        if (step.webhook) {
+            const signed = webhookBody(body);
+            body = signed.body;
+            opts.headers = { "content-type": signed.type, ...signWebhook(signed.body, interpolate(step.webhook, vars)), ...opts.headers };
+        }
         const e = step.expect;
-        if (e?.status !== undefined)
-            expect(res).toHaveStatus(interpolate(e.status, vars));
-        if (e?.headers !== undefined) {
-            const expected = Object.fromEntries(Object.entries(e.headers).map(([k, v]) => [k.toLowerCase(), v]));
-            check(Object.fromEntries(res.headers), expected, vars, "response headers");
+        const verify = (res) => {
+            if (e?.status !== undefined)
+                expect(res).toHaveStatus(interpolate(e.status, vars));
+            if (e?.headers !== undefined) {
+                const expected = Object.fromEntries(Object.entries(e.headers).map(([k, v]) => [k.toLowerCase(), v]));
+                check(Object.fromEntries(res.headers), expected, vars, "response headers");
+            }
+            if (e?.json !== undefined)
+                check(res.json, e.json, vars, "response JSON");
+            if (e?.text !== undefined)
+                check(res.text, e.text, vars, "response text");
+        };
+        if (step.concurrency !== undefined) {
+            // Each request gets its own body: a URLSearchParams body can only be read once.
+            const all = await ctx.http.concurrently(step.concurrency, () => ctx.http.request(method, path, body instanceof URLSearchParams ? new URLSearchParams(body) : body, opts));
+            if (e?.statuses !== undefined)
+                expect(all).toHaveStatuses(interpolate(e.statuses, vars));
+            all.forEach(verify);
+            return;
         }
-        if (e?.json !== undefined)
-            check(res.json, e.json, vars, "response JSON");
-        if (e?.text !== undefined)
-            check(res.text, e.text, vars, "response text");
+        const max = e?.queries === undefined ? undefined : interpolate(e.queries, vars);
+        let res;
+        const queries = await (max === undefined ? undefined : ctx.db.queries(async () => (res = await ctx.http.request(method, path, body, opts))));
+        if (!queries)
+            res = await ctx.http.request(method, path, body, opts);
+        if (queries && max !== undefined) {
+            const ran = queries.withoutTransactions();
+            if (ran.length > max) {
+                const shapes = ran.shapes().map((s) => `  ${s.count > 1 ? `×${s.count} ` : ""}${s.sql}`);
+                throw new Error(`expected at most ${max} SQL statements for ${method} ${path}, the app ran ${ran.length}:\n${shapes.join("\n")}`);
+            }
+        }
+        verify(res);
         capture(step.capture, { status: res.status, json: res.json, text: res.text, headers: Object.fromEntries(res.headers) }, vars);
         return;
     }
@@ -161,6 +222,22 @@ async function runStep(step, ctx, vars) {
         capture(step.capture, { rows, row: rows[0] }, vars);
         return;
     }
+    if ("chaos" in step) {
+        const { chaos, name: _, ...opts } = step;
+        ctx.stub(chaos).chaos(opts);
+        return;
+    }
+    if ("make" in step) {
+        const given = interpolate(step.rows, vars) ?? {};
+        const rows = [];
+        if (Array.isArray(given))
+            for (const r of given)
+                rows.push(await ctx.db.make(step.make, r));
+        else
+            rows.push(...(await ctx.db.makeMany(step.make, step.count ?? 1, given)));
+        capture(step.capture, { rows, row: rows[0] }, vars);
+        return;
+    }
     if ("sql" in step) {
         const rows = await ctx.db.query(step.sql, interpolate(step.params, vars) ?? []);
         expectRows(step.expect, rows, vars);

package/dist/yaml.d.ts

@@ -6,6 +6,8 @@
  */
 export interface YamlFile {
     file: string;
+    /** Absolute path, for CI annotations. */
+    path?: string;
     /** Steps run at the start of every scenario in the file. */
     setup: Step[];
     scenarios: YamlScenario[];
@@ -19,7 +21,7 @@ export interface YamlScenario {
     timeout?: number;
     steps: Step[];
 }
-export type Step = (StubStep | RequestStep | InsertStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep) & {
+export type Step = (StubStep | RequestStep | InsertStep | MakeStep | ChaosStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep | MailStep) & {
     line: number;
     name?: string;
 };
@@ -55,11 +57,31 @@ export interface RequestStep {
     form?: Record<string, unknown>;
     body?: string;
     follow?: boolean;
+    /** Send `Authorization: Bearer` with a token from the `auth` issuer: `true`, or the claims, e.g. { sub: u1, roles: [admin] }. */
+    auth?: true | Record<string, unknown>;
+    /** Sign the body as this provider would deliver a webhook: { provider: stripe, secret: whsec_test, event, stale, invalidSignature }. */
+    webhook?: {
+        provider: string | {
+            header: string;
+            algorithm?: string;
+            encoding?: "hex" | "base64";
+            prefix?: string;
+        };
+        secret: string;
+        event?: string;
+        stale?: boolean;
+        invalidSignature?: boolean;
+    };
+    /** Send the request this many times at once. `expect` applies to every response; `statuses` counts them. */
+    concurrency?: number;
+    /** `queries`: at most this many SQL statements (not counting BEGIN/COMMIT), with `db.queries` on. */
     expect?: {
         status?: number;
+        statuses?: Record<string, number>;
         headers?: Record<string, unknown>;
         json?: unknown;
         text?: unknown;
+        queries?: number;
     };
     capture?: Record<string, string>;
 }
@@ -68,6 +90,24 @@ export interface InsertStep {
     rows: Record<string, unknown> | Record<string, unknown>[];
     capture?: Record<string, string>;
 }
+/** Rows built by `db.make()`: only the columns given are fixed, the rest is filled from the schema. */
+export interface MakeStep {
+    make: string;
+    rows?: Record<string, unknown> | Record<string, unknown>[];
+    /** Make this many rows, each with `rows` (a mapping). */
+    count?: number;
+    capture?: Record<string, string>;
+}
+/** Faults injected into a stub's answers for the rest of the scenario, like `stub(name).chaos()`. */
+export interface ChaosStep {
+    chaos: string;
+    failFirst?: number;
+    errorRate?: number;
+    statuses?: number[];
+    networkErrorRate?: number;
+    latency?: number | [number, number];
+    seed?: number;
+}
 export interface SqlStep {
     sql: string;
     params?: unknown[];
@@ -129,6 +169,24 @@ export interface SnapshotStep {
     /** Keys whose values are masked in addition to dates and UUIDs. */
     mask?: string[];
 }
+/**
+ * The app sent mail matching `mail:` (strings are exact addresses for to/from and substrings
+ * otherwise; `{ $regex }` also works). Waits up to `within` ms (default 5000). `capture` reads
+ * the last match: `subject`, `text`, `links.0`.
+ */
+export interface MailStep {
+    mail: {
+        to?: unknown;
+        from?: unknown;
+        subject?: unknown;
+        text?: unknown;
+        html?: unknown;
+    };
+    /** Exact number of matching messages. Default: at least one. */
+    times?: number;
+    within?: number;
+    capture?: Record<string, string>;
+}
 export declare class YamlScenarioError extends Error {
 }
 export declare function parseScenarioFile(text: string, file: string): YamlFile;

package/dist/yaml.js

@@ -1,7 +1,7 @@
 import { isMap, isSeq, LineCounter, parseDocument } from "yaml";
 const KINDS = {
     stub: ["on", "when", "reply", "sequence", "networkError", "times", "delay"],
-    request: ["headers", "query", "json", "form", "body", "follow", "expect", "capture"],
+    request: ["headers", "query", "json", "form", "body", "follow", "auth", "webhook", "concurrency", "expect", "capture"],
     insert: ["rows", "capture"],
     sql: ["params", "expect", "capture", "within"],
     db: ["where", "orderBy", "expect", "capture", "within"],
@@ -10,17 +10,25 @@ const KINDS = {
     log: ["from", "within"],
     checkpoint: [],
     snapshot: ["mask"],
+    mail: ["times", "within", "capture"],
+    make: ["rows", "count", "capture"],
+    chaos: ["failFirst", "errorRate", "statuses", "networkErrorRate", "latency", "seed"],
 };
 const EXPECT_KEYS = {
-    request: ["status", "headers", "json", "text"],
+    request: ["status", "statuses", "headers", "json", "text", "queries"],
     sql: ["rows", "count"],
     db: ["rows", "count"],
 };
 const CONDITION_KEYS = ["query", "headers", "json", "body"];
+const WEBHOOK_KEYS = ["provider", "secret", "event", "stale", "invalidSignature"];
+const WEBHOOK_PROVIDERS = ["stripe", "github", "slack", "shopify", "standard"];
+const MAIL_KEYS = ["to", "from", "subject", "text", "html"];
 const CHANGE_KEYS = ["inserted", "updated", "deleted"];
 const RESPONSE_KEYS = ["status", "headers", "body"];
 const SCENARIO_KEYS = ["name", "steps", "each", "skip", "only", "timeout"];
 const CALL = /^([A-Za-z]+|\*)\s+(\/\S*)$/;
+/** A request may also go to a captured URL of the app, e.g. a link from a mail: `GET {{link}}`. */
+const REQUEST = /^[A-Za-z]+\s+(\/\S*|\{\{[^}]+\}\}\S*)$/;
 export class YamlScenarioError extends Error {
 }
 export function parseScenarioFile(text, file) {
@@ -108,6 +116,14 @@ function parseStep(node, fail, lineOf) {
             }
         }
     }
+    else if (kind === "mail") {
+        const filter = raw.mail;
+        if (!filter || typeof filter !== "object" || Array.isArray(filter))
+            fail(at(kind), "`mail:` must be a mapping such as { to: alice@example.com, subject: Welcome } ({} for any)");
+        for (const k of Object.keys(filter))
+            if (!MAIL_KEYS.includes(k))
+                fail(at(kind), `unknown key "${k}" in mail (allowed: ${MAIL_KEYS.join(", ")})`);
+    }
     else if (kind === "checkpoint") {
         if (raw.checkpoint !== true)
             fail(at(kind), "use `checkpoint: true`");
@@ -131,8 +147,8 @@ function parseStep(node, fail, lineOf) {
                 fail(at(key), `unknown key "${k}" in ${key} (allowed: ${allowedKeys.join(", ")})`);
         }
     };
-    const call = (key) => {
-        if (raw[key] !== undefined && !CALL.test(String(raw[key])))
+    const call = (key, pattern = CALL) => {
+        if (raw[key] !== undefined && !pattern.test(String(raw[key])))
             fail(at(key), `\`${key}\` must look like "POST /path", got "${raw[key]}"`);
     };
     if (raw.within !== undefined && (typeof raw.within !== "number" || raw.within <= 0))
@@ -166,14 +182,78 @@ function parseStep(node, fail, lineOf) {
             break;
         }
         case "request":
-            call("request");
+            call("request", REQUEST);
             if (["json", "form", "body"].filter((k) => raw[k] !== undefined).length > 1)
                 fail(node, "use only one of json / form / body");
+            if (raw.webhook !== undefined) {
+                const w = raw.webhook;
+                if (!w || typeof w !== "object" || Array.isArray(w))
+                    fail(at("webhook"), "`webhook` must be a mapping such as { provider: stripe, secret: whsec_test }");
+                for (const k of Object.keys(w))
+                    if (!WEBHOOK_KEYS.includes(k))
+                        fail(at("webhook"), `unknown key "${k}" in webhook (allowed: ${WEBHOOK_KEYS.join(", ")})`);
+                if (typeof w.secret !== "string" || !w.secret)
+                    fail(at("webhook"), "`webhook.secret` is required: the signing secret the app is configured with");
+                const p = w.provider;
+                if (!(typeof p === "string" ? WEBHOOK_PROVIDERS.includes(p) : p && typeof p === "object" && typeof p.header === "string")) {
+                    fail(at("webhook"), `\`webhook.provider\` must be one of ${WEBHOOK_PROVIDERS.join(", ")} or { header, prefix, encoding }`);
+                }
+            }
+            if (raw.auth !== undefined && raw.auth !== true && !(raw.auth && typeof raw.auth === "object" && !Array.isArray(raw.auth)))
+                fail(at("auth"), "`auth` must be true or the token's claims, e.g. { sub: u1, roles: [admin] }");
+            if (raw.concurrency !== undefined && !(Number.isInteger(raw.concurrency) && raw.concurrency >= 1))
+                fail(at("concurrency"), "`concurrency` must be a positive whole number");
+            {
+                const q = raw.expect?.queries;
+                if (q !== undefined && !(Number.isInteger(q) && q >= 0))
+                    fail(at("expect"), "`expect.queries` is the most SQL statements the request may run, e.g. 3");
+                if (q !== undefined && raw.concurrency !== undefined)
+                    fail(at("expect"), "`expect.queries` can't be used with `concurrency`");
+            }
+            if (raw.concurrency !== undefined && raw.capture !== undefined)
+                fail(at("capture"), "`capture` can't be used with `concurrency`: there is more than one response");
+            {
+                const statuses = raw.expect?.statuses;
+                if (statuses !== undefined) {
+                    if (raw.concurrency === undefined)
+                        fail(at("expect"), "`expect.statuses` needs `concurrency`");
+                    if (!statuses || typeof statuses !== "object" || Object.entries(statuses).some(([k, v]) => !/^\d{3}$/.test(k) || !Number.isInteger(v))) {
+                        fail(at("expect"), "`expect.statuses` maps status codes to counts, e.g. { 201: 1, 409: 9 }");
+                    }
+                }
+            }
             break;
         case "insert":
             if (!raw.rows || typeof raw.rows !== "object")
                 fail(at("rows"), "an insert step needs `rows` (a mapping or a list of mappings)");
             break;
+        case "chaos":
+            for (const k of ["errorRate", "networkErrorRate"]) {
+                if (raw[k] !== undefined && !(typeof raw[k] === "number" && raw[k] >= 0 && raw[k] <= 1))
+                    fail(at(k), `\`${k}\` must be a number between 0 and 1`);
+            }
+            for (const k of ["failFirst", "seed"])
+                if (raw[k] !== undefined && !Number.isInteger(raw[k]))
+                    fail(at(k), `\`${k}\` must be a whole number`);
+            if (raw.statuses !== undefined && !(Array.isArray(raw.statuses) && raw.statuses.length > 0 && raw.statuses.every((s) => Number.isInteger(s) && s >= 400 && s <= 599))) {
+                fail(at("statuses"), "`statuses` must be a list of 4xx/5xx codes, e.g. [503]");
+            }
+            {
+                const l = raw.latency;
+                if (l !== undefined && !(typeof l === "number" || (Array.isArray(l) && l.length === 2 && l.every((x) => typeof x === "number"))))
+                    fail(at("latency"), "`latency` must be milliseconds or [min, max]");
+            }
+            break;
+        case "make":
+            if (raw.rows !== undefined && (!raw.rows || typeof raw.rows !== "object"))
+                fail(at("rows"), "`rows` must be a mapping or a list of mappings");
+            if (raw.count !== undefined) {
+                if (!(Number.isInteger(raw.count) && raw.count >= 1))
+                    fail(at("count"), "`count` must be a positive whole number");
+                if (Array.isArray(raw.rows))
+                    fail(at("count"), "use either `count` or a list of `rows`");
+            }
+            break;
         case "log":
             try {
                 new RegExp(raw.log);
@@ -188,6 +268,9 @@ function parseStep(node, fail, lineOf) {
             call("call");
             number("times");
             break;
+        case "mail":
+            number("times");
+            break;
     }
     return { ...raw, line: lineOf(node) };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "slicetest",
-  "version": "0.3.0",
-  "description": "Framework-agnostic slice tests: drive a real app process over HTTP with a real Postgres and stubbed outbound APIs, checked against OpenAPI contracts.",
+  "version": "0.5.0",
+  "description": "Framework-agnostic slice tests: drive a real app process over HTTP with a real Postgres, MySQL or SQLite and stubbed outbound APIs, checked against OpenAPI contracts.",
   "keywords": [
     "testing",
     "integration-testing",
@@ -9,6 +9,7 @@
     "api-testing",
     "postgres",
     "mysql",
+    "sqlite",
     "stub",
     "mock-server",
     "vitest",
@@ -17,7 +18,13 @@
     "testcontainers",
     "language-agnostic",
     "openapi",
-    "contract-testing"
+    "contract-testing",
+    "jwt",
+    "oidc",
+    "webhooks",
+    "chaos-testing",
+    "n-plus-one",
+    "test-data-factory"
   ],
   "author": "pon-bok",
   "repository": {
@@ -55,7 +62,7 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
-    "test:dist": "npm run build && tsc -p examples/tsconfig.dist.json && vitest run --config examples/vitest.dist.config.ts && node dist/cli.js --config examples/slicetest.config.yaml",
+    "test:dist": "npm run build && tsc -p examples/tsconfig.dist.json && vitest run --config examples/vitest.dist.config.ts && node dist/cli.js --config examples/slicetest.config.yaml && node test/record-dist.mjs",
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "peerDependencies": {