slicetest 0.7.0 → 0.9.0

package/dist/yaml.js

@@ -1,15 +1,18 @@
 import { isMap, isSeq, LineCounter, parseDocument } from "yaml";
+import { WEBHOOK_PROVIDERS as PROVIDERS } from "./webhook.js";
 const KINDS = {
     stub: ["on", "graphql", "when", "reply", "sequence", "networkError", "times", "delay", "optional"],
-    request: ["headers", "query", "json", "form", "body", "graphql", "follow", "auth", "webhook", "concurrency", "expect", "capture"],
+    request: ["headers", "query", "json", "form", "multipart", "body", "graphql", "follow", "auth", "webhook", "concurrency", "expect", "capture", "within", "every", "timeout"],
     submit: ["form", "fields", "headers", "follow", "expect", "capture"],
     insert: ["rows", "capture"],
     sql: ["params", "expect", "capture", "within"],
     db: ["where", "orderBy", "expect", "capture", "within"],
     received: ["call", "graphql", "when", "times", "within"],
-    changes: ["within"],
+    changes: ["within", "ignore"],
     log: ["from", "within"],
     checkpoint: [],
+    set: [],
+    order: ["within"],
     snapshot: ["mask"],
     mail: ["times", "within", "capture"],
     make: ["rows", "count", "capture"],
@@ -17,18 +20,18 @@ const KINDS = {
     use: ["with"],
 };
 const EXPECT_KEYS = {
-    request: ["status", "statuses", "headers", "json", "text", "queries", "schema"],
-    submit: ["status", "headers", "json", "text", "schema"],
+    request: ["status", "statuses", "headers", "json", "text", "queries", "schema", "duration", "cookies", "events"],
+    submit: ["status", "headers", "json", "text", "schema", "duration", "cookies", "events"],
     sql: ["rows", "count"],
     db: ["rows", "count"],
 };
-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 CONDITION_KEYS = ["query", "headers", "json", "form", "body", "variables"];
+const WEBHOOK_KEYS = ["provider", "secret", "event", "stale", "invalidSignature", "url"];
+const WEBHOOK_PROVIDERS = PROVIDERS;
 const MAIL_KEYS = ["to", "from", "subject", "text", "html"];
 const CHANGE_KEYS = ["inserted", "updated", "deleted"];
-const RESPONSE_KEYS = ["status", "headers", "body", "sse", "data", "errors"];
-const SCENARIO_KEYS = ["name", "steps", "each", "skip", "only", "timeout"];
+const RESPONSE_KEYS = ["status", "headers", "body", "file", "sse", "data", "errors"];
+const SCENARIO_KEYS = ["name", "steps", "each", "skip", "only", "timeout", "tags"];
 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*)$/;
@@ -124,6 +127,9 @@ export function parseScenarioFile(text, file) {
             }
             if (raw.timeout !== undefined && typeof raw.timeout !== "number")
                 fail(node, "`timeout` must be a number of milliseconds");
+            if (raw.tags !== undefined && !(Array.isArray(raw.tags) && raw.tags.every((t) => typeof t === "string" && /^[^\s,!]+$/.test(t)))) {
+                fail(node.get("tags", true), "`tags` must be a list of words without spaces, commas or `!`, e.g. [smoke, payments]");
+            }
             return {
                 name: raw.name,
                 line: lineOf(node),
@@ -131,6 +137,7 @@ export function parseScenarioFile(text, file) {
                 skip: raw.skip === true,
                 only: raw.only === true,
                 timeout: raw.timeout,
+                tags: raw.tags,
                 steps: stepsOf(node.get("steps", true), `scenario "${raw.name}": steps`),
             };
         }),
