@schmock/core 2.2.2 → 2.3.0

package/src/interceptor.ts

@@ -1,7 +1,100 @@
 /// <reference path="../schmock.d.ts" />
 
+import { isBinaryBody } from "./binary.js";
 import { isRouteNotFound, toHttpMethod } from "./constants.js";
 
+const PASSTHROUGH = Symbol("schmock.fetch.passthrough");
+
+type InterceptorResult = Response | typeof PASSTHROUGH;
+
+function toFetchBinaryBody(
+  body: ArrayBuffer | ArrayBufferView,
+): ArrayBuffer | Uint8Array<ArrayBuffer> {
+  if (body instanceof ArrayBuffer) return body;
+
+  const bytes = new Uint8Array(body.byteLength);
+  bytes.set(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+  return bytes;
+}
+
+interface RegisteredInterceptor {
+  token: symbol;
+  intercept: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Promise<InterceptorResult>;
+}
+
+interface InterceptorSession {
+  baselineFetch: typeof globalThis.fetch;
+  dispatchFetch: typeof globalThis.fetch;
+  interceptors: RegisteredInterceptor[];
+}
+
+let activeSession: InterceptorSession | undefined;
+
+function createInterceptorSession(): InterceptorSession {
+  const baselineFetch = globalThis.fetch;
+  const interceptors: RegisteredInterceptor[] = [];
+  const dispatchFetch: typeof globalThis.fetch = async (input, init) => {
+    const snapshot = interceptors.slice();
+
+    for (let index = snapshot.length - 1; index >= 0; index -= 1) {
+      const result = await snapshot[index].intercept(input, init);
+      if (result !== PASSTHROUGH) {
+        return result;
+      }
+    }
+
+    return baselineFetch(input, init);
+  };
+
+  return { baselineFetch, dispatchFetch, interceptors };
+}
+
+function registerInterceptor(
+  intercept: RegisteredInterceptor["intercept"],
+): Schmock.InterceptHandle {
+  let session = activeSession;
+  if (!session || globalThis.fetch !== session.dispatchFetch) {
+    session = createInterceptorSession();
+    activeSession = session;
+    globalThis.fetch = session.dispatchFetch;
+  }
+
+  const token = Symbol("schmock.fetch.interceptor");
+  session.interceptors.push({ token, intercept });
+  let active = true;
+
+  return {
+    restore() {
+      if (!active) return;
+
+      active = false;
+      const index = session.interceptors.findIndex(
+        (entry) => entry.token === token,
+      );
+      if (index !== -1) {
+        session.interceptors.splice(index, 1);
+      }
+
+      if (session.interceptors.length !== 0) return;
+      if (activeSession === session) {
+        activeSession = undefined;
+      }
+
+      // A library may have installed its own fetch wrapper after Schmock. Its
+      // replacement is now the current owner and must not be overwritten.
+      if (globalThis.fetch === session.dispatchFetch) {
+        globalThis.fetch = session.baselineFetch;
+      }
+    },
+    get active() {
+      return active;
+    },
+  };
+}
+
 /**
  * Extract pathname from a URL string, handling both absolute and relative URLs.
  */
@@ -172,149 +265,143 @@ export function createFetchInterceptor(
     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);
+  return registerInterceptor(
+    async (
+      input: RequestInfo | URL,
+      init?: RequestInit,
+    ): Promise<InterceptorResult> => {
+      // 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 PASSTHROUGH;
+          }
         }
-      }
-      if (basePath) {
-        const isMatch = path === basePath || path.startsWith(`${basePath}/`);
-        if (!isMatch) {
-          return originalFetch(input, init);
+        if (basePath) {
+          const isMatch = path === basePath || path.startsWith(`${basePath}/`);
+          if (!isMatch) {
+            return PASSTHROUGH;
+          }
         }
       }
-    }
 
-    // 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,
-    };
+      // 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;
+      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",
-          }),
+        const schmockResponse = await handle(
+          toHttpMethod(adapterRequest.method),
+          adapterRequest.path,
           {
-            status: 404,
-            headers: { "content-type": "application/json" },
+            headers: adapterRequest.headers,
+            body: adapterRequest.body,
+            query: adapterRequest.query,
           },
         );
-      }
 
