first commit

packages/nodes-base/nodes/Form/test/Form.node.test.ts

@@ -0,0 +1,538 @@
+import type { Response, Request } from 'express';
+import type { MockProxy } from 'jest-mock-extended';
+import { mock } from 'jest-mock-extended';
+import type {
+	IExecuteFunctions,
+	INode,
+	INodeExecutionData,
+	IWebhookFunctions,
+	IWorkflowSettings,
+	NodeTypeAndVersion,
+} from 'n8n-workflow';
+
+import { Form } from '../Form.node';
+
+jest.mock('../../../utils/sendAndWait/configureWaitTillDate.util', () => ({
+	configureWaitTillDate: jest.fn(), // Mocked function
+}));
+
+describe('Form Node', () => {
+	let form: Form;
+	let mockExecuteFunctions: MockProxy<IExecuteFunctions>;
+	let mockWebhookFunctions: MockProxy<IWebhookFunctions>;
+
+	const formCompletionNodeName = 'Form Completion';
+	const testExecutionId = 'test_execution_id';
+	beforeEach(() => {
+		form = new Form();
+		mockExecuteFunctions = mock<IExecuteFunctions>();
+		mockWebhookFunctions = mock<IWebhookFunctions>();
+
+		mockExecuteFunctions.getWorkflowSettings.mockReturnValue(mock<IWorkflowSettings>({}));
+		mockWebhookFunctions.getWorkflowSettings.mockReturnValue(mock<IWorkflowSettings>({}));
+	});
+
+	describe('execute method', () => {
+		it('should throw an error if Form Trigger node is not set', async () => {
+			mockExecuteFunctions.getNodeParameter.mockReturnValue('page');
+			mockExecuteFunctions.getParentNodes.mockReturnValue([]);
+			mockExecuteFunctions.getNode.mockReturnValue(mock<INode>());
+
+			await expect(form.execute(mockExecuteFunctions)).rejects.toThrow(
+				'Form Trigger node must be set before this node',
+			);
+		});
+
+		it('should put execution to wait if operation is not completion', async () => {
+			mockExecuteFunctions.getNodeParameter.mockReturnValue('page');
+			mockExecuteFunctions.getParentNodes.mockReturnValue([
+				mock<NodeTypeAndVersion>({ type: 'n8n-nodes-base.formTrigger' }),
+			]);
+			mockExecuteFunctions.getChildNodes.mockReturnValue([]);
+			mockExecuteFunctions.getNode.mockReturnValue(mock<INode>());
+
+			await form.execute(mockExecuteFunctions);
+
+			expect(mockExecuteFunctions.putExecutionToWait).toHaveBeenCalled();
+		});
+
+		it('should throw an error if completion is not the last Form node', async () => {
+			mockExecuteFunctions.getNodeParameter.mockReturnValue('completion');
+			mockExecuteFunctions.getParentNodes.mockReturnValue([
+				mock<NodeTypeAndVersion>({ type: 'n8n-nodes-base.formTrigger' }),
+			]);
+			mockExecuteFunctions.getChildNodes.mockReturnValue([
+				mock<NodeTypeAndVersion>({ type: 'n8n-nodes-base.form' }),
+			]);
+			mockExecuteFunctions.getNode.mockReturnValue(mock<INode>());
+
+			await expect(form.execute(mockExecuteFunctions)).rejects.toThrow(
+				'Completion has to be the last Form node in the workflow',
+			);
+		});
+
+		it('should return input data for completion operation', async () => {
+			const inputData: INodeExecutionData[] = [{ json: { test: 'data' } }];
+			mockExecuteFunctions.getNodeParameter.mockReturnValue('completion');
+			mockExecuteFunctions.getParentNodes.mockReturnValue([
+				mock<NodeTypeAndVersion>({ type: 'n8n-nodes-base.formTrigger' }),
+			]);
+			mockExecuteFunctions.getChildNodes.mockReturnValue([]);
+			mockExecuteFunctions.getInputData.mockReturnValue(inputData);
+			mockExecuteFunctions.getNode.mockReturnValue(mock<INode>({ name: formCompletionNodeName }));
+			mockExecuteFunctions.getExecutionId.mockReturnValue(testExecutionId);
+
+			mockExecuteFunctions.getWorkflowStaticData.mockReturnValue({
+				[`${testExecutionId}-${formCompletionNodeName}`]: { redirectUrl: 'test' },
+			});
+
+			const result = await form.execute(mockExecuteFunctions);
+
+			expect(result).toEqual([inputData]);
+		});
+	});
+
+	describe('webhook method', () => {
+		it('should render form for GET request', async () => {
+			const mockResponseObject = {
+				render: jest.fn(),
+				setHeader: jest.fn(),
+			};
+			mockWebhookFunctions.getResponseObject.mockReturnValue(
+				mockResponseObject as unknown as Response,
+			);
+			mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+			mockWebhookFunctions.getParentNodes.mockReturnValue([
+				{
+					type: 'n8n-nodes-base.formTrigger',
+					name: 'Form Trigger',
+					typeVersion: 2.1,
+					disabled: false,
+				},
+			]);
+			mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+			mockWebhookFunctions.getNode.mockReturnValue(mock<INode>());
+			mockWebhookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				if (paramName === 'operation') return 'page';
+				if (paramName === 'useJson') return false;
+				if (paramName === 'formFields.values')
+					return [
+						{ fieldLabel: 'test' },
+						{
+							fieldName: 'Powerpuff Girl',
+							fieldValue: 'Blossom',
+							fieldType: 'hiddenField',
+							fieldLabel: '',
+						},
+					];
+				if (paramName === 'options') {
+					return {
+						formTitle: 'Form Title',
+						formDescription: 'Form Description',
+						buttonLabel: 'Form Button',
+					};
+				}
+				return undefined;
+			});
+
+			mockWebhookFunctions.getChildNodes.mockReturnValue([]);
+
+			await form.webhook(mockWebhookFunctions);
+
+			expect(mockResponseObject.render).toHaveBeenCalledWith('form-trigger', {
+				appendAttribution: 'test',
+				buttonLabel: 'Form Button',
+				formDescription: 'Form Description',
+				formDescriptionMetadata: 'Form Description',
+				formFields: [
+					{
+						id: 'field-0',
+						errorId: 'error-field-0',
+						label: 'test',
+						inputRequired: '',
+						defaultValue: '',
+						isInput: true,
+						placeholder: undefined,
+						type: undefined,
+					},
+					{
+						id: 'field-1',
+						errorId: 'error-field-1',
+						label: 'Powerpuff Girl',
+						inputRequired: '',
+						defaultValue: '',
+						placeholder: undefined,
+						hiddenName: 'Powerpuff Girl',
+						hiddenValue: 'Blossom',
+						isHidden: true,
+					},
+				],
+				formSubmittedText: 'Your response has been recorded',
+				formTitle: 'Form Title',
+				n8nWebsiteLink: 'https://n8n.io/?utm_source=n8n-internal&utm_medium=form-trigger',
+				testRun: true,
+				useResponseData: true,
+				formSubmittedHeader: undefined,
+			});
+		});
+
+		it('should return form data for POST request', async () => {
+			mockWebhookFunctions.getRequestObject.mockReturnValue({
+				method: 'POST',
+				contentType: 'multipart/form-data',
+			} as Request);
+			mockWebhookFunctions.getParentNodes.mockReturnValue([
+				{
+					type: 'n8n-nodes-base.formTrigger',
+					name: 'Form Trigger',
+					typeVersion: 2.1,
+					disabled: false,
+				},
+			]);
+			mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+			mockWebhookFunctions.getNode.mockReturnValue(mock<INode>());
+			mockWebhookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				if (paramName === 'operation') return 'page';
+				if (paramName === 'useJson') return false;
+				if (paramName === 'formFields.values') return [{ fieldLabel: 'test' }];
+				if (paramName === 'options') {
+					return {
+						formTitle: 'Form Title',
+						formDescription: 'Form Description',
+						buttonLabel: 'Form Button',
+					};
+				}
+				return undefined;
+			});
+
+			mockWebhookFunctions.getBodyData.mockReturnValue({
+				data: { 'field-0': 'test value' },
+				files: {},
+			});
+
+			const result = await form.webhook(mockWebhookFunctions);
+
+			expect(result).toHaveProperty('webhookResponse');
+			expect(result).toHaveProperty('workflowData');
+			expect(result.workflowData).toEqual([
+				[
+					{
+						json: expect.objectContaining({
+							formMode: 'test',
+							submittedAt: expect.any(String),
+							test: 'test value',
+						}),
+					},
+				],
+			]);
+		});
+
+		it('should handle completion operation and render completion page', async () => {
+			const formExpected = [
+				{
+					formParam: {
+						responseText: '',
+					},
+					expected: {
+						appendAttribution: 'test',
+						formTitle: 'test',
+						message: 'Test Message',
+						redirectUrl: undefined,
+						title: 'Test Title',
+						responseBinary: encodeURIComponent(JSON.stringify('')),
+						responseText: '',
+						dangerousCustomCss: undefined,
+					},
+				},
+				{
+					formParam: {
+						responseText: '<div>hey</div><script>alert("hi")</script>',
+					},
+					expected: {
+						appendAttribution: 'test',
+						formTitle: 'test',
+						message: 'Test Message',
+						redirectUrl: undefined,
+						title: 'Test Title',
+						responseText: '<div>hey</div><script>alert("hi")</script>',
+						responseBinary: encodeURIComponent(JSON.stringify('')),
+						dangerousCustomCss: undefined,
+					},
+				},
+				{
+					formParam: {
+						responseText: 'my text over here',
+					},
+					expected: {
+						appendAttribution: 'test',
+						formTitle: 'test',
+						message: 'Test Message',
+						redirectUrl: undefined,
+						responseBinary: encodeURIComponent(JSON.stringify('')),
+						title: 'Test Title',
+						responseText: 'my text over here',
+						dangerousCustomCss: undefined,
+					},
+				},
+			];
+
+			for (const { formParam, expected } of formExpected) {
+				mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+				mockWebhookFunctions.getNodeParameter.mockImplementation((paramName) => {
+					if (paramName === 'operation') return 'completion';
+					if (paramName === 'useJson') return false;
+					if (paramName === 'jsonOutput') return '[]';
+					if (paramName === 'respondWith') return 'text';
+					if (paramName === 'completionTitle') return 'Test Title';
+					if (paramName === 'completionMessage') return 'Test Message';
+					if (paramName === 'redirectUrl') return '';
+					if (paramName === 'formFields.values') return [];
+					if (paramName === 'responseText') return formParam.responseText;
+					return {};
+				});
+				mockWebhookFunctions.getParentNodes.mockReturnValue([
+					{
+						type: 'n8n-nodes-base.formTrigger',
+						name: 'Form Trigger',
+						typeVersion: 2.1,
+						disabled: false,
+					},
+				]);
+				mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+
+				const mockResponseObject = {
+					render: jest.fn(),
+					redirect: jest.fn(),
+					setHeader: jest.fn(),
+				};
+				mockWebhookFunctions.getResponseObject.mockReturnValue(
+					mockResponseObject as unknown as Response,
+				);
+				mockWebhookFunctions.getNode.mockReturnValue(mock<INode>({ name: formCompletionNodeName }));
+				mockWebhookFunctions.getExecutionId.mockReturnValue(testExecutionId);
+
+				const result = await form.webhook(mockWebhookFunctions);
+
+				expect(result).toEqual({ noWebhookResponse: true });
+				expect(mockResponseObject.render).toHaveBeenCalledWith('form-trigger-completion', {
+					...expected,
+				});
+			}
+		});
+
+		it('should pass customCss to form template', async () => {
+			const mockResponseObject = {
+				render: jest.fn(),
+				setHeader: jest.fn(),
+			};
+			mockWebhookFunctions.getResponseObject.mockReturnValue(
+				mockResponseObject as unknown as Response,
+			);
+			mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+			mockWebhookFunctions.getParentNodes.mockReturnValue([
+				{
+					type: 'n8n-nodes-base.formTrigger',
+					name: 'Form Trigger',
+					typeVersion: 2.1,
+					disabled: false,
+				},
+			]);
+			mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+			mockWebhookFunctions.getNode.mockReturnValue(mock<INode>());
+			mockWebhookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+				if (paramName === 'operation') return 'page';
+				if (paramName === 'formFields.values') return [];
+				if (paramName === 'options') {
+					return {
+						customCss: '.form-container { background-color: #f5f5f5; }',
+					};
+				}
+				return undefined;
+			});
+
+			mockWebhookFunctions.getChildNodes.mockReturnValue([]);
+
+			await form.webhook(mockWebhookFunctions);
+
+			expect(mockResponseObject.render).toHaveBeenCalledWith(
+				'form-trigger',
+				expect.objectContaining({
+					dangerousCustomCss: '.form-container { background-color: #f5f5f5; }',
+				}),
+			);
+		});
+
+		it('should pass customCss to form completion template', async () => {
+			mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+			mockWebhookFunctions.getNodeParameter.mockImplementation((paramName) => {
+				if (paramName === 'operation') return 'completion';
+				if (paramName === 'respondWith') return 'text';
+				if (paramName === 'completionTitle') return 'Completion Title';
+				if (paramName === 'completionMessage') return 'Completion Message';
+				if (paramName === 'redirectUrl') return '';
+				if (paramName === 'responseText') return '';
+				if (paramName === 'options')
+					return {
+						customCss: '.completion-container { color: blue; }',
+					};
+				if (paramName === 'formFields.values') return [];
+				return {};
+			});
+			mockWebhookFunctions.getParentNodes.mockReturnValue([
+				{
+					type: 'n8n-nodes-base.formTrigger',
+					name: 'Form Trigger',
+					typeVersion: 2.1,
+					disabled: false,
+				},
+			]);
+			mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+
+			const mockResponseObject = {
+				render: jest.fn(),
+				setHeader: jest.fn(),
+			};
+			mockWebhookFunctions.getResponseObject.mockReturnValue(
+				mockResponseObject as unknown as Response,
+			);
+			mockWebhookFunctions.getNode.mockReturnValue(mock<INode>());
+
+			const result = await form.webhook(mockWebhookFunctions);
+
+			expect(result).toEqual({ noWebhookResponse: true });
+			expect(mockResponseObject.render).toHaveBeenCalledWith(
+				'form-trigger-completion',
+				expect.objectContaining({
+					dangerousCustomCss: '.completion-container { color: blue; }',
+				}),
+			);
+		});
+
+		it.each(['json', 'fields'])(
+			'should evaluate expressions only once in %s mode, preserving nested braces',
+			async (defineForm) => {
+				const formFields = [
+					{
+						fieldLabel: 'Custom HTML',
+						fieldType: 'html',
+						elementName: 'test',
+						html: '<h2>Hello {{ $json.world }} </h2>',
+					},
+				];
+
+				const mockResponseObject = {
+					render: jest.fn(),
+					setHeader: jest.fn(),
+				};
+				mockWebhookFunctions.getResponseObject.mockReturnValue(
+					mockResponseObject as unknown as Response,
+				);
+				mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+				mockWebhookFunctions.getParentNodes.mockReturnValue([
+					{
+						type: 'n8n-nodes-base.formTrigger',
+						name: 'Form Trigger',
+						typeVersion: 2.1,
+						disabled: false,
+					},
+				]);
+				mockWebhookFunctions.evaluateExpression.mockImplementation((expression: string) => {
+					console.log('expression', expression);
+					if (expression.includes('formMode')) {
+						return 'test';
+					}
+					if (expression === '{{ $json.world }}') {
+						return "{{ 'World' }}";
+					}
+					if (expression === "{{ 'World' }}") {
+						fail('Should not be called');
+					}
+					return expression;
+				});
+				mockWebhookFunctions.getNode.mockReturnValue(mock<INode>());
+				mockWebhookFunctions.getNodeParameter.mockImplementation((paramName: string) => {
+					if (paramName === 'operation') return 'page';
+					if (paramName === 'defineForm') return defineForm;
+					if (paramName === 'jsonOutput') return `=${JSON.stringify(formFields)}`;
+					if (paramName === 'formFields.values') return formFields;
+					if (paramName === 'options') {
+						return {
+							formTitle: 'Form Title',
+							formDescription: 'Form Description',
+							buttonLabel: 'Form Button',
+						};
+					}
+					return undefined;
+				});
+
+				mockWebhookFunctions.getChildNodes.mockReturnValue([]);
+
+				await form.webhook(mockWebhookFunctions);
+
+				expect(mockWebhookFunctions.evaluateExpression).not.toHaveBeenCalledWith("{{ 'World' }}");
+				expect(mockResponseObject.render).toHaveBeenCalledWith(
+					'form-trigger',
+					expect.objectContaining({
+						formFields: expect.arrayContaining([
+							expect.objectContaining({
+								html: "<h2>Hello {{ 'World' }} </h2>",
+							}),
+						]),
+					}),
+				);
+			},
+		);
+	});
+
+	describe('webhook method - completion and redirect', () => {
+		it('should handle completion operation and redirect', async () => {
+			mockWebhookFunctions.getRequestObject.mockReturnValue({ method: 'GET' } as Request);
+			mockWebhookFunctions.getNodeParameter.mockImplementation((paramName) => {
+				if (paramName === 'operation') return 'completion';
+				if (paramName === 'useJson') return false;
+				if (paramName === 'jsonOutput') return '[]';
+				if (paramName === 'respondWith') return 'text';
+				if (paramName === 'completionTitle') return 'Test Title';
+				if (paramName === 'completionMessage') return 'Test Message';
+				if (paramName === 'redirectUrl') return 'https://n8n.io';
+				if (paramName === 'formFields.values') return [];
+				if (paramName === 'responseText') return '';
+
+				return {};
+			});
+			mockWebhookFunctions.getParentNodes.mockReturnValue([
+				{
+					type: 'n8n-nodes-base.formTrigger',
+					name: 'Form Trigger',
+					typeVersion: 2.1,
+					disabled: false,
+				},
+			]);
+			mockWebhookFunctions.evaluateExpression.mockReturnValue('test');
+
+			const mockResponseObject = {
+				render: jest.fn(),
+				redirect: jest.fn(),
+				send: jest.fn(),
+				setHeader: jest.fn(),
+			};
+			mockWebhookFunctions.getResponseObject.mockReturnValue(
+				mockResponseObject as unknown as Response,
+			);
+			mockWebhookFunctions.getNode.mockReturnValue(mock<INode>({ name: formCompletionNodeName }));
+
+			const result = await form.webhook(mockWebhookFunctions);
+
+			expect(result).toEqual({ noWebhookResponse: true });
+			expect(mockResponseObject.render).toHaveBeenCalledWith('form-trigger-completion', {
+				appendAttribution: 'test',
+				formTitle: 'test',
+				message: 'Test Message',
+				redirectUrl: 'https://n8n.io',
+				responseText: '',
+				title: 'Test Title',
+				responseBinary: encodeURIComponent(JSON.stringify('')),
+			});
+		});
+	});
+});

