@schmock/core 1.0.0

package/dist/index.js

@@ -0,0 +1 @@
+class X extends Error{code;context;constructor(A,B,G){super(A);this.code=B;this.context=G;this.name="SchmockError",Error.captureStackTrace(this,this.constructor)}}class _ extends X{constructor(A,B){super(`Route not found: ${A} ${B}`,"ROUTE_NOT_FOUND",{method:A,path:B});this.name="RouteNotFoundError"}}class $ extends X{constructor(A,B){super(`Invalid route key format: "${A}". ${B}`,"ROUTE_PARSE_ERROR",{routeKey:A,reason:B});this.name="RouteParseError"}}class z extends X{constructor(A,B){super(`Failed to generate response for route ${A}: ${B.message}`,"RESPONSE_GENERATION_ERROR",{route:A,originalError:B});this.name="ResponseGenerationError"}}class j extends X{constructor(A,B){super(`Plugin "${A}" failed: ${B.message}`,"PLUGIN_ERROR",{pluginName:A,originalError:B});this.name="PluginError"}}class O extends X{constructor(A,B){super(`Invalid route definition for "${A}": ${B}`,"ROUTE_DEFINITION_ERROR",{routeKey:A,reason:B});this.name="RouteDefinitionError"}}class M extends X{constructor(A,B,G){super(`Schema validation failed at ${A}: ${B}${G?`. ${G}`:""}`,"SCHEMA_VALIDATION_ERROR",{schemaPath:A,issue:B,suggestion:G});this.name="SchemaValidationError"}}class N extends X{constructor(A,B,G){super(`Schema generation failed for route ${A}: ${B.message}`,"SCHEMA_GENERATION_ERROR",{route:A,originalError:B,schema:G});this.name="SchemaGenerationError"}}class K extends X{constructor(A,B,G){super(`Resource limit exceeded for ${A}: limit=${B}${G?`, actual=${G}`:""}`,"RESOURCE_LIMIT_ERROR",{resource:A,limit:B,actual:G});this.name="ResourceLimitError"}}function S(A){let B=A.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (.+)$/);if(!B)throw new $(A,'Expected format: "METHOD /path" (e.g., "GET /users")');let[,G,H]=B,J=[],Q=/:([^/]+)/g,T;T=Q.exec(H);while(T!==null)J.push(T[1]),T=Q.exec(H);let U=H.replace(/[.*+?^${}()|[\]\\]/g,"\\$&").replace(/:([^/]+)/g,"([^/]+)"),V=new RegExp(`^${U}$`);return{method:G,path:H,pattern:V,params:J}}class k{enabled;constructor(A=!1){this.enabled=A}log(A,B,G){if(!this.enabled)return;let J=`[${new Date().toISOString()}] [SCHMOCK:${A.toUpperCase()}]`;if(G)console.log(`${J} ${B}`,G);else console.log(`${J} ${B}`)}time(A){if(!this.enabled)return;console.time(`[SCHMOCK] ${A}`)}timeEnd(A){if(!this.enabled)return;console.timeEnd(`[SCHMOCK] ${A}`)}}class L{globalConfig;routes=[];plugins=[];logger;constructor(A={}){this.globalConfig=A;if(this.logger=new k(A.debug||!1),A.debug)this.logger.log("config","Debug mode enabled");this.logger.log("config","Callable mock instance created",{debug:A.debug,namespace:A.namespace,delay:A.delay})}defineRoute(A,B,G){if(!G.contentType)if(typeof B==="function")G.contentType="application/json";else if(typeof B==="string"||typeof B==="number"||typeof B==="boolean")G.contentType="text/plain";else if(Buffer.isBuffer(B))G.contentType="application/octet-stream";else G.contentType="application/json";if(typeof B!=="function"&&G.contentType==="application/json")try{JSON.stringify(B)}catch(Q){throw new O(A,"Generator data is not valid JSON but contentType is application/json")}let H=S(A),J={pattern:H.pattern,params:H.params,method:H.method,path:H.path,generator:B,config:G};return this.routes.push(J),this.logger.log("route",`Route defined: ${A}`,{contentType:G.contentType,generatorType:typeof B,hasParams:H.params.length>0}),this}pipe(A){return this.plugins.push(A),this.logger.log("plugin",`Registered plugin: ${A.name}@${A.version||"unknown"}`,{name:A.name,version:A.version,hasProcess:typeof A.process==="function",hasOnError:typeof A.onError==="function"}),this}async handle(A,B,G){let H=Math.random().toString(36).substring(7);this.logger.log("request",`[${H}] ${A} ${B}`,{headers:G?.headers,query:G?.query,bodyType:G?.body?typeof G.body:"none"}),this.logger.time(`request-${H}`);try{let J=B;if(this.globalConfig.namespace){let W=this.globalConfig.namespace;if(W==="/")J=B;else{let Y=W.startsWith("/")?W:`/${W}`,w=B.startsWith("/")?B:`/${B}`,F=Y.endsWith("/")&&Y!=="/"?Y.slice(0,-1):Y;if(!w.startsWith(F)){this.logger.log("route",`[${H}] Path doesn't match namespace ${W}`);let v=new _(A,B),I={status:404,body:{error:v.message,code:v.code},headers:{}};return this.logger.timeEnd(`request-${H}`),I}if(J=w.substring(F.length),!J.startsWith("/"))J=`/${J}`}}let Q=this.findRoute(A,J);if(!Q){this.logger.log("route",`[${H}] No route found for ${A} ${J}`);let W=new _(A,B),Y={status:404,body:{error:W.message,code:W.code},headers:{}};return this.logger.timeEnd(`request-${H}`),Y}this.logger.log("route",`[${H}] Matched route: ${A} ${Q.path}`);let T=this.extractParams(Q,J),U={method:A,path:J,params:T,query:G?.query||{},headers:G?.headers||{},body:G?.body,state:this.globalConfig.state||{}},V;if(typeof Q.generator==="function")V=await Q.generator(U);else V=Q.generator;let D={path:J,route:Q.config,method:A,params:T,query:G?.query||{},headers:G?.headers||{},body:G?.body,state:new Map,routeState:this.globalConfig.state||{}};try{let W=await this.runPluginPipeline(D,V,Q.config,H);D=W.context,V=W.response}catch(W){throw this.logger.log("error",`[${H}] Plugin pipeline error: ${W.message}`),W}let Z=this.parseResponse(V,Q.config);return await this.applyDelay(),this.logger.log("response",`[${H}] Sending response ${Z.status}`,{status:Z.status,headers:Z.headers,bodyType:typeof Z.body}),this.logger.timeEnd(`request-${H}`),Z}catch(J){this.logger.log("error",`[${H}] Error processing request: ${J.message}`,J);let Q={status:500,body:{error:J.message,code:J instanceof X?J.code:"INTERNAL_ERROR"},headers:{}};return await this.applyDelay(),this.logger.log("error",`[${H}] Returning error response 500`),this.logger.timeEnd(`request-${H}`),Q}}async applyDelay(){if(!this.globalConfig.delay)return;let A=Array.isArray(this.globalConfig.delay)?Math.random()*(this.globalConfig.delay[1]-this.globalConfig.delay[0])+this.globalConfig.delay[0]:this.globalConfig.delay;await new Promise((B)=>setTimeout(B,A))}parseResponse(A,B){let G=200,H=A,J={},Q=!1;if(A&&typeof A==="object"&&"status"in A&&"body"in A)return{status:A.status,body:A.body,headers:A.headers||{}};if(Array.isArray(A)&&typeof A[0]==="number")[G,H,J={}]=A,Q=!0;if(H===null||H===void 0){if(!Q)G=G===200?204:G;H=void 0}if(!J["content-type"]&&B.contentType&&!Q){if(J["content-type"]=B.contentType,B.contentType==="text/plain"&&H!==void 0){if(typeof H==="object"&&!Buffer.isBuffer(H))H=JSON.stringify(H);else if(typeof H!=="string")H=String(H)}}return{status:G,body:H,headers:J}}async runPluginPipeline(A,B,G,H){let J=A,Q=B;this.logger.log("pipeline",`Running plugin pipeline for ${this.plugins.length} plugins`);for(let T of this.plugins){this.logger.log("pipeline",`Processing plugin: ${T.name}`);try{let U=await T.process(J,Q);if(!U||!U.context)throw Error(`Plugin ${T.name} didn't return valid result`);if(J=U.context,U.response!==void 0&&(Q===void 0||Q===null))this.logger.log("pipeline",`Plugin ${T.name} generated response`),Q=U.response;else if(U.response!==void 0&&Q!==void 0)this.logger.log("pipeline",`Plugin ${T.name} transformed response`),Q=U.response}catch(U){if(this.logger.log("pipeline",`Plugin ${T.name} failed: ${U.message}`),T.onError)try{let V=await T.onError(U,J);if(V){if(this.logger.log("pipeline",`Plugin ${T.name} handled error`),typeof V==="object"&&V.status){Q=V;break}}}catch(V){this.logger.log("pipeline",`Plugin ${T.name} error handler failed: ${V.message}`)}throw new j(T.name,U)}}return{context:J,response:Q}}findRoute(A,B){for(let G=this.routes.length-1;G>=0;G--){let H=this.routes[G];if(H.method===A&&H.params.length===0&&H.pattern.test(B))return H}for(let G=this.routes.length-1;G>=0;G--){let H=this.routes[G];if(H.method===A&&H.params.length>0&&H.pattern.test(B))return H}return}extractParams(A,B){let G=B.match(A.pattern);if(!G)return{};let H={};return A.params.forEach((J,Q)=>{H[J]=G[Q+1]}),H}}function b(A){let B=new L(A||{}),G=(H,J,Q={})=>{return B.defineRoute(H,J,Q),G};return G.pipe=(H)=>{return B.pipe(H),G},G.handle=B.handle.bind(B),G}export{b as schmock,X as SchmockError,M as SchemaValidationError,N as SchemaGenerationError,$ as RouteParseError,_ as RouteNotFoundError,O as RouteDefinitionError,z as ResponseGenerationError,K as ResourceLimitError,j as PluginError};

