@schmock/core 2.2.3 → 2.3.1

package/src/interceptor.test.ts

@@ -1,291 +0,0 @@
-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();
-  });
-});

package/src/interceptor.ts

@@ -1,320 +0,0 @@
-/// <reference path="../schmock.d.ts" />
-
-import { isRouteNotFound, toHttpMethod } from "./constants.js";
-
-/**
- * Extract pathname from a URL string, handling both absolute and relative URLs.
- */
-function extractPathname(url: string): string {
-  const queryStart = url.indexOf("?");
-  const urlWithoutQuery = queryStart === -1 ? url : url.slice(0, queryStart);
-
-  if (urlWithoutQuery.includes("://")) {
-    try {
-      return new URL(urlWithoutQuery).pathname;
-    } catch {
-      // Fall through to simple extraction
-    }
-  }
-
-  if (!urlWithoutQuery.startsWith("/")) {
-    return `/${urlWithoutQuery}`;
-  }
-
-  return urlWithoutQuery;
-}
-
-/**
- * Extract origin (scheme + host + port) from a URL string, or null for
- * relative URLs that don't carry one.
- */
-function extractOrigin(url: string): string | null {
-  if (!url.includes("://")) return null;
-  try {
-    return new URL(url).origin;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Parse the user-supplied baseUrl option into its origin and path parts.
- * - "/api"                  → { origin: null, path: "/api" }
- * - "https://x.com/api/v1"  → { origin: "https://x.com", path: "/api/v1" }
- * - "https://x.com"         → { origin: "https://x.com", path: "" }
- *
- * Trailing slash is stripped from the path so the segment-boundary check
- * works the same way for "/api" and "/api/".
- */
-function parseBaseUrl(baseUrl: string): {
-  origin: string | null;
-  path: string;
-} {
-  if (baseUrl.includes("://")) {
-    try {
-      const parsed = new URL(baseUrl);
-      const rawPath = parsed.pathname;
-      const path = rawPath === "/" ? "" : rawPath.replace(/\/$/, "");
-      return { origin: parsed.origin, path };
-    } catch {
-      // Fall through to path-only handling
-    }
-  }
-  return { origin: null, path: baseUrl.replace(/\/$/, "") };
-}
-
-/**
- * Extract query parameters from a URL string.
- */
-function extractQuery(url: string): Record<string, string> {
-  const queryStart = url.indexOf("?");
-  if (queryStart === -1) return {};
-
-  const params = new URLSearchParams(url.slice(queryStart + 1));
-  const result: Record<string, string> = {};
-  params.forEach((value, key) => {
-    result[key] = value;
-  });
-  return result;
-}
-
-/**
- * Extract headers from fetch init or Request object.
- */
-function extractHeaders(
-  input: RequestInfo | URL,
-  init?: RequestInit,
-): Record<string, string> {
-  const headers: Record<string, string> = {};
-
-  const raw =
-    init?.headers ?? (input instanceof Request ? input.headers : undefined);
-  if (!raw) return headers;
-
-  if (raw instanceof Headers) {
-    raw.forEach((value, key) => {
-      headers[key.toLowerCase()] = value;
-    });
-  } else if (Array.isArray(raw)) {
-    for (const [key, value] of raw) {
-      headers[key.toLowerCase()] = value;
-    }
-  } else {
-    for (const key of Object.keys(raw)) {
-      headers[key.toLowerCase()] = (raw as Record<string, string>)[key];
-    }
-  }
-
-  return headers;
-}
-
-/**
- * Extract body from fetch init, parsing JSON when possible.
- */
-async function extractBody(
-  input: RequestInfo | URL,
-  init?: RequestInit,
-): Promise<unknown> {
-  // Per Fetch spec, init.body overrides Request.body when both are present
-  const bodyInit = init?.body ?? (input instanceof Request ? input.body : null);
-  if (bodyInit === null || bodyInit === undefined) return undefined;
-
-  // String body — try to parse as JSON
-  if (typeof bodyInit === "string") {
-    try {
-      return JSON.parse(bodyInit);
-    } catch {
-      return bodyInit;
-    }
-  }
-
-  // URLSearchParams — convert to key/value object
-  if (bodyInit instanceof URLSearchParams) {
-    const result: Record<string, string> = {};
-    bodyInit.forEach((value, key) => {
-      result[key] = value;
-    });
-    return result;
-  }
-
-  // Request with body — clone and read
-  if (input instanceof Request && !init?.body && input.body) {
-    try {
-      return await input.clone().json();
-    } catch {
-      try {
-        return await input.clone().text();
-      } catch {
-        return undefined;
-      }
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Create a fetch interceptor that routes requests through mock.handle().
- */
-export function createFetchInterceptor(
-  handle: (
-    method: Schmock.HttpMethod,
-    path: string,
-    requestOptions?: Schmock.RequestOptions,
-  ) => Promise<Schmock.Response>,
-  options: Schmock.InterceptOptions = {},
-): Schmock.InterceptHandle {
-  const {
-    baseUrl,
-    passthrough = true,
-    beforeRequest,
-    beforeResponse,
-    errorFormatter,
-  } = options;
-
-  const originalFetch = globalThis.fetch;
-  let active = true;
-
-  globalThis.fetch = async (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    // Resolve the URL string
-    const urlString =
-      input instanceof Request
-        ? input.url
-        : input instanceof URL
-          ? input.href
-          : input;
-
-    const path = extractPathname(urlString);
-
-    // BaseUrl filter — non-matching requests go straight to real fetch.
-    // Two modes:
-    //   - origin form ("https://api.example.com/v1"): require matching
-    //     origin AND matching path prefix.
-    //   - path form ("/api"): match pathname prefix only.
-    // Both enforce a segment boundary so "/api" doesn't match "/apiv2".
-    if (baseUrl) {
-      const { origin: baseOrigin, path: basePath } = parseBaseUrl(baseUrl);
-      if (baseOrigin) {
-        const reqOrigin = extractOrigin(urlString);
-        if (reqOrigin !== baseOrigin) {
-          return originalFetch(input, init);
-        }
-      }
-      if (basePath) {
-        const isMatch = path === basePath || path.startsWith(`${basePath}/`);
-        if (!isMatch) {
-          return originalFetch(input, init);
-        }
-      }
-    }
-
-    // Build adapter request
-    const method =
-      input instanceof Request ? input.method : (init?.method ?? "GET");
-    const headers = extractHeaders(input, init);
-    const query = extractQuery(urlString);
-    const body = await extractBody(input, init);
-
-    let adapterRequest: Schmock.AdapterRequest = {
-      method,
-      path,
-      headers,
-      body,
-      query,
-    };
-
-    try {
-      // Apply beforeRequest hook
-      if (beforeRequest) {
-        const modified = await beforeRequest(adapterRequest);
-        if (modified) {
-          adapterRequest = modified;
-        }
-      }
-
-      const schmockResponse = await handle(
-        toHttpMethod(adapterRequest.method),
-        adapterRequest.path,
-        {
-          headers: adapterRequest.headers,
-          body: adapterRequest.body,
-          query: adapterRequest.query,
-        },
-      );
-
-      // Route not found — passthrough or 404
-      if (isRouteNotFound(schmockResponse)) {
-        if (passthrough) {
-          return originalFetch(input, init);
-        }
-        return new Response(
-          JSON.stringify({
-            error: "No matching mock route found",
-            code: "ROUTE_NOT_FOUND",
-          }),
-          {
-            status: 404,
-            headers: { "content-type": "application/json" },
-          },
-        );
-      }
-
-      // Apply beforeResponse hook
-      let response: Schmock.AdapterResponse = schmockResponse;
-      if (beforeResponse) {
-        const modified = await beforeResponse(response, adapterRequest);
-        if (modified) {
-          response = modified;
-        }
-      }
-
-      // Build fetch Response
-      const responseHeaders = new Headers(response.headers);
-      if (
-        !responseHeaders.has("content-type") &&
-        response.body !== null &&
-        response.body !== undefined
-      ) {
-        responseHeaders.set("content-type", "application/json");
-      }
-
-      const responseBody =
-        response.body === null || response.body === undefined
-          ? null
-          : typeof response.body === "string"
-            ? response.body
-            : JSON.stringify(response.body);
-
-      return new Response(responseBody, {
-        status: response.status,
-        headers: responseHeaders,
-      });
-    } catch (error) {
-      if (errorFormatter) {
-        const formatted = errorFormatter(
-          error instanceof Error ? error : new Error(String(error)),
-        );
-        return new Response(JSON.stringify(formatted), {
-          status: 500,
-          headers: { "content-type": "application/json" },
-        });
-      }
-      throw error;
-    }
-  };
-
-  return {
-    restore() {
-      if (active) {
-        globalThis.fetch = originalFetch;
-        active = false;
-      }
-    },
-    get active() {
-      return active;
-    },
-  };
-}