slicetest 0.4.0 → 0.6.0

package/dist/yaml.js

@@ -1,7 +1,8 @@
 import { isMap, isSeq, LineCounter, parseDocument } from "yaml";
 const KINDS = {
     stub: ["on", "when", "reply", "sequence", "networkError", "times", "delay"],
-    request: ["headers", "query", "json", "form", "body", "follow", "concurrency", "expect", "capture"],
+    request: ["headers", "query", "json", "form", "body", "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"],
@@ -11,16 +12,21 @@ const KINDS = {
     checkpoint: [],
     snapshot: ["mask"],
     mail: ["times", "within", "capture"],
+    make: ["rows", "count", "capture"],
+    chaos: ["failFirst", "errorRate", "statuses", "networkErrorRate", "latency", "seed"],
 };
 const EXPECT_KEYS = {
-    request: ["status", "statuses", "headers", "json", "text"],
+    request: ["status", "statuses", "headers", "json", "text", "queries"],
+    submit: ["status", "headers", "json", "text"],
     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 RESPONSE_KEYS = ["status", "headers", "body", "sse"];
 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}}`. */
@@ -120,6 +126,22 @@ function parseStep(node, fail, lineOf) {
             if (!MAIL_KEYS.includes(k))
                 fail(at(kind), `unknown key "${k}" in mail (allowed: ${MAIL_KEYS.join(", ")})`);
     }
+    else if (kind === "submit") {
+        if (raw.submit !== true && (typeof raw.submit !== "string" || !raw.submit.trim()))
+            fail(at(kind), "`submit:` names the button to press (its text), or is `true` for the form's only button");
+        if (raw.form !== undefined && !(typeof raw.form === "string" || (Number.isInteger(raw.form) && raw.form >= 0)))
+            fail(at("form"), "`form` is the form's id or name, or its position on the page (0 for the first)");
+        const fields = raw.fields;
+        if (fields !== undefined) {
+            if (!fields || typeof fields !== "object" || Array.isArray(fields))
+                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`);
+            }
+        }
+    }
     else if (kind === "checkpoint") {
         if (raw.checkpoint !== true)
             fail(at(kind), "use `checkpoint: true`");
@@ -171,6 +193,18 @@ function parseStep(node, fail, lineOf) {
             if (answers.length !== 1)
                 fail(node, "a stub step needs exactly one of reply / sequence / networkError");
             keysOf("reply", RESPONSE_KEYS);
+            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;
+                if (sse === undefined)
+                    continue;
+                if (body !== undefined)
+                    fail(at(where), "a reply has either `body` or `sse`, not both");
+                if (!Array.isArray(sse) || sse.some((e) => !e || typeof e !== "object" || Array.isArray(e) || !("data" in e) || Object.keys(e).some((k) => !["event", "data", "id"].includes(k)))) {
+                    fail(at(where), "`sse` must be a list of events such as { event: message_start, data: { ... } }");
+                }
+            }
             if (raw.sequence !== undefined && (!Array.isArray(raw.sequence) || raw.sequence.length === 0))
                 fail(at("sequence"), "`sequence` must be a non-empty list of responses");
             number("times");
@@ -181,8 +215,31 @@ function parseStep(node, fail, lineOf) {
             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");
             {
@@ -200,6 +257,33 @@ function parseStep(node, fail, lineOf) {
             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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicetest",
-  "version": "0.4.0",
+  "version": "0.6.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",
@@ -18,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": {
@@ -47,6 +53,7 @@
   },
   "files": [
     "dist",
+    "preload",
     "schema"
   ],
   "engines": {
@@ -60,9 +67,9 @@
     "prepublishOnly": "npm run typecheck && npm run build"
   },
   "peerDependencies": {
-    "vitest": ">=5",
+    "@testcontainers/mysql": ">=11",
     "mysql2": ">=3",
-    "@testcontainers/mysql": ">=11"
+    "vitest": ">=4"
   },
   "dependencies": {
     "@testcontainers/postgresql": "^12.2.0",
@@ -73,6 +80,7 @@
     "yaml": "^2.9.1"
   },
   "devDependencies": {
+    "@neondatabase/serverless": "^1.1.0",
     "@testcontainers/mysql": "^12.2.0",
     "@types/node": "^26.6.3",
     "@types/pg": "^8.23.1",

package/preload/node-proxy.cjs

@@ -0,0 +1,19 @@
+// Loaded into Node apps (NODE_OPTIONS=--require) while slicetest intercepts their outbound calls.
+// NODE_USE_ENV_PROXY covers fetch and the default agents; libraries that make their own
+// http(s).Agent (the Stripe SDK, many API clients) would otherwise go straight to the real
+// host. Agents made from here on get the proxy settings too, unless they set their own.
+"use strict";
+const http = require("node:http");
+const https = require("node:https");
+const { syncBuiltinESMExports } = require("node:module");
+
+for (const mod of [http, https]) {
+  const Original = mod.Agent;
+  class Agent extends Original {
+    constructor(options = {}) {
+      super({ proxyEnv: process.env, ...options });
+    }
+  }
+  mod.Agent = Agent;
+}
+syncBuiltinESMExports();

package/schema/scenario.schema.json

@@ -111,7 +111,33 @@
                 },
                 "body": {
                   "description": "String, or anything else to send as JSON. May use {{call.params.x}}, {{call.json.x}}, {{call.query.x}}"
+                },
+                "sse": {
+                  "type": "array",
+                  "description": "A streamed reply (Server-Sent Events), instead of body: a list of { event, data, id }. Data that isn't a string is sent as JSON",
+                  "items": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": [
+                      "data"
+                    ],
+                    "properties": {
+                      "event": {
+                        "type": "string"
+                      },
+                      "data": {},
+                      "id": {
+                        "type": "string"
+                      }
+                    }
+                  }
                 }
+              },
+              "not": {
+                "required": [
+                  "body",
+                  "sse"
+                ]
               }
             },
             "sequence": {
@@ -131,7 +157,33 @@
                   },
                   "body": {
                     "description": "String, or anything else to send as JSON. May use {{call.params.x}}, {{call.json.x}}, {{call.query.x}}"
+                  },
+                  "sse": {
+                    "type": "array",
+                    "description": "A streamed reply (Server-Sent Events), instead of body: a list of { event, data, id }. Data that isn't a string is sent as JSON",
+                    "items": {
+                      "type": "object",
+                      "additionalProperties": false,
+                      "required": [
+                        "data"
+                      ],
+                      "properties": {
+                        "event": {
+                          "type": "string"
+                        },
+                        "data": {},
+                        "id": {
+                          "type": "string"
+                        }
+                      }
+                    }
                   }
