@schmock/core 1.0.4 → 1.2.1

package/src/steps/error-handling.steps.ts

@@ -1,7 +1,7 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
+import type { CallableMockInstance, Plugin } from "../types";
 import { schmock } from "../index";
-import type { CallableMockInstance } from "../types";
 
 const feature = await loadFeature("../../features/error-handling.feature");
 
@@ -11,9 +11,9 @@ describeFeature(feature, ({ Scenario }) => {
   let error: Error | null = null;
 
   Scenario("Route not found returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with a GET /users route returning a user list", () => {
       mock = schmock();
-      mock('GET /users', [{ id: 1, name: 'John' }]);
+      mock("GET /users", [{ id: 1, name: "John" }]);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -35,9 +35,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Wrong HTTP method returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with a GET /api/data route returning success", () => {
       mock = schmock();
-      mock('GET /api/data', { success: true });
+      mock("GET /api/data", { success: true });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -55,11 +55,11 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Invalid route key throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to create a mock with invalid route:", (_, docString: string) => {
+    Given("I attempt to register a route with an invalid HTTP method", () => {
       error = null;
       try {
         mock = schmock();
-        mock('INVALID_METHOD /path', 'response');
+        mock("INVALID_METHOD /path" as any, "response");
       } catch (e) {
         error = e as Error;
       }
@@ -67,20 +67,20 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("it should throw a RouteDefinitionError", () => {
       expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
+      expect(error!.constructor.name).toBe("RouteParseError");
     });
 
     And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain('Invalid route key format');
+      expect(error!.message).toContain("Invalid route key format");
     });
   });
 
   Scenario("Empty route path throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to create a mock with empty path:", (_, docString: string) => {
+    Given("I attempt to register a route with an empty path", () => {
       error = null;
       try {
         mock = schmock();
-        mock('GET ', 'response');
+        mock("GET " as any, "response");
       } catch (e) {
         error = e as Error;
       }
@@ -88,22 +88,22 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("it should throw a RouteDefinitionError", () => {
       expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteParseError');
+      expect(error!.constructor.name).toBe("RouteParseError");
     });
 
     And("the error message should contain {string}", (_, message: string) => {
-      expect(error!.message).toContain('Invalid route key format');
+      expect(error!.message).toContain("Invalid route key format");
     });
   });
 
   Scenario("Plugin throws error returns 500 with PluginError", ({ Given, When, Then, And }) => {
-    Given("I create a mock with failing plugin:", (_, docString: string) => {
+    Given("I create a mock with a plugin that throws {string}", (_, errorMsg: string) => {
       mock = schmock();
-      const failingPlugin = {
-        name: 'failing-plugin',
-        process: () => { throw new Error('Plugin failed'); }
+      const failingPlugin: Plugin = {
+        name: "failing-plugin",
+        process: () => { throw new Error(errorMsg); },
       };
-      mock('GET /test', 'original').pipe(failingPlugin);
+      mock("GET /test", "original").pipe(failingPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -125,14 +125,14 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin onError hook recovers from failure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with recoverable plugin:", (_, docString: string) => {
+    Given("I create a mock with a recoverable plugin that returns {string}", (_, recoveredBody: string) => {
       mock = schmock();
-      const recoverablePlugin = {
-        name: 'recoverable',
-        process: () => { throw new Error('Initial failure'); },
-        onError: () => ({ status: 200, body: 'recovered', headers: {} })
+      const recoverablePlugin: Plugin = {
+        name: "recoverable",
+        process: () => { throw new Error("Initial failure"); },
+        onError: () => ({ status: 200, body: recoveredBody, headers: {} }),
       };
-      mock('GET /test', 'original').pipe(recoverablePlugin);
+      mock("GET /test", "original").pipe(recoverablePlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -150,13 +150,13 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin returns invalid result structure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with invalid plugin:", (_, docString: string) => {
+    Given("I create a mock with a plugin returning an invalid result", () => {
       mock = schmock();
-      const invalidPlugin = {
-        name: 'invalid',
-        process: () => ({ wrongStructure: true })
+      const invalidPlugin: Plugin = {
+        name: "invalid",
+        process: () => ({ wrongStructure: true }) as any,
       };
-      mock('GET /test', 'original').pipe(invalidPlugin);
+      mock("GET /test", "original").pipe(invalidPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -174,9 +174,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Function generator throws error returns 500", ({ Given, When, Then, And }) => {
-    Given("I create a mock with failing generator:", (_, docString: string) => {
+    Given("I create a mock with a generator that throws {string}", (_, errorMsg: string) => {
       mock = schmock();
-      mock('GET /fail', () => { throw new Error('Generator failed'); });
+      mock("GET /fail", () => { throw new Error(errorMsg); });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -198,13 +198,13 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Invalid JSON generator with JSON content-type throws RouteDefinitionError", ({ Given, Then, And }) => {
-    Given("I attempt to create a mock with invalid JSON:", (_, docString: string) => {
+    Given("I attempt to register a route with a circular reference as JSON", () => {
       error = null;
       try {
         mock = schmock();
-        const circularRef: any = {};
+        const circularRef: Record<string, unknown> = {};
         circularRef.self = circularRef;
-        mock('GET /invalid', circularRef, { contentType: 'application/json' });
+        mock("GET /invalid", circularRef, { contentType: "application/json" });
       } catch (e) {
         error = e as Error;
       }
@@ -212,7 +212,7 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("it should throw a RouteDefinitionError", () => {
       expect(error).not.toBeNull();
-      expect(error!.constructor.name).toBe('RouteDefinitionError');
+      expect(error!.constructor.name).toBe("RouteDefinitionError");
     });
 
     And("the error message should contain {string}", (_, message: string) => {
@@ -221,9 +221,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Namespace mismatch returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with namespace:", (_, docString: string) => {
-      mock = schmock({ namespace: '/api/v1' });
-      mock('GET /users', [{ id: 1 }]);
+    Given("I create a mock with namespace {string} and a GET /users route", (_, namespace: string) => {
+      mock = schmock({ namespace });
+      mock("GET /users", [{ id: 1 }]);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -241,17 +241,17 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Multiple plugin failures cascade properly", ({ Given, When, Then, And }) => {
-    Given("I create a mock with multiple failing plugins:", (_, docString: string) => {
+    Given("I create a mock with two failing plugins piped in sequence", () => {
       mock = schmock();
-      const plugin1 = {
-        name: 'first-fail',
-        process: () => { throw new Error('First error'); }
+      const plugin1: Plugin = {
+        name: "first-fail",
+        process: () => { throw new Error("First error"); },
       };
-      const plugin2 = {
-        name: 'second-fail', 
-        process: () => { throw new Error('Second error'); }
+      const plugin2: Plugin = {
+        name: "second-fail",
+        process: () => { throw new Error("Second error"); },
       };
-      mock('GET /cascade', 'original').pipe(plugin1).pipe(plugin2);
+      mock("GET /cascade", "original").pipe(plugin1).pipe(plugin2);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -269,14 +269,14 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin onError hook also fails", ({ Given, When, Then, And }) => {
-    Given("I create a mock with broken error handler:", (_, docString: string) => {
+    Given("I create a mock with a plugin whose error handler also throws", () => {
       mock = schmock({ debug: true });
-      const brokenPlugin = {
-        name: 'broken-handler',
-        process: () => { throw new Error('Process failed'); },
-        onError: () => { throw new Error('Handler failed'); }
+      const brokenPlugin: Plugin = {
+        name: "broken-handler",
+        process: () => { throw new Error("Process failed"); },
+        onError: () => { throw new Error("Handler failed"); },
       };
-      mock('GET /broken', 'original').pipe(brokenPlugin);
+      mock("GET /broken", "original").pipe(brokenPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -294,9 +294,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Empty parameter in route returns 404", ({ Given, When, Then, And }) => {
-    Given("I create a mock with parameterized route:", (_, docString: string) => {
+    Given("I create a mock with a parameterized route {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /users/:id', ({ params }) => ({ userId: params.id }));
+      mock(route as any, ({ params }: any) => ({ userId: params.id }));
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -314,11 +314,11 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async generator error handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with failing async generator:", (_, docString: string) => {
+    Given("I create a mock with an async generator that throws {string}", (_, errorMsg: string) => {
       mock = schmock();
-      mock('GET /async-fail', async () => { 
+      mock("GET /async-fail", async () => {
         await new Promise(resolve => setTimeout(resolve, 10));
-        throw new Error('Async generator failed'); 
+        throw new Error(errorMsg);
       });
     });
 
@@ -337,9 +337,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Error responses include proper headers", ({ Given, When, Then, And }) => {
-    Given("I create a mock with failing route:", (_, docString: string) => {
+    Given("I create a mock with a generator that throws {string}", (_, errorMsg: string) => {
       mock = schmock();
-      mock('GET /error', () => { throw new Error('Test error'); });
+      mock("GET /error", () => { throw new Error(errorMsg); });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -352,7 +352,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("the content-type should be {string}", (_, contentType: string) => {
-      // Error responses don't get content-type headers automatically
       expect(response.headers).toBeDefined();
     });
 
@@ -362,14 +361,14 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin onError returns response with status 0", ({ Given, When, Then, And }) => {
-    Given("I create a mock with status-zero error handler:", (_, docString: string) => {
+    Given("I create a mock with a plugin whose error handler returns status 0", () => {
       mock = schmock();
-      const plugin = {
-        name: 'zero-status',
-        process: () => { throw new Error('fail'); },
-        onError: () => ({ status: 0, body: 'zero status', headers: {} })
+      const plugin: Plugin = {
+        name: "zero-status",
+        process: () => { throw new Error("fail"); },
+        onError: () => ({ status: 0, body: "zero status", headers: {} }),
       };
-      mock('GET /zero', 'original').pipe(plugin);
+      mock("GET /zero", "original").pipe(plugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -387,13 +386,13 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin null/undefined return handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with null-returning plugin:", (_, docString: string) => {
+    Given("I create a mock with a plugin that returns null", () => {
       mock = schmock();
-      const nullPlugin = {
-        name: 'null-plugin',
-        process: () => null
+      const nullPlugin: Plugin = {
+        name: "null-plugin",
+        process: () => null as any,
       };
-      mock('GET /null', 'original').pipe(nullPlugin);
+      mock("GET /null", "original").pipe(nullPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -409,4 +408,4 @@ describeFeature(feature, ({ Scenario }) => {
       expect(response.body.error).toContain(errorMessage);
     });
   });
-});
+});

package/src/steps/fluent-api.steps.ts

@@ -1,24 +1,21 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
 import { schmock } from "../index";
-import type { MockInstance } from "../types";
+import type { CallableMockInstance } from "../types";
 
 const feature = await loadFeature("../../features/fluent-api.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let mock: MockInstance<any>;
+  let mock: CallableMockInstance;
   let response: any;
   let responses: any[] = [];
-  const error: Error | null = null;
 
   Scenario("Simple route with generator function", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create callable mock instance
+    Given("I create a mock with a JSON generator at {string}", (_, route: string) => {
       mock = schmock({});
-      
-      // Parse and execute the route definition from docString
-      // This scenario defines: GET /users with a generator function
-      mock('GET /users', () => [{ id: 1, name: 'John' }], {});
+      mock(route as Schmock.RouteKey, () => [{ id: 1, name: "John" }], {
+        contentType: "application/json",
+      });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -37,15 +34,17 @@ describeFeature(feature, ({ Scenario }) => {
     ({ Given, When, Then, And }) => {
       responses = [];
 
-      Given("I create a mock with:", (_, docString: string) => {
-        // Create mock with global state
+      Given("I create a mock with a stateful counter", () => {
         mock = schmock({ state: { count: 0 } });
-        
-        // Define counter route that uses global state
-        mock('GET /counter', ({ state }) => {
-          state.count++;
-          return { value: state.count };
-        }, {});
+        mock(
+          "GET /counter",
+          ({ state }) => {
+            const s = state as { count: number };
+            s.count++;
+            return { value: s.count };
+          },
+          { contentType: "application/json" },
+        );
       });
 
       When("I request {string} twice", async (_, request: string) => {
@@ -66,10 +65,11 @@ describeFeature(feature, ({ Scenario }) => {
   );
 
   Scenario("Route with parameters", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with parameter route
+    Given("I create a mock with a parameterized route {string}", (_, route: string) => {
       mock = schmock({});
-      mock('GET /users/:id', ({ params }) => ({ userId: params.id }), {});
+      mock(route as Schmock.RouteKey, ({ params }) => ({ userId: params.id }), {
+        contentType: "application/json",
+      });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -84,10 +84,14 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Response with custom status code", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with custom status response
+    Given("I create a mock returning status {int} for {string}", (_, _status: number, route: string) => {
       mock = schmock({});
-      mock('POST /users', ({ body }) => [201, { id: 1, ...body }], {});
+      mock(route as Schmock.RouteKey, ({ body }) => {
+        const b = body as Record<string, unknown>;
+        return [201, { id: 1, ...b }];
+      }, {
+        contentType: "application/json",
+      });
     });
 
     When(
@@ -109,11 +113,29 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
+  Scenario("Static data response", ({ Given, When, Then }) => {
+    Given("I create a mock with static config data at {string}", (_, route: string) => {
+      mock = schmock({});
+      mock(route as Schmock.RouteKey, { version: "1.0.0", features: ["auth"] }, {
+        contentType: "application/json",
+      });
+    });
+
+    When("I request {string}", async (_, request: string) => {
+      const [method, path] = request.split(" ");
+      response = await mock.handle(method as any, path);
+    });
+
+    Then("I should receive:", (_, docString: string) => {
+      const expected = JSON.parse(docString);
+      expect(response.body).toEqual(expected);
+    });
+  });
+
   Scenario("404 for undefined routes", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with only one route, so other routes return 404
+    Given("I create a mock with only a {string} route", (_, route: string) => {
       mock = schmock({});
-      mock('GET /users', () => [], {});
+      mock(route as Schmock.RouteKey, () => [], { contentType: "application/json" });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -127,20 +149,22 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Query parameters", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock that handles query parameters
+    Given("I create a mock that reads query parameters at {string}", (_, route: string) => {
       mock = schmock({});
-      mock('GET /search', ({ query }) => ({ 
-        results: [], 
-        query: query.q 
-      }), {});
+      mock(
+        route as Schmock.RouteKey,
+        ({ query }) => ({
+          results: [],
+          query: query.q,
+        }),
+        { contentType: "application/json" },
+      );
     });
 
     When("I request {string}", async (_, request: string) => {
       const [method, fullPath] = request.split(" ");
       const [path, queryString] = fullPath.split("?");
 
-      // Parse query string
       const query: Record<string, string> = {};
       if (queryString) {
         queryString.split("&").forEach((param) => {
@@ -159,12 +183,15 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Request headers access", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock that accesses request headers
+    Given("I create a mock that reads headers at {string}", (_, route: string) => {
       mock = schmock({});
-      mock('GET /auth', ({ headers }) => ({ 
-        authenticated: headers.authorization === 'Bearer token123' 
-      }), {});
+      mock(
+        route as Schmock.RouteKey,
+        ({ headers }) => ({
+          authenticated: headers.authorization === "Bearer token123",
+        }),
+        { contentType: "application/json" },
+      );
     });
 
     When(
@@ -183,28 +210,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Global configuration with namespace", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with namespace configuration
-      mock = schmock({ namespace: '/api/v1' });
-      mock('GET /users', () => [], {});
-    });
-
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      response = await mock.handle(method as any, path);
-    });
-
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(response.body).toEqual(expected);
-    });
-  });
-
-  Scenario("Static data response", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with static data response
-      mock = schmock({});
-      mock('GET /config', { version: '1.0.0', features: ['auth'] }, {});
+    Given("I create a mock with namespace {string}", (_, namespace: string) => {
+      mock = schmock({ namespace });
+      mock("GET /users", () => [], { contentType: "application/json" });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -218,18 +226,19 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Plugin pipeline with pipe chaining", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
-      // Create mock with plugin pipeline
+  Scenario("Plugin pipeline with pipe chaining", ({ Given, When, Then }) => {
+    Given("I create a mock with two passthrough plugins", () => {
       mock = schmock({});
-      mock('GET /users', () => [{ id: 1, name: 'John' }], {})
+      mock("GET /users", () => [{ id: 1, name: "John" }], {
+        contentType: "application/json",
+      })
         .pipe({
           name: "logging",
-          process: (ctx, response) => ({ context: ctx, response })
+          process: (ctx, response) => ({ context: ctx, response }),
         })
         .pipe({
           name: "cors",
-          process: (ctx, response) => ({ context: ctx, response })
+          process: (ctx, response) => ({ context: ctx, response }),
         });
     });
 
@@ -242,11 +251,5 @@ describeFeature(feature, ({ Scenario }) => {
       const expected = JSON.parse(docString);
       expect(response.body).toEqual(expected);
     });
-
-    And("the response should have CORS headers", () => {
-      // This would check for CORS headers if implemented
-      // For now just verify the response was processed
-      expect(response).toBeDefined();
-    });
   });
 });