slicetest 0.6.0 → 0.7.0

package/dist/yaml-runtime.js

@@ -5,6 +5,9 @@ import { formatChanges } from "./db.js";
 import "./matchers.js";
 import { scenario } from "./scenario.js";
 import { signWebhook, webhookBody } from "./webhook.js";
+import path from "node:path";
+import { graphqlErrors } from "./graphql.js";
+import { schemaProblems } from "./schema.js";
 import { sse } from "./stub.js";
 /** Registers the scenarios of one parsed YAML file. Called from the module the plugin generates for it. */
 export function defineYamlScenarios(doc) {
@@ -17,20 +20,30 @@ export function defineYamlScenarios(doc) {
         });
     }
 }
-async function runSteps(doc, sc, steps, ctx, vars) {
+async function runSteps(doc, sc, steps, ctx, vars, trail = []) {
     for (const [i, step] of steps.entries()) {
+        if ("use" in step) {
+            // The definition sees the scenario's variables plus `with`; what it captures is kept afterwards.
+            const args = interpolate(step.with ?? {}, vars) ?? {};
+            const inner = { ...vars, ...args };
+            await runSteps(doc, sc, doc.define[step.use].steps, ctx, inner, [...trail, `step ${i + 1}: use ${step.use}`]);
+            for (const [k, v] of Object.entries(inner))
+                if (!(k in args))
+                    vars[k] = v;
+            continue;
+        }
         try {
             // A log step waits by itself; `within` is its timeout.
             // 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));
+            await retry("within" in step && !("log" in step) && !("mail" in step) ? step.within : undefined, () => runStep(step, ctx, vars, doc.path ? path.dirname(doc.path) : undefined));
         }
         catch (e) {
             const label = step.name ?? describeStep(step);
-            const where = `${doc.file}:${step.line} (${sc.name}, step ${i + 1}: ${label})`;
+            const where = `${doc.file}:${step.line} (${sc.name}, ${[...trail, `step ${i + 1}: ${label}`].join(" → ")})`;
             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(() => { });
+                await recordYamlFailure(ciDir, { file: doc.path, line: step.line, scenario: sc.name, step: [...trail, `step ${i + 1}: ${label}`].join(" → "), message }).catch(() => { });
             }
             if (e instanceof Error) {
                 e.message = `${where}\n${e.message}`;
@@ -41,14 +54,16 @@ async function runSteps(doc, sc, steps, ctx, vars) {
     }
 }
 function describeStep(step) {
+    if ("use" in step)
+        return `use ${step.use}`;
     if ("submit" in step)
         return step.submit === true ? "submit" : `submit ${JSON.stringify(step.submit)}`;
     if ("request" in step)
         return step.concurrency ? `${step.request} ×${step.concurrency}` : step.request;
     if ("stub" in step)
-        return `stub ${step.stub} ${step.on}`;
+        return `stub ${step.stub} ${step.on ?? `GraphQL ${step.graphql}`}`;
     if ("received" in step)
-        return `received ${step.received}${step.call ? ` ${step.call}` : ""}`;
+        return `received ${step.received}${step.call ? ` ${step.call}` : step.graphql ? ` GraphQL ${step.graphql}` : ""}`;
     if ("insert" in step)
         return `insert ${step.insert}`;
     if ("make" in step)
@@ -88,7 +103,9 @@ async function retry(within, fn) {
         }
     }
 }
-async function runStep(step, ctx, vars) {
+async function runStep(step, ctx, vars, base) {
+    if ("use" in step)
+        throw new Error("slicetest: use steps are expanded by runSteps");
     if ("checkpoint" in step) {
         await ctx.db.checkpoint();
         return;
@@ -145,15 +162,28 @@ async function runStep(step, ctx, vars) {
         return;
     }
     if ("stub" in step) {
-        const [method, path] = splitCall(step.on);
-        let route = ctx.stub(step.stub).on(method, interpolate(path, vars), conditions(step.when, vars));
+        const stub = ctx.stub(step.stub);
+        let route;
+        if (step.graphql !== undefined) {
+            const { variables, ...when } = conditions(step.when, vars);
+            route = stub.graphql(interpolate(step.graphql, vars), { ...when, variables });
+        }
+        else {
+            const [method, path] = splitCall(step.on);
+            route = stub.on(method, interpolate(path, vars), conditions(step.when, vars));
+        }
         if (step.times !== undefined)
             route = route.times(step.times);
         if (step.delay !== undefined)
             route = route.delay(step.delay);
-        // Replies are interpolated when a call arrives, so they can echo it: {{call.params.id}}, {{call.json.name}}.
+        if (step.optional)
+            route = route.optional();
+        // Replies are interpolated when a call arrives, so they can echo it: {{call.params.id}}, {{call.json.name}}, {{call.variables.id}}.
         const answer = (template) => (call) => {
-            const { sse: events, ...response } = interpolate(template, { ...vars, call: callVars(call) });
+            const { sse: events, data, errors, ...response } = interpolate(template, { ...vars, call: callVars(call) });
+            if (data !== undefined || errors !== undefined) {
+                return { status: 200, ...response, body: { ...(errors ? { errors: graphqlErrors(errors) } : {}), ...(data !== undefined ? { data } : {}) } };
+            }
             return events ? sse(events, response) : response;
         };
         if (step.networkError)
@@ -178,7 +208,7 @@ async function runStep(step, ctx, vars) {
             headers: interpolate(step.headers, vars),
             follow: step.follow,
         });
-        verifyResponse(res, step.expect, vars);
+        verifyResponse(res, step.expect, vars, base);
         capture(step.capture, { status: res.status, json: res.json, text: res.text, headers: Object.fromEntries(res.headers) }, vars);
         return;
     }
@@ -191,18 +221,27 @@ async function runStep(step, ctx, vars) {
             query: interpolate(step.query, vars),
             follow: step.follow,
         };
-        let body = step.json !== undefined
-            ? interpolate(step.json, vars)
-            : step.form !== undefined
-                ? ctx.http.form(interpolate(step.form, vars))
-                : interpolate(step.body, vars);
+        const gql = step.graphql === undefined ? undefined : interpolate(typeof step.graphql === "string" ? { query: step.graphql } : step.graphql, vars);
+        let body = gql !== undefined
+            ? gql
+            : step.json !== undefined
+                ? interpolate(step.json, vars)
+                : step.form !== undefined
+                    ? ctx.http.form(interpolate(step.form, vars))
+                    : interpolate(step.body, vars);
         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;
-        const verify = (res) => verifyResponse(res, e, vars);
+        const verify = (res) => {
+            // GraphQL servers answer errors with 200, so a status check alone would pass them.
+            const expectsErrors = !!e?.json && typeof e.json === "object" && "errors" in e.json;
+            if (gql && !expectsErrors && Array.isArray(res.json?.errors) && res.json.errors.length)
+                expect(res).toHaveGraphQLData();
+            verifyResponse(res, e, vars, base);
+        };
         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));
@@ -263,7 +302,9 @@ async function runStep(step, ctx, vars) {
     // received
     const [method, path] = step.call ? splitCall(step.call) : [undefined, undefined];
     const stub = ctx.stub(step.received);
-    const match = conditions(step.when, vars);
+    const { variables, ...match } = conditions(step.when, vars);
+    if (step.graphql !== undefined)
+        match.graphql = { operation: interpolate(step.graphql, vars), variables };
     const p = path && interpolate(path, vars);
     if (step.times === undefined)
         expect(stub).toHaveReceived(method ?? "*", p ?? /.*/, match);
@@ -311,6 +352,7 @@ function callVars(call) {
         headers: call.headers,
         json: call.json,
         body: call.body,
+        variables: call.graphql?.variables,
     };
 }
 function splitCall(s) {
@@ -406,7 +448,7 @@ function interpolateTitle(name, row, index) {
         return v === undefined ? m : typeof v === "object" ? JSON.stringify(v) : String(v);
     });
 }
-function verifyResponse(res, e, vars) {
+function verifyResponse(res, e, vars, base) {
     if (e?.status !== undefined)
         expect(res).toHaveStatus(interpolate(e.status, vars));
     if (e?.headers !== undefined) {
@@ -417,4 +459,9 @@ function verifyResponse(res, e, vars) {
         check(res.json, e.json, vars, "response JSON");
     if (e?.text !== undefined)
         check(res.text, e.text, vars, "response text");
+    if (e?.schema !== undefined) {
+        const problems = schemaProblems(e.schema, res.json, base);
+        if (problems.length)
+            throw new Error(`${res.method} ${res.url}: the response JSON doesn't match ${typeof e.schema === "string" ? e.schema : "the schema"}:\n${problems.map((p) => `  ${p}`).join("\n")}`);
+    }
 }

package/dist/yaml.d.ts

@@ -10,6 +10,11 @@ export interface YamlFile {
     path?: string;
     /** Steps run at the start of every scenario in the file. */
     setup: Step[];
+    /** Named step lists that `use:` steps run, with `with:` values for their `params`. */
+    define: Record<string, {
+        params: string[];
+        steps: Step[];
+    }>;
     scenarios: YamlScenario[];
 }
 export interface YamlScenario {
@@ -21,13 +26,27 @@ export interface YamlScenario {
     timeout?: number;
     steps: Step[];
 }
-export type Step = (StubStep | RequestStep | SubmitStep | InsertStep | MakeStep | ChaosStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep | MailStep) & {
+export type Step = (StubStep | RequestStep | SubmitStep | InsertStep | MakeStep | ChaosStep | SqlStep | DbStep | ReceivedStep | ChangesStep | CheckpointStep | LogStep | SnapshotStep | MailStep | UseStep) & {
     line: number;
     name?: string;
 };
+type GraphQLReply = {
+    data?: unknown;
+    errors?: (string | {
+        message: string;
+    })[];
+};
+/** Run the steps of a `define:` entry. Values in `with` become variables inside it; what it captures is visible afterwards. */
+export interface UseStep {
+    use: string;
+    with?: Record<string, unknown>;
+}
 export interface StubStep {
     stub: string;
-    on: string;
+    /** METHOD /path; or `graphql` instead. */
+    on?: string;
+    /** A GraphQL operation name, answered at any path. */
+    graphql?: string;
     when?: Conditions;
     /** `sse`: a streamed reply, a list of { event, data, id } (instead of `body`). */
     reply?: {
@@ -39,8 +58,8 @@ export interface StubStep {
             data: unknown;
             id?: string;
         }[];
-    };
-    sequence?: {
+    } & GraphQLReply;
+    sequence?: ({
         status?: number;
         headers?: Record<string, string>;
         body?: unknown;
@@ -49,16 +68,20 @@ export interface StubStep {
             data: unknown;
             id?: string;
         }[];
-    }[];
+    } & GraphQLReply)[];
     networkError?: boolean;
     times?: number;
     delay?: number;
+    /** The app may not call this route; `strictStubs` doesn't report it. */
+    optional?: boolean;
 }
 export interface Conditions {
     query?: Record<string, unknown>;
     headers?: Record<string, unknown>;
     json?: unknown;
     body?: unknown;
+    /** Subset of a GraphQL request's variables (with `graphql`). */
+    variables?: unknown;
 }
 export interface RequestStep {
     request: string;
@@ -67,6 +90,12 @@ export interface RequestStep {
     json?: unknown;
     form?: Record<string, unknown>;
     body?: string;
+    /** A GraphQL operation sent as the JSON body. */
+    graphql?: string | {
+        query: string;
+        variables?: Record<string, unknown>;
+        operationName?: 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>;
@@ -86,6 +115,7 @@ export interface RequestStep {
     /** 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. */
+    /** `schema`: a JSON Schema for the response JSON, inline or `file#/pointer` relative to the scenario file. */
     expect?: {
         status?: number;
         statuses?: Record<string, number>;
@@ -93,6 +123,7 @@ export interface RequestStep {
         json?: unknown;
         text?: unknown;
         queries?: number;
+        schema?: string | object;
     };
     capture?: Record<string, string>;
 }
@@ -113,6 +144,7 @@ export interface SubmitStep {
         headers?: Record<string, unknown>;
         json?: unknown;
         text?: unknown;
+        schema?: string | object;
     };
     capture?: Record<string, string>;
 }
@@ -164,6 +196,8 @@ export interface DbStep {
 export interface ReceivedStep {
     received: string;
     call?: string;
+    /** A GraphQL operation name, instead of `call`. */
+    graphql?: string;
     when?: Conditions;
     /** Exact number of matching calls. Default: at least one. */
     times?: number;
@@ -221,3 +255,4 @@ export interface MailStep {
 export declare class YamlScenarioError extends Error {
 }
 export declare function parseScenarioFile(text: string, file: string): YamlFile;
+export {};

package/dist/yaml.js

@@ -1,12 +1,12 @@
 import { isMap, isSeq, LineCounter, parseDocument } from "yaml";
 const KINDS = {
-    stub: ["on", "when", "reply", "sequence", "networkError", "times", "delay"],
-    request: ["headers", "query", "json", "form", "body", "follow", "auth", "webhook", "concurrency", "expect", "capture"],
+    stub: ["on", "graphql", "when", "reply", "sequence", "networkError", "times", "delay", "optional"],
+    request: ["headers", "query", "json", "form", "body", "graphql", "follow", "auth", "webhook", "concurrency", "expect", "capture"],
     submit: ["form", "fields", "headers", "follow", "expect", "capture"],
     insert: ["rows", "capture"],
     sql: ["params", "expect", "capture", "within"],
     db: ["where", "orderBy", "expect", "capture", "within"],
-    received: ["call", "when", "times", "within"],
+    received: ["call", "graphql", "when", "times", "within"],
     changes: ["within"],
     log: ["from", "within"],
     checkpoint: [],
@@ -14,19 +14,20 @@ const KINDS = {
     mail: ["times", "within", "capture"],
     make: ["rows", "count", "capture"],
     chaos: ["failFirst", "errorRate", "statuses", "networkErrorRate", "latency", "seed"],
+    use: ["with"],
 };
 const EXPECT_KEYS = {
-    request: ["status", "statuses", "headers", "json", "text", "queries"],
-    submit: ["status", "headers", "json", "text"],
+    request: ["status", "statuses", "headers", "json", "text", "queries", "schema"],
+    submit: ["status", "headers", "json", "text", "schema"],
     sql: ["rows", "count"],
     db: ["rows", "count"],
 };
-const CONDITION_KEYS = ["query", "headers", "json", "body"];
+const CONDITION_KEYS = ["query", "headers", "json", "body", "variables"];
 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", "sse"];
+const RESPONSE_KEYS = ["status", "headers", "body", "sse", "data", "errors"];
 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}}`. */
@@ -48,8 +49,8 @@ export function parseScenarioFile(text, file) {
         return fail(root, "expected a mapping with a `scenarios:` list");
     const top = doc.toJS();
     for (const key of Object.keys(top))
-        if (key !== "scenarios" && key !== "setup")
-            fail(root, `unknown top-level key "${key}" (expected scenarios, setup)`);
+        if (!["scenarios", "setup", "define"].includes(key))
+            fail(root, `unknown top-level key "${key}" (expected scenarios, setup, define)`);
     const stepsOf = (seqNode, what) => {
         if (!isSeq(seqNode))
             return fail(seqNode, `${what} must be a list of steps`);
@@ -59,9 +60,56 @@ export function parseScenarioFile(text, file) {
     if (!isSeq(scenariosNode) || scenariosNode.items.length === 0)
         return fail(scenariosNode ?? root, "`scenarios:` must be a non-empty list");
     const setupNode = root.get("setup", true);
-    return {
+    const define = {};
+    const defineNode = root.get("define", true);
+    if (defineNode !== undefined) {
+        if (!isMap(defineNode))
+            return fail(defineNode, "`define:` maps names to step lists, e.g. `define: { login: [ ...steps ] }`");
+        for (const pair of defineNode.items) {
+            const name = String(pair.key?.value ?? pair.key);
+            const value = pair.value;
+            if (isSeq(value)) {
+                define[name] = { params: [], steps: stepsOf(value, `define "${name}"`) };
+                continue;
+            }
+            if (!isMap(value))
+                return fail(value ?? pair.key, `define "${name}" must be a list of steps, or { params, steps }`);
+            const raw = value.toJSON();
+            for (const k of Object.keys(raw))
+                if (k !== "params" && k !== "steps")
+                    fail(value, `unknown key "${k}" in define "${name}" (allowed: params, steps)`);
+            if (raw.params !== undefined && !(Array.isArray(raw.params) && raw.params.every((p) => typeof p === "string" && p)))
+                fail(value.get("params", true) ?? value, "`params` must be a list of names, e.g. [email, password]");
+            define[name] = { params: raw.params ?? [], steps: stepsOf(value.get("steps", true), `define "${name}": steps`) };
+        }
+    }
+    // `use:` must name a definition and give it exactly its params; definitions can't use themselves.
+    const checkUses = (steps, chain) => {
+        for (const step of steps) {
+            if (!("use" in step))
+                continue;
+            const def = define[step.use];
+            const at = `${file}:${step.line}`;
+            if (!def)
+                throw new YamlScenarioError(`${at}: no definition "${step.use}" (defined: ${Object.keys(define).join(", ") || "none; add a top-level \`define:\`"})`);
+            if (chain.includes(step.use))
+                throw new YamlScenarioError(`${at}: "${step.use}" uses itself (${[...chain, step.use].join(" → ")})`);
+            const given = Object.keys(step.with ?? {});
+            const missing = def.params.filter((p) => !given.includes(p));
+            const extra = given.filter((g) => !def.params.includes(g));
+            if (missing.length)
+                throw new YamlScenarioError(`${at}: use ${step.use} needs \`with: { ${missing.join(", ")} }\``);
+            if (extra.length)
+                throw new YamlScenarioError(`${at}: "${extra.join('", "')}" ${extra.length > 1 ? "aren't params" : "isn't a param"} of ${step.use} (params: ${def.params.join(", ") || "none"})`);
+            checkUses(def.steps, [...chain, step.use]);
+        }
+    };
+    for (const [name, def] of Object.entries(define))
+        checkUses(def.steps, [name]);
+    const parsed = {
         file,
         setup: setupNode ? stepsOf(setupNode, "setup") : [],
+        define,
         scenarios: scenariosNode.items.map((node) => {
             if (!isMap(node))
                 return fail(node, "each scenario must be a mapping with `name` and `steps`");
@@ -87,6 +135,10 @@ export function parseScenarioFile(text, file) {
             };
         }),
     };
+    checkUses(parsed.setup, []);
+    for (const sc of parsed.scenarios)
+        checkUses(sc.steps, []);
+    return parsed;
 }
 function parseStep(node, fail, lineOf) {
     if (!isMap(node))
@@ -142,6 +194,12 @@ function parseStep(node, fail, lineOf) {
             }
         }
     }
+    else if (kind === "use") {
+        if (typeof raw.use !== "string" || !raw.use)
+            fail(at(kind), "`use:` names a step list from `define:`");
+        if (raw.with !== undefined && (!raw.with || typeof raw.with !== "object" || Array.isArray(raw.with)))
+            fail(at("with"), "`with` maps params to values, e.g. { email: a@b.test }");
+    }
     else if (kind === "checkpoint") {
         if (raw.checkpoint !== true)
             fail(at(kind), "use `checkpoint: true`");
@@ -183,11 +241,21 @@ function parseStep(node, fail, lineOf) {
     }
     if (kind in EXPECT_KEYS)
         keysOf("expect", EXPECT_KEYS[kind]);
+    {
+        const schema = raw.expect?.schema;
+        if (schema !== undefined && !((typeof schema === "string" && schema) || (schema && typeof schema === "object" && !Array.isArray(schema)))) {
+            fail(at("expect"), "`expect.schema` is a JSON Schema, or a file such as openapi.yaml#/components/schemas/Poll");
+        }
+    }
     keysOf("when", CONDITION_KEYS);
+    if (raw.graphql !== undefined && kind !== "request" && (typeof raw.graphql !== "string" || !raw.graphql))
+        fail(at("graphql"), "`graphql` is the operation's name, e.g. `graphql: GetUser`");
+    if (raw.when?.variables !== undefined && raw.graphql === undefined)
+        fail(at("when"), "`when.variables` needs `graphql: <operation>`");
     switch (kind) {
         case "stub": {
-            if (raw.on === undefined)
-                fail(node, "a stub step needs `on`, e.g. `on: POST /hook`");
+            if ((raw.on === undefined) === (raw.graphql === undefined))
+                fail(node, "a stub step needs one of `on` (e.g. `on: POST /hook`) or `graphql` (e.g. `graphql: GetUser`)");
             call("on");
             const answers = ["reply", "sequence", "networkError"].filter((k) => raw[k] !== undefined);
             if (answers.length !== 1)
@@ -196,7 +264,16 @@ function parseStep(node, fail, lineOf) {
             for (const [where, r] of [["reply", raw.reply], ...(Array.isArray(raw.sequence) ? raw.sequence : []).map((r) => ["sequence", r])]) {
                 if (!r || typeof r !== "object")
                     continue;
-                const { body, sse } = r;
+                const { body, sse, data, errors } = r;
+                if (data !== undefined || errors !== undefined) {
+                    if (raw.graphql === undefined)
+                        fail(at(where), "`data` and `errors` answer a GraphQL operation: use them with `graphql: <operation>`, or send `body`");
+                    if (body !== undefined || sse !== undefined)
+                        fail(at(where), "a GraphQL reply has `data` / `errors`, not `body` or `sse`");
+                    if (errors !== undefined && !(Array.isArray(errors) && errors.every((e) => typeof e === "string" || (e && typeof e === "object" && typeof e.message === "string")))) {
+                        fail(at(where), "`errors` must be a list of messages or { message, path, extensions }");
+                    }
+                }
                 if (sse === undefined)
                     continue;
                 if (body !== undefined)
@@ -209,12 +286,20 @@ function parseStep(node, fail, lineOf) {
                 fail(at("sequence"), "`sequence` must be a non-empty list of responses");
             number("times");
             number("delay");
+            if (raw.optional !== undefined && typeof raw.optional !== "boolean")
+                fail(at("optional"), "`optional` must be true or false");
             break;
         }
         case "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 (["json", "form", "body", "graphql"].filter((k) => raw[k] !== undefined).length > 1)
+                fail(node, "use only one of json / form / body / graphql");
+            if (raw.graphql !== undefined) {
+                const g = raw.graphql;
+                const ok = (typeof g === "string" && g.trim()) || (g && typeof g === "object" && !Array.isArray(g) && typeof g.query === "string" && Object.keys(g).every((k) => ["query", "variables", "operationName"].includes(k)));
+                if (!ok)
+                    fail(at("graphql"), "`graphql` is the query, or { query, variables, operationName }");
+            }
             if (raw.webhook !== undefined) {
                 const w = raw.webhook;
                 if (!w || typeof w !== "object" || Array.isArray(w))
@@ -296,6 +381,8 @@ function parseStep(node, fail, lineOf) {
             break;
         case "received":
             call("call");
+            if (raw.call !== undefined && raw.graphql !== undefined)
+                fail(node, "a received step takes `call` or `graphql`, not both");
             number("times");
             break;
         case "mail":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicetest",
-  "version": "0.6.0",
+  "version": "0.7.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",
@@ -19,6 +19,7 @@
     "language-agnostic",
     "openapi",
     "contract-testing",
+    "graphql",
     "jwt",
     "oidc",
     "webhooks",