@schmock/core 2.2.3 → 2.3.1

package/src/delay.test.ts

@@ -1,319 +0,0 @@
-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/dist-shape.test.ts

@@ -1,35 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { describe, expect, it } from "vitest";
-
-/**
- * Regression coverage for issue #395 — a top-level `import { createServer }
- * from "node:http"` in `dist/builder.js` was preserved by browser bundlers
- * (esbuild / Angular / Vite) even when `.listen()` was never called, causing
- * `node:http` resolution failures in browsers.
- *
- * Inspect published artifacts: top-level `node:http` imports must not exist.
- * `node:http` may only appear inside dynamic imports (`await import(...)`).
- */
-const distRoot = resolve(__dirname, "..", "dist");
-
-// Static ESM imports from node: modules — `from "node:..."`. Dynamic imports
-// (`await import("node:...")`) have no `from` clause and are not matched.
-function staticNodeImports(src: string): string[] {
-  return src.match(/from\s*["']node:[^"']+["']/g) ?? [];
-}
-
-describe.skipIf(!existsSync(distRoot))(
-  "dist shape — browser compatibility (#395)",
-  () => {
-    it("dist/builder.js has no static node:* imports", () => {
-      const src = readFileSync(resolve(distRoot, "builder.js"), "utf8");
-      expect(staticNodeImports(src)).toEqual([]);
-    });
-
-    it("dist/index.js has no static node:* imports", () => {
-      const src = readFileSync(resolve(distRoot, "index.js"), "utf8");
-      expect(staticNodeImports(src)).toEqual([]);
-    });
-  },
-);

package/src/errors.test.ts

