@schmock/core 1.0.0

package/src/debug.test.ts

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

package/src/delay.test.ts

@@ -0,0 +1,319 @@
+import { describe, expect, it } from "vitest";
+import { schmock } from "./index";
+
+describe("response delay functionality", () => {
+  describe("fixed delay", () => {
+    it("applies fixed delay to responses", async () => {
+      const mock = schmock({ delay: 100 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeGreaterThanOrEqual(95); // Allow some tolerance
+      expect(duration).toBeLessThan(150);
+    });
+
+    it("applies delay to all routes", async () => {
+      const mock = schmock({ delay: 50 });
+      mock("GET /route1", "response1");
+      mock("POST /route2", "response2");
+
+      const start1 = Date.now();
+      const response1 = await mock.handle("GET", "/route1");
+      const duration1 = Date.now() - start1;
+
+      const start2 = Date.now();
+      const response2 = await mock.handle("POST", "/route2");
+      const duration2 = Date.now() - start2;
+
+      expect(response1.body).toBe("response1");
+      expect(response2.body).toBe("response2");
+      expect(duration1).toBeGreaterThanOrEqual(45);
+      expect(duration2).toBeGreaterThanOrEqual(45);
+    });
+
+    it("works with zero delay", async () => {
+      const mock = schmock({ delay: 0 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeLessThan(50); // Should be very fast
+    });
+  });
+
+  describe("random delay range", () => {
+    it("applies random delay within specified range", async () => {
+      const mock = schmock({ delay: [100, 200] });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeGreaterThanOrEqual(95); // Allow some tolerance for timer precision
+      expect(duration).toBeLessThan(250);
+    });
+
+    it("generates different delays for multiple requests", async () => {
+      const mock = schmock({ delay: [50, 150] });
+      mock("GET /test", "response");
+
+      const durations: number[] = [];
+
+      for (let i = 0; i < 5; i++) {
+        const start = Date.now();
+        await mock.handle("GET", "/test");
+        durations.push(Date.now() - start);
+      }
+
+      // Check that we got some variation in delays
+      const minDuration = Math.min(...durations);
+      const maxDuration = Math.max(...durations);
+
+      expect(minDuration).toBeGreaterThanOrEqual(45);
+      expect(maxDuration).toBeLessThan(200);
+      // There should be some variation (not all identical)
+      expect(maxDuration - minDuration).toBeGreaterThan(10);
+    });
+
+    it("handles reversed range [max, min]", async () => {
+      const mock = schmock({ delay: [200, 100] });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      // Should still work, treating it as [100, 200]
+      expect(duration).toBeGreaterThanOrEqual(0);
+      expect(duration).toBeLessThan(300);
+    });
+
+    it("handles equal min and max values", async () => {
+      const mock = schmock({ delay: [100, 100] });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeGreaterThanOrEqual(95);
+      expect(duration).toBeLessThan(150);
+    });
+  });
+
+  describe("delay with different response types", () => {
+    it("applies delay to function generators", async () => {
+      const mock = schmock({ delay: 50 });
+      mock("GET /dynamic", () => ({ timestamp: Date.now() }));
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/dynamic");
+      const duration = Date.now() - start;
+
+      expect(response.body).toHaveProperty("timestamp");
+      expect(duration).toBeGreaterThanOrEqual(45);
+    });
+
+    it("applies delay to static responses", async () => {
+      const mock = schmock({ delay: 50 });
+      mock("GET /static", { data: "static" });
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/static");
+      const duration = Date.now() - start;
+
+      expect(response.body).toEqual({ data: "static" });
+      expect(duration).toBeGreaterThanOrEqual(45);
+    });
+
+    it("applies delay to tuple responses", async () => {
+      const mock = schmock({ delay: 50 });
+      mock("GET /tuple", () => [201, { created: true }]);
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/tuple");
+      const duration = Date.now() - start;
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ created: true });
+      expect(duration).toBeGreaterThanOrEqual(45);
+    });
+
+    it("applies delay to error responses", async () => {
+      const mock = schmock({ delay: 50 });
+      mock("GET /error", () => {
+        throw new Error("Test error");
+      });
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/error");
+      const duration = Date.now() - start;
+
+      expect(response.status).toBe(500);
+      expect(duration).toBeGreaterThanOrEqual(45);
+    });
+  });
+
+  describe("delay with plugins", () => {
+    it("applies delay after plugin processing", async () => {
+      const mock = schmock({ delay: 50 });
+
+      const plugin = {
+        name: "slow-plugin",
+        process: async (ctx: any, res: any) => {
+          await new Promise((resolve) => setTimeout(resolve, 30));
+          return { context: ctx, response: `processed-${res}` };
+        },
+      };
+
+      mock("GET /test", "original").pipe(plugin);
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("processed-original");
+      expect(duration).toBeGreaterThanOrEqual(75); // Plugin delay + response delay
+    });
+
+    it("applies delay even when plugin generates response", async () => {
+      const mock = schmock({ delay: 50 });
+
+      const plugin = {
+        name: "generator-plugin",
+        process: (ctx: any, _res: any) => {
+          return { context: ctx, response: "plugin-generated" };
+        },
+      };
+
+      mock("GET /test", null).pipe(plugin);
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("plugin-generated");
+      expect(duration).toBeGreaterThanOrEqual(45);
+    });
+  });
+
+  describe("no delay configuration", () => {
+    it("doesn't apply delay when not configured", async () => {
+      const mock = schmock();
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeLessThan(30); // Should be very fast without delay
+    });
+
+    it("doesn't apply delay when delay is undefined", async () => {
+      const mock = schmock({ delay: undefined });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeLessThan(30);
+    });
+  });
+
+  describe("delay edge cases", () => {
+    it("handles very small delays", async () => {
+      const mock = schmock({ delay: 1 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeGreaterThanOrEqual(0);
+      expect(duration).toBeLessThan(50);
+    });
+
+    it("handles large delays", async () => {
+      const mock = schmock({ delay: 500 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      expect(duration).toBeGreaterThanOrEqual(490);
+      expect(duration).toBeLessThan(600);
+    }, 1000); // Increase test timeout
+
+    it("handles negative delays gracefully", async () => {
+      const mock = schmock({ delay: -50 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      // Should not crash, and should be fast
+      expect(duration).toBeLessThan(50);
+    });
+
+    it("handles delay range with negative values", async () => {
+      const mock = schmock({ delay: [-10, 50] });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+      const response = await mock.handle("GET", "/test");
+      const duration = Date.now() - start;
+
+      expect(response.body).toBe("response");
+      // Should handle gracefully
+      expect(duration).toBeGreaterThanOrEqual(0);
+      expect(duration).toBeLessThan(100);
+    });
+  });
+
+  describe("concurrent requests with delay", () => {
+    it("applies delay to concurrent requests independently", async () => {
+      const mock = schmock({ delay: 100 });
+      mock("GET /test", "response");
+
+      const start = Date.now();
+
+      // Start multiple requests concurrently
+      const promises = [
+        mock.handle("GET", "/test"),
+        mock.handle("GET", "/test"),
+        mock.handle("GET", "/test"),
+      ];
+
+      const responses = await Promise.all(promises);
+      const duration = Date.now() - start;
+
+      // All should succeed
+      responses.forEach((response) => {
+        expect(response.body).toBe("response");
+      });
+
+      // Should take about 100ms, not 300ms (concurrent, not sequential)
+      expect(duration).toBeGreaterThanOrEqual(95);
+      expect(duration).toBeLessThan(200);
+    });
+  });
+});

package/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,IAAI,EAAE,MAAM;aACZ,OAAO,CAAC,EAAE,OAAO;gBAFjC,OAAO,EAAE,MAAM,EACC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,YAAA;CAMpC;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAQzC;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;gBAC3C,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAQxC;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,YAAY;gBAC/B,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK;CAQ7C;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAQ7C;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;CAQnE;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,YAAY;gBACzC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO;CAQ1D;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBACtC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;CAQ7D"}