@planning-inspectorate/dynamic-forms 1.14.0 → 1.15.0

package/test/utils/test-server.js

@@ -0,0 +1,167 @@
+import http from 'http';
+
+const DEFAULT_OPTIONS = {
+	credentials: 'include'
+};
+
+export class TestServer {
+	// Private cookie jar for storing cookies between requests
+	/** @type {Object<string, string>} */
+	#cookieJar = {};
+
+	/**
+	 * @param {import('http').RequestListener} requestListener
+	 * @param {object} [options]
+	 * @param {boolean} [options.rememberCookies] - If true, cookies are stored and sent with each request
+	 */
+	constructor(requestListener, options = {}) {
+		this.requestListener = requestListener;
+		this.server = null;
+		this.port = null;
+		this.rememberCookies = Boolean(options.rememberCookies);
+	}
+
+	/**
+	 * Starts the server on a random port.
+	 * @returns {Promise<void>}
+	 */
+	async start() {
+		if (this.server) return;
+		this.server = http.createServer(this.requestListener);
+		await new Promise((resolve, reject) => {
+			this.server.listen(0, '127.0.0.1');
+			this.server.on('listening', () => {
+				this.port = this.server.address().port;
+				resolve();
+			});
+			this.server.on('error', reject);
+		});
+	}
+
+	/**
+	 * Stops the server.
+	 * @returns {Promise<void>}
+	 */
+	async stop() {
+		if (!this.server) return;
+		await new Promise((resolve, reject) => {
+			this.server.close((err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+		this.server = null;
+		this.port = null;
+	}
+
+	/**
+	 * Performs a GET request to the server.
+	 * @param {string} path
+	 * @param {RequestInit} [options]
+	 * @returns {Promise<Response>}
+	 */
+	async get(path, options = {}) {
+		if (!this.server || !this.port) {
+			throw new Error('Server is not started');
+		}
+		const fetchOptions = { headers: {}, ...DEFAULT_OPTIONS, ...options, method: 'GET' };
+		this.#addCookies(fetchOptions.headers);
+		const response = await fetch(`http://localhost:${this.port}${path}`, fetchOptions);
+		if (this.rememberCookies) {
+			this.#updateCookies(response);
+		}
+		return response;
+	}
+
+	/**
+	 * Performs a GET request to the server, following a maximum number of redirects.
+	 * @param {string} path
+	 * @param {number} maxRedirects
+	 * @param {RequestInit} [options]
+	 * @returns {Promise<Response>}
+	 */
+	async getWithRedirects(path, maxRedirects, options = {}) {
+		if (!this.server || !this.port) {
+			throw new Error('Server is not started');
+		}
+		if (maxRedirects === 0) {
+			// can just use get() directly otherwise
+			throw new Error('maxRedirects must be greater than 0');
+		}
+		let response;
+		let currentPath = path;
+		let numRedirects = 0;
+		while (true) {
+			response = await this.get(currentPath, { ...options, redirect: 'manual' });
+			if (
+				response.status >= 300 &&
+				response.status < 400 &&
+				response.headers.has('location') &&
+				numRedirects < maxRedirects
+			) {
+				currentPath = response.headers.get('location');
+				numRedirects++;
+				continue;
+			}
+			break;
+		}
+		if (this.rememberCookies) {
+			this.#updateCookies(response);
+		}
+		return response;
+	}
+
+	/**
+	 * Performs a POST request to the server.
+	 * @param {string} path
+	 * @param {object} [body]
+	 * @param {RequestInit} [options]
+	 * @returns {Promise<Response>}
+	 */
+	async post(path, body = {}, options = {}) {
+		if (!this.server || !this.port) {
+			throw new Error('Server is not started');
+		}
+		const headers = { 'Content-Type': 'application/json', ...(options.headers || {}) };
+		const fetchOptions = {
+			...DEFAULT_OPTIONS,
+			...options,
+			method: 'POST',
+			headers,
+			body: JSON.stringify(body)
+		};
+		this.#addCookies(fetchOptions.headers);
+		const response = await fetch(`http://localhost:${this.port}${path}`, fetchOptions);
+		if (this.rememberCookies) {
+			this.#updateCookies(response);
+		}
+		return response;
+	}
+
+	#addCookies(headers) {
+		if (!this.rememberCookies) return;
+		if (this.#cookies) {
+			headers.Cookie = this.#cookies;
+		}
+	}
+
+	get #cookies() {
+		return Object.entries(this.#cookieJar)
+			.map(([k, v]) => `${k}=${v}`)
+			.join('; ');
+	}
+
+	/**
+	 * Update the internal cookie jar from a fetch Response
+	 * @param {Response} response
+	 */
+	#updateCookies(response) {
+		const cookies = response.headers.getSetCookie();
+		if (!cookies) return;
+		const cookieKv = cookies.map((c) => c.split(';')[0]);
+		for (const c of cookieKv) {
+			const [k, v] = c.split('=');
+			this.#cookieJar[k] = v;
+		}
+	}
+}

package/test/utils/test-server.test.js

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import express from 'express';
+import cookieParser from 'cookie-parser';
+import { TestServer } from './test-server.js';
+
+// Basic express app for testing
+function createApp() {
+	const app = express();
+	app.use(express.json());
+	app.use(cookieParser());
+
+	app.get('/hello', (req, res) => {
+		res.send('world');
+	});
+
+	app.post('/echo', (req, res) => {
+		res.json(req.body);
+	});
+
+	app.get('/set-cookie', (req, res) => {
+		res.cookie('foo', 'bar');
+		res.send('cookie set');
+	});
+
+	app.get('/check-cookie', (req, res) => {
+		const foo = req.cookies ? req.cookies.foo : undefined;
+		res.json({ foo });
+	});
+
+	return app;
+}
+
+/**
+ * @param {import('node:test').TestContext} ctx
+ * @returns {Promise<TestServer>}
+ */
+async function newTestServer(ctx) {
+	const server = new TestServer(createApp());
+	await server.start();
+	ctx.after(async () => await server.stop());
+	return server;
+}
+
+describe('TestServer', () => {
+	it('should GET /hello', async (ctx) => {
+		const server = await newTestServer(ctx);
+		const res = await server.get('/hello');
+		assert.equal(res.status, 200);
+		const text = await res.text();
+		assert.equal(text, 'world');
+	});
+
+	it('should POST /echo', async (ctx) => {
+		const server = await newTestServer(ctx);
+		const payload = { foo: 'bar' };
+		const res = await server.post('/echo', payload);
+		assert.equal(res.status, 200);
+		const json = await res.json();
+		assert.deepEqual(json, payload);
+	});
+
+	it('should handle cookies', async (ctx) => {
+		const server = await newTestServer(ctx);
+		server.rememberCookies = true;
+		// Set cookie
+		let res = await server.get('/set-cookie');
+		assert.equal(res.status, 200);
+		// Now check cookie is sent back
+		res = await server.get('/check-cookie');
+		assert.equal(res.status, 200);
+		const json = await res.json();
+		assert.equal(json.foo, 'bar');
+	});
+});

package/{src/lib/test-utils.js → test/utils/utils.js}

@@ -1,11 +1,13 @@
-import { mock } from 'node:test';
-import { createRequire } from 'node:module';
-import nunjucks from 'nunjucks';
 import path from 'path';
-import { fileURLToPath } from 'url';
+import { mock } from 'node:test';
+
+export function testDir() {
+	return path.join(path.dirname(new URL(import.meta.url).pathname), '..');
+}
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+export function snapshotsDir() {
+	return path.join(testDir(), 'snapshots');
+}
 
 /**
  * @returns {import('pino').BaseLogger}
@@ -28,7 +30,6 @@ export const mockReq = () => ({
 	params: {},
 	body: {}
 });
-
 export const mockRes = () => {
 	const res = {
 		locals: {},
@@ -43,13 +44,11 @@ export const mockRes = () => {
 	return res;
 };
 
-export function configureNunjucks() {
-	const require = createRequire(import.meta.url);
-	const paths = [
-		// get the path to the govuk-frontend folder, in node_modules, using the node require resolution
-		path.resolve(require.resolve('govuk-frontend'), '../..'),
-		// path to src folder
-		path.join(__dirname, '..')
-	];
-	return nunjucks.configure(paths);
+/**
+ * escapes all RegExp meta-characters in a string
+ * @param {string} s
+ * @returns {string}
+ */
+export function escapeForRegExp(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }

package/test/views/layout-check-your-answers.njk

@@ -0,0 +1 @@
+{% extends "components/task-list/index.njk" %}