+                },
+                "not": {
+                  "required": [
+                    "body",
+                    "sse"
+                  ]
                 }
               },
               "minItems": 1
@@ -180,6 +232,81 @@
             "follow": {
               "type": "boolean"
             },
+            "auth": {
+              "description": "Send Authorization: Bearer with a token from the auth issuer: true, or the token's claims",
+              "oneOf": [
+                {
+                  "const": true
+                },
+                {
+                  "type": "object"
+                }
+              ]
+            },
+            "webhook": {
+              "type": "object",
+              "description": "Sign the body as this provider delivers webhooks",
+              "required": [
+                "provider",
+                "secret"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "provider": {
+                  "oneOf": [
+                    {
+                      "enum": [
+                        "stripe",
+                        "github",
+                        "slack",
+                        "shopify",
+                        "standard"
+                      ]
+                    },
+                    {
+                      "type": "object",
+                      "required": [
+                        "header"
+                      ],
+                      "additionalProperties": false,
+                      "properties": {
+                        "header": {
+                          "type": "string"
+                        },
+                        "algorithm": {
+                          "type": "string"
+                        },
+                        "encoding": {
+                          "enum": [
+                            "hex",
+                            "base64"
+                          ]
+                        },
+                        "prefix": {
+                          "type": "string"
+                        }
+                      }
+                    }
+                  ]
+                },
+                "secret": {
+                  "type": "string",
+                  "description": "The signing secret the app is configured with"
+                },
+                "event": {
+                  "type": "string",
+                  "description": "Event type, e.g. X-GitHub-Event"
+                },
+                "stale": {
+                  "type": "boolean",
+                  "description": "Signed ten minutes ago"
+                },
+                "invalidSignature": {
+                  "type": "boolean",
+                  "description": "Signed with a different secret"
+                }
+              }
+            },
             "concurrency": {
               "type": "integer",
               "minimum": 1,
@@ -212,6 +339,11 @@
                     "minimum": 0
                   },
                   "description": "With `concurrency`: how many responses have each status, e.g. { 201: 1, 409: 9 }"
