From 6742c04de99d2c231a145df57ab43e998a9fbd17 Mon Sep 17 00:00:00 2001 From: petruki <31597636+petruki@users.noreply.github.com> Date: Sun, 4 Oct 2026 16:00:33 -0700 Subject: [PATCH] chore: patched code smells in prod code and tests --- src/aggregator/permission-resolvers.js | 25 ++-- src/aggregator/resolvers.js | 17 +-- src/helpers/index.js | 19 +--- src/models/admin.js | 2 +- src/models/component.js | 6 +- src/models/config-strategy.js | 2 +- src/models/config.js | 4 +- src/models/domain.js | 8 +- src/models/group-config.js | 4 +- src/models/team.js | 3 +- src/routers/admin.js | 9 +- src/services/admin.js | 5 +- src/services/config-strategy.js | 22 ++-- src/services/domain.js | 2 +- src/services/gitops/index.js | 6 +- src/services/gitops/push-deleted.js | 8 +- src/services/gitops/push-new.js | 12 +- src/services/group-config.js | 12 +- src/services/permission.js | 6 +- src/services/team.js | 2 +- tests/admin-saml.test.js | 8 +- tests/admin.test.js | 78 +++++++++---- tests/component.test.js | 43 +++++-- tests/config-relay.test.js | 32 ++++-- tests/config-strategy.test.js | 94 +++++++++++---- tests/environment.test.js | 32 ++++-- tests/gitops-account.test.js | 3 +- tests/group-config.test.js | 72 ++++++++---- tests/metric.test.js | 70 ++++++++---- tests/permission.test.js | 112 +++++++++++++----- tests/slack.test.js | 132 ++++++++++++++++------ tests/team.test.js | 138 +++++++++++++++++------ tests/unit-test/verify-ownership.test.js | 14 +-- 33 files changed, 675 insertions(+), 327 deletions(-) diff --git a/src/aggregator/permission-resolvers.js b/src/aggregator/permission-resolvers.js index fbb55eef..af1db6ed 100644 --- a/src/aggregator/permission-resolvers.js +++ b/src/aggregator/permission-resolvers.js @@ -15,24 +15,23 @@ export async function resolvePermission(args, admin) { let elements = await getElements(args.domain, args.parent, args.router); - let result = []; - for (const element of elements) { - result.push({ - id: element._id, - name: element.name || element.key, - permissions: [] - }); - - for (const action_perm of args.actions) { + const result = await Promise.all(elements.map(async (element) => { + const permissions = await Promise.all(args.actions.map(async (action_perm) => { try { await verifyOwnership(admin, element, args.domain, action_perm, args.router, false, args.environment); - result.at(-1).permissions.push({ action: action_perm.toString(), result: 'ok' }); + return { action: action_perm.toString(), result: 'ok' }; } catch (e) { Logger.debug('resolvePermission', e); - result.at(-1).permissions.push({ action: action_perm.toString(), result: 'nok' }); + return { action: action_perm.toString(), result: 'nok' }; } - } - } + })); + + return { + id: element._id, + name: element.name || element.key, + permissions + }; + })); if (result.length) { permissionCache.set(cacheKey, result); diff --git a/src/aggregator/resolvers.js b/src/aggregator/resolvers.js index afd812d4..2f578840 100644 --- a/src/aggregator/resolvers.js +++ b/src/aggregator/resolvers.js @@ -165,19 +165,12 @@ function isElementActive(element, environment, activated) { async function resolveComponentsFirst(source, context, groups) { if (context._component) { const component = await Component.findOne({ domain: source._id, name: context._component }).exec(); - const validGroups = []; - context._component = component?._id; - for (const group of groups) { - let configsLength = await Config.find({ - domain: source._id, group: group._id, components: context._component - }).countDocuments().exec(); - - if (configsLength) { - validGroups.push(group); - } - } - return validGroups; + const configsLengths = await Promise.all(groups.map(group => Config.find({ + domain: source._id, group: group._id, components: context._component + }).countDocuments().exec())); + + return groups.filter((_, index) => configsLengths[index]); } return groups; } \ No newline at end of file diff --git a/src/helpers/index.js b/src/helpers/index.js index 36550ee2..f8feb8f4 100644 --- a/src/helpers/index.js +++ b/src/helpers/index.js @@ -134,21 +134,10 @@ export async function verifyOwnership(admin, element, domainId, actions, routerT } const actionsArray = Array.isArray(actions) ? actions : [actions]; - let hasPermission = []; - let allowedElement; - - // Verify each team permission - for (const team of teams) { - if (cascade) { - allowedElement = await verifyPermissionsCascade(team, element, actionsArray, routerType, environment); - } else { - allowedElement = await verifyPermissions(team, element, actionsArray, routerType, environment); - } - - if (allowedElement) { - hasPermission.push(allowedElement); - } - } + let hasPermission = (await Promise.all(teams.map((team) => cascade + ? verifyPermissionsCascade(team, element, actionsArray, routerType, environment) + : verifyPermissions(team, element, actionsArray, routerType, environment) + ))).filter(Boolean); if (!hasPermission.length) { throw new PermissionError('Action forbidden'); diff --git a/src/models/admin.js b/src/models/admin.js index 92c85bf1..859d26c3 100644 --- a/src/models/admin.js +++ b/src/models/admin.js @@ -230,9 +230,9 @@ adminSchema.pre('deleteOne', { document: true, query: false }, async function () for (const team of teams) { let indexMmeber = team.members.indexOf(this._id); team.members.splice(indexMmeber, 1); - await team.save(); } + await Promise.all(teams.map(team => team.save())); notifyAcDeletion(this._id); }); diff --git a/src/models/component.js b/src/models/component.js index 9a9d7aca..a8470328 100644 --- a/src/models/component.js +++ b/src/models/component.js @@ -77,11 +77,11 @@ componentSchema.pre('validate', async function () { componentSchema.pre('deleteOne', { document: true, query: false }, async function () { const configsToRemoveFrom = await Config.find({ components: { $in: [this._id] } }).exec(); - for (const config of configsToRemoveFrom) { + await Promise.all(configsToRemoveFrom.map(async (config) => { const indexValue = config.components.indexOf(this._id); config.components.splice(indexValue, 1); - config.save(); - } + await config.save(); + })); }); const Component = mongoose.model('Component', componentSchema); diff --git a/src/models/config-strategy.js b/src/models/config-strategy.js index da018bba..213f72c7 100644 --- a/src/models/config-strategy.js +++ b/src/models/config-strategy.js @@ -259,7 +259,7 @@ configStrategySchema.pre('save', async function () { } const operations = StrategyRequirementDefinition.find(element => element.strategy === strategy).operations; - const foundOperation = operations.find((element) => element === operationStrategy); + const foundOperation = operations.includes(operationStrategy); // Verify strategy operation requirements if (!foundOperation) { diff --git a/src/models/config.js b/src/models/config.js index 2c045786..79d1796d 100644 --- a/src/models/config.js +++ b/src/models/config.js @@ -183,9 +183,7 @@ configSchema.virtual('configStrategy', { configSchema.pre('deleteOne', { document: true, query: false }, async function () { const strategies = await ConfigStrategy.find({ config: this._id }).exec(); if (strategies) { - for (const strategy of strategies) { - await Promise.resolve(strategy.deleteOne()); - } + await Promise.all(strategies.map(strategy => strategy.deleteOne())); } await History.deleteMany({ domainId: this.domain, elementId: this._id }).exec(); diff --git a/src/models/domain.js b/src/models/domain.js index e6cd7f71..28daa324 100644 --- a/src/models/domain.js +++ b/src/models/domain.js @@ -112,16 +112,12 @@ domainSchema.pre('deleteOne', { document: true, query: false }, async function ( const groups = await GroupConfig.find({ domain: this._id }).exec(); if (groups) { - for (const group of groups) { - await Promise.resolve(group.deleteOne()); - } + await Promise.all(groups.map(group => group.deleteOne())); } const teams = await Team.find({ domain: this._id }).exec(); if (teams) { - for (const team of teams) { - await Promise.resolve(team.deleteOne()); - } + await Promise.all(teams.map(team => team.deleteOne())); } await Promise.all([ diff --git a/src/models/group-config.js b/src/models/group-config.js index 14cf85c8..1813c647 100644 --- a/src/models/group-config.js +++ b/src/models/group-config.js @@ -78,9 +78,7 @@ groupConfigSchema.pre('deleteOne', { document: true, query: false }, async funct const configs = await Config.find({ group: this._id }).exec(); if (configs) { - for (const config of configs) { - await Promise.resolve(config.deleteOne()); - } + await Promise.all(configs.map(config => config.deleteOne())); } await History.deleteMany({ domainId: this.domain, elementId: this._id }).exec(); diff --git a/src/models/team.js b/src/models/team.js index 1d7bb16f..a7898e3e 100644 --- a/src/models/team.js +++ b/src/models/team.js @@ -80,8 +80,9 @@ teamSchema.pre('deleteOne', { document: true, query: false }, async function () for (const member of membersToRemve) { const indexValue = member.teams.indexOf(this._id); member.teams.splice(indexValue, 1); - member.save(); } + + await Promise.all(membersToRemve.map((member) => member.save())); }); export const Team = mongoose.model('Team', teamSchema); \ No newline at end of file diff --git a/src/routers/admin.js b/src/routers/admin.js index 02f1b790..776b2c49 100644 --- a/src/routers/admin.js +++ b/src/routers/admin.js @@ -115,17 +115,16 @@ router.post('/admin/collaboration/permission', auth, [ return res.send(permissionCache.get(cacheKey)); } - let result = []; - for (const action_perm of req.body.action) { + const result = await Promise.all(req.body.action.map(async action_perm => { try { await verifyOwnership(req.admin, element, req.body.domain, action_perm, req.body.router, false, req.body.environment); - result.push({ action: action_perm, result: 'ok' }); + return { action: action_perm, result: 'ok' }; } catch (e) { Logger.debug('resolvePermission', e); - result.push({ action : action_perm, result: 'nok' }); + return { action : action_perm, result: 'nok' }; } - } + })); if (result.length) { permissionCache.set(cacheKey, result); diff --git a/src/services/admin.js b/src/services/admin.js index 6aacc4c5..7e6b59ee 100644 --- a/src/services/admin.js +++ b/src/services/admin.js @@ -114,13 +114,14 @@ export async function leaveDomain(domainid, admin) { for (const admin_team of teams) { let indexMmeber = admin_team.members.indexOf(admin.id); admin_team.members.splice(indexMmeber, 1); - await admin_team.save(); let indexTeam = admin.teams.indexOf(admin_team._id); admin.teams.splice(indexTeam, 1); - await saveAdmin(admin); } + await Promise.all(teams.map((admin_team) => admin_team.save())); + await saveAdmin(admin); + return admin; } diff --git a/src/services/config-strategy.js b/src/services/config-strategy.js index beb6fe7b..e825b6f2 100644 --- a/src/services/config-strategy.js +++ b/src/services/config-strategy.js @@ -20,8 +20,8 @@ async function verifyStrategyValueInput(strategyId, value) { } function validateValues(values) { - const invalidValue = values.find(value => value.length > 128); - if (invalidValue) { + const hasInvalidValue = values.some(value => value.length > 128); + if (hasInvalidValue) { throw new BadRequestError('Value cannot be longer than 128 characters'); } } @@ -44,7 +44,7 @@ export async function getStrategies(where, lean = false) { } export async function populateAdmin(configStrategies) { - for (const configStrategy of configStrategies) { + for await (const configStrategy of configStrategies) { await configStrategy.populate({ path: 'admin', select: 'name' }); } } @@ -70,7 +70,7 @@ export async function createStrategy(args, admin, status = true) { RouterTypes.STRATEGY, false, environment.name); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } @@ -81,7 +81,7 @@ export async function deleteStrategy(id, admin) { RouterTypes.STRATEGY, false, configStrategy.activated.keys().next().value); await configStrategy.deleteOne(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); // resets permission cache permissionCache.permissionReset(configStrategy.domain, ActionTypes.ALL, RouterTypes.STRATEGY, configStrategy.name); @@ -98,7 +98,7 @@ export async function updateStrategy(id, args, admin) { const updates = Object.keys(args); updates.forEach((update) => configStrategy[update] = args[update]); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } @@ -107,7 +107,7 @@ export async function addVal(id, args, admin) { let configStrategy = await verifyStrategyValueInput(id, args.value); const value = args.value.trim(); - const foundExistingOne = configStrategy.values.find((element) => element === value); + const foundExistingOne = configStrategy.values.includes(value); validateValues([value]); if (foundExistingOne) { @@ -120,7 +120,7 @@ export async function addVal(id, args, admin) { configStrategy.values.push(value); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } @@ -154,7 +154,7 @@ export async function updateVal(id, args, admin) { configStrategy.values.splice(indexOldValue, 1); configStrategy.values.push(newvalue); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } @@ -175,7 +175,7 @@ export async function removeVal(id, args, admin) { configStrategy.values.splice(indexValue, 1); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } @@ -199,7 +199,7 @@ export async function updateStatusEnv(id, args, admin) { configStrategy.activated.set(updates[0], args[updates[0]]); await configStrategy.save(); - updateDomainVersion(configStrategy.domain); + await updateDomainVersion(configStrategy.domain); return configStrategy; } \ No newline at end of file diff --git a/src/services/domain.js b/src/services/domain.js index 4c2173ce..cf3032d9 100644 --- a/src/services/domain.js +++ b/src/services/domain.js @@ -61,7 +61,7 @@ export async function createDomain(args, admin) { owner: admin._id }); - environment.save(); + await environment.save(); return saveDomain(domain); } diff --git a/src/services/gitops/index.js b/src/services/gitops/index.js index 270400a6..12fa13ae 100644 --- a/src/services/gitops/index.js +++ b/src/services/gitops/index.js @@ -18,9 +18,9 @@ export async function pushChanges(domainId, environment, changes) { Logger.debug(`Changes: ${JSON.stringify(changes)}`); let domain = await getDomainById(domainId); - for (const change of changes) { - await CHANGE_PROCESSES[change.action](domain, change, environment); - } + await Promise.all(changes.map(change => + CHANGE_PROCESSES[change.action](domain, change, environment) + )); domain = await updateDomainVersion(domainId); return { diff --git a/src/services/gitops/push-deleted.js b/src/services/gitops/push-deleted.js index 598b1fc5..52789250 100644 --- a/src/services/gitops/push-deleted.js +++ b/src/services/gitops/push-deleted.js @@ -64,9 +64,7 @@ async function processComponentDeleted(domain, change) { const components = await getComponents({ domain: domain._id, name: { $in: content } }); const componentIds = components.map(component => component._id); - for (const id of componentIds) { - if (config.components.includes(id)) { - await removeComponent(config._id, { component: id }, admin); - } - } + await Promise.all(componentIds + .filter(id => config.components.includes(id)) + .map(id => removeComponent(config._id, { component: id }, admin))); } \ No newline at end of file diff --git a/src/services/gitops/push-new.js b/src/services/gitops/push-new.js index 2d365c0e..ef7a407e 100644 --- a/src/services/gitops/push-new.js +++ b/src/services/gitops/push-new.js @@ -32,7 +32,7 @@ async function processNewGroup(domain, change, environment) { }, admin); if (content.config?.length) { - for (const config of content.config) { + for await (const config of content.config) { await processNewConfig(domain, { path: [group.name], content: config @@ -81,7 +81,7 @@ async function processNewConfig(domain, change, environment) { const config = await createConfig(newConfig, admin); if (content.strategies?.length) { - for (const strategy of content.strategies) { + for await(const strategy of content.strategies) { await processNewStrategy(domain, { path: [group.name, config.key], content: strategy @@ -117,11 +117,9 @@ async function processNewComponent(domain, change) { const components = await getComponents({ domain: domain._id, name: { $in: content } }); const componentIds = components.map(component => component._id); - for (const id of componentIds) { - if (!config.components.includes(id)) { - await addComponent(config._id, { component: id }, admin); - } - } + await Promise.all(componentIds + .filter(id => !config.components.includes(id)) + .map(id => addComponent(config._id, { component: id }, admin))); } function getNewValue(newValue, defaultValue) { diff --git a/src/services/group-config.js b/src/services/group-config.js index 621fb238..64179c96 100644 --- a/src/services/group-config.js +++ b/src/services/group-config.js @@ -43,7 +43,7 @@ export async function getTotalGroupsByDomainId(domain) { } export async function populateAdmin(groups) { - for (const group of groups) { + for await (const group of groups) { await group.populate({ path: 'admin', select: 'name' }); } } @@ -69,7 +69,7 @@ export async function createGroup(args, admin) { groupconfig = await verifyOwnership(admin, groupconfig, domain._id, ActionTypes.CREATE, RouterTypes.GROUP); // creates group config - updateDomainVersion(domain._id); + await updateDomainVersion(domain._id); await groupconfig.save(); // resets permission cache @@ -83,7 +83,7 @@ export async function deleteGroup(id, admin) { groupconfig = await verifyOwnership(admin, groupconfig, groupconfig.domain, ActionTypes.DELETE, RouterTypes.GROUP); await groupconfig.deleteOne(); - updateDomainVersion(groupconfig.domain); + await updateDomainVersion(groupconfig.domain); // resets permission cache permissionCache.permissionReset(groupconfig.domain, ActionTypes.ALL, RouterTypes.GROUP); @@ -114,7 +114,7 @@ export async function updateGroup(id, args, admin) { updates.forEach((update) => groupconfig[update] = args[update]); groupconfig.name = formatInput(groupconfig.name, { allowSpace: true }); await groupconfig.save(); - updateDomainVersion(groupconfig.domain); + await updateDomainVersion(groupconfig.domain); return groupconfig; } @@ -129,7 +129,7 @@ export async function updateGroupStatusEnv(id, args, admin) { const updates = await checkEnvironmentStatusChange(args, groupconfig.domain); updates.forEach((update) => groupconfig.activated.set(update, args[update])); await groupconfig.save(); - updateDomainVersion(groupconfig.domain); + await updateDomainVersion(groupconfig.domain); return groupconfig; } @@ -140,7 +140,7 @@ export async function removeGroupStatusEnv(id, env, admin) { groupconfig = await verifyOwnership(admin, groupconfig, groupconfig.domain, [ActionTypes.UPDATE, ActionTypes.UPDATE_ENV_STATUS], RouterTypes.GROUP, false, env); groupconfig.updatedBy = admin.email; - updateDomainVersion(groupconfig.domain); + await updateDomainVersion(groupconfig.domain); return removeGroupStatus(groupconfig, env); } diff --git a/src/services/permission.js b/src/services/permission.js index f2e20602..03e45aa8 100644 --- a/src/services/permission.js +++ b/src/services/permission.js @@ -71,11 +71,11 @@ export async function deletePermission(id, admin) { const team = await verifyRequestedTeamByPermission(permission._id, admin, ActionTypes.DELETE); const teams = await getTeams({ permissions: permission._id }); - for (const pTeam of teams) { + await Promise.all(teams.map((pTeam) => { const indexValue = pTeam.permissions.indexOf(permission._id); pTeam.permissions.splice(indexValue, 1); - pTeam.save(); - } + return pTeam.save(); + })); permissionCache.permissionReset(team.domain, permission.action, permission.router); return permission.deleteOne(); diff --git a/src/services/team.js b/src/services/team.js index 876a84fc..a2421b77 100644 --- a/src/services/team.js +++ b/src/services/team.js @@ -90,7 +90,7 @@ export async function createTeam(args, admin, defaultActions) { if (defaultActions) { const actions = defaultActions.split(','); checkActionType(actions); - for (const action of actions) { + for await (const action of actions) { await addDefaultPermission(action, team); } } diff --git a/tests/admin-saml.test.js b/tests/admin-saml.test.js index 76ad5a78..137f20bb 100644 --- a/tests/admin-saml.test.js +++ b/tests/admin-saml.test.js @@ -126,11 +126,13 @@ describe('SAML Authentication', () => { }); // test - await request(app) + const response = await request(app) .post('/admin/saml/callback') .set('Content-Type', 'application/x-www-form-urlencoded') .send('SAMLResponse=test') .expect(401); + + expect(response.body).toBeDefined(); }); test('SAML_SUITE - Should authenticate SAML user from redirect', async () => { @@ -151,10 +153,12 @@ describe('SAML Authentication', () => { }); test('SAML_SUITE - Should reject SAML user authentication - not valid SAML account', async () => { - await request(app) + const response = await request(app) .post('/admin/saml/auth') .set('Authorization', `Bearer ${adminAccountToken}`) .expect(401); + + expect(response.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/admin.test.js b/tests/admin.test.js index 9670df3c..5e1ea0e2 100644 --- a/tests/admin.test.js +++ b/tests/admin.test.js @@ -114,11 +114,13 @@ describe('Testing Admin insertion', () => { const token = response.body.jwt.token; // test - await request(app) + response = await request(app) .get('/admin/me') .set('Authorization', `Bearer ${token}`) .send().expect(401); + expect(response.body).toBeDefined(); + // teardown - restore admin admin.active = true; await admin.save(); @@ -192,11 +194,13 @@ describe('Testing Admin insertion', () => { }); test('ADMIN_SUITE - Should NOT request password recovery - Invalid email', async () => { - await request(app) + const response = await request(app) .post('/admin/login/request/recovery') .send({ email: 'new_admin' }).expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT reset admin password - Invalid code', async () => { @@ -208,7 +212,7 @@ describe('Testing Admin insertion', () => { axiosPostStub.returns(Promise.resolve(mockedRecaptchaResponse)); // test - await request(app) + const response = await request(app) .post('/admin/login/recovery') .send({ code: 'INVALID_CODE', @@ -216,6 +220,8 @@ describe('Testing Admin insertion', () => { token: 'GOOGLE_RECAPTCHA_TOKEN' }).expect(404); + expect(response.body).toBeDefined(); + // restore axiosPostStub.restore(); }); @@ -330,7 +336,7 @@ describe('Testing Admin insertion', () => { }); test('ADMIN_SUITE - Should NOT signup - invalid email format', async () => { - await request(app) + const response = await request(app) .post('/admin/signup') .send({ name: 'Admin', @@ -338,6 +344,8 @@ describe('Testing Admin insertion', () => { password: '12312312312', token: 'GOOGLE_RECAPTCHA_TOKEN' }).expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT signup - Access denied to GitHub User Info', async () => { @@ -468,9 +476,11 @@ describe('Testing Admin insertion', () => { }); test('ADMIN_SUITE - Should NOT return OpenAPI Swagger API document - Not authenticated', async () => { - await request(app) + const response = await request(app) .get('/swagger.json') .send().expect(401); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should renew access', async () => { @@ -561,18 +571,22 @@ describe('Testing Admin insertion', () => { const secondRefreshToken = responseLogin.body.jwt.refreshToken; - await request(app) + let response = await request(app) .get('/admin/me') .set('Authorization', `Bearer ${firstToken}`) .send().expect(401); - + + expect(response.body).toBeDefined(); + // Refreshing should not work as well - await request(app) + response = await request(app) .post('/admin/refresh/me') .set('Authorization', `Bearer ${firstToken}`) .send({ refreshToken: secondRefreshToken }).expect(401); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT renew access - invalid Token', async () => { @@ -611,10 +625,12 @@ describe('Testing Admin insertion', () => { password: adminAccount.password }).expect(200); - await request(app) + response = await request(app) .get('/admin/me') .set('Authorization', `Bearer ${response.body.jwt.token}`) .send().expect(200); + + expect(response.body).toBeDefined(); }); }); @@ -635,12 +651,14 @@ describe('Testing Admin login and fetch', () => { }); test('ADMIN_SUITE - Should not login non-existent admin', async () => { - await request(app) + const response = await request(app) .post('/admin/login') .send({ email: adminMasterAccount.email, password: 'wrongpassword' }).expect(401); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should not login non-active admin', async () => { @@ -650,25 +668,29 @@ describe('Testing Admin login and fetch', () => { await admin.save(); // test - await request(app) + const response = await request(app) .post('/admin/login') .send({ email: adminAccount.email, password: adminAccount.password }).expect(401); + expect(response.body).toBeDefined(); + // teardown - reactivate admin admin.active = true; await admin.save(); }); test('ADMIN_SUITE - Should not login with wrong email format', async () => { - await request(app) + const response = await request(app) .post('/admin/login') .send({ email: 'notemail', password: 'password' }).expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should get profile for admin', async () => { @@ -717,11 +739,13 @@ describe('Testing Admin login and fetch', () => { password: adminMasterAccount.password }).expect(200); - await request(app) + const response = await request(app) .get('/admin/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send() .expect(404); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT get admin profile given an invalid Admin ID', async () => { @@ -732,11 +756,13 @@ describe('Testing Admin login and fetch', () => { password: adminMasterAccount.password }).expect(200); - await request(app) + const response = await request(app) .get('/admin/INVALID_ID') .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send() .expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT get admin profile given unexisting Admin ID', async () => { @@ -747,18 +773,22 @@ describe('Testing Admin login and fetch', () => { password: adminMasterAccount.password }).expect(200); - await request(app) + const response = await request(app) .get(`/admin/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send() .expect(404); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should not get profile for unauthenticated admin', async () => { - await request(app) + const response = await request(app) .get('/admin/me') .send() .expect(401); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should not uddate/me admin fields - malicious name input', async () => { @@ -769,13 +799,15 @@ describe('Testing Admin login and fetch', () => { password: adminMasterAccount.password }).expect(200); - await request(app) + const response = await request(app) .patch('/admin/me') .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send({ name: '' }) .expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should update/me valid admin field', async () => { @@ -824,13 +856,15 @@ describe('Testing Admin login and fetch', () => { password: adminMasterAccount.password }).expect(200); - await request(app) + const response = await request(app) .patch('/admin/me') .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send({ _id: new mongoose.Types.ObjectId() }) .expect(400); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should logout valid admin', async () => { @@ -1111,10 +1145,12 @@ describe('Testing Admin collaboration endpoint', () => { }).expect(200); //test - await request(app) + const response = await request(app) .patch('/admin/me/team/leave/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should NOT remove any user from teams given a INVALID Domain ID', async () => { @@ -1127,10 +1163,12 @@ describe('Testing Admin collaboration endpoint', () => { }).expect(200); //test - await request(app) + const response = await request(app) .patch('/admin/me/team/leave/INVALID_ID') .set('Authorization', `Bearer ${responseLogin.body.jwt.token}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('ADMIN_SUITE - Should remove user from all teams when user is deleted', async () => { diff --git a/tests/component.test.js b/tests/component.test.js index be851483..407d1ba6 100644 --- a/tests/component.test.js +++ b/tests/component.test.js @@ -66,7 +66,7 @@ describe('Insertion tests', () => { }); test('COMPONENT_SUITE - Should NOT create a new Component - Domain not found', async () => { - await request(app) + const response = await request(app) .post('/component/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -74,10 +74,12 @@ describe('Insertion tests', () => { description: 'This is my Web App using this wonderful API', domain: 'FAKE_DOMAIN' }).expect(400); + + expect(response.body).toBeDefined(); }); test('COMPONENT_SUITE - Should NOT create a new Component - Name too short', async () => { - await request(app) + const response = await request(app) .post('/component/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -85,6 +87,8 @@ describe('Insertion tests', () => { description: 'This is my Web App using this wonderful API', domain: domainId }).expect(422); + + expect(response.body).toBeDefined(); }); test('COMPONENT_SUITE - Should generate a valid API Key for a Component', async () => { @@ -103,16 +107,20 @@ describe('Insertion tests', () => { test('COMPONENT_SUITE - Should NOT generate an API Key for', async () => { // Invalid component ID - await request(app) + const responseInvalid = await request(app) .get('/component/generateApiKey/INVALID_COMPONENT_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(responseInvalid.body).toBeDefined(); + // Not found component ID - await request(app) + const responseNotFound = await request(app) .get('/component/generateApiKey/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); }); @@ -152,31 +160,39 @@ describe('Reading tests', () => { }); test('COMPONENT_SUITE - Should NOT read Component - Invalid Id', async () => { - await request(app) + const responseInvalid = await request(app) .get('/component/NOT_FOUND') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalid.body).toBeDefined(); }); test('COMPONENT_SUITE - Should NOT read Component - Not found', async () => { - await request(app) + const responseNotFound = await request(app) .get('/component/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); test('COMPONENT_SUITE - Should NOT read Component - Invalid Domain Id', async () => { - await request(app) + const responseInvalidDomain = await request(app) .get('/component?domain=INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidDomain.body).toBeDefined(); }); test('COMPONENT_SUITE - Should NOT read Component - Domain Id not specified', async () => { - await request(app) + const responseDomainNotSpecified = await request(app) .get('/component?domain=') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseDomainNotSpecified.body).toBeDefined(); }); }); @@ -226,13 +242,14 @@ describe('Updating tests', () => { description: 'Wow, this should be my updated description, only not' }).expect(422); - await request(app) + const responseNotFound = await request(app) .patch('/component/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ description: 'Wow, this should be my updated description, only not' }).expect(404); + expect(responseNotFound.body).toBeDefined(); }); }); @@ -271,7 +288,7 @@ describe('Deletion tests', () => { }); test('COMPONENT_SUITE - Should NOT delete a Component - Invalid Component Id/Not found', async () => { - await request(app) + const responseInvalid = await request(app) .post('/component/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -285,10 +302,14 @@ describe('Deletion tests', () => { .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalid.body).toBeDefined(); + + const responseNotFound = await request(app) .delete('/component/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/config-relay.test.js b/tests/config-relay.test.js index acc176ff..23fcf3a6 100644 --- a/tests/config-relay.test.js +++ b/tests/config-relay.test.js @@ -57,10 +57,12 @@ describe('Testing relay verification', () => { bodyRelay.endpoint.default = 'https://localhost:3001'; // Test - await request(app) + const response = await request(app) .patch(`/config/updateRelay/${configId1}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send(bodyRelay).expect(200); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should update Relay status', async () => { @@ -78,10 +80,12 @@ describe('Testing relay verification', () => { bodyRelay.endpoint.default = 'HTTPS://localhost:3001'; // Test - await request(app) + const response = await request(app) .patch(`/config/updateRelay/${configId1}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send(bodyRelay).expect(200); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should reset Relay verified flag when changing endpoint', async () => { @@ -180,10 +184,12 @@ describe('Testing relay association', () => { }); test('CONFIG_RELAY_SUITE - Should NOT configure new Relay - Config not found', async () => { - await request(app) + const response = await request(app) .patch(`/config/updateRelay/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send(bodyRelayProd).expect(404); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should NOT configure new Relay - Environment does not exist', async () => { @@ -206,7 +212,7 @@ describe('Testing relay association', () => { }); test('CONFIG_RELAY_SUITE - Should NOT configure new Relay - Invalid TYPE', async () => { - await request(app) + const response = await request(app) .patch(`/config/updateRelay/${configId1}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -220,10 +226,12 @@ describe('Testing relay association', () => { }, method: 'GET' }).expect(400); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should NOT configure new Relay - Invalid METHOD', async () => { - await request(app) + const response = await request(app) .patch(`/config/updateRelay/${configId1}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -237,6 +245,8 @@ describe('Testing relay association', () => { }, method: 'PATCH' }).expect(400); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should configure new Relay on new environment', async () => { @@ -333,10 +343,12 @@ describe('Testing relay association', () => { }); test('CONFIG_RELAY_SUITE - Should NOT remove Relays - Config not found', async () => { - await request(app) + const response = await request(app) .patch(`/config/removeRelay/${new mongoose.Types.ObjectId()}/default`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should remove all Relays', async () => { @@ -379,10 +391,12 @@ describe('Testing relay association', () => { }); test('CONFIG_RELAY_SUITE - Should NOT generate verification code - Config not found', async () => { - await request(app) + const response = await request(app) .patch(`/domain/relay/verificationCode/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send(bodyRelayProd).expect(404); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should verify code', async () => { @@ -428,10 +442,12 @@ describe('Testing relay association', () => { .send().expect(200); // Test - await request(app) + const response = await request(app) .patch(`/config/relay/verify/${new mongoose.Types.ObjectId()}/${EnvType.DEFAULT}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('CONFIG_RELAY_SUITE - Should NOT verify code - Invalid code', async () => { diff --git a/tests/config-strategy.test.js b/tests/config-strategy.test.js index cfc32797..b6910d4d 100644 --- a/tests/config-strategy.test.js +++ b/tests/config-strategy.test.js @@ -149,7 +149,7 @@ describe('Testing strategy creation #1', () => { config: configId2 }).expect(400); - await request(app) + const response = await request(app) .post('/configstrategy/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -159,6 +159,8 @@ describe('Testing strategy creation #1', () => { values: ['192.168.0.1/16'], config: configId2 }).expect(400); + + expect(response.body.error).toBeDefined(); }); }); @@ -374,22 +376,28 @@ describe('Testing reading strategies #1', () => { }); test('STRATEGY_SUITE - Should NOT get Config Strategy information - Invalid Config Id', async () => { - await request(app) + const responseNotFound = await request(app) .get('/configstrategy?config=' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFound.body).toBeDefined(); + + const responseInvalidId = await request(app) .get('/configstrategy?config=INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT get Config Strategy information - Invalid Environment query', async () => { - await request(app) + const response = await request(app) .get(`/configstrategy?config=${configId1}&env=${'a'.repeat(50)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -411,15 +419,19 @@ describe('Testing reading/deleting strategies #2', () => { }); test('STRATEGY_SUITE - Should not found Config Strategy information by Id', async () => { - await request(app) + const responseInvalidId = await request(app) .get('/configstrategy/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalidId.body).toBeDefined(); + + const responseNotFound = await request(app) .get('/configstrategy/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); test('STRATEGY_SUITE - Should delete Config Strategy', async () => { @@ -465,15 +477,19 @@ describe('Testing reading/deleting strategies #2', () => { }); test('STRATEGY_SUITE - Should NOT delete Config Strategy', async () => { - await request(app) + const responseInvalidId = await request(app) .delete('/configstrategy/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalidId.body).toBeDefined(); + + const responseNotFound = await request(app) .delete('/configstrategy/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); }); @@ -499,31 +515,37 @@ describe('Testing update strategies #1', () => { }); test('STRATEGY_SUITE - Should NOT update Config Strategy - Invalid Config Id', async () => { - await request(app) + const response = await request(app) .patch('/configstrategy/' + configStrategyId) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ activated: false, config: 'I_SHOULD_NOT_UPDATE_THIS' }).expect(400); + + expect(response.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT update Config Strategy - Invalid Strategy Id', async () => { - await request(app) + const responseInvalidId = await request(app) .patch('/configstrategy/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ description: 'New description', }).expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT update Config Strategy - Config Strategy Id not found', async () => { - await request(app) + const responseNotFound = await request(app) .patch('/configstrategy/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ description: 'New description', }).expect(404); + + expect(responseNotFound.body).toBeDefined(); }); test('STRATEGY_SUITE - Should record changes on history collection', async () => { @@ -579,27 +601,35 @@ describe('Testing update strategies #1', () => { }); test('STRATEGY_SUITE - Should NOT list changes by invalid Strategy Id', async () => { - await request(app) + const responseNotFound = await request(app) .get('/configstrategy/history/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFound.body).toBeDefined(); + + const responseInvalidId = await request(app) .get('/configstrategy/history/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT delete history by invalid Strategy Id', async () => { - await request(app) + const responseNotFound = await request(app) .delete('/configstrategy/history/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFound.body).toBeDefined(); + + const responseInvalidId = await request(app) .delete('/configstrategy/history/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should delete history from a Strategy element', async () => { @@ -729,31 +759,37 @@ describe('Testing update strategies #1', () => { }); test('STRATEGY_SUITE - Should NOT add new value to Strategy values - Invalid Strategy Id', async () => { - await request(app) + const responseInvalidId = await request(app) .patch('/configstrategy/addval/INVALID_STRATEGY_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'USER_3' }).expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT add new value to Strategy values - Strategy Id Not Found', async () => { - await request(app) + const responseNotFound = await request(app) .patch('/configstrategy/addval/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'USER_3' }).expect(404); + + expect(responseNotFound.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT update a values - Invalid Strategy Id', async () => { - await request(app) + const responseInvalidId = await request(app) .patch('/configstrategy/updateval/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ oldvalue: 'USER_3', newvalue: 'USER_THREE' }).expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should update a value inside Strategy values', async () => { @@ -847,19 +883,22 @@ describe('Testing update strategies #2', () => { }); test('STRATEGY_SUITE - Should NOT remove a value from an invalid Strategy', async () => { - await request(app) + const responseNotFound = await request(app) .patch('/configstrategy/removeval/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'USER_3' }).expect(404); - await request(app) + const responseInvalidId = await request(app) .patch('/configstrategy/removeval/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'USER_3' }).expect(422); + + expect(responseNotFound.body).toBeDefined(); + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT remove a value from Strategy values', async () => { @@ -917,15 +956,19 @@ describe('Testing fetch strategies', () => { }); test('STRATEGY_SUITE - Should NOT fetch values from Strategy', async () => { - await request(app) + const responseNotFound = await request(app) .get('/configstrategy/values/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFound.body).toBeDefined(); + + const responseInvalidId = await request(app) .get('/configstrategy/values/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('STRATEGY_SUITE - Should update Strategy environment status - default', async () => { @@ -998,19 +1041,22 @@ describe('Scenario: creating QA environment and modifying its status', () => { }); test('STRATEGY_SUITE - Should NOT update Strategy environment status - Strategy not fould', async () => { - await request(app) + const responseInvalidId = await request(app) .patch('/configstrategy/updateStatus/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ default: false }).expect(422); - await request(app) + const responseNotFound = await request(app) .patch('/configstrategy/updateStatus/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ default: false }).expect(404); + + expect(responseInvalidId.body).toBeDefined(); + expect(responseNotFound.body).toBeDefined(); }); test('STRATEGY_SUITE - Should NOT update Strategy environment status - More than one environemnt', async () => { diff --git a/tests/environment.test.js b/tests/environment.test.js index 8cf418a8..7c581aed 100644 --- a/tests/environment.test.js +++ b/tests/environment.test.js @@ -43,13 +43,15 @@ describe('Insertion tests', () => { }); test('ENV_SUITE - Should NOT create a new Environment - Permission denied', async () => { - await request(app) + const response = await request(app) .post('/environment/create') .set('Authorization', `Bearer ${adminAccountToken}`) .send({ name: 'QA', domain: domainId }).expect(403); + + expect(response.body.error).toBeDefined(); }); test('ENV_SUITE - Should NOT create a new Environment - Environment already exists', async () => { @@ -65,13 +67,15 @@ describe('Insertion tests', () => { }); test('ENV_SUITE - Should NOT create a new Environment - Domain not found', async () => { - await request(app) + const response = await request(app) .post('/environment/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ name: 'DEV', domain: 'FAKE_DOMAIN' }).expect(404); + + expect(response.body.error).toBeDefined(); }); }); @@ -96,10 +100,12 @@ describe('Reading tests', () => { }); test('ENV_SUITE - Should NOT read Environment - Not found', async () => { - await request(app) + const response = await request(app) .get('/environment/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -139,17 +145,21 @@ describe('Deletion tests', () => { }); test('ENV_SUITE - Should NOT delete an Environment - Invalid Env Id', async () => { - await request(app) + const response = await request(app) .delete('/environment/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('ENV_SUITE - Should NOT delete an Environment - Env not found', async () => { - await request(app) + const response = await request(app) .delete('/environment/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body.error).toBeDefined(); }); test('ENV_SUITE - Should NOT delete an Environment - Permission denied', async () => { @@ -161,10 +171,12 @@ describe('Deletion tests', () => { domain: domainId }).expect(201); - await request(app) + const response403 = await request(app) .delete('/environment/' + response.body._id) .set('Authorization', `Bearer ${adminAccountToken}`) .send().expect(403); + + expect(response403.body.error).toBeDefined(); }); test('ENV_SUITE - Should recover an Environment', async () => { @@ -252,16 +264,20 @@ describe('Deletion tests', () => { }); test('ENV_SUITE - Should NOT recover an Environment - Invalid Env Id', async () => { - await request(app) + const responseInvalidId = await request(app) .patch('/environment/recover/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('ENV_SUITE - Should NOT recover an Environment - Env not found', async () => { - await request(app) + const responseNotFound = await request(app) .patch('/environment/recover/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFound.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/gitops-account.test.js b/tests/gitops-account.test.js index b9cb2ebd..32523b25 100644 --- a/tests/gitops-account.test.js +++ b/tests/gitops-account.test.js @@ -630,12 +630,13 @@ describe('GitOps Account - Unsubscribe', () => { }); // test - await request(app) + const response = await request(app) .post(`/gitops/v1/account/unsubscribe`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send(VALID_DELETE_REQUEST) .expect(200); + expect(response.body).toBeDefined(); postStub.restore(); }); diff --git a/tests/group-config.test.js b/tests/group-config.test.js index 4abb3692..1493e0c7 100644 --- a/tests/group-config.test.js +++ b/tests/group-config.test.js @@ -163,39 +163,51 @@ describe('Testing fetch Group info', () => { }); test('GROUP_SUITE - Should NOT get Group Config information by Id', async () => { - await request(app) + const responseNotFound = await request(app) .get('/groupconfig/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFound.body).toBeDefined(); + + const responseInvalidId = await request(app) .get('/groupconfig/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidId.body).toBeDefined(); }); test('GROUP_SUITE - Should NOT found Group Config information by Id', async () => { - await request(app) + const responseInvalidDomain = await request(app) .get('/groupconfig?domain=INVALD_ID') .set('Authorization', `Bearer ${adminAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalidDomain.body).toBeDefined(); + + const responseNotFoundDomain = await request(app) .get('/groupconfig?domain=' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminAccountToken}`) .send().expect(404); + + expect(responseNotFoundDomain.body).toBeDefined(); }); test('GROUP_SUITE - Should NOT delete Group Config by invalid Group Id', async () => { - await request(app) + const responseInvalidGroupId = await request(app) .delete('/groupconfig/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalidGroupId.body).toBeDefined(); + + const responseNotFoundGroupId = await request(app) .delete('/groupconfig/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFoundGroupId.body).toBeDefined(); }); test('GROUP_SUITE - Should delete Group Config', async () => { @@ -273,29 +285,35 @@ describe('Testing update Group info', () => { }); test('GROUP_SUITE - Should NOT update Group Config info', async () => { - await request(app) - .patch('/groupconfig/' + groupConfigId) - .set('Authorization', `Bearer ${adminMasterAccountToken}`) - .send({ - name: 'Updated Group Name', - owner: 'I_SHOULD_NOT_UPDATE_THIS' - }).expect(400); + const responseInvalidUpdate = await request(app) + .patch('/groupconfig/' + groupConfigId) + .set('Authorization', `Bearer ${adminMasterAccountToken}`) + .send({ + name: 'Updated Group Name', + owner: 'I_SHOULD_NOT_UPDATE_THIS' + }).expect(400); + + expect(responseInvalidUpdate.body.error).toBeDefined(); }); test('GROUP_SUITE - Should NOT update an unknown Group Config', async () => { - await request(app) + const responseInvalidGroupId = await request(app) .patch('/groupconfig/UNKNOWN_GROUP_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ name: 'Updated Group Name' }).expect(422); - await request(app) + expect(responseInvalidGroupId.body).toBeDefined(); + + const responseNotFoundGroupId = await request(app) .patch('/groupconfig/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ name: 'Updated Group Name' }).expect(404); + + expect(responseNotFoundGroupId.body).toBeDefined(); }); test('GROUP_SUITE - Should update Group environment status - default', async () => { @@ -316,27 +334,35 @@ describe('Testing update Group info', () => { }); test('GROUP_SUITE - Should NOT list changes by invalid Group Id', async () => { - await request(app) + const responseInvalidHistoryId = await request(app) .get('/groupconfig/history/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); - await request(app) + expect(responseInvalidHistoryId.body).toBeDefined(); + + const responseNotFoundHistoryId = await request(app) .get('/groupconfig/history/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(responseNotFoundHistoryId.body).toBeDefined(); }); test('GROUP_SUITE - Should NOT delete history by invalid Group Id', async () => { - await request(app) + const responseNotFoundHistory = await request(app) .delete('/groupconfig/history/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); - await request(app) + expect(responseNotFoundHistory.body).toBeDefined(); + + const responseInvalidHistory = await request(app) .delete('/groupconfig/history/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(responseInvalidHistory.body).toBeDefined(); }); test('GROUP_SUITE - Should delete history from a Group element', async () => { @@ -446,19 +472,23 @@ describe('Testing envrionment status change #1', () => { }); test('GROUP_SUITE - Should NOT update Group environment status - Invalid Group Id', async () => { - await request(app) + const responseInvalidGroupId = await request(app) .patch('/groupconfig/updateStatus/INVALID_ID_VALUE') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ default: false }).expect(422); - await request(app) + expect(responseInvalidGroupId.body).toBeDefined(); + + const responseNotFoundGroupId = await request(app) .patch('/groupconfig/updateStatus/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ default: false }).expect(404); + + expect(responseNotFoundGroupId.body).toBeDefined(); }); }); diff --git a/tests/metric.test.js b/tests/metric.test.js index 88b5713f..06d0db40 100644 --- a/tests/metric.test.js +++ b/tests/metric.test.js @@ -129,84 +129,100 @@ describe('Fetch overall statistics', () => { }); test('METRIC_SUITE - Should NOT return statistics when no Domain is provided', async () => { - await request(app) + const response = await request(app) .get('/metric/statistics?statistics=all') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should NOT return statistics - Invalid queries', async () => { - await request(app) + let response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&environment=${'a'.repeat(31)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) - .send().expect(422); + .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&component=${'a'.repeat(51)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&key=${'a'.repeat(31)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&group=${'a'.repeat(31)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&result=not_true`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&dateBefore=202000`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&dateAfter=2020000`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should return statistics - Valid queries', async () => { - await request(app) + let response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&environment=${'a'.repeat(30)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&component=${'a'.repeat(50)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&key=${'a'.repeat(30)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&group=${'a'.repeat(30)}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&result=true`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); - - await request(app) + expect(response.body).toBeDefined(); + + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&dateBefore=2020-10-10`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + response = await request(app) .get(`/metric/statistics?domainid=${domainId}&statistics=all&dateAfter=2020-10-10`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); }); }); @@ -224,17 +240,21 @@ describe('Fetch metrics', () => { }); test('METRIC_SUITE - Should NOT fetch records from a unknown Domain - Not Domain Id', async () => { - await request(app) + const response = await request(app) .get('/metric/data?domainid=UNKNOWN&page=1') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should NOT fetch records - Invalid attribute for page', async () => { - await request(app) + const response = await request(app) .get(`/metric/data?domainid=${domainId}&page=test`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(500); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should fetch records by KEY', async () => { @@ -366,24 +386,30 @@ describe('Delete metrics', () => { beforeAll(setupDatabase); test('METRIC_SUITE - Should NOT delete metrics - Invalid ID', async () => { - await request(app) + const response = await request(app) .delete(`/metric?domainid=${domainId}&key=INVALID_ID`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should NOT delete metrics - Domain ID not provided', async () => { - await request(app) + const response = await request(app) .delete('/metric?key=INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should NOT delete metrics - Permission denied', async () => { - await request(app) + const response = await request(app) .delete(`/metric?domainid=${domainId}&key=KEY_1`) .set('Authorization', `Bearer ${adminAccountToken}`) .send().expect(403); + + expect(response.body).toBeDefined(); }); test('METRIC_SUITE - Should delete metrics', async () => { diff --git a/tests/permission.test.js b/tests/permission.test.js index 8ed1cec4..d2fb27d6 100644 --- a/tests/permission.test.js +++ b/tests/permission.test.js @@ -38,32 +38,38 @@ describe('Insertion tests', () => { }); test('PERMISSION_SUITE - Should NOT create a new Permission - Invalid parameter (route instead of router)', async () => { - await request(app) + const response = await request(app) .post('/permission/create/' + team1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ action: ActionTypes.READ, route: RouterTypes.GROUP }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT create a new Permission - Missing required parameter', async () => { - await request(app) + const response = await request(app) .post('/permission/create/' + team1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ action: ActionTypes.READ }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT create a new Permission - Team not found', async () => { - await request(app) + const response = await request(app) .post('/permission/create/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ action: ActionTypes.READ, router: RouterTypes.STRATEGY }).expect(404); + + expect(response.body).toBeDefined(); }); }); @@ -91,7 +97,7 @@ describe('Insertion tests - by Environment', () => { }); test('PERMISSION_SUITE - Should NOT create a new Permission - Environment is not an Array', async () => { - await request(app) + const response = await request(app) .post('/permission/create/' + team1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ @@ -99,6 +105,8 @@ describe('Insertion tests - by Environment', () => { router: RouterTypes.GROUP, environments: 'development' }).expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -129,10 +137,12 @@ describe('Reading tests', () => { }); test('PERMISSION_SUITE - Should NOT read all Permissions from a Domain - Invalid team Id', async () => { - await request(app) + const response = await request(app) .get('/permission?team=INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should read one single Permission', async () => { @@ -145,31 +155,39 @@ describe('Reading tests', () => { }); test('PERMISSION_SUITE - Should NOT read Permission - Not found', async () => { - await request(app) + const response = await request(app) .get(`/permission/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT read Permission - Invalid Id', async () => { - await request(app) + const response = await request(app) .get('/permission/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT read Permission - Team Id not provided', async () => { - await request(app) + const response = await request(app) .get('/permission') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT read Permissions - Team not found', async () => { - await request(app) + const response = await request(app) .get('/permission?team=' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should get all available routers', async () => { @@ -227,30 +245,36 @@ describe('Updating tests', () => { }); test('PERMISSION_SUITE - Should NOT update a Permission - Invalid field', async () => { - await request(app) + const response = await request(app) .patch('/permission/' + team1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'New Value' }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT update a Permission - Not found', async () => { - await request(app) + const response = await request(app) .patch('/permission/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ active: true }).expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT update a Permission - Invalid id', async () => { - await request(app) + const response = await request(app) .patch('/permission/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ active: true }).expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -284,17 +308,21 @@ describe('Deletion tests', () => { }); test('PERMISSION_SUITE - Should NOT delete a Permission - Not found', async () => { - await request(app) + const response = await request(app) .delete('/permission/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT delete a Permission - Invalid Id', async () => { - await request(app) + const response = await request(app) .delete('/permission/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -340,117 +368,143 @@ describe('Updating permission values tests', () => { }); test('PERMISSION_SUITE - Should NOT add a value - Permission not found', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/add/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT add a value - Invalid Permission Id', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/add/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT add a value - Value not given', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/add/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT add a value - Value already joined', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/add/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT add a value - Invalid parameter', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/add/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ values: ['NEW'] }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT update values from a permission - Invalid ID', async () => { - await request(app) + const response = await request(app) .patch('/permission/updateValues/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ values: ['NEW VALUE 1', 'OLD VALUE'] }).expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT update values from a permission - Wrong ID', async () => { - await request(app) + const response = await request(app) .patch('/permission/updateValues/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ values: ['NEW VALUE 1', 'OLD VALUE'] }).expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT remove a value - Permission not found', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/' + new mongoose.Types.ObjectId()) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT remove a value - Invalid Permission Id', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT remove a value - Value not given', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT remove a value - Invalid parameter', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ values: '<- INVALID' }).expect(400); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should NOT remove a value - Value does not exist', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NOT_EXISTING_VALUE' }).expect(404); + + expect(response.body).toBeDefined(); }); test('PERMISSION_SUITE - Should remove a value', async () => { - await request(app) + const response = await request(app) .patch('/permission/value/remove/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ value: 'NEW VALUE' }).expect(200); + expect(response.body).toBeDefined(); + // DB validation const permission = await Permission.findById(permission1Id).lean().exec(); expect(permission.values.length).toBe(0); @@ -474,11 +528,13 @@ describe('Updating environments tests', () => { }); test('PERMISSION_SUITE - Should NOT set an environment to the permission - Invalid value (not an array)', async () => { - await request(app) + const response = await request(app) .patch('/permission/' + permission1Id) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ environments: 'development' }).expect(422); + + expect(response.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/slack.test.js b/tests/slack.test.js index 7e376173..7679e3bf 100644 --- a/tests/slack.test.js +++ b/tests/slack.test.js @@ -169,10 +169,12 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT save installation - Token expired', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/installation') .set('Authorization', `Bearer ${generateToken('0ms')}`) .send(mock1_slack_installation).expect(401); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT save installation - Missing installation payload', async () => { @@ -181,10 +183,12 @@ describe('Slack Installation', () => { delete slack_install.installation_payload; //test - await request(app) + const response = await request(app) .post('/slack/v1/installation') .set('Authorization', `Bearer ${generateToken('30s')}`) .send(slack_install).expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should authorize installation', async () => { @@ -242,17 +246,21 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT query installation by Domain - Domain not found', async () => { - await request(app) + const response = await request(app) .get(`/slack/v1/installation/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT query installation by Domain - Invalid Domain', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/installation/INVALID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT authorize installation - Admin is not owner', async () => { @@ -260,42 +268,50 @@ describe('Slack Installation', () => { const installation = await buildInstallation('T01Y', null); //test - await request(app) + const response = await request(app) .post('/slack/v1/authorize') .set('Authorization', `Bearer ${adminAccountToken}`) .send({ domain: domainId, team_id: installation.team_id }).expect(403); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT authorize installation - Invalid Domain Id', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/authorize') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ domain: 'INVALID_DOMAIN', team_id: 'team_id' }).expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT authorize installation - Domain Id not found', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/authorize') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ domain: new mongoose.Types.ObjectId(), team_id: 'T04Y' }).expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT authorize installation - Team Id is missing', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/authorize') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ domain: domainId }).expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should find bot', async () => { @@ -315,17 +331,21 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT find bot - Not found', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/findbot?enterprise_id=&team_id=T15NZ') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT find bot - Missing param', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/findbot') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should find installation', async () => { @@ -345,17 +365,21 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT find installation - Not found', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/findinstallation?enterprise_id=&team_id=T12NZ') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT find installation - Missing param', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/findinstallation') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should find installation (Admin)', async () => { @@ -382,11 +406,13 @@ describe('Slack Installation', () => { await Services.createSlackInstallation(installation); //test - await request(app) + const response = await request(app) .delete(`/slack/v1/installation?enterprise_id=&team_id=${installation.team_id}`) .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(200); + expect(response.body).toBeDefined(); + //check DB const slackDb = await Services.getSlack({ enterprise_id: installation.enterprise_id, @@ -400,28 +426,34 @@ describe('Slack Installation', () => { const installation = await buildInstallation('T05NZ', null); //test - await request(app) + const response = await request(app) .delete(`/slack/v1/installation?team_id=${installation.team_id}`) .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(200); + expect(response.body).toBeDefined(); + //check DB const slackDb = await Services.getSlack({ team_id: installation.team_id }); expect(slackDb).toBe(null); }); test('SLACK_SUITE - Should NOT delete installation - Not found', async () => { - await request(app) + const response = await request(app) .delete('/slack/v1/installation?enterprise_id=&team_id=T06NZ') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT delete installation - Missing param', async () => { - await request(app) + const response = await request(app) .delete('/slack/v1/installation') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should unlink installation', async () => { @@ -487,10 +519,12 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT unlink installation - Domain Id not provided', async () => { - await request(app) + const response = await request(app) .delete('/slack/v1/installation/unlink') .set('Authorization', `Bearer ${adminAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should decline installation', async () => { @@ -549,17 +583,21 @@ describe('Slack Installation', () => { }); test('SLACK_SUITE - Should NOT find Domains by Slack Team Id - Missing param', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/domains') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT find Domains by Slack Team Id - Team Id not found', async () => { - await request(app) + const response = await request(app) .get('/slack/v1/domains?team_id=T03NZ') .set('Authorization', `Bearer ${generateToken('30s')}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); }); @@ -611,30 +649,36 @@ describe('Slack Settings', () => { }); test('SLACK_SUIT - Should NOT update settings - Invalid Domain Id', async () => { - await request(app) + const response = await request(app) .patch(`/slack/v1/settings/${TicketValidationType.IGNORED_ENVIRONMENT}/INVALID`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ environments: ['dev', 'dev1'] }).expect(422); + + expect(response.body).toBeDefined(); }); test('SLACK_SUIT - Should NOT update settings - Slack Installation not found', async () => { - await request(app) + const response = await request(app) .patch(`/slack/v1/settings/${TicketValidationType.IGNORED_ENVIRONMENT}/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ environments: ['dev', 'dev1'] }).expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUIT - Should NOT update settings - Invalid Parameter', async () => { - await request(app) + const response = await request(app) .patch(`/slack/v1/settings/INVALID/${domainId}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ environments: ['dev', 'dev1'] }).expect(400); + + expect(response.body).toBeDefined(); }); }); @@ -855,7 +899,7 @@ describe('Slack Route - Create Ticket', () => { }; //test - invalid domain id - await request(app) + let response = await request(app) .post('/slack/v1/ticket/validate') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -863,18 +907,20 @@ describe('Slack Route - Create Ticket', () => { domain_id: 'INVALID', ticket_content }).expect(422); + expect(response.body).toBeDefined(); //test - domain not provided - await request(app) + response = await request(app) .post('/slack/v1/ticket/validate') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ team_id: slack.team_id, ticket_content }).expect(422); + expect(response.body).toBeDefined(); //test - domain not found - await request(app) + response = await request(app) .post('/slack/v1/ticket/validate') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -882,6 +928,7 @@ describe('Slack Route - Create Ticket', () => { domain_id: new mongoose.Types.ObjectId(), ticket_content }).expect(404); + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT create a ticket - Invalid Domain Id', async () => { @@ -893,7 +940,7 @@ describe('Slack Route - Create Ticket', () => { }; //test - invalid domain id - await request(app) + let response = await request(app) .post('/slack/v1/ticket/create') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -901,18 +948,20 @@ describe('Slack Route - Create Ticket', () => { domain_id: 'INVALID', ticket_content }).expect(422); + expect(response.body).toBeDefined(); //test - domain not provided - await request(app) + response = await request(app) .post('/slack/v1/ticket/create') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ team_id: slack.team_id, ticket_content }).expect(422); + expect(response.body).toBeDefined(); //test - domain not found - await request(app) + response = await request(app) .post('/slack/v1/ticket/create') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -920,6 +969,7 @@ describe('Slack Route - Create Ticket', () => { domain_id: new mongoose.Types.ObjectId(), ticket_content }).expect(404); + expect(response.body).toBeDefined(); }); }); @@ -994,7 +1044,7 @@ describe('Slack Route - Process Ticket', () => { }); test('SLACK_SUITE - Should NOT process a ticket - Ticket not found', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/ticket/process') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -1003,13 +1053,15 @@ describe('Slack Route - Process Ticket', () => { ticket_id: new mongoose.Types.ObjectId(), approved: true }).expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT process a ticket - Invalid Domain Id', async () => { const { ticket } = await createTicket(); //test - invalid domain id - await request(app) + let response = await request(app) .post('/slack/v1/ticket/process') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -1018,9 +1070,10 @@ describe('Slack Route - Process Ticket', () => { ticket_id: ticket._id, approved: true }).expect(422); + expect(response.body).toBeDefined(); //test - domain not provided - await request(app) + response = await request(app) .post('/slack/v1/ticket/process') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -1028,9 +1081,10 @@ describe('Slack Route - Process Ticket', () => { ticket_id: ticket._id, approved: true }).expect(422); + expect(response.body).toBeDefined(); //test - domain not found - await request(app) + response = await request(app) .post('/slack/v1/ticket/process') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -1039,10 +1093,11 @@ describe('Slack Route - Process Ticket', () => { ticket_id: ticket._id, approved: true }).expect(404); + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should NOT process a ticket - Installation not found', async () => { - await request(app) + const response = await request(app) .post('/slack/v1/ticket/process') .set('Authorization', `Bearer ${generateToken('30s')}`) .send({ @@ -1051,6 +1106,8 @@ describe('Slack Route - Process Ticket', () => { ticket_id: new mongoose.Types.ObjectId(), approved: true }).expect(404); + + expect(response.body).toBeDefined(); }); test('SLACK_SUITE - Should deny a ticket', async () => { @@ -1112,30 +1169,33 @@ describe('Slack Route - Process Ticket', () => { test('SLACK_SUITE - Should NOT reset installation tickets - Invalid Domain Id', async () => { //test - invalid domain id - await request(app) + let response = await request(app) .post('/slack/v1/ticket/clear') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ team_id: slack.team_id, domain_id: 'INVALID' }).expect(422); + expect(response.body).toBeDefined(); //test - domain not provided - await request(app) + response = await request(app) .post('/slack/v1/ticket/clear') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ team_id: slack.team_id }).expect(422); + expect(response.body).toBeDefined(); //test - domain not found - await request(app) + response = await request(app) .post('/slack/v1/ticket/clear') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ team_id: slack.team_id, domain_id: new mongoose.Types.ObjectId() }).expect(404); + expect(response.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/team.test.js b/tests/team.test.js index c0eccd2f..d54a2b66 100644 --- a/tests/team.test.js +++ b/tests/team.test.js @@ -86,32 +86,38 @@ describe('Insertion tests', () => { }); test('TEAM_SUITE - Should NOT create a new Team - Domain not found', async () => { - await request(app) + const response = await request(app) .post('/team/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ name: 'My Team', domain: new mongoose.Types.ObjectId() }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT create a new Team - Invalid domain Id', async () => { - await request(app) + const response = await request(app) .post('/team/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ name: 'My Team', domain: 'INVALID_ID' }).expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT create a new Team - Name is missing', async () => { - await request(app) + const response = await request(app) .post('/team/create') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ domain: domainId }).expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -142,10 +148,12 @@ describe('Reading tests', () => { }); test('TEAM_SUITE - Should NOT read all Teams from a Domain - Invalid domain Id', async () => { - await request(app) + const response = await request(app) .get('/team?domain=INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should read one single Team', async () => { @@ -158,24 +166,30 @@ describe('Reading tests', () => { }); test('TEAM_SUITE - Should NOT read Team - Not found', async () => { - await request(app) + const response = await request(app) .get(`/team/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT read Team - Invalid Id', async () => { - await request(app) + const response = await request(app) .get('/team/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT read Team - Domain Id not provided', async () => { - await request(app) + const response = await request(app) .get('/team') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -196,30 +210,36 @@ describe('Updating tests', () => { }); test('TEAM_SUITE - Should NOT update a Team - Invalid field', async () => { - await request(app) + const response = await request(app) .patch(`/team/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ domain: new mongoose.Types.ObjectId() }).expect(400); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT update a Team - Not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ active: true }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT update a Team - Invalid id', async () => { - await request(app) + const response = await request(app) .patch('/team/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ active: true }).expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -262,17 +282,21 @@ describe('Deletion tests', () => { }); test('TEAM_SUITE - Should NOT delete a Team - Not found', async () => { - await request(app) + const response = await request(app) .delete(`/team/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT delete a Team - Invalid Id', async () => { - await request(app) + const response = await request(app) .delete('/team/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); }); @@ -336,28 +360,32 @@ describe('Updating team members tests', () => { }); test('TEAM_SUITE - Should NOT create invite request - Invalid Team ID', async () => { - await request(app) + const response = await request(app) .post('/team/member/invite/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ email: adminMasterAccount.email }).expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT get invitation request - Invalid Request ID', async () => { - await request(app) + const responseInvalidId = await request(app) .get('/team/member/invite/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ email: adminMasterAccount.email }).expect(422); + expect(responseInvalidId.body).toBeDefined(); - await request(app) + const responseNotFound = await request(app) .get(`/team/member/invite/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ email: adminMasterAccount.email }).expect(404); + expect(responseNotFound.body).toBeDefined(); }); test('TEAM_SUITE - Should get all invitation requests from a team', async () => { @@ -378,22 +406,26 @@ describe('Updating team members tests', () => { }); test('TEAM_SUITE - Should NOT get invitation requests - NO TEAM ID', async () => { - await request(app) + const response = await request(app) .get('/team/member/invite/pending') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove team invitaion - TEAM INVITE REQUEST NOT FOUND', async () => { - await request(app) + const response = await request(app) .get(`/team/member/invite/pending/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(200); + expect(response.body).toBeDefined(); - await request(app) + const responseRemove = await request(app) .delete(`/team/member/invite/remove/${team1Id}/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(404); + expect(responseRemove.body).toBeDefined(); }); test('TEAM_SUITE - Should remove team invitaion', async () => { @@ -427,116 +459,138 @@ describe('Updating team members tests', () => { }); test('TEAM_SUITE - Should NOT add a team member - Team not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/add/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: adminAccountId }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT add a team member - Member not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/add/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: new mongoose.Types.ObjectId() }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT add a team member - Member not given', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/add/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT add a team member - Member already joined', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/add/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: adminAccountId }).expect(400); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT add a team member - Invalid parameter', async () => { // Test - invalid parameter key - await request(app) + const responseInvalidKey = await request(app) .patch(`/team/member/add/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ admin: adminAccountId }).expect(422); + expect(responseInvalidKey.body).toBeDefined(); // Test - invalid parameter value - await request(app) + const responseInvalidValue = await request(app) .patch(`/team/member/add/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: 'INVALID_ID' }).expect(422); + expect(responseInvalidValue.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a team member - Team not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/remove/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: adminAccountId }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a team member - Member not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: new mongoose.Types.ObjectId() }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a team member - Member do not belong to the team', async () => { // Remove member - await request(app) + let response = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: adminMasterAccountId }).expect(200); + + expect(response.body).toBeDefined(); // Trying to remove again - await request(app) + response = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: adminMasterAccountId }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a team member - Member not given', async () => { - await request(app) + const response = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send().expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a team member - Invalid parameter', async () => { // Test - invalid parameter key - await request(app) + const responseInvalidKey = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ admin: adminAccountId }).expect(422); + expect(responseInvalidKey.body).toBeDefined(); // Test - invalid parameter value - await request(app) + const responseInvalidValue = await request(app) .patch(`/team/member/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: 'INVALID_ID' }).expect(422); + expect(responseInvalidValue.body).toBeDefined(); }); test('TEAM_SUITE - Should remove a team member', async () => { @@ -650,57 +704,67 @@ describe('Updating team permissions tests', () => { beforeAll(setupDatabase); test('TEAM_SUITE - Should NOT remove a permission - Team not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/permission/remove/${new mongoose.Types.ObjectId()}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ permission: permission1Id }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a permission - Invalid Team Id', async () => { - await request(app) + const response = await request(app) .patch('/team/permission/remove/INVALID_ID') .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ permission: permission1Id }).expect(422); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a permission - Invalid parameter', async () => { // Test - invalid parameter key - await request(app) + const responseInvalidKey = await request(app) .patch(`/team/permission/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ member: permission1Id }).expect(422); + expect(responseInvalidKey.body).toBeDefined(); // Test - invalid parameter value - await request(app) + const responseInvalidValue = await request(app) .patch(`/team/permission/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ permission: 'INVALID_ID' }).expect(422); + expect(responseInvalidValue.body).toBeDefined(); }); test('TEAM_SUITE - Should NOT remove a permission - Permission not found', async () => { - await request(app) + const response = await request(app) .patch(`/team/permission/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ permission: new mongoose.Types.ObjectId() }).expect(404); + + expect(response.body).toBeDefined(); }); test('TEAM_SUITE - Should remove a permission', async () => { - await request(app) + const response = await request(app) .patch(`/team/permission/remove/${team1Id}`) .set('Authorization', `Bearer ${adminMasterAccountToken}`) .send({ permission: permission1Id }).expect(200); + + expect(response.body).toBeDefined(); }); }); \ No newline at end of file diff --git a/tests/unit-test/verify-ownership.test.js b/tests/unit-test/verify-ownership.test.js index eea39c2a..cbb250e8 100644 --- a/tests/unit-test/verify-ownership.test.js +++ b/tests/unit-test/verify-ownership.test.js @@ -329,7 +329,7 @@ describe('Error tests', () => { test('UNIT_TEAM_PERMISSION_SUITE - Should NOT allow access - Permission innactive', async () => { await changePermissionStatus(permission2Id, false); - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, groupConfig2Document, @@ -340,7 +340,7 @@ describe('Error tests', () => { }); test('UNIT_TEAM_PERMISSION_SUITE - Should NOT allow access - Permission not found', async () => { - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, domainDocument, @@ -351,7 +351,7 @@ describe('Error tests', () => { }); test('UNIT_TEAM_PERMISSION_SUITE - Should NOT allow access - Permission does not match', async () => { - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, configDocument, @@ -362,7 +362,7 @@ describe('Error tests', () => { }); test('UNIT_TEAM_PERMISSION_SUITE - Should NOT allow access - Member does not belong to a team', async () => { - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount2, domainDocument, @@ -375,7 +375,7 @@ describe('Error tests', () => { test('UNIT_TEAM_PERMISSION_SUITE - Should NOT allow access - Team not active', async () => { await changeTeamStatus(team1Id, false); - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, groupConfig2Document, @@ -396,7 +396,7 @@ describe('Error tests', () => { let groups = await GroupConfig.find({ domain: domainId }).exec(); expect(groups.length).toEqual(2); - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, groups, @@ -411,7 +411,7 @@ describe('Error tests', () => { //enabled Update - Switcher (update only in dev environment) await changePermissionStatus(permission11Id, true); - expect(async () => { + await expect(async () => { await verifyOwnership( adminAccount, configDocument,