@schmock/core 2.3.0 → 2.4.0

package/src/steps/standalone-server.steps.ts

@@ -1,227 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/standalone-server.feature");
-
-describeFeature(feature, ({ Scenario, AfterEachScenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let serverInfo: Schmock.ServerInfo;
-  let httpResponse: Response;
-
-  AfterEachScenario(() => {
-    mock?.close();
-  });
-
-  function baseUrl(): string {
-    return `http://${serverInfo.hostname}:${serverInfo.port}`;
-  }
-
-  Scenario("Start and stop a simple server", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a GET /hello route", () => {
-      mock = schmock();
-      mock("GET /hello", { message: "hello" });
-    });
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    Then("the server should be running", () => {
-      expect(serverInfo.port).toBeGreaterThan(0);
-    });
-
-    When("I fetch {string} from the server", async (_, route: string) => {
-      const [, path] = route.split(" ");
-      httpResponse = await fetch(`${baseUrl()}${path}`);
-    });
-
-    Then("the HTTP response status should be {int}", (_, status: number) => {
-      expect(httpResponse.status).toBe(status);
-    });
-
-    And(
-      "the HTTP response body should have {string} equal to {string}",
-      async (_, key: string, value: string) => {
-        const body = await httpResponse.json();
-        expect(body[key]).toBe(value);
-      },
-    );
-
-    When("I stop the server", () => {
-      mock.close();
-    });
-
-    Then("the server should not be running", async () => {
-      await expect(fetch(`${baseUrl()}/hello`)).rejects.toBeDefined();
-    });
-  });
-
-  Scenario("Handle POST with JSON body", ({ Given, When, Then, And }) => {
-    Given("I create a mock echoing POST at {string}", (_, path: string) => {
-      mock = schmock();
-      mock(`POST ${path}`, ({ body }) => body);
-    });
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    And(
-      "I fetch {string} with JSON body:",
-      async (_, route: string, docString: string) => {
-        const [method, path] = route.split(" ");
-        httpResponse = await fetch(`${baseUrl()}${path}`, {
-          method,
-          headers: { "content-type": "application/json" },
-          body: docString,
-        });
-      },
-    );
-
-    Then(
-      "the response status from POST should be {int}",
-      (_, status: number) => {
-        expect(httpResponse.status).toBe(status);
-      },
-    );
-
-    And(
-      "the response body from POST should have {string} equal to {string}",
-      async (_, key: string, value: string) => {
-        const body = await httpResponse.json();
-        expect(body[key]).toBe(value);
-      },
-    );
-
-    When("I stop the server", () => {
-      mock.close();
-    });
-  });
-
-  Scenario(
-    "Return 404 for unregistered routes",
-    ({ Given, When, And, Then }) => {
-      Given("I create a mock with a GET /hello route", () => {
-        mock = schmock();
-        mock("GET /hello", { message: "hello" });
-      });
-
-      When("I start the server on a random port", async () => {
-        serverInfo = await mock.listen(0);
-      });
-
-      And("I fetch {string} from the server", async (_, route: string) => {
-        const [, path] = route.split(" ");
-        httpResponse = await fetch(`${baseUrl()}${path}`);
-      });
-
-      Then("the HTTP response status should be {int}", (_, status: number) => {
-        expect(httpResponse.status).toBe(status);
-      });
-
-      When("I stop the server", () => {
-        mock.close();
-      });
-    },
-  );
-
-  Scenario("Query parameters are forwarded", ({ Given, When, And, Then }) => {
-    let parsedBody: Record<string, string>;
-
-    Given(
-      "I create a mock reflecting query params at {string}",
-      (_, route: string) => {
-        const [method, path] = route.split(" ");
-        mock = schmock();
-        mock(`${method} ${path}` as Schmock.RouteKey, ({ query }) => query);
-      },
-    );
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    And("I fetch {string} from the server", async (_, route: string) => {
-      const [, pathWithQuery] = route.split(" ");
-      httpResponse = await fetch(`${baseUrl()}${pathWithQuery}`);
-      parsedBody = await httpResponse.json();
-    });
-
-    Then("the HTTP response status should be {int}", (_, status: number) => {
-      expect(httpResponse.status).toBe(status);
-    });
-
-    And(
-      "the HTTP response body should have {string} equal to {string}",
-      (_, key: string, value: string) => {
-        expect(parsedBody[key]).toBe(value);
-      },
-    );
-
-    And(
-      "the query param {string} should equal {string}",
-      (_, key: string, value: string) => {
-        expect(parsedBody[key]).toBe(value);
-      },
-    );
-
-    When("I stop the server", () => {
-      mock.close();
-    });
-  });
-
-  Scenario("Double listen throws an error", ({ Given, When, Then }) => {
-    Given("I create a mock with a GET /hello route", () => {
-      mock = schmock();
-      mock("GET /hello", { message: "hello" });
-    });
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    Then("starting the server again should throw", () => {
-      expect(() => mock.listen(0)).toThrow("Server is already running");
-      mock.close();
-    });
-  });
-
-  Scenario("Close is idempotent", ({ Given, When, And, Then }) => {
-    Given("I create a mock with a GET /hello route", () => {
-      mock = schmock();
-      mock("GET /hello", { message: "hello" });
-    });
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    And("I stop the server", () => {
-      mock.close();
-    });
-
-    Then("stopping the server again should not throw", () => {
-      expect(() => mock.close()).not.toThrow();
-    });
-  });
-
-  Scenario("Reset stops the server", ({ Given, When, And, Then }) => {
-    Given("I create a mock with a GET /hello route", () => {
-      mock = schmock();
-      mock("GET /hello", { message: "hello" });
-    });
-
-    When("I start the server on a random port", async () => {
-      serverInfo = await mock.listen(0);
-    });
-
-    And("I reset the mock", () => {
-      mock.reset();
-    });
-
-    Then("the server should not be running", async () => {
-      await expect(fetch(`${baseUrl()}/hello`)).rejects.toBeDefined();
-    });
-  });
-});

