@schmock/core 1.0.4 → 1.2.1

package/src/steps/stateful-workflows.steps.ts

@@ -1,12 +1,31 @@
 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";
+
+interface CartItem {
+  id: number;
+  name: string;
+  price: number;
+  quantity: number;
+}
+
+interface UserRecord {
+  username: string;
+  password: string;
+  profile: { name: string; role: string };
+}
+
+interface SessionRecord {
+  user: string;
+  profile: { name: string; role: string };
+  loginTime: string;
+}
 
 const feature = await loadFeature("../../features/stateful-workflows.feature");
 
 describeFeature(feature, ({ Scenario }) => {
-  let mock: MockInstance<any>;
+  let mock: CallableMockInstance;
   let response: any;
   let sessionToken: string;
   let addedItemIds: number[] = [];
@@ -14,73 +33,65 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("Shopping cart workflow", ({ Given, When, Then, And }) => {
     addedItemIds = [];
 
-    Given("I create a stateful shopping cart mock:", (_, docString: string) => {
-      // Create stateful shopping cart mock with new callable API
-      const sharedState = { items: [], total: 0 };
-      mock = schmock({ state: sharedState });
-      
-      mock('GET /cart', ({ state }) => ({
-        items: state.items,
-        total: state.total,
-        count: state.items.length
+    Given("I create a stateful shopping cart mock", () => {
+      const items: CartItem[] = [];
+      let total = 0;
+
+      mock = schmock();
+      mock("GET /cart", () => ({
+        items,
+        total,
+        count: items.length,
       }));
-      
-      mock('POST /cart/add', ({ state, body }) => {
-        const item = { 
-          id: Date.now(), 
-          name: body.name, 
-          price: body.price, 
-          quantity: body.quantity || 1 
+      mock("POST /cart/add", ({ body }) => {
+        const b = body as Record<string, unknown>;
+        const item: CartItem = {
+          id: Date.now(),
+          name: b.name as string,
+          price: b.price as number,
+          quantity: (b.quantity as number) || 1,
         };
-        
-        state.items.push(item);
-        state.total += item.price * item.quantity;
-        
+        items.push(item);
+        total += item.price * item.quantity;
         return {
-          message: 'Item added to cart',
+          message: "Item added to cart",
           added: item,
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
-      
-      mock('DELETE /cart/:id', ({ state, params }) => {
+      mock("DELETE /cart/:id", ({ params }) => {
         const itemId = parseInt(params.id);
-        const itemIndex = state.items.findIndex(item => item.id === itemId);
-        
+        const itemIndex = items.findIndex((item) => item.id === itemId);
         if (itemIndex === -1) {
-          return [404, { error: 'Item not found in cart' }];
+          return [404, { error: "Item not found in cart" }];
         }
-        
-        const removedItem = state.items[itemIndex];
-        state.total -= removedItem.price * removedItem.quantity;
-        state.items.splice(itemIndex, 1);
-        
+        const removedItem = items[itemIndex];
+        total -= removedItem.price * removedItem.quantity;
+        items.splice(itemIndex, 1);
         return {
-          message: 'Item removed from cart',
+          message: "Item removed from cart",
           item: removedItem,
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
-      
-      mock('POST /cart/clear', ({ state }) => {
-        state.items = [];
-        state.total = 0;
-        
+      mock("POST /cart/clear", () => {
+        items.length = 0;
+        total = 0;
         return {
-          message: 'Cart cleared',
+          message: "Cart cleared",
           cart: {
-            items: state.items,
-            total: state.total,
-            count: state.items.length
-          }
+            items,
+            total,
+            count: items.length,
+          },
         };
       });
     });
@@ -114,29 +125,34 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("the cart should contain {int} items", async (_, expectedCount: number) => {
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.count).toBe(expectedCount);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     Then("the cart should contain {int} item", async (_, expectedCount: number) => {
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.count).toBe(expectedCount);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("the initial cart total should be {string}", async (_, expectedTotalStr: string) => {
       const expectedTotal = parseFloat(expectedTotalStr);
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.total).toBe(expectedTotal);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.total).toBe(expectedTotal);
     });
 
     And("the final cart total should be {string}", async (_, expectedTotalStr: string) => {
       const expectedTotal = parseFloat(expectedTotalStr);
       const cartResponse = await mock.handle("GET", "/cart");
-      expect(cartResponse.body.total).toBe(expectedTotal);
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      expect(body.total).toBe(expectedTotal);
     });
 
     When("I remove the first item from the cart", async () => {
       const cartResponse = await mock.handle("GET", "/cart");
-      const firstItemId = cartResponse.body.items[0].id;
+      const body = cartResponse.body as { items: CartItem[]; total: number; count: number };
+      const firstItemId = body.items[0].id;
       response = await mock.handle("DELETE", `/cart/${firstItemId}`);
     });
   });
@@ -144,66 +160,54 @@ describeFeature(feature, ({ Scenario }) => {
   Scenario("User session simulation", ({ Given, When, Then, And }) => {
     sessionToken = "";
 
-    Given("I create a session-based mock:", (_, docString: string) => {
-      // Create session-based mock with new callable API
-      const sharedState = { 
-        users: [
-          { username: 'admin', password: 'secret', profile: { name: 'Admin User', role: 'administrator' } },
-          { username: 'user1', password: 'pass123', profile: { name: 'Regular User', role: 'user' } }
-        ],
-        sessions: {} 
-      };
-      
-      mock = schmock({ state: sharedState });
-      
-      mock('POST /auth/login', ({ state, body }) => {
-        const user = state.users.find(u => u.username === body.username && u.password === body.password);
-        
+    Given("I create a session-based authentication mock", () => {
+      const users: UserRecord[] = [
+        { username: "admin", password: "secret", profile: { name: "Admin User", role: "administrator" } },
+        { username: "user1", password: "pass123", profile: { name: "Regular User", role: "user" } },
+      ];
+      const sessions: Record<string, SessionRecord> = {};
+
+      mock = schmock();
+      mock("POST /auth/login", ({ body }) => {
+        const b = body as Record<string, unknown>;
+        const user = users.find((u) => u.username === b.username && u.password === b.password);
         if (!user) {
-          return [401, { error: 'Invalid credentials' }];
+          return [401, { error: "Invalid credentials" }];
         }
-        
-        const token = `token-${user.username}-${Date.now()}`;
-        state.sessions[token] = {
+        const token = "token-" + user.username + "-" + Date.now();
+        sessions[token] = {
           user: user.username,
           profile: user.profile,
-          loginTime: new Date().toISOString()
+          loginTime: new Date().toISOString(),
         };
-        
         return {
-          message: 'Login successful',
-          token: token,
-          user: user.profile
+          message: "Login successful",
+          token,
+          user: user.profile,
         };
       });
-      
-      mock('GET /profile', ({ state, headers }) => {
-        const token = headers.authorization?.replace('Bearer ', '');
-        
-        if (!token || !state.sessions[token]) {
-          return [401, { error: 'Unauthorized' }];
+      mock("GET /profile", ({ headers }) => {
+        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
+        if (!token || !sessions[token]) {
+          return [401, { error: "Unauthorized" }];
         }
-        
-        const session = state.sessions[token];
+        const session = sessions[token];
         return {
           user: session.user,
           profile: session.profile,
           loginTime: session.loginTime,
           session: {
-            active: true
-          }
+            active: true,
+          },
         };
       });
-      
-      mock('POST /auth/logout', ({ state, headers }) => {
-        const token = headers.authorization?.replace('Bearer ', '');
-        
-        if (!token || !state.sessions[token]) {
-          return [401, { error: 'Unauthorized' }];
+      mock("POST /auth/logout", ({ headers }) => {
+        const token = headers.authorization ? headers.authorization.replace("Bearer ", "") : "";
+        if (!token || !sessions[token]) {
+          return [401, { error: "Unauthorized" }];
         }
-        
-        delete state.sessions[token];
-        return { message: 'Logged out successfully' };
+        delete sessions[token];
+        return { message: "Logged out successfully" };
       });
     });
 
@@ -264,45 +268,37 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Multi-user state isolation", ({ Given, When, Then, And }) => {
-    Given("I create a multi-user counter mock:", (_, docString: string) => {
-      // Create multi-user counter mock with new callable API
-      const sharedState = { counters: {} };
-      mock = schmock({ state: sharedState });
-      
-      mock('POST /counter/:userId/increment', ({ state, params }) => {
+    Given("I create a multi-user counter mock", () => {
+      const counters: Record<string, number> = {};
+
+      mock = schmock();
+      mock("POST /counter/:userId/increment", ({ params }) => {
         const userId = params.userId;
-        
-        if (!state.counters[userId]) {
-          state.counters[userId] = 0;
+        if (!counters[userId]) {
+          counters[userId] = 0;
         }
-        
-        state.counters[userId]++;
-        
+        counters[userId]++;
         return {
-          userId: userId,
-          count: state.counters[userId],
-          message: `Counter incremented for user ${userId}`
+          userId,
+          count: counters[userId],
+          message: "Counter incremented for user " + userId,
         };
       });
-      
-      mock('GET /counter/:userId', ({ state, params }) => {
+      mock("GET /counter/:userId", ({ params }) => {
         const userId = params.userId;
-        const count = state.counters[userId] || 0;
-        
+        const count = counters[userId] || 0;
         return {
-          userId: userId,
-          count: count
+          userId,
+          count,
         };
       });
-      
-      mock('GET /counters/summary', ({ state }) => {
-        const totalCount = Object.values(state.counters).reduce((sum: number, count: number) => sum + count, 0);
-        const userCount = Object.keys(state.counters).length;
-        
+      mock("GET /counters/summary", () => {
+        const totalCount = Object.values(counters).reduce((sum, count) => sum + count, 0);
+        const userCount = Object.keys(counters).length;
         return {
           totalCounts: totalCount,
           totalUsers: userCount,
-          counters: state.counters
+          counters,
         };
       });
     });
@@ -321,31 +317,37 @@ describeFeature(feature, ({ Scenario }) => {
 
     Then("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
       const response = await mock.handle("GET", `/counter/${userId}`);
-      expect(response.body.count).toBe(expectedCount);
+      const body = response.body as { userId: string; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("{string}'s counter should be {int}", async (_, userId: string, expectedCount: number) => {
       const response = await mock.handle("GET", `/counter/${userId}`);
-      expect(response.body.count).toBe(expectedCount);
+      const body = response.body as { userId: string; count: number };
+      expect(body.count).toBe(expectedCount);
     });
 
     And("the summary should show {int} total users", async (_, expectedUsers: number) => {
       const response = await mock.handle("GET", "/counters/summary");
-      expect(response.body.totalUsers).toBe(expectedUsers);
+      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
+      expect(body.totalUsers).toBe(expectedUsers);
     });
 
     And("the summary should show total counts of {int}", async (_, expectedTotal: number) => {
       const response = await mock.handle("GET", "/counters/summary");
-      expect(response.body.totalCounts).toBe(expectedTotal);
+      const body = response.body as { totalCounts: number; totalUsers: number; counters: Record<string, number> };
+      expect(body.totalCounts).toBe(expectedTotal);
     });
 
     And("each user's state should be independent", async () => {
       const aliceResponse = await mock.handle("GET", "/counter/alice");
       const bobResponse = await mock.handle("GET", "/counter/bob");
-      
-      expect(aliceResponse.body.count).toBe(3);
-      expect(bobResponse.body.count).toBe(2);
-      expect(aliceResponse.body.count).not.toBe(bobResponse.body.count);
+      const aliceBody = aliceResponse.body as { userId: string; count: number };
+      const bobBody = bobResponse.body as { userId: string; count: number };
+
+      expect(aliceBody.count).toBe(3);
+      expect(bobBody.count).toBe(2);
+      expect(aliceBody.count).not.toBe(bobBody.count);
     });
   });
-});
+});