@schmock/core 2.2.3 → 2.3.1

package/src/steps/error-handling.steps.ts

@@ -1,345 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import type { CallableMockInstance, Plugin } from "../types";
-import { schmock } from "../index";
-
-const feature = await loadFeature("../../features/error-handling.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-
-  Scenario("Route not found returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a GET /users route returning a user list", () => {
-      mock = schmock();
-      mock("GET /users", [{ id: 1, name: "John" }]);
-    });
-
-    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);
-    });
-
-    And("the response should have error code {string}", (_, errorCode: string) => {
-      expect(response.body.code).toBe(errorCode);
-    });
-  });
-
-  Scenario("Wrong HTTP method returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a GET /api/data route returning success", () => {
-      mock = schmock();
-      mock("GET /api/data", { success: true });
-    });
-
-    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("Plugin throws error returns 500 with PluginError", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin that throws {string}", (_, errorMsg: string) => {
-      mock = schmock();
-      const failingPlugin: Plugin = {
-        name: "failing-plugin",
-        process: () => { throw new Error(errorMsg); },
-      };
-      mock("GET /test", "original").pipe(failingPlugin);
-    });
-
-    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);
-    });
-
-    And("the response should have error code {string}", (_, errorCode: string) => {
-      expect(response.body.code).toBe(errorCode);
-    });
-  });
-
-  Scenario("Plugin onError hook recovers from failure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a recoverable plugin that returns {string}", (_, recoveredBody: string) => {
-      mock = schmock();
-      const recoverablePlugin: Plugin = {
-        name: "recoverable",
-        process: () => { throw new Error("Initial failure"); },
-        onError: () => ({ status: 200, body: recoveredBody, headers: {} }),
-      };
-      mock("GET /test", "original").pipe(recoverablePlugin);
-    });
-
-    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("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-  });
-
-  Scenario("Plugin returns invalid result structure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin returning an invalid result", () => {
-      mock = schmock();
-      const invalidPlugin: Plugin = {
-        name: "invalid",
-        process: () => ({ wrongStructure: true }) as any,
-      };
-      mock("GET /test", "original").pipe(invalidPlugin);
-    });
-
-    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("Function generator throws error returns 500", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a generator that throws {string}", (_, errorMsg: string) => {
-      mock = schmock();
-      mock("GET /fail", () => { throw new Error(errorMsg); });
-    });
-
-    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);
-    });
-
-    And("the response should have error code {string}", (_, errorCode: string) => {
-      expect(response.body.code).toBe(errorCode);
-    });
-  });
-
-  Scenario("Namespace mismatch returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with namespace {string} and a GET /users route", (_, namespace: string) => {
-      mock = schmock({ namespace });
-      mock("GET /users", [{ id: 1 }]);
-    });
-
-    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("Multiple plugin failures cascade properly", ({ Given, When, Then, And }) => {
-    Given("I create a mock with two failing plugins piped in sequence", () => {
-      mock = schmock();
-      const plugin1: Plugin = {
-        name: "first-fail",
-        process: () => { throw new Error("First error"); },
-      };
-      const plugin2: Plugin = {
-        name: "second-fail",
-        process: () => { throw new Error("Second error"); },
-      };
-      mock("GET /cascade", "original").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("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("Plugin onError hook also fails", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin whose error handler also throws", () => {
-      mock = schmock({ debug: true });
-      const brokenPlugin: Plugin = {
-        name: "broken-handler",
-        process: () => { throw new Error("Process failed"); },
-        onError: () => { throw new Error("Handler failed"); },
-      };
-      mock("GET /broken", "original").pipe(brokenPlugin);
-    });
-
-    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("Empty parameter in route returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a parameterized route {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as any, ({ params }: any) => ({ userId: params.id }));
-    });
-
-    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 generator error handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async generator that throws {string}", (_, errorMsg: string) => {
-      mock = schmock();
-      mock("GET /async-fail", async () => {
-        await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error(errorMsg);
-      });
-    });
-
-    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("Error responses include proper headers", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a generator that throws {string}", (_, errorMsg: string) => {
-      mock = schmock();
-      mock("GET /error", () => { throw new Error(errorMsg); });
-    });
-
-    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 content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers).toBeDefined();
-    });
-
-    And("the response body should be valid JSON", () => {
-      expect(() => JSON.parse(JSON.stringify(response.body))).not.toThrow();
-    });
-  });
-
-  Scenario("Plugin onError returns response with status 0", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin whose error handler returns status 0", () => {
-      mock = schmock();
-      const plugin: Plugin = {
-        name: "zero-status",
-        process: () => { throw new Error("fail"); },
-        onError: () => ({ status: 0, body: "zero status", headers: {} }),
-      };
-      mock("GET /zero", "original").pipe(plugin);
-    });
-
-    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("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-  });
-
-  Scenario("Plugin null/undefined return handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin that returns null", () => {
-      mock = schmock();
-      const nullPlugin: Plugin = {
-        name: "null-plugin",
-        process: () => null as any,
-      };
-      mock("GET /null", "original").pipe(nullPlugin);
-    });
-
-    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);
-    });
-  });
-});

