@schmock/openapi 1.2.0 → 1.4.0

package/src/prefer.ts

@@ -0,0 +1,37 @@
+/// <reference path="../../core/schmock.d.ts" />
+
+interface PreferDirectives {
+  code?: number;
+  example?: string;
+  dynamic?: boolean;
+}
+
+/**
+ * Parse the RFC 7240 Prefer header for mock-specific directives.
+ * Supports: code=N, example=name, dynamic=true
+ */
+export function parsePreferHeader(value: string): PreferDirectives {
+  const result: PreferDirectives = {};
+
+  for (const part of value.split(",")) {
+    const trimmed = part.trim();
+
+    const codeMatch = trimmed.match(/^code\s*=\s*(\d+)$/);
+    if (codeMatch) {
+      result.code = Number(codeMatch[1]);
+      continue;
+    }
+
+    const exampleMatch = trimmed.match(/^example\s*=\s*(.+)$/);
+    if (exampleMatch) {
+      result.example = exampleMatch[1].trim();
+      continue;
+    }
+
+    if (trimmed === "dynamic=true" || trimmed === "dynamic") {
+      result.dynamic = true;
+    }
+  }
+
+  return result;
+}

package/src/seed.ts

@@ -1,4 +1,4 @@
-/// <reference path="../../../types/schmock.d.ts" />
+/// <reference path="../../core/schmock.d.ts" />
 
 import { readFileSync } from "node:fs";
 import type { CrudResource } from "./crud-detector.js";

package/src/steps/callback-mocking.steps.ts

@@ -0,0 +1,164 @@
+import { createServer } from "node:http";
+import type { Server } from "node:http";
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { schmock } from "@schmock/core";
+import { expect } from "vitest";
+import { openapi } from "../plugin";
+
+const feature = await loadFeature("../../features/callback-mocking.feature");
+
+function makeCallbackSpec(receiverPort: number): object {
+  return {
+    openapi: "3.0.3",
+    info: { title: "Test", version: "1.0.0" },
+    paths: {
+      "/orders": {
+        post: {
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    item: { type: "string" },
+                    callbackUrl: { type: "string" },
+                  },
+                },
+              },
+            },
+          },
+          responses: { "201": { description: "Created" } },
+          callbacks: {
+            orderStatus: {
+              "{$request.body#/callbackUrl}": {
+                post: {
+                  requestBody: {
+                    content: {
+                      "application/json": {
+                        schema: {
+                          type: "object",
+                          properties: {
+                            status: { type: "string" },
+                          },
+                        },
+                      },
+                    },
+                  },
+                  responses: { "200": { description: "OK" } },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  };
+}
+
+// No-port version for the "missing callback URL" scenario
+const specNoPort = {
+  openapi: "3.0.3",
+  info: { title: "Test", version: "1.0.0" },
+  paths: {
+    "/orders": {
+      post: {
+        requestBody: {
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  item: { type: "string" },
+                  callbackUrl: { type: "string" },
+                },
+              },
+            },
+          },
+        },
+        responses: { "201": { description: "Created" } },
+        callbacks: {
+          orderStatus: {
+            "{$request.body#/callbackUrl}": {
+              post: {
+                responses: { "200": { description: "OK" } },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+describeFeature(feature, ({ Scenario }) => {
+  Scenario("Callback fires after resource creation", ({ Given, When, Then, And }) => {
+    let mock: Schmock.CallableMockInstance;
+    let receiver: Server;
+    let receiverPort: number;
+    let receivedCallback: boolean;
+
+    Given("a mock with a spec defining a callback on POST", () => {
+      receivedCallback = false;
+    });
+
+    And("a callback receiver is listening", async () => {
+      await new Promise<void>((resolve) => {
+        receiver = createServer((req, res) => {
+          if (req.method === "POST") {
+            receivedCallback = true;
+          }
+          res.writeHead(200);
+          res.end();
+        });
+        receiver.listen(0, "127.0.0.1", () => {
+          const addr = receiver.address();
+          receiverPort = typeof addr === "object" && addr !== null ? addr.port : 0;
+          resolve();
+        });
+      });
+
+      mock = schmock({ state: {} });
+      const spec = makeCallbackSpec(receiverPort);
+      mock.pipe(await openapi({ spec }));
+    });
+
+    When("I create a resource with a callback URL", async () => {
+      await mock.handle("POST", "/orders", {
+        body: {
+          item: "widget",
+          callbackUrl: `http://127.0.0.1:${receiverPort}/webhook`,
+        },
+        headers: { "content-type": "application/json" },
+      });
+      // Wait a bit for fire-and-forget callback to arrive
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    });
+
+    Then("the callback receiver gets a POST request", () => {
+      receiver.close();
+      expect(receivedCallback).toBe(true);
+    });
+  });
+
+  Scenario("Missing callback URL is silently skipped", ({ Given, When, Then }) => {
+    let mock: Schmock.CallableMockInstance;
+    let response: Schmock.Response;
+
+    Given("a mock with a spec defining a callback on POST", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specNoPort }));
+    });
+
+    When("I create a resource without a callback URL", async () => {
+      response = await mock.handle("POST", "/orders", {
+        body: { item: "widget" },
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    Then("no error is raised", () => {
+      // Should not throw, and status should not be 500
+      expect(response.status).not.toBe(500);
+    });
+  });
+});

package/src/steps/content-negotiation.steps.ts

@@ -0,0 +1,107 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { schmock } from "@schmock/core";
+import { expect } from "vitest";
+import { openapi } from "../plugin";
+
+const feature = await loadFeature("../../features/content-negotiation.feature");
+
+const specWithJson = {
+  openapi: "3.0.3",
+  info: { title: "Test", version: "1.0.0" },
+  paths: {
+    "/items": {
+      get: {
+        responses: {
+          "200": {
+            description: "OK",
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: { id: { type: "integer" } },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+
+describeFeature(feature, ({ Scenario }) => {
+  let mock: Schmock.CallableMockInstance;
+  let response: Schmock.Response;
+
+  Scenario("JSON accepted returns 200", ({ Given, When, Then }) => {
+    Given("a mock with a spec defining JSON responses", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithJson }));
+    });
+
+    When('I request with Accept header "application/json"', async () => {
+      response = await mock.handle("GET", "/items", {
+        headers: { accept: "application/json" },
+      });
+    });
+
+    Then("the response status is 200", () => {
+      expect(response.status).toBe(200);
+    });
+  });
+
+  Scenario("Unsupported content type returns 406", ({ Given, When, Then, And }) => {
+    Given("a mock with a spec defining JSON responses", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithJson }));
+    });
+
+    When('I request with Accept header "application/xml"', async () => {
+      response = await mock.handle("GET", "/items", {
+        headers: { accept: "application/xml" },
+      });
+    });
+
+    Then("the response status is 406", () => {
+      expect(response.status).toBe(406);
+    });
+
+    And('the error body has an "acceptable" array', () => {
+      const body = response.body as Record<string, unknown>;
+      expect(Array.isArray(body.acceptable)).toBe(true);
+      expect(body.acceptable).toContain("application/json");
+    });
+  });
+
+  Scenario("Wildcard Accept passes through", ({ Given, When, Then }) => {
+    Given("a mock with a spec defining JSON responses", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithJson }));
+    });
+
+    When('I request with Accept header "*/*"', async () => {
+      response = await mock.handle("GET", "/items", {
+        headers: { accept: "*/*" },
+      });
+    });
+
+    Then("the response status is 200", () => {
+      expect(response.status).toBe(200);
+    });
+  });
+
+  Scenario("No Accept header defaults to success", ({ Given, When, Then }) => {
+    Given("a mock with a spec defining JSON responses", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithJson }));
+    });
+
+    When("I request without an Accept header", async () => {
+      response = await mock.handle("GET", "/items", { headers: {} });
+    });
+
+    Then("the response status is 200", () => {
+      expect(response.status).toBe(200);
+    });
+  });
+});

