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

ci: Refactor e2e tests to delete boilerplate code (no-changelog) (#6524)

Browse Source
This commit is contained in:
कारतोफ्फेलस्क्रिप्ट™
2023-06-23 00:38:12 +02:00
committed by GitHub
parent abe7f71627
commit 0e071724ee
50 changed files with 281 additions and 913 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
packages/cli/.npmignore
View File

@@ -1 +0,0 @@
dist/ReloadNodesAndCredentials.*

4
packages/cli/package.json
View File

@@ -59,7 +59,9 @@
"bin",
"templates",
"dist",
"oclif.manifest.json"
"oclif.manifest.json",
"!dist/**/e2e.*",
"!dist/ReloadNodesAndCredentials.*"
],
"devDependencies": {
"@apidevtools/swagger-cli": "4.0.0",

3
packages/cli/src/License.ts
View File

@@ -96,9 +96,8 @@ export class License {
await this.manager.renew();
}
isFeatureEnabled(feature: string): boolean {
isFeatureEnabled(feature: LICENSE_FEATURES): boolean {
if (!this.manager) {
getLogger().warn('License manager not initialized');
return false;
}

15
packages/cli/src/Server.ts
View File

@@ -68,6 +68,7 @@ import {
EDITOR_UI_DIST_DIR,
GENERATED_STATIC_DIR,
inDevelopment,
inE2ETests,
N8N_VERSION,
RESPONSE_ERROR_MESSAGES,
TEMPLATES_DIR,
@@ -338,10 +339,6 @@ export class Server extends AbstractServer {
this.push = Container.get(Push);
if (process.env.E2E_TESTS === 'true') {
this.app.use('/e2e', require('./api/e2e.api').e2eController);
}
await super.start();
const cpus = os.cpus();
@@ -461,7 +458,7 @@ export class Server extends AbstractServer {
return this.frontendSettings;
}
private registerControllers(ignoredEndpoints: Readonly<string[]>) {
private async registerControllers(ignoredEndpoints: Readonly<string[]>) {
const { app, externalHooks, activeWorkflowRunner, nodeTypes } = this;
const repositories = Db.collections;
setupAuthMiddlewares(app, ignoredEndpoints, this.restEndpoint);
@@ -515,6 +512,12 @@ export class Server extends AbstractServer {
);
}
if (inE2ETests) {
// eslint-disable-next-line @typescript-eslint/naming-convention
const { E2EController } = await import('./controllers/e2e.controller');
controllers.push(Container.get(E2EController));
}
controllers.forEach((controller) => registerController(app, config, controller));
}
@@ -590,7 +593,7 @@ export class Server extends AbstractServer {
await handleLdapInit();
this.registerControllers(ignoredEndpoints);
await this.registerControllers(ignoredEndpoints);
this.app.use(`/${this.restEndpoint}/credentials`, credentialsController);

158
packages/cli/src/api/e2e.api.ts
View File

@@ -1,158 +0,0 @@
/* eslint-disable @typescript-eslint/no-unsafe-return */
/* eslint-disable @typescript-eslint/no-unsafe-call */
/* eslint-disable @typescript-eslint/no-unsafe-member-access */
/* eslint-disable @typescript-eslint/no-unsafe-argument */
/* eslint-disable @typescript-eslint/no-unsafe-assignment */
/* eslint-disable @typescript-eslint/naming-convention */
import { Router } from 'express';
import type { Request } from 'express';
import bodyParser from 'body-parser';
import { v4 as uuid } from 'uuid';
import { Container } from 'typedi';
import config from '@/config';
import * as Db from '@/Db';
import type { Role } from '@db/entities/Role';
import { RoleRepository } from '@db/repositories';
import { hashPassword } from '@/UserManagement/UserManagementHelper';
import { eventBus } from '@/eventbus/MessageEventBus/MessageEventBus';
import { License } from '../License';
import { LICENSE_FEATURES } from '@/constants';
if (process.env.E2E_TESTS !== 'true') {
console.error('E2E endpoints only allowed during E2E tests');
process.exit(1);
}
const enabledFeatures = {
[LICENSE_FEATURES.SHARING]: true, //default to true here instead of setting it in config/index.ts for e2e
[LICENSE_FEATURES.LDAP]: false,
[LICENSE_FEATURES.SAML]: false,
[LICENSE_FEATURES.LOG_STREAMING]: false,
[LICENSE_FEATURES.ADVANCED_EXECUTION_FILTERS]: false,
[LICENSE_FEATURES.SOURCE_CONTROL]: false,
};
type Feature = keyof typeof enabledFeatures;
Container.get(License).isFeatureEnabled = (feature: Feature) => enabledFeatures[feature] ?? false;
const tablesToTruncate = [
'auth_identity',
'auth_provider_sync_history',
'event_destinations',
'shared_workflow',
'shared_credentials',
'webhook_entity',
'workflows_tags',
'credentials_entity',
'tag_entity',
'workflow_statistics',
'workflow_entity',
'execution_entity',
'settings',
'installed_packages',
'installed_nodes',
'user',
'role',
'variables',
];
const truncateAll = async () => {
const connection = Db.getConnection();
for (const table of tablesToTruncate) {
try {
await connection.query(
`DELETE FROM ${table}; DELETE FROM sqlite_sequence WHERE name=${table};`,
);
} catch (error) {
console.warn('Dropping Table for E2E Reset error: ', error);
}
}
};
const setupUserManagement = async () => {
const connection = Db.getConnection();
await connection.query('INSERT INTO role (name, scope) VALUES ("owner", "global");');
const instanceOwnerRole = (await connection.query(
'SELECT last_insert_rowid() as insertId',
)) as Array<{ insertId: number }>;
const roles: Array<[Role['name'], Role['scope']]> = [
['member', 'global'],
['owner', 'workflow'],
['owner', 'credential'],
['user', 'credential'],
['editor', 'workflow'],
];
await Promise.all(
roles.map(async ([name, scope]) =>
connection.query(`INSERT INTO role (name, scope) VALUES ("${name}", "${scope}");`),
),
);
await connection.query(
`INSERT INTO user (id, globalRoleId) values ("${uuid()}", ${instanceOwnerRole[0].insertId})`,
);
await connection.query(
"INSERT INTO \"settings\" (key, value, loadOnStartup) values ('userManagement.isInstanceOwnerSetUp', 'false', true)",
);
config.set('userManagement.isInstanceOwnerSetUp', false);
};
const resetLogStreaming = async () => {
enabledFeatures[LICENSE_FEATURES.LOG_STREAMING] = false;
for (const id in eventBus.destinations) {
await eventBus.removeDestination(id);
}
};
export const e2eController = Router();
e2eController.post('/db/reset', async (req, res) => {
await resetLogStreaming();
await truncateAll();
await setupUserManagement();
res.writeHead(204).end();
});
e2eController.post('/db/setup-owner', bodyParser.json(), async (req, res) => {
if (config.get('userManagement.isInstanceOwnerSetUp')) {
res.writeHead(500).send({ error: 'Owner already setup' });
return;
}
const globalRole = await Container.get(RoleRepository).findGlobalOwnerRoleOrFail();
const owner = await Db.collections.User.findOneByOrFail({ globalRoleId: globalRole.id });
await Db.collections.User.update(owner.id, {
email: req.body.email,
password: await hashPassword(req.body.password),
firstName: req.body.firstName,
lastName: req.body.lastName,
});
await Db.collections.Settings.update(
{ key: 'userManagement.isInstanceOwnerSetUp' },
{ value: 'true' },
);
config.set('userManagement.isInstanceOwnerSetUp', true);
res.writeHead(204).end();
});
e2eController.patch(
'/feature/:feature',
bodyParser.json(),
async (req: Request<{ feature: Feature }>, res) => {
const { feature } = req.params;
const { enabled } = req.body;
enabledFeatures[feature] = enabled === undefined || enabled === true;
res.writeHead(204).end();
},
);

1
packages/cli/src/config/index.ts
View File

@@ -18,7 +18,6 @@ if (inE2ETests) {
N8N_PUBLIC_API_DISABLED: 'true',
EXTERNAL_FRONTEND_HOOKS_URLS: '',
N8N_PERSONALIZATION_ENABLED: 'false',
NODE_FUNCTION_ALLOW_EXTERNAL: 'node-fetch',
};
} else if (inTest) {
const testsDir = join(tmpdir(), 'n8n-tests/');

154
packages/cli/src/controllers/e2e.controller.ts Normal file
View File

@@ -0,0 +1,154 @@
import { Request } from 'express';
import { Service } from 'typedi';
import { v4 as uuid } from 'uuid';
import config from '@/config';
import type { Role } from '@db/entities/Role';
import { RoleRepository, SettingsRepository, UserRepository } from '@db/repositories';
import { hashPassword } from '@/UserManagement/UserManagementHelper';
import { eventBus } from '@/eventbus/MessageEventBus/MessageEventBus';
import { License } from '@/License';
import { LICENSE_FEATURES, inE2ETests } from '@/constants';
import { NoAuthRequired, Patch, Post, RestController } from '@/decorators';
import type { UserSetupPayload } from '@/requests';
if (!inE2ETests) {
console.error('E2E endpoints only allowed during E2E tests');
process.exit(1);
}
const tablesToTruncate = [
'auth_identity',
'auth_provider_sync_history',
'event_destinations',
'shared_workflow',
'shared_credentials',
'webhook_entity',
'workflows_tags',
'credentials_entity',
'tag_entity',
'workflow_statistics',
'workflow_entity',
'execution_entity',
'settings',
'installed_packages',
'installed_nodes',
'user',
'role',
'variables',
];
type ResetRequest = Request<
{},
{},
{
owner: UserSetupPayload;
members: UserSetupPayload[];
}
>;
@Service()
@NoAuthRequired()
@RestController('/e2e')
export class E2EController {
private enabledFeatures: Record<LICENSE_FEATURES, boolean> = {
[LICENSE_FEATURES.SHARING]: false,
[LICENSE_FEATURES.LDAP]: false,
[LICENSE_FEATURES.SAML]: false,
[LICENSE_FEATURES.LOG_STREAMING]: false,
[LICENSE_FEATURES.ADVANCED_EXECUTION_FILTERS]: false,
[LICENSE_FEATURES.SOURCE_CONTROL]: false,
[LICENSE_FEATURES.VARIABLES]: false,
[LICENSE_FEATURES.API_DISABLED]: false,
};
constructor(
license: License,
private roleRepo: RoleRepository,
private settingsRepo: SettingsRepository,
private userRepo: UserRepository,
) {
license.isFeatureEnabled = (feature: LICENSE_FEATURES) =>
this.enabledFeatures[feature] ?? false;
}
@Post('/reset')
async reset(req: ResetRequest) {
this.resetFeatures();
await this.resetLogStreaming();
await this.truncateAll();
await this.setupUserManagement(req.body.owner, req.body.members);
}
@Patch('/feature')
setFeature(req: Request<{}, {}, { feature: LICENSE_FEATURES; enabled: boolean }>) {
const { enabled, feature } = req.body;
this.enabledFeatures[feature] = enabled;
}
private resetFeatures() {
for (const feature of Object.keys(this.enabledFeatures)) {
this.enabledFeatures[feature as LICENSE_FEATURES] = false;
}
}
private async resetLogStreaming() {
for (const id in eventBus.destinations) {
await eventBus.removeDestination(id);
}
}
private async truncateAll() {
for (const table of tablesToTruncate) {
try {
const { connection } = this.roleRepo.manager;
await connection.query(
`DELETE FROM ${table}; DELETE FROM sqlite_sequence WHERE name=${table};`,
);
} catch (error) {
console.warn('Dropping Table for E2E Reset error: ', error);
}
}
}
private async setupUserManagement(owner: UserSetupPayload, members: UserSetupPayload[]) {
const roles: Array<[Role['name'], Role['scope']]> = [
['owner', 'global'],
['member', 'global'],
['owner', 'workflow'],
['owner', 'credential'],
['user', 'credential'],
['editor', 'workflow'],
];
const [{ id: globalOwnerRoleId }, { id: globalMemberRoleId }] = await this.roleRepo.save(
roles.map(([name, scope], index) => ({ name, scope, id: index.toString() })),
);
const users = [];
users.push({
id: uuid(),
...owner,
password: await hashPassword(owner.password),
globalRoleId: globalOwnerRoleId,
});
for (const { password, ...payload } of members) {
users.push(
this.userRepo.create({
id: uuid(),
...payload,
password: await hashPassword(password),
globalRoleId: globalMemberRoleId,
}),
);
}
await this.userRepo.insert(users);
await this.settingsRepo.update(
{ key: 'userManagement.isInstanceOwnerSetUp' },
{ value: 'true' },
);
config.set('userManagement.isInstanceOwnerSetUp', true);
}
}

19
packages/cli/src/requests.ts
View File

@@ -181,22 +181,19 @@ export declare namespace MeRequest {
export type SurveyAnswers = AuthenticatedRequest<{}, {}, Record<string, string> | {}>;
}
export interface UserSetupPayload {
email: string;
password: string;
firstName: string;
lastName: string;
}
// ----------------------------------
// /owner
// ----------------------------------
export declare namespace OwnerRequest {
type Post = AuthenticatedRequest<
{},
{},
Partial<{
email: string;
password: string;
firstName: string;
lastName: string;
}>,
{}
>;
type Post = AuthenticatedRequest<{}, {}, UserSetupPayload, {}>;
}
// ----------------------------------