@schmock/core 2.2.3 → 2.3.1

package/src/constants.test.ts

@@ -1,99 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  HTTP_METHODS,
-  isHttpMethod,
-  isRouteNotFound,
-  ROUTE_NOT_FOUND_CODE,
-  toHttpMethod,
-} from "./constants";
-
-describe("constants", () => {
-  it("exports ROUTE_NOT_FOUND_CODE", () => {
-    expect(ROUTE_NOT_FOUND_CODE).toBe("ROUTE_NOT_FOUND");
-  });
-
-  it("exports all HTTP methods", () => {
-    expect(HTTP_METHODS).toEqual([
-      "GET",
-      "POST",
-      "PUT",
-      "DELETE",
-      "PATCH",
-      "HEAD",
-      "OPTIONS",
-    ]);
-  });
-});
-
-describe("isHttpMethod", () => {
-  it("returns true for valid HTTP methods", () => {
-    for (const method of HTTP_METHODS) {
-      expect(isHttpMethod(method)).toBe(true);
-    }
-  });
-
-  it("returns false for invalid methods", () => {
-    expect(isHttpMethod("INVALID")).toBe(false);
-    expect(isHttpMethod("")).toBe(false);
-    expect(isHttpMethod("get")).toBe(false);
-  });
-});
-
-describe("toHttpMethod", () => {
-  it("converts lowercase to uppercase", () => {
-    expect(toHttpMethod("get")).toBe("GET");
-    expect(toHttpMethod("post")).toBe("POST");
-    expect(toHttpMethod("delete")).toBe("DELETE");
-  });
-
-  it("returns already uppercase methods", () => {
-    expect(toHttpMethod("GET")).toBe("GET");
-    expect(toHttpMethod("PATCH")).toBe("PATCH");
-  });
-
-  it("throws for invalid methods", () => {
-    expect(() => toHttpMethod("INVALID")).toThrow(
-      'Invalid HTTP method: "INVALID"',
-    );
-    expect(() => toHttpMethod("")).toThrow('Invalid HTTP method: ""');
-  });
-});
-
-describe("isRouteNotFound", () => {
-  it("returns true for a route-not-found response", () => {
-    const response = {
-      status: 404,
-      body: { error: "Route not found", code: ROUTE_NOT_FOUND_CODE },
-      headers: {},
-    };
-    expect(isRouteNotFound(response)).toBe(true);
-  });
-
-  it("returns false for a regular 404 response", () => {
-    const response = {
-      status: 404,
-      body: { message: "User not found" },
-      headers: {},
-    };
-    expect(isRouteNotFound(response)).toBe(false);
-  });
-
-  it("returns false for a non-404 response", () => {
-    const response = {
-      status: 200,
-      body: { code: ROUTE_NOT_FOUND_CODE },
-      headers: {},
-    };
-    expect(isRouteNotFound(response)).toBe(false);
-  });
-
-  it("returns false when body is null", () => {
-    const response = { status: 404, body: null, headers: {} };
-    expect(isRouteNotFound(response)).toBe(false);
-  });
-
-  it("returns false when body is a string", () => {
-    const response = { status: 404, body: "not found", headers: {} };
-    expect(isRouteNotFound(response)).toBe(false);
-  });
-});

package/src/constants.ts

@@ -1,73 +0,0 @@
-import type { HttpMethod } from "./types.js";
-
-export const ROUTE_NOT_FOUND_CODE = "ROUTE_NOT_FOUND" as const;
-
-export const HTTP_METHODS: readonly HttpMethod[] = [
-  "GET",
-  "POST",
-  "PUT",
-  "DELETE",
-  "PATCH",
-  "HEAD",
-  "OPTIONS",
-] as const;
-
-export function isHttpMethod(method: string): method is HttpMethod {
-  return (HTTP_METHODS as readonly string[]).includes(method);
-}
-
-export function toHttpMethod(method: string): HttpMethod {
-  const upper = method.toUpperCase();
-  if (!isHttpMethod(upper)) {
-    throw new Error(`Invalid HTTP method: "${method}"`);
-  }
-  return upper;
-}
-
-export function normalizePath(path: string): string {
-  return path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-}
-
-export function toRouteKey(method: HttpMethod, path: string): Schmock.RouteKey {
-  const key: `${HttpMethod} ${string}` = `${method} ${path}`;
-  return key;
-}
-
-/**
- * Check if a Schmock response is a route-not-found response.
- * Used by adapters to decide whether to pass through to the real backend.
- */
-export function isRouteNotFound(response: {
-  status: number;
-  body: unknown;
-}): boolean {
-  const { status, body } = response;
-  return (
-    status === 404 &&
-    body !== null &&
-    typeof body === "object" &&
-    "code" in body &&
-    body.code === ROUTE_NOT_FOUND_CODE
-  );
-}
-
-/**
- * Check if a value is a status tuple: [status, body] or [status, body, headers]
- * Guards against misinterpreting numeric arrays like [1, 2, 3] as tuples.
- *
- * Known ambiguity: a length-2 numeric array whose first element happens to
- * be in the HTTP-status range (e.g. [200, 300] as legitimate data) is
- * indistinguishable from a status tuple by shape alone. Prefer the explicit
- * status() helper or return an object response when the data could collide.
- */
-export function isStatusTuple(
-  value: unknown,
-): value is [number, unknown] | [number, unknown, Record<string, string>] {
-  return (
-    Array.isArray(value) &&
-    (value.length === 2 || value.length === 3) &&
-    typeof value[0] === "number" &&
-    value[0] >= 100 &&
-    value[0] <= 599
-  );
-}

package/src/debug.test.ts

