first commit

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

@@ -0,0 +1,188 @@
+import { NodeTestHarness } from '@nodes-testing/node-test-harness';
+import { mock } from 'jest-mock-extended';
+import { DateTime } from 'luxon';
+import { NodeOperationError, type IExecuteFunctions } from 'n8n-workflow';
+
+import { Wait } from '../Wait.node';
+
+describe('Execute Wait Node', () => {
+	let timer: NodeJS.Timeout;
+	const { clearInterval, setInterval } = global;
+	const nextDay = DateTime.now().startOf('day').plus({ days: 1 });
+
+	beforeAll(() => {
+		timer = setInterval(() => jest.advanceTimersByTime(1000), 10);
+		jest.useFakeTimers().setSystemTime(new Date('2025-01-01'));
+	});
+
+	afterAll(() => {
+		clearInterval(timer);
+		jest.useRealTimers();
+	});
+
+	test.each([
+		{ value: 'invalid_date', isValid: false },
+		{
+			value: nextDay.toISO(),
+			isValid: true,
+			expectedWaitTill: nextDay.toJSDate(),
+		},
+		{
+			value: nextDay.toISO({ includeOffset: true }),
+			isValid: true,
+			expectedWaitTill: nextDay.toUTC().toJSDate(),
+		},
+		{
+			value: nextDay.toJSDate(),
+			isValid: true,
+			expectedWaitTill: nextDay.toJSDate(),
+		},
+		{
+			value: nextDay,
+			isValid: true,
+			expectedWaitTill: nextDay.toJSDate(),
+		},
+	])(
+		'Test Wait Node with specificTime $value and isValid $isValid',
+		async ({ value, isValid, expectedWaitTill }) => {
+			const putExecutionToWaitSpy = jest.fn();
+			const waitNode = new Wait();
+			const executeFunctionsMock = mock<IExecuteFunctions>({
+				getNodeParameter: jest.fn().mockImplementation((paramName: string) => {
+					if (paramName === 'resume') return 'specificTime';
+					if (paramName === 'dateTime') return value;
+				}),
+				getTimezone: jest.fn().mockReturnValue('UTC'),
+				putExecutionToWait: putExecutionToWaitSpy,
+				getInputData: jest.fn(),
+				getNode: jest.fn(),
+			});
+
+			if (isValid) {
+				await expect(waitNode.execute(executeFunctionsMock)).resolves.not.toThrow();
+				expect(putExecutionToWaitSpy).toHaveBeenCalledWith(expectedWaitTill);
+			} else {
+				await expect(waitNode.execute(executeFunctionsMock)).rejects.toThrow(NodeOperationError);
+			}
+		},
+	);
+
+	test('should resolve with input data if canceled', async () => {
+		const putExecutionToWaitSpy = jest.fn();
+		const waitNode = new Wait();
+
+		let cancelSignal: (() => void) | null = null;
+
+		const inputData = [{ json: { test: 'data' } }];
+
+		const executeFunctionsMock = mock<IExecuteFunctions>({
+			getNodeParameter: jest.fn().mockImplementation((paramName: string) => {
+				if (paramName === 'resume') return 'timeInterval';
+				if (paramName === 'unit') return 'seconds';
+				if (paramName === 'amount') return 60;
+			}),
+			getTimezone: jest.fn().mockReturnValue('UTC'),
+			putExecutionToWait: putExecutionToWaitSpy,
+			getInputData: jest.fn(() => inputData),
+			getNode: jest.fn(),
+			onExecutionCancellation: (handler) => {
+				cancelSignal = handler;
+			},
+		});
+
+		const waitPromise = waitNode.execute(executeFunctionsMock);
+
+		for (let index = 0; index < 20; index++) {
+			await new Promise((r) => setTimeout(r, 10));
+			if (cancelSignal !== null) break;
+		}
+
+		expect(cancelSignal).not.toBeNull();
+		cancelSignal!();
+
+		await expect(waitPromise).resolves.toEqual([inputData]);
+	});
+
+	describe('Validation', () => {
+		describe('Time interval', () => {
+			it.each([
+				{
+					unit: 'seconds',
+					amount: 300,
+					expectedWaitTill: () => DateTime.now().plus({ seconds: 300 }).toJSDate(),
+				},
+				{
+					unit: 'minutes',
+					amount: 2,
+					expectedWaitTill: () => DateTime.now().plus({ minutes: 2 }).toJSDate(),
+				},
+				{
+					unit: 'hours',
+					amount: 1,
+					expectedWaitTill: () => DateTime.now().plus({ hours: 1 }).toJSDate(),
+				},
+				{
+					unit: 'days',
+					amount: 10,
+					expectedWaitTill: () => DateTime.now().plus({ days: 10 }).toJSDate(),
+				},
+				{
+					unit: 'seconds',
+					amount: 0,
+					mode: 'timeout',
+					expectedWaitTill: () => DateTime.now().toJSDate(),
+				},
+				{
+					unit: 'seconds',
+					amount: -10,
+					error: 'Invalid wait amount. Please enter a number that is 0 or greater.',
+				},
+				{
+					unit: 'years',
+					amount: 10,
+					error: "Invalid wait unit. Valid units are 'seconds', 'minutes', 'hours', or 'days'.",
+				},
+				{
+					unit: 'minutes',
+					amount: 'test',
+					error: 'Invalid wait amount. Please enter a number that is 0 or greater.',
+				},
+			])(
+				'Validate wait unit: $unit, amount: $amount',
+				async ({ unit, amount, expectedWaitTill, error, mode }) => {
+					const putExecutionToWaitSpy = jest.fn();
+					const waitNode = new Wait();
+					const inputData = [{ json: { inputData: true } }];
+					const executeFunctionsMock = mock<IExecuteFunctions>({
+						getNodeParameter: jest.fn().mockImplementation((paramName: string) => {
+							if (paramName === 'resume') return 'timeInterval';
+							if (paramName === 'amount') return amount;
+							if (paramName === 'unit') return unit;
+						}),
+						getTimezone: jest.fn().mockReturnValue('UTC'),
+						putExecutionToWait: putExecutionToWaitSpy,
+						getInputData: jest.fn(() => inputData),
+						getNode: jest.fn(),
+					});
+
+					if (!error) {
+						if (mode === 'timeout') {
+							// for short wait times (<65s) a simple timeout is used
+							const resultPromise = waitNode.execute(executeFunctionsMock);
+							jest.runAllTimers();
+							await expect(resultPromise).resolves.toEqual([inputData]);
+						} else {
+							// for longer wait times (>=65s) the execution is put to wait
+							await expect(waitNode.execute(executeFunctionsMock)).resolves.not.toThrow();
+							expect(putExecutionToWaitSpy).toHaveBeenCalledWith(expectedWaitTill?.());
+						}
+					} else {
+						await expect(waitNode.execute(executeFunctionsMock)).rejects.toThrowError(error);
+					}
+				},
+			);
+		});
+	});
+
+	new NodeTestHarness().setupTests();
+});