@@ -156,6 +163,8 @@ function parseStep(node, fail, lineOf) {
             fail(at(key), `unknown key "${key}" in a ${kind} step (allowed: ${[...allowed].join(", ")})`);
     }
     if (kind === "changes") {
+        if (raw.ignore !== undefined && !(Array.isArray(raw.ignore) && raw.ignore.every((c) => typeof c === "string" && c)))
+            fail(at("ignore"), "`ignore` must be a list of columns or tables, e.g. [updated_at, sessions.*]");
         const tables = raw.changes;
         if (!tables || typeof tables !== "object" || Array.isArray(tables))
             fail(at(kind), "`changes:` must map table names to { inserted, updated, deleted }");
@@ -189,8 +198,9 @@ function parseStep(node, fail, lineOf) {
                 fail(at("fields"), "`fields` must map field names to values, e.g. { email: a@b.test }");
             for (const [k, v] of Object.entries(fields)) {
                 const scalar = (x) => typeof x === "string" || typeof x === "number";
-                if (!(scalar(v) || typeof v === "boolean" || (Array.isArray(v) && v.every(scalar))))
-                    fail(at("fields"), `field "${k}" must be a string, number, true / false or a list`);
+                const isFile = !!v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).every((x) => ["file", "content", "filename", "type"].includes(x)) && ("file" in v) !== ("content" in v);
+                if (!(scalar(v) || typeof v === "boolean" || (Array.isArray(v) && v.every(scalar)) || isFile))
+                    fail(at("fields"), `field "${k}" must be a string, number, true / false, a list, or a file ({ file: path } or { content, filename })`);
             }
         }
     }
