@schmock/core 2.3.0 → 2.3.1

package/src/steps/async-support.steps.ts

@@ -1,421 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-import type { CallableMockInstance, Plugin } from "../types";
-
-const feature = await loadFeature("../../features/async-support.feature");
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-  let responses: any[] = [];
-  let startTime: number;
-  let endTime: number;
-
-  Scenario("Async generator function returns Promise", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async generator at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as any, async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        return { message: "async response" };
-      });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Async generator with context access", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async param-based generator at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as any, async ({ params }: any) => {
-        await new Promise(resolve => setTimeout(resolve, 5));
-        return {
-          userId: params.id,
-          fetchedAt: new Date().toISOString(),
-        };
-      });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the response should have property {string} with value {string}", (_, property: string, value: string) => {
-      expect(response.body).toHaveProperty(property, value);
-    });
-
-    And("the response should have property {string}", (_, property: string) => {
-      expect(response.body).toHaveProperty(property);
-    });
-  });
-
-  Scenario("Async plugin processing", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async processing plugin at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      const asyncPlugin: Plugin = {
-        name: "async-processor",
-        process: async (ctx, response) => {
-          await new Promise(resolve => setTimeout(resolve, 5));
-          return {
-            context: ctx,
-            response: {
-              data: response,
-              processedAsync: true,
-              timestamp: new Date().toISOString(),
-            },
-          };
-        },
-      };
-      mock(`${method} ${path}` as any, { original: "data" }).pipe(asyncPlugin);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the async response should have property {string}", (_, property: string) => {
-      expect(response.body).toHaveProperty(property);
-    });
-
-    And("the async response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === "true" ? true : value === "false" ? false : value;
-      expect(response.body).toHaveProperty(property, expectedValue);
-    });
-
-    And("the async response should have property {string}", (_, property: string) => {
-      expect(response.body).toHaveProperty(property);
-    });
-  });
-
-  Scenario("Mixed sync and async plugin pipeline", ({ Given, When, Then, And }) => {
-    Given("I create a mock with sync and async plugins at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      const syncPlugin: Plugin = {
-        name: "sync-step",
-        process: (ctx, pluginResponse) => {
-          if (!isRecord(pluginResponse)) {
-            throw new Error(
-              "Expected the sync plugin response to be an object",
-            );
-          }
-          return {
-            context: ctx,
-            response: { ...pluginResponse, syncStep: true },
-          };
-        },
-      };
-      const asyncPlugin: Plugin = {
-        name: "async-step",
-        process: async (ctx, pluginResponse) => {
-          await new Promise(resolve => setTimeout(resolve, 5));
-          if (!isRecord(pluginResponse)) {
-            throw new Error(
-              "Expected the async plugin response to be an object",
-            );
-          }
-          return {
-            context: ctx,
-            response: { ...pluginResponse, asyncStep: true },
-          };
-        },
-      };
-      mock(`${method} ${path}` as any, { base: "data" })
-        .pipe(syncPlugin)
-        .pipe(asyncPlugin);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the response should have property {string} with value {string}", (_, property: string, value: string) => {
-      expect(response.body).toHaveProperty(property, value);
-    });
-
-    And("the response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === "true" ? true : value === "false" ? false : value;
-      expect(response.body).toHaveProperty(property, expectedValue);
-    });
-
-    And("the response should have property {string} with boolean value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === "true" ? true : value === "false" ? false : value;
-      expect(response.body).toHaveProperty(property, expectedValue);
-    });
-  });
-
-  Scenario("Async generator with Promise rejection", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async generator that throws at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as any, async () => {
-        await new Promise(resolve => setTimeout(resolve, 5));
-        throw new Error("Async operation failed");
-      });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the response should contain error {string}", (_, errorMessage: string) => {
-      expect(response.body.error).toContain(errorMessage);
-    });
-  });
-
-  Scenario("Async plugin error recovery", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async error-recovery plugin at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      const asyncErrorPlugin: Plugin = {
-        name: "async-error-handler",
-        process: async () => {
-          await new Promise(resolve => setTimeout(resolve, 5));
-          throw new Error("Async plugin failed");
-        },
-        onError: async (error) => {
-          await new Promise(resolve => setTimeout(resolve, 3));
-          return {
-            status: 200,
-            body: { recovered: true, originalError: error.message },
-            headers: {},
-          };
-        },
-      };
-      mock(`${method} ${path}` as any, "original").pipe(asyncErrorPlugin);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive status {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("the response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === "true" ? true : value === "false" ? false : value;
-      expect(response.body).toHaveProperty(property, expectedValue);
-    });
-
-    And("the response should have property {string}", (_, property: string) => {
-      expect(response.body).toHaveProperty(property);
-    });
-  });
-
-  Scenario("Async generator with delay configuration", ({ Given, When, Then, And }) => {
-    Given("I create a mock with delay 20ms and async generator at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock({ delay: 20 });
-      mock(`${method} ${path}` as any, async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        return { delayed: true, async: true };
-      });
-    });
-
-    When("I request {string} and measure time", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      startTime = Date.now();
-      response = await mock.handle(method as any, path);
-      endTime = Date.now();
-    });
-
-    Then("the response time should be at least {int}ms", (_, minTime: number) => {
-      const actualTime = endTime - startTime;
-      expect(actualTime).toBeGreaterThanOrEqual(minTime);
-    });
-
-    And("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Async generator with state management", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async stateful counter at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock({ state: { asyncCounter: 0 } });
-      mock(`${method} ${path}` as any, async ({ state }: any) => {
-        await new Promise(resolve => setTimeout(resolve, 5));
-        state.asyncCounter = (state.asyncCounter || 0) + 1;
-        return {
-          count: state.asyncCounter,
-          processedAsync: true,
-        };
-      });
-    });
-
-    When("I request {string} twice", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      const firstResponse = await mock.handle(method as any, path);
-      const secondResponse = await mock.handle(method as any, path);
-      responses = [firstResponse, secondResponse];
-    });
-
-    Then("the first response should have count {int}", (_, count: number) => {
-      expect(responses[0].body.count).toBe(count);
-    });
-
-    And("the second response should have count {int}", (_, count: number) => {
-      expect(responses[1].body.count).toBe(count);
-    });
-
-    And("both responses should have processedAsync {word}", (_, value: string) => {
-      const expectedValue = value === "true" ? true : value === "false" ? false : value;
-      expect(responses[0].body.processedAsync).toBe(expectedValue);
-      expect(responses[1].body.processedAsync).toBe(expectedValue);
-    });
-  });
-
-  Scenario("Promise-based plugin response generation", ({ Given, When, Then }) => {
-    Given("I create a mock with a Promise-generating plugin at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      const promisePlugin: Plugin = {
-        name: "promise-generator",
-        process: async (ctx, response) => {
-          if (!response) {
-            const data = await Promise.resolve({ generated: "by promise" });
-            return { context: ctx, response: data };
-          }
-          return { context: ctx, response };
-        },
-      };
-      mock(`${method} ${path}` as any, null).pipe(promisePlugin);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Concurrent async requests isolation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async delay per id at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      mock(`${method} ${path}` as any, async ({ params }: any) => {
-        const delay = parseInt(params.id) * 5;
-        await new Promise(resolve => setTimeout(resolve, delay));
-        return {
-          id: params.id,
-          processedAt: Date.now(),
-        };
-      });
-    });
-
-    When("I make concurrent requests to {string}, {string}, and {string}", async (_, path1: string, path2: string, path3: string) => {
-      const promises = [
-        mock.handle("GET", path1),
-        mock.handle("GET", path2),
-        mock.handle("GET", path3),
-      ];
-      responses = await Promise.all(promises);
-    });
-
-    Then("all responses should have valid processedAt timestamps", () => {
-      const timestamps = responses.map(r => r.body.processedAt);
-      expect(timestamps).toHaveLength(3);
-      timestamps.forEach((timestamp: number) => expect(timestamp).toBeGreaterThan(0));
-    });
-
-    And("each response should have the correct id value", () => {
-      expect(responses[0].body.id).toBe("1");
-      expect(responses[1].body.id).toBe("2");
-      expect(responses[2].body.id).toBe("3");
-    });
-
-    And("all responses should complete with status 200", () => {
-      for (const response of responses) {
-        expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty("id");
-        expect(response.body).toHaveProperty("processedAt");
-      }
-    });
-  });
-
-  Scenario("Async plugin pipeline with context state", ({ Given, When, Then, And }) => {
-    Given("I create a mock with two async stateful plugins at {string}", (_, route: string) => {
-      const [method, path] = route.split(" ");
-      mock = schmock();
-      const plugin1: Plugin = {
-        name: "async-step-1",
-        process: async (ctx, response) => {
-          await new Promise(resolve => setTimeout(resolve, 5));
-          ctx.state.set("step1", "completed");
-          return { context: ctx, response };
-        },
-      };
-      const plugin2: Plugin = {
-        name: "async-step-2",
-        process: async (ctx, pluginResponse) => {
-          await new Promise(resolve => setTimeout(resolve, 3));
-          const step1Status = ctx.state.get("step1");
-          if (!isRecord(pluginResponse)) {
-            throw new Error(
-              "Expected the stateful plugin response to be an object",
-            );
-          }
-          return {
-            context: ctx,
-            response: {
-              ...pluginResponse,
-              step1: step1Status,
-              step2: "completed",
-            },
-          };
-        },
-      };
-      mock(`${method} ${path}` as any, { base: "data" })
-        .pipe(plugin1)
-        .pipe(plugin2);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the response should have property {string} with value {string}", (_, property: string, value: string) => {
-      expect(response.body).toHaveProperty(property, value);
-    });
-
-    And("the async pipeline response should have both step properties completed", () => {
-      expect(response.body).toHaveProperty("step1", "completed");
-      expect(response.body).toHaveProperty("step2", "completed");
-    });
-  });
-});