package/dist/parser.d.ts

@@ -0,0 +1,19 @@
+import type { HttpMethod } from "./types";
+export interface ParsedRoute {
+    method: HttpMethod;
+    path: string;
+    pattern: RegExp;
+    params: string[];
+}
+/**
+ * Parse 'METHOD /path' route key format
+ *
+ * Design note: We validate the format strictly to catch typos early.
+ * The 'METHOD /path' format was chosen for its readability and
+ * similarity to API documentation formats.
+ *
+ * @example
+ * parseRouteKey('GET /users/:id')
+ * // => { method: 'GET', path: '/users/:id', pattern: /^\/users\/([^/]+)$/, params: ['id'] }
+ */
+export declare function parseRouteKey(routeKey: string): ParsedRoute;

package/dist/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAuC3D"}

package/dist/parser.js

@@ -0,0 +1,40 @@
+import { RouteParseError } from "./errors";
+/**
+ * Parse 'METHOD /path' route key format
+ *
+ * Design note: We validate the format strictly to catch typos early.
+ * The 'METHOD /path' format was chosen for its readability and
+ * similarity to API documentation formats.
+ *
+ * @example
+ * parseRouteKey('GET /users/:id')
+ * // => { method: 'GET', path: '/users/:id', pattern: /^\/users\/([^/]+)$/, params: ['id'] }
+ */
+export function parseRouteKey(routeKey) {
+    const match = routeKey.match(/^(GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS) (.+)$/);
+    if (!match) {
+        throw new RouteParseError(routeKey, 'Expected format: "METHOD /path" (e.g., "GET /users")');
+    }
+    const [, method, path] = match;
+    // Extract parameter names
+    const params = [];
+    const paramPattern = /:([^/]+)/g;
+    let paramMatch;
+    paramMatch = paramPattern.exec(path);
+    while (paramMatch !== null) {
+        params.push(paramMatch[1]);
+        paramMatch = paramPattern.exec(path);
+    }
+    // Build regex pattern for matching
+    // Replace :param with capture groups
+    const regexPath = path
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except :
+        .replace(/:([^/]+)/g, "([^/]+)"); // Replace :param with capture group
+    const pattern = new RegExp(`^${regexPath}$`);
+    return {
+        method: method,
+        path,
+        pattern,
+        params,
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,15 @@
+export type HttpMethod = Schmock.HttpMethod;
+export type RouteKey = Schmock.RouteKey;
+export type ResponseResult = Schmock.ResponseResult;
+export type RequestContext = Schmock.RequestContext;
+export type Response = Schmock.Response;
+export type RequestOptions = Schmock.RequestOptions;
+export type GlobalConfig = Schmock.GlobalConfig;
+export type RouteConfig = Schmock.RouteConfig;
+export type Generator = Schmock.Generator;
+export type GeneratorFunction = Schmock.GeneratorFunction;
+export type CallableMockInstance = Schmock.CallableMockInstance;
+export type Plugin = Schmock.Plugin;
+export type PluginContext = Schmock.PluginContext;
+export type PluginResult = Schmock.PluginResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACxC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;AACxC,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;AACpD,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;AAChD,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;AAC9C,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;AAC1C,MAAM,MAAM,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;AAC1D,MAAM,MAAM,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC;AAChE,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;AACpC,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+/// <reference path="../../../types/schmock.d.ts" />
+export {};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@schmock/core",
+  "description": "Core functionality for Schmock",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "bun build:lib && bun build:types",
+    "build:lib": "bun build --minify --outdir=dist src/index.ts",
+    "build:types": "tsc -p tsconfig.json",
+    "pretest": "rm -f src/*.js src/*.d.ts || true",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "pretest:bdd": "rm -f src/*.js src/*.d.ts || true",
+    "test:bdd": "vitest run --config vitest.config.bdd.ts",
+    "lint": "biome check src/*.ts",
+    "lint:fix": "biome check --write --unsafe src/*.ts"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@amiceli/vitest-cucumber": "^6.1.0",
+    "@types/node": "^24.9.1",
+    "@vitest/ui": "^4.0.15",
+    "vitest": "^4.0.15"
+  }
+}

