✔️ Fix tests

packages/core/src/Interfaces.ts

@@ -11,7 +11,6 @@ import {
 	ITriggerFunctions as ITriggerFunctionsBase,
 	IWebhookFunctions as IWebhookFunctionsBase,
 	IWorkflowSettings as IWorkflowSettingsWorkflow,
-	WorkflowExecuteMode,
  } from 'n8n-workflow';
 
 

packages/core/src/NodeExecuteFunctions.ts

@@ -3,7 +3,6 @@ import {
 	IHookFunctions,
 	ILoadOptionsFunctions,
 	IWorkflowSettings,
-	WorkflowExecute,
 	BINARY_ENCODING,
 } from './';
 
@@ -12,7 +11,6 @@ import {
 	IContextObject,
 	ICredentialDataDecryptedObject,
 	IDataObject,
-	IExecuteData,
 	IExecuteFunctions,
 	IExecuteSingleFunctions,
 	INode,

packages/core/test/Helpers.ts

@@ -5,7 +5,7 @@ import {
 	INodeParameters,
 	INodeType,
 	INodeTypes,
-	INodeTypesObject,
+	INodeTypeData,
 	IRun,
 	ITaskData,
 	IWorkflowExecuteAdditionalData,
@@ -19,201 +19,218 @@ import {
 
 class NodeTypesClass implements INodeTypes {
 
-	nodeTypes: INodeTypesObject = {
+	nodeTypes: INodeTypeData = {
 		'n8n-nodes-base.merge': {
-			description: {
+			sourcePath: '',
-				displayName: 'Merge',
+			type: {
-				name: 'merge',
+				description: {
-				icon: 'fa:clone',
+					displayName: 'Merge',
-				group: ['transform'],
+					name: 'merge',
-				version: 1,
+					icon: 'fa:clone',
-				description: 'Merges data of multiple streams once data of both is available',
+					group: ['transform'],
-				defaults: {
+					version: 1,
-					name: 'Merge',
+					description: 'Merges data of multiple streams once data of both is available',
-					color: '#00cc22',
+					defaults: {
-				},
+						name: 'Merge',
-				inputs: ['main', 'main'],
+						color: '#00cc22',
-				outputs: ['main'],
-				properties: [
-					{
-						displayName: 'Mode',
-						name: 'mode',
-						type: 'options',
-						options: [
-							{
-								name: 'Append',
-								value: 'append',
-								description: 'Combines data of both inputs. The output will contain items of input 1 and input 2.',
-							},
-							{
-								name: 'Pass-through',
-								value: 'passThrough',
-								description: 'Passes through data of one input. The output will conain only items of the defined input.',
-							},
-							{
-								name: 'Wait',
-								value: 'wait',
-								description: 'Waits till data of both inputs is available and will then output a single empty item.',
-							},
-						],
-						default: 'append',
-						description: 'How data should be merged. If it should simply<br />be appended or merged depending on a property.',
 					},
-					{
+					inputs: ['main', 'main'],
-						displayName: 'Output Data',
+					outputs: ['main'],
-						name: 'output',
+					properties: [
-						type: 'options',
+						{
-						displayOptions: {
+							displayName: 'Mode',
-							show: {
+							name: 'mode',
-								mode: [
+							type: 'options',
-									'passThrough'
+							options: [
-								],
+								{
-							},
+									name: 'Append',
+									value: 'append',
+									description: 'Combines data of both inputs. The output will contain items of input 1 and input 2.',
+								},
+								{
+									name: 'Pass-through',
+									value: 'passThrough',
+									description: 'Passes through data of one input. The output will conain only items of the defined input.',
+								},
+								{
+									name: 'Wait',
+									value: 'wait',
+									description: 'Waits till data of both inputs is available and will then output a single empty item.',
+								},
+							],
+							default: 'append',
+							description: 'How data should be merged. If it should simply<br />be appended or merged depending on a property.',
 						},
-						options: [
+						{
-							{
+							displayName: 'Output Data',
-								name: 'Input 1',
+							name: 'output',
-								value: 'input1',
+							type: 'options',
+							displayOptions: {
+								show: {
+									mode: [
+										'passThrough'
+									],
+								},
 							},
-							{
+							options: [
-								name: 'Input 2',
+								{
-								value: 'input2',
+									name: 'Input 1',
-							},
+									value: 'input1',
-						],
+								},
-						default: 'input1',
+								{
-						description: 'Defines of which input the data should be used as output of node.',
+									name: 'Input 2',
-					},
+									value: 'input2',
-				]
+								},
-			},
+							],
-			async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+							default: 'input1',
-				// const itemsInput2 = this.getInputData(1);
+							description: 'Defines of which input the data should be used as output of node.',
+						},
+					]
+				},
+				async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					// const itemsInput2 = this.getInputData(1);
 
-				const returnData: INodeExecutionData[] = [];
+					const returnData: INodeExecutionData[] = [];
 
-				const mode = this.getNodeParameter('mode', 0) as string;
+					const mode = this.getNodeParameter('mode', 0) as string;
 
-				if (mode === 'append') {
+					if (mode === 'append') {
-					// Simply appends the data
+						// Simply appends the data
-					for (let i = 0; i < 2; i++) {
+						for (let i = 0; i < 2; i++) {
-						returnData.push.apply(returnData, this.getInputData(i));
+							returnData.push.apply(returnData, this.getInputData(i));
+						}
+					} else if (mode === 'passThrough') {
+						const output = this.getNodeParameter('output', 0) as string;
+
+						if (output === 'input1') {
+							returnData.push.apply(returnData, this.getInputData(0));
+						} else {
+							returnData.push.apply(returnData, this.getInputData(1));
+						}
+					} else if (mode === 'wait') {
+						returnData.push({ json: {} });
 					}
-				} else if (mode === 'passThrough') {
-					const output = this.getNodeParameter('output', 0) as string;
 
-					if (output === 'input1') {
+					return [returnData];
-						returnData.push.apply(returnData, this.getInputData(0));
-					} else {
-						returnData.push.apply(returnData, this.getInputData(1));
-					}
-				} else if (mode === 'wait') {
-					returnData.push({ json: {} });
 				}
-
+			},
-				return [returnData];
-			}
 		},
 		'n8n-nodes-base.set': {
-			description: {
+			sourcePath: '',
-				displayName: 'Set',
+			type: {
-				name: 'set',
+				description: {
-				group: ['input'],
+					displayName: 'Set',
-				version: 1,
+					name: 'set',
-				description: 'Sets a value',
+					group: ['input'],
-				defaults: {
+					version: 1,
-					name: 'Set',
+					description: 'Sets a value',
-					color: '#0000FF',
+					defaults: {
-				},
+						name: 'Set',
-				inputs: ['main'],
+						color: '#0000FF',
-				outputs: ['main'],
-				properties: [
-					{
-						displayName: 'Keep Only Set',
-						name: 'keepOnlySet',
-						type: 'boolean',
-						default: false,
-						description: 'If only the values set on this node should be<br />kept and all others removed.',
 					},
-					{
+					inputs: ['main'],
-						displayName: 'Values to Set',
+					outputs: ['main'],
-						name: 'values',
+					properties: [
-						placeholder: 'Add Value',
+						{
-						type: 'fixedCollection',
+							displayName: 'Keep Only Set',
-						typeOptions: {
+							name: 'keepOnlySet',
-							multipleValues: true,
+							type: 'boolean',
+							default: false,
+							description: 'If only the values set on this node should be<br />kept and all others removed.',
 						},
-						description: 'The value to set.',
+						{
-						default: {},
+							displayName: 'Values to Set',
-						options: [
+							name: 'values',
-							{
+							placeholder: 'Add Value',
-								name: 'number',
+							type: 'fixedCollection',
-								displayName: 'Number',
+							typeOptions: {
-								values: [
+								multipleValues: true,
-									{
-										displayName: 'Name',
-										name: 'name',
-										type: 'string',
-										default: 'propertyName',
-										description: 'Name of the property to write data to.<br />Supports dot-notation.<br />Example: "data.person[0].name"',
-									},
-									{
-										displayName: 'Value',
-										name: 'value',
-										type: 'number',
-										default: 0,
-										description: 'The number value to write in the property.',
-									},
-								]
 							},
-						],
+							description: 'The value to set.',
-					},
+							default: {},
-				]
+							options: [
-			},
+								{
-			execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+									name: 'number',
-				const items = this.getInputData();
+									displayName: 'Number',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description: 'Name of the property to write data to.<br />Supports dot-notation.<br />Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'number',
+											default: 0,
+											description: 'The number value to write in the property.',
+										},
+									]
+								},
+							],
+						},
+					]
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
 
-				let item: INodeExecutionData;
+					const returnData: INodeExecutionData[] = [];
-				for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+					let item: INodeExecutionData;
-					item = items[itemIndex];
+					for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
-					// Add number values
+						item = items[itemIndex];
-					(this.getNodeParameter('values.number', itemIndex, []) as INodeParameters[]).forEach((setItem) => {
+
-						set(item.json, setItem.name as string, setItem.value);
+						const newItem: INodeExecutionData = {
-					});
+							json: JSON.parse(JSON.stringify(item.json)),
+						};
+
+						// Add number values
+						(this.getNodeParameter('values.number', itemIndex, []) as INodeParameters[]).forEach((setItem) => {
+							set(newItem.json, setItem.name as string, setItem.value);
+						});
+
+						returnData.push(newItem);
+					}
+
+					return this.prepareOutputData(returnData);
 				}
-
+			},
-				return this.prepareOutputData(items);
-			}
 		},
 		'n8n-nodes-base.start': {
-			description: {
+			sourcePath: '',
-				displayName: 'Start',
+			type: {
-				name: 'start',
+				description: {
-				group: ['input'],
+					displayName: 'Start',
-				version: 1,
+					name: 'start',
-				description: 'Starts the workflow execution from this node',
+					group: ['input'],
-				defaults: {
+					version: 1,
-					name: 'Start',
+					description: 'Starts the workflow execution from this node',
-					color: '#553399',
+					defaults: {
+						name: 'Start',
+						color: '#553399',
+					},
+					inputs: [],
+					outputs: ['main'],
+					properties: []
 				},
-				inputs: [],
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-				outputs: ['main'],
+					const items = this.getInputData();
-				properties: []
-			},
-			execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
-				const items = this.getInputData();
 
-				return this.prepareOutputData(items);
+					return this.prepareOutputData(items);
+				},
 			},
 		},
 	};
 
-	async init(nodeTypes: INodeTypesObject): Promise<void> { }
+	async init(nodeTypes: INodeTypeData): Promise<void> { }
 
 	getAll(): INodeType[] {
-		return Object.values(this.nodeTypes);
+		return Object.values(this.nodeTypes).map((data) => data.type);
 	}
 
 	getByName(nodeType: string): INodeType {
-		return this.nodeTypes[nodeType];
+		return this.nodeTypes[nodeType].type;
 	}
 }
 
@@ -235,12 +252,12 @@ export function WorkflowExecuteAdditionalData(waitPromise: IDeferredPromise<IRun
 		credentials: {},
 		hooks: {
 			nodeExecuteAfter: [
-				async (executionId: string, nodeName: string, data: ITaskData): Promise<void> => {
+				async (nodeName: string, data: ITaskData): Promise<void> => {
 					nodeExecutionOrder.push(nodeName);
 				},
 			],
 			workflowExecuteAfter: [
-				async (fullRunData: IRun, executionId: string): Promise<void> => {
+				async (fullRunData: IRun): Promise<void> => {
 					waitPromise.resolve(fullRunData);
 				},
 			],

packages/core/test/WorkflowExecute.test.ts

@@ -587,11 +587,14 @@ describe('WorkflowExecute', () => {
 
 				const workflowExecute = new WorkflowExecute(additionalData, executionMode);
 
-				const executionId = await workflowExecute.run(workflowInstance, undefined);
+				const executionData = await workflowExecute.run(workflowInstance, undefined);
-				expect(executionId).toBeDefined();
 
 				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) {

packages/workflow/test/Helpers.ts

@@ -1,99 +1,109 @@
 import {
 	INodeType,
 	INodeTypes,
-	INodeTypesObject,
+	INodeTypeData,
 } from '../src';
 
+export interface INodeTypesObject {
+	[key: string]: INodeType;
+}
+
 class NodeTypesClass implements INodeTypes {
 
-	nodeTypes: INodeTypesObject = {
+	nodeTypes: INodeTypeData = {
 		'test.set': {
-			description: {
+			sourcePath: '',
-				displayName: 'Set',
+			type: {
-				name: 'set',
+				description: {
-				group: ['input'],
+					displayName: 'Set',
-				version: 1,
+					name: 'set',
-				description: 'Sets a value',
+					group: ['input'],
-				defaults: {
+					version: 1,
-					name: 'Set',
+					description: 'Sets a value',
-					color: '#0000FF',
+					defaults: {
-				},
+						name: 'Set',
-				inputs: ['main'],
+						color: '#0000FF',
-				outputs: ['main'],
-				properties: [
-					{
-						displayName: 'Value1',
-						name: 'value1',
-						type: 'string',
-						default: 'default-value1',
 					},
-					{
+					inputs: ['main'],
-						displayName: 'Value2',
+					outputs: ['main'],
-						name: 'value2',
+					properties: [
-						type: 'string',
+						{
-						default: 'default-value2',
+							displayName: 'Value1',
-					}
+							name: 'value1',
-				]
+							type: 'string',
+							default: 'default-value1',
+						},
+						{
+							displayName: 'Value2',
+							name: 'value2',
+							type: 'string',
+							default: 'default-value2',
+						}
+					]
+				}
 			}
 		},
 		'test.setMulti': {
-			description: {
+			sourcePath: '',
-				displayName: 'Set Multi',
+			type: {
-				name: 'setMulti',
+				description: {
-				group: ['input'],
+					displayName: 'Set Multi',
-				version: 1,
+					name: 'setMulti',
-				description: 'Sets multiple values',
+					group: ['input'],
-				defaults: {
+					version: 1,
-					name: 'Set Multi',
+					description: 'Sets multiple values',
-					color: '#0000FF',
+					defaults: {
-				},
+						name: 'Set Multi',
-				inputs: ['main'],
+						color: '#0000FF',
-				outputs: ['main'],
-				properties: [
-					{
-						displayName: 'Values',
-						name: 'values',
-						type: 'fixedCollection',
-						typeOptions: {
-							multipleValues: true,
-						},
-						default: {},
-						options: [
-							{
-								name: 'string',
-								displayName: 'String',
-								values: [
-									{
-										displayName: 'Name',
-										name: 'name',
-										type: 'string',
-										default: 'propertyName',
-										placeholder: 'Name of the property to write data to.',
-									},
-									{
-										displayName: 'Value',
-										name: 'value',
-										type: 'string',
-										default: '',
-										placeholder: 'The string value to write in the property.',
-									},
-								]
-							},
-						],
 					},
-				]
+					inputs: ['main'],
+					outputs: ['main'],
+					properties: [
+						{
+							displayName: 'Values',
+							name: 'values',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+							},
+							default: {},
+							options: [
+								{
+									name: 'string',
+									displayName: 'String',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											placeholder: 'Name of the property to write data to.',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'string',
+											default: '',
+											placeholder: 'The string value to write in the property.',
+										},
+									]
+								},
+							],
+						},
+					]
+				}
 			}
 		},
 	};
 
-	async init(nodeTypes: INodeTypesObject): Promise<void> { }
+	async init(nodeTypes: INodeTypeData): Promise<void> { }
 
 	getAll(): INodeType[] {
-		return Object.values(this.nodeTypes);
+		return Object.values(this.nodeTypes).map((data) => data.type);
 	}
 
 	getByName(nodeType: string): INodeType {
-		return this.nodeTypes[nodeType];
+		return this.nodeTypes[nodeType].type;
 	}
 }