@schmock/core 2.2.3 → 2.3.1

package/src/steps/plugin-integration.steps.ts

@@ -1,280 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-import type { CallableMockInstance } from "../types";
-
-const feature = await loadFeature("../../features/plugin-integration.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let requestResponses: any[] = [];
-
-  Scenario("Plugin state sharing with pipeline", ({ Given, When, Then, And }) => {
-    requestResponses = [];
-
-    Given("I create a mock with a counter plugin using route state", () => {
-      mock = schmock({ state: {} });
-      mock("GET /counter", null, { contentType: "application/json" }).pipe({
-        name: "counter-plugin",
-        process: (ctx, response) => {
-          const routeState = ctx.routeState!;
-          routeState.request_count =
-            ((routeState.request_count as number) || 0) + 1;
-
-          if (!response) {
-            return {
-              context: ctx,
-              response: {
-                request_number: routeState.request_count,
-                path: ctx.path,
-                processed_at: new Date().toISOString(),
-              },
-            };
-          }
-
-          return { context: ctx, response };
-        },
-      });
-    });
-
-    When("I request {string} three times", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      requestResponses = [];
-
-      for (let i = 0; i < 3; i++) {
-        const response = await mock.handle(method as any, path);
-        requestResponses.push(response);
-      }
-    });
-
-    Then(
-      "each response should have incrementing {string} values",
-      (_, property: string) => {
-        expect(requestResponses).toHaveLength(3);
-
-        for (let i = 0; i < requestResponses.length; i++) {
-          expect(requestResponses[i].body[property]).toBe(i + 1);
-        }
-      },
-    );
-
-    And(
-      "each response should have a {string} timestamp",
-      (_, property: string) => {
-        for (const response of requestResponses) {
-          expect(response.body[property]).toBeDefined();
-          expect(typeof response.body[property]).toBe("string");
-          expect(new Date(response.body[property]).getTime()).toBeGreaterThan(0);
-        }
-      },
-    );
-
-    And("the route state should persist across requests", () => {
-      const requestNumbers = requestResponses.map(
-        (r) => r.body.request_number,
-      );
-      expect(requestNumbers).toEqual([1, 2, 3]);
-    });
-  });
-
-  Scenario("Multiple plugins in pipeline", ({ Given, When, Then }) => {
-    Given("I create a mock with auth and wrapper plugins", () => {
-      mock = schmock({});
-      mock("GET /users", () => [{ id: 1, name: "John" }], {
-        contentType: "application/json",
-      })
-        .pipe({
-          name: "auth-plugin",
-          process: (ctx, response) => {
-            if (!ctx.headers.authorization) {
-              throw new Error("Missing authorization");
-            }
-            ctx.state.set("user", { id: 1, name: "Admin" });
-            return { context: ctx, response };
-          },
-        })
-        .pipe({
-          name: "wrapper-plugin",
-          process: (ctx, response) => {
-            if (response) {
-              return {
-                context: ctx,
-                response: {
-                  data: response,
-                  meta: {
-                    user: ctx.state.get("user"),
-                    timestamp: "2025-01-31T10:15:30.123Z",
-                  },
-                },
-              };
-            }
-            return { context: ctx, response };
-          },
-        });
-    });
-
-    When(
-      "I request {string} with headers:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const headers = JSON.parse(docString);
-        requestResponses = [
-          await mock.handle(method as any, path, { headers }),
-        ];
-      },
-    );
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(requestResponses[0].body).toEqual(expected);
-    });
-  });
-
-  Scenario("Plugin error handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an auth guard plugin", () => {
-      mock = schmock({});
-      mock("GET /protected", () => ({ secret: "data" }), {
-        contentType: "application/json",
-      }).pipe({
-        name: "auth-plugin",
-        process: (ctx, response) => {
-          if (!ctx.headers.authorization) {
-            return {
-              context: ctx,
-              response: [401, { error: "Unauthorized", code: "AUTH_REQUIRED" }],
-            };
-          }
-          return { context: ctx, response };
-        },
-      });
-    });
-
-    When(
-      "I request {string} without authorization",
-      async (_, request: string) => {
-        const [method, path] = request.split(" ");
-        requestResponses = [await mock.handle(method as any, path)];
-      },
-    );
-
-    Then("the status should be {int}", (_, status: number) => {
-      expect(requestResponses[0].status).toBe(status);
-    });
-
-    And("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(requestResponses[0].body).toEqual(expected);
-    });
-  });
-
-  Scenario(
-    "Pipeline order and response transformation",
-    ({ Given, When, Then }) => {
-      Given("I create a mock with three ordered step plugins", () => {
-        mock = schmock({});
-        mock("GET /data", () => ({ value: 42 }), {
-          contentType: "application/json",
-        })
-          .pipe({
-            name: "step-1",
-            process: (ctx, response) => {
-              ctx.state.set("step1", "processed");
-              if (response) {
-                return {
-                  context: ctx,
-                  response: { ...response, step1: "processed" },
-                };
-              }
-              return { context: ctx, response };
-            },
-          })
-          .pipe({
-            name: "step-2",
-            process: (ctx, response) => {
-              if (response) {
-                return {
-                  context: ctx,
-                  response: { ...response, step2: "processed" },
-                };
-              }
-              return { context: ctx, response };
-            },
-          })
-          .pipe({
-            name: "step-3",
-            process: (ctx, response) => {
-              if (response) {
-                return {
-                  context: ctx,
-                  response: { ...response, step3: "processed" },
-                };
-              }
-              return { context: ctx, response };
-            },
-          });
-      });
-
-      When("I request {string}", async (_, request: string) => {
-        const [method, path] = request.split(" ");
-        requestResponses = [await mock.handle(method as any, path)];
-      });
-
-      Then("I should receive:", (_, docString: string) => {
-        const expected = JSON.parse(docString);
-        expect(requestResponses[0].body).toEqual(expected);
-      });
-    },
-  );
-
-  Scenario("Schema plugin in pipeline", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a metadata wrapper plugin", () => {
-      mock = schmock({});
-      mock(
-        "GET /users",
-        () => [
-          { id: 1, name: "John Doe", email: "john@example.com" },
-          { id: 2, name: "Jane Smith", email: "jane@example.com" },
-        ],
-        { contentType: "application/json" },
-      ).pipe({
-        name: "add-metadata",
-        process: (ctx, response) => {
-          if (response && Array.isArray(response)) {
-            return {
-              context: ctx,
-              response: {
-                users: response,
-                count: response.length,
-                generated_at: new Date().toISOString(),
-              },
-            };
-          }
-          return { context: ctx, response };
-        },
-      });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      requestResponses = [await mock.handle(method as any, path)];
-    });
-
-    Then("the response should have a {string} array with {int} items", (_, property: string, count: number) => {
-      expect(requestResponses[0].body).toHaveProperty(property);
-      expect(Array.isArray(requestResponses[0].body[property])).toBe(true);
-      expect(requestResponses[0].body[property]).toHaveLength(count);
-    });
-
-    And("the response should have {string} equal to {int}", (_, property: string, value: number) => {
-      expect(requestResponses[0].body[property]).toBe(value);
-    });
-
-    And(
-      "the response should have a {string} timestamp",
-      (_, property: string) => {
-        expect(requestResponses[0].body).toHaveProperty(property);
-        expect(typeof requestResponses[0].body[property]).toBe("string");
-      },
-    );
-  });
-});

