@schmock/core 1.13.0 → 2.0.1

package/src/helpers.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import {
+  badRequest,
+  created,
+  forbidden,
+  noContent,
+  notFound,
+  paginate,
+  serverError,
+  unauthorized,
+} from "./helpers.js";
+
+describe("notFound", () => {
+  it("returns 404 with default message", () => {
+    expect(notFound()).toEqual([404, { message: "Not Found" }]);
+  });
+  it("returns 404 with custom string message", () => {
+    expect(notFound("User not found")).toEqual([
+      404,
+      { message: "User not found" },
+    ]);
+  });
+  it("returns 404 with custom object", () => {
+    expect(notFound({ code: "NOT_FOUND", detail: "gone" })).toEqual([
+      404,
+      { code: "NOT_FOUND", detail: "gone" },
+    ]);
+  });
+});
+
+describe("badRequest", () => {
+  it("returns 400 with default message", () => {
+    expect(badRequest()).toEqual([400, { message: "Bad Request" }]);
+  });
+  it("returns 400 with custom string", () => {
+    expect(badRequest("Invalid email")).toEqual([
+      400,
+      { message: "Invalid email" },
+    ]);
+  });
+});
+
+describe("unauthorized", () => {
+  it("returns 401 with default message", () => {
+    expect(unauthorized()).toEqual([401, { message: "Unauthorized" }]);
+  });
+});
+
+describe("forbidden", () => {
+  it("returns 403 with default message", () => {
+    expect(forbidden()).toEqual([403, { message: "Forbidden" }]);
+  });
+});
+
+describe("serverError", () => {
+  it("returns 500 with default message", () => {
+    expect(serverError()).toEqual([500, { message: "Internal Server Error" }]);
+  });
+});
+
+describe("created", () => {
+  it("returns 201 with body", () => {
+    expect(created({ id: 1, name: "John" })).toEqual([
+      201,
+      { id: 1, name: "John" },
+    ]);
+  });
+});
+
+describe("noContent", () => {
+  it("returns 204 with null body", () => {
+    expect(noContent()).toEqual([204, null]);
+  });
+});
+
+describe("paginate", () => {
+  const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
+
+  it("returns first page with default pageSize", () => {
+    const result = paginate(items);
+    expect(result).toEqual({
+      data: items,
+      page: 1,
+      pageSize: 10,
+      total: 5,
+      totalPages: 1,
+    });
+  });
+
+  it("paginates correctly with custom options", () => {
+    const result = paginate(items, { page: 2, pageSize: 2 });
+    expect(result).toEqual({
+      data: [{ id: 3 }, { id: 4 }],
+      page: 2,
+      pageSize: 2,
+      total: 5,
+      totalPages: 3,
+    });
+  });
+
+  it("returns empty data for page beyond range", () => {
+    const result = paginate(items, { page: 10, pageSize: 2 });
+    expect(result.data).toEqual([]);
+    expect(result.total).toBe(5);
+  });
+
+  it("page=0 falls back to page 1 (falsy default)", () => {
+    const result = paginate(items, { page: 0, pageSize: 2 });
+    // page=0 is falsy, so options.page || 1 => 1
+    expect(result.page).toBe(1);
+    expect(result.data).toEqual([{ id: 1 }, { id: 2 }]);
+  });
+
+  it("pageSize=0 falls back to default 10 (falsy default)", () => {
+    const result = paginate(items, { pageSize: 0 });
+    // pageSize=0 is falsy, so options.pageSize || 10 => 10
+    expect(result.pageSize).toBe(10);
+    expect(result.data).toEqual(items);
+  });
+
+  it("handles empty array", () => {
+    const result = paginate([], { page: 1, pageSize: 5 });
+    expect(result).toEqual({
+      data: [],
+      page: 1,
+      pageSize: 5,
+      total: 0,
+      totalPages: 0,
+    });
+  });
+
+  it("negative page produces empty data (start index < 0)", () => {
+    const result = paginate(items, { page: -1, pageSize: 2 });
+    // (page - 1) * pageSize = (-1 - 1) * 2 = -4
+    // items.slice(-4, -2) => items from index 1 to 3
+    expect(result.page).toBe(-1);
+    expect(result.pageSize).toBe(2);
+    expect(result.total).toBe(5);
+  });
+
+  it("negative pageSize returns empty data", () => {
+    const result = paginate(items, { page: 1, pageSize: -5 });
+    // start = 0, end = 0 + (-5) = -5 => items.slice(0, -5) => []
+    expect(result.data).toEqual([]);
+    expect(result.pageSize).toBe(-5);
+  });
+});