@@ -200,6 +210,42 @@ function parseStep(node, fail, lineOf) {
         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 === "order") {
+        const list = raw.order;
+        if (!Array.isArray(list) || list.length < 2)
+            fail(at(kind), "`order:` lists at least two calls, e.g. [\"stripe POST /v1/charges\", \"mail POST /send\"]");
+        for (const item of list) {
+            if (typeof item === "string") {
+                if (!/^\S+\s+([A-Za-z]+|\*)\s+\/\S*$/.test(item))
+                    fail(at(kind), `"${item}" should be "<stub> METHOD /path", e.g. "mail POST /send"`);
+                continue;
+            }
+            if (!item || typeof item !== "object" || Array.isArray(item))
+                fail(at(kind), "each `order` entry is \"<stub> METHOD /path\" or { stub, call, when }");
+            const o = item;
+            for (const k of Object.keys(o))
+                if (!["stub", "call", "when"].includes(k))
+                    fail(at(kind), `unknown key "${k}" in an order entry (allowed: stub, call, when)`);
+            if (typeof o.stub !== "string" || !o.stub)
+                fail(at(kind), "an order entry needs `stub`");
+            if (typeof o.call !== "string" || !CALL.test(o.call))
+                fail(at(kind), `an order entry's \`call\` must look like "POST /path", got ${JSON.stringify(o.call)}`);
+            if (o.when !== undefined) {
+                if (!o.when || typeof o.when !== "object" || Array.isArray(o.when))
+                    fail(at(kind), "`when` in an order entry must be a mapping");
+                for (const k of Object.keys(o.when))
+                    if (!CONDITION_KEYS.includes(k))
+                        fail(at(kind), `unknown key "${k}" in when (allowed: ${CONDITION_KEYS.join(", ")})`);
+            }
+        }
+    }
+    else if (kind === "set") {
+        if (!raw.set || typeof raw.set !== "object" || Array.isArray(raw.set) || Object.keys(raw.set).length === 0)
+            fail(at(kind), "`set:` maps variable names to values, e.g. { orderId: \"{{$uuid}}\" }");
+        for (const k of Object.keys(raw.set))
+            if (!/^[A-Za-z_][\w]*$/.test(k))
+                fail(at(kind), `"${k}" isn't a variable name (letters, digits and _)`);
+    }
     else if (kind === "checkpoint") {
         if (raw.checkpoint !== true)
             fail(at(kind), "use `checkpoint: true`");
@@ -229,6 +275,18 @@ function parseStep(node, fail, lineOf) {
     };
     if (raw.within !== undefined && (typeof raw.within !== "number" || raw.within <= 0))
         fail(at("within"), "`within` must be a positive number of milliseconds");
+    const events = raw.expect?.events;
+    if (events !== undefined && !(Array.isArray(events) && events.every((e) => e && typeof e === "object" && !Array.isArray(e)))) {
+        fail(at("expect"), "`expect.events` is a list of events, each a subset of { event, data, id }: [{ event: message_stop }]");
+    }
+    const cookies = raw.expect?.cookies;
+    if (cookies !== undefined && (!cookies || typeof cookies !== "object" || Array.isArray(cookies) || Object.values(cookies).some((c) => c !== null && (typeof c !== "object" || Array.isArray(c))))) {
+        fail(at("expect"), "`expect.cookies` maps cookie names to attributes ({ sid: { httpOnly: true } }), {} for any value, or null for a cookie that must not be set");
+    }
+    const duration = raw.expect?.duration;
+    if (duration !== undefined && !((typeof duration === "number" && duration > 0) || (duration && typeof duration === "object" && !Array.isArray(duration)))) {
+        fail(at("expect"), "`expect.duration` is a number of milliseconds (at most), or a matcher such as { $lt: 200 }");
+    }
     const number = (key) => {
         if (raw[key] !== undefined && (typeof raw[key] !== "number" || raw[key] < 0))
             fail(at(key), `\`${key}\` must be a non-negative number`);
@@ -264,7 +322,13 @@ 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, data, errors } = r;
+                const { body, sse, data, errors, file } = r;
+                if (file !== undefined) {
+                    if (typeof file !== "string" || !file)
+                        fail(at(where), "`file` is a path relative to the scenario file, e.g. fixtures/charge.json");
+                    if (body !== undefined || sse !== undefined || data !== undefined || errors !== undefined)
+                        fail(at(where), "a reply has `file` instead of `body`, `sse`, `data` or `errors`");
+                }
                 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`");
@@ -292,8 +356,27 @@ function parseStep(node, fail, lineOf) {
         }
         case "request":
             call("request", REQUEST);
-            if (["json", "form", "body", "graphql"].filter((k) => raw[k] !== undefined).length > 1)
-                fail(node, "use only one of json / form / body / graphql");
+            if (["json", "form", "multipart", "body", "graphql"].filter((k) => raw[k] !== undefined).length > 1)
+                fail(node, "use only one of json / form / multipart / body / graphql");
+            if (raw.multipart !== undefined) {
+                const m = raw.multipart;
+                if (!m || typeof m !== "object" || Array.isArray(m))
+                    fail(at("multipart"), "`multipart` maps field names to values, e.g. { name: ada, avatar: { file: ada.png } }");
+                for (const [k, v] of Object.entries(m)) {
+                    for (const part of Array.isArray(v) ? v : [v]) {
+                        if (part && typeof part === "object") {
+                            const keys = Object.keys(part);
+                            const bad = keys.find((x) => !["file", "content", "filename", "type"].includes(x));
+                            if (bad)
+                                fail(at("multipart"), `unknown key "${bad}" in multipart field "${k}" (allowed: file, content, filename, type)`);
+                            if (("file" in part) === ("content" in part))
+                                fail(at("multipart"), `multipart field "${k}" needs one of \`file\` (a path relative to the scenario file) or \`content\``);
+                        }
+                        else if (part === null)
+                            fail(at("multipart"), `multipart field "${k}" has no value`);
+                    }
+                }
+            }
             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)));
@@ -318,6 +401,14 @@ function parseStep(node, fail, lineOf) {
                 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");
+            if (raw.timeout !== undefined && !(typeof raw.timeout === "number" && raw.timeout > 0))
+                fail(at("timeout"), "`timeout` must be a positive number of milliseconds");
+            if (raw.every !== undefined && !(typeof raw.every === "number" && raw.every > 0))
+                fail(at("every"), "`every` must be a positive number of milliseconds");
+            if (raw.every !== undefined && raw.within === undefined)
+                fail(at("every"), "`every` sets the pause between attempts of a `within` step; add `within: <ms>`");
+            if (raw.within !== undefined && raw.concurrency !== undefined)
+                fail(at("within"), "`within` repeats one request until it passes; it can't be combined with `concurrency`");
             {
                 const q = raw.expect?.queries;
                 if (q !== undefined && !(Number.isInteger(q) && q >= 0))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicetest",
-  "version": "0.7.0",
+  "version": "0.9.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",