Merge pull request #51 from jaredwray/feat-adding-in-cookies-from-httpbin

feat: adding in cookies from httpbin

Author: jaredwray

package.json

@@ -49,6 +49,7 @@
     "xo": "^0.60.0"
   },
   "dependencies": {
+    "@fastify/cookie": "^11.0.2",
     "@fastify/helmet": "^13.0.1",
     "@fastify/static": "^8.1.1",
     "@fastify/swagger": "^9.5.1",

src/mock-http.ts

@@ -2,6 +2,7 @@ import path from 'node:path';
 import fastifyStatic from '@fastify/static';
 import fastifyHelmet from '@fastify/helmet';
 import {fastifySwagger} from '@fastify/swagger';
+import fastifyCookie from '@fastify/cookie';
 import Fastify, {type FastifyInstance} from 'fastify';
 import {Hookified, type HookifiedOptions} from 'hookified';
 import {detect} from 'detect-port';
@@ -16,6 +17,7 @@ import {statusCodeRoute} from './routes/status-codes/index.js';
 import {ipRoute, headersRoute, userAgentRoute} from './routes/request-inspection/index.js';
 import {cacheRoutes, etagRoutes, responseHeadersRoutes} from './routes/response-inspection/index.js';
 import {absoluteRedirectRoute, relativeRedirectRoute, redirectToRoute} from './routes/redirects/index.js';
+import {getCookiesRoute, postCookieRoute, deleteCookieRoute} from './routes/cookies/index.js';
 
 // eslint-disable-next-line unicorn/prevent-abbreviations
 export type HttpBinOptions = {
@@ -24,6 +26,7 @@ export type HttpBinOptions = {
 	requestInspection?: boolean;
 	responseInspection?: boolean;
 	statusCodes?: boolean;
+	cookies?: boolean;
 };
 
 export type MockHttpOptions = {
@@ -70,6 +73,7 @@ export class MockHttp extends Hookified {
 		requestInspection: true,
 		responseInspection: true,
 		statusCodes: true,
+		cookies: true,
 	};
 
 	// eslint-disable-next-line new-cap
@@ -245,7 +249,7 @@ export class MockHttp extends Hookified {
 				await this.registerApiDocs();
 			}
 
-			const {httpMethods, redirects, requestInspection, responseInspection, statusCodes} = this._httpBin;
+			const {httpMethods, redirects, requestInspection, responseInspection, statusCodes, cookies} = this._httpBin;
 
 			if (httpMethods) {
 				await this.registerHttpMethods();
@@ -267,6 +271,10 @@ export class MockHttp extends Hookified {
 				await this.registerRedirectRoutes();
 			}
 
+			if (cookies) {
+				await this.registerCookieRoutes();
+			}
+
 			if (this._autoDetectPort) {
 				const originalPort = this._port;
 				this._port = await this.detectPort();
@@ -370,6 +378,18 @@ export class MockHttp extends Hookified {
 		await fastify.register(relativeRedirectRoute);
 		await fastify.register(redirectToRoute);
 	}
+
+	/**
+	 * Register the cookie routes.
+	 * @param fastifyInstance - the server instance to register the routes on.
+	 */
+	public async registerCookieRoutes(fastifyInstance?: FastifyInstance): Promise<void> {
+		const fastify = fastifyInstance ?? this._server;
+		await fastify.register(fastifyCookie);
+		await fastify.register(getCookiesRoute);
+		await fastify.register(postCookieRoute);
+		await fastify.register(deleteCookieRoute);
+	}
 }
 
 export const mockhttp = MockHttp;

src/routes/cookies/delete.ts

@@ -0,0 +1,33 @@
+import {
+	type FastifyInstance, type FastifySchema,
+} from 'fastify';
+
+export const cookiesDeleteSchema: FastifySchema = {
+	description: 'Delete a cookie',
+	tags: ['Cookies'],
+	querystring: {
+		type: 'object',
+		properties: {
+			name: {type: 'string'},
+		},
+		required: ['name'],
+		additionalProperties: false,
+	},
+	response: {
+		// eslint-disable-next-line  @typescript-eslint/naming-convention
+		204: {
+			type: 'null',
+		},
+	},
+};
+
+export const deleteCookieRoute = (fastify: FastifyInstance) => {
+	fastify.delete('/cookies', {schema: cookiesDeleteSchema}, async (request, reply) => {
+		const {name} = request.query as {name: string};
+		// eslint-disable-next-line @typescript-eslint/no-floating-promises
+		reply.clearCookie(name, {path: '/'});
+
+		// Send back a 204 No Content response
+		return reply.status(204).send();
+	});
+};

src/routes/cookies/get.ts

@@ -0,0 +1,29 @@
+import {
+	type FastifyInstance, type FastifyRequest, type FastifyReply, type FastifySchema,
+} from 'fastify';
+
+const getCookiesRouteSchema: FastifySchema = {
+	description: 'Return cookies from the request',
+	tags: ['Cookies'],
+	response: {
+		// eslint-disable-next-line  @typescript-eslint/naming-convention
+		200: {
+			type: 'object',
+			properties: {
+				cookies: {
+					type: 'object',
+					additionalProperties: {type: 'string'},
+				},
+			},
+			required: ['cookies'],
+		},
+	},
+};
+
+export const getCookiesRoute = (fastify: FastifyInstance) => {
+	fastify.get('/cookies', {schema: getCookiesRouteSchema}, async (request: FastifyRequest, reply: FastifyReply) => {
+		await reply.send({
+			cookies: request.cookies,
+		});
+	});
+};

src/routes/cookies/index.ts

@@ -0,0 +1,4 @@
+export {getCookiesRoute} from './get.js';
+export {postCookieRoute} from './post.js';
+export {deleteCookieRoute} from './delete.js';
+

src/routes/cookies/post.ts

@@ -0,0 +1,48 @@
+import {
+	type FastifyInstance, type FastifySchema,
+} from 'fastify';
+
+const postCookieRouteSchema: FastifySchema = {
+	description: 'Set a cookie',
+	tags: ['Cookies'],
+	body: {
+		type: 'object',
+		properties: {
+			name: {type: 'string'},
+			value: {type: 'string'},
+			expires: {type: 'string', format: 'date-time'},
+		},
+		required: ['name', 'value'],
+		additionalProperties: false,
+	},
+	response: {
+		// eslint-disable-next-line  @typescript-eslint/naming-convention
+		200: {
+			type: 'object',
+			properties: {
+				cookies: {
+					type: 'object',
+					additionalProperties: {type: 'string'},
+				},
+			},
+			required: ['cookies'],
+		},
+	},
+};
+
+export const postCookieRoute = (fastify: FastifyInstance) => {
+	fastify.post<{Body: {name: string; value: string; expires?: string}}>('/cookies', {schema: postCookieRouteSchema}, async (request, reply) => {
+		const {name, value, expires} = request.body;
+		if (expires) {
+			const date = new Date(expires);
+			// eslint-disable-next-line @typescript-eslint/no-floating-promises
+			reply.setCookie(name, value, {path: '/', expires: date});
+		} else {
+			// eslint-disable-next-line @typescript-eslint/no-floating-promises
+			reply.setCookie(name, value, {path: '/'});
+		}
+
+		// Send back the current cookies
+		return reply.status(200).send();
+	});
+};

test/routes/cookies/index.test.ts

@@ -0,0 +1,82 @@
+import {describe, it, expect} from 'vitest';
+import Fastify from 'fastify';
+import fastifyCookie from '@fastify/cookie';
+import {getCookiesRoute, postCookieRoute, deleteCookieRoute} from '../../../src/routes/cookies/index.js';
+
+describe('Cookies route', async () => {
+	// eslint-disable-next-line new-cap
+	const fastify = Fastify();
+	await fastify.register(fastifyCookie);
+	await fastify.register(getCookiesRoute);
+	await fastify.register(postCookieRoute);
+	await fastify.register(deleteCookieRoute);
+	await fastify.ready();
+
+	it('should return no cookies in the response', async () => {
+		const response = await fastify.inject({
+			method: 'GET',
+			url: '/cookies',
+		});
+
+		expect(response.statusCode).toBe(200);
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		const responseBody = response.json();
+		expect(responseBody).toEqual({
+			cookies: {},
+		});
+	});
+
+	it('should set a cookie', async () => {
+		const setCookieResponse = await fastify.inject({
+			method: 'POST',
+			url: '/cookies',
+			payload: {
+				name: 'testCookie',
+				value: 'testValue',
+				expires: new Date(Date.now() + (60 * 60 * 1000)).toISOString(),
+			},
+		});
+
+		expect(setCookieResponse.statusCode).toBe(200);
+
+		const setCookieHeader = setCookieResponse.headers['set-cookie'];
+
+		expect(setCookieHeader).toBeDefined();
+		expect(setCookieHeader).toContain('testCookie=testValue');
+	});
+
+	it('should set a cookie with no expires', async () => {
+		const setCookieResponse = await fastify.inject({
+			method: 'POST',
+			url: '/cookies',
+			payload: {
+				name: 'testCookieNoExpires',
+				value: 'testValueNoExpires',
+			},
+		});
+
+		expect(setCookieResponse.statusCode).toBe(200);
+
+		const setCookieHeader = setCookieResponse.headers['set-cookie'];
+
+		expect(setCookieHeader).toBeDefined();
+		expect(setCookieHeader).toContain('testCookieNoExpires=testValueNoExpires');
+	});
+
+	it('should delete a cookie', async () => {
+		const deleteCookieResponse = await fastify.inject({
+			method: 'DELETE',
+			url: '/cookies',
+			query: {
+				name: 'testCookieToDelete',
+			},
+		});
+
+		expect(deleteCookieResponse.statusCode).toBe(204);
+
+		const deleteCookieHeader = deleteCookieResponse.headers['set-cookie'];
+
+		expect(deleteCookieHeader).toBeDefined();
+		expect(deleteCookieHeader).toContain('testCookieToDelete=; Max-Age=0; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT; SameSite=Lax');
+	});
+});