@fsai-flow/core 0.0.5 → 0.1.1

package/tests/WorkflowExecute.test.ts

@@ -1,1242 +0,0 @@
-/* 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([]);
-			});
-		}
-	});
-});