From dd2b55e352b21ea373a1f62880953ba125c1f48c Mon Sep 17 00:00:00 2001
From: Omar Ajoue <krynble@gmail.com>
Date: Mon, 12 Sep 2022 15:52:06 +0200
Subject: [PATCH] test: Add more tests to active executions file (#4071)

* test: Add more tests to active executions file
---
 .../cli/test/unit/ActiveExecutions.test.ts    | 75 ++++++++++++++++++-
 1 file changed, 73 insertions(+), 2 deletions(-)

diff --git a/packages/cli/test/unit/ActiveExecutions.test.ts b/packages/cli/test/unit/ActiveExecutions.test.ts
index 7be21960ef..452ee4e1b0 100644
--- a/packages/cli/test/unit/ActiveExecutions.test.ts
+++ b/packages/cli/test/unit/ActiveExecutions.test.ts
@@ -2,7 +2,7 @@ import { ActiveExecutions, IWorkflowExecutionDataProcess, Db } from '../../src';
 import { mocked } from 'jest-mock';
 import PCancelable from 'p-cancelable';
 import { v4 as uuid } from 'uuid';
-import type { IRun } from 'n8n-workflow';
+import { createDeferredPromise, IDeferredPromise, IExecuteResponsePromiseData, IRun } from 'n8n-workflow';
 
 const FAKE_EXECUTION_ID = '15';
 const FAKE_SECOND_EXECUTION_ID = '20';
@@ -37,6 +37,7 @@ describe('ActiveExecutions', () => {
 	test('Should add execution to active execution list', async () => {
 		const newExecution = mockExecutionData();
 		const executionId = await activeExecutions.add(newExecution);
+
 		expect(executionId).toBe(FAKE_EXECUTION_ID);
 		expect(activeExecutions.getActiveExecutions().length).toBe(1);
 		expect(mocked(Db.collections.Execution.save)).toHaveBeenCalledTimes(1);
@@ -46,6 +47,7 @@ describe('ActiveExecutions', () => {
 	test('Should update execution if add is called with execution ID', async () => {
 		const newExecution = mockExecutionData();
 		const executionId = await activeExecutions.add(newExecution, undefined, FAKE_SECOND_EXECUTION_ID);
+
 		expect(executionId).toBe(FAKE_SECOND_EXECUTION_ID);
 		expect(activeExecutions.getActiveExecutions().length).toBe(1);
 		expect(mocked(Db.collections.Execution.save)).toHaveBeenCalledTimes(0);
@@ -54,6 +56,7 @@ describe('ActiveExecutions', () => {
 
 	test('Should fail attaching execution to invalid executionId', async () => {
 		const deferredPromise = mockCancelablePromise();
+
 		expect(() => {
 			activeExecutions.attachWorkflowExecution(FAKE_EXECUTION_ID, deferredPromise);
 		}).toThrow();
@@ -63,7 +66,59 @@ describe('ActiveExecutions', () => {
 		const newExecution = mockExecutionData();
 		await activeExecutions.add(newExecution, undefined, FAKE_EXECUTION_ID);
 		const deferredPromise = mockCancelablePromise();
-		activeExecutions.attachWorkflowExecution(FAKE_EXECUTION_ID, deferredPromise);
+
+		expect(() => activeExecutions.attachWorkflowExecution(FAKE_EXECUTION_ID, deferredPromise)).not.toThrow();
+	});
+
+	test('Should attach and resolve response promise to existing execution', async () => {
+		const newExecution = mockExecutionData();
+		await activeExecutions.add(newExecution, undefined, FAKE_EXECUTION_ID);
+		const deferredPromise = await mockDeferredPromise();
+		activeExecutions.attachResponsePromise(FAKE_EXECUTION_ID, deferredPromise);
+		const fakeResponse = {data: {resultData: {runData: {}}}};
+		activeExecutions.resolveResponsePromise(FAKE_EXECUTION_ID, fakeResponse);
+
+		expect(deferredPromise.promise()).resolves.toEqual(fakeResponse);
+	});
+
+	test('Should remove an existing execution', async () => {
+		const newExecution = mockExecutionData();
+		const executionId = await activeExecutions.add(newExecution);
+		activeExecutions.remove(executionId);
+
+		expect(activeExecutions.getActiveExecutions().length).toBe(0);
+	});
+
+	test('Should resolve post execute promise on removal', async () => {
+		const newExecution = mockExecutionData();
+		const executionId = await activeExecutions.add(newExecution);
+		const postExecutePromise = activeExecutions.getPostExecutePromise(executionId);
+		// Force the above to be executed since we cannot await it
+		await new Promise((res) => {
+			setTimeout(res, 100);
+		});
+		const fakeOutput = mockFullRunData();
+		activeExecutions.remove(executionId, fakeOutput);
+
+		expect(postExecutePromise).resolves.toEqual(fakeOutput);
+	});
+
+	test('Should throw error when trying to create a promise with invalid execution', async() => {
+		expect(
+				activeExecutions.getPostExecutePromise(FAKE_EXECUTION_ID)
+		).rejects.toThrow();
+	});
+
+	test('Should call function to cancel execution when asked to stop', async () => {
+		const newExecution = mockExecutionData();
+		const executionId = await activeExecutions.add(newExecution);
+		const cancelExecution = jest.fn();
+		const cancellablePromise = mockCancelablePromise();
+		cancellablePromise.cancel = cancelExecution;
+		activeExecutions.attachWorkflowExecution(executionId, cancellablePromise);
+		activeExecutions.stopExecution(executionId);
+
+		expect(cancelExecution).toHaveBeenCalledTimes(1);
 	});
 
 });
@@ -83,9 +138,25 @@ function mockExecutionData(): IWorkflowExecutionDataProcess {
 	}
 }
 
+function mockFullRunData(): IRun {
+	return {
+		data: {
+			resultData: {
+				runData: {}
+			}
+		},
+		mode: 'manual',
+		startedAt: new Date(),
+	};
+}
+
 function mockCancelablePromise(): PCancelable<IRun> {
 	return new PCancelable(async (resolve) => {
 		resolve();
 	});
 }
 
+function mockDeferredPromise(): Promise<IDeferredPromise<IExecuteResponsePromiseData>> {
+	return createDeferredPromise<IExecuteResponsePromiseData>();
+}
+