@schmock/core 1.0.3 → 1.1.0

package/src/steps/developer-experience.steps.ts

@@ -1,7 +1,7 @@
 import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
 import { expect } from "vitest";
 import { schmock } from "../index";
-import type { CallableMockInstance } from "../types";
+import type { CallableMockInstance, Plugin, PluginContext } from "../types";
 
 const feature = await loadFeature("../../features/developer-experience.feature");
 
@@ -9,12 +9,11 @@ describeFeature(feature, ({ Scenario }) => {
   let mock: CallableMockInstance;
   let response: any;
   let responses: any[] = [];
-  let error: Error | null = null;
 
   Scenario("Forgetting to provide response data", ({ Given, When, Then, And }) => {
-    Given("I create a mock without response data:", (_, docString: string) => {
+    Given("I create a mock with no response data on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /empty');
+      mock(route as Schmock.RouteKey, undefined);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -32,9 +31,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Using wrong parameter name in route", ({ Given, When, Then }) => {
-    Given("I create a mock with parameter route:", (_, docString: string) => {
+    Given("I create a mock with a mismatched parameter name on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /users/:userId', ({ params }) => ({ id: params.id }));
+      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.id }));
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -48,9 +47,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Correct parameter usage", ({ Given, When, Then }) => {
-    Given("I create a mock with proper parameter usage:", (_, docString: string) => {
+    Given("I create a mock with a matching parameter name on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /users/:userId', ({ params }) => ({ id: params.userId }));
+      mock(route as Schmock.RouteKey, ({ params }) => ({ id: params.userId }));
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -65,20 +64,20 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Mixing content types without explicit configuration", ({ Given, When, Then, And }) => {
-    Given("I create a mock with mixed content types:", (_, docString: string) => {
+    Given("I create a mock with JSON, text, number, and boolean routes", () => {
       mock = schmock();
-      mock('GET /json', { data: 'json' });
-      mock('GET /text', 'plain text');
-      mock('GET /number', 42);
-      mock('GET /boolean', true);
+      mock("GET /json", { data: "json" });
+      mock("GET /text", "plain text");
+      mock("GET /number", 42);
+      mock("GET /boolean", true);
     });
 
     When("I test all mixed content type routes", async () => {
       responses = [];
-      responses.push(await mock.handle('GET', '/json'));
-      responses.push(await mock.handle('GET', '/text'));
-      responses.push(await mock.handle('GET', '/number'));
-      responses.push(await mock.handle('GET', '/boolean'));
+      responses.push(await mock.handle("GET", "/json"));
+      responses.push(await mock.handle("GET", "/text"));
+      responses.push(await mock.handle("GET", "/number"));
+      responses.push(await mock.handle("GET", "/boolean"));
     });
 
     Then("JSON route should have content-type {string}", (_, contentType: string) => {
@@ -99,9 +98,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Expecting JSON but getting string conversion", ({ Given, When, Then, And }) => {
-    Given("I create a mock with number response:", (_, docString: string) => {
+    Given("I create a mock returning a decimal number on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /price', 19.99);
+      mock(route as Schmock.RouteKey, 19.99);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -119,9 +118,9 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Forgetting await with async generators", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async generator:", (_, docString: string) => {
+    Given("I create a mock with an async handler on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /data', async () => ({ async: true }));
+      mock(route as Schmock.RouteKey, async () => ({ async: true }));
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -140,10 +139,11 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("State confusion between global and local state", ({ Given, When, Then, And }) => {
-    Given("I create a mock with state confusion:", (_, docString: string) => {
+    Given("I create a mock with global state and a local state counter", () => {
       mock = schmock({ state: { global: 1 } });
-      mock('GET /counter', ({ state }) => {
-        state.local = (state.local || 0) + 1;
+      mock("GET /counter", ({ state }) => {
+        const current = (state.local as number | undefined) || 0;
+        state.local = current + 1;
         return { global: state.global, local: state.local };
       });
     });
@@ -167,19 +167,19 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Query parameter edge cases", ({ Given, When, Then }) => {
-    Given("I create a mock handling query parameters:", (_, docString: string) => {
+    Given("I create a mock that echoes query parameters on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /search', ({ query }) => ({ 
+      mock(route as Schmock.RouteKey, ({ query }) => ({
         term: query.q,
         page: query.page,
-        empty: query.empty
+        empty: query.empty,
       }));
     });
 
     When("I request {string}", async (_, request: string) => {
       const [method, fullPath] = request.split(" ");
       const [path, queryString] = fullPath.split("?");
-      
+
       const query: Record<string, string> = {};
       if (queryString) {
         queryString.split("&").forEach((param) => {
@@ -187,7 +187,7 @@ describeFeature(feature, ({ Scenario }) => {
           query[key] = value || "";
         });
       }
-      
+
       response = await mock.handle(method as any, path, { query });
     });
 
@@ -198,12 +198,12 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Headers case sensitivity", ({ Given, When, Then }) => {
-    Given("I create a mock checking headers:", (_, docString: string) => {
+    Given("I create a mock that echoes headers on {string}", (_, route: string) => {
       mock = schmock();
-      mock('GET /auth', ({ headers }) => ({ 
+      mock(route as Schmock.RouteKey, ({ headers }) => ({
         auth: headers.authorization,
         authUpper: headers.Authorization,
-        contentType: headers['content-type']
+        contentType: headers["content-type"],
       }));
     });
 
@@ -214,25 +214,25 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     Then("the header case sensitivity should show expected values", () => {
-      expect(response.body).toEqual({ 
-        auth: undefined, 
-        authUpper: "Bearer token", 
-        contentType: undefined 
+      expect(response.body).toEqual({
+        auth: undefined,
+        authUpper: "Bearer token",
+        contentType: undefined,
       });
     });
   });
 
   Scenario("Route precedence with similar paths", ({ Given, When, Then, And }) => {
-    Given("I create a mock with similar routes:", (_, docString: string) => {
+    Given("I create a mock with an exact route and a parameterized route on {string}", (_, basePath: string) => {
       mock = schmock();
-      mock('GET /users/profile', { type: 'profile' });
-      mock('GET /users/:id', ({ params }) => ({ type: 'user', id: params.id }));
+      mock(`GET ${basePath}/profile`, { type: "profile" });
+      mock(`GET ${basePath}/:id`, ({ params }) => ({ type: "user", id: params.id }));
     });
 
     When("I test both route precedence scenarios", async () => {
       responses = [];
-      responses.push(await mock.handle('GET', '/users/profile'));
-      responses.push(await mock.handle('GET', '/users/123'));
+      responses.push(await mock.handle("GET", "/users/profile"));
+      responses.push(await mock.handle("GET", "/users/123"));
     });
 
     Then("the profile route should return exact match:", (_, docString: string) => {
@@ -247,25 +247,23 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin order affecting results", ({ Given, When, Then }) => {
-    Given("I create a mock with order-dependent plugins:", (_, docString: string) => {
+    Given("I create a mock with two plugins that each set a step number", () => {
       mock = schmock();
-      const plugin1 = {
-        name: 'first',
-        process: (ctx: any, response: any) => ({
+      const plugin1: Plugin = {
+        name: "first",
+        process: (ctx: PluginContext, response: unknown) => ({
           context: ctx,
-          response: { ...response, step: 1 }
-        })
+          response: { ...(response as Record<string, unknown>), step: 1 },
+        }),
       };
-      const plugin2 = {
-        name: 'second', 
-        process: (ctx: any, response: any) => ({
+      const plugin2: Plugin = {
+        name: "second",
+        process: (ctx: PluginContext, response: unknown) => ({
           context: ctx,
-          response: { ...response, step: 2 }
-        })
+          response: { ...(response as Record<string, unknown>), step: 2 },
+        }),
       };
-      mock('GET /order', { original: true })
-        .pipe(plugin1)
-        .pipe(plugin2);
+      mock("GET /order", { original: true }).pipe(plugin1).pipe(plugin2);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -280,15 +278,15 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Namespace confusion with absolute paths", ({ Given, When, Then, And }) => {
-    Given("I create a mock with namespace:", (_, docString: string) => {
-      mock = schmock({ namespace: '/api/v1' });
-      mock('GET /users', []);
+    Given("I create a mock with namespace {string} and a users route", (_, namespace: string) => {
+      mock = schmock({ namespace });
+      mock("GET /users", []);
     });
 
     When("I test both namespace scenarios", async () => {
       responses = [];
-      responses.push(await mock.handle('GET', '/users'));
-      responses.push(await mock.handle('GET', '/api/v1/users'));
+      responses.push(await mock.handle("GET", "/users"));
+      responses.push(await mock.handle("GET", "/api/v1/users"));
     });
 
     Then("the wrong namespace should receive status {int}", (_, status: number) => {
@@ -302,27 +300,27 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin expecting different context structure", ({ Given, When, Then }) => {
-    Given("I create a mock with context-dependent plugin:", (_, docString: string) => {
+    Given("I create a mock with a plugin that reads context properties", () => {
       mock = schmock();
-      const plugin = {
-        name: 'context-reader',
-        process: (ctx: any, response: any) => ({
+      const plugin: Plugin = {
+        name: "context-reader",
+        process: (ctx: PluginContext, _response: unknown) => ({
           context: ctx,
           response: {
             method: ctx.method,
             path: ctx.path,
             hasBody: !!ctx.body,
-            hasQuery: !!ctx.query && Object.keys(ctx.query).length > 0
-          }
-        })
+            hasQuery: !!ctx.query && Object.keys(ctx.query).length > 0,
+          },
+        }),
       };
-      mock('POST /analyze', null).pipe(plugin);
+      mock("POST /analyze", null).pipe(plugin);
     });
 
     When("I request {string} with body:", async (_, request: string, docString: string) => {
       const [method, fullPath] = request.split(" ");
       const [path, queryString] = fullPath.split("?");
-      
+
       const query: Record<string, string> = {};
       if (queryString) {
         queryString.split("&").forEach((param) => {
@@ -330,7 +328,7 @@ describeFeature(feature, ({ Scenario }) => {
           query[key] = value || "";
         });
       }
-      
+
       const body = JSON.parse(docString);
       response = await mock.handle(method as any, path, { body, query });
     });
@@ -342,18 +340,18 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Response tuple format edge cases", ({ Given, When, Then, And }) => {
-    Given("I create a mock with tuple responses:", (_, docString: string) => {
+    Given("I create a mock with three tuple response routes", () => {
       mock = schmock();
-      mock('GET /created', [201]);
-      mock('GET /with-headers', [200, { data: true }, { 'x-custom': 'header' }]);
-      mock('GET /empty-with-status', [204, null]);
+      mock("GET /created", [201]);
+      mock("GET /with-headers", [200, { data: true }, { "x-custom": "header" }]);
+      mock("GET /empty-with-status", [204, null]);
     });
 
     When("I test all tuple response formats", async () => {
       responses = [];
-      responses.push(await mock.handle('GET', '/created'));
-      responses.push(await mock.handle('GET', '/with-headers'));
-      responses.push(await mock.handle('GET', '/empty-with-status'));
+      responses.push(await mock.handle("GET", "/created"));
+      responses.push(await mock.handle("GET", "/with-headers"));
+      responses.push(await mock.handle("GET", "/empty-with-status"));
     });
 
     Then("the created endpoint should return status 201 with empty body", () => {
@@ -364,7 +362,7 @@ describeFeature(feature, ({ Scenario }) => {
     And("the headers endpoint should return status 200 with data and custom header", () => {
       expect(responses[1].status).toBe(200);
       expect(responses[1].body).toEqual({ data: true });
-      expect(responses[1].headers?.['x-custom']).toBe('header');
+      expect(responses[1].headers?.["x-custom"]).toBe("header");
     });
 
     And("the empty endpoint should return status 204 with null body", () => {
@@ -376,18 +374,18 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Common typos in method names", ({ Given, When, Then, And }) => {
     let errors: Error[] = [];
 
-    Given("I attempt to create mocks with typo methods:", (_, docString: string) => {
+    Given("I create an empty mock for testing method typos", () => {
       mock = schmock();
     });
 
     When("I test all common method typos", () => {
       errors = [];
-      const typos = ['GETS /users', 'post /users', 'GET/users'];
-      
+      const typos = ["GETS /users", "post /users", "GET/users"];
+
       for (const typo of typos) {
         try {
-          mock(typo, 'test');
-          errors.push(new Error('No error thrown')); // Should not happen
+          mock(typo as Schmock.RouteKey, "test");
+          errors.push(new Error("No error thrown"));
         } catch (e) {
           errors.push(e as Error);
         }
@@ -396,31 +394,49 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("the wrong method typo should throw RouteParseError", () => {
       expect(errors[0]).not.toBeNull();
-      expect(errors[0].constructor.name).toBe('RouteParseError');
-      expect(errors[0].message).toContain('Invalid route key format');
+      expect(errors[0].constructor.name).toBe("RouteParseError");
+      expect(errors[0].message).toContain("Invalid route key format");
     });
 
     And("the lowercase method typo should throw RouteParseError", () => {
       expect(errors[1]).not.toBeNull();
-      expect(errors[1].constructor.name).toBe('RouteParseError');
-      expect(errors[1].message).toContain('Invalid route key format');
+      expect(errors[1].constructor.name).toBe("RouteParseError");
+      expect(errors[1].message).toContain("Invalid route key format");
     });
 
     And("the missing space typo should throw RouteParseError", () => {
       expect(errors[2]).not.toBeNull();
-      expect(errors[2].constructor.name).toBe('RouteParseError');
-      expect(errors[2].message).toContain('Invalid route key format');
+      expect(errors[2].constructor.name).toBe("RouteParseError");
+      expect(errors[2].message).toContain("Invalid route key format");
+    });
+  });
+
+  Scenario("Registering duplicate routes first route wins", ({ Given, When, Then }) => {
+    Given("I create a mock with two routes on {string} with different data", (_, route: string) => {
+      mock = schmock();
+      mock(route as Schmock.RouteKey, [{ id: 1 }]);
+      mock(route as Schmock.RouteKey, [{ id: 2 }]);
+    });
+
+    When("I request {string}", async (_, request: string) => {
+      const [method, path] = request.split(" ");
+      response = await mock.handle(method as any, path);
+    });
+
+    Then("the first route response should win:", (_, docString: string) => {
+      const expected = JSON.parse(docString);
+      expect(response.body).toEqual(expected);
     });
   });
 
   Scenario("Plugin returning unexpected structure", ({ Given, When, Then, And }) => {
-    Given("I create a mock with malformed plugin:", (_, docString: string) => {
+    Given("I create a mock with a plugin that returns an invalid structure", () => {
       mock = schmock();
       const badPlugin = {
-        name: 'bad-structure',
-        process: () => ({ wrong: 'structure' })
+        name: "bad-structure",
+        process: () => ({ wrong: "structure" }),
       };
-      mock('GET /bad', 'original').pipe(badPlugin);
+      mock("GET /bad", "original").pipe(badPlugin as any);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -436,4 +452,4 @@ describeFeature(feature, ({ Scenario }) => {
       expect(response.body.error).toContain(errorMessage);
     });
   });
-});
+});