import type { SuperAgentTest } from 'supertest'; import type { INode, IPinData } from 'n8n-workflow'; import * as UserManagementHelpers from '@/UserManagement/UserManagementHelper'; import type { User } from '@db/entities/User'; import { v4 as uuid } from 'uuid'; import { RoleService } from '@/services/role.service'; import Container from 'typedi'; import type { ListQuery } from '@/requests'; import { WorkflowHistoryRepository } from '@db/repositories/workflowHistory.repository'; import { ActiveWorkflowRunner } from '@/ActiveWorkflowRunner'; import { mockInstance } from '../shared/mocking'; import * as utils from './shared/utils/'; import * as testDb from './shared/testDb'; import { makeWorkflow, MOCK_PINDATA } from './shared/utils/'; import { randomCredentialPayload } from './shared/random'; import { saveCredential } from './shared/db/credentials'; import { createOwner } from './shared/db/users'; import { createWorkflow } from './shared/db/workflows'; import { createTag } from './shared/db/tags'; import { Push } from '@/push'; let owner: User; let authOwnerAgent: SuperAgentTest; jest.spyOn(UserManagementHelpers, 'isSharingEnabled').mockReturnValue(false); const testServer = utils.setupTestServer({ endpointGroups: ['workflows'] }); const license = testServer.license; const { objectContaining, arrayContaining, any } = expect; const activeWorkflowRunnerLike = mockInstance(ActiveWorkflowRunner); mockInstance(Push); beforeAll(async () => { owner = await createOwner(); authOwnerAgent = testServer.authAgentFor(owner); }); beforeEach(async () => { jest.resetAllMocks(); await testDb.truncate(['Workflow', 'SharedWorkflow', 'Tag', 'WorkflowHistory']); }); describe('POST /workflows', () => { const testWithPinData = async (withPinData: boolean) => { const workflow = makeWorkflow({ withPinData }); const response = await authOwnerAgent.post('/workflows').send(workflow); expect(response.statusCode).toBe(200); return (response.body.data as { pinData: IPinData }).pinData; }; test('should store pin data for node in workflow', async () => { const pinData = await testWithPinData(true); expect(pinData).toMatchObject(MOCK_PINDATA); }); test('should set pin data to null if no pin data', async () => { const pinData = await testWithPinData(false); expect(pinData).toBeNull(); }); test('should create workflow history version when licensed', async () => { license.enable('feat:workflowHistory'); const payload = { name: 'testing', nodes: [ { id: 'uuid-1234', parameters: {}, name: 'Start', type: 'n8n-nodes-base.start', typeVersion: 1, position: [240, 300], }, ], connections: {}, staticData: null, settings: { saveExecutionProgress: true, saveManualExecutions: true, saveDataErrorExecution: 'all', saveDataSuccessExecution: 'all', executionTimeout: 3600, timezone: 'America/New_York', }, active: false, }; const response = await authOwnerAgent.post('/workflows').send(payload); expect(response.statusCode).toBe(200); const { data: { id }, } = response.body; expect(id).toBeDefined(); expect( await Container.get(WorkflowHistoryRepository).count({ where: { workflowId: id } }), ).toBe(1); const historyVersion = await Container.get(WorkflowHistoryRepository).findOne({ where: { workflowId: id, }, }); expect(historyVersion).not.toBeNull(); expect(historyVersion!.connections).toEqual(payload.connections); expect(historyVersion!.nodes).toEqual(payload.nodes); }); test('should not create workflow history version when not licensed', async () => { license.disable('feat:workflowHistory'); const payload = { name: 'testing', nodes: [ { id: 'uuid-1234', parameters: {}, name: 'Start', type: 'n8n-nodes-base.start', typeVersion: 1, position: [240, 300], }, ], connections: {}, staticData: null, settings: { saveExecutionProgress: true, saveManualExecutions: true, saveDataErrorExecution: 'all', saveDataSuccessExecution: 'all', executionTimeout: 3600, timezone: 'America/New_York', }, active: false, }; const response = await authOwnerAgent.post('/workflows').send(payload); expect(response.statusCode).toBe(200); const { data: { id }, } = response.body; expect(id).toBeDefined(); expect( await Container.get(WorkflowHistoryRepository).count({ where: { workflowId: id } }), ).toBe(0); }); }); describe('GET /workflows/:id', () => { test('should return pin data', async () => { const workflow = makeWorkflow({ withPinData: true }); const workflowCreationResponse = await authOwnerAgent.post('/workflows').send(workflow); const { id } = workflowCreationResponse.body.data as { id: string }; const workflowRetrievalResponse = await authOwnerAgent.get(`/workflows/${id}`); expect(workflowRetrievalResponse.statusCode).toBe(200); const { pinData } = workflowRetrievalResponse.body.data as { pinData: IPinData }; expect(pinData).toMatchObject(MOCK_PINDATA); }); }); describe('GET /workflows', () => { test('should return zero workflows if none exist', async () => { const response = await authOwnerAgent.get('/workflows').expect(200); expect(response.body).toEqual({ count: 0, data: [] }); }); test('should return workflows', async () => { const credential = await saveCredential(randomCredentialPayload(), { user: owner, role: await Container.get(RoleService).findCredentialOwnerRole(), }); const nodes: INode[] = [ { id: uuid(), name: 'Action Network', type: 'n8n-nodes-base.actionNetwork', parameters: {}, typeVersion: 1, position: [0, 0], credentials: { actionNetworkApi: { id: credential.id, name: credential.name, }, }, }, ]; const tag = await createTag({ name: 'A' }); await createWorkflow({ name: 'First', nodes, tags: [tag] }, owner); await createWorkflow({ name: 'Second' }, owner); const response = await authOwnerAgent.get('/workflows').expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ objectContaining({ id: any(String), name: 'First', active: any(Boolean), createdAt: any(String), updatedAt: any(String), tags: [{ id: any(String), name: 'A' }], versionId: any(String), ownedBy: { id: owner.id, email: any(String), firstName: any(String), lastName: any(String), }, sharedWith: [], }), objectContaining({ id: any(String), name: 'Second', active: any(Boolean), createdAt: any(String), updatedAt: any(String), tags: [], versionId: any(String), ownedBy: { id: owner.id, email: any(String), firstName: any(String), lastName: any(String), }, sharedWith: [], }), ]), }); const found = response.body.data.find( (w: ListQuery.Workflow.WithOwnership) => w.name === 'First', ); expect(found.nodes).toBeUndefined(); expect(found.sharedWith).toHaveLength(0); expect(found.usedCredentials).toBeUndefined(); }); describe('filter', () => { test('should filter workflows by field: name', async () => { await createWorkflow({ name: 'First' }, owner); await createWorkflow({ name: 'Second' }, owner); const response = await authOwnerAgent .get('/workflows') .query('filter={"name":"First"}') .expect(200); expect(response.body).toEqual({ count: 1, data: [objectContaining({ name: 'First' })], }); }); test('should filter workflows by field: active', async () => { await createWorkflow({ active: true }, owner); await createWorkflow({ active: false }, owner); const response = await authOwnerAgent .get('/workflows') .query('filter={ "active": true }') .expect(200); expect(response.body).toEqual({ count: 1, data: [objectContaining({ active: true })], }); }); test('should filter workflows by field: tags', async () => { const workflow = await createWorkflow({ name: 'First' }, owner); await createTag({ name: 'A' }, workflow); await createTag({ name: 'B' }, workflow); const response = await authOwnerAgent .get('/workflows') .query('filter={ "tags": ["A"] }') .expect(200); expect(response.body).toEqual({ count: 1, data: [objectContaining({ name: 'First', tags: [{ id: any(String), name: 'A' }] })], }); }); }); describe('select', () => { test('should select workflow field: name', async () => { await createWorkflow({ name: 'First' }, owner); await createWorkflow({ name: 'Second' }, owner); const response = await authOwnerAgent.get('/workflows').query('select=["name"]').expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ { id: any(String), name: 'First' }, { id: any(String), name: 'Second' }, ]), }); }); test('should select workflow field: active', async () => { await createWorkflow({ active: true }, owner); await createWorkflow({ active: false }, owner); const response = await authOwnerAgent .get('/workflows') .query('select=["active"]') .expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ { id: any(String), active: true }, { id: any(String), active: false }, ]), }); }); test('should select workflow field: tags', async () => { const firstWorkflow = await createWorkflow({ name: 'First' }, owner); const secondWorkflow = await createWorkflow({ name: 'Second' }, owner); await createTag({ name: 'A' }, firstWorkflow); await createTag({ name: 'B' }, secondWorkflow); const response = await authOwnerAgent.get('/workflows').query('select=["tags"]').expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ objectContaining({ id: any(String), tags: [{ id: any(String), name: 'A' }] }), objectContaining({ id: any(String), tags: [{ id: any(String), name: 'B' }] }), ]), }); }); test('should select workflow fields: createdAt and updatedAt', async () => { const firstWorkflowCreatedAt = '2023-08-08T09:31:25.000Z'; const firstWorkflowUpdatedAt = '2023-08-08T09:31:40.000Z'; const secondWorkflowCreatedAt = '2023-07-07T09:31:25.000Z'; const secondWorkflowUpdatedAt = '2023-07-07T09:31:40.000Z'; await createWorkflow( { createdAt: new Date(firstWorkflowCreatedAt), updatedAt: new Date(firstWorkflowUpdatedAt), }, owner, ); await createWorkflow( { createdAt: new Date(secondWorkflowCreatedAt), updatedAt: new Date(secondWorkflowUpdatedAt), }, owner, ); const response = await authOwnerAgent .get('/workflows') .query('select=["createdAt", "updatedAt"]') .expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ objectContaining({ id: any(String), createdAt: firstWorkflowCreatedAt, updatedAt: firstWorkflowUpdatedAt, }), objectContaining({ id: any(String), createdAt: secondWorkflowCreatedAt, updatedAt: secondWorkflowUpdatedAt, }), ]), }); }); test('should select workflow field: versionId', async () => { const firstWorkflowVersionId = 'e95ccdde-2b4e-4fd0-8834-220a2b5b4353'; const secondWorkflowVersionId = 'd099b8dc-b1d8-4b2d-9b02-26f32c0ee785'; await createWorkflow({ versionId: firstWorkflowVersionId }, owner); await createWorkflow({ versionId: secondWorkflowVersionId }, owner); const response = await authOwnerAgent .get('/workflows') .query('select=["versionId"]') .expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ { id: any(String), versionId: firstWorkflowVersionId }, { id: any(String), versionId: secondWorkflowVersionId }, ]), }); }); test('should select workflow field: ownedBy', async () => { await createWorkflow({}, owner); await createWorkflow({}, owner); const response = await authOwnerAgent .get('/workflows') .query('select=["ownedBy"]') .expect(200); expect(response.body).toEqual({ count: 2, data: arrayContaining([ { id: any(String), ownedBy: { id: owner.id, email: any(String), firstName: any(String), lastName: any(String), }, sharedWith: [], }, { id: any(String), ownedBy: { id: owner.id, email: any(String), firstName: any(String), lastName: any(String), }, sharedWith: [], }, ]), }); }); }); }); describe('PATCH /workflows/:id', () => { test('should create workflow history version when licensed', async () => { license.enable('feat:workflowHistory'); const workflow = await createWorkflow({}, owner); const payload = { name: 'name updated', versionId: workflow.versionId, nodes: [ { id: 'uuid-1234', parameters: {}, name: 'Start', type: 'n8n-nodes-base.start', typeVersion: 1, position: [240, 300], }, { id: 'uuid-1234', parameters: {}, name: 'Cron', type: 'n8n-nodes-base.cron', typeVersion: 1, position: [400, 300], }, ], connections: {}, staticData: '{"id":1}', settings: { saveExecutionProgress: false, saveManualExecutions: false, saveDataErrorExecution: 'all', saveDataSuccessExecution: 'all', executionTimeout: 3600, timezone: 'America/New_York', }, }; const response = await authOwnerAgent.patch(`/workflows/${workflow.id}`).send(payload); const { data: { id }, } = response.body; expect(response.statusCode).toBe(200); expect(id).toBe(workflow.id); expect( await Container.get(WorkflowHistoryRepository).count({ where: { workflowId: id } }), ).toBe(1); const historyVersion = await Container.get(WorkflowHistoryRepository).findOne({ where: { workflowId: id, }, }); expect(historyVersion).not.toBeNull(); expect(historyVersion!.connections).toEqual(payload.connections); expect(historyVersion!.nodes).toEqual(payload.nodes); }); test('should not create workflow history version when not licensed', async () => { license.disable('feat:workflowHistory'); const workflow = await createWorkflow({}, owner); const payload = { name: 'name updated', versionId: workflow.versionId, nodes: [ { id: 'uuid-1234', parameters: {}, name: 'Start', type: 'n8n-nodes-base.start', typeVersion: 1, position: [240, 300], }, { id: 'uuid-1234', parameters: {}, name: 'Cron', type: 'n8n-nodes-base.cron', typeVersion: 1, position: [400, 300], }, ], connections: {}, staticData: '{"id":1}', settings: { saveExecutionProgress: false, saveManualExecutions: false, saveDataErrorExecution: 'all', saveDataSuccessExecution: 'all', executionTimeout: 3600, timezone: 'America/New_York', }, }; const response = await authOwnerAgent.patch(`/workflows/${workflow.id}`).send(payload); const { data: { id }, } = response.body; expect(response.statusCode).toBe(200); expect(id).toBe(workflow.id); expect( await Container.get(WorkflowHistoryRepository).count({ where: { workflowId: id } }), ).toBe(0); }); test('should activate workflow without changing version ID', async () => { license.disable('feat:workflowHistory'); const workflow = await createWorkflow({}, owner); const payload = { versionId: workflow.versionId, active: true, }; const response = await authOwnerAgent.patch(`/workflows/${workflow.id}`).send(payload); expect(response.statusCode).toBe(200); expect(activeWorkflowRunnerLike.add).toBeCalled(); const { data: { id, versionId, active }, } = response.body; expect(id).toBe(workflow.id); expect(versionId).toBe(workflow.versionId); expect(active).toBe(true); }); test('should deactivate workflow without changing version ID', async () => { license.disable('feat:workflowHistory'); const workflow = await createWorkflow({ active: true }, owner); const payload = { versionId: workflow.versionId, active: false, }; const response = await authOwnerAgent.patch(`/workflows/${workflow.id}`).send(payload); expect(response.statusCode).toBe(200); expect(activeWorkflowRunnerLike.add).not.toBeCalled(); expect(activeWorkflowRunnerLike.remove).toBeCalled(); const { data: { id, versionId, active }, } = response.body; expect(id).toBe(workflow.id); expect(versionId).toBe(workflow.versionId); expect(active).toBe(false); }); });