@fsai-flow/core 0.0.1

package/tests/WorkflowExecute.test.ts

@@ -0,0 +1,1242 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import {
+	createDeferredPromise,
+	IConnections,
+	ILogger,
+	INode,
+	IRun,
+	LoggerProxy,
+	Workflow,
+} from '@fsai-flow/workflow';
+
+import { WorkflowExecute } from '../src';
+
+import * as Helpers from './Helpers';
+
+describe('WorkflowExecute', () => {
+	describe('run', () => {
+		const tests: Array<{
+			description: string;
+			input: {
+				workflowData: {
+					nodes: INode[];
+					connections: IConnections;
+				};
+			};
+			output: {
+				nodeExecutionOrder: string[];
+				nodeData: {
+					[key: string]: any[][];
+				};
+			};
+		}> = [
+			{
+				description: 'should run basic two node workflow',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [100, 300],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value1',
+												value: 1,
+											},
+										],
+									},
+								},
+								name: 'Set',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [280, 300],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set'],
+					nodeData: {
+						Set: [
+							[
+								{
+									value1: 1,
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description: 'should run node twice when it has two input connections',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [100, 300],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value1',
+												value: 1,
+											},
+										],
+									},
+								},
+								name: 'Set1',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [300, 250],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value2',
+												value: 2,
+											},
+										],
+									},
+								},
+								name: 'Set2',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [500, 400],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set1',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Set2',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set1: {
+								main: [
+									[
+										{
+											node: 'Set2',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set1', 'Set2', 'Set2'],
+					nodeData: {
+						Set1: [
+							[
+								{
+									value1: 1,
+								},
+							],
+						],
+						Set2: [
+							[
+								{
+									value2: 2,
+								},
+							],
+							[
+								{
+									value1: 1,
+									value2: 2,
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description: 'should run complicated multi node workflow',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {
+									mode: 'passThrough',
+								},
+								name: 'Merge4',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1150, 500],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value2',
+												value: 2,
+											},
+										],
+									},
+								},
+								name: 'Set2',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [290, 400],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value4',
+												value: 4,
+											},
+										],
+									},
+								},
+								name: 'Set4',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [850, 200],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value3',
+												value: 3,
+											},
+										],
+									},
+								},
+								name: 'Set3',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [650, 200],
+							},
+							{
+								parameters: {
+									mode: 'passThrough',
+								},
+								name: 'Merge4',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1150, 500],
+							},
+							{
+								parameters: {},
+								name: 'Merge3',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1000, 400],
+							},
+							{
+								parameters: {
+									mode: 'passThrough',
+									output: 'input2',
+								},
+								name: 'Merge2',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [700, 400],
+							},
+							{
+								parameters: {},
+								name: 'Merge1',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [500, 300],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value1',
+												value: 1,
+											},
+										],
+									},
+								},
+								name: 'Set1',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [300, 200],
+							},
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [100, 300],
+							},
+						],
+						connections: {
+							Set2: {
+								main: [
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 1,
+										},
+										{
+											node: 'Merge2',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							Set4: {
+								main: [
+									[
+										{
+											node: 'Merge3',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set3: {
+								main: [
+									[
+										{
+											node: 'Set4',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Merge3: {
+								main: [
+									[
+										{
+											node: 'Merge4',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Merge2: {
+								main: [
+									[
+										{
+											node: 'Merge3',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							Merge1: {
+								main: [
+									[
+										{
+											node: 'Merge2',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set1: {
+								main: [
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Set3',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set1',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Set2',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Merge4',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: [
+						'Start',
+						'Set1',
+						'Set2',
+						'Set3',
+						'Merge1',
+						'Set4',
+						'Merge2',
+						'Merge3',
+						'Merge4',
+					],
+					nodeData: {
+						Set1: [
+							[
+								{
+									value1: 1,
+								},
+							],
+						],
+						Set2: [
+							[
+								{
+									value2: 2,
+								},
+							],
+						],
+						Set3: [
+							[
+								{
+									value1: 1,
+									value3: 3,
+								},
+							],
+						],
+						Set4: [
+							[
+								{
+									value1: 1,
+									value3: 3,
+									value4: 4,
+								},
+							],
+						],
+						Merge1: [
+							[
+								{
+									value1: 1,
+								},
+								{
+									value2: 2,
+								},
+							],
+						],
+						Merge2: [
+							[
+								{
+									value2: 2,
+								},
+							],
+						],
+						Merge3: [
+							[
+								{
+									value1: 1,
+									value3: 3,
+									value4: 4,
+								},
+								{
+									value2: 2,
+								},
+							],
+						],
+						Merge4: [
+							[
+								{
+									value1: 1,
+									value3: 3,
+									value4: 4,
+								},
+								{
+									value2: 2,
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description:
+					'should run workflow also if node has multiple input connections and one is empty',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [250, 450],
+							},
+							{
+								parameters: {
+									conditions: {
+										boolean: [],
+										number: [
+											{
+												value1: '={{Object.keys($json).length}}',
+												operation: 'notEqual',
+											},
+										],
+									},
+								},
+								name: 'IF',
+								type: 'n8n-nodes-base.if',
+								typeVersion: 1,
+								position: [650, 350],
+							},
+							{
+								parameters: {},
+								name: 'Merge1',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1150, 450],
+							},
+							{
+								parameters: {
+									values: {
+										string: [
+											{
+												name: 'test1',
+												value: 'a',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set1',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 450],
+							},
+							{
+								parameters: {
+									values: {
+										string: [
+											{
+												name: 'test2',
+												value: 'b',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set2',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [800, 250],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set1',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							IF: {
+								main: [
+									[
+										{
+											node: 'Set2',
+											type: 'main',
+											index: 0,
+										},
+									],
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set1: {
+								main: [
+									[
+										{
+											node: 'IF',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							Set2: {
+								main: [
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set1', 'IF', 'Set2', 'Merge1'],
+					nodeData: {
+						Merge1: [
+							[
+								{
+									test1: 'a',
+									test2: 'b',
+								},
+								{
+									test1: 'a',
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description: 'should use empty data if second input does not have any data',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [250, 300],
+							},
+							{
+								parameters: {},
+								name: 'Merge',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [800, 450],
+							},
+							{
+								parameters: {},
+								name: 'Merge1',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1000, 300],
+							},
+							{
+								parameters: {
+									conditions: {
+										boolean: [
+											{
+												value2: true,
+											},
+										],
+										string: [
+											{
+												value1: '={{$json["key"]}}',
+												value2: 'a',
+											},
+										],
+									},
+									combineOperation: 'any',
+								},
+								name: 'IF',
+								type: 'n8n-nodes-base.if',
+								typeVersion: 1,
+								position: [600, 600],
+								alwaysOutputData: false,
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'number0',
+											},
+										],
+										string: [
+											{
+												name: 'key',
+												value: 'a',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set0',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 300],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'number1',
+												value: 1,
+											},
+										],
+										string: [
+											{
+												name: 'key',
+												value: 'b',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set1',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 450],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'number2',
+												value: 2,
+											},
+										],
+										string: [
+											{
+												name: 'key',
+												value: 'c',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set2',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 600],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set0',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Merge: {
+								main: [
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							IF: {
+								main: [
+									[
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							Set0: {
+								main: [
+									[
+										{
+											node: 'Merge1',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set1: {
+								main: [
+									[
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set2: {
+								main: [
+									[
+										{
+											node: 'IF',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set0', 'Set2', 'IF', 'Set1', 'Merge', 'Merge1'],
+					nodeData: {
+						Merge: [
+							[
+								{
+									number1: 1,
+									key: 'b',
+								},
+							],
+						],
+						Merge1: [
+							[
+								{
+									number0: 0,
+									key: 'a',
+								},
+								{
+									number1: 1,
+									key: 'b',
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description:
+					'should use empty data if input of sibling does not receive any data from parent',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [250, 300],
+							},
+							{
+								parameters: {
+									conditions: {
+										number: [
+											{
+												value1: '={{$json["value1"]}}',
+												operation: 'equal',
+												value2: 1,
+											},
+										],
+									},
+								},
+								name: 'IF',
+								type: 'n8n-nodes-base.if',
+								typeVersion: 1,
+								position: [650, 300],
+							},
+							{
+								parameters: {
+									values: {
+										string: [],
+										number: [
+											{
+												name: 'value2',
+												value: 2,
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set2',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [850, 450],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value1',
+												value: 1,
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set1',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 300],
+							},
+							{
+								parameters: {},
+								name: 'Merge',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1050, 300],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set1',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							IF: {
+								main: [
+									[
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 0,
+										},
+									],
+									[
+										{
+											node: 'Set2',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set2: {
+								main: [
+									[
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 1,
+										},
+									],
+								],
+							},
+							Set1: {
+								main: [
+									[
+										{
+											node: 'IF',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set1', 'IF', 'Set2', 'Merge'],
+					nodeData: {
+						Merge: [
+							[
+								{
+									value1: 1,
+								},
+								{
+									value2: 2,
+								},
+							],
+						],
+					},
+				},
+			},
+			{
+				description: 'should not use empty data in sibling if parent did not send any data',
+				input: {
+					// Leave the workflowData in regular JSON to be able to easily
+					// copy it from/in the UI
+					workflowData: {
+						nodes: [
+							{
+								parameters: {},
+								name: 'Start',
+								type: 'n8n-nodes-base.start',
+								typeVersion: 1,
+								position: [250, 300],
+							},
+							{
+								parameters: {
+									values: {
+										number: [
+											{
+												name: 'value1',
+											},
+										],
+									},
+									options: {},
+								},
+								name: 'Set',
+								type: 'n8n-nodes-base.set',
+								typeVersion: 1,
+								position: [450, 300],
+							},
+							{
+								parameters: {},
+								name: 'Merge',
+								type: 'n8n-nodes-base.merge',
+								typeVersion: 1,
+								position: [1050, 250],
+							},
+							{
+								parameters: {
+									conditions: {
+										number: [
+											{
+												value1: '={{$json["value1"]}}',
+												operation: 'equal',
+												value2: 1,
+											},
+										],
+									},
+								},
+								name: 'IF',
+								type: 'n8n-nodes-base.if',
+								typeVersion: 1,
+								position: [650, 300],
+							},
+							{
+								parameters: {},
+								name: 'NoOpTrue',
+								type: 'n8n-nodes-base.noOp',
+								typeVersion: 1,
+								position: [850, 150],
+							},
+							{
+								parameters: {},
+								name: 'NoOpFalse',
+								type: 'n8n-nodes-base.noOp',
+								typeVersion: 1,
+								position: [850, 400],
+							},
+						],
+						connections: {
+							Start: {
+								main: [
+									[
+										{
+											node: 'Set',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							Set: {
+								main: [
+									[
+										{
+											node: 'IF',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							IF: {
+								main: [
+									[
+										{
+											node: 'NoOpTrue',
+											type: 'main',
+											index: 0,
+										},
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 1,
+										},
+									],
+									[
+										{
+											node: 'NoOpFalse',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+							NoOpTrue: {
+								main: [
+									[
+										{
+											node: 'Merge',
+											type: 'main',
+											index: 0,
+										},
+									],
+								],
+							},
+						},
+					},
+				},
+				output: {
+					nodeExecutionOrder: ['Start', 'Set', 'IF', 'NoOpFalse'],
+					nodeData: {
+						IF: [[]],
+						NoOpFalse: [
+							[
+								{
+									value1: 0,
+								},
+							],
+						],
+					},
+				},
+			},
+		];
+
+		const fakeLogger = {
+			log: () => {},
+			debug: () => {},
+			verbose: () => {},
+			info: () => {},
+			warn: () => {},
+			error: () => {},
+		} as ILogger;
+
+		const executionMode = 'manual';
+		const nodeTypes = Helpers.NodeTypes();
+		LoggerProxy.init(fakeLogger);
+
+		for (const testData of tests) {
+			test(testData.description, async () => {
+				const workflowInstance = new Workflow({
+					id: 'test',
+					nodes: testData.input.workflowData.nodes,
+					connections: testData.input.workflowData.connections,
+					active: false,
+					nodeTypes,
+				});
+
+				const waitPromise = await createDeferredPromise<IRun>();
+				const nodeExecutionOrder: string[] = [];
+				const additionalData = Helpers.WorkflowExecuteAdditionalData(
+					waitPromise,
+					nodeExecutionOrder,
+				);
+
+				const workflowExecute = new WorkflowExecute(additionalData, executionMode);
+
+				const executionData = await workflowExecute.run(workflowInstance);
+
+				const result = await waitPromise.promise();
+
+				// Check if the data from WorkflowExecute is identical to data received
+				// by the webhooks
+				expect(executionData).toEqual(result);
+
+				// Check if the output data of the nodes is correct
+				for (const nodeName of Object.keys(testData.output.nodeData)) {
+					if (result.data.resultData.runData[nodeName] === undefined) {
+						throw new Error(`Data for node "${nodeName}" is missing!`);
+					}
+
+					const resultData = result.data.resultData.runData[nodeName].map((nodeData) => {
+						if (nodeData.data === undefined) {
+							return null;
+						}
+						return nodeData.data['main'][0]!.map((entry) => entry.json);
+					});
+
+					// expect(resultData).toEqual(testData.output.nodeData[nodeName]);
+					expect(resultData).toEqual(testData.output.nodeData[nodeName]);
+				}
+
+				// Check if the nodes did execute in the correct order
+				expect(nodeExecutionOrder).toEqual(testData.output.nodeExecutionOrder);
+
+				// Check if other data has correct value
+				expect(result.finished).toEqual(true);
+				expect(result.data.executionData!.contextData).toEqual({});
+				expect(result.data.executionData!.nodeExecutionStack).toEqual([]);
+			});
+		}
+	});
+});