n8n 0.178.2 → 0.181.0

package/dist/test/integration/publicApi/workflows.test.js

@@ -0,0 +1,948 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../../../src");
+const config = require("../../../config");
+const random_1 = require("../shared/random");
+const utils = __importStar(require("../shared/utils"));
+const testDb = __importStar(require("../shared/testDb"));
+let app;
+let testDbName = '';
+let globalOwnerRole;
+let globalMemberRole;
+let workflowOwnerRole;
+let credentialOwnerRole;
+let workflowRunner;
+jest.mock('../../../src/telemetry');
+beforeAll(async () => {
+    app = await utils.initTestServer({ endpointGroups: ['publicApi'], applyAuth: false });
+    const initResult = await testDb.init();
+    testDbName = initResult.testDbName;
+    const [fetchedGlobalOwnerRole, fetchedGlobalMemberRole, fetchedWorkflowOwnerRole, fetchedCredentialOwnerRole,] = await testDb.getAllRoles();
+    globalOwnerRole = fetchedGlobalOwnerRole;
+    globalMemberRole = fetchedGlobalMemberRole;
+    workflowOwnerRole = fetchedWorkflowOwnerRole;
+    credentialOwnerRole = fetchedCredentialOwnerRole;
+    utils.initTestTelemetry();
+    utils.initTestLogger();
+    await utils.initNodeTypes();
+    workflowRunner = await utils.initActiveWorkflowRunner();
+});
+beforeEach(async () => {
+    await testDb.truncate(['SharedCredentials', 'SharedWorkflow'], testDbName);
+    await testDb.truncate(['User', 'Workflow', 'Credentials'], testDbName);
+    config.set('userManagement.disabled', false);
+    config.set('userManagement.isInstanceOwnerSetUp', true);
+    config.set('userManagement.emails.mode', 'smtp');
+});
+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: (0, random_1.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: (0, random_1.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: (0, random_1.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();
+    }
+    expect(response.body.data[0].id).toBeLessThan(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: (0, random_1.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: (0, random_1.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) => {
+            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: (0, random_1.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/:workflowId 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/:workflowId should fail due to invalid API Key', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId should fail due to non existing workflow', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId should retrieve workflow', async () => {
+    const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: (0, random_1.randomApiKey)() });
+    const authAgent = utils.createAgent(app, {
+        apiPath: 'public',
+        auth: true,
+        user: member,
+        version: 1,
+    });
+    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 } = 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('GET /workflows/:workflowId should retrieve non-owned workflow for owner', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.randomApiKey)() });
+    const member = await testDb.createUser({ globalRole: globalMemberRole });
+    const authOwnerAgent = utils.createAgent(app, {
+        apiPath: 'public',
+        auth: true,
+        user: owner,
+        version: 1,
+    });
+    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/:workflowId 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/:workflowId should fail due to invalid API Key', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId should fail due to non existing workflow', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId should delete the workflow', async () => {
+    const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: (0, random_1.randomApiKey)() });
+    const authAgent = utils.createAgent(app, {
+        apiPath: 'public',
+        auth: true,
+        user: member,
+        version: 1,
+    });
+    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());
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        workflow,
+    });
+    expect(sharedWorkflow).toBeUndefined();
+});
+test('DELETE /workflows/:workflowId should delete non-owned workflow when owner', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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.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());
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        workflow,
+    });
+    expect(sharedWorkflow).toBeUndefined();
+});
+test('POST /workflows/:workflowId/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/:workflowId/activate should fail due to invalid API Key', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId/activate should fail due to non existing workflow', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId/activate should fail due to trying to activate a workflow without a trigger', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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.skip('POST /workflows/:workflowId/activate should set workflow as active', async () => {
+    const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: (0, random_1.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());
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow,
+        },
+        relations: ['workflow'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.active).toBe(true);
+    expect(await workflowRunner.isActive(workflow.id.toString())).toBe(true);
+});
+test.skip('POST /workflows/:workflowId/activate should set non-owned workflow as active when owner', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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());
+    const sharedOwnerWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: owner,
+            workflow,
+        },
+    });
+    expect(sharedOwnerWorkflow).toBeUndefined();
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow,
+        },
+        relations: ['workflow'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.active).toBe(true);
+    expect(await workflowRunner.isActive(workflow.id.toString())).toBe(true);
+});
+test('POST /workflows/:workflowId/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/:workflowId/deactivate should fail due to invalid API Key', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId/deactivate should fail due to non existing workflow', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId/deactivate should deactive workflow', async () => {
+    const member = await testDb.createUser({ globalRole: globalMemberRole, apiKey: (0, random_1.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();
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow,
+        },
+        relations: ['workflow'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.active).toBe(false);
+    expect(await workflowRunner.isActive(workflow.id.toString())).toBe(false);
+});
+test('POST /workflows/:workflowId/deactivate should deactive non-owned workflow when owner', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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();
+    const sharedOwnerWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: owner,
+            workflow,
+        },
+    });
+    expect(sharedOwnerWorkflow).toBeUndefined();
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow,
+        },
+        relations: ['workflow'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.active).toBe(false);
+    expect(await workflowRunner.isActive(workflow.id.toString())).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: (0, random_1.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: (0, random_1.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: (0, random_1.randomApiKey)() });
+    const authAgent = utils.createAgent(app, {
+        apiPath: 'public',
+        auth: true,
+        user: member,
+        version: 1,
+    });
+    const payload = {
+        name: 'testing',
+        nodes: [
+            {
+                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);
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow: response.body,
+        },
+        relations: ['workflow', 'role'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.name).toBe(name);
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.createdAt.toISOString()).toBe(createdAt);
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.role).toEqual(workflowOwnerRole);
+});
+test('PUT /workflows/:workflowId 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/:workflowId should fail due to invalid API Key', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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/:workflowId should fail due to non existing workflow', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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: [
+            {
+                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/:workflowId should fail due to invalid body', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.randomApiKey)() });
+    const authOwnerAgent = utils.createAgent(app, {
+        apiPath: 'public',
+        auth: true,
+        user: owner,
+        version: 1,
+    });
+    const response = await authOwnerAgent.put(`/workflows/1`).send({
+        nodes: [
+            {
+                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/:workflowId should update workflow', async () => {
+    const member = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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: [
+            {
+                parameters: {},
+                name: 'Start',
+                type: 'n8n-nodes-base.start',
+                typeVersion: 1,
+                position: [240, 300],
+            },
+            {
+                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).toEqual(payload.staticData);
+    expect(nodes).toEqual(payload.nodes);
+    expect(active).toBe(false);
+    expect(createdAt).toBe(workflow.createdAt.toISOString());
+    expect(updatedAt).not.toBe(workflow.updatedAt.toISOString());
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow: response.body,
+        },
+        relations: ['workflow'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.name).toBe(payload.name);
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.updatedAt.getTime()).toBeGreaterThan(workflow.updatedAt.getTime());
+});
+test('PUT /workflows/:workflowId should update non-owned workflow if owner', async () => {
+    const owner = await testDb.createUser({ globalRole: globalOwnerRole, apiKey: (0, random_1.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: [
+            {
+                parameters: {},
+                name: 'Start',
+                type: 'n8n-nodes-base.start',
+                typeVersion: 1,
+                position: [240, 300],
+            },
+            {
+                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).toEqual(payload.staticData);
+    expect(nodes).toEqual(payload.nodes);
+    expect(active).toBe(false);
+    expect(createdAt).toBe(workflow.createdAt.toISOString());
+    expect(updatedAt).not.toBe(workflow.updatedAt.toISOString());
+    const sharedOwnerWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: owner,
+            workflow: response.body,
+        },
+    });
+    expect(sharedOwnerWorkflow).toBeUndefined();
+    const sharedWorkflow = await src_1.Db.collections.SharedWorkflow.findOne({
+        where: {
+            user: member,
+            workflow: response.body,
+        },
+        relations: ['workflow', 'role'],
+    });
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.name).toBe(payload.name);
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.workflow.updatedAt.getTime()).toBeGreaterThan(workflow.updatedAt.getTime());
+    expect(sharedWorkflow === null || sharedWorkflow === void 0 ? void 0 : sharedWorkflow.role).toEqual(workflowOwnerRole);
+});
+//# sourceMappingURL=workflows.test.js.map