Merge pull request #88 from jaredwray/feat-adding-function-for-tap-injections

feat: adding function for tap injections

Author: jaredwray

src/mock-http.ts

@@ -276,7 +276,13 @@ export class MockHttp extends Hookified {
 			this._server.addHook("onRequest", async (request, reply) => {
 				const matchedTap = this._taps.matchRequest(request);
 				if (matchedTap) {
-					const { response, statusCode = 200, headers } = matchedTap.response;
+					// Handle both static response objects and response functions
+					const injectionResponse =
+						typeof matchedTap.response === "function"
+							? matchedTap.response(request)
+							: matchedTap.response;
+
+					const { response, statusCode = 200, headers } = injectionResponse;
 
 					// Set status code
 					reply.code(statusCode);

src/tap-manager.ts

@@ -48,6 +48,13 @@ export type InjectionMatcher = {
 	headers?: Record<string, string>;
 };
 
+/**
+ * Function that returns an injection response
+ */
+export type InjectionResponseFunction = (
+	request: FastifyRequest,
+) => InjectionResponse;
+
 /**
  * A tap represents an active injection that can be removed later
  */
@@ -57,9 +64,9 @@ export type InjectionTap = {
 	 */
 	id: string;
 	/**
-	 * The response configuration
+	 * The response configuration or a function that returns it
 	 */
-	response: InjectionResponse;
+	response: InjectionResponse | InjectionResponseFunction;
 	/**
 	 * The request matcher configuration
 	 */
@@ -92,12 +99,12 @@ export class TapManager {
 
 	/**
 	 * Inject a custom response for requests matching the given criteria
-	 * @param response - The response configuration
+	 * @param response - The response configuration or a function that returns it
 	 * @param matcher - Optional criteria to match requests
 	 * @returns A tap object that can be used to remove the injection
 	 */
 	public inject(
-		response: InjectionResponse,
+		response: InjectionResponse | InjectionResponseFunction,
 		matcher?: InjectionMatcher,
 	): InjectionTap {
 		const id = randomUUID();

test/mock-http.test.ts

@@ -321,5 +321,116 @@ describe("MockHttp", () => {
 
 			await mock.close();
 		});
+
+		test("should support function response", async () => {
+			const mock = new MockHttp();
+			await mock.start();
+
+			mock.taps.inject(
+				(request) => ({
+					response: `Hello from ${request.url}`,
+					statusCode: 200,
+				}),
+				{ url: "/api/dynamic" },
+			);
+
+			const response = await mock.server.inject({
+				method: "GET",
+				url: "/api/dynamic",
+			});
+
+			expect(response.statusCode).toBe(200);
+			expect(response.body).toBe("Hello from /api/dynamic");
+
+			await mock.close();
+		});
+
+		test("should support function response with dynamic status codes", async () => {
+			const mock = new MockHttp();
+			await mock.start();
+
+			mock.taps.inject((request) => {
+				const statusCode = request.url.includes("error") ? 500 : 200;
+				return {
+					response: { status: statusCode === 500 ? "error" : "success" },
+					statusCode,
+				};
+			});
+
+			const successResponse = await mock.server.inject({
+				method: "GET",
+				url: "/api/success",
+			});
+
+			const errorResponse = await mock.server.inject({
+				method: "GET",
+				url: "/api/error",
+			});
+
+			expect(successResponse.statusCode).toBe(200);
+			expect(successResponse.json()).toEqual({ status: "success" });
+
+			expect(errorResponse.statusCode).toBe(500);
+			expect(errorResponse.json()).toEqual({ status: "error" });
+
+			await mock.close();
+		});
+
+		test("should support function response with dynamic headers", async () => {
+			const mock = new MockHttp();
+			await mock.start();
+
+			mock.taps.inject(
+				(request) => ({
+					response: "OK",
+					statusCode: 200,
+					headers: {
+						"X-Request-Method": request.method,
+						"X-Request-URL": request.url,
+					},
+				}),
+				{ url: "/api/headers" },
+			);
+
+			const response = await mock.server.inject({
+				method: "POST",
+				url: "/api/headers",
+			});
+
+			expect(response.statusCode).toBe(200);
+			expect(response.headers["x-request-method"]).toBe("POST");
+			expect(response.headers["x-request-url"]).toBe("/api/headers");
+
+			await mock.close();
+		});
+
+		test("should support function response with request body inspection", async () => {
+			const mock = new MockHttp();
+			await mock.start();
+
+			mock.taps.inject(
+				(request) => ({
+					response: {
+						receivedMethod: request.method,
+						receivedUrl: request.url,
+					},
+					statusCode: 200,
+				}),
+				{ url: "/api/echo" },
+			);
+
+			const response = await mock.server.inject({
+				method: "POST",
+				url: "/api/echo",
+				payload: { test: "data" },
+			});
+
+			expect(response.statusCode).toBe(200);
+			const body = response.json();
+			expect(body.receivedMethod).toBe("POST");
+			expect(body.receivedUrl).toBe("/api/echo");
+
+			await mock.close();
+		});
 	});
 });

test/tap.test.ts

@@ -371,7 +371,7 @@ describe("Tap", () => {
 			};
 			const tap = tapManager.inject(response);
 
-			expect(tap.response.response).toBe("Hello World");
+			expect(tap.response).toEqual(response);
 		});
 
 		it("should support object response", () => {
@@ -380,7 +380,7 @@ describe("Tap", () => {
 			};
 			const tap = tapManager.inject(response);
 
-			expect(tap.response.response).toEqual({ message: "Hello", code: 200 });
+			expect(tap.response).toEqual(response);
 		});
 
 		it("should support custom status code", () => {
@@ -390,7 +390,7 @@ describe("Tap", () => {
 			};
 			const tap = tapManager.inject(response);
 
-			expect(tap.response.statusCode).toBe(404);
+			expect(tap.response).toEqual(response);
 		});
 
 		it("should support custom headers", () => {
@@ -403,10 +403,93 @@ describe("Tap", () => {
 			};
 			const tap = tapManager.inject(response);
 
-			expect(tap.response.headers).toEqual({
-				"Content-Type": "application/json",
-				"X-Custom-Header": "value",
-			});
+			expect(tap.response).toEqual(response);
+		});
+
+		it("should support function response", () => {
+			const responseFunction = (request: FastifyRequest): InjectionResponse => {
+				return {
+					response: `Hello from ${request.url}`,
+					statusCode: 200,
+				};
+			};
+
+			const tap = tapManager.inject(responseFunction);
+
+			expect(tap.response).toBe(responseFunction);
+			expect(typeof tap.response).toBe("function");
+		});
+
+		it("should call function response with request object", () => {
+			const responseFunction = (request: FastifyRequest): InjectionResponse => {
+				return {
+					response: `Method: ${request.method}, URL: ${request.url}`,
+					statusCode: 200,
+				};
+			};
+
+			const tap = tapManager.inject(responseFunction, { url: "/api/test" });
+			const mockRequest = createMockRequest("/api/test", "GET");
+
+			// Verify the tap was created with the function
+			expect(typeof tap.response).toBe("function");
+
+			// Call the function to verify it works correctly
+			if (typeof tap.response === "function") {
+				const result = tap.response(mockRequest);
+				expect(result.response).toBe("Method: GET, URL: /api/test");
+				expect(result.statusCode).toBe(200);
+			}
+		});
+
+		it("should support function response with dynamic status codes", () => {
+			const responseFunction = (request: FastifyRequest): InjectionResponse => {
+				const statusCode = request.url.includes("error") ? 500 : 200;
+				return {
+					response: { status: statusCode === 500 ? "error" : "success" },
+					statusCode,
+				};
+			};
+
+			const tap = tapManager.inject(responseFunction);
+
+			// Test success case
+			if (typeof tap.response === "function") {
+				const successRequest = createMockRequest("/api/success", "GET");
+				const successResult = tap.response(successRequest);
+				expect(successResult.statusCode).toBe(200);
+				expect(successResult.response).toEqual({ status: "success" });
+
+				// Test error case
+				const errorRequest = createMockRequest("/api/error", "GET");
+				const errorResult = tap.response(errorRequest);
+				expect(errorResult.statusCode).toBe(500);
+				expect(errorResult.response).toEqual({ status: "error" });
+			}
+		});
+
+		it("should support function response with dynamic headers", () => {
+			const responseFunction = (request: FastifyRequest): InjectionResponse => {
+				return {
+					response: "OK",
+					statusCode: 200,
+					headers: {
+						"X-Request-Method": request.method,
+						"X-Request-URL": request.url,
+					},
+				};
+			};
+
+			const tap = tapManager.inject(responseFunction);
+			const mockRequest = createMockRequest("/api/test", "POST");
+
+			if (typeof tap.response === "function") {
+				const result = tap.response(mockRequest);
+				expect(result.headers).toEqual({
+					"X-Request-Method": "POST",
+					"X-Request-URL": "/api/test",
+				});
+			}
 		});
 	});
 });