@schmock/core 2.2.2 → 2.3.0

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

@@ -0,0 +1,457 @@
+/// <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/http-methods.steps.ts

@@ -5,6 +5,10 @@ import type { CallableMockInstance, Plugin } from "../types";
 
 const feature = await loadFeature("../../features/http-methods.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;
@@ -299,14 +303,21 @@ describeFeature(feature, ({ Scenario }) => {
       mock = schmock();
       const loggerPlugin: Plugin = {
         name: 'method-logger',
-        process: (ctx, response) => ({
-          context: ctx,
-          response: {
-            ...response,
-            method: ctx.method,
-            logged: true,
-          },
-        }),
+        process: (ctx, pluginResponse) => {
+          if (!isRecord(pluginResponse)) {
+            throw new Error(
+              "Expected the logger plugin response to be an object",
+            );
+          }
+          return {
+            context: ctx,
+            response: {
+              ...pluginResponse,
+              method: ctx.method,
+              logged: true,
+            },
+          };
+        },
       };
       mock('GET /logged', { data: 'get' }).pipe(loggerPlugin);
       mock('POST /logged', { data: 'post' }).pipe(loggerPlugin);

package/src/steps/lifecycle-events.steps.ts

@@ -15,6 +15,19 @@ describeFeature(feature, ({ Scenario }) => {
     };
   }
 
+  function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null;
+  }
+
+  function eventData(type: string): Record<string, unknown> {
+    const event = events.find((candidate) => candidate.type === type);
+    expect(event).toBeDefined();
+    if (!event || !isRecord(event.data)) {
+      throw new Error(`Expected object payload for ${type}`);
+    }
+    return event.data;
+  }
+
   Scenario("Events fire at correct times", ({ Given, And, When, Then }) => {
     Given('a mock with a route "GET /items"', () => {
       mock = schmock({ state: {} });
@@ -33,58 +46,52 @@ describeFeature(feature, ({ Scenario }) => {
       await mock.handle("GET", "/items");
     });
 
-    Then('the "request:start" event fired', () => {
-      expect(events.some((e) => e.type === "request:start")).toBe(true);
+    Then("the event order should be {string}", (_, expectedOrder: string) => {
+      expect(events.map((event) => event.type)).toEqual(
+        expectedOrder.split(","),
+      );
     });
 
     And('the "request:match" event fired with routePath "/items"', () => {
-      const match = events.find((e) => e.type === "request:match");
-      expect(match).toBeDefined();
-      const data = match?.data as Record<string, unknown>;
-      expect(data.routePath).toBe("/items");
+      expect(eventData("request:match").routePath).toBe("/items");
     });
 
     And('the "request:end" event fired with status 200', () => {
-      const end = events.find((e) => e.type === "request:end");
-      expect(end).toBeDefined();
-      const data = end?.data as Record<string, unknown>;
-      expect(data.status).toBe(200);
+      expect(eventData("request:end").status).toBe(200);
     });
   });
 
-  Scenario("Not found event fires for unmatched routes", ({ Given, And, When, Then }) => {
-    Given('a mock with a route "GET /items"', () => {
-      mock = schmock({ state: {} });
-      mock("GET /items", [{ id: 1 }], {});
-    });
-
-    And("I register listeners for all events", () => {
-      events = [];
-      mock.on("request:start", collectEvent("request:start"));
-      mock.on("request:match", collectEvent("request:match"));
-      mock.on("request:notfound", collectEvent("request:notfound"));
-      mock.on("request:end", collectEvent("request:end"));
-    });
-
-    When('I request "GET /missing"', async () => {
-      await mock.handle("GET", "/missing");
-    });
-
-    Then('the "request:start" event fired', () => {
-      expect(events.some((e) => e.type === "request:start")).toBe(true);
-    });
-
-    And('the "request:notfound" event fired', () => {
-      expect(events.some((e) => e.type === "request:notfound")).toBe(true);
-    });
-
-    And('the "request:end" event fired with status 404', () => {
-      const end = events.find((e) => e.type === "request:end");
-      expect(end).toBeDefined();
-      const data = end?.data as Record<string, unknown>;
-      expect(data.status).toBe(404);
-    });
-  });
+  Scenario(
+    "Not found event fires for unmatched routes",
+    ({ Given, And, When, Then }) => {
+      Given('a mock with a route "GET /items"', () => {
+        mock = schmock({ state: {} });
+        mock("GET /items", [{ id: 1 }], {});
+      });
+
+      And("I register listeners for all events", () => {
+        events = [];
+        mock.on("request:start", collectEvent("request:start"));
+        mock.on("request:match", collectEvent("request:match"));
+        mock.on("request:notfound", collectEvent("request:notfound"));
+        mock.on("request:end", collectEvent("request:end"));
+      });
+
+      When('I request "GET /missing"', async () => {
+        await mock.handle("GET", "/missing");
+      });
+
+      Then("the event order should be {string}", (_, expectedOrder: string) => {
+        expect(events.map((event) => event.type)).toEqual(
+          expectedOrder.split(","),
+        );
+      });
+
+      And('the "request:end" event fired with status 404', () => {
+        expect(eventData("request:end").status).toBe(404);
+      });
+    },
+  );
 
   Scenario("Off removes listener", ({ Given, And, When, Then }) => {
     Given('a mock with a route "GET /items"', () => {