@schmock/core 1.0.3 → 1.1.0

package/src/steps/plugin-integration.steps.ts

@@ -1,100 +1,100 @@
 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/plugin-integration.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let mock: MockInstance<any>;
+  let mock: CallableMockInstance;
   let requestResponses: any[] = [];
 
   Scenario("Plugin state sharing with pipeline", ({ Given, When, Then, And }) => {
     requestResponses = [];
 
-    Given("I create a mock with stateful plugin:", (_, docString: string) => {
-      // Create mock with stateful plugin that persists state across requests
-      mock = schmock({});
-      
-      // We need persistent state per route, so let's use a closure
-      let routeState = { request_count: 0 };
-      
-      mock('GET /counter', null, {})
-        .pipe({
-          name: "counter-plugin",
-          process: (ctx, response) => {
-            // Update shared route state
-            routeState.request_count = (routeState.request_count || 0) + 1;
-            
-            // Generate response if none exists
-            if (!response) {
-              return {
-                context: ctx,
-                response: {
-                  request_number: routeState.request_count,
-                  path: ctx.path,
-                  processed_at: new Date().toISOString()
-                }
-              };
-            }
-            
-            // Pass through existing response
-            return { context: ctx, response };
+    Given("I create a mock with a counter plugin using route state", () => {
+      mock = schmock({ state: {} });
+      mock("GET /counter", null, { contentType: "application/json" }).pipe({
+        name: "counter-plugin",
+        process: (ctx, response) => {
+          const routeState = ctx.routeState!;
+          routeState.request_count =
+            ((routeState.request_count as number) || 0) + 1;
+
+          if (!response) {
+            return {
+              context: ctx,
+              response: {
+                request_number: routeState.request_count,
+                path: ctx.path,
+                processed_at: new Date().toISOString(),
+              },
+            };
           }
-        });
+
+          return { context: ctx, response };
+        },
+      });
     });
 
     When("I request {string} three times", async (_, request: string) => {
       const [method, path] = request.split(" ");
       requestResponses = [];
-      
+
       for (let i = 0; i < 3; i++) {
         const response = await mock.handle(method as any, path);
         requestResponses.push(response);
       }
     });
 
-    Then("each response should have incrementing {string} values", (_, property: string) => {
-      expect(requestResponses).toHaveLength(3);
-      
-      for (let i = 0; i < requestResponses.length; i++) {
-        expect(requestResponses[i].body[property]).toBe(i + 1);
-      }
-    });
+    Then(
+      "each response should have incrementing {string} values",
+      (_, property: string) => {
+        expect(requestResponses).toHaveLength(3);
 
-    And("each response should have a {string} timestamp", (_, property: string) => {
-      for (const response of requestResponses) {
-        expect(response.body[property]).toBeDefined();
-        expect(typeof response.body[property]).toBe('string');
-        expect(new Date(response.body[property]).getTime()).toBeGreaterThan(0);
-      }
-    });
+        for (let i = 0; i < requestResponses.length; i++) {
+          expect(requestResponses[i].body[property]).toBe(i + 1);
+        }
+      },
+    );
+
+    And(
+      "each response should have a {string} timestamp",
+      (_, property: string) => {
+        for (const response of requestResponses) {
+          expect(response.body[property]).toBeDefined();
+          expect(typeof response.body[property]).toBe("string");
+          expect(new Date(response.body[property]).getTime()).toBeGreaterThan(0);
+        }
+      },
+    );
 
     And("the route state should persist across requests", () => {
-      // Actually testing that state persists across requests for shared plugin state
-      // The name is misleading but the test expects [1, 2, 3] which shows shared state
-      const requestNumbers = requestResponses.map(r => r.body.request_number);
+      const requestNumbers = requestResponses.map(
+        (r) => r.body.request_number,
+      );
       expect(requestNumbers).toEqual([1, 2, 3]);
     });
   });
 
   Scenario("Multiple plugins in pipeline", ({ Given, When, Then }) => {
-    Given("I create a mock with multiple plugins:", (_, docString: string) => {
-      // Create mock with multiple plugins in pipeline
+    Given("I create a mock with auth and wrapper plugins", () => {
       mock = schmock({});
-      mock('GET /users', () => [{ id: 1, name: 'John' }], {})
+      mock("GET /users", () => [{ id: 1, name: "John" }], {
+        contentType: "application/json",
+      })
         .pipe({
           name: "auth-plugin",
           process: (ctx, response) => {
             if (!ctx.headers.authorization) {
               throw new Error("Missing authorization");
             }
-            ctx.state.set('user', { id: 1, name: 'Admin' });
+            ctx.state.set("user", { id: 1, name: "Admin" });
             return { context: ctx, response };
-          }
+          },
         })
         .pipe({
-          name: "wrapper-plugin", 
+          name: "wrapper-plugin",
           process: (ctx, response) => {
             if (response) {
               return {
@@ -102,22 +102,27 @@ describeFeature(feature, ({ Scenario }) => {
                 response: {
                   data: response,
                   meta: {
-                    user: ctx.state.get('user'),
-                    timestamp: "2025-01-31T10:15:30.123Z" // Fixed timestamp for test consistency
-                  }
-                }
+                    user: ctx.state.get("user"),
+                    timestamp: "2025-01-31T10:15:30.123Z",
+                  },
+                },
               };
             }
             return { context: ctx, response };
-          }
+          },
         });
     });
 
-    When("I request {string} with headers:", async (_, request: string, docString: string) => {
-      const [method, path] = request.split(" ");
-      const headers = JSON.parse(docString);
-      requestResponses = [await mock.handle(method as any, path, { headers })];
-    });
+    When(
+      "I request {string} with headers:",
+      async (_, request: string, docString: string) => {
+        const [method, path] = request.split(" ");
+        const headers = JSON.parse(docString);
+        requestResponses = [
+          await mock.handle(method as any, path, { headers }),
+        ];
+      },
+    );
 
     Then("I should receive:", (_, docString: string) => {
       const expected = JSON.parse(docString);
@@ -126,29 +131,31 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Plugin error handling", ({ Given, When, Then, And }) => {
-    Given("I create a mock with error handling plugin:", (_, docString: string) => {
-      // Create mock with error handling plugin
+    Given("I create a mock with an auth guard plugin", () => {
       mock = schmock({});
-      mock('GET /protected', () => ({ secret: 'data' }), {})
-        .pipe({
-          name: "auth-plugin",
-          process: (ctx, response) => {
-            if (!ctx.headers.authorization) {
-              // Return error response directly instead of throwing
-              return {
-                context: ctx,
-                response: [401, { error: "Unauthorized", code: "AUTH_REQUIRED" }]
-              };
-            }
-            return { context: ctx, response };
+      mock("GET /protected", () => ({ secret: "data" }), {
+        contentType: "application/json",
+      }).pipe({
+        name: "auth-plugin",
+        process: (ctx, response) => {
+          if (!ctx.headers.authorization) {
+            return {
+              context: ctx,
+              response: [401, { error: "Unauthorized", code: "AUTH_REQUIRED" }],
+            };
           }
-        });
+          return { context: ctx, response };
+        },
+      });
     });
 
-    When("I request {string} without authorization", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      requestResponses = [await mock.handle(method as any, path)];
-    });
+    When(
+      "I request {string} without authorization",
+      async (_, request: string) => {
+        const [method, path] = request.split(" ");
+        requestResponses = [await mock.handle(method as any, path)];
+      },
+    );
 
     Then("the status should be {int}", (_, status: number) => {
       expect(requestResponses[0].status).toBe(status);
@@ -160,101 +167,91 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Pipeline order and response transformation", ({ Given, When, Then }) => {
-    Given("I create a mock with ordered plugins:", (_, docString: string) => {
-      // Create mock with ordered plugins that transform response
-      mock = schmock({});
-      mock('GET /data', () => ({ value: 42 }), {})
-        .pipe({
-          name: "step-1",
-          process: (ctx, response) => {
-            ctx.state.set('step1', 'processed');
-            // Transform the response by adding step1 property
-            if (response) {
-              return {
-                context: ctx,
-                response: { ...response, step1: 'processed' }
-              };
-            }
-            return { context: ctx, response };
-          }
-        })
-        .pipe({
-          name: "step-2", 
-          process: (ctx, response) => {
-            if (response) {
-              return {
-                context: ctx,
-                response: { ...response, step2: 'processed' }
-              };
-            }
-            return { context: ctx, response };
-          }
+  Scenario(
+    "Pipeline order and response transformation",
+    ({ Given, When, Then }) => {
+      Given("I create a mock with three ordered step plugins", () => {
+        mock = schmock({});
+        mock("GET /data", () => ({ value: 42 }), {
+          contentType: "application/json",
         })
-        .pipe({
-          name: "step-3",
-          process: (ctx, response) => {
-            if (response) {
-              return {
-                context: ctx,
-                response: { ...response, step3: 'processed' }
-              };
-            }
-            return { context: ctx, response };
-          }
-        });
-    });
+          .pipe({
+            name: "step-1",
+            process: (ctx, response) => {
+              ctx.state.set("step1", "processed");
+              if (response) {
+                return {
+                  context: ctx,
+                  response: { ...response, step1: "processed" },
+                };
+              }
+              return { context: ctx, response };
+            },
+          })
+          .pipe({
+            name: "step-2",
+            process: (ctx, response) => {
+              if (response) {
+                return {
+                  context: ctx,
+                  response: { ...response, step2: "processed" },
+                };
+              }
+              return { context: ctx, response };
+            },
+          })
+          .pipe({
+            name: "step-3",
+            process: (ctx, response) => {
+              if (response) {
+                return {
+                  context: ctx,
+                  response: { ...response, step3: "processed" },
+                };
+              }
+              return { context: ctx, response };
+            },
+          });
+      });
 
-    When("I request {string}", async (_, request: string) => {
-      const [method, path] = request.split(" ");
-      requestResponses = [await mock.handle(method as any, path)];
-    });
+      When("I request {string}", async (_, request: string) => {
+        const [method, path] = request.split(" ");
+        requestResponses = [await mock.handle(method as any, path)];
+      });
 
-    Then("I should receive:", (_, docString: string) => {
-      const expected = JSON.parse(docString);
-      expect(requestResponses[0].body).toEqual(expected);
-    });
-  });
+      Then("I should receive:", (_, docString: string) => {
+        const expected = JSON.parse(docString);
+        expect(requestResponses[0].body).toEqual(expected);
+      });
+    },
+  );
 
   Scenario("Schema plugin in pipeline", ({ Given, When, Then, And }) => {
-    Given("I create a mock with schema plugin:", (_, docString: string) => {
-      // Create mock with schema plugin that generates data
+    Given("I create a mock with a metadata wrapper plugin", () => {
       mock = schmock({});
-      mock('GET /users', (ctx) => {
-        // Schema-based generator function
-        const schema = {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              id: { type: 'integer' },
-              name: { type: 'string', faker: 'person.fullName' },
-              email: { type: 'string', format: 'email' }
-            }
-          }
-        };
-        // Generate mock data from schema (simplified)
-        return [
+      mock(
+        "GET /users",
+        () => [
           { id: 1, name: "John Doe", email: "john@example.com" },
-          { id: 2, name: "Jane Smith", email: "jane@example.com" }
-        ];
-      }, {})
-        .pipe({
-          name: "add-metadata",
-          process: (ctx, response) => {
-            if (response && Array.isArray(response)) {
-              return {
-                context: ctx,
-                response: {
-                  users: response,
-                  count: response.length,
-                  generated_at: new Date().toISOString()
-                }
-              };
-            }
-            return { context: ctx, response };
+          { id: 2, name: "Jane Smith", email: "jane@example.com" },
+        ],
+        { contentType: "application/json" },
+      ).pipe({
+        name: "add-metadata",
+        process: (ctx, response) => {
+          if (response && Array.isArray(response)) {
+            return {
+              context: ctx,
+              response: {
+                users: response,
+                count: response.length,
+                generated_at: new Date().toISOString(),
+              },
+            };
           }
-        });
+          return { context: ctx, response };
+        },
+      });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -271,9 +268,12 @@ describeFeature(feature, ({ Scenario }) => {
       expect(requestResponses[0].body).toHaveProperty(property);
     });
 
-    And("the response should have a {string} timestamp", (_, property: string) => {
-      expect(requestResponses[0].body).toHaveProperty(property);
-      expect(typeof requestResponses[0].body[property]).toBe('string');
-    });
+    And(
+      "the response should have a {string} timestamp",
+      (_, property: string) => {
+        expect(requestResponses[0].body).toHaveProperty(property);
+        expect(typeof requestResponses[0].body[property]).toBe("string");
+      },
+    );
   });
-});
+});