+                },
+                "queries": {
+                  "type": "integer",
+                  "minimum": 0,
+                  "description": "At most this many SQL statements for this request, not counting BEGIN/COMMIT (needs db.queries)"
                 }
               }
             },
@@ -224,6 +356,94 @@
             }
           }
         },
+        {
+          "type": "object",
+          "required": [
+            "submit"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "submit": {
+              "oneOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "const": true
+                }
+              ],
+              "description": "Submit a form of the page the last request returned, as a browser with JavaScript off would (hidden fields such as CSRF tokens and Next.js server action ids included). Names the button to press by its text, value, name or id; `true` for the form's only button"
+            },
+            "name": {
+              "type": "string",
+              "description": "Label shown when this step fails"
+            },
+            "form": {
+              "type": [
+                "string",
+                "integer"
+              ],
+              "description": "The form by id, name or 0-based position, when the page has several"
+            },
+            "fields": {
+              "type": "object",
+              "description": "Values typed into the form by field name; true / false / a list of values check checkboxes and radios",
+              "additionalProperties": {
+                "oneOf": [
+                  {
+                    "type": [
+                      "string",
+                      "number",
+                      "boolean"
+                    ]
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": [
+                        "string",
+                        "number"
+                      ]
+                    }
+                  }
+                ]
+              }
+            },
+            "headers": {
+              "type": "object"
+            },
+            "follow": {
+              "type": "boolean"
+            },
+            "expect": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "status": {
+                  "type": [
+                    "integer",
+                    "string"
+                  ]
+                },
+                "headers": {
+                  "type": "object"
+                },
+                "json": {
+                  "description": "Subset of the response JSON"
+                },
+                "text": {}
+              }
+            },
+            "capture": {
+              "type": "object",
+              "description": "Save values as variables for later steps, e.g. { pollId: json.id }",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        },
         {
           "type": "object",
           "required": [
@@ -255,6 +475,106 @@
             }
           }
         },
+        {
+          "type": "object",
+          "required": [
+            "make"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "make": {
+              "type": "string",
+              "description": "Table to make rows in: required columns and parent rows are filled from the schema"
+            },
+            "name": {
+              "type": "string",
+              "description": "Label shown when this step fails"
+            },
+            "rows": {
+              "type": [
+                "object",
+                "array"
+              ],
+              "description": "Columns to set: a mapping, or a list of mappings for several rows"
+            },
+            "count": {
+              "type": "integer",
+              "minimum": 1,
+              "description": "Make this many rows, each with `rows`"
+            },
+            "capture": {
+              "type": "object",
+              "description": "Save values as variables for later steps, e.g. { orderId: row.id }",
+              "additionalProperties": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        {
+          "type": "object",
+          "required": [
+            "chaos"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "chaos": {
+              "type": "string",
+              "description": "Stub to inject faults into, for the rest of the scenario"
+            },
+            "name": {
+              "type": "string",
+              "description": "Label shown when this step fails"
+            },
+            "failFirst": {
+              "type": "integer",
+              "minimum": 0,
+              "description": "Fail the first n calls, then answer normally"
+            },
+            "errorRate": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1,
+              "description": "Share of calls answered with an error status"
+            },
+            "statuses": {
+              "type": "array",
+              "minItems": 1,
+              "items": {
+                "type": "integer",
+                "minimum": 400,
+                "maximum": 599
+              },
+              "description": "Error statuses to pick from (default 500, 502, 503)"
+            },
+            "networkErrorRate": {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 1,
+              "description": "Share of calls whose connection is dropped"
+            },
+            "latency": {
+              "oneOf": [
+                {
+                  "type": "number"
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "number"
+                  },
+                  "minItems": 2,
+                  "maxItems": 2
+                }
+              ],
+              "description": "Extra delay in ms, or [min, max]"
+            },
+            "seed": {
+              "type": "integer",
+              "description": "Seed for the random faults"
+            }
+          }
+        },
         {
           "type": "object",
           "required": [