@@ -1,223 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  PluginError,
-  ResourceLimitError,
-  ResponseGenerationError,
-  RouteDefinitionError,
-  RouteNotFoundError,
-  RouteParseError,
-  SchemaGenerationError,
-  SchemaValidationError,
-  SchmockError,
-} from "./errors";
-
-describe("error classes", () => {
-  describe("SchmockError", () => {
-    it("creates base error with code and context", () => {
-      const error = new SchmockError("test message", "TEST_CODE", {
-        data: "test",
-      });
-
-      expect(error.message).toBe("test message");
-      expect(error.code).toBe("TEST_CODE");
-      expect(error.context).toEqual({ data: "test" });
-      expect(error.name).toBe("SchmockError");
-      expect(error).toBeInstanceOf(Error);
-    });
-
-    it("creates error without context", () => {
-      const error = new SchmockError("test message", "TEST_CODE");
-
-      expect(error.context).toBeUndefined();
-    });
-
-    it("captures stack trace", () => {
-      const error = new SchmockError("test", "TEST");
-
-      expect(error.stack).toBeDefined();
-      expect(error.stack).toContain("SchmockError");
-    });
-  });
-
-  describe("RouteNotFoundError", () => {
-    it("formats message with method and path", () => {
-      const error = new RouteNotFoundError("GET", "/users/123");
-
-      expect(error.message).toBe("Route not found: GET /users/123");
-      expect(error.code).toBe("ROUTE_NOT_FOUND");
-      expect(error.context).toEqual({ method: "GET", path: "/users/123" });
-      expect(error.name).toBe("RouteNotFoundError");
-    });
-  });
-
-  describe("RouteParseError", () => {
-    it("includes route key and reason in message", () => {
-      const error = new RouteParseError("INVALID /test", "Missing method");
-
-      expect(error.message).toBe(
-        'Invalid route key format: "INVALID /test". Missing method',
-      );
-      expect(error.code).toBe("ROUTE_PARSE_ERROR");
-      expect(error.context).toEqual({
-        routeKey: "INVALID /test",
-        reason: "Missing method",
-      });
-    });
-  });
-
-  describe("ResponseGenerationError", () => {
-    it("wraps original error", () => {
-      const originalError = new Error("Original failure");
-      const error = new ResponseGenerationError("GET /users", originalError);
-
-      expect(error.message).toBe(
-        "Failed to generate response for route GET /users: Original failure",
-      );
-      expect(error.code).toBe("RESPONSE_GENERATION_ERROR");
-      expect(error.context).toEqual({
-        route: "GET /users",
-        originalError,
-      });
-    });
-  });
-
-  describe("PluginError", () => {
-    it("includes plugin name and wraps error", () => {
-      const originalError = new Error("Plugin failed");
-      const error = new PluginError("test-plugin", originalError);
-
-      expect(error.message).toBe('Plugin "test-plugin" failed: Plugin failed');
-      expect(error.code).toBe("PLUGIN_ERROR");
-      expect(error.context).toEqual({
-        pluginName: "test-plugin",
-        originalError,
-      });
-    });
-  });
-
-  describe("RouteDefinitionError", () => {
-    it("includes route key and reason", () => {
-      const error = new RouteDefinitionError(
-        "GET /test",
-        "Missing response function",
-      );
-
-      expect(error.message).toBe(
-        'Invalid route definition for "GET /test": Missing response function',
-      );
-      expect(error.code).toBe("ROUTE_DEFINITION_ERROR");
-      expect(error.context).toEqual({
-        routeKey: "GET /test",
-        reason: "Missing response function",
-      });
-    });
-  });
-
-  describe("SchemaValidationError", () => {
-    it("includes path and issue", () => {
-      const error = new SchemaValidationError(
-        "users.name",
-        "Required field missing",
-      );
-
-      expect(error.message).toBe(
-        "Schema validation failed at users.name: Required field missing",
-      );
-      expect(error.code).toBe("SCHEMA_VALIDATION_ERROR");
-      expect(error.context).toEqual({
-        schemaPath: "users.name",
-        issue: "Required field missing",
-        suggestion: undefined,
-      });
-    });
-
-    it("includes suggestion when provided", () => {
-      const error = new SchemaValidationError(
-        "users.age",
-        "Invalid type",
-        "Use number instead of string",
-      );
-
-      expect(error.message).toBe(
-        "Schema validation failed at users.age: Invalid type. Use number instead of string",
-      );
-      expect(error.context?.suggestion).toBe("Use number instead of string");
-    });
-  });
-
-  describe("SchemaGenerationError", () => {
-    it("wraps schema generation failure", () => {
-      const originalError = new Error("Invalid schema");
-      const schema = { type: "object" };
-      const error = new SchemaGenerationError(
-        "GET /users",
-        originalError,
-        schema,
-      );
-
-      expect(error.message).toBe(
-        "Schema generation failed for route GET /users: Invalid schema",
-      );
-      expect(error.code).toBe("SCHEMA_GENERATION_ERROR");
-      expect(error.context).toEqual({
-        route: "GET /users",
-        originalError,
-        schema,
-      });
-    });
-
-    it("works without schema context", () => {
-      const originalError = new Error("Invalid schema");
-      const error = new SchemaGenerationError("GET /users", originalError);
-
-      expect(error.context?.schema).toBeUndefined();
-    });
-  });
-
-  describe("ResourceLimitError", () => {
-    it("includes resource and limit", () => {
-      const error = new ResourceLimitError("memory", 1024);
-
-      expect(error.message).toBe(
-        "Resource limit exceeded for memory: limit=1024",
-      );
-      expect(error.code).toBe("RESOURCE_LIMIT_ERROR");
-      expect(error.context).toEqual({
-        resource: "memory",
-        limit: 1024,
-        actual: undefined,
-      });
-    });
-
-    it("includes actual value when provided", () => {
-      const error = new ResourceLimitError("connections", 100, 150);
-
-      expect(error.message).toBe(
-        "Resource limit exceeded for connections: limit=100, actual=150",
-      );
-      expect(error.context?.actual).toBe(150);
-    });
-  });
-
-  describe("error inheritance", () => {
-    it("all custom errors inherit from SchmockError", () => {
-      const errors = [
-        new RouteNotFoundError("GET", "/test"),
-        new RouteParseError("invalid", "reason"),
-        new ResponseGenerationError("route", new Error("test")),
-        new PluginError("plugin", new Error("test")),
-        new RouteDefinitionError("route", "reason"),
-        new SchemaValidationError("path", "issue"),
-        new SchemaGenerationError("route", new Error("test")),
-        new ResourceLimitError("resource", 100),
-      ];
-
-      for (const error of errors) {
-        expect(error).toBeInstanceOf(SchmockError);
-        expect(error).toBeInstanceOf(Error);
-        expect(error.code).toBeDefined();
-        expect(error.name).toBeDefined();
-      }
-    });
-  });
-});