package/src/steps/request-history.steps.ts

@@ -1,276 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import type { CallableMockInstance } from "../types";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/request-history.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-
-  Scenario("Record multiple requests", ({ Given, When, And, Then }) => {
-    Given("I create a mock with GET and POST user routes", () => {
-      mock = schmock();
-      mock("GET /users", [{ id: 1 }]);
-      mock("POST /users", ({ body }) => [201, body]);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    And(
-      "I request {string} with body:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const body = JSON.parse(docString);
-        response = await mock.handle(method as any, path, { body });
-      },
-    );
-
-    And("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the call count should be 3", () => {
-      expect(mock.callCount()).toBe(3);
-    });
-
-    And(
-      "the call count for {string} should be {int}",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.callCount(method as any, path)).toBe(count);
-      },
-    );
-
-    And(
-      "the call count for {string} should be {int} request",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.callCount(method as any, path)).toBe(count);
-      },
-    );
-  });
-
-  Scenario("Filter history by method and path", ({ Given, When, And, Then }) => {
-    Given("I create a mock with users and posts routes", () => {
-      mock = schmock();
-      mock("GET /users", []);
-      mock("POST /users", ({ body }) => [201, body]);
-      mock("GET /posts", []);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    And(
-      "I request {string} with body:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const body = JSON.parse(docString);
-        response = await mock.handle(method as any, path, { body });
-      },
-    );
-
-    And("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then(
-      "the history for {string} should have {int} record",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.history(method as any, path)).toHaveLength(count);
-      },
-    );
-
-    And(
-      "the history for {string} should have {int} record",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.history(method as any, path)).toHaveLength(count);
-      },
-    );
-
-    And(
-      "the history for {string} should have {int} entry",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.history(method as any, path)).toHaveLength(count);
-      },
-    );
-
-    And(
-      "the history for {string} should have {int} entries",
-      (_, route: string, count: number) => {
-        const [method, path] = route.split(" ");
-        expect(mock.history(method as any, path)).toHaveLength(count);
-      },
-    );
-  });
-
-  Scenario("Check if specific route was called", ({ Given, When, Then, And }) => {
-    Given("I create a mock with users and posts list routes", () => {
-      mock = schmock();
-      mock("GET /users", []);
-      mock("GET /posts", []);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("{string} should have been called", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      expect(mock.called(method as any, path)).toBe(true);
-    });
-
-    And("{string} should not have been called", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      expect(mock.called(method as any, path)).toBe(false);
-    });
-  });
-
-  Scenario("Request record captures full details", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a parameterized POST route", () => {
-      mock = schmock();
-      mock("POST /users/:id", ({ params, body }) => [
-        200,
-        { ...(body as Record<string, unknown>), id: params.id },
-      ]);
-    });
-
-    When(
-      "I request {string} with headers and body:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const options = JSON.parse(docString);
-        response = await mock.handle(method as any, path, options);
-      },
-    );
-
-    Then("the last request should have:", (_, table: any) => {
-      const record = mock.lastRequest();
-      expect(record).toBeDefined();
-      for (const row of table) {
-        const field = row.field as keyof typeof record;
-        expect(record![field]).toBe(row.value);
-      }
-    });
-
-    And(
-      "the last request params should include {string} = {string}",
-      (_, key: string, value: string) => {
-        expect(mock.lastRequest()?.params[key]).toBe(value);
-      },
-    );
-
-    And(
-      "the last request headers should include {string} = {string}",
-      (_, key: string, value: string) => {
-        expect(mock.lastRequest()?.headers[key]).toBe(value);
-      },
-    );
-
-    And(
-      "the last request body should have property {string} with value {string}",
-      (_, prop: string, value: string) => {
-        expect((mock.lastRequest()?.body as any)?.[prop]).toBe(value);
-      },
-    );
-
-    And("the last request should have a timestamp", () => {
-      const record = mock.lastRequest();
-      expect(record?.timestamp).toBeDefined();
-      expect(typeof record?.timestamp).toBe("number");
-      expect(record!.timestamp).toBeGreaterThan(0);
-    });
-
-    And(
-      "the last request response status should be {int}",
-      (_, status: number) => {
-        expect(mock.lastRequest()?.response.status).toBe(status);
-      },
-    );
-  });
-
-  Scenario("Get last request for a specific route", ({ Given, When, And, Then }) => {
-    Given("I create a mock echoing POST body at {string}", (_, path: string) => {
-      mock = schmock();
-      mock(`POST ${path}`, ({ body }) => [201, body]);
-    });
-
-    When(
-      "I request {string} with body:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const body = JSON.parse(docString);
-        response = await mock.handle(method as any, path, { body });
-      },
-    );
-
-    And(
-      "I request {string} with body:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const body = JSON.parse(docString);
-        response = await mock.handle(method as any, path, { body });
-      },
-    );
-
-    Then(
-      "the last request for {string} body should have property {string} with value {string}",
-      (_, route: string, prop: string, value: string) => {
-        const [method, path] = route.split(" ");
-        const record = mock.lastRequest(method as any, path);
-        expect((record?.body as any)?.[prop]).toBe(value);
-      },
-    );
-  });
-
-  Scenario("404 requests are not recorded in history", ({ Given, When, Then, And }) => {
-    Given("I create a mock with only a users route", () => {
-      mock = schmock();
-      mock("GET /users", []);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the mock should not have been called", () => {
-      expect(mock.called()).toBe(false);
-    });
-
-    And("the call count should be 0", () => {
-      expect(mock.callCount()).toBe(0);
-    });
-  });
-
-  Scenario("maxHistorySize bounds the history with FIFO eviction", ({ Given, When, Then }) => {
-    Given("I create a mock with maxHistorySize {int} and a users route", (_, maxHistorySize: number) => {
-      mock = schmock({ maxHistorySize });
-      mock("GET /users", []);
-    });
-
-    When("I issue {int} requests to {string}", async (_, count: number, request: string) => {
-      const [method, path] = request.split(" ");
-      for (let i = 0; i < count; i++) {
-        await mock.handle(method as any, path);
-      }
-    });
-
-    Then("the call count should be {int}", (_, expected: number) => {
-      expect(mock.callCount()).toBe(expected);
-    });
-  });
-});

