n8n/packages/cli/test/integration/publicApi/workflows.test.ts
Michael Auerswald b67f803cbe
feat: Add global event bus (#4860)
* fix branch

* fix deserialize, add filewriter

* add catchAll eventGroup/Name

* adding simple Redis sender and receiver to eventbus

* remove native node threads

* improve eventbus

* refactor and simplify

* more refactoring and syslog client

* more refactor, improved endpoints and eventbus

* remove local broker and receivers from mvp

* destination de/serialization

* create MessageEventBusDestinationEntity

* db migrations, load destinations at startup

* add delete destination endpoint

* pnpm merge and circular import fix

* delete destination fix

* trigger log file shuffle after size reached

* add environment variables for eventbus

* reworking event messages

* serialize to thread fix

* some refactor and lint fixing

* add emit to eventbus

* cleanup and fix sending unsent

* quicksave frontend trial

* initial EventTree vue component

* basic log streaming settings in vue

* http request code merge

* create destination settings modals

* fix eventmessage options types

* credentials are loaded

* fix and clean up frontend code

* move request code to axios

* update lock file

* merge fix

* fix redis build

* move destination interfaces into workflow pkg

* revive sentry as destination

* migration fixes and frontend cleanup

* N8N-5777 / N8N-5789 N8N-5788

* N8N-5784

* N8N-5782 removed event levels

* N8N-5790 sentry destination cleanup

* N8N-5786 and refactoring

* N8N-5809 and refactor/cleanup

* UI fixes and anonymize renaming

* N8N-5837

* N8N-5834

* fix no-items UI issues

* remove card / settings label in modal

* N8N-5842 fix

* disable webhook auth for now and update ui

* change sidebar to tabs

* remove payload option

* extend audit events with more user data

* N8N-5853 and UI revert to sidebar

* remove redis destination

* N8N-5864 / N8N-5868 / N8N-5867 / N8N-5865

* ui and licensing fixes

* add node events and info bubbles to frontend

* ui wording changes

* frontend tests

* N8N-5896 and ee rename

* improves backend tests

* merge fix

* fix backend test

* make linter happy

* remove unnecessary cfg / limit  actions to owners

* fix multiple sentry DSN and anon bug

* eslint fix

* more tests and fixes

* merge fix

* fix workflow audit events

* remove 'n8n.workflow.execution.error' event

* merge fix

* lint fix

* lint fix

* review fixes

* fix merge

* prettier fixes

* merge

* review changes

* use loggerproxy

* remove catch from internal hook promises

* fix tests

* lint fix

* include review PR changes

* review changes

* delete duplicate lines from a bad merge

* decouple log-streaming UI options from public API

* logstreaming -> log-streaming for consistency

* do not make unnecessary api calls when log streaming is disabled

* prevent sentryClient.close() from being called if init failed

* fix the e2e test for log-streaming

* review changes

* cleanup

* use `private` for one last private property

* do not use node prefix package names.. just yet

* remove unused import

* fix the tests

because there is a folder called `events`, tsc-alias is messing up all imports for native events module.
https://github.com/justkey007/tsc-alias/issues/152

Co-authored-by: कारतोफ्फेलस्क्रिप्ट™ <aditya@netroy.in>
2023-01-04 09:47:48 +01:00

1271 lines
34 KiB
TypeScript

import express from 'express';
import * as Db from '@/Db';
import config from '@/config';
import { Role } from '@db/entities/Role';
import { TagEntity } from '@db/entities/TagEntity';
import { ActiveWorkflowRunner } from '@/ActiveWorkflowRunner';
import { randomApiKey } from '../shared/random';
import * as utils from '../shared/utils';
import * as testDb from '../shared/testDb';
let app: express.Application;
let testDbName = '';
let globalOwnerRole: Role;
let globalMemberRole: Role;
let workflowOwnerRole: Role;
let workflowRunner: ActiveWorkflowRunner;
beforeAll(async () => {
app = await utils.initTestServer({ endpointGroups: ['publicApi'], applyAuth: false });
const initResult = await testDb.init();
testDbName = initResult.testDbName;
const [fetchedGlobalOwnerRole, fetchedGlobalMemberRole, fetchedWorkflowOwnerRole] =
await testDb.getAllRoles();
globalOwnerRole = fetchedGlobalOwnerRole;
globalMemberRole = fetchedGlobalMemberRole;
workflowOwnerRole = fetchedWorkflowOwnerRole;
utils.initTestTelemetry();
utils.initTestLogger();
utils.initConfigFile();
await utils.initNodeTypes();
workflowRunner = await utils.initActiveWorkflowRunner();
});
beforeEach(async () => {
await testDb.truncate(
['SharedCredentials', 'SharedWorkflow', 'Tag', 'User', 'Workflow', 'Credentials'],
testDbName,
);
config.set('userManagement.disabled', false);
config.set('userManagement.isInstanceOwnerSetUp', true);
});
afterEach(async () => {
await workflowRunner.removeAll();
});
afterAll(async () => {
await testDb.terminate(testDbName);
});
test('GET /workflows should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.get('/workflows');
expect(response.statusCode).toBe(401);
});
test('GET /workflows should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.get('/workflows');
expect(response.statusCode).toBe(401);
});
test('GET /workflows should return all owned workflows', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
await Promise.all([
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, member),
]);
const response = await authAgent.get('/workflows');
expect(response.statusCode).toBe(200);
expect(response.body.data.length).toBe(3);
expect(response.body.nextCursor).toBeNull();
for (const workflow of response.body.data) {
const {
id,
connections,
active,
staticData,
nodes,
settings,
name,
createdAt,
updatedAt,
tags,
} = workflow;
expect(id).toBeDefined();
expect(name).toBeDefined();
expect(connections).toBeDefined();
expect(active).toBe(false);
expect(staticData).toBeDefined();
expect(nodes).toBeDefined();
expect(tags).toBeDefined();
expect(settings).toBeDefined();
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
}
});
test('GET /workflows should return all owned workflows with pagination', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
await Promise.all([
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, member),
]);
const response = await authAgent.get('/workflows?limit=1');
expect(response.statusCode).toBe(200);
expect(response.body.data.length).toBe(1);
expect(response.body.nextCursor).not.toBeNull();
const response2 = await authAgent.get(`/workflows?limit=1&cursor=${response.body.nextCursor}`);
expect(response2.statusCode).toBe(200);
expect(response2.body.data.length).toBe(1);
expect(response2.body.nextCursor).not.toBeNull();
expect(response2.body.nextCursor).not.toBe(response.body.nextCursor);
const responses = [...response.body.data, ...response2.body.data];
for (const workflow of responses) {
const {
id,
connections,
active,
staticData,
nodes,
settings,
name,
createdAt,
updatedAt,
tags,
} = workflow;
expect(id).toBeDefined();
expect(name).toBeDefined();
expect(connections).toBeDefined();
expect(active).toBe(false);
expect(staticData).toBeDefined();
expect(nodes).toBeDefined();
expect(tags).toBeDefined();
expect(settings).toBeDefined();
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
}
// check that we really received a different result
expect(Number(response.body.data[0].id)).toBeLessThan(Number(response2.body.data[0].id));
});
test('GET /workflows should return all owned workflows filtered by tag', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
const tag = await testDb.createTag({});
const [workflow] = await Promise.all([
testDb.createWorkflow({ tags: [tag] }, member),
testDb.createWorkflow({}, member),
]);
const response = await authAgent.get(`/workflows?tags=${tag.name}`);
expect(response.statusCode).toBe(200);
expect(response.body.data.length).toBe(1);
const {
id,
connections,
active,
staticData,
nodes,
settings,
name,
createdAt,
updatedAt,
tags: wfTags,
} = response.body.data[0];
expect(id).toBe(workflow.id);
expect(name).toBeDefined();
expect(connections).toBeDefined();
expect(active).toBe(false);
expect(staticData).toBeDefined();
expect(nodes).toBeDefined();
expect(settings).toBeDefined();
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
expect(wfTags.length).toBe(1);
expect(wfTags[0].id).toBe(tag.id);
});
test('GET /workflows should return all owned workflows filtered by tags', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
const tags = await Promise.all([await testDb.createTag({}), await testDb.createTag({})]);
const tagNames = tags.map((tag) => tag.name).join(',');
const [workflow1, workflow2] = await Promise.all([
testDb.createWorkflow({ tags }, member),
testDb.createWorkflow({ tags }, member),
testDb.createWorkflow({}, member),
testDb.createWorkflow({ tags: [tags[0]] }, member),
testDb.createWorkflow({ tags: [tags[1]] }, member),
]);
const response = await authAgent.get(`/workflows?tags=${tagNames}`);
expect(response.statusCode).toBe(200);
expect(response.body.data.length).toBe(2);
for (const workflow of response.body.data) {
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
workflow;
expect(id).toBeDefined();
expect([workflow1.id, workflow2.id].includes(id)).toBe(true);
expect(name).toBeDefined();
expect(connections).toBeDefined();
expect(active).toBe(false);
expect(staticData).toBeDefined();
expect(nodes).toBeDefined();
expect(settings).toBeDefined();
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
expect(workflow.tags.length).toBe(2);
workflow.tags.forEach((tag: TagEntity) => {
expect(tags.some((savedTag) => savedTag.id === tag.id)).toBe(true);
});
}
});
test('GET /workflows should return all workflows for owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
await Promise.all([
testDb.createWorkflow({}, owner),
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, owner),
testDb.createWorkflow({}, member),
testDb.createWorkflow({}, owner),
]);
const response = await authOwnerAgent.get('/workflows');
expect(response.statusCode).toBe(200);
expect(response.body.data.length).toBe(5);
expect(response.body.nextCursor).toBeNull();
for (const workflow of response.body.data) {
const {
id,
connections,
active,
staticData,
nodes,
settings,
name,
createdAt,
updatedAt,
tags,
} = workflow;
expect(id).toBeDefined();
expect(name).toBeDefined();
expect(connections).toBeDefined();
expect(active).toBe(false);
expect(staticData).toBeDefined();
expect(nodes).toBeDefined();
expect(tags).toBeDefined();
expect(settings).toBeDefined();
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
}
});
test('GET /workflows/:id should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
owner.apiKey = null;
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.get(`/workflows/2`);
expect(response.statusCode).toBe(401);
});
test('GET /workflows/:id should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.get(`/workflows/2`);
expect(response.statusCode).toBe(401);
});
test('GET /workflows/:id should fail due to non-existing workflow', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.get(`/workflows/2`);
expect(response.statusCode).toBe(404);
});
test('GET /workflows/:id should retrieve workflow', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
// create and assign workflow to owner
const workflow = await testDb.createWorkflow({}, member);
const response = await authAgent.get(`/workflows/${workflow.id}`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt, tags } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(tags).toEqual([]);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
});
test('GET /workflows/:id should retrieve non-owned workflow for owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
// create and assign workflow to owner
const workflow = await testDb.createWorkflow({}, member);
const response = await authOwnerAgent.get(`/workflows/${workflow.id}`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
});
test('DELETE /workflows/:id should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.delete(`/workflows/2`);
expect(response.statusCode).toBe(401);
});
test('DELETE /workflows/:id should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.delete(`/workflows/2`);
expect(response.statusCode).toBe(401);
});
test('DELETE /workflows/:id should fail due to non-existing workflow', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.delete(`/workflows/2`);
expect(response.statusCode).toBe(404);
});
test('DELETE /workflows/:id should delete the workflow', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
// create and assign workflow to owner
const workflow = await testDb.createWorkflow({}, member);
const response = await authAgent.delete(`/workflows/${workflow.id}`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
// make sure the workflow actually deleted from the db
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
workflow,
});
expect(sharedWorkflow).toBeUndefined();
});
test('DELETE /workflows/:id should delete non-owned workflow when owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
// create and assign workflow to owner
const workflow = await testDb.createWorkflow({}, member);
const response = await authAgent.delete(`/workflows/${workflow.id}`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
// make sure the workflow actually deleted from the db
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
workflow,
});
expect(sharedWorkflow).toBeUndefined();
});
test('POST /workflows/:id/activate should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/activate`);
expect(response.statusCode).toBe(401);
});
test('POST /workflows/:id/activate should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/activate`);
expect(response.statusCode).toBe(401);
});
test('POST /workflows/:id/activate should fail due to non-existing workflow', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/activate`);
expect(response.statusCode).toBe(404);
});
test('POST /workflows/:id/activate should fail due to trying to activate a workflow without a trigger', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const workflow = await testDb.createWorkflow({}, owner);
const response = await authOwnerAgent.post(`/workflows/${workflow.id}/activate`);
expect(response.statusCode).toBe(400);
});
test('POST /workflows/:id/activate should set workflow as active', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
const workflow = await testDb.createWorkflowWithTrigger({}, member);
const response = await authAgent.post(`/workflows/${workflow.id}/activate`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(true);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
// check whether the workflow is on the database
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow,
},
relations: ['workflow'],
});
expect(sharedWorkflow?.workflow.active).toBe(true);
// check whether the workflow is on the active workflow runner
expect(await workflowRunner.isActive(workflow.id)).toBe(true);
});
test('POST /workflows/:id/activate should set non-owned workflow as active when owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const workflow = await testDb.createWorkflowWithTrigger({}, member);
const response = await authAgent.post(`/workflows/${workflow.id}/activate`);
expect(response.statusCode).toBe(200);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
response.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(true);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toEqual(workflow.createdAt.toISOString());
expect(updatedAt).toEqual(workflow.updatedAt.toISOString());
// check whether the workflow is on the database
const sharedOwnerWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: owner,
workflow,
},
});
expect(sharedOwnerWorkflow).toBeUndefined();
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow,
},
relations: ['workflow'],
});
expect(sharedWorkflow?.workflow.active).toBe(true);
// check whether the workflow is on the active workflow runner
expect(await workflowRunner.isActive(workflow.id)).toBe(true);
});
test('POST /workflows/:id/deactivate should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/deactivate`);
expect(response.statusCode).toBe(401);
});
test('POST /workflows/:id/deactivate should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/deactivate`);
expect(response.statusCode).toBe(401);
});
test('POST /workflows/:id/deactivate should fail due to non-existing workflow', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post(`/workflows/2/deactivate`);
expect(response.statusCode).toBe(404);
});
test('POST /workflows/:id/deactivate should deactivate workflow', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
const workflow = await testDb.createWorkflowWithTrigger({}, member);
await authAgent.post(`/workflows/${workflow.id}/activate`);
const workflowDeactivationResponse = await authAgent.post(`/workflows/${workflow.id}/deactivate`);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
workflowDeactivationResponse.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
// get the workflow after it was deactivated
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow,
},
relations: ['workflow'],
});
// check whether the workflow is deactivated in the database
expect(sharedWorkflow?.workflow.active).toBe(false);
expect(await workflowRunner.isActive(workflow.id)).toBe(false);
});
test('POST /workflows/:id/deactivate should deactivate non-owned workflow when owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const workflow = await testDb.createWorkflowWithTrigger({}, member);
await authAgent.post(`/workflows/${workflow.id}/activate`);
const workflowDeactivationResponse = await authAgent.post(`/workflows/${workflow.id}/deactivate`);
const { id, connections, active, staticData, nodes, settings, name, createdAt, updatedAt } =
workflowDeactivationResponse.body;
expect(id).toEqual(workflow.id);
expect(name).toEqual(workflow.name);
expect(connections).toEqual(workflow.connections);
expect(active).toBe(false);
expect(staticData).toEqual(workflow.staticData);
expect(nodes).toEqual(workflow.nodes);
expect(settings).toEqual(workflow.settings);
expect(createdAt).toBeDefined();
expect(updatedAt).toBeDefined();
// check whether the workflow is deactivated in the database
const sharedOwnerWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: owner,
workflow,
},
});
expect(sharedOwnerWorkflow).toBeUndefined();
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow,
},
relations: ['workflow'],
});
expect(sharedWorkflow?.workflow.active).toBe(false);
expect(await workflowRunner.isActive(workflow.id)).toBe(false);
});
test('POST /workflows should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post('/workflows');
expect(response.statusCode).toBe(401);
});
test('POST /workflows should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post('/workflows');
expect(response.statusCode).toBe(401);
});
test('POST /workflows should fail due to invalid body', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.post('/workflows').send({});
expect(response.statusCode).toBe(400);
});
test('POST /workflows should create workflow', async () => {
const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: randomApiKey() });
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
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',
},
};
const response = await authAgent.post('/workflows').send(payload);
expect(response.statusCode).toBe(200);
const { id, name, nodes, connections, staticData, active, settings, createdAt, updatedAt } =
response.body;
expect(id).toBeDefined();
expect(name).toBe(payload.name);
expect(connections).toEqual(payload.connections);
expect(settings).toEqual(payload.settings);
expect(staticData).toEqual(payload.staticData);
expect(nodes).toEqual(payload.nodes);
expect(active).toBe(false);
expect(createdAt).toBeDefined();
expect(updatedAt).toEqual(createdAt);
// check if created workflow in DB
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow: response.body,
},
relations: ['workflow', 'role'],
});
expect(sharedWorkflow?.workflow.name).toBe(name);
expect(sharedWorkflow?.workflow.createdAt.toISOString()).toBe(createdAt);
expect(sharedWorkflow?.role).toEqual(workflowOwnerRole);
});
test('PUT /workflows/:id should fail due to missing API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.put(`/workflows/1`);
expect(response.statusCode).toBe(401);
});
test('PUT /workflows/:id should fail due to invalid API Key', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
owner.apiKey = 'abcXYZ';
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.put(`/workflows/1`).send({});
expect(response.statusCode).toBe(401);
});
test('PUT /workflows/:id should fail due to non-existing workflow', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.put(`/workflows/1`).send({
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',
},
});
expect(response.statusCode).toBe(404);
});
test('PUT /workflows/:id should fail due to invalid body', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const authOwnerAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const response = await authOwnerAgent.put(`/workflows/1`).send({
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',
},
});
expect(response.statusCode).toBe(400);
});
test('PUT /workflows/:id should update workflow', async () => {
const member = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const workflow = await testDb.createWorkflow({}, member);
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: member,
version: 1,
});
const payload = {
name: 'name updated',
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 authAgent.put(`/workflows/${workflow.id}`).send(payload);
const { id, name, nodes, connections, staticData, active, settings, createdAt, updatedAt } =
response.body;
expect(response.statusCode).toBe(200);
expect(id).toBe(workflow.id);
expect(name).toBe(payload.name);
expect(connections).toEqual(payload.connections);
expect(settings).toEqual(payload.settings);
expect(staticData).toMatchObject(JSON.parse(payload.staticData));
expect(nodes).toEqual(payload.nodes);
expect(active).toBe(false);
expect(createdAt).toBe(workflow.createdAt.toISOString());
expect(updatedAt).not.toBe(workflow.updatedAt.toISOString());
// check updated workflow in DB
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow: response.body,
},
relations: ['workflow'],
});
expect(sharedWorkflow?.workflow.name).toBe(payload.name);
expect(sharedWorkflow?.workflow.updatedAt.getTime()).toBeGreaterThan(
workflow.updatedAt.getTime(),
);
});
test('PUT /workflows/:id should update non-owned workflow if owner', async () => {
const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: randomApiKey() });
const member = await testDb.createUser({ globalRole: globalMemberRole });
const workflow = await testDb.createWorkflow({}, member);
const authAgent = utils.createAgent(app, {
apiPath: 'public',
auth: true,
user: owner,
version: 1,
});
const payload = {
name: 'name owner updated',
nodes: [
{
id: 'uuid-1',
parameters: {},
name: 'Start',
type: 'n8n-nodes-base.start',
typeVersion: 1,
position: [240, 300],
},
{
id: 'uuid-2',
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 authAgent.put(`/workflows/${workflow.id}`).send(payload);
const { id, name, nodes, connections, staticData, active, settings, createdAt, updatedAt } =
response.body;
expect(response.statusCode).toBe(200);
expect(id).toBe(workflow.id);
expect(name).toBe(payload.name);
expect(connections).toEqual(payload.connections);
expect(settings).toEqual(payload.settings);
expect(staticData).toMatchObject(JSON.parse(payload.staticData));
expect(nodes).toEqual(payload.nodes);
expect(active).toBe(false);
expect(createdAt).toBe(workflow.createdAt.toISOString());
expect(updatedAt).not.toBe(workflow.updatedAt.toISOString());
// check updated workflow in DB
const sharedOwnerWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: owner,
workflow: response.body,
},
});
expect(sharedOwnerWorkflow).toBeUndefined();
const sharedWorkflow = await Db.collections.SharedWorkflow.findOne({
where: {
user: member,
workflow: response.body,
},
relations: ['workflow', 'role'],
});
expect(sharedWorkflow?.workflow.name).toBe(payload.name);
expect(sharedWorkflow?.workflow.updatedAt.getTime()).toBeGreaterThan(
workflow.updatedAt.getTime(),
);
expect(sharedWorkflow?.role).toEqual(workflowOwnerRole);
});