package/src/steps/state-concurrency.steps.ts

@@ -1,167 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/state-concurrency.feature");
-
-function readCounter(state: Record<string, unknown>): number {
-  const counter = state.counter;
-  if (typeof counter !== "number") throw new Error("Counter state is invalid");
-  return counter;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function responseRecord(response: Schmock.Response): Record<string, unknown> {
-  if (!isRecord(response.body)) {
-    throw new Error("Expected an object response");
-  }
-  return response.body;
-}
-
-function withTimeout(
-  promise: Promise<void>,
-  timeoutMs: number,
-  message: string,
-): Promise<void> {
-  let timeoutId: ReturnType<typeof setTimeout> | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timeoutId = setTimeout(() => reject(new Error(message)), timeoutMs);
-  });
-
-  return Promise.race([promise, timeout]).finally(() => {
-    if (timeoutId !== undefined) clearTimeout(timeoutId);
-  });
-}
-
-describeFeature(feature, ({ Scenario }) => {
-  let firstMock: Schmock.CallableMockInstance;
-  let secondMock: Schmock.CallableMockInstance;
-  let firstResponse: Schmock.Response;
-  let secondResponse: Schmock.Response;
-  let concurrentResponses: Schmock.Response[] = [];
-  let expectedConcurrentCount = 0;
-
-  Scenario(
-    "Different mock instances keep independent route state",
-    ({ Given, When, Then, And }) => {
-      Given("I create two mocks with different counter state", () => {
-        firstMock = schmock({ state: { counter: 0 } });
-        secondMock = schmock({ state: { counter: 100 } });
-
-        const registerIncrement = (mock: Schmock.CallableMockInstance) => {
-          mock("POST /increment", ({ state }) => {
-            const next = readCounter(state) + 1;
-            state.counter = next;
-            return { counter: next };
-          });
-        };
-        registerIncrement(firstMock);
-        registerIncrement(secondMock);
-      });
-
-      When("I increment both mocks concurrently", async () => {
-        [firstResponse, secondResponse] = await Promise.all([
-          firstMock.handle("POST", "/increment"),
-          secondMock.handle("POST", "/increment"),
-        ]);
-      });
-
-      Then("the first mock counter should be {int}", (_, counter: number) => {
-        expect(responseRecord(firstResponse).counter).toBe(counter);
-        expect(firstMock.getState().counter).toBe(counter);
-      });
-
-      And("the second mock counter should be {int}", (_, counter: number) => {
-        expect(responseRecord(secondResponse).counter).toBe(counter);
-        expect(secondMock.getState().counter).toBe(counter);
-      });
-    },
-  );
-
-  Scenario(
-    "Concurrent requests keep plugin state isolated",
-    ({ Given, When, Then }) => {
-      let requestCount = 0;
-      let arrivals = 0;
-      let boundedBarrier: Promise<void> | undefined;
-      let releaseBarrier: (() => void) | undefined;
-
-      Given(
-        "I create a two-stage plugin pipeline with a shared async barrier",
-        () => {
-          arrivals = 0;
-
-          const firstStage: Schmock.Plugin = {
-            name: "first-stage",
-            async process(context, response) {
-              context.state.set("request-id", context.params.id);
-              arrivals += 1;
-              if (arrivals === requestCount) releaseBarrier?.();
-              if (!boundedBarrier) {
-                throw new Error("Plugin rendezvous was not initialized");
-              }
-              await boundedBarrier;
-              return { context, response };
-            },
-          };
-          const secondStage: Schmock.Plugin = {
-            name: "second-stage",
-            process(context, response) {
-              const firstStageId = context.state.get("request-id");
-              return {
-                context,
-                response: {
-                  routeId: context.params.id,
-                  firstStageId,
-                  original: response,
-                },
-              };
-            },
-          };
-
-          firstMock = schmock();
-          firstMock("GET /work/:id", ({ params }) => ({ id: params.id }))
-            .pipe(firstStage)
-            .pipe(secondStage);
-        },
-      );
-
-      When(
-        "I issue {int} concurrent requests with distinct IDs through the pipeline",
-        async (_scenario, count: number) => {
-          requestCount = count;
-          expectedConcurrentCount = count;
-          const barrier = new Promise<void>((resolve) => {
-            releaseBarrier = resolve;
-          });
-          boundedBarrier = withTimeout(
-            barrier,
-            2_000,
-            `Timed out waiting for ${count} requests to reach the plugin rendezvous`,
-          );
-          concurrentResponses = await Promise.all(
-            Array.from({ length: count }, (_, index) =>
-              firstMock.handle("GET", `/work/${index}`),
-            ),
-          );
-        },
-      );
-
-      Then(
-        "every response should contain the same ID from both plugin stages",
-        () => {
-          expect(arrivals).toBe(expectedConcurrentCount);
-          expect(concurrentResponses).toHaveLength(expectedConcurrentCount);
-          concurrentResponses.forEach((response, index) => {
-            const body = responseRecord(response);
-            expect(body.routeId).toBe(String(index));
-            expect(body.firstStageId).toBe(String(index));
-          });
-        },
-      );
-    },
-  );
-});

