@schmock/core 1.13.0 → 2.0.1

package/src/steps/developer-experience.steps.ts

@@ -10,134 +10,6 @@ describeFeature(feature, ({ Scenario }) => {
   let response: any;
   let responses: any[] = [];
 
-  Scenario("Forgetting to provide response data", ({ Given, When, Then, And }) => {
-    Given("I create a mock with no response data on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, undefined);
-    });
-
-    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 body should be empty", () => {
-      expect(response.body).toBeUndefined();
-    });
-  });
-
-  Scenario("Using wrong parameter name in route", ({ Given, When, Then }) => {
-    Given("I create a mock with a mismatched parameter name on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.id }));
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the wrong parameter should be undefined", () => {
-      expect(response.body).toEqual({ id: undefined });
-    });
-  });
-
-  Scenario("Correct parameter usage", ({ Given, When, Then }) => {
-    Given("I create a mock with a matching parameter name on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.userId }));
-    });
-
-    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("Mixing content types without explicit configuration", ({ Given, When, Then, And }) => {
-    Given("I create a mock with JSON, text, number, and boolean routes", () => {
-      mock = schmock();
-      mock("GET /json", { data: "json" });
-      mock("GET /text", "plain text");
-      mock("GET /number", 42);
-      mock("GET /boolean", true);
-    });
-
-    When("I test all mixed content type routes", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/json"));
-      responses.push(await mock.handle("GET", "/text"));
-      responses.push(await mock.handle("GET", "/number"));
-      responses.push(await mock.handle("GET", "/boolean"));
-    });
-
-    Then("JSON route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[0].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("text route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[1].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("number route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[2].headers?.["content-type"]).toBe(contentType);
-    });
-
-    And("boolean route should have content-type {string}", (_, contentType: string) => {
-      expect(responses[3].headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Expecting JSON but getting string conversion", ({ Given, When, Then, And }) => {
-    Given("I create a mock returning a decimal number on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, 19.99);
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive text {string}", (_, expectedText: string) => {
-      expect(response.body).toBe(expectedText);
-    });
-
-    And("the content-type should be {string}", (_, contentType: string) => {
-      expect(response.headers?.["content-type"]).toBe(contentType);
-    });
-  });
-
-  Scenario("Forgetting await with async generators", ({ Given, When, Then, And }) => {
-    Given("I create a mock with an async handler on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, async () => ({ async: 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:", (_, 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("State confusion between global and local state", ({ Given, When, Then, And }) => {
     Given("I create a mock with global state and a local state counter", () => {
       mock = schmock({ state: { global: 1 } });
@@ -166,62 +38,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Query parameter edge cases", ({ Given, When, Then }) => {
-    Given("I create a mock that echoes query parameters on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ query }) => ({
-        term: query.q,
-        page: query.page,
-        empty: query.empty,
-      }));
-    });
-
-    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("Headers case sensitivity", ({ Given, When, Then }) => {
-    Given("I create a mock that echoes headers on {string}", (_, route: string) => {
-      mock = schmock();
-      mock(route as Schmock.RouteKey, ({ headers }) => ({
-        auth: headers.authorization,
-        authUpper: headers.Authorization,
-        contentType: headers["content-type"],
-      }));
-    });
-
-    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("the header case sensitivity should show expected values", () => {
-      expect(response.body).toEqual({
-        auth: undefined,
-        authUpper: "Bearer token",
-        contentType: undefined,
-      });
-    });
-  });
-
   Scenario("Route precedence with similar paths", ({ Given, When, Then, And }) => {
     Given("I create a mock with an exact route and a parameterized route on {string}", (_, basePath: string) => {
       mock = schmock();
@@ -277,28 +93,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Namespace confusion with absolute paths", ({ Given, When, Then, And }) => {
-    Given("I create a mock with namespace {string} and a users route", (_, namespace: string) => {
-      mock = schmock({ namespace });
-      mock("GET /users", []);
-    });
-
-    When("I test both namespace scenarios", async () => {
-      responses = [];
-      responses.push(await mock.handle("GET", "/users"));
-      responses.push(await mock.handle("GET", "/api/v1/users"));
-    });
-
-    Then("the wrong namespace should receive status {int}", (_, status: number) => {
-      expect(responses[0].status).toBe(status);
-    });
-
-    And("the correct namespace should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(responses[1].body).toEqual(expected);
-    });
-  });
-
   Scenario("Plugin expecting different context structure", ({ Given, When, Then }) => {
     Given("I create a mock with a plugin that reads context properties", () => {
       mock = schmock();
@@ -371,46 +165,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Common typos in method names", ({ Given, When, Then, And }) => {
-    let errors: Error[] = [];
-
-    Given("I create an empty mock for testing method typos", () => {
-      mock = schmock();
-    });
-
-    When("I test all common method typos", () => {
-      errors = [];
-      const typos = ["GETS /users", "post /users", "GET/users"];
-
-      for (const typo of typos) {
-        try {
-          mock(typo as Schmock.RouteKey, "test");
-          errors.push(new Error("No error thrown"));
-        } catch (e) {
-          errors.push(e as Error);
-        }
-      }
-    });
-
-    Then("the wrong method typo should throw RouteParseError", () => {
-      expect(errors[0]).not.toBeNull();
-      expect(errors[0].constructor.name).toBe("RouteParseError");
-      expect(errors[0].message).toContain("Invalid route key format");
-    });
-
-    And("the lowercase method typo should throw RouteParseError", () => {
-      expect(errors[1]).not.toBeNull();
-      expect(errors[1].constructor.name).toBe("RouteParseError");
-      expect(errors[1].message).toContain("Invalid route key format");
-    });
-
-    And("the missing space typo should throw RouteParseError", () => {
-      expect(errors[2]).not.toBeNull();
-      expect(errors[2].constructor.name).toBe("RouteParseError");
-      expect(errors[2].message).toContain("Invalid route key format");
-    });
-  });
-
   Scenario("Registering duplicate routes first route wins", ({ Given, When, Then }) => {
     Given("I create a mock with two routes on {string} with different data", (_, route: string) => {
       mock = schmock();
@@ -429,27 +183,4 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Plugin returning unexpected structure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with a plugin that returns an invalid structure", () => {
-      mock = schmock();
-      const badPlugin = {
-        name: "bad-structure",
-        process: () => ({ wrong: "structure" }),
-      };
-      mock("GET /bad", "original").pipe(badPlugin as any);
-    });
-
-    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/error-handling.steps.ts

@@ -8,7 +8,6 @@ const feature = await loadFeature("../../features/error-handling.feature");
 describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
-  let error: Error | null = null;
 
   Scenario("Route not found returns 404", ({ Given, When, Then, And }) => {
     Given("I create a mock with a GET /users route returning a user list", () => {
@@ -54,48 +53,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Invalid route key throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with an invalid HTTP method", () => {
-      error = null;
-      try {
-        mock = schmock();
-        mock("INVALID_METHOD /path" as any, "response");
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteParseError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain("Invalid route key format");
-    });
-  });
-
-  Scenario("Empty route path throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with an empty path", () => {
-      error = null;
-      try {
-        mock = schmock();
-        mock("GET " as any, "response");
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteParseError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain("Invalid route key format");
-    });
-  });
-
   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();
@@ -197,29 +154,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Invalid JSON generator with JSON content-type throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to register a route with a circular reference as JSON", () => {
-      error = null;
-      try {
-        mock = schmock();
-        const circularRef: Record<string, unknown> = {};
-        circularRef.self = circularRef;
-        mock("GET /invalid", circularRef, { contentType: "application/json" });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw a RouteDefinitionError", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe("RouteDefinitionError");
-    });
-
-    And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain(message);
-    });
-  });
-
   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 });

package/src/steps/http-methods.steps.ts

@@ -9,7 +9,6 @@ describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
   let responses: any[] = [];
-  let error: Error | null = null;
 
   Scenario("GET method with query parameters", ({ Given, When, Then }) => {
     Given("I create a mock with a GET search endpoint", () => {
@@ -255,71 +254,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Method case sensitivity", ({ Given, When, Then }) => {
-    error = null;
-
-    Given("I create an empty mock for case sensitivity testing", () => {
-      mock = schmock();
-    });
-
-    When("I attempt to create a mock with lowercase method", () => {
-      error = null;
-      try {
-        mock('get /test' as Schmock.RouteKey, { method: 'get' });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw RouteParseError for invalid method case", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
-      expect(error!.message).toContain('Invalid route key format');
-    });
-  });
-
-  Scenario("Unsupported HTTP methods", ({ Given, When, Then }) => {
-    error = null;
-
-    Given("I create an empty mock for unsupported method testing", () => {
-      mock = schmock();
-    });
-
-    When("I attempt to create a mock with unsupported method", () => {
-      error = null;
-      try {
-        mock('CUSTOM /endpoint' as Schmock.RouteKey, { custom: true });
-      } catch (e) {
-        error = e as Error;
-      }
-    });
-
-    Then("it should throw RouteParseError for unsupported method", () => {
-      expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
-      expect(error!.message).toContain('Invalid route key format');
-    });
-  });
-
-  Scenario("Method with special characters in path", ({ Given, When, Then }) => {
-    Given("I create a mock with nested parameterized path segments", () => {
-      mock = schmock();
-      mock('GET /api/v1/users/:id/posts/:post-id', ({ params }) => ({
-        userId: params.id,
-        postId: params['post-id'],
-      }));
-    });
-
-    When("I make a GET request to {string}", async (_, path: string) => {
-      response = await mock.handle('GET', path);
-    });
-
-    Then("I should receive special characters response:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
   Scenario("Method with request headers validation", ({ Given, When, Then, And }) => {
     Given("I create a mock with authorization header checking", () => {
       mock = schmock();

package/src/steps/interceptor.steps.ts

@@ -0,0 +1,206 @@
+/// <reference path="../../schmock.d.ts" />
+
+import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
+import { expect, 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: ReturnType<typeof vi.fn>;
+  let fetchResponse: Response | undefined;
+
+  function setup() {
+    originalFetch = globalThis.fetch;
+    savedFetch = vi.fn().mockResolvedValue(new Response("real backend"));
+    globalThis.fetch = savedFetch;
+    mock = schmock();
+    fetchResponse = undefined;
+  }
+
+  AfterEachScenario(() => {
+    handle?.restore();
+    handle = undefined;
+    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("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 (e) {
+        error = e as Error;
+      }
+    });
+
+    Then("it should throw an error about already intercepting", () => {
+      expect(error?.message).toMatch(/already intercepting/i);
+    });
+  });
+});