package/src/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["builder.ts"],"names":[],"mappings":"AAAA,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;AAW7B,OAAO,KAAK,EACV,OAAO,EACP,aAAa,EAEb,YAAY,EAGZ,MAAM,EACP,MAAM,SAAS,CAAC;AAajB;;;;GAIG;AACH,qBAAa,cAAc,CAAC,MAAM,GAAG,OAAO,CAAE,YAAW,OAAO,CAAC,MAAM,CAAC;IACtE,OAAO,CAAC,OAAO,CAEb;IAEF,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAK/C,KAAK,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAShC,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKpC,KAAK,IAAI,YAAY,CAAC,MAAM,CAAC;IAQ7B;;;OAGG;IACH,OAAO,CAAC,aAAa;CA0BtB"}

package/src/builder.test.ts

@@ -0,0 +1,289 @@
+import { describe, expect, it } from "vitest";
+import { schmock } from "./index";
+
+describe("schmock callable API", () => {
+  describe("callable instance", () => {
+    it("returns callable mock instance from factory", () => {
+      const mock = schmock();
+      expect(mock).toBeDefined();
+      expect(typeof mock).toBe("function");
+      expect(mock.handle).toBeTypeOf("function");
+      expect(mock.pipe).toBeTypeOf("function");
+    });
+
+    it("allows defining routes through function calls", () => {
+      const mock = schmock();
+      const result = mock("GET /users", () => [], {});
+
+      expect(result).toBe(mock); // Should return same instance for chaining
+      expect(result.pipe).toBeTypeOf("function");
+    });
+
+    it("supports chaining with pipe method", () => {
+      const mock = schmock();
+      const result = mock("GET /users", () => [], {}).pipe({
+        name: "test-plugin",
+        process: (ctx, response) => ({ context: ctx, response }),
+      });
+
+      expect(result).toBe(mock); // Should return same instance for chaining
+    });
+  });
+
+  describe("request handling", () => {
+    it("handles simple GET request", async () => {
+      const mock = schmock();
+      mock("GET /users", () => [{ id: 1, name: "John" }], {});
+
+      const response = await mock.handle("GET", "/users");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([{ id: 1, name: "John" }]);
+      expect(response.headers).toEqual({ "content-type": "application/json" });
+    });
+
+    it("returns 404 for undefined routes", async () => {
+      const mock = schmock();
+      mock("GET /users", () => [], {});
+
+      const response = await mock.handle("GET", "/posts");
+
+      expect(response.status).toBe(404);
+    });
+
+    it("handles route with parameters", async () => {
+      const mock = schmock();
+      mock("GET /users/:id", ({ params }) => ({ userId: params.id }), {});
+
+      const response = await mock.handle("GET", "/users/123");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ userId: "123" });
+    });
+
+    it("handles custom status codes via tuple", async () => {
+      const mock = schmock();
+      mock("POST /users", ({ body }) => [201, { id: 1, ...body }], {});
+
+      const response = await mock.handle("POST", "/users", {
+        body: { name: "Alice" },
+      });
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ id: 1, name: "Alice" });
+    });
+
+    it("handles custom headers via triple tuple", async () => {
+      const mock = schmock();
+      mock(
+        "POST /users",
+        ({ body }) => [201, { id: 1, ...body }, { Location: "/users/1" }],
+        {},
+      );
+
+      const response = await mock.handle("POST", "/users", {
+        body: { name: "Alice" },
+      });
+
+      expect(response.status).toBe(201);
+      expect(response.headers).toEqual({
+        Location: "/users/1",
+      });
+    });
+  });
+
+  describe("state management", () => {
+    it("maintains state across requests with global config", async () => {
+      const globalState = { count: 0 };
+      const mock = schmock({ state: globalState });
+      mock(
+        "GET /increment",
+        ({ state }) => {
+          state.count++;
+          return { value: state.count };
+        },
+        {},
+      );
+
+      const first = await mock.handle("GET", "/increment");
+      const second = await mock.handle("GET", "/increment");
+
+      expect(first.body).toEqual({ value: 1 });
+      expect(second.body).toEqual({ value: 2 });
+    });
+
+    it("shares state between routes with global config", async () => {
+      const globalState = { users: [] as unknown[] };
+      const mock = schmock({ state: globalState });
+
+      mock(
+        "POST /users",
+        ({ body, state }) => {
+          const user = { id: Date.now(), ...body };
+          state.users.push(user);
+          return [201, user];
+        },
+        {},
+      );
+
+      mock("GET /users", ({ state }) => state.users, {});
+
+      await mock.handle("POST", "/users", { body: { name: "John" } });
+      const response = await mock.handle("GET", "/users");
+
+      expect(response.body).toHaveLength(1);
+      expect(response.body[0]).toHaveProperty("name", "John");
+    });
+  });
+
+  describe("configuration", () => {
+    it("applies namespace to all routes", async () => {
+      const mock = schmock({ namespace: "/api/v1" });
+      mock("GET /users", () => [], {});
+
+      const response = await mock.handle("GET", "/api/v1/users");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([]);
+    });
+
+    it("returns 404 without namespace prefix", async () => {
+      const mock = schmock({ namespace: "/api/v1" });
+      mock("GET /users", () => [], {});
+
+      const response = await mock.handle("GET", "/users");
+
+      expect(response.status).toBe(404);
+    });
+  });
+
+  describe("request context", () => {
+    it("provides query parameters", async () => {
+      const mock = schmock();
+      mock(
+        "GET /search",
+        ({ query }) => ({
+          results: [],
+          query: query.q,
+        }),
+        {},
+      );
+
+      const response = await mock.handle("GET", "/search", {
+        query: { q: "test" },
+      });
+
+      expect(response.body).toEqual({
+        results: [],
+        query: "test",
+      });
+    });
+
+    it("provides headers", async () => {
+      const mock = schmock();
+      mock(
+        "GET /auth",
+        ({ headers }) => ({
+          authenticated: headers.authorization === "Bearer token123",
+        }),
+        {},
+      );
+
+      const response = await mock.handle("GET", "/auth", {
+        headers: { authorization: "Bearer token123" },
+      });
+
+      expect(response.body).toEqual({ authenticated: true });
+    });
+
+    it("provides method and path in context", async () => {
+      const mock = schmock();
+      mock("GET /info", ({ method, path }) => ({ method, path }), {});
+
+      const response = await mock.handle("GET", "/info");
+
+      expect(response.body).toEqual({
+        method: "GET",
+        path: "/info",
+      });
+    });
+  });
+
+  describe("contentType auto-detection", () => {
+    it("defaults to application/json for function generators", async () => {
+      const mock = schmock();
+      mock("GET /users", () => [{ id: 1 }], {});
+
+      const response = await mock.handle("GET", "/users");
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([{ id: 1 }]);
+    });
+
+    it("defaults to text/plain for string generators", async () => {
+      const mock = schmock();
+      mock("GET /text", "Hello World", {});
+
+      const response = await mock.handle("GET", "/text");
+      expect(response.status).toBe(200);
+      expect(response.body).toBe("Hello World");
+    });
+
+    it("defaults to application/json for object generators", async () => {
+      const mock = schmock();
+      mock("GET /users", [{ id: 1, name: "John" }], {});
+
+      const response = await mock.handle("GET", "/users");
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual([{ id: 1, name: "John" }]);
+    });
+
+    it("allows explicit contentType override", async () => {
+      const mock = schmock();
+      mock("GET /json", "Hello World", { contentType: "application/json" });
+
+      const response = await mock.handle("GET", "/json");
+      expect(response.status).toBe(200);
+      expect(response.body).toBe("Hello World");
+    });
+
+    it("validates JSON data for application/json contentType", () => {
+      const mock = schmock();
+
+      // This should work - valid JSON data
+      expect(() => {
+        mock("GET /users", [{ id: 1 }], { contentType: "application/json" });
+      }).not.toThrow();
+
+      // This should fail - circular reference can't be JSON serialized
+      const circular: any = {};
+      circular.self = circular;
+
+      expect(() => {
+        mock("GET /users", circular, { contentType: "application/json" });
+      }).toThrow(
+        "Generator data is not valid JSON but contentType is application/json",
+      );
+    });
+  });
+
+  describe("plugin integration", () => {
+    it("supports plugin pipeline with pipe method", async () => {
+      const mock = schmock();
+      mock("GET /users", [{ id: 1, name: "John" }], {}).pipe({
+        name: "test-plugin",
+        process: (ctx, response) => ({
+          context: ctx,
+          response: { data: response, processed: true },
+        }),
+      });
+
+      const response = await mock.handle("GET", "/users");
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({
+        data: [{ id: 1, name: "John" }],
+        processed: true,
+      });
+    });
+  });
+});