packages/nodes-base/nodes/Form/test/FormTriggerV2.node.test.ts

@@ -0,0 +1,421 @@
+import crypto from 'crypto';
+import { mock } from 'jest-mock-extended';
+import { NodeOperationError, type INode } from 'n8n-workflow';
+
+import { testVersionedWebhookTriggerNode } from '@test/nodes/TriggerHelpers';
+
+import { FormTrigger } from '../FormTrigger.node';
+
+describe('FormTrigger', () => {
+	beforeEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should render a form template with correct fields', async () => {
+		const formFields = [
+			{ fieldLabel: 'Name', fieldType: 'text', requiredField: true },
+			{ fieldLabel: 'Age', fieldType: 'number', requiredField: false },
+			{ fieldLabel: 'Notes', fieldType: 'textarea', requiredField: false },
+			{
+				fieldLabel: 'Gender',
+				fieldType: 'select',
+				requiredField: true,
+				fieldOptions: { values: [{ option: 'Male' }, { option: 'Female' }] },
+			},
+			{
+				fieldLabel: 'Resume',
+				fieldType: 'file',
+				requiredField: true,
+				acceptFileTypes: '.pdf,.doc',
+				multipleFiles: false,
+			},
+		];
+
+		const { response, responseData } = await testVersionedWebhookTriggerNode(FormTrigger, 2, {
+			mode: 'manual',
+			node: {
+				parameters: {
+					formTitle: 'Test Form',
+					formDescription: 'Test Description',
+					responseMode: 'onReceived',
+					authentication: 'none',
+					formFields: { values: formFields },
+					options: {
+						appendAttribution: false,
+						respondWithOptions: { values: { respondWith: 'text' } },
+					},
+				},
+			},
+		});
+
+		expect(response.render).toHaveBeenCalledWith('form-trigger', {
+			appendAttribution: false,
+			buttonLabel: 'Submit',
+			formDescription: 'Test Description',
+			formDescriptionMetadata: 'Test Description',
+			formFields: [
+				{
+					defaultValue: '',
+					errorId: 'error-field-0',
+					id: 'field-0',
+					inputRequired: 'form-required',
+					isInput: true,
+					label: 'Name',
+					placeholder: undefined,
+					type: 'text',
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-1',
+					id: 'field-1',
+					inputRequired: '',
+					isInput: true,
+					label: 'Age',
+					placeholder: undefined,
+					type: 'number',
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-2',
+					id: 'field-2',
+					inputRequired: '',
+					label: 'Notes',
+					placeholder: undefined,
+					isTextarea: true,
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-3',
+					id: 'field-3',
+					inputRequired: 'form-required',
+					isInput: true,
+					label: 'Gender',
+					placeholder: undefined,
+					type: 'select',
+				},
+				{
+					acceptFileTypes: '.pdf,.doc',
+					defaultValue: '',
+					errorId: 'error-field-4',
+					id: 'field-4',
+					inputRequired: 'form-required',
+					isFileInput: true,
+					label: 'Resume',
+					multipleFiles: '',
+					placeholder: undefined,
+				},
+			],
+			formSubmittedText: 'Your response has been recorded',
+			formTitle: 'Test Form',
+			n8nWebsiteLink:
+				'https://n8n.io/?utm_source=n8n-internal&utm_medium=form-trigger&utm_campaign=instanceId',
+			testRun: true,
+			useResponseData: false,
+		});
+
+		expect(responseData).toEqual({ noWebhookResponse: true });
+	});
+
+	it('should return workflowData on POST request', async () => {
+		const formFields = [
+			{ fieldLabel: 'Name', fieldType: 'text', requiredField: true },
+			{ fieldLabel: 'Age', fieldType: 'number', requiredField: false },
+			{ fieldLabel: 'Date', fieldType: 'date', formatDate: 'dd MMM', requiredField: false },
+			{ fieldLabel: 'Empty', fieldType: 'number', requiredField: false },
+			{
+				fieldLabel: 'Tags',
+				fieldType: 'select',
+				multiselect: true,
+				requiredField: false,
+				fieldOptions: { values: [{ option: 'Popular' }, { option: 'Recent' }] },
+			},
+		];
+
+		const bodyData = {
+			data: {
+				'field-0': 'John Doe',
+				'field-1': '30',
+				'field-2': '2024-08-31',
+				'field-4': '{}',
+			},
+		};
+
+		const { responseData } = await testVersionedWebhookTriggerNode(FormTrigger, 2, {
+			mode: 'manual',
+			node: {
+				parameters: {
+					formTitle: 'Test Form',
+					formDescription: 'Test Description',
+					responseMode: 'onReceived',
+					authentication: 'none',
+					formFields: { values: formFields },
+				},
+			},
+			request: {
+				method: 'POST',
+				headers: { 'content-type': 'multipart/form-data' },
+				contentType: 'multipart/form-data',
+			},
+			bodyData,
+		});
+
+		expect(responseData).toEqual({
+			webhookResponse: { status: 200 },
+			workflowData: [
+				[
+					{
+						json: {
+							Name: 'John Doe',
+							Age: 30,
+							Date: '31 Jan',
+							Empty: null,
+							Tags: {},
+							submittedAt: expect.any(String),
+							formMode: 'test',
+						},
+					},
+				],
+			],
+		});
+	});
+
+	describe('Respond to Webhook', () => {
+		it('should throw when misconfigured', async () => {
+			await expect(
+				testVersionedWebhookTriggerNode(FormTrigger, 2, {
+					node: {
+						parameters: {
+							responseMode: 'responseNode',
+						},
+					},
+					request: { method: 'POST' },
+					childNodes: [],
+				}),
+			).rejects.toEqual(
+				new NodeOperationError(mock<INode>(), 'No Respond to Webhook node found in the workflow'),
+			);
+
+			await expect(
+				testVersionedWebhookTriggerNode(FormTrigger, 2.1, {
+					node: {
+						typeVersion: 2.1,
+						parameters: {
+							responseMode: 'onReceived',
+						},
+					},
+					request: { method: 'POST' },
+					childNodes: [
+						{
+							name: 'Test Respond To Webhook',
+							type: 'n8n-nodes-base.respondToWebhook',
+							typeVersion: 1,
+							disabled: false,
+						},
+					],
+				}),
+			).rejects.toEqual(
+				new NodeOperationError(
+					mock<INode>(),
+					'Unused Respond to Webhook node found in the workflow',
+				),
+			);
+		});
+	});
+
+	it('webhook execution not successful when token is invalid', async () => {
+		const formFields = [
+			{ fieldLabel: 'Name', fieldType: 'text', requiredField: true },
+			{ fieldLabel: 'Age', fieldType: 'number', requiredField: false },
+		];
+
+		const { responseData } = await testVersionedWebhookTriggerNode(FormTrigger, 2, {
+			mode: 'manual',
+			node: {
+				parameters: {
+					formTitle: 'Test Form',
+					formDescription: 'Test Description',
+					responseMode: 'onReceived',
+					formFields: { values: formFields },
+					authentication: 'basicAuth',
+				},
+			},
+			request: { method: 'POST', query: {}, headers: {} },
+			credential: {
+				user: 'testuser',
+				password: 'testpass',
+			},
+		});
+
+		expect(responseData).toEqual({ noWebhookResponse: true });
+	});
+
+	it('should validate POST requests with correct authentication token', async () => {
+		const formFields = [
+			{ fieldLabel: 'Name', fieldType: 'text', requiredField: true },
+			{ fieldLabel: 'Age', fieldType: 'number', requiredField: false },
+		];
+
+		const nodeId = 'test-node-id';
+		const webhookId = 'test-webhook-id';
+		const credentials = { user: 'testuser', password: 'testpass' };
+
+		const token = crypto
+			.createHmac('sha256', `${credentials.user}:${credentials.password}`)
+			.update(`${nodeId}-${webhookId}`)
+			.digest('hex');
+
+		const bodyData = {
+			data: {
+				'field-0': 'John Doe',
+				'field-1': '30',
+			},
+		};
+
+		const { responseData } = await testVersionedWebhookTriggerNode(FormTrigger, 2, {
+			mode: 'manual',
+			node: {
+				id: nodeId,
+				webhookId,
+				parameters: {
+					formTitle: 'Test Form',
+					formDescription: 'Test Description',
+					responseMode: 'onReceived',
+					formFields: { values: formFields },
+					authentication: 'basicAuth',
+				},
+			},
+			request: {
+				method: 'POST',
+				contentType: 'multipart/form-data',
+				headers: { 'content-type': 'multipart/form-data', 'x-auth-token': token },
+			},
+			bodyData,
+			credential: credentials,
+		});
+
+		expect(responseData).toEqual({
+			webhookResponse: { status: 200 },
+			workflowData: [
+				[
+					{
+						json: {
+							Name: 'John Doe',
+							Age: 30,
+							submittedAt: expect.any(String),
+							formMode: 'test',
+						},
+					},
+				],
+			],
+		});
+	});
+
+	it('should apply customCss property to form render', async () => {
+		const formFields = [{ fieldLabel: 'Name', fieldType: 'text', requiredField: true }];
+
+		const { response } = await testVersionedWebhookTriggerNode(FormTrigger, 2.2, {
+			mode: 'manual',
+			node: {
+				typeVersion: 2.2,
+				parameters: {
+					formTitle: 'Custom CSS Test',
+					formDescription: 'Testing custom CSS',
+					responseMode: 'onReceived',
+					authentication: 'none',
+					formFields: { values: formFields },
+					options: {
+						customCss: '.form-input { border-color: red; }',
+					},
+				},
+			},
+		});
+
+		expect(response.render).toHaveBeenCalledWith(
+			'form-trigger',
+			expect.objectContaining({
+				dangerousCustomCss: '.form-input { border-color: red; }',
+			}),
+		);
+	});
+
+	it('should handle files', async () => {
+		const formFields = [
+			{
+				fieldLabel: 'Resume',
+				fieldType: 'file',
+				requiredField: true,
+				acceptFileTypes: '.pdf,.doc',
+				multipleFiles: false,
+			},
+			{
+				fieldLabel: 'Attachments',
+				fieldType: 'file',
+				requiredField: true,
+				acceptFileTypes: '.pdf,.doc',
+				multipleFiles: true,
+			},
+		];
+
+		const bodyData = {
+			files: {
+				'field-0': {
+					originalFilename: 'resume.pdf',
+					mimetype: 'application/json',
+					filepath: '/resume.pdf',
+					size: 200,
+				},
+				'field-1': [
+					{
+						originalFilename: 'attachment1.pdf',
+						mimetype: 'application/json',
+						filepath: '/attachment1.pdf',
+						size: 201,
+					},
+				],
+			},
+		};
+
+		const { responseData } = await testVersionedWebhookTriggerNode(FormTrigger, 2, {
+			mode: 'trigger',
+			node: {
+				parameters: {
+					formTitle: 'Test Form',
+					formDescription: 'Test Description',
+					responseMode: 'onReceived',
+					authentication: 'none',
+					formFields: { values: formFields },
+				},
+			},
+			request: {
+				method: 'POST',
+				headers: { 'content-type': 'multipart/form-data' },
+				contentType: 'multipart/form-data',
+			},
+			bodyData,
+		});
+
+		expect(responseData?.webhookResponse).toEqual({ status: 200 });
+		expect(responseData?.workflowData).toEqual([
+			[
+				expect.objectContaining({
+					json: {
+						Resume: {
+							filename: 'resume.pdf',
+							mimetype: 'application/json',
+							size: 200,
+						},
+						Attachments: [
+							{
+								filename: 'attachment1.pdf',
+								mimetype: 'application/json',
+								size: 201,
+							},
+						],
+						formMode: 'production',
+						submittedAt: expect.any(String),
+					},
+				}),
+			],
+		]);
+	});
+});