package/src/steps/response-delay.steps.ts

@@ -1,88 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/response-delay.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let elapsed: number;
-  let elapsed2: number;
-
-  Scenario("Route delay overrides global delay", ({ Given, And, When, Then }) => {
-    Given("a mock with global delay of 200ms", () => {
-      mock = schmock({ delay: 200, state: {} });
-    });
-
-    And('a route "GET /fast" with delay of 10ms', () => {
-      mock("GET /fast", { ok: true }, { delay: 10 });
-    });
-
-    And('a route "GET /default" with no delay override', () => {
-      mock("GET /default", { ok: true }, {});
-    });
-
-    When('I request "GET /fast"', async () => {
-      const start = performance.now();
-      await mock.handle("GET", "/fast");
-      elapsed = performance.now() - start;
-    });
-
-    // Upper bound is intentionally generous: it only needs to prove the 10ms
-    // route delay was used instead of the 200ms global. A tight bound here
-    // flakes under CI load (a single timer can be delayed tens of ms).
-    Then("the response took less than 150ms", () => {
-      expect(elapsed).toBeLessThan(150);
-    });
-
-    When('I request "GET /default" with timing', async () => {
-      const start = performance.now();
-      await mock.handle("GET", "/default");
-      elapsed2 = performance.now() - start;
-    });
-
-    Then("that response took at least 150ms", () => {
-      expect(elapsed2).toBeGreaterThanOrEqual(150);
-    });
-  });
-
-  Scenario("Route delay supports random range", ({ Given, And, When, Then }) => {
-    Given("a mock with no global delay", () => {
-      mock = schmock({ state: {} });
-    });
-
-    And('a route "GET /random" with delay range 10 to 30', () => {
-      mock("GET /random", { ok: true }, { delay: [10, 30] });
-    });
-
-    When('I request "GET /random"', async () => {
-      const start = performance.now();
-      await mock.handle("GET", "/random");
-      elapsed = performance.now() - start;
-    });
-
-    Then("the response took at least 8ms", () => {
-      expect(elapsed).toBeGreaterThanOrEqual(8);
-    });
-  });
-
-  Scenario("No route delay inherits global delay", ({ Given, And, When, Then }) => {
-    Given("a mock with global delay of 50ms", () => {
-      mock = schmock({ delay: 50, state: {} });
-    });
-
-    And('a route "GET /items" with no delay override', () => {
-      mock("GET /items", { ok: true }, {});
-    });
-
-    When('I request "GET /items" with timing', async () => {
-      const start = performance.now();
-      await mock.handle("GET", "/items");
-      elapsed = performance.now() - start;
-    });
-
-    Then("that response took at least 40ms", () => {
-      expect(elapsed).toBeGreaterThanOrEqual(40);
-    });
-  });
-});