@schmock/core 1.0.4 → 1.1.0

package/src/steps/http-methods.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 } from "../types";
 
 const feature = await loadFeature("../../features/http-methods.feature");
 
@@ -12,13 +12,13 @@ describeFeature(feature, ({ Scenario }) => {
   let error: Error | null = null;
 
   Scenario("GET method with query parameters", ({ Given, When, Then }) => {
-    Given("I create a mock with GET endpoint:", (_, docString: string) => {
+    Given("I create a mock with a GET search endpoint", () => {
       mock = schmock();
       mock('GET /search', ({ query }) => ({
         results: [],
         query: query.q,
         page: parseInt(query.page || '1'),
-        limit: parseInt(query.limit || '10')
+        limit: parseInt(query.limit || '10'),
       }));
     });
 
@@ -41,12 +41,12 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("POST method with JSON body", ({ Given, When, Then, And }) => {
-    Given("I create a mock with POST endpoint:", (_, docString: string) => {
+    Given("I create a mock with a POST users endpoint", () => {
       mock = schmock();
       mock('POST /users', ({ body }) => [201, {
         id: 123,
-        ...body,
-        createdAt: '2023-01-01T00:00:00Z'
+        ...(body as Record<string, unknown>),
+        createdAt: '2023-01-01T00:00:00Z',
       }]);
     });
 
@@ -66,12 +66,12 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("PUT method for resource updates", ({ Given, When, Then }) => {
-    Given("I create a mock with PUT endpoint:", (_, docString: string) => {
+    Given("I create a mock with a PUT users endpoint", () => {
       mock = schmock();
       mock('PUT /users/:id', ({ params, body }) => ({
         id: parseInt(params.id),
-        ...body,
-        updatedAt: '2023-01-01T00:00:00Z'
+        ...(body as Record<string, unknown>),
+        updatedAt: '2023-01-01T00:00:00Z',
       }));
     });
 
@@ -87,7 +87,7 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("DELETE method with confirmation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with DELETE endpoint:", (_, docString: string) => {
+    Given("I create a mock with a DELETE users endpoint", () => {
       mock = schmock();
       mock('DELETE /users/:id', ({ params }) => [204, null]);
     });
@@ -106,13 +106,13 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("PATCH method for partial updates", ({ Given, When, Then }) => {
-    Given("I create a mock with PATCH endpoint:", (_, docString: string) => {
+    Given("I create a mock with a PATCH users endpoint", () => {
       mock = schmock();
       mock('PATCH /users/:id', ({ params, body }) => ({
         id: parseInt(params.id),
         email: 'existing@example.com',
-        ...body,
-        updatedAt: '2023-01-01T00:00:00Z'
+        ...(body as Record<string, unknown>),
+        updatedAt: '2023-01-01T00:00:00Z',
       }));
     });
 
@@ -128,12 +128,12 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("HEAD method returns headers only", ({ Given, When, Then, And }) => {
-    Given("I create a mock with HEAD endpoint:", (_, docString: string) => {
+    Given("I create a mock with a HEAD users endpoint", () => {
       mock = schmock();
       mock('HEAD /users/:id', ({ params }) => [200, null, {
         'Content-Type': 'application/json',
         'Last-Modified': 'Wed, 01 Jan 2023 00:00:00 GMT',
-        'Content-Length': '156'
+        'Content-Length': '156',
       }]);
     });
 
@@ -157,12 +157,12 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("OPTIONS method for CORS preflight", ({ Given, When, Then, And }) => {
-    Given("I create a mock with OPTIONS endpoint:", (_, docString: string) => {
+    Given("I create a mock with an OPTIONS users endpoint", () => {
       mock = schmock();
       mock('OPTIONS /api/users', () => [200, null, {
         'Access-Control-Allow-Origin': '*',
         'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, PATCH, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
       }]);
     });
 
@@ -184,7 +184,7 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Multiple methods on same path", ({ Given, When, Then, And }) => {
-    Given("I create a mock with multiple methods on same path:", (_, docString: string) => {
+    Given("I create a mock with GET, POST, PUT, and DELETE on the same path", () => {
       mock = schmock();
       mock('GET /resource', { action: 'read' });
       mock('POST /resource', { action: 'create' });
@@ -222,7 +222,7 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Method-specific content types", ({ Given, When, Then, And }) => {
-    Given("I create a mock with method-specific content types:", (_, docString: string) => {
+    Given("I create a mock with JSON, XML, text, and upload endpoints", () => {
       mock = schmock();
       mock('GET /data.json', { data: 'json' });
       mock('GET /data.xml', '<data>xml</data>', { contentType: 'application/xml' });
@@ -258,14 +258,14 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Method case sensitivity", ({ Given, When, Then }) => {
     error = null;
 
-    Given("I create a mock with lowercase method:", (_, docString: string) => {
+    Given("I create an empty mock for case sensitivity testing", () => {
       mock = schmock();
     });
 
     When("I attempt to create a mock with lowercase method", () => {
       error = null;
       try {
-        mock('get /test', { method: 'get' });
+        mock('get /test' as Schmock.RouteKey, { method: 'get' });
       } catch (e) {
         error = e as Error;
       }
@@ -281,14 +281,14 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Unsupported HTTP methods", ({ Given, When, Then }) => {
     error = null;
 
-    Given("I create a mock with custom method:", (_, docString: string) => {
+    Given("I create an empty mock for unsupported method testing", () => {
       mock = schmock();
     });
 
     When("I attempt to create a mock with unsupported method", () => {
       error = null;
       try {
-        mock('CUSTOM /endpoint', { custom: true });
+        mock('CUSTOM /endpoint' as Schmock.RouteKey, { custom: true });
       } catch (e) {
         error = e as Error;
       }
@@ -302,11 +302,11 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Method with special characters in path", ({ Given, When, Then }) => {
-    Given("I create a mock with special characters:", (_, docString: string) => {
+    Given("I create a mock with nested parameterized path segments", () => {
       mock = schmock();
       mock('GET /api/v1/users/:id/posts/:post-id', ({ params }) => ({
         userId: params.id,
-        postId: params['post-id']
+        postId: params['post-id'],
       }));
     });
 
@@ -321,7 +321,7 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Method with request headers validation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with header validation:", (_, docString: string) => {
+    Given("I create a mock with authorization header checking", () => {
       mock = schmock();
       mock('POST /secure', ({ headers, body }) => {
         if (headers.authorization !== 'Bearer valid-token') {
@@ -361,18 +361,18 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Method chaining with plugins", ({ Given, When, Then, And }) => {
-    Given("I create a mock with method-specific plugins:", (_, docString: string) => {
+    Given("I create a mock with a logger plugin on GET and POST", () => {
       mock = schmock();
-      const loggerPlugin = {
+      const loggerPlugin: Plugin = {
         name: 'method-logger',
-        process: (ctx: any, response: any) => ({
+        process: (ctx, response) => ({
           context: ctx,
           response: {
             ...response,
             method: ctx.method,
-            logged: true
-          }
-        })
+            logged: true,
+          },
+        }),
       };
       mock('GET /logged', { data: 'get' }).pipe(loggerPlugin);
       mock('POST /logged', { data: 'post' }).pipe(loggerPlugin);
@@ -394,4 +394,4 @@ describeFeature(feature, ({ Scenario }) => {
       expect(responses[1].body).toEqual(expected);
     });
   });
-});
+});

package/src/steps/performance-reliability.steps.ts

@@ -1,39 +1,35 @@
 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/performance-reliability.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let mock: MockInstance<any>;
+  let mock: CallableMockInstance;
   let responses: any[] = [];
   let responsesTimes: number[] = [];
+  let expectedResponseCount = 0;
 
   Scenario("High-volume concurrent requests", ({ Given, When, Then, And }) => {
     responses = [];
     responsesTimes = [];
 
-    Given("I create a mock for load testing:", (_, docString: string) => {
-      // Create mock with new callable API for load testing
+    Given("I create a mock for high-volume load testing", () => {
       mock = schmock();
-      
-      mock('GET /api/health', () => ({ 
-        status: 'healthy', 
-        timestamp: Date.now() 
+      mock('GET /api/health', () => ({
+        status: 'healthy',
+        timestamp: Date.now()
       }));
-      
       mock('GET /api/data/:id', ({ params }) => ({
         id: params.id,
-        data: Array.from({ length: 50 }, (_, i) => ({ 
-          index: i, 
-          value: Math.random() 
+        data: Array.from({ length: 50 }, (_, i) => ({
+          index: i,
+          value: Math.random()
         })),
         generated_at: new Date().toISOString()
       }));
-      
       mock('POST /api/process', ({ body }) => {
-        // Simulate processing time
         const items = Array.isArray(body) ? body : [body];
         return {
           processed: items.length,
@@ -47,6 +43,7 @@ describeFeature(feature, ({ Scenario }) => {
       const [method, path] = request.split(" ");
       responses = [];
       responsesTimes = [];
+      expectedResponseCount = count;
 
       const promises = Array.from({ length: count }, async () => {
         const startTime = Date.now();
@@ -61,8 +58,7 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     Then("all concurrent requests should complete successfully", () => {
-      const expectedCount = responses.length;
-      expect(responses).toHaveLength(expectedCount);
+      expect(responses).toHaveLength(expectedResponseCount);
       for (const response of responses) {
         expect(response.status).toBe(200);
       }
@@ -80,7 +76,7 @@ describeFeature(feature, ({ Scenario }) => {
 
     When("I send {int} concurrent requests to different {string} endpoints", async (_, count: number, pathPattern: string) => {
       responses = [];
-      
+
       const promises = Array.from({ length: count }, async (_, i) => {
         const path = pathPattern.replace(":id", `id${i}`);
         return await mock.handle("GET", path);
@@ -104,6 +100,7 @@ describeFeature(feature, ({ Scenario }) => {
     When("I send {int} concurrent {string} requests with different payloads", async (_, count: number, request: string) => {
       const [method, path] = request.split(" ");
       responses = [];
+      expectedResponseCount = count;
 
       const promises = Array.from({ length: count }, async (_, i) => {
         return await mock.handle(method as any, path, {
@@ -115,8 +112,7 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("all concurrent requests should complete successfully", () => {
-      const expectedCount = responses.length;
-      expect(responses).toHaveLength(expectedCount);
+      expect(responses).toHaveLength(expectedResponseCount);
       for (const response of responses) {
         expect(response.status).toBe(200);
       }
@@ -130,19 +126,15 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Memory usage under sustained load", ({ Given, When, Then, And }) => {
-    Given("I create a mock with potential memory concerns:", (_, docString: string) => {
-      // Create mock with routes that handle large data
+    Given("I create a mock with large payload handling", () => {
       mock = schmock();
-      
       mock('POST /api/large-data', ({ body }) => {
-        // Create large response data
         const largeArray = Array.from({ length: 1000 }, (_, i) => ({
           id: i,
-          data: 'x'.repeat(100), // 100 chars per item
+          data: 'x'.repeat(100),
           timestamp: Date.now(),
           payload: body
         }));
-        
         return {
           results: largeArray,
           items: largeArray,
@@ -151,7 +143,6 @@ describeFeature(feature, ({ Scenario }) => {
           memory_usage: process.memoryUsage ? process.memoryUsage() : null
         };
       });
-      
       mock('GET /api/accumulate/:count', ({ params }) => {
         const count = parseInt(params.count);
         const items = Array.from({ length: count }, (_, i) => ({
@@ -159,7 +150,6 @@ describeFeature(feature, ({ Scenario }) => {
           value: Math.random(),
           timestamp: Date.now()
         }));
-        
         return {
           items: items,
           accumulated: items,
@@ -173,7 +163,7 @@ describeFeature(feature, ({ Scenario }) => {
     When("I send {int} requests to {string} with {int}KB payloads", async (_, count: number, request: string, payloadSize: number) => {
       const [method, path] = request.split(" ");
       responses = [];
-      
+
       const largePayload = { data: 'x'.repeat(payloadSize * 1024) };
 
       for (let i = 0; i < count; i++) {
@@ -198,7 +188,7 @@ describeFeature(feature, ({ Scenario }) => {
     When("I request {string} multiple times", async (_, request: string) => {
       const [method, path] = request.split(" ");
       responses = [];
-      
+
       for (let i = 0; i < 5; i++) {
         const response = await mock.handle(method as any, path);
         responses.push(response);
@@ -221,47 +211,34 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Error resilience and recovery", ({ Given, When, Then, And }) => {
     responses = [];
 
-    Given("I create a mock with intermittent failures:", (_, docString: string) => {
-      // Create mock with intermittent failure simulation
+    Given("I create a mock with intermittent failure simulation", () => {
       mock = schmock();
-      
       let requestCount = 0;
-      
       mock('POST /api/unreliable', ({ body }) => {
         requestCount++;
-        
-        // Simulate 20% failure rate
         if (requestCount % 5 === 0) {
           return [500, { error: 'Simulated server error', request_id: requestCount }];
         }
-        
         return [200, { success: true, data: body, request_id: requestCount }];
       });
-      
       mock('GET /api/flaky', () => {
         requestCount++;
-        
-        // Simulate 20% failure rate (1 in 5 requests fail)
         if (requestCount % 5 === 0) {
           return [500, { error: 'Flaky service error', request_id: requestCount }];
         }
-        
         return [200, { success: true, request_id: requestCount }];
       });
-      
       mock('POST /api/validate-strict', ({ body }) => {
         if (!body || typeof body !== 'object') {
           return [400, { error: 'Request body is required and must be an object', code: 'INVALID_BODY' }];
         }
-        
-        if (!body.name || typeof body.name !== 'string') {
+        const record = body as Record<string, unknown>;
+        if (!record.name || typeof record.name !== 'string') {
           return [422, { error: 'Name field is required and must be a string', code: 'INVALID_NAME' }];
         }
-        
-        if (!body.email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(body.email)) {
+        if (!record.email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(record.email as string)) {
           return [422, { error: 'Valid email address is required', code: 'INVALID_EMAIL' }];
         }
-        
         return [200, { message: 'Validation successful', data: body }];
       });
     });
@@ -279,7 +256,7 @@ describeFeature(feature, ({ Scenario }) => {
     Then("some requests should succeed and some should fail", () => {
       const successCount = responses.filter(r => r.status === 200).length;
       const errorCount = responses.filter(r => r.status >= 400).length;
-      
+
       expect(successCount).toBeGreaterThan(0);
       expect(errorCount).toBeGreaterThan(0);
       expect(successCount + errorCount).toBe(responses.length);
@@ -288,7 +265,7 @@ describeFeature(feature, ({ Scenario }) => {
     And("the success rate should be approximately {int}%", (_, expectedRate: number) => {
       const successCount = responses.filter(r => r.status === 200).length;
       const actualRate = (successCount / responses.length) * 100;
-      
+
       // Allow for some variance due to randomness
       expect(actualRate).toBeGreaterThan(expectedRate - 10);
       expect(actualRate).toBeLessThan(expectedRate + 10);
@@ -297,18 +274,18 @@ describeFeature(feature, ({ Scenario }) => {
     And("error responses should have appropriate status codes", () => {
       const errorResponses = responses.filter(r => r.status >= 400);
       const validErrorCodes = [429, 500, 503];
-      
+
       for (const response of errorResponses) {
         expect(validErrorCodes).toContain(response.status);
       }
     });
 
     When("I send requests to {string} with various invalid inputs", async (_, request: string) => {
-      const [method, path] = request.split(" ");  
+      const [method, path] = request.split(" ");
       responses = [];
 
       // Test various invalid scenarios
-      const testCases = [
+      const testCases: Schmock.RequestOptions[] = [
         { headers: {}, body: null }, // No content-type, no body
         { headers: { 'content-type': 'application/json' }, body: null }, // No body
         { headers: { 'content-type': 'application/json' }, body: "invalid" }, // Invalid body type
@@ -332,7 +309,7 @@ describeFeature(feature, ({ Scenario }) => {
 
     And("the error codes should correctly identify the validation issue", () => {
       expect(responses[0].status).toBe(400); // No content-type
-      expect(responses[1].status).toBe(400); // No body  
+      expect(responses[1].status).toBe(400); // No body
       expect(responses[2].status).toBe(400); // Invalid body type
       expect(responses[3].status).toBe(422); // Missing required field
     });
@@ -341,47 +318,44 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Route matching performance with complex patterns", ({ Given, When, Then, And }) => {
     responses = [];
 
-    Given("I create a mock with many route patterns:", (_, docString: string) => {
-      // Create mock with many different route patterns for performance testing
+    Given("I create a mock with many nested route patterns", () => {
       mock = schmock();
-      
-      // Routes that match the test expectations
       mock('GET /api/users', () => ({ type: 'users-list' }));
       mock('GET /api/users/:id', ({ params }) => ({ type: 'user', id: params.id }));
       mock('GET /api/users/:userId/posts', ({ params }) => ({ type: 'user-posts', userId: params.userId }));
-      mock('GET /api/users/:userId/posts/:postId', ({ params }) => ({ 
-        type: 'user-post', 
-        userId: params.userId, 
-        postId: params.postId 
+      mock('GET /api/users/:userId/posts/:postId', ({ params }) => ({
+        type: 'user-post',
+        userId: params.userId,
+        postId: params.postId
       }));
-      mock('GET /api/users/:userId/posts/:postId/comments', ({ params }) => ({ 
-        type: 'post-comments', 
-        userId: params.userId, 
-        postId: params.postId 
+      mock('GET /api/users/:userId/posts/:postId/comments', ({ params }) => ({
+        type: 'post-comments',
+        userId: params.userId,
+        postId: params.postId
       }));
       mock('GET /api/posts', () => ({ type: 'posts-list' }));
       mock('GET /api/posts/:postId', ({ params }) => ({ type: 'post', postId: params.postId }));
-      mock('GET /api/posts/:postId/comments/:commentId', ({ params }) => ({ 
-        type: 'comment', 
-        postId: params.postId, 
-        commentId: params.commentId 
+      mock('GET /api/posts/:postId/comments/:commentId', ({ params }) => ({
+        type: 'comment',
+        postId: params.postId,
+        commentId: params.commentId
       }));
-      mock('GET /static/:category/:file', ({ params }) => ({ 
-        type: 'static', 
-        category: params.category, 
-        file: params.file 
+      mock('GET /static/:category/:file', ({ params }) => ({
+        type: 'static',
+        category: params.category,
+        file: params.file
       }));
-      mock('GET /api/v2/users/:userId', ({ params }) => ({ 
-        type: 'versioned-user', 
-        userId: params.userId, 
-        version: 'v2' 
+      mock('GET /api/v2/users/:userId', ({ params }) => ({
+        type: 'versioned-user',
+        userId: params.userId,
+        version: 'v2'
       }));
     });
 
     When("I send requests to all route patterns simultaneously", async () => {
       const testPaths = [
         "GET /api/users",
-        "GET /api/users/123", 
+        "GET /api/users/123",
         "GET /api/users/123/posts",
         "GET /api/users/123/posts/456",
         "GET /api/users/123/posts/456/comments",
@@ -423,11 +397,6 @@ describeFeature(feature, ({ Scenario }) => {
       expect(responses[9].body.version).toBe("v2");
     });
 
-    And("the route matching should be efficient even with many patterns", () => {
-      // All requests completed quickly if we got here
-      expect(responses).toHaveLength(10);
-    });
-
     When("I send requests to non-matching paths", async () => {
       const invalidPaths = [
         "GET /api/invalid",
@@ -449,11 +418,6 @@ describeFeature(feature, ({ Scenario }) => {
         expect(response.status).toBe(expectedStatus);
       }
     });
-
-    And("the {int} responses should be fast", (_, statusCode: number) => {
-      // If we got here quickly, the 404 responses were fast
-      expect(responses.every(r => r.status === statusCode)).toBe(true);
-    });
   });
 
-});
+});