package/src/helpers.ts

@@ -0,0 +1,58 @@
+/// <reference path="../schmock.d.ts" />
+
+export function notFound(
+  message: string | object = "Not Found",
+): [number, object] {
+  const body = typeof message === "string" ? { message } : message;
+  return [404, body];
+}
+
+export function badRequest(
+  message: string | object = "Bad Request",
+): [number, object] {
+  const body = typeof message === "string" ? { message } : message;
+  return [400, body];
+}
+
+export function unauthorized(
+  message: string | object = "Unauthorized",
+): [number, object] {
+  const body = typeof message === "string" ? { message } : message;
+  return [401, body];
+}
+
+export function forbidden(
+  message: string | object = "Forbidden",
+): [number, object] {
+  const body = typeof message === "string" ? { message } : message;
+  return [403, body];
+}
+
+export function serverError(
+  message: string | object = "Internal Server Error",
+): [number, object] {
+  const body = typeof message === "string" ? { message } : message;
+  return [500, body];
+}
+
+export function created(body: object): [number, object] {
+  return [201, body];
+}
+
+export function noContent(): [number, null] {
+  return [204, null];
+}
+
+export function paginate<T>(
+  items: T[],
+  options: Schmock.PaginateOptions = {},
+): Schmock.PaginatedResponse<T> {
+  const page = options.page || 1;
+  const pageSize = options.pageSize || 10;
+  const total = items.length;
+  const totalPages = Math.ceil(total / pageSize);
+  const start = (page - 1) * pageSize;
+  const end = start + pageSize;
+  const data = items.slice(start, end);
+  return { data, page, pageSize, total, totalPages };
+}

package/src/index.ts

@@ -70,6 +70,8 @@ export function schmock(
       getState: instance.getState.bind(instance),
       listen: instance.listen.bind(instance),
       close: instance.close.bind(instance),
+      intercept: (options?: Schmock.InterceptOptions) =>
+        instance.intercept(options),
     },
   );
 