package/src/steps/audit-core-builder.steps.ts

@@ -1,188 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/audit-core-builder.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  // ── FIX 1.2: defineRoute must shallow-clone the config ───────────────────
-
-  Scenario(
-    "defineRoute does not mutate the caller's config object",
-    ({ Given, When, Then }) => {
-      let sharedConfig: Schmock.RouteConfig;
-      let mock: Schmock.CallableMockInstance;
-
-      Given("a shared config object with no contentType", () => {
-        sharedConfig = {};
-      });
-
-      When("I register two routes with the same config object", () => {
-        mock = schmock();
-        mock("GET /route1", { name: "route1" }, sharedConfig);
-        mock("GET /route2", { name: "route2" }, sharedConfig);
-      });
-
-      Then(
-        "the shared config object remains unchanged after registration",
-        () => {
-          expect(Object.keys(sharedConfig)).toHaveLength(0);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Mutating a returned config does not affect the registered route",
-    ({ Given, When, Then, And }) => {
-      let singleConfig: Schmock.RouteConfig;
-      let mock: Schmock.CallableMockInstance;
-
-      Given("a single config object with no contentType", () => {
-        singleConfig = {};
-      });
-
-      When("I register one route with that config object", () => {
-        mock = schmock();
-        mock("GET /item", { value: 99 }, singleConfig);
-      });
-
-      And("I mutate the config object after registration", () => {
-        singleConfig.status = 503;
-        singleConfig.contentType = "text/html";
-      });
-
-      Then(
-        "the registered route still responds with application/json content type",
-        async () => {
-          const response = await mock.handle("GET", "/item");
-          expect(response.status).toBe(200);
-          const ct =
-            response.headers?.["content-type"] ??
-            response.headers?.["Content-Type"];
-          expect(ct).toContain("application/json");
-        },
-      );
-    },
-  );
-
-  // ── FIX 2.2: duplicate route detection must normalize trailing slash ──────
-
-  Scenario(
-    "Trailing-slash path is treated as duplicate",
-    ({ Given, And, Then }) => {
-      let mock: Schmock.CallableMockInstance;
-
-      Given("a fresh mock instance", () => {
-        mock = schmock();
-      });
-
-      And("I register GET /users without trailing slash", () => {
-        mock("GET /users", [{ id: 1 }], {});
-      });
-
-      And("I register GET /users with trailing slash", () => {
-        mock("GET /users/", [{ id: 2 }], {});
-      });
-
-      Then("only one route exists for GET /users", () => {
-        const routes = mock.getRoutes();
-        const userRoutes = routes.filter(
-          (r) =>
-            r.method === "GET" && (r.path === "/users" || r.path === "/users/"),
-        );
-        expect(userRoutes).toHaveLength(1);
-      });
-    },
-  );
-
-  // ── FIX 3.3: reset()/resetState() must not mutate caller's state ─────────
-
-  Scenario(
-    "reset() does not mutate the caller's state object",
-    ({ Given, When, Then, And }) => {
-      let externalState: Record<string, unknown>;
-      let mock: Schmock.CallableMockInstance;
-
-      Given('a mock with external state containing key "a" equal to 1', () => {
-        externalState = { a: 1 };
-        mock = schmock({ state: externalState });
-      });
-
-      When("I call mock reset", () => {
-        mock.reset();
-      });
-
-      Then('the external state still has key "a" equal to 1', () => {
-        expect(externalState).toEqual({ a: 1 });
-      });
-
-      And("the mock internal state is empty", () => {
-        expect(mock.getState()).toEqual({});
-      });
-    },
-  );
-
-  Scenario(
-    "resetState() does not mutate the caller's state object",
-    ({ Given, When, Then, And }) => {
-      let externalState: Record<string, unknown>;
-      let mock: Schmock.CallableMockInstance;
-
-      Given('a mock with external state containing key "b" equal to 2', () => {
-        externalState = { b: 2 };
-        mock = schmock({ state: externalState });
-      });
-
-      When("I call mock resetState", () => {
-        mock.resetState();
-      });
-
-      Then('the external state still has key "b" equal to 2', () => {
-        expect(externalState).toEqual({ b: 2 });
-      });
-
-      And("the mock internal state is empty after resetState", () => {
-        expect(mock.getState()).toEqual({});
-      });
-    },
-  );
-
-  // ── FIX 2.3: history()/lastRequest() must return deep clones ─────────────
-
-  Scenario(
-    "history() returns deep clones of request records",
-    ({ Given, When, Then, And }) => {
-      let mock: Schmock.CallableMockInstance;
-
-      Given("a fresh mock with a route returning a nested body", () => {
-        mock = schmock();
-        mock("GET /data", { nested: { value: "original" } }, {});
-      });
-
-      When("I handle that route once", async () => {
-        await mock.handle("GET", "/data");
-      });
-
-      And("I mutate the response body of the first history record", () => {
-        const records = mock.history();
-        expect(records).toHaveLength(1);
-        const body = records[0].response.body as { nested: { value: string } };
-        body.nested.value = "MUTATED";
-      });
-
-      Then("history returns the original body unchanged", () => {
-        const records = mock.history();
-        const body = records[0].response.body as { nested: { value: string } };
-        expect(body.nested.value).toBe("original");
-      });
-
-      And("lastRequest returns the original body unchanged", () => {
-        const last = mock.lastRequest();
-        if (!last) throw new Error("expected a record");
-        const body = last.response.body as { nested: { value: string } };
-        expect(body.nested.value).toBe("original");
-      });
-    },
-  );
-});

package/src/steps/audit-onerror-tuple.steps.ts

@@ -1,83 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/audit-onerror-tuple.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let response: Awaited<ReturnType<Schmock.CallableMockInstance["handle"]>>;
-
-  Scenario(
-    "2-element tuple from onError recovers with correct status and body",
-    ({ Given, When, Then, And }) => {
-      Given(
-        "a mock with a plugin whose process throws and onError returns a 2-element tuple",
-        () => {
-          mock = schmock({ state: {} });
-          mock("GET /fail", null, {}).pipe({
-            name: "failing-plugin",
-            process: (_ctx, _response) => {
-              throw new Error("simulated failure");
-            },
-            onError: () => [503, { error: "recovered" }],
-          });
-        },
-      );
-
-      When('I handle a request to "GET /fail"', async () => {
-        response = await mock.handle("GET", "/fail");
-      });
-
-      Then("the response status is 503", () => {
-        expect(response.status).toBe(503);
-      });
-
-      And('the response body is \'{"error":"recovered"}\'', () => {
-        expect(response.body).toEqual({ error: "recovered" });
-      });
-    },
-  );
-
-  Scenario(
-    "3-element tuple from onError recovers and includes custom headers",
-    ({ Given, When, Then, And }) => {
-      Given(
-        "a mock with a plugin whose process throws and onError returns a 3-element tuple with headers",
-        () => {
-          mock = schmock({ state: {} });
-          mock("GET /fail-with-headers", null, {}).pipe({
-            name: "failing-plugin-headers",
-            process: (_ctx, _response) => {
-              throw new Error("simulated failure with headers");
-            },
-            onError: () => [
-              503,
-              { error: "recovered with headers" },
-              { "x-recovery": "true" },
-            ],
-          });
-        },
-      );
-
-      When('I handle a request to "GET /fail-with-headers"', async () => {
-        response = await mock.handle("GET", "/fail-with-headers");
-      });
-
-      Then("the response status is 503", () => {
-        expect(response.status).toBe(503);
-      });
-
-      And('the response body is \'{"error":"recovered with headers"}\'', () => {
-        expect(response.body).toEqual({ error: "recovered with headers" });
-      });
-
-      And(
-        "the response header {string} is {string}",
-        (_, header: string, value: string) => {
-          expect(response.headers[header]).toBe(value);
-        },
-      );
-    },
-  );
-});