-      // Apply beforeResponse hook
-      let response: Schmock.AdapterResponse = schmockResponse;
-      if (beforeResponse) {
-        const modified = await beforeResponse(response, adapterRequest);
-        if (modified) {
-          response = modified;
+        // Route not found — passthrough or 404
+        if (isRouteNotFound(schmockResponse)) {
+          if (passthrough) {
+            return PASSTHROUGH;
+          }
+          return new Response(
+            JSON.stringify({
+              error: "No matching mock route found",
+              code: "ROUTE_NOT_FOUND",
+            }),
+            {
+              status: 404,
+              headers: { "content-type": "application/json" },
+            },
+          );
         }
-      }
 
-      // 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");
-      }
+        // Apply beforeResponse hook
+        let response: Schmock.AdapterResponse = schmockResponse;
+        if (beforeResponse) {
+          const modified = await beforeResponse(response, adapterRequest);
+          if (modified) {
+            response = modified;
+          }
+        }
 
-      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;
-    }
-  };
+        // Build fetch Response
+        const responseHeaders = new Headers(response.headers);
+        if (
+          !responseHeaders.has("content-type") &&
+          response.body !== null &&
+          response.body !== undefined
+        ) {
+          responseHeaders.set(
+            "content-type",
+            isBinaryBody(response.body)
+              ? "application/octet-stream"
+              : "application/json",
+          );
+        }
 
-  return {
-    restore() {
-      if (active) {
-        globalThis.fetch = originalFetch;
-        active = false;
+        const responseBody =
+          response.body === null || response.body === undefined
+            ? null
+            : typeof response.body === "string"
+              ? response.body
+              : isBinaryBody(response.body)
+                ? toFetchBinaryBody(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;
       }
     },
-    get active() {
-      return active;
-    },
-  };
+  );
 }

package/src/parser.property.test.ts

@@ -83,8 +83,6 @@ const doubleSlashPath = fc
   .array(safeSeg, { minLength: 2, maxLength: 4 })
   .map((segs) => `/${segs.join("//")}`);
 
-const trailingSlashPath = safePath.map((p) => `${p}/`);
-
 const deepPath = fc
   .array(safeSeg, { minLength: 10, maxLength: 30 })
   .map((segs) => `/${segs.join("/")}`);
@@ -106,14 +104,55 @@ const paramRouteKey = fc
     return `${m} /${parts.join("/")}`;
   });
 
-// Route keys with hostile characters in the path portion
-const hostileRouteKey = fc
-  .tuple(method, hostilePath)
-  .map(([m, p]) => `${m} ${p}`);
+const parameterizedRouteCase = fc
+  .tuple(
+    method,
+    fc.uniqueArray(
+      fc.record({
+        literal: safeSeg,
+        parameter: safeSeg,
+        value: safeSeg,
+      }),
+      {
+        minLength: 1,
+        maxLength: 4,
+        selector: (part) => part.parameter,
+      },
+    ),
+  )
+  .map(([httpMethod, parts]) => ({
+    key: `${httpMethod} /${parts
+      .map((part) => `${part.literal}/:${part.parameter}`)
+      .join("/")}`,
+    concretePath: `/${parts
+      .map((part) => `${part.literal}/${part.value}`)
+      .join("/")}`,
+    parameterNames: parts.map((part) => part.parameter),
+    parameterValues: parts.map((part) => part.value),
+  }));
 
 // --- Arbitrary inputs ---
 
-const arbitraryString = fc.string({ minLength: 0, maxLength: 200 });
+const asciiString = fc
+  .array(fc.integer({ min: 0, max: 0x7f }), {
+    minLength: 0,
+    maxLength: 200,
+  })
+  .map((codePoints) => String.fromCharCode(...codePoints));
+const unicodeString = fc.string({ minLength: 0, maxLength: 200 });
+
+function expectParseResultOrRouteError(input: string): void {
+  let result: ReturnType<typeof parseRouteKey>;
+  try {
+    result = parseRouteKey(input);
+  } catch (error) {
+    expect(error).toBeInstanceOf(RouteParseError);
+    return;
+  }
+
+  expect(`${result.method} ${result.path}`).toBe(input);
+  expect(result.pattern.test(result.path)).toBe(true);
+}
 
 // --- Namespace generators ---
 