@@ -1,241 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { schmock } from "./index";
-
-describe("debug functionality", () => {
-  const originalConsole = console.log;
-  const originalTime = console.time;
-  const originalTimeEnd = console.timeEnd;
-  let consoleLogs: any[] = [];
-
-  beforeEach(() => {
-    consoleLogs = [];
-    console.log = vi.fn((...args) => consoleLogs.push(args));
-    console.time = vi.fn();
-    console.timeEnd = vi.fn();
-  });
-
-  afterEach(() => {
-    console.log = originalConsole;
-    console.time = originalTime;
-    console.timeEnd = originalTimeEnd;
-  });
-
-  describe("debug logging", () => {
-    it("logs debug messages when debug mode is enabled", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /test", () => ({ data: "test" }));
-
-      await mock.handle("GET", "/test");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) => msg.includes("Debug mode enabled")),
-      ).toBe(true);
-      expect(logMessages.some((msg) => msg.includes("[SCHMOCK:REQUEST]"))).toBe(
-        true,
-      );
-    });
-
-    it("does not log when debug mode is disabled", async () => {
-      const mock = schmock({ debug: false });
-      mock("GET /test", () => ({ data: "test" }));
-
-      await mock.handle("GET", "/test");
-
-      expect(consoleLogs).toHaveLength(0);
-    });
-
-    it("defaults to no logging when debug is not configured", async () => {
-      const mock = schmock();
-      mock("GET /test", () => ({ data: "test" }));
-
-      await mock.handle("GET", "/test");
-
-      expect(consoleLogs).toHaveLength(0);
-    });
-
-    it("logs plugin registration with debug enabled", () => {
-      const plugin = {
-        name: "test-plugin",
-        version: "1.0.0",
-        enforce: "pre" as const,
-        beforeRequest: () => {},
-        generate: () => {},
-      };
-
-      const mock = schmock({ debug: true });
-      mock.pipe(plugin);
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) =>
-          msg.includes("Registered plugin: test-plugin@1.0.0"),
-        ),
-      ).toBe(true);
-    });
-
-    it("logs plugin execution during request handling", async () => {
-      const plugin = {
-        name: "logging-test",
-        version: "1.0.0",
-        process: (ctx: any, response: any) => ({
-          context: ctx,
-          response: response || { data: "generated" },
-        }),
-      };
-
-      const mock = schmock({ debug: true });
-      mock.pipe(plugin);
-      mock("GET /test", undefined);
-
-      await mock.handle("GET", "/test");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) =>
-          msg.includes("Processing plugin: logging-test"),
-        ),
-      ).toBe(true);
-      expect(
-        logMessages.some((msg) =>
-          msg.includes("Plugin logging-test generated response"),
-        ),
-      ).toBe(true);
-    });
-
-    it("logs response status and timing", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /test", () => [201, { created: true }]);
-
-      await mock.handle("GET", "/test");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) => msg.includes("Sending response 201")),
-      ).toBe(true);
-
-      expect(console.time).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-      expect(console.timeEnd).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-    });
-
-    it("logs route matching information", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /users/:id", ({ params }) => ({ userId: params.id }));
-
-      await mock.handle("GET", "/users/123");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some(
-          (msg) =>
-            msg.includes("Matched route:") || msg.includes("GET /users/123"),
-        ),
-      ).toBe(true);
-    });
-
-    it("logs 404 errors with debug enabled", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /exists", () => "OK");
-
-      await mock.handle("GET", "/missing");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) =>
-          msg.includes("No route found for GET /missing"),
-        ),
-      ).toBe(true);
-    });
-
-    it("logs error details when exceptions occur", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /error", () => {
-        throw new Error("Test error");
-      });
-
-      await mock.handle("GET", "/error");
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      expect(
-        logMessages.some((msg) =>
-          msg.includes("Error processing request: Test error"),
-        ),
-      ).toBe(true);
-    });
-
-    it("includes request details in debug logs", async () => {
-      const mock = schmock({ debug: true });
-      mock("POST /data", ({ body }) => body);
-
-      await mock.handle("POST", "/data", {
-        headers: { "content-type": "application/json" },
-        body: { test: "data" },
-        query: { filter: "active" },
-      });
-
-      const logMessages = consoleLogs.map((args) => args.join(" "));
-      const requestLog = logMessages.find((msg) => msg.includes("POST /data"));
-      expect(requestLog).toBeDefined();
-    });
-  });
-
-  describe("performance timing", () => {
-    it("times the overall request processing", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /test", () => "OK");
-
-      await mock.handle("GET", "/test");
-
-      expect(console.time).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-      expect(console.timeEnd).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-    });
-
-    it("times the request processing", async () => {
-      const mock = schmock({ debug: true });
-      mock("GET /test", () => "OK");
-
-      await mock.handle("GET", "/test");
-
-      expect(console.time).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-      expect(console.timeEnd).toHaveBeenCalledWith(
-        expect.stringMatching(/\[SCHMOCK\] request-/),
-      );
-    });
-  });
-
-  describe("debug configuration inheritance", () => {
-    it("preserves debug setting through chained calls", () => {
-      // Create mock with debug enabled, then configure namespace
-      const mock = schmock({ debug: true, namespace: "/api" });
-      mock("GET /test", () => "OK");
-
-      expect(
-        consoleLogs.some((args) =>
-          args.join(" ").includes("Debug mode enabled"),
-        ),
-      ).toBe(true);
-    });
-
-    it("can disable debug mode with subsequent config", async () => {
-      const mock = schmock({ debug: false });
-      mock("GET /test", () => "OK");
-
-      // Clear logs from build phase
-      consoleLogs = [];
-
-      await mock.handle("GET", "/test");
-
-      expect(consoleLogs).toHaveLength(0);
-    });
-  });
-});