@schmock/core 2.3.0 → 2.3.1

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

@@ -1,458 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock, toHttpMethod } from "../index";
-import type { CallableMockInstance } from "../types";
-
-const feature = await loadFeature("../../features/request-history.feature");
-
-interface HistoryTableRow {
-  field: string;
-  value: string;
-}
-
-function parseRequest(request: string): {
-  method: Schmock.HttpMethod;
-  path: string;
-} {
-  const separator = request.indexOf(" ");
-  const methodText = request.slice(0, separator);
-  const path = request.slice(separator + 1);
-  if (separator <= 0 || !path.startsWith("/")) {
-    throw new Error(`Expected request in METHOD /path format, got: ${request}`);
-  }
-  return { method: toHttpMethod(methodText), path };
-}
-
-function requireRecord(
-  value: unknown,
-  description: string,
-): Record<string, unknown> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`Expected ${description} to be an object`);
-  }
-  return Object.fromEntries(Object.entries(value));
-}
-
-function requireStringRecord(
-  value: unknown,
-  description: string,
-): Record<string, string> {
-  const record = requireRecord(value, description);
-  const strings: Record<string, string> = {};
-  for (const [key, entry] of Object.entries(record)) {
-    if (typeof entry !== "string") {
-      throw new Error(`Expected ${description}.${key} to be a string`);
-    }
-    strings[key] = entry;
-  }
-  return strings;
-}
-
-function parseJson(docString: string): unknown {
-  const parsed: unknown = JSON.parse(docString);
-  return parsed;
-}
-
-function parseRequestOptions(docString: string): Schmock.RequestOptions {
-  const parsed = requireRecord(parseJson(docString), "request options");
-  const options: Schmock.RequestOptions = {};
-  if (parsed.headers !== undefined) {
-    options.headers = requireStringRecord(parsed.headers, "request headers");
-  }
-  if (parsed.query !== undefined) {
-    options.query = requireStringRecord(parsed.query, "request query");
-  }
-  if ("body" in parsed) {
-    options.body = parsed.body;
-  }
-  return options;
-}
-
-function requireHistoryTable(table: unknown): HistoryTableRow[] {
-  if (!Array.isArray(table)) {
-    throw new Error("Expected request history table rows");
-  }
-  return table.map((candidate) => {
-    const row = requireRecord(candidate, "request history table row");
-    if (typeof row.field !== "string" || typeof row.value !== "string") {
-      throw new Error("Expected request history table field and value strings");
-    }
-    return { field: row.field, value: row.value };
-  });
-}
-
-function requestRecordField(
-  record: Schmock.RequestRecord,
-  field: string,
-): unknown {
-  switch (field) {
-    case "method":
-      return record.method;
-    case "path":
-      return record.path;
-    case "params":
-      return record.params;
-    case "query":
-      return record.query;
-    case "headers":
-      return record.headers;
-    case "body":
-      return record.body;
-    case "timestamp":
-      return record.timestamp;
-    case "response":
-      return record.response;
-    default:
-      throw new Error(`Unknown request record field: ${field}`);
-  }
-}
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: Schmock.Response;
-
-  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 } = parseRequest(request);
-      response = await mock.handle(method, path);
-    });
-
-    And(
-      "I request {string} with body:",
-      async (_, request: string, docString: string) => {
-        const { method, path } = parseRequest(request);
-        const body = parseJson(docString);
-        response = await mock.handle(method, path, { body });
-      },
-    );
-
-    And("I request {string}", async (_, request: string) => {
-      const { method, path } = parseRequest(request);
-      response = await mock.handle(method, 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 } = parseRequest(route);
-        expect(mock.callCount(method, path)).toBe(count);
-      },
-    );
-
-    And(
-      "the call count for {string} should be {int} request",
-      (_, route: string, count: number) => {
-        const { method, path } = parseRequest(route);
-        expect(mock.callCount(method, 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 } = parseRequest(request);
-        response = await mock.handle(method, path);
-      });
-
-      And(
-        "I request {string} with body:",
-        async (_, request: string, docString: string) => {
-          const { method, path } = parseRequest(request);
-          const body = parseJson(docString);
-          response = await mock.handle(method, path, { body });
-        },
-      );
-
-      And("I request {string}", async (_, request: string) => {
-        const { method, path } = parseRequest(request);
-        response = await mock.handle(method, path);
-      });
-
-      Then(
-        "the history for {string} should have {int} record",
-        (_, route: string, count: number) => {
-          const { method, path } = parseRequest(route);
-          expect(mock.history(method, path)).toHaveLength(count);
-        },
-      );
-
-      And(
-        "the history for {string} should have {int} record",
-        (_, route: string, count: number) => {
-          const { method, path } = parseRequest(route);
-          expect(mock.history(method, path)).toHaveLength(count);
-        },
-      );
-
-      And(
-        "the history for {string} should have {int} entry",
-        (_, route: string, count: number) => {
-          const { method, path } = parseRequest(route);
-          expect(mock.history(method, path)).toHaveLength(count);
-        },
-      );
-
-      And(
-        "the history for {string} should have {int} entries",
-        (_, route: string, count: number) => {
-          const { method, path } = parseRequest(route);
-          expect(mock.history(method, 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 } = parseRequest(request);
-        response = await mock.handle(method, path);
-      });
-
-      Then("{string} should have been called", (_, route: string) => {
-        const { method, path } = parseRequest(route);
-        expect(mock.called(method, path)).toBe(true);
-      });
-
-      And("{string} should not have been called", (_, route: string) => {
-        const { method, path } = parseRequest(route);
-        expect(mock.called(method, 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 }) => {
-          const requestBody = requireRecord(body, "request body");
-          return [200, { ...requestBody, id: params.id }];
-        });
-      });
-
-      When(
-        "I request {string} with headers and body:",
-        async (_, request: string, docString: string) => {
-          const { method, path } = parseRequest(request);
-          const options = parseRequestOptions(docString);
-          response = await mock.handle(method, path, options);
-        },
-      );
-
-      Then("the last request should have:", (_, table: unknown) => {
-        const record = mock.lastRequest();
-        if (!record) {
-          throw new Error("Expected a recorded request");
-        }
-        for (const row of requireHistoryTable(table)) {
-          expect(requestRecordField(record, row.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) => {
-          const record = mock.lastRequest();
-          if (!record) {
-            throw new Error("Expected a recorded request");
-          }
-          expect(requireRecord(record.body, "request body")[prop]).toBe(value);
-        },
-      );
-
-      And("the last request should have a timestamp", () => {
-        const record = mock.lastRequest();
-        if (!record) {
-          throw new Error("Expected a recorded request");
-        }
-        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 } = parseRequest(request);
-          const body = parseJson(docString);
-          response = await mock.handle(method, path, { body });
-        },
-      );
-
-      And(
-        "I request {string} with body:",
-        async (_, request: string, docString: string) => {
-          const { method, path } = parseRequest(request);
-          const body = parseJson(docString);
-          response = await mock.handle(method, 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 } = parseRequest(route);
-          const record = mock.lastRequest(method, path);
-          if (!record) {
-            throw new Error(`Expected a recorded request for ${route}`);
-          }
-          expect(requireRecord(record.body, "request body")[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 } = parseRequest(request);
-        response = await mock.handle(method, 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, And }) => {
-      Given(
-        "I create a mock with maxHistorySize {int} and a users route",
-        (_, maxHistorySize: number) => {
-          mock = schmock({ maxHistorySize });
-          mock("GET /users", []);
-        },
-      );
-
-      When(
-        "I issue {int} sequenced requests to {string}",
-        async (_, count: number, request: string) => {
-          const { method, path } = parseRequest(request);
-          for (let i = 0; i < count; i++) {
-            await mock.handle(method, path, {
-              query: { sequence: String(i + 1) },
-            });
-          }
-        },
-      );
-
-      Then("the call count should be {int}", (_, expected: number) => {
-        expect(mock.callCount()).toBe(expected);
-      });
-
-      And(
-        "the retained request sequence should be {string}",
-        (_, sequence: string) => {
-          expect(mock.history().map((record) => record.query.sequence)).toEqual(
-            sequence.split(","),
-          );
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Resetting history preserves routes and shared state",
-    ({ Given, When, Then, And }) => {
-      Given("I create a stateful mock and record a request", async () => {
-        mock = schmock({ state: { marker: "preserved" } });
-        mock("GET /stateful", ({ state }) => ({ marker: state.marker }));
-        await mock.handle("GET", "/stateful");
-        expect(mock.callCount()).toBe(1);
-      });
-
-      When("I reset only the request history", () => {
-        mock.resetHistory();
-      });
-
-      Then("the call count should be {int}", (_, expected: number) => {
-        expect(mock.callCount()).toBe(expected);
-      });
-
-      And("the registered route should still respond", async () => {
-        response = await mock.handle("GET", "/stateful");
-        expect(response.status).toBe(200);
-      });
-
-      And(
-        "the shared state marker should still be {string}",
-        (_, marker: string) => {
-          expect(mock.getState().marker).toBe(marker);
-        },
-      );
-    },
-  );
-});

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);
-    });
-  });
-});

