@schmock/core 2.2.2 → 2.3.0

package/src/steps/interceptor.steps.ts

@@ -1,260 +0,0 @@
-/// <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("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);
-    });
-
-    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", () => {
-      expect(savedFetch).toHaveBeenCalled();
-    });
-  });
-
-  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);
-    });
-
-    When("I fetch \"https://api.example.com/users\"", async () => {
-      await fetch("https://api.example.com/users");
-    });
-
-    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);
-    });
-  });
-});

package/src/steps/stateful-workflows.steps.ts

@@ -1,353 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { expect } from "vitest";
-import { schmock } from "../index";
-import type { CallableMockInstance } from "../types";
-
-interface CartItem {
-  id: number;
-  name: string;
-  price: number;
-  quantity: number;
-}
-
-interface UserRecord {
-  username: string;
-  password: string;
-  profile: { name: string; role: string };
-}
-
-interface SessionRecord {
-  user: string;
-  profile: { name: string; role: string };
-  loginTime: string;
-}
-
-const feature = await loadFeature("../../features/stateful-workflows.feature");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: CallableMockInstance;
-  let response: any;
-  let sessionToken: string;
-  let addedItemIds: number[] = [];
-
-  Scenario("Shopping cart workflow", ({ Given, When, Then, And }) => {
-    addedItemIds = [];
-
-    Given("I create a stateful shopping cart mock", () => {
-      const items: CartItem[] = [];
-      let total = 0;
-
-      mock = schmock();
-      mock("GET /cart", () => ({
-        items,
-        total,
-        count: items.length,
-      }));
-      mock("POST /cart/add", ({ body }) => {
-        const b = body as Record<string, unknown>;
-        const item: CartItem = {
-          id: Date.now(),
-          name: b.name as string,
-          price: b.price as number,
-          quantity: (b.quantity as number) || 1,
-        };
-        items.push(item);
-        total += item.price * item.quantity;
-        return {
-          message: "Item added to cart",
-          added: item,
-          cart: {
-            items,
-            total,
-            count: items.length,
-          },
-        };
-      });
-      mock("DELETE /cart/:id", ({ params }) => {
-        const itemId = parseInt(params.id);
-        const itemIndex = items.findIndex((item) => item.id === itemId);
-        if (itemIndex === -1) {
-          return [404, { error: "Item not found in cart" }];
-        }
-        const removedItem = items[itemIndex];
-        total -= removedItem.price * removedItem.quantity;
-        items.splice(itemIndex, 1);
-        return {
-          message: "Item removed from cart",
-          item: removedItem,
-          cart: {
-            items,
-            total,
-            count: items.length,
-          },
-        };
-      });
-      mock("POST /cart/clear", () => {
-        items.length = 0;
-        total = 0;
-        return {
-          message: "Cart cleared",
-          cart: {
-            items,
-            total,
-            count: items.length,
-          },
-        };
-      });
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("the response should show an empty cart with count {int}", (_, expectedCount: number) => {
-      expect(response.body.count).toBe(expectedCount);
-      expect(response.body.items).toEqual([]);
-      expect(response.body.total).toBe(0);
-    });
-
-    When("I add item with name {string} and price {string}", async (_, itemName: string, priceStr: string) => {
-      const price = parseFloat(priceStr);
-      response = await mock.handle("POST", "/cart/add", {
-        body: { name: itemName, price }
-      });
-      addedItemIds.push(response.body.added.id);
-    });
-
-    And("I add second item with name {string} and price {string}", async (_, itemName: string, priceStr: string) => {
-      const price = parseFloat(priceStr);
-      response = await mock.handle("POST", "/cart/add", {
-        body: { name: itemName, price }
-      });
-      addedItemIds.push(response.body.added.id);
-    });
-
-    Then("the cart should contain {int} items", async (_, expectedCount: number) => {
-      const cartResponse = await mock.handle("GET", "/cart");
-      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
-      expect(body.count).toBe(expectedCount);
-    });
-
-    Then("the cart should contain {int} item", async (_, expectedCount: number) => {
-      const cartResponse = await mock.handle("GET", "/cart");
-      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
-      expect(body.count).toBe(expectedCount);
-    });
-
-    And("the initial cart total should be {string}", async (_, expectedTotalStr: string) => {
-      const expectedTotal = parseFloat(expectedTotalStr);
-      const cartResponse = await mock.handle("GET", "/cart");
-      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
-      expect(body.total).toBe(expectedTotal);
-    });
-
-    And("the final cart total should be {string}", async (_, expectedTotalStr: string) => {
-      const expectedTotal = parseFloat(expectedTotalStr);
-      const cartResponse = await mock.handle("GET", "/cart");
-      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
-      expect(body.total).toBe(expectedTotal);
-    });
-
-    When("I remove the first item from the cart", async () => {
-      const cartResponse = await mock.handle("GET", "/cart");
-      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
-      const firstItemId = body.items[0].id;
-      response = await mock.handle("DELETE", `/cart/${firstItemId}`);
-    });
-  });
-
-  Scenario("User session simulation", ({ Given, When, Then, And }) => {
-    sessionToken = "";
-
-    Given("I create a session-based authentication mock", () => {
-      const users: UserRecord[] = [
-        { username: "admin", password: "secret", profile: { name: "Admin User", role: "administrator" } },
-        { username: "user1", password: "pass123", profile: { name: "Regular User", role: "user" } },
-      ];
-      const sessions: Record<string, SessionRecord> = {};
-
-      mock = schmock();
-      mock("POST /auth/login", ({ body }) => {
-        const b = body as Record<string, unknown>;
-        const user = users.find((u) => u.username === b.username && u.password === b.password);
-        if (!user) {
-          return [401, { error: "Invalid credentials" }];
-        }
-        const token = "token-" + user.username + "-" + Date.now();
-        sessions[token] = {
-          user: user.username,
-          profile: user.profile,
-          loginTime: new Date().toISOString(),
-        };
-        return {
-          message: "Login successful",
-          token,
-          user: user.profile,
-        };
-      });
-      mock("GET /profile", ({ headers }) => {
-        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
-        if (!token || !sessions[token]) {
-          return [401, { error: "Unauthorized" }];
-        }
-        const session = sessions[token];
-        return {
-          user: session.user,
-          profile: session.profile,
-          loginTime: session.loginTime,
-          session: {
-            active: true,
-          },
-        };
-      });
-      mock("POST /auth/logout", ({ headers }) => {
-        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
-        if (!token || !sessions[token]) {
-          return [401, { error: "Unauthorized" }];
-        }
-        delete sessions[token];
-        return { message: "Logged out successfully" };
-      });
-    });
-
-    When("I login with username {string} and password {string}", async (_, username: string, password: string) => {
-      response = await mock.handle("POST", "/auth/login", {
-        body: { username, password }
-      });
-      if (response.body.token) {
-        sessionToken = response.body.token;
-      }
-    });
-
-    Then("I should receive a session token", () => {
-      expect(response.body.token).toBeDefined();
-      expect(typeof response.body.token).toBe('string');
-      expect(response.body.token.length).toBeGreaterThan(0);
-    });
-
-    And("the response should contain user info with role {string}", (_, expectedRole: string) => {
-      expect(response.body.user).toBeDefined();
-      expect(response.body.user.role).toBe(expectedRole);
-    });
-
-    When("I request {string} with the session token", async (_, path: string) => {
-      response = await mock.handle("GET", path, {
-        headers: { authorization: `Bearer ${sessionToken}` }
-      });
-    });
-
-    Then("I should get my profile information", () => {
-      expect(response.body.user).toBeDefined();
-      expect(response.body.session).toBeDefined();
-    });
-
-    And("the session should be marked as active", () => {
-      expect(response.body.session.active).toBe(true);
-    });
-
-    When("I logout with the session token", async () => {
-      response = await mock.handle("POST", "/auth/logout", {
-        headers: { authorization: `Bearer ${sessionToken}` }
-      });
-    });
-
-    Then("the logout should be successful", () => {
-      expect(response.body.message).toContain("Logged out successfully");
-    });
-
-    When("I request {string} with the same token", async (_, path: string) => {
-      response = await mock.handle("GET", path, {
-        headers: { authorization: `Bearer ${sessionToken}` }
-      });
-    });
-
-    Then("I should get a {int} unauthorized response", (_, expectedStatus: number) => {
-      expect(response.status).toBe(expectedStatus);
-    });
-  });
-
-  Scenario("Multi-user state isolation", ({ Given, When, Then, And }) => {
-    Given("I create a multi-user counter mock", () => {
-      const counters: Record<string, number> = {};
-
-      mock = schmock();
-      mock("POST /counter/:userId/increment", ({ params }) => {
-        const userId = params.userId;
-        if (!counters[userId]) {
-          counters[userId] = 0;
-        }
-        counters[userId]++;
-        return {
-          userId,
-          count: counters[userId],
-          message: "Counter incremented for user " + userId,
-        };
-      });
-      mock("GET /counter/:userId", ({ params }) => {
-        const userId = params.userId;
-        const count = counters[userId] || 0;
-        return {
-          userId,
-          count,
-        };
-      });
-      mock("GET /counters/summary", () => {
-        const totalCount = Object.values(counters).reduce((sum, count) => sum + count, 0);
-        const userCount = Object.keys(counters).length;
-        return {
-          totalCounts: totalCount,
-          totalUsers: userCount,
-          counters,
-        };
-      });
-    });
-
-    When("user {string} increments their counter {int} times", async (_, userId: string, times: number) => {
-      for (let i = 0; i < times; i++) {
-        await mock.handle("POST", `/counter/${userId}/increment`);
-      }
-    });
-
-    And("user {string} increments their counter {int} times", async (_, userId: string, times: number) => {
-      for (let i = 0; i < times; i++) {
-        await mock.handle("POST", `/counter/${userId}/increment`);
-      }
-    });
-
-    Then("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
-      const response = await mock.handle("GET", `/counter/${userId}`);
-      const body = response.body as { userId: string; count: number };
-      expect(body.count).toBe(expectedCount);
-    });
-
-    And("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
-      const response = await mock.handle("GET", `/counter/${userId}`);
-      const body = response.body as { userId: string; count: number };
-      expect(body.count).toBe(expectedCount);
-    });
-
-    And("the summary should show {int} total users", async (_, expectedUsers: number) => {
-      const response = await mock.handle("GET", "/counters/summary");
-      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
-      expect(body.totalUsers).toBe(expectedUsers);
-    });
-
-    And("the summary should show total counts of {int}", async (_, expectedTotal: number) => {
-      const response = await mock.handle("GET", "/counters/summary");
-      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
-      expect(body.totalCounts).toBe(expectedTotal);
-    });
-
-    And("each user's state should be independent", async () => {
-      const aliceResponse = await mock.handle("GET", "/counter/alice");
-      const bobResponse = await mock.handle("GET", "/counter/bob");
-      const aliceBody = aliceResponse.body as { userId: string; count: number };
-      const bobBody = bobResponse.body as { userId: string; count: number };
-
-      expect(aliceBody.count).toBe(3);
-      expect(bobBody.count).toBe(2);
-      expect(aliceBody.count).not.toBe(bobBody.count);
-    });
-  });
-});