@schmock/core 1.9.2 → 1.9.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/core",
   "description": "Core functionality for Schmock",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/steps/async-support.steps.ts

@@ -365,9 +365,8 @@ describeFeature(feature, ({ Scenario }) => {
       responses = await Promise.all(promises);
     });
 
-    Then("all responses should have different processedAt timestamps", () => {
+    Then("all responses should have valid processedAt timestamps", () => {
       const timestamps = responses.map(r => r.body.processedAt);
-      // In fast test environments, timestamps might be the same, so just check they exist
       expect(timestamps).toHaveLength(3);
       timestamps.forEach((timestamp: number) => expect(timestamp).toBeGreaterThan(0));
     });
@@ -378,8 +377,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(responses[2].body.id).toBe("3");
     });
 
-    And("the responses should complete in expected order", () => {
-      // All responses should be successful regardless of timing
+    And("all responses should complete with status 200", () => {
       for (const response of responses) {
         expect(response.status).toBe(200);
         expect(response.body).toHaveProperty("id");

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

@@ -180,8 +180,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the mock should handle the load gracefully", () => {
-      // If we got here without throwing, the mock handled the load
+    And("each response should confirm large payload processing", () => {
       expect(responses.every(r => r.body.size === 'large')).toBe(true);
     });
 
@@ -202,8 +201,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the memory usage should remain stable", () => {
-      // Memory stability is tested by not crashing during multiple large requests
+    And("all accumulation requests should complete successfully", () => {
       expect(responses).toHaveLength(5);
     });
   });
@@ -262,13 +260,12 @@ describeFeature(feature, ({ Scenario }) => {
       expect(successCount + errorCount).toBe(responses.length);
     });
 
-    And("the success rate should be approximately {int}%", (_, expectedRate: number) => {
+    And("the success rate should be between {int}% and {int}%", (_, low: number, high: 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);
+      expect(actualRate).toBeGreaterThanOrEqual(low);
+      expect(actualRate).toBeLessThanOrEqual(high);
     });
 
     And("error responses should have appropriate status codes", () => {
@@ -298,7 +295,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    Then("each error should have a specific, helpful error message", () => {
+    Then("each error response should have a non-empty error message", () => {
       for (const response of responses) {
         expect(response.status).toBeGreaterThanOrEqual(400);
         expect(response.body.error).toBeDefined();
@@ -307,7 +304,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("the error codes should correctly identify the validation issue", () => {
+    And("each error response should have the correct status code", () => {
       expect(responses[0].status).toBe(400); // No content-type
       expect(responses[1].status).toBe(400); // No body
       expect(responses[2].status).toBe(400); // Invalid body type

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

@@ -259,13 +259,14 @@ describeFeature(feature, ({ Scenario }) => {
       requestResponses = [await mock.handle(method as any, path)];
     });
 
-    Then("the response should have a {string} array", (_, property: string) => {
+    Then("the response should have a {string} array with {int} items", (_, property: string, count: number) => {
       expect(requestResponses[0].body).toHaveProperty(property);
       expect(Array.isArray(requestResponses[0].body[property])).toBe(true);
+      expect(requestResponses[0].body[property]).toHaveLength(count);
     });
 
-    And("the response should have a {string} field", (_, property: string) => {
-      expect(requestResponses[0].body).toHaveProperty(property);
+    And("the response should have {string} equal to {int}", (_, property: string, value: number) => {
+      expect(requestResponses[0].body[property]).toBe(value);
     });
 
     And(

package/src/steps/response-delay.steps.ts

@@ -58,8 +58,8 @@ describeFeature(feature, ({ Scenario }) => {
       elapsed = performance.now() - start;
     });
 
-    Then("the response took at least 10ms", () => {
-      expect(elapsed).toBeGreaterThanOrEqual(8); // small tolerance
+    Then("the response took at least 8ms", () => {
+      expect(elapsed).toBeGreaterThanOrEqual(8);
     });
   });
 

package/src/steps/state-concurrency.steps.ts

@@ -533,18 +533,18 @@ describeFeature(feature, ({ Scenario }) => {
       responses = await Promise.all(promises);
     });
 
-    Then("the cache should maintain its size limit", () => {
+    Then("no response should report a cache size above 5", () => {
       responses.forEach(response => {
         expect((response.body as CacheResponseBody).cacheSize).toBeLessThanOrEqual(5);
       });
     });
 
-    And("old items should be evicted properly", () => {
+    And("the final cache size should be 5", () => {
       const finalCacheSize = Math.max(...responses.map(r => (r.body as CacheResponseBody).cacheSize));
       expect(finalCacheSize).toBe(5);
     });
 
-    And("cache size should remain consistent", () => {
+    And("each response should confirm the item was cached", () => {
       responses.forEach(response => {
         const body = response.body as CacheResponseBody;
         expect(body.cached).toBe(true);
@@ -617,7 +617,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(activityUpdates).toHaveLength(3);
     });
 
-    And("no cross-contamination should occur between user data", () => {
+    And("user 1 should have 4 updates and user 2 should have 2", () => {
       const user1Updates = responses.filter(r => (r.body as ProfileResponseBody).userId === "1");
       const user2Updates = responses.filter(r => (r.body as ProfileResponseBody).userId === "2");
 
@@ -625,13 +625,7 @@ describeFeature(feature, ({ Scenario }) => {
       expect(user2Updates).toHaveLength(2); // profile, activity
     });
 
-    And("nested state structure should remain intact", () => {
-      responses.forEach(response => {
-        const body = response.body as ProfileResponseBody;
-        expect(body.userId).toBeDefined();
-        expect(["1", "2"]).toContain(body.userId);
-      });
-
+    And("user 1 activity count should be 2", () => {
       const activityUpdates = responses.filter(r => (r.body as ProfileResponseBody).activityCount);
       const user1Activities = activityUpdates.filter(r => (r.body as ProfileResponseBody).userId === "1");
       expect(user1Activities.length).toBe(2);
@@ -733,7 +727,7 @@ describeFeature(feature, ({ Scenario }) => {
       }
     });
 
-    And("transaction history should be consistent", () => {
+    And("the transaction count should match the number of successful transactions", () => {
       const successfulTransactions = responses.filter(r => (r.body as TransactionResponseBody).success === true);
       if (successfulTransactions.length > 0) {
         const transactionCounts = successfulTransactions.map(r => (r.body as TransactionResponseBody).transactionCount);