package/src/steps/errors-mode.steps.ts

@@ -0,0 +1,95 @@
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { schmock } from "@schmock/core";
+import { expect } from "vitest";
+import { openapi } from "../plugin";
+
+const feature = await loadFeature("../../features/errors-mode.feature");
+
+const specWithRequestBody = {
+  openapi: "3.0.3",
+  info: { title: "Test", version: "1.0.0" },
+  paths: {
+    "/items": {
+      get: {
+        responses: {
+          "200": { description: "List" },
+        },
+      },
+      post: {
+        requestBody: {
+          required: true,
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  name: { type: "string" },
+                  price: { type: "number" },
+                },
+                required: ["name", "price"],
+              },
+            },
+          },
+        },
+        responses: {
+          "201": { description: "Created" },
+        },
+      },
+    },
+    "/items/{itemId}": {
+      get: {
+        parameters: [{ name: "itemId", in: "path", required: true }],
+        responses: { "200": { description: "OK" } },
+      },
+    },
+  },
+};
+
+describeFeature(feature, ({ Scenario }) => {
+  let mock: Schmock.CallableMockInstance;
+  let response: Schmock.Response;
+
+  Scenario("Invalid request body returns 400 with validation errors", ({ Given, When, Then, And }) => {
+    Given("a mock with validateRequests enabled", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithRequestBody, validateRequests: true }));
+    });
+
+    When("I POST an invalid body to a route with a requestBody schema", async () => {
+      response = await mock.handle("POST", "/items", {
+        body: { name: 123 }, // name should be string, price missing
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    Then("the response status is 400", () => {
+      expect(response.status).toBe(400);
+    });
+
+    And('the error body has a "details" array', () => {
+      const body = response.body as Record<string, unknown>;
+      expect(body.code).toBe("VALIDATION_ERROR");
+      expect(Array.isArray(body.details)).toBe(true);
+      const details = body.details as unknown[];
+      expect(details.length).toBeGreaterThan(0);
+    });
+  });
+
+  Scenario("Valid request body passes through", ({ Given, When, Then }) => {
+    Given("a mock with validateRequests enabled", async () => {
+      mock = schmock({ state: {} });
+      mock.pipe(await openapi({ spec: specWithRequestBody, validateRequests: true }));
+    });
+
+    When("I POST a valid body to a route with a requestBody schema", async () => {
+      response = await mock.handle("POST", "/items", {
+        body: { name: "Widget", price: 9.99 },
+        headers: { "content-type": "application/json" },
+      });
+    });
+
+    Then("the response status is 201", () => {
+      expect(response.status).toBe(201);
+    });
+  });
+});