@mastra/server-adapters-test-suite 0.1.3-alpha.1 → 0.1.3

package/dist/index.js

@@ -1,3 +1,5 @@
+import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
+import { handleError } from "@mastra/server/handlers/error";
 import { HTTPException, SERVER_ROUTES, WorkflowRegistry, createRoute } from "@mastra/server/server-adapter";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 import * as zod from "zod";
@@ -57,6 +59,7 @@ function getRouteSpecificSchemaDefaults(route) {
 		predicateScope: "trace",
 		path: "entityName"
 	} };
+	if (route.path === "/agent-controller/:controllerId/sessions" && route.method === "POST") return { body: { resourceId: "test-resource" } };
 	if (route.path === "/datasets/:datasetId/compare") return { body: {
 		experimentIds: ["test-experiment-a", "test-experiment-b"],
 		baselineId: "test-experiment-a"
@@ -134,8 +137,10 @@ function generateValidDataFromSchema(schema, fieldName) {
 		def = getZodDef(schema);
 	}
 	if (typeName === "ZodOptional" || typeName === "ZodNullable") return generateValidDataFromSchema(def.innerType, fieldName);
-	if (typeName === "ZodDefault") if ("_zod" in schema) return def.defaultValue;
-	else return def.defaultValue();
+	if (typeName === "ZodDefault") {
+		if ("_zod" in schema) return def.defaultValue;
+		else return def.defaultValue();
+	}
 	if (typeName === "ZodString") {
 		if ((def.checks ?? []).some((check) => {
 			const checkDef = check._zod?.def ?? check.def ?? check;
@@ -233,13 +238,19 @@ function generateValidDataFromSchema(schema, fieldName) {
 	if (typeName === "ZodUndefined") return void 0;
 	if (typeName === "ZodDate") return /* @__PURE__ */ new Date();
 	if (typeName === "ZodBigInt") return BigInt(0);
-	if (typeName === "ZodLiteral") if ("_zod" in schema) return def.values?.[0];
-	else return def.value;
-	if (typeName === "ZodEnum") if ("_zod" in schema) return Object.values(def.entries)[0];
-	else return def.values[0];
+	if (typeName === "ZodLiteral") {
+		if ("_zod" in schema) return def.values?.[0];
+		else return def.value;
+	}
+	if (typeName === "ZodEnum") {
+		if ("_zod" in schema) return Object.values(def.entries)[0];
+		else return def.values[0];
+	}
 	if (typeName === "ZodNativeEnum") return Object.values(def.values)[0];
-	if (typeName === "ZodArray") if ("_zod" in schema) return [generateValidDataFromSchema(def.element, fieldName)];
-	else return [generateValidDataFromSchema(def.type, fieldName)];
+	if (typeName === "ZodArray") {
+		if ("_zod" in schema) return [generateValidDataFromSchema(def.element, fieldName)];
+		else return [generateValidDataFromSchema(def.type, fieldName)];
+	}
 	if (typeName === "ZodObject") {
 		const shape = typeof def.shape === "function" ? def.shape() : def.shape;
 		const obj = {};
@@ -307,6 +318,7 @@ function getDefaultValidPathParams(route) {
 	if (route.path.includes(":controllerId")) params.controllerId = "test-controller";
 	if (route.path.includes(":responseId")) params.responseId = "test-response";
 	if (route.path.includes(":resourceId")) params.resourceId = "test-resource";
+	if (route.path.includes(":sessionId")) params.sessionId = "test-session";
 	if (route.path.includes(":modelConfigId")) params.modelConfigId = "id1";
 	if (route.path.includes(":scorerId") && route.path.includes("/stored/scorers/")) params.scorerId = "test-stored-scorer";
 	else if (route.path.includes(":scorerId")) params.scorerId = "test-scorer";
@@ -430,7 +442,8 @@ function createRouteTestSuite(config) {
 		});
 	});
 	routes.forEach((route) => {
-		describe(`${route.method} ${route.path}`, () => {
+		const routeKey = `${route.method} ${route.path}`;
+		describe(routeKey, () => {
 			if (route.deprecated) {
 				it("should be marked as deprecated", () => {
 					expect(route.deprecated).toBe(true);
@@ -782,9 +795,7 @@ async function createDefaultTestContext() {
 				case "multiply":
 					result = a * b;
 					break;
-				case "divide":
-					result = b !== 0 ? a / b : Infinity;
-					break;
+				case "divide": result = b !== 0 ? a / b : Infinity;
 			}
 			return { result };
 		}
@@ -1336,9 +1347,10 @@ Follow these instructions for the test skill.
 		installedAt: (/* @__PURE__ */ new Date("2024-01-01T00:00:00.000Z")).toISOString()
 	};
 	fs.writeFileSync(path.join(agentSkillsDir, ".meta.json"), JSON.stringify(metaJson, null, 2));
+	const filesystem = new LocalFilesystem({ basePath: tempDir });
 	const workspace = new Workspace({
 		id: "test-workspace",
-		filesystem: new LocalFilesystem({ basePath: tempDir }),
+		filesystem,
 		skills: ["skills"],
 		bm25: true
 	});
@@ -1362,7 +1374,8 @@ function createTestTool(overrides = {}) {
 * Following the pattern from handler tests - uses actual MockMemory implementation
 */
 function createMockMemory() {
-	const mockMemory = new MockMemory({ storage: new InMemoryStore() });
+	const storage = new InMemoryStore();
+	const mockMemory = new MockMemory({ storage });
 	mockMemory.__registerMastra = vi.fn();
 	return mockMemory;
 }
@@ -1831,7 +1844,8 @@ function createRouteAdapterTestSuite(config) {
 			expect(response.status).toBe(200);
 			const data = response.data;
 			expect(data.filter).toEqual({ status: "active" });
-			expect(Array.isArray(data.tag) ? data.tag : [data.tag]).toContain("b");
+			const tags = Array.isArray(data.tag) ? data.tag : [data.tag];
+			expect(tags).toContain("b");
 			expect(data.keys).not.toContain("__proto__");
 			expect(data.keys).not.toContain("constructor");
 			expect(data.keys).not.toContain("prototype");
@@ -2102,7 +2116,8 @@ function createRouteAdapterTestSuite(config) {
 		Object.entries(deprecatedByCategory).forEach(([category, routes]) => {
 			describe(category, () => {
 				routes.forEach((route) => {
-					describe(`${route.method} ${route.path}`, () => {
+					const testName = `${route.method} ${route.path}`;
+					describe(testName, () => {
 						it("should be marked as deprecated", () => {
 							expect(route.deprecated).toBe(true);
 							expect(route.openapi?.deprecated).toBe(true);
@@ -2162,7 +2177,8 @@ function createRouteAdapterTestSuite(config) {
 		Object.entries(routesByCategory).forEach(([category, routes]) => {
 			describe(category, () => {
 				routes.forEach((route) => {
-					describe(`${route.method} ${route.path}`, () => {
+					const testName = `${route.method} ${route.path}`;
+					describe(testName, () => {
 						it("should execute with valid request", async () => {
 							const request = buildRouteRequest(route);
 							const httpRequest = {
@@ -2197,7 +2213,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.path.includes(":workflowId")) it("should return 404 when workflow not found", async () => {
 							const request = buildRouteRequest(route, { pathParams: { workflowId: "non-existent-workflow" } });
@@ -2207,7 +2224,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.path.includes(":backgroundTaskId")) it("should return 404 when background task not found", async () => {
 							const request = buildRouteRequest(route, { pathParams: { backgroundTaskId: "non-existent-background-task" } });
@@ -2217,7 +2235,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.path.includes(":serverId")) it("should return 404 when MCP server not found (via :serverId)", async () => {
 							const request = buildRouteRequest(route, { pathParams: { serverId: "non-existent-server" } });
@@ -2227,7 +2246,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.path.includes("/mcp/v0/servers/:id")) it("should return 404 when MCP server not found (via :id)", async () => {
 							const request = buildRouteRequest(route, { pathParams: { id: "non-existent-server" } });
@@ -2237,7 +2257,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.path.includes(":processorId")) it("should return 404 when processor not found", async () => {
 							const request = buildRouteRequest(route, { pathParams: { processorId: "non-existent-processor" } });
@@ -2247,7 +2268,8 @@ function createRouteAdapterTestSuite(config) {
 								query: request.query,
 								body: request.body
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBe(404);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBe(404);
 						});
 						if (route.responseType === "stream") it("should be consumable via stream reader", async () => {
 							const request = buildRouteRequest(route);
@@ -2262,9 +2284,13 @@ function createRouteAdapterTestSuite(config) {
 							expect(response.stream).toBeDefined();
 							if (typeof response.stream.getReader === "function") {
 								const reader = response.stream.getReader();
-								expect(await reader.read()).toBeDefined();
+								const firstChunk = await reader.read();
+								expect(firstChunk).toBeDefined();
 								reader.releaseLock();
-							} else if (typeof response.stream[Symbol.asyncIterator] === "function") expect(await response.stream[Symbol.asyncIterator]().next()).toBeDefined();
+							} else if (typeof response.stream[Symbol.asyncIterator] === "function") {
+								const firstChunk = await response.stream[Symbol.asyncIterator]().next();
+								expect(firstChunk).toBeDefined();
+							}
 						});
 						if (route.queryParamSchema || route.bodySchema) it("should return 400 when schema validation fails", async () => {
 							const request = buildRouteRequest(route);
@@ -2321,7 +2347,8 @@ function createRouteAdapterTestSuite(config) {
 									}
 								}
 							};
-							expect((await executeHttpRequest(app, httpRequest)).status).toBeLessThan(500);
+							const response = await executeHttpRequest(app, httpRequest);
+							expect(response.status).toBeLessThan(500);
 						});
 						const bodySchema = route.bodySchema;
 						if (["POST", "PUT"].includes(route.method) && bodySchema) it("should spread body fields to handler params", async () => {
@@ -2382,7 +2409,8 @@ function createRouteAdapterTestSuite(config) {
 					expect(response.type).toBe("json");
 					const errorData = response.data;
 					expect(errorData).toBeDefined();
-					expect(errorData.error !== void 0 || errorData.message !== void 0 || errorData.details !== void 0 || errorData.statusCode !== void 0).toBe(true);
+					const hasErrorField = errorData.error !== void 0 || errorData.message !== void 0 || errorData.details !== void 0 || errorData.statusCode !== void 0;
+					expect(hasErrorField).toBe(true);
 				});
 			});
 			SERVER_ROUTES.filter((r) => r.method === "POST" && r.bodySchema && !isExcluded(r)).forEach((route) => {
@@ -2498,41 +2526,88 @@ function createRouteAdapterTestSuite(config) {
 				expect(custom.getHandlerCalls()).toBe(1);
 			});
 		});
+		describe("Run claim conflict responses (#27638)", () => {
+			it.each([
+				"AGENT_RESUME_ALREADY_CLAIMED",
+				"WORKFLOW_RESUME_ALREADY_CLAIMED",
+				"AGENT_RESUME_RUN_NOT_SUSPENDED",
+				"WORKFLOW_RUN_NOT_SUSPENDED",
+				"WORKFLOW_TIME_TRAVEL_ALREADY_CLAIMED",
+				"WORKFLOW_TIME_TRAVEL_RUN_RUNNING"
+			])("lets clients identify %s without matching message text", async (code) => {
+				const error = new MastraError({
+					id: code,
+					domain: ErrorDomain.MASTRA_WORKFLOW,
+					category: ErrorCategory.USER
+				}, "Run conflict");
+				const route = {
+					method: "POST",
+					path: "/test/run-claim-conflict",
+					responseType: "json",
+					handler: async () => handleError(error, "Unable to resume")
+				};
+				const mutableServerRoutes = SERVER_ROUTES;
+				const originalLength = mutableServerRoutes.length;
+				mutableServerRoutes.push(route);
+				let conflictApp;
+				try {
+					({app: conflictApp} = await setupAdapter(context));
+				} finally {
+					mutableServerRoutes.splice(originalLength);
+				}
+				const response = await executeHttpRequest(conflictApp, {
+					method: "POST",
+					path: "/api/test/run-claim-conflict",
+					body: {}
+				});
+				expect(response.status).toBe(409);
+				expect(response.headers["content-type"]).toContain("application/json");
+				expect(response.data).toEqual({
+					error: "Run conflict",
+					code
+				});
+			});
+		});
 		describe("Route Prefix", () => {
 			it("should register routes at prefixed paths without double /api", async () => {
 				const prefixedApp = (await setupAdapter(context, { prefix: "/v2" })).app;
-				expect((await executeHttpRequest(prefixedApp, {
+				const response = await executeHttpRequest(prefixedApp, {
 					method: "GET",
 					path: "/v2/agents"
-				})).status).toBeLessThan(400);
+				});
+				expect(response.status).toBeLessThan(400);
 			});
 			it("should not have routes at double /api path when prefix is set", async () => {
 				const prefixedApp = (await setupAdapter(context, { prefix: "/v2" })).app;
-				expect((await executeHttpRequest(prefixedApp, {
+				const response = await executeHttpRequest(prefixedApp, {
 					method: "GET",
 					path: "/v2/api/agents"
-				})).status).toBe(404);
+				});
+				expect(response.status).toBe(404);
 			});
 			it("should normalize prefix with trailing slash", async () => {
 				const prefixedApp = (await setupAdapter(context, { prefix: "/mastra/" })).app;
-				expect((await executeHttpRequest(prefixedApp, {
+				const response = await executeHttpRequest(prefixedApp, {
 					method: "GET",
 					path: "/mastra/agents"
-				})).status).toBeLessThan(400);
+				});
+				expect(response.status).toBeLessThan(400);
 			});
 			it("should normalize prefix without leading slash", async () => {
 				const prefixedApp = (await setupAdapter(context, { prefix: "mastra" })).app;
-				expect((await executeHttpRequest(prefixedApp, {
+				const response = await executeHttpRequest(prefixedApp, {
 					method: "GET",
 					path: "/mastra/agents"
-				})).status).toBeLessThan(400);
+				});
+				expect(response.status).toBeLessThan(400);
 			});
 			it("should not have routes at double-slash path when prefix has trailing slash", async () => {
 				const prefixedApp = (await setupAdapter(context, { prefix: "/mastra/" })).app;
-				expect((await executeHttpRequest(prefixedApp, {
+				const response = await executeHttpRequest(prefixedApp, {
 					method: "GET",
 					path: "/mastra//agents"
-				})).status).toBe(404);
+				});
+				expect(response.status).toBe(404);
 			});
 		});
 	});
@@ -2696,10 +2771,11 @@ function createMCPRouteTestSuite(config) {
 				expect(res.data.tools).toEqual(expect.arrayContaining([expect.objectContaining({ name: "getWeather" }), expect.objectContaining({ name: "calculate" })]));
 			});
 			it("should return 404 for non-existent server", async () => {
-				expect((await executeHttpRequest(app, {
+				const res = await executeHttpRequest(app, {
 					method: "GET",
 					path: "/api/mcp/non-existent/tools"
-				})).status).toBe(404);
+				});
+				expect(res.status).toBe(404);
 			});
 		});
 		describe("GET /api/mcp/:serverId/tools/:toolId", () => {
@@ -2716,10 +2792,11 @@ function createMCPRouteTestSuite(config) {
 				});
 			});
 			it("should return 404 for non-existent tool", async () => {
-				expect((await executeHttpRequest(app, {
+				const res = await executeHttpRequest(app, {
 					method: "GET",
 					path: `/api/mcp/${mcpServer1.id}/tools/non-existent`
-				})).status).toBe(404);
+				});
+				expect(res.status).toBe(404);
 			});
 		});
 		describe("POST /api/mcp/:serverId/tools/:toolId/execute", () => {
@@ -2749,7 +2826,7 @@ function createMCPRouteTestSuite(config) {
 				});
 			});
 			it("should return 404 for non-existent server", async () => {
-				expect((await executeHttpRequest(app, {
+				const res = await executeHttpRequest(app, {
 					method: "POST",
 					path: "/api/mcp/non-existent/tools/calculate/execute",
 					body: { data: {
@@ -2757,7 +2834,8 @@ function createMCPRouteTestSuite(config) {
 						a: 1,
 						b: 2
 					} }
-				})).status).toBe(404);
+				});
+				expect(res.status).toBe(404);
 			});
 			it("should return error for non-existent tool", async () => {
 				const res = await executeHttpRequest(app, {
@@ -3028,9 +3106,7 @@ function createMCPTransportTestSuite(config) {
 					case "multiply":
 						result = a * b;
 						break;
-					case "divide":
-						result = a / b;
-						break;
+					case "divide": result = a / b;
 				}
 				return { result };
 			}
@@ -3092,7 +3168,8 @@ function createMCPTransportTestSuite(config) {
 				path: "messages",
 				method: "POST"
 			}])("rejects the legacy $path route for a native server", async ({ path, method }) => {
-				expect((await fetch(`http://localhost:${port}/api/mcp/native-fixture/${path}`, { method })).status).toBe(404);
+				const response = await fetch(`http://localhost:${port}/api/mcp/native-fixture/${path}`, { method });
+				expect(response.status).toBe(404);
 			});
 			it("executes ordinary tools with the v2 request context and reports a suspended tool truthfully", async () => {
 				const base = `http://localhost:${port}/api/mcp/native-fixture/tools`;
@@ -3144,7 +3221,7 @@ function createMCPTransportTestSuite(config) {
 		describe("HTTP Transport (/api/mcp/:serverId/mcp)", () => {
 			describe("Error handling (raw HTTP)", () => {
 				it("should return 404 for non-existent server", async () => {
-					expect((await fetch(`http://localhost:${port}/api/mcp/non-existent/mcp`, {
+					const res = await fetch(`http://localhost:${port}/api/mcp/non-existent/mcp`, {
 						method: "POST",
 						headers: {
 							"Content-Type": "application/json",
@@ -3163,7 +3240,8 @@ function createMCPTransportTestSuite(config) {
 							},
 							id: 1
 						})
-					})).status).toBe(404);
+					});
+					expect(res.status).toBe(404);
 				});
 			});
 			describe("Protocol operations (MCPClient)", () => {
@@ -3199,7 +3277,8 @@ function createMCPTransportTestSuite(config) {
 					const tools = await mcpClient.listTools();
 					expect(tools["server1_getWeather"]).toBeDefined();
 					expect(tools["server1_calculate"]).toBeDefined();
-					expect(Object.keys(tools).filter((k) => k.startsWith("server2_"))).toHaveLength(0);
+					const server2Tools = Object.keys(tools).filter((k) => k.startsWith("server2_"));
+					expect(server2Tools).toHaveLength(0);
 				});
 			});
 			describe("Tool execution errors (MCPClient)", () => {
@@ -3208,17 +3287,18 @@ function createMCPTransportTestSuite(config) {
 				let failingMastra;
 				let failingHttpServer;
 				beforeAll(async () => {
+					const failingTool = createTool({
+						id: "failingTool",
+						description: "A tool that always throws an error",
+						inputSchema: z.object({}),
+						execute: async () => {
+							throw new Error("Tool execution failed intentionally");
+						}
+					});
 					failingServer = new MCPServer({
 						name: "failingServer",
 						version: "1.0.0",
-						tools: { failingTool: createTool({
-							id: "failingTool",
-							description: "A tool that always throws an error",
-							inputSchema: z.object({}),
-							execute: async () => {
-								throw new Error("Tool execution failed intentionally");
-							}
-						}) }
+						tools: { failingTool }
 					});
 					failingMastra = new Mastra$1({ mcpServers: { "failing-server": failingServer } });
 					const serverSetup = await createServer(failingMastra);
@@ -3253,10 +3333,11 @@ function createMCPTransportTestSuite(config) {
 		describe("SSE Transport (/api/mcp/:serverId/sse)", () => {
 			describe("Error handling (raw HTTP)", () => {
 				it("should return 404 for non-existent server on GET /sse", async () => {
-					expect((await fetch(`http://localhost:${port}/api/mcp/non-existent/sse`)).status).toBe(404);
+					const res = await fetch(`http://localhost:${port}/api/mcp/non-existent/sse`);
+					expect(res.status).toBe(404);
 				});
 				it("should return 404 for non-existent server on POST /messages", async () => {
-					expect((await fetch(`http://localhost:${port}/api/mcp/non-existent/messages`, {
+					const res = await fetch(`http://localhost:${port}/api/mcp/non-existent/messages`, {
 						method: "POST",
 						headers: { "Content-Type": "application/json" },
 						body: JSON.stringify({
@@ -3264,14 +3345,16 @@ function createMCPTransportTestSuite(config) {
 							method: "test",
 							id: 1
 						})
-					})).status).toBe(404);
+					});
+					expect(res.status).toBe(404);
 				});
 			});
 			describe("MCP 2.x servers (MCPClient)", () => {
 				it("does not serve the legacy SSE transport for a 2.x MCPServer", async (ctx) => {
 					if (mcpServer1.mcpVersion !== 2) ctx.skip();
-					expect((await fetch(`http://localhost:${port}/api/mcp/${mcpServer1.id}/sse`)).status).toBe(404);
-					expect((await fetch(`http://localhost:${port}/api/mcp/${mcpServer1.id}/messages`, {
+					const res = await fetch(`http://localhost:${port}/api/mcp/${mcpServer1.id}/sse`);
+					expect(res.status).toBe(404);
+					const messages = await fetch(`http://localhost:${port}/api/mcp/${mcpServer1.id}/messages`, {
 						method: "POST",
 						headers: { "Content-Type": "application/json" },
 						body: JSON.stringify({
@@ -3279,7 +3362,8 @@ function createMCPTransportTestSuite(config) {
 							method: "tools/list",
 							id: 1
 						})
-					})).status).toBe(404);
+					});
+					expect(messages.status).toBe(404);
 				});
 				it("fails to connect through the SSE URL without downgrading", async (ctx) => {
 					if (mcpServer1.mcpVersion !== 2) ctx.skip();
@@ -3356,7 +3440,8 @@ function createMultipartTestSuite(config) {
 				body: formData
 			});
 			expect(response.status).toBe(200);
-			expect(await response.json()).toMatchObject({
+			const result = await response.json();
+			expect(result).toMatchObject({
 				success: true,
 				hasAudio: true
 			});
@@ -3391,10 +3476,11 @@ function createMultipartTestSuite(config) {
 				language: "en",
 				format: "mp3"
 			}));
-			expect((await fetch(`${serverInfo.baseUrl}/test/upload-with-options`, {
+			const response = await fetch(`${serverInfo.baseUrl}/test/upload-with-options`, {
 				method: "POST",
 				body: formData
-			})).status).toBe(200);
+			});
+			expect(response.status).toBe(200);
 			expect(receivedBody.options).toBeDefined();
 			expect(typeof receivedBody.options).toBe("object");
 			expect(receivedBody.options.language).toBe("en");
@@ -3424,10 +3510,11 @@ function createMultipartTestSuite(config) {
 			])], { type: "audio/wav" });
 			formData.append("audio", audioBlob, "test.wav");
 			formData.append("name", "test-recording");
-			expect((await fetch(`${serverInfo.baseUrl}/test/upload-with-string`, {
+			const response = await fetch(`${serverInfo.baseUrl}/test/upload-with-string`, {
 				method: "POST",
 				body: formData
-			})).status).toBe(200);
+			});
+			expect(response.status).toBe(200);
 			expect(receivedBody.name).toBe("test-recording");
 		});
 		it("should reject files exceeding size limit", async () => {
@@ -3449,10 +3536,11 @@ function createMultipartTestSuite(config) {
 			const formData = new FormData();
 			const largeBlob = new Blob([/* @__PURE__ */ new Uint8Array(200)], { type: "audio/wav" });
 			formData.append("audio", largeBlob, "large.wav");
-			expect((await fetch(`${serverInfo.baseUrl}/test/upload-limited`, {
+			const response = await fetch(`${serverInfo.baseUrl}/test/upload-limited`, {
 				method: "POST",
 				body: formData
-			})).status).toBeGreaterThanOrEqual(400);
+			});
+			expect(response.status).toBeGreaterThanOrEqual(400);
 		});
 		it("should handle empty FormData gracefully", async () => {
 			const { adapter, app } = await setupAdapter(context);
@@ -3485,7 +3573,8 @@ function createMultipartTestSuite(config) {
 				body: formData
 			});
 			expect(response.status).toBe(200);
-			expect(await response.json()).toMatchObject({
+			const result = await response.json();
+			expect(result).toMatchObject({
 				success: true,
 				bodyKeys: []
 			});
@@ -3527,7 +3616,8 @@ function createMultipartTestSuite(config) {
 				body: formData
 			});
 			expect(response.status).toBe(200);
-			expect(await response.json()).toMatchObject({
+			const result = await response.json();
+			expect(result).toMatchObject({
 				hasFile1: true,
 				hasFile2: true
 			});
@@ -3556,7 +3646,8 @@ function createMultipartTestSuite(config) {
 				body: JSON.stringify({ message: "Hello, World!" })
 			});
 			expect(response.status).toBe(200);
-			expect(await response.json()).toMatchObject({
+			const result = await response.json();
+			expect(result).toMatchObject({
 				success: true,
 				message: "Hello, World!"
 			});
@@ -3656,7 +3747,8 @@ function createHttpLoggingTestSuite(config) {
 			logSpy = vi.spyOn(adapter.logger, "info");
 			await adapter.init();
 			await addRoute(app, "GET", "/test", () => ({ message: "success" }));
-			expect((await executeRequest(app, "GET", "http://localhost/test")).status).toBe(200);
+			const response = await executeRequest(app, "GET", "http://localhost/test");
+			expect(response.status).toBe(200);
 			expect(logSpy).toHaveBeenCalledWith(expect.stringMatching(/GET \/test 200 \d+ms/), expect.objectContaining({
 				method: "GET",
 				path: "/test",
@@ -3834,10 +3926,11 @@ function createBodyLimitTestSuite(config) {
 					return { receivedBody: body };
 				}
 			});
-			expect((await executeRequest(wiredApp, "POST", "http://localhost/test/route-body-limit", {
+			const response = await executeRequest(wiredApp, "POST", "http://localhost/test/route-body-limit", {
 				headers: { "Content-Type": "application/json" },
 				body: oversizedPayload
-			})).status).toBe(413);
+			});
+			expect(response.status).toBe(413);
 			expect(handlerCalled).toBe(false);
 			await cleanupApp?.(wiredApp);
 		});
@@ -3856,10 +3949,11 @@ function createBodyLimitTestSuite(config) {
 					return { receivedBody: body };
 				}
 			});
-			expect((await executeRequestWithoutContentLength(wiredApp, "POST", "http://localhost/test/route-body-limit-no-content-length", {
+			const response = await executeRequestWithoutContentLength(wiredApp, "POST", "http://localhost/test/route-body-limit-no-content-length", {
 				headers: { "Content-Type": "application/json" },
 				body: oversizedPayload
-			})).status).toBe(413);
+			});
+			expect(response.status).toBe(413);
 			expect(handlerCalled).toBe(false);
 			await cleanupApp?.(wiredApp);
 		});
@@ -3876,10 +3970,11 @@ function createBodyLimitTestSuite(config) {
 				responseType: "json",
 				handler: async ({ body }) => ({ receivedBody: body })
 			});
-			expect((await executeRequest(wiredApp, method, "http://localhost/test/body-limit", {
+			const response = await executeRequest(wiredApp, method, "http://localhost/test/body-limit", {
 				headers: { "Content-Type": "application/json" },
 				body: oversizedPayload
-			})).status).toBe(413);
+			});
+			expect(response.status).toBe(413);
 			await cleanupApp?.(wiredApp);
 		});
 	});