@schmock/core 1.0.3 → 1.1.0

package/src/steps/async-support.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/async-support.feature");
 
@@ -13,11 +13,12 @@ describeFeature(feature, ({ Scenario }) => {
   let endTime: number;
 
   Scenario("Async generator function returns Promise", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async generator:", (_, docString: string) => {
+    Given("I create a mock with an async generator at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /async-data', async () => {
+      mock(`${method} ${path}` as any, async () => {
         await new Promise(resolve => setTimeout(resolve, 10));
-        return { message: 'async response' };
+        return { message: "async response" };
       });
     });
 
@@ -37,13 +38,14 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async generator with context access", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async context generator:", (_, docString: string) => {
+    Given("I create a mock with an async param-based generator at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /async-user/:id', async ({ params }) => {
+      mock(`${method} ${path}` as any, async ({ params }: any) => {
         await new Promise(resolve => setTimeout(resolve, 5));
-        return { 
-          userId: params.id, 
-          fetchedAt: new Date().toISOString()
+        return {
+          userId: params.id,
+          fetchedAt: new Date().toISOString(),
         };
       });
     });
@@ -63,22 +65,22 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Multiple async generators in different routes", ({ Given, When, Then, And }) => {
-    Given("I create a mock with multiple async routes:", (_, docString: string) => {
+    Given("I create a mock with async routes for posts and comments", () => {
       mock = schmock();
-      mock('GET /async-posts', async () => {
+      mock("GET /async-posts", async () => {
         await new Promise(resolve => setTimeout(resolve, 5));
-        return [{ id: 1, title: 'First Post' }];
+        return [{ id: 1, title: "First Post" }];
       });
-      mock('GET /async-comments', async () => {
+      mock("GET /async-comments", async () => {
         await new Promise(resolve => setTimeout(resolve, 8));
-        return [{ id: 1, comment: 'Great post!' }];
+        return [{ id: 1, comment: "Great post!" }];
       });
     });
 
     When("I make concurrent requests to {string} and {string}", async (_, path1: string, path2: string) => {
       const [posts, comments] = await Promise.all([
-        mock.handle('GET', path1),
-        mock.handle('GET', path2)
+        mock.handle("GET", path1),
+        mock.handle("GET", path2),
       ]);
       responses = [posts, comments];
     });
@@ -98,23 +100,24 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async plugin processing", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async plugin:", (_, docString: string) => {
+    Given("I create a mock with an async processing plugin at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      const asyncPlugin = {
-        name: 'async-processor',
-        process: async (ctx: any, response: any) => {
+      const asyncPlugin: Plugin = {
+        name: "async-processor",
+        process: async (ctx, response) => {
           await new Promise(resolve => setTimeout(resolve, 5));
           return {
             context: ctx,
             response: {
               data: response,
               processedAsync: true,
-              timestamp: new Date().toISOString()
-            }
+              timestamp: new Date().toISOString(),
+            },
           };
-        }
+        },
       };
-      mock('GET /processed', { original: 'data' }).pipe(asyncPlugin);
+      mock(`${method} ${path}` as any, { original: "data" }).pipe(asyncPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -127,7 +130,7 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("the async response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === 'true' ? true : value === 'false' ? false : value;
+      const expectedValue = value === "true" ? true : value === "false" ? false : value;
       expect(response.body).toHaveProperty(property, expectedValue);
     });
 
@@ -137,26 +140,27 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Mixed sync and async plugin pipeline", ({ Given, When, Then, And }) => {
-    Given("I create a mock with mixed plugin pipeline:", (_, docString: string) => {
+    Given("I create a mock with sync and async plugins at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      const syncPlugin = {
-        name: 'sync-step',
-        process: (ctx: any, response: any) => ({
+      const syncPlugin: Plugin = {
+        name: "sync-step",
+        process: (ctx, response) => ({
           context: ctx,
-          response: { ...response, syncStep: true }
-        })
+          response: { ...response, syncStep: true },
+        }),
       };
-      const asyncPlugin = {
-        name: 'async-step',
-        process: async (ctx: any, response: any) => {
+      const asyncPlugin: Plugin = {
+        name: "async-step",
+        process: async (ctx, response) => {
           await new Promise(resolve => setTimeout(resolve, 5));
           return {
             context: ctx,
-            response: { ...response, asyncStep: true }
+            response: { ...response, asyncStep: true },
           };
-        }
+        },
       };
-      mock('GET /mixed', { base: 'data' })
+      mock(`${method} ${path}` as any, { base: "data" })
         .pipe(syncPlugin)
         .pipe(asyncPlugin);
     });
@@ -171,22 +175,23 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("the response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === 'true' ? true : value === 'false' ? false : value;
+      const expectedValue = value === "true" ? true : value === "false" ? false : value;
       expect(response.body).toHaveProperty(property, expectedValue);
     });
 
     And("the response should have property {string} with boolean value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === 'true' ? true : value === 'false' ? false : value;
+      const expectedValue = value === "true" ? true : value === "false" ? false : value;
       expect(response.body).toHaveProperty(property, expectedValue);
     });
   });
 
   Scenario("Async generator with Promise rejection", ({ Given, When, Then, And }) => {
-    Given("I create a mock with failing async generator:", (_, docString: string) => {
+    Given("I create a mock with an async generator that throws at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /async-fail', async () => {
+      mock(`${method} ${path}` as any, async () => {
         await new Promise(resolve => setTimeout(resolve, 5));
-        throw new Error('Async operation failed');
+        throw new Error("Async operation failed");
       });
     });
 
@@ -205,24 +210,25 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async plugin error recovery", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async error recovery:", (_, docString: string) => {
+    Given("I create a mock with an async error-recovery plugin at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      const asyncErrorPlugin = {
-        name: 'async-error-handler',
+      const asyncErrorPlugin: Plugin = {
+        name: "async-error-handler",
         process: async () => {
           await new Promise(resolve => setTimeout(resolve, 5));
-          throw new Error('Async plugin failed');
+          throw new Error("Async plugin failed");
         },
-        onError: async (error: Error, ctx: any) => {
+        onError: async (error) => {
           await new Promise(resolve => setTimeout(resolve, 3));
           return {
             status: 200,
             body: { recovered: true, originalError: error.message },
-            headers: {}
+            headers: {},
           };
-        }
+        },
       };
-      mock('GET /async-recovery', 'original').pipe(asyncErrorPlugin);
+      mock(`${method} ${path}` as any, "original").pipe(asyncErrorPlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -235,7 +241,7 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("the response should have property {string} with value {word}", (_, property: string, value: string) => {
-      const expectedValue = value === 'true' ? true : value === 'false' ? false : value;
+      const expectedValue = value === "true" ? true : value === "false" ? false : value;
       expect(response.body).toHaveProperty(property, expectedValue);
     });
 
@@ -245,9 +251,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async generator with delay configuration", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async generator and delay:", (_, docString: string) => {
+    Given("I create a mock with delay 20ms and async generator at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock({ delay: 20 });
-      mock('GET /delayed-async', async () => {
+      mock(`${method} ${path}` as any, async () => {
         await new Promise(resolve => setTimeout(resolve, 10));
         return { delayed: true, async: true };
       });
@@ -272,14 +279,15 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Async generator with state management", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async stateful generator:", (_, docString: string) => {
+    Given("I create a mock with async stateful counter at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock({ state: { asyncCounter: 0 } });
-      mock('GET /async-counter', async ({ state }) => {
+      mock(`${method} ${path}` as any, async ({ state }: any) => {
         await new Promise(resolve => setTimeout(resolve, 5));
         state.asyncCounter = (state.asyncCounter || 0) + 1;
-        return { 
+        return {
           count: state.asyncCounter,
-          processedAsync: true
+          processedAsync: true,
         };
       });
     });
@@ -300,26 +308,27 @@ describeFeature(feature, ({ Scenario }) => {
     });
 
     And("both responses should have processedAsync {word}", (_, value: string) => {
-      const expectedValue = value === 'true' ? true : value === 'false' ? false : value;
+      const expectedValue = value === "true" ? true : value === "false" ? false : value;
       expect(responses[0].body.processedAsync).toBe(expectedValue);
       expect(responses[1].body.processedAsync).toBe(expectedValue);
     });
   });
 
   Scenario("Promise-based plugin response generation", ({ Given, When, Then }) => {
-    Given("I create a mock with Promise-generating plugin:", (_, docString: string) => {
+    Given("I create a mock with a Promise-generating plugin at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      const promisePlugin = {
-        name: 'promise-generator',
-        process: async (ctx: any, response: any) => {
+      const promisePlugin: Plugin = {
+        name: "promise-generator",
+        process: async (ctx, response) => {
           if (!response) {
-            const data = await Promise.resolve({ generated: 'by promise' });
+            const data = await Promise.resolve({ generated: "by promise" });
             return { context: ctx, response: data };
           }
           return { context: ctx, response };
-        }
+        },
       };
-      mock('GET /promise-gen', null).pipe(promisePlugin);
+      mock(`${method} ${path}` as any, null).pipe(promisePlugin);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -334,33 +343,33 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Concurrent async requests isolation", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async state isolation:", (_, docString: string) => {
+    Given("I create a mock with async delay per id at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /isolated/:id', async ({ params }) => {
+      mock(`${method} ${path}` as any, async ({ params }: any) => {
         const delay = parseInt(params.id) * 5;
         await new Promise(resolve => setTimeout(resolve, delay));
-        return { 
+        return {
           id: params.id,
-          processedAt: Date.now()
+          processedAt: Date.now(),
         };
       });
     });
 
     When("I make concurrent requests to {string}, {string}, and {string}", async (_, path1: string, path2: string, path3: string) => {
       const promises = [
-        mock.handle('GET', path1),
-        mock.handle('GET', path2), 
-        mock.handle('GET', path3)
+        mock.handle("GET", path1),
+        mock.handle("GET", path2),
+        mock.handle("GET", path3),
       ];
       responses = await Promise.all(promises);
     });
 
     Then("all responses should have different processedAt timestamps", () => {
       const timestamps = responses.map(r => r.body.processedAt);
-      const uniqueTimestamps = new Set(timestamps);
       // In fast test environments, timestamps might be the same, so just check they exist
       expect(timestamps).toHaveLength(3);
-      timestamps.forEach(timestamp => expect(timestamp).toBeGreaterThan(0));
+      timestamps.forEach((timestamp: number) => expect(timestamp).toBeGreaterThan(0));
     });
 
     And("each response should have the correct id value", () => {
@@ -373,39 +382,40 @@ describeFeature(feature, ({ Scenario }) => {
       // All responses should be successful regardless of timing
       for (const response of responses) {
         expect(response.status).toBe(200);
-        expect(response.body).toHaveProperty('id');
-        expect(response.body).toHaveProperty('processedAt');
+        expect(response.body).toHaveProperty("id");
+        expect(response.body).toHaveProperty("processedAt");
       }
     });
   });
 
   Scenario("Async plugin pipeline with context state", ({ Given, When, Then, And }) => {
-    Given("I create a mock with async stateful plugins:", (_, docString: string) => {
+    Given("I create a mock with two async stateful plugins at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      const plugin1 = {
-        name: 'async-step-1',
-        process: async (ctx: any, response: any) => {
+      const plugin1: Plugin = {
+        name: "async-step-1",
+        process: async (ctx, response) => {
           await new Promise(resolve => setTimeout(resolve, 5));
-          ctx.state.set('step1', 'completed');
+          ctx.state.set("step1", "completed");
           return { context: ctx, response };
-        }
+        },
       };
-      const plugin2 = {
-        name: 'async-step-2',
-        process: async (ctx: any, response: any) => {
+      const plugin2: Plugin = {
+        name: "async-step-2",
+        process: async (ctx, response) => {
           await new Promise(resolve => setTimeout(resolve, 3));
-          const step1Status = ctx.state.get('step1');
+          const step1Status = ctx.state.get("step1");
           return {
             context: ctx,
             response: {
               ...response,
               step1: step1Status,
-              step2: 'completed'
-            }
+              step2: "completed",
+            },
           };
-        }
+        },
       };
-      mock('GET /async-pipeline', { base: 'data' })
+      mock(`${method} ${path}` as any, { base: "data" })
         .pipe(plugin1)
         .pipe(plugin2);
     });
@@ -424,4 +434,4 @@ describeFeature(feature, ({ Scenario }) => {
       expect(response.body).toHaveProperty("step2", "completed");
     });
   });
-});
+});

package/src/steps/basic-usage.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 { schmock } from "../index";
 
 const feature = await loadFeature("../../features/basic-usage.feature");
 
@@ -10,9 +10,10 @@ describeFeature(feature, ({ Scenario }) => {
   let response: any;
 
   Scenario("Simplest possible mock - plain text", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a plain text mock returning {string} at {string}", (_, text: string, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /', 'Hello World');
+      mock(`${method} ${path}` as Schmock.RouteKey, text);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -30,9 +31,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Return JSON without specifying contentType", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning a JSON array at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /users', [{ id: 1, name: 'John' }]);
+      mock(`${method} ${path}` as Schmock.RouteKey, [{ id: 1, name: "John" }]);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -51,9 +53,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Return object without contentType", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning a JSON object at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /user', { id: 1, name: 'John' });
+      mock(`${method} ${path}` as Schmock.RouteKey, { id: 1, name: "John" });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -72,7 +75,7 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Empty mock instance", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create an empty mock with no routes", () => {
       mock = schmock();
     });
 
@@ -87,9 +90,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Null response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning null at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /null', null);
+      mock(`${method} ${path}` as Schmock.RouteKey, null);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -107,9 +111,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Undefined response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning undefined at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /undefined', undefined);
+      mock(`${method} ${path}` as Schmock.RouteKey, undefined);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -127,9 +132,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Empty string response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning empty string at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /empty', '');
+      mock(`${method} ${path}` as Schmock.RouteKey, "");
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -147,9 +153,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Number response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning number {int} at {string}", (_, num: number, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /count', 42);
+      mock(`${method} ${path}` as Schmock.RouteKey, num);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -167,9 +174,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Boolean response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning boolean true at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /active', true);
+      mock(`${method} ${path}` as Schmock.RouteKey, true);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -187,9 +195,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Function returning string", ({ Given, When, Then }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with a string generator at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /dynamic', () => 'Dynamic response');
+      mock(`${method} ${path}` as Schmock.RouteKey, () => "Dynamic response");
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -203,9 +212,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Function returning object", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with an object generator at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /dynamic-json', () => ({ timestamp: Date.now() }));
+      mock(`${method} ${path}` as Schmock.RouteKey, () => ({ timestamp: Date.now() }));
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -227,17 +237,17 @@ describeFeature(feature, ({ Scenario }) => {
     let aboutResponse: any;
     let contactResponse: any;
 
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with three routes", () => {
       mock = schmock();
-      mock('GET /', 'Home');
-      mock('GET /about', 'About Us');
-      mock('GET /contact', { email: 'test@example.com' });
+      mock("GET /", "Home");
+      mock("GET /about", "About Us");
+      mock("GET /contact", { email: "test@example.com" });
     });
 
     When("I make three requests to different routes", async () => {
-      homeResponse = await mock.handle('GET', '/');
-      aboutResponse = await mock.handle('GET', '/about');
-      contactResponse = await mock.handle('GET', '/contact');
+      homeResponse = await mock.handle("GET", "/");
+      aboutResponse = await mock.handle("GET", "/about");
+      contactResponse = await mock.handle("GET", "/contact");
     });
 
     Then("the home route should return {string}", (_, expectedText: string) => {
@@ -255,9 +265,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Override contentType detection", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock with explicit text/plain contentType at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /data', { foo: 'bar' }, { contentType: 'text/plain' });
+      mock(`${method} ${path}` as Schmock.RouteKey, { foo: "bar" }, { contentType: "text/plain" });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -275,9 +286,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("HTML response", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning HTML at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /page', '<h1>Hello</h1>', { contentType: 'text/html' });
+      mock(`${method} ${path}` as Schmock.RouteKey, "<h1>Hello</h1>", { contentType: "text/html" });
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -295,9 +307,10 @@ describeFeature(feature, ({ Scenario }) => {
   });
 
   Scenario("Binary/buffer response detection", ({ Given, When, Then, And }) => {
-    Given("I create a mock with:", (_, docString: string) => {
+    Given("I create a mock returning a Buffer at {string}", (_, route: string) => {
+      const [method, path] = route.split(" ");
       mock = schmock();
-      mock('GET /binary', Buffer.from('binary data'));
+      mock(`${method} ${path}` as Schmock.RouteKey, Buffer.from("binary data") as unknown as Schmock.Generator);
     });
 
     When("I request {string}", async (_, request: string) => {
@@ -313,4 +326,4 @@ describeFeature(feature, ({ Scenario }) => {
       expect(response.headers?.["content-type"]).toBe(contentType);
     });
   });
-});
+});