@@ -82,6 +84,7 @@ export function schmock(
 export {
   HTTP_METHODS,
   isHttpMethod,
+  isRouteNotFound,
   isStatusTuple,
   ROUTE_NOT_FOUND_CODE,
   toHttpMethod,
@@ -99,6 +102,17 @@ export {
   SchemaValidationError,
   SchmockError,
 } from "./errors.js";
+// Re-export response helpers
+export {
+  badRequest,
+  created,
+  forbidden,
+  noContent,
+  notFound,
+  paginate,
+  serverError,
+  unauthorized,
+} from "./helpers.js";
 // Re-export HTTP server helpers
 export {
   collectBody,
@@ -107,12 +121,19 @@ export {
   writeSchmockResponse,
 } from "./http-helpers.js";
 // Re-export types
+// Re-export interceptor
+export { createFetchInterceptor } from "./interceptor.js";
+// Re-export types
 export type {
+  AdapterRequest,
+  AdapterResponse,
   CallableMockInstance,
   Generator,
   GeneratorFunction,
   GlobalConfig,
   HttpMethod,
+  InterceptHandle,
+  InterceptOptions,
   Plugin,
   PluginContext,
   PluginResult,

package/src/interceptor.test.ts

@@ -0,0 +1,291 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { schmock } from "./index.js";
+
+describe("mock.intercept()", () => {
+  let originalFetch: typeof globalThis.fetch;
+  let mock: Schmock.CallableMockInstance;
+
+  beforeEach(() => {
+    originalFetch = globalThis.fetch;
+    globalThis.fetch = vi.fn().mockResolvedValue(new Response("real backend"));
+    mock = schmock();
+  });
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  it("intercepts a matched fetch request and returns mocked response", async () => {
+    mock("GET /api/users", [{ id: 1, name: "Alice" }]);
+    const handle = mock.intercept();
+
+    const res = await fetch("http://localhost/api/users");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual([{ id: 1, name: "Alice" }]);
+
+    handle.restore();
+  });
+
+  it("passes through unmatched routes when passthrough is true", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    // Save reference to the vi.fn() mock that the interceptor will call on passthrough
+    const mockFetch = globalThis.fetch as ReturnType<typeof vi.fn>;
+    const handle = mock.intercept({ passthrough: true });
+
+    await fetch("http://localhost/api/other");
+    // The interceptor saves the vi.fn() as its original and calls it on passthrough
+    expect(mockFetch).toHaveBeenCalled();
+    handle.restore();
+  });
+
+  it("returns 404 when passthrough is disabled and route not found", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    const handle = mock.intercept({ passthrough: false });
+
+    const res = await fetch("http://localhost/api/other");
+    expect(res.status).toBe(404);
+
+    handle.restore();
+  });
+
+  it("restores original fetch", () => {
+    const savedFetch = globalThis.fetch;
+    const handle = mock.intercept();
+
+    expect(globalThis.fetch).not.toBe(savedFetch);
+    handle.restore();
+    expect(globalThis.fetch).toBe(savedFetch);
+  });
+
+  it("reports active status", () => {
+    const handle = mock.intercept();
+    expect(handle.active).toBe(true);
+
+    handle.restore();
+    expect(handle.active).toBe(false);
+  });
+
+  it("filters by baseUrl", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    const savedFetch = globalThis.fetch;
+    const handle = mock.intercept({ baseUrl: "/api" });
+
+    await fetch("http://localhost/other/path");
+    // Should have called the saved fetch (passthrough for non-matching baseUrl)
+    expect(savedFetch).toHaveBeenCalled();
+
+    handle.restore();
+  });
+
+  it("throws when intercepting twice", () => {
+    const handle = mock.intercept();
+    expect(() => mock.intercept()).toThrow(/already intercepting/i);
+    handle.restore();
+  });
+
+  it("applies beforeRequest hook", async () => {
+    mock("GET /api/users", ({ headers }) => [
+      200,
+      { token: headers["x-token"] },
+    ]);
+    const handle = mock.intercept({
+      beforeRequest: (req) => ({
+        ...req,
+        headers: { ...req.headers, "x-token": "injected" },
+      }),
+    });
+
+    const res = await fetch("http://localhost/api/users");
+    expect(await res.json()).toEqual({ token: "injected" });
+
+    handle.restore();
+  });
+
+  it("applies beforeResponse hook", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    const handle = mock.intercept({
+      beforeResponse: (resp) => ({
+        ...resp,
+        headers: { ...resp.headers, "x-mock": "true" },
+      }),
+    });
+
+    const res = await fetch("http://localhost/api/users");
+    expect(res.headers.get("x-mock")).toBe("true");
+
+    handle.restore();
+  });
+
+  it("handles relative URLs", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    const handle = mock.intercept();
+
+    const res = await fetch("/api/users");
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual([{ id: 1 }]);
+
+    handle.restore();
+  });
+
+  it("applies errorFormatter when beforeRequest throws", async () => {
+    mock("GET /api/users", [{ id: 1 }]);
+    const handle = mock.intercept({
+      beforeRequest: () => {
+        throw new Error("hook failed");
+      },
+      errorFormatter: (err) => ({ custom: err.message }),
+    });
+
+    const res = await fetch("http://localhost/api/users");
+    expect(res.status).toBe(500);
+    expect(await res.json()).toEqual({ custom: "hook failed" });
+
+    handle.restore();
+  });
+
+  it("normalizes header keys to lowercase", async () => {
+    mock("POST /api/data", ({ headers }) => [
+      200,
+      { auth: headers.authorization, ct: headers["content-type"] },
+    ]);
+    const handle = mock.intercept();
+
+    const res = await fetch("http://localhost/api/data", {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer tok",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({}),
+    });
+    expect(await res.json()).toEqual({
+      auth: "Bearer tok",
+      ct: "application/json",
+    });
+
+    handle.restore();
+  });
+
+  it("parses JSON body from fetch init", async () => {
+    mock("POST /api/users", ({ body }) => [201, body]);
+    const handle = mock.intercept();
+
+    const res = await fetch("http://localhost/api/users", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: "Alice" }),
+    });
+    expect(res.status).toBe(201);
+    expect(await res.json()).toEqual({ name: "Alice" });
+
+    handle.restore();
+  });
+
+  it("intercepts fetch called with a Request object", async () => {
+    mock("GET /api/users", [{ id: 1, name: "Alice" }]);
+    const handle = mock.intercept();
+
+    const req = new Request("http://localhost/api/users");
+    const res = await fetch(req);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual([{ id: 1, name: "Alice" }]);
+
+    handle.restore();
+  });
+
+  it("prefers init.headers over Request.headers", async () => {
+    mock("GET /api/data", ({ headers }) => [200, { val: headers["x-custom"] }]);
+    const handle = mock.intercept();
+
+    const req = new Request("http://localhost/api/data", {
+      headers: { "X-Custom": "from-request" },
+    });
+    const res = await fetch(req, {
+      headers: { "X-Custom": "from-init" },
+    });
+    expect(await res.json()).toEqual({ val: "from-init" });
+
+    handle.restore();
+  });
+
+  it("parses URLSearchParams body", async () => {
+    mock("POST /api/form", ({ body }) => [200, body]);
+    const handle = mock.intercept();
+
+    const params = new URLSearchParams();
+    params.set("name", "Alice");
+    params.set("role", "admin");
+
+    const res = await fetch("http://localhost/api/form", {
+      method: "POST",
+      body: params,
+    });
+    expect(await res.json()).toEqual({ name: "Alice", role: "admin" });
+
+    handle.restore();
+  });
+
+  it("baseUrl /api should NOT match /apiv2 (segment boundary)", async () => {
+    mock("GET /apiv2/data", [{ v2: true }]);
+    const savedFetch = globalThis.fetch;
+    const handle = mock.intercept({ baseUrl: "/api" });
+
+    // /apiv2/data does not start with "/api/" — it should passthrough
+    await fetch("http://localhost/apiv2/data");
+    expect(savedFetch).toHaveBeenCalled();
+
+    handle.restore();
+  });
+
+  it("baseUrl with trailing slash matches the same routes as without", async () => {
+    mock("GET /api/items", [{ id: 1 }]);
+
+    // Without trailing slash
+    const handle1 = mock.intercept({ baseUrl: "/api" });
+    const res1 = await fetch("http://localhost/api/items");
+    expect(res1.status).toBe(200);
+    expect(await res1.json()).toEqual([{ id: 1 }]);
+    handle1.restore();
+
+    // With trailing slash — should still match /api/items
+    const handle2 = mock.intercept({ baseUrl: "/api/" });
+    const res2 = await fetch("http://localhost/api/items");
+    expect(res2.status).toBe(200);
+    expect(await res2.json()).toEqual([{ id: 1 }]);
+    handle2.restore();
+  });
+
+  it("extractBody: init.body wins over Request.body per Fetch spec", async () => {
+    mock("POST /api/data", ({ body }) => [200, body]);
+    const handle = mock.intercept();
+
+    const req = new Request("http://localhost/api/data", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ source: "request" }),
+    });
+
+    const res = await fetch(req, {
+      body: JSON.stringify({ source: "init" }),
+    });
+    expect(await res.json()).toEqual({ source: "init" });
+
+    handle.restore();
+  });
+
+  it("extractBody: failed JSON parse falls back to text", async () => {
+    mock("POST /api/text", ({ body }) => [200, { received: body }]);
+    const handle = mock.intercept();
+
+    const res = await fetch("http://localhost/api/text", {
+      method: "POST",
+      headers: { "content-type": "text/plain" },
+      body: "not-json-{broken",
+    });
+
+    const json = await res.json();
+    expect(json.received).toBe("not-json-{broken");
+
+    handle.restore();
+  });
+});