@schmock/core 2.3.0 → 2.4.0

package/src/steps/fetch-interceptor.steps.ts

@@ -1,457 +0,0 @@
-/// <reference path="../../schmock.d.ts" />
-
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect, type Mock, vi } from "vitest";
-import { schmock } from "../index.js";
-
-const feature = await loadFeature("../../features/fetch-interceptor.feature");
-
-describeFeature(feature, ({ Scenario, AfterEachScenario }) => {
-  let mock: Schmock.CallableMockInstance;
-  let handle: Schmock.InterceptHandle | undefined;
-  let originalFetch: typeof globalThis.fetch;
-  let savedFetch: Mock<typeof globalThis.fetch>;
-  let fetchResponse: Response | undefined;
-  let additionalHandles: Schmock.InterceptHandle[] = [];
-
-  function setup() {
-    originalFetch = globalThis.fetch;
-    savedFetch = vi
-      .fn<typeof globalThis.fetch>()
-      .mockResolvedValue(new Response("real backend"));
-    globalThis.fetch = savedFetch;
-    mock = schmock();
-    fetchResponse = undefined;
-    additionalHandles = [];
-  }
-
-  AfterEachScenario(() => {
-    handle?.restore();
-    for (const additionalHandle of additionalHandles) {
-      additionalHandle.restore();
-    }
-    handle = undefined;
-    additionalHandles = [];
-    globalThis.fetch = originalFetch;
-  });
-
-  Scenario(
-    "Intercept a matched fetch request",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /api/users" returning users',
-        () => {
-          setup();
-          mock("GET /api/users", [{ id: 1, name: "Alice" }]);
-        },
-      );
-
-      And("fetch is intercepted", () => {
-        handle = mock.intercept();
-      });
-
-      When('I fetch "/api/users"', async () => {
-        fetchResponse = await fetch("http://localhost/api/users");
-      });
-
-      Then("the fetch response status should be 200", () => {
-        expect(fetchResponse?.status).toBe(200);
-      });
-
-      And("the fetch response body should be the mocked users", async () => {
-        const body = await fetchResponse?.json();
-        expect(body).toEqual([{ id: 1, name: "Alice" }]);
-      });
-    },
-  );
-
-  Scenario("Passthrough for unmatched routes", ({ Given, When, Then, And }) => {
-    Given(
-      'a Schmock instance with route "GET /api/users" returning users',
-      () => {
-        setup();
-        mock("GET /api/users", [{ id: 1 }]);
-      },
-    );
-
-    And("fetch is intercepted with passthrough enabled", () => {
-      handle = mock.intercept({ passthrough: true });
-    });
-
-    When('I fetch "/api/other"', async () => {
-      fetchResponse = await fetch("http://localhost/api/other");
-    });
-
-    Then("the original fetch should have been called", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  Scenario("Passthrough disabled returns 404", ({ Given, When, Then, And }) => {
-    Given(
-      'a Schmock instance with route "GET /api/users" returning users',
-      () => {
-        setup();
-        mock("GET /api/users", [{ id: 1 }]);
-      },
-    );
-
-    And("fetch is intercepted with passthrough disabled", () => {
-      handle = mock.intercept({ passthrough: false });
-    });
-
-    When('I fetch "/api/other"', async () => {
-      fetchResponse = await fetch("http://localhost/api/other");
-    });
-
-    Then("the fetch response status should be 404", () => {
-      expect(fetchResponse?.status).toBe(404);
-    });
-  });
-
-  Scenario("Restore puts original fetch back", ({ Given, When, Then, And }) => {
-    let savedRef: typeof globalThis.fetch;
-
-    Given(
-      'a Schmock instance with route "GET /api/users" returning users',
-      () => {
-        setup();
-        mock("GET /api/users", [{ id: 1 }]);
-      },
-    );
-
-    And("fetch is intercepted", () => {
-      savedRef = globalThis.fetch;
-      handle = mock.intercept();
-    });
-
-    When("I restore the interceptor", () => {
-      handle?.restore();
-    });
-
-    Then("globalThis.fetch should be the original function", () => {
-      expect(globalThis.fetch).toBe(savedRef);
-    });
-  });
-
-  Scenario(
-    "BaseUrl filters which requests are intercepted",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /api/users" returning users',
-        () => {
-          setup();
-          mock("GET /api/users", [{ id: 1 }]);
-        },
-      );
-
-      And('fetch is intercepted with baseUrl "/api"', () => {
-        handle = mock.intercept({ baseUrl: "/api" });
-      });
-
-      When('I fetch "/other/endpoint"', async () => {
-        await fetch("http://localhost/other/endpoint");
-      });
-
-      Then("the original fetch should have been called", () => {
-        expect(savedFetch).toHaveBeenCalled();
-      });
-    },
-  );
-
-  Scenario(
-    "Origin-form baseUrl intercepts matching origin only",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /api/users" returning users',
-        () => {
-          setup();
-          mock("GET /api/users", [{ id: 1 }]);
-        },
-      );
-
-      And('fetch is intercepted with baseUrl "https://api.example.com"', () => {
-        handle = mock.intercept({ baseUrl: "https://api.example.com" });
-      });
-
-      When('I fetch "https://api.example.com/api/users"', async () => {
-        fetchResponse = await fetch("https://api.example.com/api/users");
-      });
-
-      Then("the response status should be {int}", (_, status: number) => {
-        expect(fetchResponse?.status).toBe(status);
-      });
-
-      And("the fetch response body should be the mocked users", async () => {
-        expect(await fetchResponse?.json()).toEqual([{ id: 1 }]);
-      });
-
-      And("the original fetch should not have been called", () => {
-        expect(savedFetch).not.toHaveBeenCalled();
-      });
-
-      When('I fetch "https://other.example.com/api/users"', async () => {
-        await fetch("https://other.example.com/api/users");
-      });
-
-      Then(
-        "the original fetch should have been called exactly once for {string}",
-        (_, url: string) => {
-          expect(savedFetch.mock.calls).toEqual([[url, undefined]]);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "Origin-form baseUrl with a path prefix requires both to match",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /v1/users" returning users',
-        () => {
-          setup();
-          mock("GET /v1/users", [{ id: 1 }]);
-        },
-      );
-
-      And(
-        'fetch is intercepted with baseUrl "https://api.example.com/v1"',
-        () => {
-          handle = mock.intercept({ baseUrl: "https://api.example.com/v1" });
-        },
-      );
-
-      When('I fetch "https://api.example.com/v1/users"', async () => {
-        fetchResponse = await fetch("https://api.example.com/v1/users");
-      });
-
-      Then("the response status should be {int}", (_, status: number) => {
-        expect(fetchResponse?.status).toBe(status);
-      });
-
-      And("the fetch response body should be the mocked users", async () => {
-        expect(await fetchResponse?.json()).toEqual([{ id: 1 }]);
-      });
-
-      And("the original fetch should not have been called", () => {
-        expect(savedFetch).not.toHaveBeenCalled();
-      });
-
-      When('I fetch "https://api.example.com/users"', async () => {
-        await fetch("https://api.example.com/users");
-      });
-
-      Then(
-        "the original fetch should have been called exactly once for {string}",
-        (_, url: string) => {
-          expect(savedFetch.mock.calls).toEqual([[url, undefined]]);
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "beforeRequest hook modifies the request",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /api/users" that reads headers',
-        () => {
-          setup();
-          mock("GET /api/users", ({ headers }) => [
-            200,
-            { token: headers["x-token"] },
-          ]);
-        },
-      );
-
-      And(
-        "fetch is intercepted with a beforeRequest hook that adds a header",
-        () => {
-          handle = mock.intercept({
-            beforeRequest: (req) => ({
-              ...req,
-              headers: { ...req.headers, "x-token": "injected" },
-            }),
-          });
-        },
-      );
-
-      When('I fetch "/api/users"', async () => {
-        fetchResponse = await fetch("http://localhost/api/users");
-      });
-
-      Then(
-        "the response should contain the injected header value",
-        async () => {
-          const body = await fetchResponse?.json();
-          expect(body).toEqual({ token: "injected" });
-        },
-      );
-    },
-  );
-
-  Scenario(
-    "beforeResponse hook modifies the response",
-    ({ Given, When, Then, And }) => {
-      Given(
-        'a Schmock instance with route "GET /api/users" returning users',
-        () => {
-          setup();
-          mock("GET /api/users", [{ id: 1 }]);
-        },
-      );
-
-      And(
-        "fetch is intercepted with a beforeResponse hook that adds a header",
-        () => {
-          handle = mock.intercept({
-            beforeResponse: (res) => ({
-              ...res,
-              headers: { ...res.headers, "x-mock": "true" },
-            }),
-          });
-        },
-      );
-
-      When('I fetch "/api/users"', async () => {
-        fetchResponse = await fetch("http://localhost/api/users");
-      });
-
-      Then("the fetch response should have the injected header", () => {
-        expect(fetchResponse?.headers.get("x-mock")).toBe("true");
-      });
-    },
-  );
-
-  Scenario("Double intercept throws an error", ({ Given, When, Then, And }) => {
-    let error: Error | undefined;
-
-    Given(
-      'a Schmock instance with route "GET /api/users" returning users',
-      () => {
-        setup();
-        mock("GET /api/users", [{ id: 1 }]);
-      },
-    );
-
-    And("fetch is intercepted", () => {
-      handle = mock.intercept();
-    });
-
-    When("I try to intercept again", () => {
-      try {
-        mock.intercept();
-      } catch (caught) {
-        error = caught instanceof Error ? caught : new Error(String(caught));
-      }
-    });
-
-    Then("it should throw an error about already intercepting", () => {
-      expect(error?.message).toMatch(/already intercepting/i);
-    });
-  });
-
-  Scenario(
-    "Multiple mocks compose from newest to oldest",
-    ({ Given, When, Then, And }) => {
-      let newerMock: Schmock.CallableMockInstance;
-      let newerHandle: Schmock.InterceptHandle | undefined;
-      let sharedResponse: Response | undefined;
-      let olderResponse: Response | undefined;
-
-      Given(
-        'an older mock for both routes and a newer mock for "GET /api/shared"',
-        () => {
-          setup();
-          mock("GET /api/older", { source: "older" });
-          mock("GET /api/shared", { source: "older" });
-          newerMock = schmock();
-          newerMock("GET /api/shared", { source: "newer" });
-        },
-      );
-
-      And("both mocks intercept fetch in that order", () => {
-        handle = mock.intercept();
-        newerHandle = newerMock.intercept();
-        additionalHandles.push(newerHandle);
-      });
-
-      When("I fetch the shared and older routes", async () => {
-        sharedResponse = await fetch("http://localhost/api/shared");
-        olderResponse = await fetch("http://localhost/api/older");
-      });
-
-      Then("the shared route should use the newer mock", async () => {
-        expect(await sharedResponse?.json()).toEqual({ source: "newer" });
-      });
-
-      And("the older route should fall through to the older mock", async () => {
-        expect(await olderResponse?.json()).toEqual({ source: "older" });
-      });
-    },
-  );
-
-  Scenario(
-    "Interceptors can be restored out of order",
-    ({ Given, When, Then }) => {
-      let newerMock: Schmock.CallableMockInstance;
-      let newerHandle: Schmock.InterceptHandle | undefined;
-      let newerResponse: Response | undefined;
-
-      Given("an older mock and a newer mock both intercepting fetch", () => {
-        setup();
-        mock("GET /api/older", { source: "older" });
-        newerMock = schmock();
-        newerMock("GET /api/newer", { source: "newer" });
-        handle = mock.intercept();
-        newerHandle = newerMock.intercept();
-        additionalHandles.push(newerHandle);
-      });
-
-      When("I restore the older interceptor first", () => {
-        handle?.restore();
-      });
-
-      Then("the newer interceptor should remain active", async () => {
-        newerResponse = await fetch("http://localhost/api/newer");
-        expect(newerHandle?.active).toBe(true);
-        expect(await newerResponse.json()).toEqual({ source: "newer" });
-      });
-
-      When("I restore the newer interceptor", () => {
-        newerHandle?.restore();
-      });
-
-      Then("globalThis.fetch should be the original function", () => {
-        expect(globalThis.fetch).toBe(savedFetch);
-      });
-    },
-  );
-
-  Scenario(
-    "Restore preserves a third-party fetch replacement",
-    ({ Given, When, Then, And }) => {
-      let replacementFetch: Mock<typeof globalThis.fetch>;
-
-      Given("fetch is intercepted", () => {
-        setup();
-        handle = mock.intercept();
-      });
-
-      When("another library replaces globalThis.fetch", () => {
-        replacementFetch = vi
-          .fn<typeof globalThis.fetch>()
-          .mockResolvedValue(new Response("third-party backend"));
-        globalThis.fetch = replacementFetch;
-      });
-
-      And("I restore the interceptor", () => {
-        handle?.restore();
-      });
-
-      Then("the third-party fetch replacement should remain installed", () => {
-        expect(globalThis.fetch).toBe(replacementFetch);
-      });
-    },
-  );
-});

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