package/src/steps/route-key-format.steps.ts

@@ -1,99 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import type { ParsedRoute } from "../parser";
-import { parseRouteKey } from "../parser";
-
-const feature = await loadFeature("../../features/route-key-format.feature");
-
-describeFeature(feature, ({ Scenario, ScenarioOutline }) => {
-  let result: ParsedRoute;
-  let error: Error | null = null;
-
-  ScenarioOutline(
-    "Valid route key formats",
-    ({ When, Then, And }, variables) => {
-      When("I parse route key {string}", () => {
-        error = null;
-        try {
-          result = parseRouteKey(variables.key);
-        } catch (e) {
-          error = e as Error;
-        }
-      });
-
-      Then("the method should be {string}", () => {
-        expect(error).toBeNull();
-        expect(result.method).toBe(variables.method);
-      });
-
-      And("the path should be {string}", () => {
-        expect(result.path).toBe(variables.path);
-      });
-    },
-  );
-
-  ScenarioOutline("Invalid route key formats", ({ When, Then }, variables) => {
-    When("I parse route key {string}", () => {
-      error = null;
-      try {
-        result = parseRouteKey(variables.key);
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("an error should be thrown with message matching {string}", () => {
-      expect(error).not.toBeNull();
-      expect(error!.message).toMatch(variables.error);
-    });
-  });
-
-  Scenario("Extract parameters from path", ({ When, Then, And }) => {
-    When("I parse route key {string}", (_, routeKey: string) => {
-      result = parseRouteKey(routeKey);
-    });
-
-    Then("the method should be {string}", (_, expectedMethod: string) => {
-      expect(result.method).toBe(expectedMethod);
-    });
-
-    And("the path should be {string}", (_, expectedPath: string) => {
-      expect(result.path).toBe(expectedPath);
-    });
-
-    And("the parameters should be:", (_, docString: string) => {
-      const expectedParams = JSON.parse(docString);
-      expect(result.params).toEqual(expectedParams);
-    });
-  });
-
-  Scenario("No parameters in simple path", ({ When, Then }) => {
-    When("I parse route key {string}", (_, routeKey: string) => {
-      result = parseRouteKey(routeKey);
-    });
-
-    Then("the parameters should be:", (_, docString: string) => {
-      const expectedParams = JSON.parse(docString);
-      expect(result.params).toEqual(expectedParams);
-    });
-  });
-
-  Scenario("Complex nested paths", ({ When, Then, And }) => {
-    When("I parse route key {string}", (_, routeKey: string) => {
-      result = parseRouteKey(routeKey);
-    });
-
-    Then("the method should be {string}", (_, expectedMethod: string) => {
-      expect(result.method).toBe(expectedMethod);
-    });
-
-    And("the path should be {string}", (_, expectedPath: string) => {
-      expect(result.path).toBe(expectedPath);
-    });
-
-    And("the parameters should be:", (_, docString: string) => {
-      const expectedParams = JSON.parse(docString);
-      expect(result.params).toEqual(expectedParams);
-    });
-  });
-});