packages/nodes-base/nodes/Form/test/formCompletionUtils.test.ts

@@ -0,0 +1,407 @@
+import { type Response } from 'express';
+import { type MockProxy, mock } from 'jest-mock-extended';
+import { type INode, type IWebhookFunctions } from 'n8n-workflow';
+
+import { binaryResponse, renderFormCompletion } from '../utils/formCompletionUtils';
+import * as utils from '../utils/utils';
+
+describe('formCompletionUtils', () => {
+	let mockWebhookFunctions: MockProxy<IWebhookFunctions>;
+
+	const mockNode: INode = mock<INode>({
+		id: 'test-node',
+		name: 'Test Node',
+		type: 'test',
+		typeVersion: 1,
+		position: [0, 0],
+		parameters: {},
+	});
+
+	const nodeNameWithFileToDownload = 'prevNode0';
+	const nodeNameWithFile = 'prevNode2';
+
+	const parentNodesWithAndWithoutFiles = [
+		{
+			name: nodeNameWithFileToDownload,
+			type: '',
+			typeVersion: 0,
+			disabled: false,
+		},
+		{
+			name: 'prevNode1',
+			type: '',
+			typeVersion: 0,
+			disabled: false,
+		},
+	];
+
+	const parentNodesWithMultipleBinaryFiles = [
+		{
+			name: nodeNameWithFileToDownload,
+			type: '',
+			typeVersion: 0,
+			disabled: false,
+		},
+		{
+			name: nodeNameWithFile,
+			type: '',
+			typeVersion: 0,
+			disabled: false,
+		},
+	];
+
+	const parentNodesWithSingleNodeFile = [
+		{
+			name: nodeNameWithFileToDownload,
+			type: '',
+			typeVersion: 0,
+			disabled: false,
+		},
+	];
+
+	const parentNodesTestCases = [
+		parentNodesWithAndWithoutFiles,
+		parentNodesWithMultipleBinaryFiles,
+		parentNodesWithSingleNodeFile,
+	];
+
+	beforeEach(() => {
+		mockWebhookFunctions = mock<IWebhookFunctions>();
+
+		mockWebhookFunctions.getNode.mockReturnValue(mockNode);
+	});
+
+	afterEach(() => {
+		jest.resetAllMocks();
+	});
+
+	describe('renderFormCompletion', () => {
+		const mockResponse: Response = mock<Response>({
+			send: jest.fn(),
+			render: jest.fn(),
+		});
+
+		const trigger = {
+			name: 'triggerNode',
+			type: 'trigger',
+			typeVersion: 1,
+			disabled: false,
+		};
+
+		afterEach(() => {
+			jest.resetAllMocks();
+		});
+
+		it('should render the form completion', async () => {
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage: 'Form has been submitted successfully',
+					options: { formTitle: 'Form Title' },
+				};
+				return params[parameterName];
+			});
+
+			await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+			expect(mockResponse.render).toHaveBeenCalledWith('form-trigger-completion', {
+				appendAttribution: undefined,
+				formTitle: 'Form Title',
+				message: 'Form has been submitted successfully',
+				redirectUrl: undefined,
+				responseBinary: encodeURIComponent(JSON.stringify('')),
+				responseText: '',
+				title: 'Form Completion',
+			});
+		});
+
+		it('should call sanitizeHtml on completionMessage', async () => {
+			const sanitizeHtmlSpy = jest.spyOn(utils, 'sanitizeHtml');
+			const maliciousMessage = '<script>alert("xss")</script>Safe message<b>bold</b>';
+			const responseText = 'Response text';
+
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage: maliciousMessage,
+					responseText,
+					options: { formTitle: 'Form Title' },
+				};
+				return params[parameterName];
+			});
+
+			await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+			expect(sanitizeHtmlSpy).toHaveBeenCalledWith(maliciousMessage);
+			expect(sanitizeHtmlSpy).toHaveBeenCalledTimes(1);
+			expect(mockResponse.render).toHaveBeenCalledWith('form-trigger-completion', {
+				appendAttribution: undefined,
+				formTitle: 'Form Title',
+				message: 'Safe message<b>bold</b>',
+				redirectUrl: undefined,
+				responseBinary: encodeURIComponent(JSON.stringify('')),
+				responseText: 'Response text',
+				title: 'Form Completion',
+				dangerousCustomCss: undefined,
+			});
+
+			sanitizeHtmlSpy.mockRestore();
+		});
+
+		it.each([
+			['\\n', '\n'],
+			['\\\\n', '\\n'],
+		])('should replace %j with %j in completionMessage', async (pattern, replacement) => {
+			const completionMessage = `Some message${pattern}Other text`;
+			const responseText = 'Response text';
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage,
+					responseText,
+					options: { formTitle: 'Form Title' },
+				};
+				return params[parameterName];
+			});
+
+			await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+			expect(mockResponse.render).toHaveBeenCalledWith('form-trigger-completion', {
+				appendAttribution: undefined,
+				formTitle: 'Form Title',
+				message: `Some message${replacement}Other text`,
+				redirectUrl: undefined,
+				responseBinary: encodeURIComponent(JSON.stringify('')),
+				responseText: 'Response text',
+				title: 'Form Completion',
+				dangerousCustomCss: undefined,
+			});
+		});
+
+		it('throw an error if no binary data with the field name is found', async () => {
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage: 'Form has been submitted successfully',
+					options: { formTitle: 'Form Title' },
+					respondWith: 'returnBinary',
+					inputDataFieldName: 'inputData',
+				};
+				return params[parameterName];
+			});
+			mockWebhookFunctions.getParentNodes.mockReturnValueOnce([]);
+
+			await expect(
+				renderFormCompletion(mockWebhookFunctions, mockResponse, trigger),
+			).rejects.toThrowError('No binary data with field inputData found.');
+		});
+
+		it('should render if respond with binary is set and binary mode is filesystem', async () => {
+			const expectedBinaryResponse = {
+				inputData: {
+					data: 'IyAxLiBHbyBpbiBwb3N0Z3',
+					fileExtension: 'txt',
+					fileName: 'file.txt',
+					fileSize: '458 B',
+					fileType: 'text',
+					mimeType: 'text/plain',
+					id: 555,
+				},
+			};
+
+			const buffer = Buffer.from(expectedBinaryResponse.inputData.data);
+
+			for (const parentNodes of parentNodesTestCases) {
+				mockWebhookFunctions.getParentNodes.mockReturnValueOnce(parentNodes);
+				mockWebhookFunctions.evaluateExpression.mockImplementation((arg) => {
+					if (arg === `{{ $('${nodeNameWithFileToDownload}').first().binary }}`) {
+						return expectedBinaryResponse;
+					} else if (arg === `{{ $('${nodeNameWithFile}').first().binary }}`) {
+						return { someData: {} };
+					} else {
+						return undefined;
+					}
+				});
+				mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+					const params: { [key: string]: any } = {
+						inputDataFieldName: 'inputData',
+						completionTitle: 'Form Completion',
+						completionMessage: 'Form has been submitted successfully',
+						options: { formTitle: 'Form Title' },
+						respondWith: 'returnBinary',
+					};
+					return params[parameterName];
+				});
+
+				mockWebhookFunctions.helpers.getBinaryStream = jest
+					.fn()
+					.mockResolvedValue(Promise.resolve({}));
+
+				mockWebhookFunctions.helpers.binaryToBuffer = jest
+					.fn()
+					.mockResolvedValue(Promise.resolve(buffer));
+
+				await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+				expect(mockResponse.render).toHaveBeenCalledWith('form-trigger-completion', {
+					appendAttribution: undefined,
+					formTitle: 'Form Title',
+					message: 'Form has been submitted successfully',
+					redirectUrl: undefined,
+					responseBinary: encodeURIComponent(
+						JSON.stringify({
+							data: buffer,
+							fileName: expectedBinaryResponse.inputData.fileName,
+							type: expectedBinaryResponse.inputData.mimeType,
+						}),
+					),
+					responseText: '',
+					title: 'Form Completion',
+				});
+			}
+		});
+
+		it('should render if respond with binary is set and binary mode is default', async () => {
+			const expectedBinaryResponse = {
+				inputData: {
+					data: 'IyAxLiBHbyBpbiBwb3N0Z3',
+					fileExtension: 'txt',
+					fileName: 'file.txt',
+					fileSize: '458 B',
+					fileType: 'text',
+					mimeType: 'text/plain',
+				},
+			};
+
+			for (const parentNodes of parentNodesTestCases) {
+				mockWebhookFunctions.getParentNodes.mockReturnValueOnce(parentNodes);
+				mockWebhookFunctions.evaluateExpression.mockImplementation((arg) => {
+					if (arg === `{{ $('${nodeNameWithFileToDownload}').first().binary }}`) {
+						return expectedBinaryResponse;
+					} else if (arg === `{{ $('${nodeNameWithFile}').first().binary }}`) {
+						return { someData: {} };
+					} else {
+						return undefined;
+					}
+				});
+				mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+					const params: { [key: string]: any } = {
+						inputDataFieldName: 'inputData',
+						completionTitle: 'Form Completion',
+						completionMessage: 'Form has been submitted successfully',
+						options: { formTitle: 'Form Title' },
+						respondWith: 'returnBinary',
+					};
+					return params[parameterName];
+				});
+
+				await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+				expect(mockResponse.render).toHaveBeenCalledWith('form-trigger-completion', {
+					appendAttribution: undefined,
+					formTitle: 'Form Title',
+					message: 'Form has been submitted successfully',
+					redirectUrl: undefined,
+					responseBinary: encodeURIComponent(
+						JSON.stringify({
+							data: atob(expectedBinaryResponse.inputData.data),
+							fileName: expectedBinaryResponse.inputData.fileName,
+							type: expectedBinaryResponse.inputData.mimeType,
+						}),
+					),
+					responseText: '',
+					title: 'Form Completion',
+				});
+			}
+		});
+
+		it('should set Content-Security-Policy header with sandbox CSP', async () => {
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage: 'Form has been submitted successfully',
+					options: { formTitle: 'Form Title' },
+				};
+				return params[parameterName];
+			});
+
+			await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+			expect(mockResponse.setHeader).toHaveBeenCalledWith(
+				'Content-Security-Policy',
+				'sandbox allow-downloads allow-forms allow-modals allow-orientation-lock allow-pointer-lock allow-popups allow-presentation allow-scripts allow-top-navigation allow-top-navigation-by-user-activation allow-top-navigation-to-custom-protocols',
+			);
+			expect(mockResponse.render).toHaveBeenCalled();
+		});
+
+		it('should NOT set Content-Security-Policy header when respondWith is redirect', async () => {
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					completionTitle: 'Form Completion',
+					completionMessage: 'Form has been submitted successfully',
+					options: { formTitle: 'Form Title' },
+					respondWith: 'redirect',
+				};
+				return params[parameterName];
+			});
+
+			await renderFormCompletion(mockWebhookFunctions, mockResponse, trigger);
+
+			expect(mockResponse.setHeader).not.toHaveBeenCalledWith(
+				'Content-Security-Policy',
+				expect.any(String),
+			);
+			expect(mockResponse.render).toHaveBeenCalled();
+		});
+	});
+
+	describe('binaryResponse', () => {
+		it('should get the latest binary data from the parent nodes', async () => {
+			const expectedBinaryResponse = {
+				inputData: {
+					data: 'IyAxLiBHbyBpbiBwb3N0Z3',
+					fileExtension: 'txt',
+					fileName: 'file.txt',
+					fileSize: '458 B',
+					fileType: 'text',
+					mimeType: 'text/plain',
+				},
+			};
+
+			const notExpectedBinaryResponse = {
+				inputData: {
+					data: 'notexpected',
+					fileExtension: 'txt',
+					fileName: 'file.txt',
+					fileSize: '458 B',
+					fileType: 'text',
+					mimeType: 'text/plain',
+				},
+			};
+
+			mockWebhookFunctions.getNodeParameter.mockImplementation((parameterName: string) => {
+				const params: { [key: string]: any } = {
+					inputDataFieldName: 'inputData',
+				};
+				return params[parameterName];
+			});
+
+			mockWebhookFunctions.getParentNodes.mockReturnValueOnce(parentNodesWithMultipleBinaryFiles);
+			mockWebhookFunctions.evaluateExpression.mockImplementation((arg) => {
+				if (arg === `{{ $('${nodeNameWithFile}').first().binary }}`) {
+					return expectedBinaryResponse;
+				} else {
+					return notExpectedBinaryResponse;
+				}
+			});
+
+			const result = await binaryResponse(mockWebhookFunctions);
+
+			expect(result).toEqual({
+				data: atob(expectedBinaryResponse.inputData.data),
+				fileName: expectedBinaryResponse.inputData.fileName,
+				type: expectedBinaryResponse.inputData.mimeType,
+			});
+		});
+	});
+});

