admin/n8n-enterprise-unlocked
1
0
Fork 0
mirror of https://github.com/Abdulazizzn/n8n-enterprise-unlocked.git synced 2025-12-17 01:56:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat(core): Allow admin creation (#7837)

Browse Source 
https://linear.app/n8n/issue/PAY-1038
This commit is contained in:
Iván Ovejero
2023-11-29 13:55:41 +01:00
committed by GitHub
parent 5ba5ed8e3c
commit 476806ebb0
9 changed files with 318 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

335
packages/cli/test/integration/invitations.api.test.ts
View File

@@ -1,7 +1,6 @@
import validator from 'validator';
import type { SuperAgentTest } from 'supertest';
import type { Role } from '@db/entities/Role';
import type { User } from '@db/entities/User';
import { compareHash } from '@/UserManagement/UserManagementHelper';
import { UserManagementMailer } from '@/UserManagement/email/UserManagementMailer';
@@ -18,74 +17,46 @@ import {
} from './shared/random';
import * as testDb from './shared/testDb';
import * as utils from './shared/utils/';
import { getAllRoles } from './shared/db/roles';
import { getGlobalAdminRole, getGlobalMemberRole } from './shared/db/roles';
import { createMember, createOwner, createUser, createUserShell } from './shared/db/users';
import { ExternalHooks } from '@/ExternalHooks';
import { InternalHooks } from '@/InternalHooks';
let credentialOwnerRole: Role;
let globalMemberRole: Role;
let workflowOwnerRole: Role;
let owner: User;
let member: User;
let authOwnerAgent: SuperAgentTest;
let authlessAgent: SuperAgentTest;
import type { UserInvitationResponse } from './shared/utils/users';
import {
assertInviteUserSuccessResponse,
assertInvitedUsersOnDb,
assertInviteUserErrorResponse,
} from './shared/utils/users';
import { mocked } from 'jest-mock';
import { License } from '@/License';
mockInstance(InternalHooks);
const license = mockInstance(License, {
isAdvancedPermissionsLicensed: jest.fn().mockReturnValue(true),
isWithinUsersLimit: jest.fn().mockReturnValue(true),
});
const externalHooks = mockInstance(ExternalHooks);
const mailer = mockInstance(UserManagementMailer, { isEmailSetUp: true });
const testServer = utils.setupTestServer({ endpointGroups: ['invitations'] });
type UserInvitationResponse = {
user: Pick<User, 'id' | 'email'> & { inviteAcceptUrl: string; emailSent: boolean };
error?: string;
};
beforeAll(async () => {
const [_, fetchedGlobalMemberRole, fetchedWorkflowOwnerRole, fetchedCredentialOwnerRole] =
await getAllRoles();
credentialOwnerRole = fetchedCredentialOwnerRole;
globalMemberRole = fetchedGlobalMemberRole;
workflowOwnerRole = fetchedWorkflowOwnerRole;
});
beforeEach(async () => {
jest.resetAllMocks();
await testDb.truncate(['User', 'SharedCredentials', 'SharedWorkflow', 'Workflow', 'Credentials']);
owner = await createOwner();
member = await createMember();
authOwnerAgent = testServer.authAgentFor(owner);
authlessAgent = testServer.authlessAgent;
});
const assertInviteUserSuccessResponse = (data: UserInvitationResponse) => {
expect(validator.isUUID(data.user.id)).toBe(true);
expect(data.user.inviteAcceptUrl).toBeUndefined();
expect(data.user.email).toBeDefined();
expect(data.user.emailSent).toBe(true);
};
const assertInviteUserErrorResponse = (data: UserInvitationResponse) => {
expect(validator.isUUID(data.user.id)).toBe(true);
expect(data.user.inviteAcceptUrl).toBeDefined();
expect(data.user.email).toBeDefined();
expect(data.user.emailSent).toBe(false);
expect(data.error).toBeDefined();
};
const assertInvitedUsersOnDb = (user: User) => {
expect(user.firstName).toBeNull();
expect(user.lastName).toBeNull();
expect(user.personalizationAnswers).toBeNull();
expect(user.password).toBeNull();
expect(user.isPending).toBe(true);
};
describe('POST /invitations/:id/accept', () => {
test('should fill out a user shell', async () => {
let owner: User;
let authlessAgent: SuperAgentTest;
beforeAll(async () => {
await testDb.truncate(['User']);
owner = await createOwner();
authlessAgent = testServer.authlessAgent;
});
test('should fill out a member shell', async () => {
const globalMemberRole = await getGlobalMemberRole();
const memberShell = await createUserShell(globalMemberRole);
const memberData = {
@@ -96,11 +67,9 @@ describe('POST /invitations/:id/accept', () => {
};
const response = await authlessAgent
.post(
`/invitations/${memberShell.id}/
accept`,
)
.send(memberData);
.post(`/invitations/${memberShell.id}/accept`)
.send(memberData)
.expect(200);
const {
id,
@@ -121,21 +90,78 @@ describe('POST /invitations/:id/accept', () => {
expect(personalizationAnswers).toBeNull();
expect(password).toBeUndefined();
expect(isPending).toBe(false);
expect(globalRole).toBeDefined();
expect(globalRole.scope).toBe('global');
expect(globalRole.name).toBe('member');
expect(apiKey).not.toBeDefined();
const authToken = utils.getAuthToken(response);
expect(authToken).toBeDefined();
const member = await Container.get(UserRepository).findOneByOrFail({ id: memberShell.id });
expect(member.firstName).toBe(memberData.firstName);
expect(member.lastName).toBe(memberData.lastName);
expect(member.password).not.toBe(memberData.password);
const storedMember = await Container.get(UserRepository).findOneByOrFail({
id: memberShell.id,
});
expect(storedMember.firstName).toBe(memberData.firstName);
expect(storedMember.lastName).toBe(memberData.lastName);
expect(storedMember.password).not.toBe(memberData.password);
});
test('should fail with invalid inputs', async () => {
test('should fill out an admin shell', async () => {
const globalAdminRole = await getGlobalAdminRole();
const adminShell = await createUserShell(globalAdminRole);
const memberData = {
inviterId: owner.id,
firstName: randomName(),
lastName: randomName(),
password: randomValidPassword(),
};
const response = await authlessAgent
.post(`/invitations/${adminShell.id}/accept`)
.send(memberData)
.expect(200);
const {
id,
email,
firstName,
lastName,
personalizationAnswers,
password,
globalRole,
isPending,
apiKey,
} = response.body.data;
expect(validator.isUUID(id)).toBe(true);
expect(email).toBeDefined();
expect(firstName).toBe(memberData.firstName);
expect(lastName).toBe(memberData.lastName);
expect(personalizationAnswers).toBeNull();
expect(password).toBeUndefined();
expect(isPending).toBe(false);
expect(globalRole.scope).toBe('global');
expect(globalRole.name).toBe('admin');
expect(apiKey).not.toBeDefined();
const authToken = utils.getAuthToken(response);
expect(authToken).toBeDefined();
const storedAdmin = await Container.get(UserRepository).findOneByOrFail({
id: adminShell.id,
});
expect(storedAdmin.firstName).toBe(memberData.firstName);
expect(storedAdmin.lastName).toBe(memberData.lastName);
expect(storedAdmin.password).not.toBe(memberData.password);
});
test('should fail with invalid payloads', async () => {
const memberShellEmail = randomEmail();
const globalMemberRole = await getGlobalMemberRole();
const memberShell = await Container.get(UserRepository).save({
email: memberShellEmail,
globalRole: globalMemberRole,
@@ -171,51 +197,62 @@ describe('POST /invitations/:id/accept', () => {
];
for (const invalidPayload of invalidPayloads) {
const response = await authlessAgent
await authlessAgent
.post(`/invitations/${memberShell.id}/accept`)
.send(invalidPayload);
expect(response.statusCode).toBe(400);
.send(invalidPayload)
.expect(400);
const storedUser = await Container.get(UserRepository).findOneOrFail({
const storedMemberShell = await Container.get(UserRepository).findOneOrFail({
where: { email: memberShellEmail },
});
expect(storedUser.firstName).toBeNull();
expect(storedUser.lastName).toBeNull();
expect(storedUser.password).toBeNull();
expect(storedMemberShell.firstName).toBeNull();
expect(storedMemberShell.lastName).toBeNull();
expect(storedMemberShell.password).toBeNull();
}
});
test('should fail with already accepted invite', async () => {
const globalMemberRole = await getGlobalMemberRole();
const member = await createUser({ globalRole: globalMemberRole });
const newMemberData = {
const memberData = {
inviterId: owner.id,
firstName: randomName(),
lastName: randomName(),
password: randomValidPassword(),
};
const response = await authlessAgent
.post(`/invitations/${member.id}/accept`)
.send(newMemberData);
expect(response.statusCode).toBe(400);
await authlessAgent.post(`/invitations/${member.id}/accept`).send(memberData).expect(400);
const storedMember = await Container.get(UserRepository).findOneOrFail({
where: { email: member.email },
});
expect(storedMember.firstName).not.toBe(newMemberData.firstName);
expect(storedMember.lastName).not.toBe(newMemberData.lastName);
expect(storedMember.firstName).not.toBe(memberData.firstName);
expect(storedMember.lastName).not.toBe(memberData.lastName);
expect(storedMember.password).not.toBe(memberData.password);
const comparisonResult = await compareHash(member.password, storedMember.password);
expect(comparisonResult).toBe(false);
expect(storedMember.password).not.toBe(newMemberData.password);
});
});
describe('POST /invitations', () => {
test('should fail with invalid inputs', async () => {
let owner: User;
let member: User;
let ownerAgent: SuperAgentTest;
beforeAll(async () => {
await testDb.truncate(['User']);
owner = await createOwner();
member = await createMember();
ownerAgent = testServer.authAgentFor(owner);
});
test('should fail with invalid payloads', async () => {
const invalidPayloads = [
randomEmail(),
[randomEmail()],
@@ -226,48 +263,96 @@ describe('POST /invitations', () => {
await Promise.all(
invalidPayloads.map(async (invalidPayload) => {
const response = await authOwnerAgent.post('/invitations').send(invalidPayload);
expect(response.statusCode).toBe(400);
await ownerAgent.post('/invitations').send(invalidPayload).expect(400);
const users = await Container.get(UserRepository).find();
expect(users.length).toBe(2); // DB unaffected
const usersCount = await Container.get(UserRepository).count();
expect(usersCount).toBe(2); // DB unaffected
}),
);
});
test('should ignore an empty payload', async () => {
const response = await authOwnerAgent.post('/invitations').send([]);
test('should return 200 on empty payload', async () => {
const response = await ownerAgent.post('/invitations').send([]).expect(200);
const { data } = response.body;
expect(response.body.data).toStrictEqual([]);
expect(response.statusCode).toBe(200);
expect(Array.isArray(data)).toBe(true);
expect(data.length).toBe(0);
const usersCount = await Container.get(UserRepository).count();
const users = await Container.get(UserRepository).find();
expect(users.length).toBe(2);
expect(usersCount).toBe(2);
});
test('should succeed if emailing is not set up', async () => {
mailer.invite.mockResolvedValueOnce({ emailSent: false });
const usersToInvite = randomEmail();
const response = await authOwnerAgent.post('/invitations').send([{ email: usersToInvite }]);
test('should return 200 if emailing is not set up', async () => {
mailer.invite.mockResolvedValue({ emailSent: false });
const response = await ownerAgent
.post('/invitations')
.send([{ email: randomEmail() }])
.expect(200);
expect(response.statusCode).toBe(200);
expect(response.body.data).toBeInstanceOf(Array);
expect(response.body.data.length).toBe(1);
const { user } = response.body.data[0];
expect(user.inviteAcceptUrl).toBeDefined();
const inviteUrl = new URL(user.inviteAcceptUrl);
expect(inviteUrl.searchParams.get('inviterId')).toBe(owner.id);
expect(inviteUrl.searchParams.get('inviteeId')).toBe(user.id);
});
test('should create member shell', async () => {
mailer.invite.mockResolvedValue({ emailSent: false });
const response = await ownerAgent
.post('/invitations')
.send([{ email: randomEmail() }])
.expect(200);
const [result] = response.body.data as UserInvitationResponse[];
const storedUser = await Container.get(UserRepository).findOneByOrFail({
id: result.user.id,
});
assertInvitedUsersOnDb(storedUser);
});
test('should create admin shell if licensed', async () => {
mailer.invite.mockResolvedValue({ emailSent: false });
const response = await ownerAgent
.post('/invitations')
.send([{ email: randomEmail(), role: 'admin' }])
.expect(200);
const [result] = response.body.data as UserInvitationResponse[];
const storedUser = await Container.get(UserRepository).findOneByOrFail({
id: result.user.id,
});
assertInvitedUsersOnDb(storedUser);
});
test('should fail to create admin shell if not licensed', async () => {
license.isAdvancedPermissionsLicensed.mockReturnValue(false);
mailer.invite.mockResolvedValue({ emailSent: false });
await ownerAgent
.post('/invitations')
.send([{ email: randomEmail(), role: 'admin' }])
.expect(403);
});
test('should email invites and create user shells but ignore existing', async () => {
const internalHooks = Container.get(InternalHooks);
externalHooks.run.mockClear();
mailer.invite.mockImplementation(async () => ({ emailSent: true }));
mailer.invite.mockResolvedValue({ emailSent: true });
const globalMemberRole = await getGlobalMemberRole();
const memberShell = await createUserShell(globalMemberRole);
const newUser = randomEmail();
@@ -281,54 +366,54 @@ describe('POST /invitations', () => {
const payload = testEmails.map((email) => ({ email }));
const response = await authOwnerAgent.post('/invitations').send(payload);
const response = await ownerAgent.post('/invitations').send(payload).expect(200);
expect(response.statusCode).toBe(200);
const internalHooks = Container.get(InternalHooks);
expect(internalHooks.onUserTransactionalEmail).toHaveBeenCalledTimes(usersToInvite.length);
expect(externalHooks.run).toHaveBeenCalledTimes(1);
const [hookName, hookData] = externalHooks.run.mock.calls[0];
expect(hookName).toBe('user.invited');
expect(hookData?.[0]).toStrictEqual(usersToCreate);
for (const invitationResponse of response.body.data as UserInvitationResponse[]) {
const result = response.body.data as UserInvitationResponse[];
for (const invitationResponse of result) {
assertInviteUserSuccessResponse(invitationResponse);
const storedUser = await Container.get(UserRepository).findOneByOrFail({
id: invitationResponse.user.id,
});
assertInviteUserSuccessResponse(invitationResponse);
assertInvitedUsersOnDb(storedUser);
}
for (const [onUserTransactionalEmailParameter] of internalHooks.onUserTransactionalEmail.mock
.calls) {
const calls = mocked(internalHooks).onUserTransactionalEmail.mock.calls;
for (const [onUserTransactionalEmailParameter] of calls) {
expect(onUserTransactionalEmailParameter.user_id).toBeDefined();
expect(onUserTransactionalEmailParameter.message_type).toBe('New user invite');
expect(onUserTransactionalEmailParameter.public_api).toBe(false);
}
});
test('should return error when invite method throws an error', async () => {
const error = 'failed to send email';
test('should return 200 when invite method throws error', async () => {
mailer.invite.mockImplementation(async () => {
throw new Error(error);
throw new Error('failed to send email');
});
const newUser = randomEmail();
const usersToCreate = [newUser];
const payload = usersToCreate.map((email) => ({ email }));
const response = await authOwnerAgent.post('/invitations').send(payload);
const response = await ownerAgent
.post('/invitations')
.send([{ email: randomEmail() }])
.expect(200);
expect(response.body.data).toBeInstanceOf(Array);
expect(response.body.data.length).toBe(1);
expect(response.statusCode).toBe(200);
const invitationResponse = response.body.data[0];
const [invitationResponse] = response.body.data;
assertInviteUserErrorResponse(invitationResponse);
});