first commit

packages/workflow/test/run-execution-data-factory.test.ts

@@ -0,0 +1,173 @@
+import { mock } from 'vitest-mock-extended';
+
+import type { INode, ExecutionError } from '../src/interfaces';
+import {
+	createRunExecutionData,
+	createEmptyRunExecutionData,
+	createErrorExecutionData,
+	type CreateFullRunExecutionDataOptions,
+} from '../src/run-execution-data-factory';
+
+describe('RunExecutionDataFactory', () => {
+	describe('createRunExecutionData', () => {
+		it('should create a complete IRunExecutionData object with default values', () => {
+			const result = createRunExecutionData();
+
+			expect(result).toEqual({
+				version: 1,
+				startData: {},
+				manualData: undefined,
+				parentExecution: undefined,
+				pushRef: undefined,
+				validateSignature: undefined,
+				waitTill: undefined,
+				resultData: {
+					error: undefined,
+					runData: {},
+					pinData: undefined,
+					lastNodeExecuted: undefined,
+					metadata: undefined,
+				},
+				executionData: {
+					contextData: {},
+					nodeExecutionStack: [],
+					metadata: {},
+					waitingExecution: {},
+					waitingExecutionSource: {},
+				},
+			});
+		});
+
+		it('should create a complete IRunExecutionData object with custom options', () => {
+			const options = {
+				startData: {
+					startNodes: [{ name: 'Start', sourceData: { previousNode: 'Previous' } }],
+					destinationNode: { nodeName: 'End', mode: 'inclusive' },
+				},
+				resultData: {
+					runData: { testNode: [] },
+					lastNodeExecuted: 'testNode',
+				},
+				executionData: {
+					nodeExecutionStack: [{ node: {} as INode, data: {}, source: null }],
+					runtimeData: {
+						version: 1 as const,
+						establishedAt: 1234567890,
+						source: 'webhook' as const,
+						credentials: 'test-credentials',
+					},
+				},
+				parentExecution: {
+					executionId: 'parent-123',
+					workflowId: 'workflow-456',
+				},
+				validateSignature: true,
+				waitTill: new Date('2023-01-01'),
+			} satisfies CreateFullRunExecutionDataOptions;
+
+			const result = createRunExecutionData(options);
+
+			expect(result.startData).toEqual(options.startData);
+			expect(result.resultData.runData).toEqual(options.resultData.runData);
+			expect(result.resultData.lastNodeExecuted).toEqual(options.resultData.lastNodeExecuted);
+			expect(result.executionData?.nodeExecutionStack).toEqual(
+				options.executionData.nodeExecutionStack,
+			);
+			expect(result.executionData?.runtimeData).toEqual(options.executionData.runtimeData);
+			expect(result.parentExecution).toEqual(options.parentExecution);
+			expect(result.validateSignature).toBe(true);
+			expect(result.waitTill).toEqual(options.waitTill);
+		});
+
+		it('should omit `executionData` if null is passed', () => {
+			const result = createRunExecutionData({
+				executionData: null,
+			});
+
+			expect(result.executionData).toBeUndefined();
+			expect(result.startData).toEqual({});
+			expect(result.resultData.runData).toEqual({});
+		});
+
+		it('should omit `resultData.runData` if null is passed', () => {
+			const result = createRunExecutionData({
+				resultData: {
+					runData: null,
+				},
+			});
+
+			expect(result.resultData.runData).toBeUndefined();
+			expect(result.startData).toEqual({});
+			expect(result.executionData).toEqual({
+				contextData: {},
+				nodeExecutionStack: [],
+				metadata: {},
+				waitingExecution: {},
+				waitingExecutionSource: {},
+			});
+		});
+	});
+
+	describe('createMinimalRunExecutionData', () => {
+		it('should create a minimal IRunExecutionData object with empty runData', () => {
+			const result = createEmptyRunExecutionData();
+
+			expect(result).toEqual({
+				version: 1,
+				resultData: {
+					runData: {},
+				},
+			});
+		});
+	});
+
+	describe('createErrorExecutionData', () => {
+		it('should create a IRunExecutionData object for error execution', () => {
+			const node: INode = {
+				id: 'node-123',
+				name: 'TestNode',
+				type: 'test',
+				typeVersion: 1,
+				position: [0, 0],
+				parameters: {},
+			};
+
+			const error = mock<ExecutionError>({
+				message: 'Test error occurred',
+				name: 'TestError',
+			});
+
+			const result = createErrorExecutionData(node, error);
+
+			expect(result.startData?.destinationNode).toEqual({
+				nodeName: 'TestNode',
+				mode: 'inclusive',
+			});
+			expect(result.startData?.runNodeFilter).toEqual(['TestNode']);
+
+			expect(result.executionData?.contextData).toEqual({});
+			expect(result.executionData?.metadata).toEqual({});
+			expect(result.executionData?.waitingExecution).toEqual({});
+			expect(result.executionData?.waitingExecutionSource).toEqual({});
+
+			expect(result.executionData?.nodeExecutionStack).toHaveLength(1);
+			expect(result.executionData?.nodeExecutionStack?.[0]?.node).toBe(node);
+			expect(result.executionData?.nodeExecutionStack?.[0]?.data.main).toEqual([
+				[{ json: {}, pairedItem: { item: 0 } }],
+			]);
+			expect(result.executionData?.nodeExecutionStack?.[0]?.source).toBe(null);
+
+			expect(result.resultData.runData['TestNode']).toHaveLength(1);
+			expect(result.resultData.runData['TestNode'][0]).toEqual({
+				startTime: 0,
+				executionIndex: 0,
+				executionTime: 0,
+				error,
+				source: [],
+			});
+
+			expect(result.resultData.error).toBe(error);
+			expect(result.resultData.lastNodeExecuted).toBe('TestNode');
+		});
+	});
+});