packages/nodes-base/nodes/Form/test/formNodeUtils.test.ts

@@ -0,0 +1,301 @@
+import { type Response } from 'express';
+import type { MockProxy } from 'jest-mock-extended';
+import { mock } from 'jest-mock-extended';
+import {
+	type FormFieldsParameter,
+	type IWebhookFunctions,
+	type NodeTypeAndVersion,
+	NodeOperationError,
+	FORM_TRIGGER_NODE_TYPE,
+} from 'n8n-workflow';
+
+import { renderFormNode, getFormTriggerNode } from '../utils/formNodeUtils';
+
+describe('formNodeUtils', () => {
+	let webhookFunctions: MockProxy<IWebhookFunctions>;
+
+	beforeEach(() => {
+		webhookFunctions = mock<IWebhookFunctions>();
+	});
+
+	afterEach(() => {
+		jest.clearAllMocks();
+	});
+
+	it('should sanitize custom html', async () => {
+		webhookFunctions.getNode.mockReturnValue({ typeVersion: 2.1 } as any);
+		webhookFunctions.getNodeParameter.calledWith('options').mockReturnValue({
+			formTitle: 'Test Title',
+			formDescription: 'Test Description',
+			buttonLabel: 'Test Button Label',
+		});
+
+		const mockRender = jest.fn();
+
+		const formFields: FormFieldsParameter = [
+			{
+				fieldLabel: 'Custom HTML',
+				fieldType: 'html',
+				html: '<div>Test HTML</div>',
+				requiredField: false,
+			},
+			{
+				fieldLabel: 'Custom HTML',
+				fieldType: 'html',
+				html: '<script>Test HTML</script>',
+				requiredField: false,
+			},
+			{
+				fieldLabel: 'Custom HTML',
+				fieldType: 'html',
+				html: '<style>Test HTML</style>',
+				requiredField: false,
+			},
+			{
+				fieldLabel: 'Custom HTML',
+				fieldType: 'html',
+				html: '<style>Test HTML</style><div>hihihi</div><script>Malicious script here</script>',
+				requiredField: false,
+			},
+		];
+
+		webhookFunctions.getNodeParameter.calledWith('formFields.values').mockReturnValue(formFields);
+
+		const responseMock = mock<Response>({ render: mockRender } as any);
+		const triggerMock = mock<NodeTypeAndVersion>({ name: 'triggerName' } as any);
+
+		await renderFormNode(webhookFunctions, responseMock, triggerMock, formFields, 'test');
+
+		expect(mockRender).toHaveBeenCalledWith('form-trigger', {
+			appendAttribution: true,
+			buttonLabel: 'Test Button Label',
+			formDescription: 'Test Description',
+			formDescriptionMetadata: 'Test Description',
+			formFields: [
+				{
+					defaultValue: '',
+					errorId: 'error-field-0',
+					html: '<div>Test HTML</div>',
+					id: 'field-0',
+					inputRequired: '',
+					isHtml: true,
+					label: 'Custom HTML',
+					placeholder: undefined,
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-1',
+					html: '',
+					id: 'field-1',
+					inputRequired: '',
+					isHtml: true,
+					label: 'Custom HTML',
+					placeholder: undefined,
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-2',
+					html: '',
+					id: 'field-2',
+					inputRequired: '',
+					isHtml: true,
+					label: 'Custom HTML',
+					placeholder: undefined,
+				},
+				{
+					defaultValue: '',
+					errorId: 'error-field-3',
+					html: '<div>hihihi</div>',
+					id: 'field-3',
+					inputRequired: '',
+					isHtml: true,
+					label: 'Custom HTML',
+					placeholder: undefined,
+				},
+			],
+			formSubmittedHeader: undefined,
+			formSubmittedText: 'Your response has been recorded',
+			formTitle: 'Test Title',
+			n8nWebsiteLink: 'https://n8n.io/?utm_source=n8n-internal&utm_medium=form-trigger',
+			testRun: true,
+			useResponseData: true,
+		});
+	});
+
+	describe('getFormTriggerNode', () => {
+		const mockCurrentNode = { name: 'currentNode' };
+
+		beforeEach(() => {
+			webhookFunctions.getNode.mockReturnValue(mockCurrentNode as any);
+		});
+
+		it('should return the first executed form trigger node', () => {
+			const formTrigger1: NodeTypeAndVersion = {
+				name: 'FormTrigger1',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+			const formTrigger2: NodeTypeAndVersion = {
+				name: 'FormTrigger2',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+			const otherNode: NodeTypeAndVersion = {
+				name: 'OtherNode',
+				type: 'n8n-nodes-base.other',
+				typeVersion: 1,
+				disabled: false,
+			};
+
+			const parentNodes = [otherNode, formTrigger1, formTrigger2];
+			webhookFunctions.getParentNodes.mockReturnValue(parentNodes);
+
+			webhookFunctions.evaluateExpression
+				.calledWith(`{{ $('${formTrigger1.name}').first() }}`)
+				.mockReturnValue('success');
+
+			const result = getFormTriggerNode(webhookFunctions);
+
+			expect(result).toBe(formTrigger1);
+			expect(webhookFunctions.getParentNodes).toHaveBeenCalledWith('currentNode');
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger1.name}').first() }}`,
+			);
+		});
+
+		it('should return the second form trigger if the first one fails evaluation', () => {
+			const formTrigger1: NodeTypeAndVersion = {
+				name: 'FormTrigger1',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+			const formTrigger2: NodeTypeAndVersion = {
+				name: 'FormTrigger2',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+
+			const parentNodes = [formTrigger1, formTrigger2];
+			webhookFunctions.getParentNodes.mockReturnValue(parentNodes);
+
+			webhookFunctions.evaluateExpression
+				.calledWith(`{{ $('${formTrigger1.name}').first() }}`)
+				.mockImplementation(() => {
+					throw new Error('Evaluation failed');
+				});
+			webhookFunctions.evaluateExpression
+				.calledWith(`{{ $('${formTrigger2.name}').first() }}`)
+				.mockReturnValue('success');
+
+			const result = getFormTriggerNode(webhookFunctions);
+
+			expect(result).toBe(formTrigger2);
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger1.name}').first() }}`,
+			);
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger2.name}').first() }}`,
+			);
+		});
+
+		it('should throw NodeOperationError when no form trigger nodes are found', () => {
+			const otherNode: NodeTypeAndVersion = {
+				name: 'OtherNode',
+				type: 'n8n-nodes-base.other',
+				typeVersion: 1,
+				disabled: false,
+			};
+
+			const parentNodes = [otherNode];
+			webhookFunctions.getParentNodes.mockReturnValue(parentNodes);
+
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(NodeOperationError);
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(
+				'Form Trigger node must be set before this node',
+			);
+		});
+
+		it('should throw NodeOperationError when form trigger nodes exist but none are executed', () => {
+			const formTrigger1: NodeTypeAndVersion = {
+				name: 'FormTrigger1',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+			const formTrigger2: NodeTypeAndVersion = {
+				name: 'FormTrigger2',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+
+			const parentNodes = [formTrigger1, formTrigger2];
+			webhookFunctions.getParentNodes.mockReturnValue(parentNodes);
+
+			webhookFunctions.evaluateExpression.mockImplementation(() => {
+				throw new Error('Evaluation failed');
+			});
+
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(NodeOperationError);
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(
+				'Form Trigger node was not executed',
+			);
+
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger1.name}').first() }}`,
+			);
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger2.name}').first() }}`,
+			);
+		});
+
+		it('should handle empty parent nodes array', () => {
+			webhookFunctions.getParentNodes.mockReturnValue([]);
+
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(NodeOperationError);
+			expect(() => getFormTriggerNode(webhookFunctions)).toThrow(
+				'Form Trigger node must be set before this node',
+			);
+		});
+
+		it('should filter out non-form-trigger nodes correctly', () => {
+			const formTrigger: NodeTypeAndVersion = {
+				name: 'FormTrigger',
+				type: FORM_TRIGGER_NODE_TYPE,
+				typeVersion: 1,
+				disabled: false,
+			};
+			const webhookNode: NodeTypeAndVersion = {
+				name: 'WebhookNode',
+				type: 'n8n-nodes-base.webhook',
+				typeVersion: 1,
+				disabled: false,
+			};
+			const httpNode: NodeTypeAndVersion = {
+				name: 'HttpNode',
+				type: 'n8n-nodes-base.httpRequest',
+				typeVersion: 1,
+				disabled: false,
+			};
+
+			const parentNodes = [webhookNode, formTrigger, httpNode];
+			webhookFunctions.getParentNodes.mockReturnValue(parentNodes);
+
+			webhookFunctions.evaluateExpression
+				.calledWith(`{{ $('${formTrigger.name}').first() }}`)
+				.mockReturnValue('success');
+
+			const result = getFormTriggerNode(webhookFunctions);
+
+			expect(result).toBe(formTrigger);
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledTimes(1);
+			expect(webhookFunctions.evaluateExpression).toHaveBeenCalledWith(
+				`{{ $('${formTrigger.name}').first() }}`,
+			);
+		});
+	});
+});