@planning-inspectorate/dynamic-forms 3.2.0 → 3.3.1

package/src/middleware/dynamic-req-files-to-req-body-files.test.js

@@ -1,221 +0,0 @@
-import { describe, it, mock, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import dynamicReqFilesToReqBodyFilesMiddleware from './dynamic-req-files-to-req-body-files.js';
-
-describe('dynamic-forms/middleware/dynamic-req-files-to-req-body-files', () => {
-	let counter = 0;
-	let mockReq;
-	let mockRes;
-	let filesPropertyPath = `example-files-property-path-${counter}`;
-
-	const mockgetQuestionByParams = mock.fn(() => {
-		return { fieldName: filesPropertyPath };
-	});
-
-	beforeEach(() => {
-		mockReq = () => ({
-			cookies: {},
-			log: {},
-			params: {}
-		});
-
-		mockRes = () => ({
-			clearCookie: mock.fn(),
-			cookie: mock.fn(),
-			locals: {
-				journeyResponse: mock.fn(),
-				journey: { getQuestionByParams: mockgetQuestionByParams }
-			},
-			redirect: mock.fn(),
-			render: mock.fn(),
-			sendStatus: mock.fn(),
-			status: mock.fn()
-		});
-
-		counter++;
-		filesPropertyPath = `example-files-property-path-${counter}`;
-	});
-
-	[
-		{
-			description: 'should return early if `req.body` is not set',
-			given: () => mockReq(),
-			expected: (req, res, next) => {
-				assert.strictEqual(req.body, undefined);
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description: 'should return early if `req.files` is not set',
-			given: () => ({
-				...mockReq(),
-				body: {}
-			}),
-			expected: (req, res, next) => {
-				assert.strictEqual(req.body.files, undefined);
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description: 'should return early if `req.params` is not set',
-			given: () => ({
-				cookies: {},
-				log: {},
-				body: {},
-				files: {}
-			}),
-			expected: (req, res, next) => {
-				assert.strictEqual(req.body.files, undefined);
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description:
-				'should set `req.body.files = []` if unable to find the given file property path `req.files` - unset',
-			given: () => ({
-				...mockReq(),
-				body: {},
-				files: {},
-				params: {
-					section: 'mock-section',
-					question: 'mock-question'
-				}
-			}),
-			expected: (req, res, next) => {
-				assert.deepStrictEqual(req.body.files, []);
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description:
-				'should set `req.body.files = []` if unable to find the given file property path `req.files` - wrong path',
-			given: () => ({
-				...mockReq(),
-				body: {},
-				files: {
-					'some-different-path': {
-						x: 'y'
-					}
-				},
-				params: {
-					section: 'mock-section',
-					question: 'mock-question'
-				}
-			}),
-			expected: (req, res, next) => {
-				assert.deepStrictEqual(req.body.files, []);
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description: 'should set `req.body.files = [req.files]` when given a single file',
-			given: () => ({
-				...mockReq(),
-				body: {},
-				params: {
-					section: 'mock-section',
-					question: 'mock-question'
-				},
-				files: {
-					[filesPropertyPath]: {
-						a: 'b'
-					}
-				}
-			}),
-			expected: (req, res, next) => {
-				assert.deepStrictEqual(req.body.files, { [filesPropertyPath]: [{ a: 'b' }] });
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description: 'should set `req.body.files = [...req.files]` when given multiple files',
-			given: () => ({
-				...mockReq(),
-				body: {},
-				params: {
-					section: 'mock-section',
-					question: 'mock-question'
-				},
-				files: {
-					[filesPropertyPath]: [
-						{
-							a: 'b'
-						},
-						{
-							c: 'd'
-						}
-					]
-				}
-			}),
-			expected: (req, res, next) => {
-				assert.deepStrictEqual(req.body.files, {
-					[filesPropertyPath]: [
-						{
-							a: 'b'
-						},
-						{
-							c: 'd'
-						}
-					]
-				});
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		},
-		{
-			description: 'should retain existing req.body.files when working with a different key',
-			given: () => ({
-				...mockReq(),
-				body: {
-					files: {
-						'an-existing-key-value-pair': [
-							{
-								rgb: 'xyz'
-							}
-						]
-					}
-				},
-				files: {
-					[filesPropertyPath]: [
-						{
-							a: 'b'
-						},
-						{
-							c: 'd'
-						}
-					]
-				},
-				params: {
-					section: 'mock-section',
-					question: 'mock-question'
-				}
-			}),
-			expected: (req, res, next) => {
-				assert.deepStrictEqual(req.body.files, {
-					'an-existing-key-value-pair': [
-						{
-							rgb: 'xyz'
-						}
-					],
-					[filesPropertyPath]: [
-						{
-							a: 'b'
-						},
-						{
-							c: 'd'
-						}
-					]
-				});
-				assert.strictEqual(next.mock.callCount(), 1);
-			}
-		}
-	].forEach(({ description, given, expected }) => {
-		it(description, () => {
-			const next = mock.fn();
-			const req = given();
-
-			dynamicReqFilesToReqBodyFilesMiddleware()(req, mockRes(), next);
-
-			expected(req, mockRes(), next);
-		});
-	});
-});

package/src/validator/required-file-upload-validator.js

@@ -1,38 +0,0 @@
-import BaseValidator from './base-validator.js';
-import { checkSchema } from 'express-validator';
-
-import requiredFileUploadSchema from './schemas/required-file-upload-schema.js';
-
-/**
- * @typedef {import('../questions/question.js')} Question
- */
-
-/**
- * enforces that at least one file is present for a question, whether it is being/already uploaded
- * @class
- */
-export default class RequiredFileUploadValidator extends BaseValidator {
-	/**
-	 * creates an instance of a RequiredFileUploadValidator
-	 * @param {string} [errorMessage] - custom error message to show on validation failure
-	 */
-	constructor(errorMessage) {
-		super();
-
-		if (errorMessage) {
-			this.errorMessage = errorMessage;
-		} else {
-			this.errorMessage = 'You must add your documents';
-		}
-	}
-
-	/**
-	 * validates against path based on questionObj's fieldname
-	 * @param {Question} questionObj
-	 */
-	validate(questionObj, journeyResponse) {
-		const path = questionObj.fieldName;
-		const documentType = questionObj.documentType.name;
-		return checkSchema(requiredFileUploadSchema(path, journeyResponse, documentType, this.errorMessage))[0];
-	}
-}

package/src/validator/required-file-upload-validator.test.js

@@ -1,141 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import RequiredFileUploadValidator from './required-file-upload-validator.js';
-
-describe('./src/dynamic-forms/validator/required-file-upload-validator.js', () => {
-	describe('validate', () => {
-		it('should have a rule for path featuring fieldName', () => {
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-
-			const rule = requiredFileUploadValidator
-				.validate({
-					fieldName: 'test-field-name',
-					documentType: {
-						name: 'test-doc-type'
-					}
-				})
-				.builder.build();
-
-			assert.deepStrictEqual(rule.fields, ['test-field-name']);
-			assert.strictEqual(!!rule.optional, false);
-			assert.strictEqual(rule.stack.length, 1);
-			assert.strictEqual(rule.stack[0].validator.name, 'options');
-			assert.strictEqual(!!rule.stack[0].validator.negated, false);
-		});
-
-		it('should pass if file being uploaded', async () => {
-			const questionObj = {
-				fieldName: 'test-fieldname',
-				documentType: {
-					name: 'test-doc-type'
-				}
-			};
-			const journeyResponse = {};
-			const req = { files: { test: 'test123' } };
-
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-			const validationResult = await requiredFileUploadValidator.validate(questionObj, journeyResponse).run(req);
-
-			assert.strictEqual(validationResult.errors.length, 0);
-		});
-
-		it('should pass if no file being uploaded and file matching question document type already uploaded', async () => {
-			const questionObj = {
-				fieldName: 'another-test-fieldname',
-				documentType: {
-					name: 'test-doc-type'
-				}
-			};
-			const uploadedFile = {
-				file: 'already-uploaded',
-				type: 'test-doc-type'
-			};
-			const journeyResponse = {
-				answers: { SubmissionDocumentUpload: [uploadedFile] }
-			};
-			const req = { body: {} };
-
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-			const validationResult = await requiredFileUploadValidator.validate(questionObj, journeyResponse).run(req);
-
-			assert.strictEqual(validationResult.errors.length, 0);
-		});
-
-		it('should fail if no file being uploaded and no file matching question document type already uploaded', async () => {
-			const questionObj = {
-				fieldName: 'yet-another-test-fieldname',
-				documentType: {
-					name: 'test-doc-type'
-				}
-			};
-			const journeyResponse = { answers: { SubmissionDocumentUpload: [] } };
-			const req = { body: {} };
-
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-			const validationResult = await requiredFileUploadValidator.validate(questionObj, journeyResponse).run(req);
-
-			assert.strictEqual(validationResult.errors.length, 1);
-		});
-
-		it('should fail if no file being uploaded matching question doc type and all existing files matching doc type being removed', async () => {
-			const questionObj = {
-				fieldName: 'test-fieldname',
-				documentType: {
-					name: 'test-doc-type'
-				}
-			};
-
-			const journeyResponse = {
-				answers: {
-					SubmissionDocumentUpload: [
-						{
-							file: 'to-be-removed',
-							type: 'test-doc-type'
-						},
-						{
-							file: 'to-be-removed-too',
-							type: 'test-doc-type'
-						}
-					]
-				}
-			};
-			const req = { body: {} };
-			req.body.removedFiles =
-				'[{"file": "to-be-removed", "type": "test-doc-type"}, {"file": "to-be-removed-too", "type": "test-doc-type"}]';
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-			const validationResult = await requiredFileUploadValidator.validate(questionObj, journeyResponse).run(req);
-
-			assert.strictEqual(validationResult.errors.length, 1);
-		});
-
-		it('should pass if existing files matching question doc type and only some being removed', async () => {
-			const questionObj = {
-				fieldName: 'test-fieldname',
-				documentType: {
-					name: 'test-doc-type'
-				}
-			};
-			const journeyResponse = {
-				answers: {
-					SubmissionDocumentUpload: [
-						{
-							file: 'to-be-removed',
-							type: 'test-doc-type'
-						},
-						{
-							file: 'to-be-kept',
-							type: 'test-doc-type'
-						}
-					]
-				}
-			};
-			const req = { body: {} };
-			req.body.removedFiles = '[{"file": "to-be-removed", "type": "test-doc-type"}]';
-
-			const requiredFileUploadValidator = new RequiredFileUploadValidator();
-			const validationResult = await requiredFileUploadValidator.validate(questionObj, journeyResponse).run(req);
-
-			assert.strictEqual(validationResult.errors.length, 0);
-		});
-	});
-});

package/src/validator/schemas/required-file-upload-schema.js

@@ -1,35 +0,0 @@
-const schema = (path, journeyResponse, documentType, errorMsg = 'Select a file to upload') => ({
-	[path]: {
-		custom: {
-			options: async (value, { req }) => {
-				if (!req.files) {
-					const uploadedFiles = journeyResponse.answers.SubmissionDocumentUpload || [];
-
-					const relevantUploadedFiles = uploadedFiles.filter((upload) => upload.type === documentType);
-
-					if (relevantUploadedFiles) {
-						//at this stage, uploadedFiles will still contain any files flagged for removal
-						//so we need to disregard them when checking uploadedFiles
-						let removedFiles = [];
-
-						if ('removedFiles' in req.body) {
-							removedFiles = JSON.parse(req.body.removedFiles) || [];
-						}
-
-						if (relevantUploadedFiles.length - removedFiles.length < 1) {
-							throw new Error(errorMsg);
-						}
-
-						return true;
-					}
-
-					throw new Error(errorMsg);
-				}
-
-				return true;
-			}
-		}
-	}
-});
-
-export default schema;