mirror of
https://github.com/n8n-io/n8n.git
synced 2026-05-25 13:55:18 +02:00
485 lines
14 KiB
TypeScript
485 lines
14 KiB
TypeScript
import {
|
|
mockInstance,
|
|
testDb,
|
|
getPersonalProject,
|
|
getAllSharedWorkflows,
|
|
getAllWorkflows,
|
|
} from '@n8n/backend-test-utils';
|
|
import { GlobalConfig } from '@n8n/config';
|
|
import { WorkflowPublishHistoryRepository, WorkflowHistoryRepository } from '@n8n/db';
|
|
import { Container } from '@n8n/di';
|
|
import { nanoid } from 'nanoid';
|
|
|
|
import '@/zod-alias-support';
|
|
import { ActiveWorkflowManager } from '@/active-workflow-manager';
|
|
import { ImportWorkflowsCommand } from '@/commands/import/workflow';
|
|
import { LoadNodesAndCredentials } from '@/load-nodes-and-credentials';
|
|
import { setupTestCommand } from '@test-integration/utils/test-command';
|
|
|
|
import { createMember, createOwner } from '../shared/db/users';
|
|
|
|
mockInstance(LoadNodesAndCredentials);
|
|
mockInstance(ActiveWorkflowManager);
|
|
mockInstance(WorkflowPublishHistoryRepository);
|
|
|
|
const command = setupTestCommand(ImportWorkflowsCommand);
|
|
|
|
beforeEach(async () => {
|
|
await testDb.truncate(['WorkflowEntity', 'SharedWorkflow', 'User']);
|
|
});
|
|
|
|
test('import:workflow should import active workflow and deactivate it', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
const owner = await createOwner();
|
|
const ownerProject = await getPersonalProject(owner);
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
await command.run([
|
|
'--separate',
|
|
'--input=./test/integration/commands/import-workflows/separate',
|
|
]);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
expect(after).toMatchObject({
|
|
workflows: [
|
|
expect.objectContaining({ name: 'active-workflow', active: false, activeVersionId: null }),
|
|
expect.objectContaining({ name: 'inactive-workflow', active: false, activeVersionId: null }),
|
|
],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
expect.objectContaining({
|
|
workflowId: '999',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test('import:workflow should import active workflow from combined file and deactivate it', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
const owner = await createOwner();
|
|
const ownerProject = await getPersonalProject(owner);
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined/combined.json',
|
|
]);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
expect(after).toMatchObject({
|
|
workflows: [
|
|
expect.objectContaining({ name: 'active-workflow', active: false, activeVersionId: null }),
|
|
expect.objectContaining({ name: 'inactive-workflow', active: false, activeVersionId: null }),
|
|
],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
expect.objectContaining({
|
|
workflowId: '999',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test('import:workflow can import a single workflow object', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
const owner = await createOwner();
|
|
const ownerProject = await getPersonalProject(owner);
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
await command.run(['--input=./test/integration/commands/import-workflows/combined/single.json']);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
expect(after).toMatchObject({
|
|
workflows: [
|
|
expect.objectContaining({ name: 'active-workflow', active: false, activeVersionId: null }),
|
|
],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test('`import:workflow --userId ...` should fail if the workflow exists already and is owned by somebody else', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
const owner = await createOwner();
|
|
const ownerProject = await getPersonalProject(owner);
|
|
const member = await createMember();
|
|
|
|
// Import workflow the first time, assigning it to a member.
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/original.json',
|
|
`--userId=${owner.id}`,
|
|
]);
|
|
|
|
const before = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure the workflow and sharing have been created.
|
|
expect(before).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
// Import the same workflow again, with another name but the same ID, and try
|
|
// to assign it to the member.
|
|
await expect(
|
|
command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/updated.json',
|
|
`--userId=${member.id}`,
|
|
]),
|
|
).rejects.toThrowError(
|
|
`The credential with ID "998" is already owned by the user with the ID "${owner.id}". It can't be re-owned by the user with the ID "${member.id}"`,
|
|
);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure there is no new sharing and that the name DID NOT change.
|
|
expect(after).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test("only update the workflow, don't create or update the owner if `--userId` is not passed", async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
await createOwner();
|
|
const member = await createMember();
|
|
const memberProject = await getPersonalProject(member);
|
|
|
|
// Import workflow the first time, assigning it to a member.
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/original.json',
|
|
`--userId=${member.id}`,
|
|
]);
|
|
|
|
const before = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure the workflow and sharing have been created.
|
|
expect(before).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: memberProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
// Import the same workflow again, with another name but the same ID.
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/updated.json',
|
|
]);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure there is no new sharing and that the name changed.
|
|
expect(after).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow updated' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: memberProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test('`import:workflow --projectId ...` should fail if the credential already exists and is owned by another project', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
const owner = await createOwner();
|
|
const ownerProject = await getPersonalProject(owner);
|
|
const member = await createMember();
|
|
const memberProject = await getPersonalProject(member);
|
|
|
|
// Import workflow the first time, assigning it to a member.
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/original.json',
|
|
`--userId=${owner.id}`,
|
|
]);
|
|
|
|
const before = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure the workflow and sharing have been created.
|
|
expect(before).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
// Import the same workflow again, with another name but the same ID, and try
|
|
// to assign it to the member.
|
|
await expect(
|
|
command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/updated.json',
|
|
`--projectId=${memberProject.id}`,
|
|
]),
|
|
).rejects.toThrowError(
|
|
`The credential with ID "998" is already owned by the user with the ID "${owner.id}". It can't be re-owned by the project with the ID "${memberProject.id}"`,
|
|
);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const after = {
|
|
workflows: await getAllWorkflows(),
|
|
sharings: await getAllSharedWorkflows(),
|
|
};
|
|
// Make sure there is no new sharing and that the name DID NOT change.
|
|
expect(after).toMatchObject({
|
|
workflows: [expect.objectContaining({ id: '998', name: 'active-workflow' })],
|
|
sharings: [
|
|
expect.objectContaining({
|
|
workflowId: '998',
|
|
projectId: ownerProject.id,
|
|
role: 'workflow:owner',
|
|
}),
|
|
],
|
|
});
|
|
});
|
|
|
|
test('`import:workflow --projectId ... --userId ...` fails explaining that only one of the options can be used at a time', async () => {
|
|
await expect(
|
|
command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/updated.json',
|
|
`--userId=${nanoid()}`,
|
|
`--projectId=${nanoid()}`,
|
|
]),
|
|
).rejects.toThrowError(
|
|
'You cannot use `--userId` and `--projectId` together. Use one or the other.',
|
|
);
|
|
});
|
|
|
|
test('should preserve versionMetadata from JSON file when importing', async () => {
|
|
//
|
|
// ARRANGE
|
|
//
|
|
await createOwner();
|
|
|
|
//
|
|
// ACT
|
|
//
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/with-history/workflow-with-metadata.json',
|
|
]);
|
|
|
|
//
|
|
// ASSERT
|
|
//
|
|
const workflows = await getAllWorkflows();
|
|
expect(workflows).toHaveLength(1);
|
|
expect(workflows[0].id).toBe('test-workflow-123');
|
|
expect(workflows[0].name).toBe('Workflow with History Metadata');
|
|
|
|
const workflowHistoryRecords = await Container.get(WorkflowHistoryRepository).find({
|
|
where: { workflowId: 'test-workflow-123' },
|
|
});
|
|
|
|
expect(workflowHistoryRecords).toHaveLength(1);
|
|
expect(workflowHistoryRecords[0].name).toBe('Historical Version Name');
|
|
expect(workflowHistoryRecords[0].description).toBe('Historical version description');
|
|
});
|
|
|
|
describe('--activeState flag', () => {
|
|
const globalConfig = Container.get(GlobalConfig);
|
|
const originalMode = globalConfig.executions.mode;
|
|
|
|
beforeAll(() => {
|
|
globalConfig.executions.mode = 'queue';
|
|
});
|
|
|
|
afterAll(() => {
|
|
globalConfig.executions.mode = originalMode;
|
|
});
|
|
|
|
describe('fromJson', () => {
|
|
it('should activate a workflow that is marked as active in the imported json', async () => {
|
|
await createOwner();
|
|
|
|
await command.run([
|
|
'--separate',
|
|
'--input=./test/integration/commands/import-workflows/separate',
|
|
'--activeState=fromJson',
|
|
]);
|
|
|
|
const workflowsInDB = await getAllWorkflows();
|
|
const activeWorkflow = workflowsInDB.find((w) => w.name === 'active-workflow');
|
|
const inactiveWorkflow = workflowsInDB.find((w) => w.name === 'inactive-workflow');
|
|
|
|
expect(workflowsInDB).toHaveLength(2);
|
|
expect(activeWorkflow).toMatchObject({ active: true });
|
|
expect(activeWorkflow?.activeVersionId).toBe(activeWorkflow?.versionId);
|
|
expect(inactiveWorkflow).toMatchObject({ active: false, activeVersionId: null });
|
|
|
|
const activeWorkflowManager = Container.get(ActiveWorkflowManager);
|
|
expect(activeWorkflowManager.add).toHaveBeenCalledWith('998', 'activate');
|
|
expect(activeWorkflowManager.add).not.toHaveBeenCalledWith('999', expect.anything());
|
|
});
|
|
|
|
it('should deactivate the previously active version and activate the new version when importing a workflow json with an ID that already exists for an active workflow', async () => {
|
|
await createOwner();
|
|
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/original.json',
|
|
'--activeState=fromJson',
|
|
]);
|
|
|
|
const [first] = await getAllWorkflows();
|
|
const v1VersionId = first.versionId;
|
|
expect(first).toMatchObject({ id: '998', active: true, name: 'active-workflow' });
|
|
expect(first.activeVersionId).toBe(v1VersionId);
|
|
|
|
await command.run([
|
|
'--input=./test/integration/commands/import-workflows/combined-with-update/updated.json',
|
|
'--activeState=fromJson',
|
|
]);
|
|
|
|
const [second] = await getAllWorkflows();
|
|
expect(second).toMatchObject({
|
|
id: '998',
|
|
active: true,
|
|
name: 'active-workflow updated',
|
|
});
|
|
expect(second.versionId).not.toBe(v1VersionId);
|
|
expect(second.activeVersionId).toBe(second.versionId);
|
|
|
|
const activeWorkflowManager = Container.get(ActiveWorkflowManager);
|
|
expect(activeWorkflowManager.remove).toHaveBeenCalledWith('998');
|
|
expect(activeWorkflowManager.add).toHaveBeenLastCalledWith('998', 'activate');
|
|
|
|
const publishHistoryRepo = Container.get(WorkflowPublishHistoryRepository);
|
|
expect(publishHistoryRepo.addRecord).toHaveBeenCalledTimes(2);
|
|
expect(publishHistoryRepo.addRecord).toHaveBeenLastCalledWith({
|
|
workflowId: '998',
|
|
versionId: second.versionId,
|
|
event: 'activated',
|
|
userId: null,
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('false', () => {
|
|
it('should deactivate a workflow that is active in the workflow json to import', async () => {
|
|
await createOwner();
|
|
const fixture =
|
|
'./test/integration/commands/import-workflows/separate/001-activeWorkflow.json';
|
|
|
|
await command.run([`--input=${fixture}`, '--activeState=fromJson']);
|
|
|
|
const [active] = await getAllWorkflows();
|
|
expect(active).toMatchObject({ id: '998', active: true });
|
|
expect(active.activeVersionId).toBe(active.versionId);
|
|
|
|
const activeWorkflowManager = Container.get(ActiveWorkflowManager);
|
|
jest.mocked(activeWorkflowManager.add).mockClear();
|
|
jest.mocked(activeWorkflowManager.remove).mockClear();
|
|
|
|
await command.run([`--input=${fixture}`, '--activeState=false']);
|
|
|
|
const [deactivated] = await getAllWorkflows();
|
|
expect(deactivated).toMatchObject({
|
|
id: '998',
|
|
name: 'active-workflow',
|
|
active: false,
|
|
activeVersionId: null,
|
|
});
|
|
|
|
expect(activeWorkflowManager.remove).toHaveBeenCalledWith('998');
|
|
expect(activeWorkflowManager.add).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|