package/src/types.ts

@@ -1,36 +0,0 @@
-/// <reference path="../schmock.d.ts" />
-
-// Re-export ambient types for consumers
-export type HttpMethod = Schmock.HttpMethod;
-export type RouteKey = Schmock.RouteKey;
-export type ResponseBody = Schmock.ResponseBody;
-export type ResponseResult = Schmock.ResponseResult;
-export type RequestContext = Schmock.RequestContext;
-export type Response = Schmock.Response;
-export type RequestOptions = Schmock.RequestOptions;
-export type GlobalConfig = Schmock.GlobalConfig;
-export type RouteConfig = Schmock.RouteConfig;
-export type Generator = Schmock.Generator;
-export type GeneratorFunction = Schmock.GeneratorFunction;
-export type CallableMockInstance = Schmock.CallableMockInstance;
-export type Plugin = Schmock.Plugin;
-export type PluginContext = Schmock.PluginContext;
-export type PluginResult = Schmock.PluginResult;
-export type StaticData = Schmock.StaticData;
-export type RequestRecord = Schmock.RequestRecord;
-export type ServerInfo = Schmock.ServerInfo;
-export type RouteInfo = Schmock.RouteInfo;
-export type SchemaGenerationContext = Schmock.SchemaGenerationContext;
-export type FakerPluginOptions = Schmock.FakerPluginOptions;
-export type ExpressAdapterOptions = Schmock.ExpressAdapterOptions;
-export type AngularAdapterOptions = Schmock.AngularAdapterOptions;
-export type OpenApiOptions = Schmock.OpenApiOptions;
-export type SeedSource = Schmock.SeedSource;
-export type SeedConfig = Schmock.SeedConfig;
-export type CliOptions = Schmock.CliOptions;
-export type CliServer = Schmock.CliServer;
-export type AdapterRequest = Schmock.AdapterRequest;
-export type AdapterResponse = Schmock.AdapterResponse;
-export type InterceptOptions = Schmock.InterceptOptions;
-export type InterceptHandle = Schmock.InterceptHandle;
-export type AdapterRequestOverride = Schmock.AdapterRequestOverride;