package/src/errors.ts

@@ -1,130 +0,0 @@
-export function errorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : "Unknown error";
-}
-
-/**
- * Base error class for all Schmock errors
- */
-export class SchmockError extends Error {
-  constructor(
-    message: string,
-    public readonly code: string,
-    public readonly context?: unknown,
-  ) {
-    super(message);
-    this.name = "SchmockError";
-    if (typeof Error.captureStackTrace === "function") {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-}
-
-/**
- * Error thrown when a route is not found
- */
-export class RouteNotFoundError extends SchmockError {
-  constructor(method: string, path: string) {
-    super(`Route not found: ${method} ${path}`, "ROUTE_NOT_FOUND", {
-      method,
-      path,
-    });
-    this.name = "RouteNotFoundError";
-  }
-}
-
-/**
- * Error thrown when route parsing fails
- */
-export class RouteParseError extends SchmockError {
-  constructor(routeKey: string, reason: string) {
-    super(
-      `Invalid route key format: "${routeKey}". ${reason}`,
-      "ROUTE_PARSE_ERROR",
-      { routeKey, reason },
-    );
-    this.name = "RouteParseError";
-  }
-}
-
-/**
- * Error thrown when response generation fails
- */
-export class ResponseGenerationError extends SchmockError {
-  constructor(route: string, error: Error) {
-    super(
-      `Failed to generate response for route ${route}: ${error.message}`,
-      "RESPONSE_GENERATION_ERROR",
-      { route, originalError: error },
-    );
-    this.name = "ResponseGenerationError";
-  }
-}
-
-/**
- * Error thrown when a plugin fails
- */
-export class PluginError extends SchmockError {
-  constructor(pluginName: string, error: Error) {
-    super(`Plugin "${pluginName}" failed: ${error.message}`, "PLUGIN_ERROR", {
-      pluginName,
-      originalError: error,
-    });
-    this.name = "PluginError";
-  }
-}
-
-/**
- * Error thrown when route definition is invalid
- */
-export class RouteDefinitionError extends SchmockError {
-  constructor(routeKey: string, reason: string) {
-    super(
-      `Invalid route definition for "${routeKey}": ${reason}`,
-      "ROUTE_DEFINITION_ERROR",
-      { routeKey, reason },
-    );
-    this.name = "RouteDefinitionError";
-  }
-}
-
-/**
- * Error thrown when schema validation fails
- */
-export class SchemaValidationError extends SchmockError {
-  constructor(schemaPath: string, issue: string, suggestion?: string) {
-    super(
-      `Schema validation failed at ${schemaPath}: ${issue}${suggestion ? `. ${suggestion}` : ""}`,
-      "SCHEMA_VALIDATION_ERROR",
-      { schemaPath, issue, suggestion },
-    );
-    this.name = "SchemaValidationError";
-  }
-}
-
-/**
- * Error thrown when schema generation fails
- */
-export class SchemaGenerationError extends SchmockError {
-  constructor(route: string, error: Error, schema?: unknown) {
-    super(
-      `Schema generation failed for route ${route}: ${error.message}`,
-      "SCHEMA_GENERATION_ERROR",
-      { route, originalError: error, schema },
-    );
-    this.name = "SchemaGenerationError";
-  }
-}
-
-/**
- * Error thrown when resource limits are exceeded
- */
-export class ResourceLimitError extends SchmockError {
-  constructor(resource: string, limit: number, actual?: number) {
-    super(
-      `Resource limit exceeded for ${resource}: limit=${limit}${actual ? `, actual=${actual}` : ""}`,
-      "RESOURCE_LIMIT_ERROR",
-      { resource, limit, actual },
-    );
-    this.name = "ResourceLimitError";
-  }
-}