@@ -133,42 +172,35 @@ const namespace = fc.oneof(
 
 describe("parseRouteKey — fuzz", () => {
   it("never throws an unhandled error on arbitrary ASCII input", () => {
-    fc.assert(
-      fc.property(arbitraryString, (input) => {
-        try {
-          parseRouteKey(input);
-        } catch (e) {
-          expect(e).toBeInstanceOf(RouteParseError);
-        }
-      }),
-      { numRuns: 1000 },
-    );
+    fc.assert(fc.property(asciiString, expectParseResultOrRouteError), {
+      numRuns: 1000,
+    });
   });
 
   it("never throws an unhandled error on arbitrary unicode input", () => {
-    fc.assert(
-      fc.property(arbitraryString, (input) => {
-        try {
-          parseRouteKey(input);
-        } catch (e) {
-          expect(e).toBeInstanceOf(RouteParseError);
-        }
-      }),
-      { numRuns: 1000 },
-    );
+    fc.assert(fc.property(unicodeString, expectParseResultOrRouteError), {
+      numRuns: 1000,
+    });
   });
 
-  it("rejects inputs that look like methods but have hostile paths", () => {
+  it("escapes regex metacharacters in literal path segments", () => {
     fc.assert(
-      fc.property(hostileRouteKey, (key) => {
-        try {
-          const result = parseRouteKey(key);
-          // If it parses, the regex must be valid
-          expect(result.pattern).toBeInstanceOf(RegExp);
-        } catch (e) {
-          expect(e).toBeInstanceOf(RouteParseError);
-        }
-      }),
+      fc.property(
+        method,
+        safeSeg,
+        regexMetaSeg,
+        safeSeg,
+        (httpMethod, prefix, literal, suffix) => {
+          const result = parseRouteKey(
+            `${httpMethod} /${prefix}/${literal}/${suffix}`,
+          );
+
+          expect(result.pattern.test(result.path)).toBe(true);
+          expect(result.pattern.test(`/${prefix}/literal/${suffix}`)).toBe(
+            false,
+          );
+        },
+      ),
       { numRuns: 500 },
     );
   });
@@ -195,36 +227,40 @@ describe("parseRouteKey — fuzz", () => {
     );
   });
 
-  it("produced regex is safe against hostile test paths", () => {
+  it("matches concrete parameterized paths and captures every value", () => {
     fc.assert(
-      fc.property(routeKey, hostilePath, (key, reqPath) => {
-        const result = parseRouteKey(key);
-        const matched = result.pattern.test(reqPath);
-        expect(typeof matched).toBe("boolean");
+      fc.property(parameterizedRouteCase, (routeCase) => {
+        const result = parseRouteKey(routeCase.key);
+        const match = result.pattern.exec(routeCase.concretePath);
+
+        expect(match).not.toBeNull();
+        expect(match?.slice(1)).toEqual(routeCase.parameterValues);
+        expect(result.params).toEqual(routeCase.parameterNames);
       }),
       { numRuns: 1000 },
     );
   });
 
-  it("produced regex handles double-slash paths without crashing", () => {
+  it("rejects slash-delimited near misses for parameterized paths", () => {
     fc.assert(
-      fc.property(routeKey, doubleSlashPath, (key, reqPath) => {
-        const result = parseRouteKey(key);
-        const matched = result.pattern.test(reqPath);
-        expect(typeof matched).toBe("boolean");
+      fc.property(parameterizedRouteCase, safeSeg, (routeCase, extra) => {
+        const result = parseRouteKey(routeCase.key);
+        const nearMiss = `${routeCase.concretePath}/${extra}`;
+
+        expect(result.pattern.test(nearMiss)).toBe(false);
       }),
-      { numRuns: 300 },
+      { numRuns: 500 },
     );
   });
 
-  it("produced regex handles trailing-slash paths without crashing", () => {
+  it("does not normalize malformed separators while matching", () => {
     fc.assert(
-      fc.property(routeKey, trailingSlashPath, (key, reqPath) => {
+      fc.property(routeKey, (key) => {
         const result = parseRouteKey(key);
-        const matched = result.pattern.test(reqPath);
-        expect(typeof matched).toBe("boolean");
+        const doubledLeadingSlash = `/${result.path}`;
+        expect(result.pattern.test(doubledLeadingSlash)).toBe(false);
       }),
-      { numRuns: 300 },
+      { numRuns: 500 },
     );
   });
 
@@ -287,7 +323,7 @@ describe("handle() — fuzz", () => {
     mock("DELETE /items/:id/comments/:cid", () => ({ deleted: true }));
 
     fc.assert(
-      fc.asyncProperty(method, arbitraryString, async (m, reqPath) => {
+      fc.asyncProperty(method, asciiString, async (m, reqPath) => {
         const response = await mock.handle(m, reqPath);
         expect(response).toBeDefined();
         expect(typeof response.status).toBe("number");
@@ -302,7 +338,7 @@ describe("handle() — fuzz", () => {
     mock("GET /data/:key", () => ({ ok: true }));
 
     fc.assert(
-      fc.asyncProperty(arbitraryString, async (reqPath) => {
+      fc.asyncProperty(unicodeString, async (reqPath) => {
         const response = await mock.handle("GET", reqPath);
         expect(response).toBeDefined();
         expect(typeof response.status).toBe("number");