package/src/steps/fluent-api.steps.ts

@@ -1,255 +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/fluent-api.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-  let responses: any[] = [];
-
-  Scenario("Simple route with generator function", ({ Given, When, Then }) => {
-    Given("I create a mock with a JSON generator at {string}", (_, route: string) => {
-      mock = schmock({});
-      mock(route as Schmock.RouteKey, () => [{ id: 1, name: "John" }], {
-        contentType: "application/json",
-      });
-    });
-
-    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(
-    "Route with dynamic response and global state",
-    ({ Given, When, Then, And }) => {
-      responses = [];
-
-      Given("I create a mock with a stateful counter", () => {
-        mock = schmock({ state: { count: 0 } });
-        mock(
-          "GET /counter",
-          ({ state }) => {
-            const s = state as { count: number };
-            s.count++;
-            return { value: s.count };
-          },
-          { contentType: "application/json" },
-        );
-      });
-
-      When("I request {string} twice", async (_, request: string) => {
-        const [method, path] = request.split(" ");
-        responses = [];
-        responses.push(await mock.handle(method as any, path));
-        responses.push(await mock.handle(method as any, path));
-      });
-
-      Then("the first response should have value {int}", (_, value: number) => {
-        expect(responses[0].body).toEqual({ value });
-      });
-
-      And("the second response should have value {int}", (_, value: number) => {
-        expect(responses[1].body).toEqual({ value });
-      });
-    },
-  );
-
-  Scenario("Route with parameters", ({ Given, When, Then }) => {
-    Given("I create a mock with a parameterized route {string}", (_, route: string) => {
-      mock = schmock({});
-      mock(route as Schmock.RouteKey, ({ params }) => ({ userId: params.id }), {
-        contentType: "application/json",
-      });
-    });
-
-    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("Response with custom status code", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning status {int} for {string}", (_, _status: number, route: string) => {
-      mock = schmock({});
-      mock(route as Schmock.RouteKey, ({ body }) => {
-        const b = body as Record<string, unknown>;
-        return [201, { id: 1, ...b }];
-      }, {
-        contentType: "application/json",
-      });
-    });
-
-    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 });
-      },
-    );
-
-    Then("the status should be {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-
-    And("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Static data response", ({ Given, When, Then }) => {
-    Given("I create a mock with static config data at {string}", (_, route: string) => {
-      mock = schmock({});
-      mock(route as Schmock.RouteKey, { version: "1.0.0", features: ["auth"] }, {
-        contentType: "application/json",
-      });
-    });
-
-    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("404 for undefined routes", ({ Given, When, Then }) => {
-    Given("I create a mock with only a {string} route", (_, route: string) => {
-      mock = schmock({});
-      mock(route as Schmock.RouteKey, () => [], { contentType: "application/json" });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the status should be {int}", (_, status: number) => {
-      expect(response.status).toBe(status);
-    });
-  });
-
-  Scenario("Query parameters", ({ Given, When, Then }) => {
-    Given("I create a mock that reads query parameters at {string}", (_, route: string) => {
-      mock = schmock({});
-      mock(
-        route as Schmock.RouteKey,
-        ({ query }) => ({
-          results: [],
-          query: query.q,
-        }),
-        { contentType: "application/json" },
-      );
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, fullPath] = request.split(" ");
-      const [path, queryString] = fullPath.split("?");
-
-      const query: Record<string, string> = {};
-      if (queryString) {
-        queryString.split("&").forEach((param) => {
-          const [key, value] = param.split("=");
-          query[key] = value;
-        });
-      }
-
-      response = await mock.handle(method as any, path, { query });
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Request headers access", ({ Given, When, Then }) => {
-    Given("I create a mock that reads headers at {string}", (_, route: string) => {
-      mock = schmock({});
-      mock(
-        route as Schmock.RouteKey,
-        ({ headers }) => ({
-          authenticated: headers.authorization === "Bearer token123",
-        }),
-        { contentType: "application/json" },
-      );
-    });
-
-    When(
-      "I request {string} with headers:",
-      async (_, request: string, docString: string) => {
-        const [method, path] = request.split(" ");
-        const headers = JSON.parse(docString);
-        response = await mock.handle(method as any, path, { headers });
-      },
-    );
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Global configuration with namespace", ({ Given, When, Then }) => {
-    Given("I create a mock with namespace {string}", (_, namespace: string) => {
-      mock = schmock({ namespace });
-      mock("GET /users", () => [], { contentType: "application/json" });
-    });
-
-    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("Plugin pipeline with pipe chaining", ({ Given, When, Then }) => {
-    Given("I create a mock with two passthrough plugins", () => {
-      mock = schmock({});
-      mock("GET /users", () => [{ id: 1, name: "John" }], {
-        contentType: "application/json",
-      })
-        .pipe({
-          name: "logging",
-          process: (ctx, response) => ({ context: ctx, response }),
-        })
-        .pipe({
-          name: "cors",
-          process: (ctx, response) => ({ context: ctx, 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);
-    });
-  });
-});