krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-16 06:07:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix test lint

Browse Source
This commit is contained in:
Matteo Pagliazzi
2019-10-08 20:45:38 +02:00
parent e37f4467f8
commit 85fb5f33aa
367 changed files with 6635 additions and 6080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
test/api/v3/integration/challenges/DELETE-challenges_challengeId.test.js
View File

@@ -1,3 +1,4 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateChallenge,
@@ -6,11 +7,10 @@ import {
checkExistence,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /challenges/:challengeId', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.del('/challenges/test')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -19,7 +19,7 @@ describe('DELETE /challenges/:challengeId', () => {
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.del(`/challenges/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -32,10 +32,10 @@ describe('DELETE /challenges/:challengeId', () => {
let groupLeader;
let group;
let challenge;
let taskText = 'A challenge task text';
const taskText = 'A challenge task text';
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup();
const populatedGroup = await createAndPopulateGroup();
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
@@ -44,14 +44,14 @@ describe('DELETE /challenges/:challengeId', () => {
await groupLeader.post(`/challenges/${challenge._id}/join`);
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
{ type: 'habit', text: taskText },
]);
await challenge.sync();
});
it('returns an error when user doesn\'t have permissions to delete the challenge', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.del(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -69,7 +69,7 @@ describe('DELETE /challenges/:challengeId', () => {
});
it('refunds gems to group leader', async () => {
let oldBalance = (await groupLeader.sync()).balance;
const oldBalance = (await groupLeader.sync()).balance;
await groupLeader.del(`/challenges/${challenge._id}`);
@@ -83,10 +83,8 @@ describe('DELETE /challenges/:challengeId', () => {
await sleep(0.5);
let tasks = await groupLeader.get('/tasks/user');
let testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
const tasks = await groupLeader.get('/tasks/user');
const testTask = _.find(tasks, task => task.text === taskText);
expect(testTask.challenge.broken).to.eql('CHALLENGE_DELETED');
expect(testTask.challenge.winner).to.be.null;

44
test/api/v3/integration/challenges/GET-challenges_challengeId.test.js
View File

@@ -1,14 +1,14 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
createAndPopulateGroup,
generateChallenge,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId', () => {
it('fails if challenge doesn\'t exists', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.get(`/challenges/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -25,8 +25,8 @@ describe('GET /challenges/:challengeId', () => {
beforeEach(async () => {
user = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'guild', privacy: 'public'},
const populatedGroup = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'public' },
});
groupLeader = populatedGroup.groupLeader;
@@ -38,7 +38,7 @@ describe('GET /challenges/:challengeId', () => {
it('should return challenge data', async () => {
await challenge.sync();
let chal = await user.get(`/challenges/${challenge._id}`);
const chal = await user.get(`/challenges/${challenge._id}`);
expect(chal.memberCount).to.equal(challenge.memberCount);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
@@ -46,7 +46,7 @@ describe('GET /challenges/:challengeId', () => {
expect(chal.leader).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
profile: { name: groupLeader.profile.name },
auth: {
local: {
username: groupLeader.auth.local.username,
@@ -81,8 +81,8 @@ describe('GET /challenges/:challengeId', () => {
beforeEach(async () => {
nonMember = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'guild', privacy: 'private'},
const populatedGroup = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
members: 2,
});
@@ -90,8 +90,8 @@ describe('GET /challenges/:challengeId', () => {
group = populatedGroup.group;
members = populatedGroup.members;
challengeLeader = members[0];
otherMember = members[1];
challengeLeader = members[0]; // eslint-disable-line prefer-destructuring
otherMember = members[1]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(challengeLeader, group);
});
@@ -105,14 +105,14 @@ describe('GET /challenges/:challengeId', () => {
});
it('returns challenge data for any user in the guild', async () => {
let chal = await otherMember.get(`/challenges/${challenge._id}`);
const chal = await otherMember.get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: challengeLeader._id,
id: challengeLeader._id,
profile: {name: challengeLeader.profile.name},
profile: { name: challengeLeader.profile.name },
auth: {
local: {
username: challengeLeader.auth.local.username,
@@ -139,14 +139,14 @@ describe('GET /challenges/:challengeId', () => {
await challengeLeader.sync();
expect(challengeLeader.guilds).to.be.empty; // check that leaving worked
let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
const chal = await challengeLeader.get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: challengeLeader._id,
id: challengeLeader._id,
profile: {name: challengeLeader.profile.name},
profile: { name: challengeLeader.profile.name },
auth: {
local: {
username: challengeLeader.auth.local.username,
@@ -171,8 +171,8 @@ describe('GET /challenges/:challengeId', () => {
beforeEach(async () => {
nonMember = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'party', privacy: 'private'},
const populatedGroup = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -180,8 +180,8 @@ describe('GET /challenges/:challengeId', () => {
group = populatedGroup.group;
members = populatedGroup.members;
challengeLeader = members[0];
otherMember = members[1];
challengeLeader = members[0]; // eslint-disable-line prefer-destructuring
otherMember = members[1]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(challengeLeader, group);
});
@@ -195,14 +195,14 @@ describe('GET /challenges/:challengeId', () => {
});
it('returns challenge data for any user in the party', async () => {
let chal = await otherMember.get(`/challenges/${challenge._id}`);
const chal = await otherMember.get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: challengeLeader._id,
id: challengeLeader._id,
profile: {name: challengeLeader.profile.name},
profile: { name: challengeLeader.profile.name },
auth: {
local: {
username: challengeLeader.auth.local.username,
@@ -229,14 +229,14 @@ describe('GET /challenges/:challengeId', () => {
await challengeLeader.sync();
expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
let chal = await challengeLeader.get(`/challenges/${challenge._id}`);
const chal = await challengeLeader.get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: challengeLeader._id,
id: challengeLeader._id,
profile: {name: challengeLeader.profile.name},
profile: { name: challengeLeader.profile.name },
auth: {
local: {
username: challengeLeader.auth.local.username,

10
test/api/v3/integration/challenges/GET-challenges_challengeId_export_csv.test.js
View File

@@ -1,3 +1,4 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
createAndPopulateGroup,
@@ -5,7 +6,6 @@ import {
translate as t,
sleep,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/export/csv', () => {
let groupLeader;
@@ -15,7 +15,7 @@ describe('GET /challenges/:challengeId/export/csv', () => {
let user;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 3,
});
@@ -30,8 +30,8 @@ describe('GET /challenges/:challengeId/export/csv', () => {
await members[2].post(`/challenges/${challenge._id}/join`);
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: 'Task 1'},
{type: 'todo', text: 'Task 2'},
{ type: 'habit', text: 'Task 1' },
{ type: 'todo', text: 'Task 2' },
]);
await sleep(0.5); // Make sure tasks are synced to the users
await members[0].sync();
@@ -74,7 +74,7 @@ describe('GET /challenges/:challengeId/export/csv', () => {
});
it('should successfully return when it contains erroneous residue user data', async () => {
await members[0].update({challenges: []});
await members[0].update({ challenges: [] });
const res = await members[1].get(`/challenges/${challenge._id}/export/csv`);
const sortedMembers = _.sortBy([members[1], members[2], groupLeader], '_id');
const splitRes = res.split('\n');

119
test/api/v3/integration/challenges/GET-challenges_challengeId_members.test.js
View File

@@ -1,3 +1,4 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateGroup,
@@ -5,7 +6,6 @@ import {
generateChallenge,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/members', () => {
let user;
@@ -31,9 +31,9 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('fails if user isn\'t in the private group and isn\'t challenge leader', async () => {
let group = await generateGroup(user, {type: 'party', privacy: 'private'});
let challenge = await generateChallenge(user, group);
let anotherUser = await generateUser();
const group = await generateGroup(user, { type: 'party', privacy: 'private' });
const challenge = await generateChallenge(user, group);
const anotherUser = await generateUser();
await expect(anotherUser.get(`/challenges/${challenge._id}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -43,23 +43,23 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('works if user isn\'t in the private group but is challenge leader', async () => {
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'party', privacy: 'private'},
const populatedGroup = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 1,
});
let groupLeader = populatedGroup.groupLeader;
let challengeLeader = populatedGroup.members[0];
let challenge = await generateChallenge(challengeLeader, populatedGroup.group);
const { groupLeader } = populatedGroup;
const challengeLeader = populatedGroup.members[0];
const challenge = await generateChallenge(challengeLeader, populatedGroup.group);
await groupLeader.post(`/challenges/${challenge._id}/join`);
await challengeLeader.post('/groups/party/leave');
await challengeLeader.sync();
expect(challengeLeader.party._id).to.be.undefined; // check that leaving worked
let res = await challengeLeader.get(`/challenges/${challenge._id}/members`);
const res = await challengeLeader.get(`/challenges/${challenge._id}/members`);
expect(res[0]).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
profile: { name: groupLeader.profile.name },
auth: {
local: {
username: groupLeader.auth.local.username,
@@ -72,15 +72,15 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('works with challenges belonging to public guild', async () => {
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(leader, group);
const leader = await generateUser({ balance: 4 });
const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
const challenge = await generateChallenge(leader, group);
await leader.post(`/challenges/${challenge._id}/join`);
let res = await user.get(`/challenges/${challenge._id}/members`);
const res = await user.get(`/challenges/${challenge._id}/members`);
expect(res[0]).to.eql({
_id: leader._id,
id: leader._id,
profile: {name: leader.profile.name},
profile: { name: leader.profile.name },
auth: {
local: {
username: leader.auth.local.username,
@@ -95,15 +95,15 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('populates only some fields', async () => {
let anotherUser = await generateUser({balance: 3});
let group = await generateGroup(anotherUser, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(anotherUser, group);
const anotherUser = await generateUser({ balance: 3 });
const group = await generateGroup(anotherUser, { type: 'guild', privacy: 'public', name: generateUUID() });
const challenge = await generateChallenge(anotherUser, group);
await anotherUser.post(`/challenges/${challenge._id}/join`);
let res = await user.get(`/challenges/${challenge._id}/members`);
const res = await user.get(`/challenges/${challenge._id}/members`);
expect(res[0]).to.eql({
_id: anotherUser._id,
id: anotherUser._id,
profile: {name: anotherUser.profile.name},
profile: { name: anotherUser.profile.name },
auth: {
local: {
username: anotherUser.auth.local.username,
@@ -118,17 +118,17 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('returns only first 30 members if req.query.includeAllMembers is not true', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
const usersToGenerate = [];
for (let i = 0; i < 31; i += 1) {
usersToGenerate.push(generateUser({ challenges: [challenge._id] }));
}
await Promise.all(usersToGenerate);
let res = await user.get(`/challenges/${challenge._id}/members?includeAllMembers=not-true`);
const res = await user.get(`/challenges/${challenge._id}/members?includeAllMembers=not-true`);
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -137,17 +137,17 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('returns only first 30 members if req.query.includeAllMembers is not defined', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
const usersToGenerate = [];
for (let i = 0; i < 31; i += 1) {
usersToGenerate.push(generateUser({ challenges: [challenge._id] }));
}
await Promise.all(usersToGenerate);
let res = await user.get(`/challenges/${challenge._id}/members`);
const res = await user.get(`/challenges/${challenge._id}/members`);
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -156,17 +156,17 @@ describe('GET /challenges/:challengeId/members', () => {
});
it('returns all members if req.query.includeAllMembers is true', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
const usersToGenerate = [];
for (let i = 0; i < 31; i += 1) {
usersToGenerate.push(generateUser({ challenges: [challenge._id] }));
}
await Promise.all(usersToGenerate);
let res = await user.get(`/challenges/${challenge._id}/members?includeAllMembers=true`);
const res = await user.get(`/challenges/${challenge._id}/members?includeAllMembers=true`);
expect(res.length).to.equal(32);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -174,47 +174,48 @@ describe('GET /challenges/:challengeId/members', () => {
});
});
it('supports using req.query.lastId to get more members', async function () {
it('supports using req.query.lastId to get more members', async function test () {
this.timeout(30000); // @TODO: times out after 8 seconds
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let usersToGenerate = [];
for (let i = 0; i < 57; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
const usersToGenerate = [];
for (let i = 0; i < 57; i += 1) {
usersToGenerate.push(generateUser({ challenges: [challenge._id] }));
}
let generatedUsers = await Promise.all(usersToGenerate); // Group has 59 members (1 is the leader)
let expectedIds = [user._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
// Group has 59 members (1 is the leader)
const generatedUsers = await Promise.all(usersToGenerate);
const expectedIds = [user._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
let res = await user.get(`/challenges/${challenge._id}/members`);
const res = await user.get(`/challenges/${challenge._id}/members`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/challenges/${challenge._id}/members?lastId=${res[res.length - 1]._id}`);
const res2 = await user.get(`/challenges/${challenge._id}/members?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(28);
let resIds = res.concat(res2).map(member => member._id);
const resIds = res.concat(res2).map(member => member._id);
expect(resIds).to.eql(expectedIds.sort());
});
it('supports using req.query.search to get search members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let usersToGenerate = [];
for (let i = 0; i < 3; i++) {
const usersToGenerate = [];
for (let i = 0; i < 3; i += 1) {
usersToGenerate.push(generateUser({
challenges: [challenge._id],
'profile.name': `${i}profilename`,
}));
}
let generatedUsers = await Promise.all(usersToGenerate);
let profileNames = generatedUsers.map(generatedUser => generatedUser.profile.name);
const generatedUsers = await Promise.all(usersToGenerate);
const profileNames = generatedUsers.map(generatedUser => generatedUser.profile.name);
let firstProfileName = profileNames[0];
let nameToSearch = firstProfileName.substring(0, 4);
const firstProfileName = profileNames[0];
const nameToSearch = firstProfileName.substring(0, 4);
let response = await user.get(`/challenges/${challenge._id}/members?search=${nameToSearch}`);
const response = await user.get(`/challenges/${challenge._id}/members?search=${nameToSearch}`);
expect(response[0].profile.name).to.eql(firstProfileName);
});
});

52
test/api/v3/integration/challenges/GET-challenges_challengeId_members_memberId.test.js
View File

@@ -1,10 +1,10 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateChallenge,
generateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/members/:memberId', () => {
let user;
@@ -30,16 +30,16 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
});
it('fails if member doesn\'t exists', async () => {
let userId = generateUUID();
const userId = generateUUID();
await expect(user.get(`/challenges/${generateUUID()}/members/${userId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId}),
message: t('userWithIDNotFound', { userId }),
});
});
it('fails if challenge doesn\'t exists', async () => {
let member = await generateUser();
const member = await generateUser();
await expect(user.get(`/challenges/${generateUUID()}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -48,11 +48,11 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
});
it('fails if user doesn\'t have access to the challenge', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let anotherUser = await generateUser();
let member = await generateUser();
const anotherUser = await generateUser();
const member = await generateUser();
await expect(anotherUser.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -61,10 +61,10 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
});
it('fails if member is not part of the challenge', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let member = await generateUser();
const member = await generateUser();
await expect(user.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -73,37 +73,37 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
});
it('works with challenges belonging to a public guild', async () => {
let groupLeader = await generateUser({balance: 4});
let group = await generateGroup(groupLeader, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(groupLeader, group);
const groupLeader = await generateUser({ balance: 4 });
const group = await generateGroup(groupLeader, { type: 'guild', privacy: 'public', name: generateUUID() });
const challenge = await generateChallenge(groupLeader, group);
await groupLeader.post(`/challenges/${challenge._id}/join`);
let taskText = 'Test Text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: taskText}]);
const taskText = 'Test Text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{ type: 'habit', text: taskText }]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${groupLeader._id}`);
const memberProgress = await user.get(`/challenges/${challenge._id}/members/${groupLeader._id}`);
expect(memberProgress).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile', 'tasks']);
expect(memberProgress.profile).to.have.all.keys(['name']);
expect(memberProgress.tasks.length).to.equal(1);
});
it('returns the member tasks for the challenges', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
await user.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: 'Test Text'}]);
await user.post(`/tasks/challenge/${challenge._id}`, [{ type: 'habit', text: 'Test Text' }]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
let chalTasks = await user.get(`/tasks/challenge/${challenge._id}`);
const memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
const chalTasks = await user.get(`/tasks/challenge/${challenge._id}`);
expect(memberProgress.tasks.length).to.equal(chalTasks.length);
expect(memberProgress.tasks[0].challenge.id).to.equal(challenge._id);
expect(memberProgress.tasks[0].challenge.taskId).to.equal(chalTasks[0]._id);
});
it('returns the tasks without the tags and checklist', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
let taskText = 'Test Text';
const taskText = 'Test Text';
await user.post(`/tasks/challenge/${challenge._id}`, [{
type: 'todo',
text: taskText,
@@ -115,7 +115,7 @@ describe('GET /challenges/:challengeId/members/:memberId', () => {
],
}]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
const memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
expect(memberProgress.tasks[0]).not.to.have.key('tags');
expect(memberProgress.tasks[0].checklist).to.eql([]);
});

107
test/api/v3/integration/challenges/GET-challenges_group_groupid.test.js
View File

@@ -8,10 +8,11 @@ import { TAVERN_ID } from '../../../../../website/common/script/constants';
describe('GET challenges/groups/:groupId', () => {
context('Public Guild', () => {
let publicGuild, user, nonMember, challenge, challenge2;
let publicGuild; let user; let nonMember; let challenge; let
challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
@@ -31,14 +32,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return group challenges for non member with populated leader', async () => {
let challenges = await nonMember.get(`/challenges/groups/${publicGuild._id}`);
const challenges = await nonMember.get(`/challenges/groups/${publicGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -48,12 +49,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -66,14 +67,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return group challenges for member with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
const challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -83,12 +84,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -106,7 +107,7 @@ describe('GET challenges/groups/:groupId', () => {
let foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
expect(foundChallengeIndex).to.eql(0);
let newChallenge = await generateChallenge(user, publicGuild);
const newChallenge = await generateChallenge(user, publicGuild);
await user.post(`/challenges/${newChallenge._id}/join`);
challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
@@ -117,10 +118,11 @@ describe('GET challenges/groups/:groupId', () => {
});
context('Private Guild', () => {
let privateGuild, user, nonMember, challenge, challenge2;
let privateGuild; let user; let nonMember; let challenge; let
challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
type: 'guild',
@@ -149,14 +151,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return group challenges for member with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${privateGuild._id}`);
const challenges = await user.get(`/challenges/groups/${privateGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: privateGuild.leader._id,
id: privateGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -166,12 +168,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: privateGuild.leader._id,
id: privateGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -185,10 +187,11 @@ describe('GET challenges/groups/:groupId', () => {
});
context('official challenge is present', () => {
let publicGuild, user, officialChallenge, challenge, challenge2;
let publicGuild; let user; let officialChallenge; let challenge; let
challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
@@ -218,9 +221,9 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return official challenges first', async () => {
let challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
const challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
let foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
const foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
expect(foundChallengeIndex).to.eql(0);
});
@@ -233,7 +236,7 @@ describe('GET challenges/groups/:groupId', () => {
foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
expect(foundChallengeIndex).to.eql(1);
let newChallenge = await generateChallenge(user, publicGuild);
const newChallenge = await generateChallenge(user, publicGuild);
await user.post(`/challenges/${newChallenge._id}/join`);
challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
@@ -244,10 +247,11 @@ describe('GET challenges/groups/:groupId', () => {
});
context('Party', () => {
let party, user, nonMember, challenge, challenge2;
let party; let user; let nonMember; let challenge; let
challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestParty',
type: 'party',
@@ -275,14 +279,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return group challenges for member with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${party._id}`);
const challenges = await user.get(`/challenges/groups/${party._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: party.leader._id,
id: party.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -292,12 +296,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: party.leader._id,
id: party.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -310,14 +314,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return group challenges for member using ID "party"', async () => {
let challenges = await user.get('/challenges/groups/party');
const challenges = await user.get('/challenges/groups/party');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: party.leader._id,
id: party.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -327,12 +331,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: party.leader._id,
id: party.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -346,28 +350,29 @@ describe('GET challenges/groups/:groupId', () => {
});
context('Tavern', () => {
let tavern, user, challenge, challenge2;
let tavern; let user; let challenge; let
challenge2;
before(async () => {
user = await generateUser();
await user.update({balance: 0.5});
await user.update({ balance: 0.5 });
tavern = await user.get(`/groups/${TAVERN_ID}`);
challenge = await generateChallenge(user, tavern, {prize: 1});
challenge = await generateChallenge(user, tavern, { prize: 1 });
await user.post(`/challenges/${challenge._id}/join`);
challenge2 = await generateChallenge(user, tavern, {prize: 1});
challenge2 = await generateChallenge(user, tavern, { prize: 1 });
await user.post(`/challenges/${challenge2._id}/join`);
});
it('should return tavern challenges with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${TAVERN_ID}`);
const challenges = await user.get(`/challenges/groups/${TAVERN_ID}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -377,12 +382,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -395,14 +400,14 @@ describe('GET challenges/groups/:groupId', () => {
});
it('should return tavern challenges using ID "habitrpg', async () => {
let challenges = await user.get('/challenges/groups/habitrpg');
const challenges = await user.get('/challenges/groups/habitrpg');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -412,12 +417,12 @@ describe('GET challenges/groups/:groupId', () => {
verifiedUsername: true,
},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,

87
test/api/v3/integration/challenges/GET-challenges_user.test.js
View File

@@ -6,10 +6,11 @@ import {
describe('GET challenges/user', () => {
context('no official challenges', () => {
let user, member, nonMember, challenge, challenge2, publicGuild;
let user; let member; let nonMember; let challenge; let challenge2; let
publicGuild;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
@@ -20,7 +21,7 @@ describe('GET challenges/user', () => {
user = groupLeader;
publicGuild = group;
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
nonMember = await generateUser();
challenge = await generateChallenge(user, group);
@@ -32,14 +33,14 @@ describe('GET challenges/user', () => {
it('should return challenges user has joined', async () => {
await nonMember.post(`/challenges/${challenge._id}/join`);
let challenges = await nonMember.get('/challenges/user');
const challenges = await nonMember.get('/challenges/user');
let foundChallenge = _.find(challenges, { _id: challenge._id });
const foundChallenge = _.find(challenges, { _id: challenge._id });
expect(foundChallenge).to.exist;
expect(foundChallenge.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -62,14 +63,14 @@ describe('GET challenges/user', () => {
});
it('should return challenges user has created', async () => {
let challenges = await user.get('/challenges/user');
const challenges = await user.get('/challenges/user');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -89,12 +90,12 @@ describe('GET challenges/user', () => {
summary: publicGuild.name,
leader: publicGuild.leader._id,
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -117,14 +118,14 @@ describe('GET challenges/user', () => {
});
it('should return challenges in user\'s group', async () => {
let challenges = await member.get('/challenges/user');
const challenges = await member.get('/challenges/user');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -144,12 +145,12 @@ describe('GET challenges/user', () => {
summary: publicGuild.name,
leader: publicGuild.leader._id,
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -172,12 +173,12 @@ describe('GET challenges/user', () => {
});
it('should not return challenges in user groups if we send member true param', async () => {
let challenges = await member.get(`/challenges/user?member=${true}`);
const challenges = await member.get(`/challenges/user?member=${true}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
const foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.not.exist;
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.not.exist;
});
@@ -187,7 +188,7 @@ describe('GET challenges/user', () => {
let foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
expect(foundChallengeIndex).to.eql(0);
let newChallenge = await generateChallenge(user, publicGuild);
const newChallenge = await generateChallenge(user, publicGuild);
await user.post(`/challenges/${newChallenge._id}/join`);
challenges = await user.get('/challenges/user');
@@ -197,7 +198,7 @@ describe('GET challenges/user', () => {
});
it('should not return challenges user doesn\'t have access to', async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
summary: 'summary for TestPrivateGuild',
@@ -206,17 +207,17 @@ describe('GET challenges/user', () => {
},
});
let privateChallenge = await generateChallenge(groupLeader, group);
const privateChallenge = await generateChallenge(groupLeader, group);
await groupLeader.post(`/challenges/${privateChallenge._id}/join`);
let challenges = await nonMember.get('/challenges/user');
const challenges = await nonMember.get('/challenges/user');
let foundChallenge = _.find(challenges, { _id: privateChallenge._id });
const foundChallenge = _.find(challenges, { _id: privateChallenge._id });
expect(foundChallenge).to.not.exist;
});
it('should not return challenges user doesn\'t have access to, even with query parameters', async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
summary: 'summary for TestPrivateGuild',
@@ -225,24 +226,27 @@ describe('GET challenges/user', () => {
},
});
let privateChallenge = await generateChallenge(groupLeader, group, {categories: [{
name: 'academics',
slug: 'academics',
}]});
const privateChallenge = await generateChallenge(groupLeader, group, {
categories: [{
name: 'academics',
slug: 'academics',
}],
});
await groupLeader.post(`/challenges/${privateChallenge._id}/join`);
let challenges = await nonMember.get('/challenges/user?categories=academics&owned=not_owned');
const challenges = await nonMember.get('/challenges/user?categories=academics&owned=not_owned');
let foundChallenge = _.find(challenges, { _id: privateChallenge._id });
const foundChallenge = _.find(challenges, { _id: privateChallenge._id });
expect(foundChallenge).to.not.exist;
});
});
context('official challenge is present', () => {
let user, officialChallenge, challenge, challenge2, publicGuild;
let user; let officialChallenge; let challenge; let challenge2; let
publicGuild;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
summary: 'summary for TestGuild',
@@ -273,9 +277,9 @@ describe('GET challenges/user', () => {
});
it('should return official challenges first', async () => {
let challenges = await user.get('/challenges/user');
const challenges = await user.get('/challenges/user');
let foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
const foundChallengeIndex = _.findIndex(challenges, { _id: officialChallenge._id });
expect(foundChallengeIndex).to.eql(0);
});
@@ -288,7 +292,7 @@ describe('GET challenges/user', () => {
foundChallengeIndex = _.findIndex(challenges, { _id: challenge2._id });
expect(foundChallengeIndex).to.eql(1);
let newChallenge = await generateChallenge(user, publicGuild);
const newChallenge = await generateChallenge(user, publicGuild);
await user.post(`/challenges/${newChallenge._id}/join`);
challenges = await user.get('/challenges/user');
@@ -299,14 +303,15 @@ describe('GET challenges/user', () => {
});
context('filters and paging', () => {
let user, guild, member;
let user; let guild; let
member;
const categories = [{
slug: 'newCat',
name: 'New Category',
}];
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
@@ -317,9 +322,9 @@ describe('GET challenges/user', () => {
user = groupLeader;
guild = group;
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
await user.update({balance: 20});
await user.update({ balance: 20 });
for (let i = 0; i < 11; i += 1) {
let challenge = await generateChallenge(user, group); // eslint-disable-line
@@ -328,7 +333,7 @@ describe('GET challenges/user', () => {
});
it('returns public guilds filtered by category', async () => {
const categoryChallenge = await generateChallenge(user, guild, {categories});
const categoryChallenge = await generateChallenge(user, guild, { categories });
await user.post(`/challenges/${categoryChallenge._id}/join`);
const challenges = await user.get(`/challenges/user?categories=${categories[0].slug}`);

70
test/api/v3/integration/challenges/POST-challenges.test.js
View File

@@ -1,13 +1,13 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges', () => {
it('returns error when group is empty', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post('/challenges')).to.eventually.be.rejected.and.eql({
code: 400,
@@ -17,7 +17,7 @@ describe('POST /challenges', () => {
});
it('returns error when groupId is not for a valid group', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post('/challenges', {
group: generateUUID(),
@@ -29,7 +29,7 @@ describe('POST /challenges', () => {
});
it('returns error when creating a challenge in the tavern with no prize', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post('/challenges', {
group: 'habitrpg',
@@ -42,8 +42,8 @@ describe('POST /challenges', () => {
});
it('returns error when creating a challenge in a public guild and you are not a member of it', async () => {
let user = await generateUser();
let { group } = await createAndPopulateGroup({
const user = await generateUser();
const { group } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -66,7 +66,7 @@ describe('POST /challenges', () => {
let groupMember;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 1,
leaderDetails: {
balance: 3,
@@ -81,7 +81,7 @@ describe('POST /challenges', () => {
groupLeader = await populatedGroup.groupLeader.sync();
group = populatedGroup.group;
groupMember = populatedGroup.members[0];
groupMember = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
});
it('returns an error when non-leader member creates a challenge in leaderOnly group', async () => {
@@ -95,14 +95,14 @@ describe('POST /challenges', () => {
});
it('allows non-leader member to create a challenge', async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 1,
});
group = populatedGroup.group;
groupMember = populatedGroup.members[0];
groupMember = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
let chal = await groupMember.post('/challenges', {
const chal = await groupMember.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
@@ -110,13 +110,13 @@ describe('POST /challenges', () => {
expect(chal.leader).to.eql({
_id: groupMember._id,
profile: {name: groupMember.profile.name},
profile: { name: groupMember.profile.name },
});
});
it('doesn\'t take gems from user or group when challenge has no prize', async () => {
let oldUserBalance = groupLeader.balance;
let oldGroupBalance = group.balance;
const oldUserBalance = groupLeader.balance;
const oldGroupBalance = group.balance;
await groupLeader.post('/challenges', {
group: group._id,
@@ -143,9 +143,9 @@ describe('POST /challenges', () => {
});
it('takes prize out of group if it has sufficient funds', async () => {
let oldUserBalance = groupLeader.balance;
let oldGroupBalance = group.balance;
let prize = 4;
const oldUserBalance = groupLeader.balance;
const oldGroupBalance = group.balance;
const prize = 4;
await groupLeader.post('/challenges', {
group: group._id,
@@ -159,8 +159,8 @@ describe('POST /challenges', () => {
});
it('takes prize out of both group and user if group doesn\'t have enough', async () => {
let oldUserBalance = groupLeader.balance;
let prize = 8;
const oldUserBalance = groupLeader.balance;
const prize = 8;
await groupLeader.post('/challenges', {
group: group._id,
@@ -170,14 +170,14 @@ describe('POST /challenges', () => {
});
await expect(group.sync()).to.eventually.have.property('balance', 0);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance - (prize / 4 - 1));
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance - (prize / 4 - 1));
});
it('takes prize out of user if group has no balance', async () => {
let oldUserBalance = groupLeader.balance;
let prize = 8;
const oldUserBalance = groupLeader.balance;
const prize = 8;
await group.update({ balance: 0});
await group.update({ balance: 0 });
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
@@ -190,7 +190,7 @@ describe('POST /challenges', () => {
});
it('increases challenge count of group', async () => {
let oldChallengeCount = group.challengeCount;
const oldChallengeCount = group.challengeCount;
await groupLeader.post('/challenges', {
group: group._id,
@@ -208,7 +208,7 @@ describe('POST /challenges', () => {
},
});
let challenge = await groupLeader.post('/challenges', {
const challenge = await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
@@ -219,7 +219,7 @@ describe('POST /challenges', () => {
});
it('doesn\'t set challenge as official if official flag is set by non-admin', async () => {
let challenge = await groupLeader.post('/challenges', {
const challenge = await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
@@ -230,9 +230,9 @@ describe('POST /challenges', () => {
});
it('returns an error when challenge validation fails; doesn\'s save user or group', async () => {
let oldChallengeCount = group.challengeCount;
let oldUserBalance = groupLeader.balance;
let oldGroupBalance = group.balance;
const oldChallengeCount = group.challengeCount;
const oldUserBalance = groupLeader.balance;
const oldGroupBalance = group.balance;
await expect(groupLeader.post('/challenges', {
group: group._id,
@@ -252,12 +252,12 @@ describe('POST /challenges', () => {
});
it('sets all properites of the challenge as passed', async () => {
let name = 'Test Challenge';
let shortName = 'TC Label';
let description = 'Test Description';
let prize = 4;
const name = 'Test Challenge';
const shortName = 'TC Label';
const description = 'Test Description';
const prize = 4;
let challenge = await groupLeader.post('/challenges', {
const challenge = await groupLeader.post('/challenges', {
group: group._id,
name,
shortName,
@@ -267,7 +267,7 @@ describe('POST /challenges', () => {
expect(challenge.leader).to.eql({
_id: groupLeader._id,
profile: {name: groupLeader.profile.name},
profile: { name: groupLeader.profile.name },
});
expect(challenge.name).to.eql(name);
expect(challenge.shortName).to.eql(shortName);

28
test/api/v3/integration/challenges/POST-challenges_challengeId_join.test.js
View File

@@ -1,14 +1,14 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/join', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser({ balance: 1});
const user = await generateUser({ balance: 1 });
await expect(user.post('/challenges/test/join')).to.eventually.be.rejected.and.eql({
code: 400,
@@ -18,7 +18,7 @@ describe('POST /challenges/:challengeId/join', () => {
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser({ balance: 1});
const user = await generateUser({ balance: 1 });
await expect(user.post(`/challenges/${generateUUID()}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -34,20 +34,20 @@ describe('POST /challenges/:challengeId/join', () => {
let authorizedUser;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
authorizedUser = populatedGroup.members[0];
authorizedUser = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(groupLeader, group);
await groupLeader.post(`/challenges/${challenge._id}/join`);
});
it('returns an error when user isn\'t in the private group and isn\'t challenge leader', async () => {
let unauthorizedUser = await generateUser();
const unauthorizedUser = await generateUser();
await expect(unauthorizedUser.post(`/challenges/${challenge._id}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -62,12 +62,12 @@ describe('POST /challenges/:challengeId/join', () => {
await groupLeader.sync();
expect(groupLeader.guilds).to.be.empty; // check that leaving worked
let res = await groupLeader.post(`/challenges/${challenge._id}/join`);
const res = await groupLeader.post(`/challenges/${challenge._id}/join`);
expect(res.name).to.equal(challenge.name);
});
it('returns challenge data', async () => {
let res = await authorizedUser.post(`/challenges/${challenge._id}/join`);
const res = await authorizedUser.post(`/challenges/${challenge._id}/join`);
expect(res.group).to.eql({
_id: group._id,
@@ -78,7 +78,7 @@ describe('POST /challenges/:challengeId/join', () => {
expect(res.leader).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
profile: { name: groupLeader.profile.name },
auth: {
local: {
username: groupLeader.auth.local.username,
@@ -111,7 +111,7 @@ describe('POST /challenges/:challengeId/join', () => {
it('increases memberCount of challenge', async () => {
await challenge.sync();
let oldMemberCount = challenge.memberCount;
const oldMemberCount = challenge.memberCount;
await authorizedUser.post(`/challenges/${challenge._id}/join`);
@@ -123,15 +123,13 @@ describe('POST /challenges/:challengeId/join', () => {
it('syncs challenge tasks to joining user', async () => {
const taskText = 'A challenge task text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'daily', text: taskText},
{ type: 'daily', text: taskText },
]);
await authorizedUser.post(`/challenges/${challenge._id}/join`);
const tasks = await authorizedUser.get('/tasks/user');
const syncedTask = tasks.find((task) => {
return task.text === taskText;
});
const syncedTask = tasks.find(task => task.text === taskText);
expect(syncedTask.text).to.eql(taskText);
expect(syncedTask.isDue).to.exist;
@@ -139,7 +137,7 @@ describe('POST /challenges/:challengeId/join', () => {
});
it('adds challenge tag to user tags', async () => {
let userTagsLength = (await authorizedUser.get('/tags')).length;
const userTagsLength = (await authorizedUser.get('/tags')).length;
await authorizedUser.post(`/challenges/${challenge._id}/join`);

30
test/api/v3/integration/challenges/POST-challenges_challengeId_leave.test.js
View File

@@ -1,14 +1,14 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/leave', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post('/challenges/test/leave')).to.eventually.be.rejected.and.eql({
code: 400,
@@ -18,7 +18,7 @@ describe('POST /challenges/:challengeId/leave', () => {
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/leave`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -37,15 +37,15 @@ describe('POST /challenges/:challengeId/leave', () => {
let taskText;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 3,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
leavingUser = populatedGroup.members[0];
notInChallengeUser = populatedGroup.members[1];
notInGroupLeavingUser = populatedGroup.members[2];
leavingUser = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
notInChallengeUser = populatedGroup.members[1]; // eslint-disable-line prefer-destructuring
notInGroupLeavingUser = populatedGroup.members[2]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(groupLeader, group);
await groupLeader.post(`/challenges/${challenge._id}/join`);
@@ -53,7 +53,7 @@ describe('POST /challenges/:challengeId/leave', () => {
taskText = 'A challenge task text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
{ type: 'habit', text: taskText },
]);
await leavingUser.post(`/challenges/${challenge._id}/join`);
@@ -87,7 +87,7 @@ describe('POST /challenges/:challengeId/leave', () => {
});
it('decreases memberCount of challenge', async () => {
let oldMemberCount = challenge.memberCount;
const oldMemberCount = challenge.memberCount;
await leavingUser.post(`/challenges/${challenge._id}/leave`);
@@ -100,10 +100,8 @@ describe('POST /challenges/:challengeId/leave', () => {
await leavingUser.post(`/challenges/${challenge._id}/leave`, {
keep: 'remove-all',
});
let tasks = await leavingUser.get('/tasks/user');
let tasksTexts = tasks.map((task) => {
return task.text;
});
const tasks = await leavingUser.get('/tasks/user');
const tasksTexts = tasks.map(task => task.text);
expect(tasksTexts).to.not.include(taskText);
});
@@ -113,10 +111,8 @@ describe('POST /challenges/:challengeId/leave', () => {
keep: 'test',
});
let tasks = await leavingUser.get('/tasks/user');
let testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
const tasks = await leavingUser.get('/tasks/user');
const testTask = _.find(tasks, task => task.text === taskText);
expect(testTask).to.not.be.undefined;
});

39
test/api/v3/integration/challenges/POST-challenges_challengeId_winner_winnerId.test.js
View File

@@ -1,3 +1,4 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateChallenge,
@@ -6,11 +7,10 @@ import {
checkExistence,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/winner/:winnerId', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post(`/challenges/test/selectWinner/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 400,
@@ -20,7 +20,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
});
it('returns error when winnerId is not a valid UUID', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/selectWinner/test`)).to.eventually.be.rejected.and.eql({
code: 400,
@@ -30,7 +30,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/selectWinner/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -44,16 +44,16 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
let group;
let challenge;
let winningUser;
let taskText = 'A challenge task text';
const taskText = 'A challenge task text';
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
const populatedGroup = await createAndPopulateGroup({
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
winningUser = populatedGroup.members[0];
winningUser = populatedGroup.members[0]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(groupLeader, group, {
prize: 1,
@@ -61,7 +61,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
await groupLeader.post(`/challenges/${challenge._id}/join`);
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
{ type: 'habit', text: taskText },
]);
await winningUser.post(`/challenges/${challenge._id}/join`);
@@ -78,12 +78,12 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
});
it('returns an error when winning user isn\'t part of the challenge', async () => {
let notInChallengeUser = await generateUser();
const notInChallengeUser = await generateUser();
await expect(groupLeader.post(`/challenges/${challenge._id}/selectWinner/${notInChallengeUser._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('winnerNotFound', {userId: notInChallengeUser._id}),
message: t('winnerNotFound', { userId: notInChallengeUser._id }),
});
});
@@ -101,12 +101,13 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
await sleep(0.5);
await expect(winningUser.sync()).to.eventually.have.nested.property('achievements.challenges').to.include(challenge.name);
expect(winningUser.notifications.length).to.equal(2); // 2 because winningUser just joined the challenge, which now awards an achievement
// 2 because winningUser just joined the challenge, which now awards an achievement
expect(winningUser.notifications.length).to.equal(2);
expect(winningUser.notifications[1].type).to.equal('WON_CHALLENGE');
});
it('gives winner gems as reward', async () => {
let oldBalance = winningUser.balance;
const oldBalance = winningUser.balance;
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
@@ -116,8 +117,8 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
});
it('doesn\'t gives winner gems if group policy prevents it', async () => {
let oldBalance = winningUser.balance;
let oldLeaderBalance = (await groupLeader.sync()).balance;
const oldBalance = winningUser.balance;
const oldLeaderBalance = (await groupLeader.sync()).balance;
await winningUser.update({
'purchased.plan.customerId': 'group-plan',
@@ -136,7 +137,7 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
});
it('doesn\'t refund gems to group leader', async () => {
let oldBalance = (await groupLeader.sync()).balance;
const oldBalance = (await groupLeader.sync()).balance;
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
@@ -151,14 +152,10 @@ describe('POST /challenges/:challengeId/winner/:winnerId', () => {
await sleep(0.5);
const tasks = await winningUser.get('/tasks/user');
const testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
const testTask = _.find(tasks, task => task.text === taskText);
const updatedUser = await winningUser.sync();
const challengeTag = updatedUser.tags.find(tags => {
return tags.id === challenge._id;
});
const challengeTag = updatedUser.tags.find(tags => tags.id === challenge._id);
expect(testTask.challenge.broken).to.eql('CHALLENGE_CLOSED');
expect(testTask.challenge.winner).to.eql(winningUser.profile.name);

5
test/api/v3/integration/challenges/POST_challenges_id_clone.test.js
View File

@@ -5,7 +5,7 @@ import {
describe('POST /challenges/:challengeId/clone', () => {
it('clones a challenge', async () => {
const user = await generateUser({balance: 10});
const user = await generateUser({ balance: 10 });
const group = await generateGroup(user);
const name = 'Test Challenge';
@@ -38,6 +38,7 @@ describe('POST /challenges/:challengeId/clone', () => {
expect(cloneChallengeResponse.clonedTasks[0].text).to.eql(challengeTask.text);
expect(cloneChallengeResponse.clonedTasks[0]._id).to.not.eql(challengeTask._id);
expect(cloneChallengeResponse.clonedTasks[0].challenge.id).to.eql(cloneChallengeResponse.clonedChallenge._id);
expect(cloneChallengeResponse.clonedTasks[0].challenge.id)
.to.eql(cloneChallengeResponse.clonedChallenge._id);
});
});

11
test/api/v3/integration/challenges/PUT-challenges_challengeId.test.js
View File

@@ -6,10 +6,11 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('PUT /challenges/:challengeId', () => {
let privateGuild, user, nonMember, challenge, member;
let privateGuild; let user; let nonMember; let challenge; let
member;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
type: 'guild',
@@ -22,7 +23,7 @@ describe('PUT /challenges/:challengeId', () => {
user = groupLeader;
nonMember = await generateUser();
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
challenge = await generateChallenge(user, group);
await user.post(`/challenges/${challenge._id}/join`);
@@ -48,7 +49,7 @@ describe('PUT /challenges/:challengeId', () => {
});
it('only updates allowed fields', async () => {
let res = await user.put(`/challenges/${challenge._id}`, {
const res = await user.put(`/challenges/${challenge._id}`, {
// ignored
prize: 33,
group: 'blabla',
@@ -78,7 +79,7 @@ describe('PUT /challenges/:challengeId', () => {
expect(res.leader).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,

23
test/api/v3/integration/chat/DELETE-chat_id.test.js
View File

@@ -1,15 +1,16 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /groups/:groupId/chat/:chatId', () => {
let groupWithChat, message, user, userThatDidNotCreateChat, admin;
let groupWithChat; let message; let user; let userThatDidNotCreateChat; let
admin;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -21,12 +22,12 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
userThatDidNotCreateChat = await generateUser();
admin = await generateUser({'contributor.admin': true});
admin = await generateUser({ 'contributor.admin': true });
});
context('Chat errors', () => {
it('returns an error is message does not exist', async () => {
let fakeChatId = generateUUID();
const fakeChatId = generateUUID();
await expect(user.del(`/groups/${groupWithChat._id}/chat/${fakeChatId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -55,9 +56,9 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
const messageFromUser = returnedMessages.find(returnedMessage => {
return returnedMessage.id === nextMessage.id;
});
const messageFromUser = returnedMessages.find(
returnedMessage => returnedMessage.id === nextMessage.id,
);
expect(returnedMessages).is.an('array');
expect(messageFromUser).to.not.exist;
@@ -67,9 +68,9 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
await admin.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
const messageFromUser = returnedMessages.find(returnedMessage => {
return returnedMessage.id === nextMessage.id;
});
const messageFromUser = returnedMessages.find(
returnedMessage => returnedMessage.id === nextMessage.id,
);
expect(returnedMessages).is.an('array');
expect(messageFromUser).to.not.exist;

8
test/api/v3/integration/chat/GET-chat.test.js
View File

@@ -15,7 +15,7 @@ describe('GET /groups/:groupId/chat', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
const leader = await generateUser({ balance: 2 });
group = await generateGroup(leader, {
name: 'test group',
@@ -23,8 +23,8 @@ describe('GET /groups/:groupId/chat', () => {
privacy: 'public',
}, {
chat: [
{text: 'Hello', flags: {}, id: 1},
{text: 'Welcome to the Guild', flags: {}, id: 2},
{ text: 'Hello', flags: {}, id: 1 },
{ text: 'Welcome to the Guild', flags: {}, id: 2 },
],
});
});
@@ -41,7 +41,7 @@ describe('GET /groups/:groupId/chat', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
const leader = await generateUser({ balance: 2 });
group = await generateGroup(leader, {
name: 'test group',

83
test/api/v3/integration/chat/POST-chat.flag.test.js
View File

@@ -1,24 +1,25 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { find } from 'lodash';
import moment from 'moment';
import nconf from 'nconf';
import { IncomingWebhook } from '@slack/client';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
const BASE_URL = nconf.get('BASE_URL');
describe('POST /chat/:chatId/flag', () => {
let user, admin, anotherUser, newUser, group;
let user; let admin; let anotherUser; let newUser; let
group;
const TEST_MESSAGE = 'Test Message';
const USER_AGE_FOR_FLAGGING = 3;
beforeEach(async () => {
user = await generateUser({balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
admin = await generateUser({balance: 1, 'contributor.admin': true});
anotherUser = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
newUser = await generateUser({'auth.timestamps.created': moment().subtract(1, 'days').toDate()});
user = await generateUser({ balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
admin = await generateUser({ balance: 1, 'contributor.admin': true });
anotherUser = await generateUser({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
newUser = await generateUser({ 'auth.timestamps.created': moment().subtract(1, 'days').toDate() });
sandbox.stub(IncomingWebhook.prototype, 'send');
group = await user.post('/groups', {
@@ -42,20 +43,20 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Allows players to flag their own message', async () => {
let message = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const message = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await expect(user.post(`/groups/${group._id}/chat/${message.message.id}/flag`)).to.eventually.be.ok;
});
it('Flags a chat and sends normal message to moderator Slack when user is not new', async () => {
let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[user._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(1);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[user._id]).to.equal(true);
// Slack message to mods
@@ -81,16 +82,16 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Does not increment message flag count and sends different message to moderator Slack when user is new', async () => {
let automatedComment = `The post's flag count has not been increased because the flagger's account is less than ${USER_AGE_FOR_FLAGGING} days old.`;
let { message } = await newUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const automatedComment = `The post's flag count has not been increased because the flagger's account is less than ${USER_AGE_FOR_FLAGGING} days old.`;
const { message } = await newUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await newUser.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await newUser.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[newUser._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(0);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[newUser._id]).to.equal(true);
// Slack message to mods
@@ -116,38 +117,38 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Flags a chat when the author\'s account was deleted', async () => {
let deletedUser = await generateUser();
let { message } = await deletedUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const deletedUser = await generateUser();
const { message } = await deletedUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await deletedUser.del('/user', {
password: 'password',
});
let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[user._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(1);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[user._id]).to.equal(true);
});
it('Flags a chat with a higher flag acount when an admin flags the message', async () => {
let { message } = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[admin._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(5);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[admin._id]).to.equal(true);
expect(messageToCheck.flagCount).to.equal(5);
});
it('allows admin to flag a message in a private group', async () => {
let privateGroup = await user.post('/groups', {
const privateGroup = await user.post('/groups', {
name: 'Test party',
type: 'party',
privacy: 'private',
@@ -156,26 +157,26 @@ describe('POST /chat/:chatId/flag', () => {
uuids: [anotherUser._id],
});
await anotherUser.post(`/groups/${privateGroup._id}/join`);
let { message } = await user.post(`/groups/${privateGroup._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${privateGroup._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await admin.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`);
const flagResult = await admin.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`);
expect(flagResult.flags[admin._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(5);
let groupWithFlags = await anotherUser.get(`/groups/${privateGroup._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const groupWithFlags = await anotherUser.get(`/groups/${privateGroup._id}`);
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck).to.not.exist;
});
it('does not allow non member to flag message in private group', async () => {
let privateGroup = await user.post('/groups', {
const privateGroup = await user.post('/groups', {
name: 'Test party',
type: 'party',
privacy: 'private',
});
let { message } = await user.post(`/groups/${privateGroup._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${privateGroup._id}/chat`, { message: TEST_MESSAGE });
await expect(anotherUser.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`))
.to.eventually.be.rejected.and.eql({
@@ -186,7 +187,7 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Returns an error when user tries to flag a message that they already flagged', async () => {
let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
@@ -199,17 +200,17 @@ describe('POST /chat/:chatId/flag', () => {
});
it('shows a hidden message to the original poster', async () => {
let { message } = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
let groupWithFlags = await user.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const groupWithFlags = await user.get(`/groups/${group._id}`);
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck).to.exist;
let auGroupWithFlags = await anotherUser.get(`/groups/${group._id}`);
let auMessageToCheck = find(auGroupWithFlags.chat, {id: message.id});
const auGroupWithFlags = await anotherUser.get(`/groups/${group._id}`);
const auMessageToCheck = find(auGroupWithFlags.chat, { id: message.id });
expect(auMessageToCheck).to.not.exist;
});

28
test/api/v3/integration/chat/POST-chat.like.test.js
View File

@@ -1,17 +1,17 @@
import { find } from 'lodash';
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { find } from 'lodash';
describe('POST /chat/:chatId/like', () => {
let user;
let groupWithChat;
let testMessage = 'Test Message';
const testMessage = 'Test Message';
let anotherUser;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -22,7 +22,7 @@ describe('POST /chat/:chatId/like', () => {
user = groupLeader;
groupWithChat = group;
anotherUser = members[0];
anotherUser = members[0]; // eslint-disable-line prefer-destructuring
});
it('Returns an error when chat message is not found', async () => {
@@ -35,7 +35,7 @@ describe('POST /chat/:chatId/like', () => {
});
it('Returns an error when user tries to like their own message', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
await expect(user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
.to.eventually.be.rejected.and.eql({
@@ -46,30 +46,30 @@ describe('POST /chat/:chatId/like', () => {
});
it('Likes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
const groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithChatLikes.chat, {id: message.message.id});
const messageToCheck = find(groupWithChatLikes.chat, { id: message.message.id });
expect(messageToCheck.likes[user._id]).to.equal(true);
});
it('Unlikes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let unlikeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const unlikeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(unlikeResult.likes[user._id]).to.equal(false);
let groupWithoutChatLikes = await user.get(`/groups/${groupWithChat._id}`);
const groupWithoutChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithoutChatLikes.chat, {id: message.message.id});
const messageToCheck = find(groupWithoutChatLikes.chat, { id: message.message.id });
expect(messageToCheck.likes[user._id]).to.equal(false);
});
});

199
test/api/v3/integration/chat/POST-chat.test.js
View File

@@ -1,5 +1,6 @@
import { IncomingWebhook } from '@slack/client';
import nconf from 'nconf';
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
@@ -13,7 +14,6 @@ import {
TAVERN_ID,
} from '../../../../../website/server/models/group';
import { CHAT_FLAG_FROM_SHADOW_MUTE } from '../../../../../website/common/script/constants';
import { v4 as generateUUID } from 'uuid';
import { getMatchesByWordArray } from '../../../../../website/server/libs/stringUtils';
import bannedWords from '../../../../../website/server/libs/bannedWords';
import guildsAllowingBannedWords from '../../../../../website/server/libs/guildsAllowingBannedWords';
@@ -22,16 +22,17 @@ import * as email from '../../../../../website/server/libs/email';
const BASE_URL = nconf.get('BASE_URL');
describe('POST /chat', () => {
let user, groupWithChat, member, additionalMember;
let testMessage = 'Test Message';
let testBannedWordMessage = 'TESTPLACEHOLDERSWEARWORDHERE';
let testBannedWordMessage1 = 'TESTPLACEHOLDERSWEARWORDHERE1';
let testSlurMessage = 'message with TESTPLACEHOLDERSLURWORDHERE';
let testSlurMessage1 = 'TESTPLACEHOLDERSLURWORDHERE1';
let bannedWordErrorMessage = t('bannedWordUsed', {swearWordsUsed: testBannedWordMessage});
let user; let groupWithChat; let member; let
additionalMember;
const testMessage = 'Test Message';
const testBannedWordMessage = 'TESTPLACEHOLDERSWEARWORDHERE';
const testBannedWordMessage1 = 'TESTPLACEHOLDERSWEARWORDHERE1';
const testSlurMessage = 'message with TESTPLACEHOLDERSLURWORDHERE';
const testSlurMessage1 = 'TESTPLACEHOLDERSLURWORDHERE1';
const bannedWordErrorMessage = t('bannedWordUsed', { swearWordsUsed: testBannedWordMessage });
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -40,14 +41,14 @@ describe('POST /chat', () => {
members: 2,
});
user = groupLeader;
await user.update({'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL}); // prevent tests accidentally throwing messageGroupChatSpam
await user.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL }); // prevent tests accidentally throwing messageGroupChatSpam
groupWithChat = group;
member = members[0];
additionalMember = members[1];
member = members[0]; // eslint-disable-line prefer-destructuring
additionalMember = members[1]; // eslint-disable-line prefer-destructuring
});
it('Returns an error when no message is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ''}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -56,7 +57,7 @@ describe('POST /chat', () => {
});
it('Returns an error when an empty message is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ' '}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ' ' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -65,7 +66,7 @@ describe('POST /chat', () => {
});
it('Returns an error when an message containing only newlines is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '\n\n'}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '\n\n' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -74,7 +75,7 @@ describe('POST /chat', () => {
});
it('Returns an error when group is not found', async () => {
await expect(user.post('/groups/invalidID/chat', { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post('/groups/invalidID/chat', { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
@@ -83,12 +84,12 @@ describe('POST /chat', () => {
describe('mute user', () => {
afterEach(() => {
member.update({'flags.chatRevoked': false});
member.update({ 'flags.chatRevoked': false });
});
it('returns an error when chat privileges are revoked when sending a message to a public guild', async () => {
const userWithChatRevoked = await member.update({'flags.chatRevoked': true});
await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
const userWithChatRevoked = await member.update({ 'flags.chatRevoked': true });
await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -106,9 +107,9 @@ describe('POST /chat', () => {
});
const privateGuildMemberWithChatsRevoked = members[0];
await privateGuildMemberWithChatsRevoked.update({'flags.chatRevoked': true});
await privateGuildMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
const message = await privateGuildMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await privateGuildMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
});
@@ -124,9 +125,9 @@ describe('POST /chat', () => {
});
const privatePartyMemberWithChatsRevoked = members[0];
await privatePartyMemberWithChatsRevoked.update({'flags.chatRevoked': true});
await privatePartyMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
const message = await privatePartyMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await privatePartyMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
});
@@ -140,12 +141,12 @@ describe('POST /chat', () => {
afterEach(() => {
sandbox.restore();
member.update({'flags.chatShadowMuted': false});
member.update({ 'flags.chatShadowMuted': false });
});
it('creates a chat with flagCount already set and notifies mods when sending a message to a public guild', async () => {
const userWithChatShadowMuted = await member.update({'flags.chatShadowMuted': true});
const message = await userWithChatShadowMuted.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const userWithChatShadowMuted = await member.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(CHAT_FLAG_FROM_SHADOW_MUTE);
@@ -185,9 +186,9 @@ describe('POST /chat', () => {
});
const userWithChatShadowMuted = members[0];
await userWithChatShadowMuted.update({'flags.chatShadowMuted': true});
await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
@@ -204,16 +205,16 @@ describe('POST /chat', () => {
});
const userWithChatShadowMuted = members[0];
await userWithChatShadowMuted.update({'flags.chatShadowMuted': true});
await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
});
it('creates a chat with zero flagCount when non-shadow-muted user sends a message to a public guild', async () => {
const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
});
@@ -221,7 +222,7 @@ describe('POST /chat', () => {
context('banned word', () => {
it('returns an error when chat message contains a banned word in tavern', async () => {
await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage}))
await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -230,7 +231,7 @@ describe('POST /chat', () => {
});
it('returns an error when chat message contains a banned word in a public guild', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'public guild',
type: 'guild',
@@ -239,7 +240,7 @@ describe('POST /chat', () => {
members: 1,
});
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage}))
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -248,8 +249,8 @@ describe('POST /chat', () => {
});
it('errors when word is part of a phrase', async () => {
let wordInPhrase = `phrase ${testBannedWordMessage} end`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase}))
const wordInPhrase = `phrase ${testBannedWordMessage} end`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -258,8 +259,8 @@ describe('POST /chat', () => {
});
it('errors when word is surrounded by non alphabet characters', async () => {
let wordInPhrase = `_!${testBannedWordMessage}@_`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase}))
const wordInPhrase = `_!${testBannedWordMessage}@_`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -268,47 +269,51 @@ describe('POST /chat', () => {
});
it('errors when word is typed in mixed case', async () => {
let substrLength = Math.floor(testBannedWordMessage.length / 2);
let chatMessage = testBannedWordMessage.substring(0, substrLength).toLowerCase() + testBannedWordMessage.substring(substrLength).toUpperCase();
const substrLength = Math.floor(testBannedWordMessage.length / 2);
const chatMessage = testBannedWordMessage.substring(0, substrLength).toLowerCase()
+ testBannedWordMessage.substring(substrLength).toUpperCase();
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedWordUsed', {swearWordsUsed: chatMessage}),
message: t('bannedWordUsed', { swearWordsUsed: chatMessage }),
});
});
it('checks error message has all the banned words used, regardless of case', async () => {
let testBannedWords = [testBannedWordMessage.toUpperCase(), testBannedWordMessage1.toLowerCase()];
let chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage}))
const testBannedWords = [
testBannedWordMessage.toUpperCase(),
testBannedWordMessage1.toLowerCase(),
];
const chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected
.and.have.property('message')
.that.includes(testBannedWords.join(', '));
});
it('check all banned words are matched', async () => {
let message = bannedWords.join(',').replace(/\\/g, '');
let matches = getMatchesByWordArray(message, bannedWords);
const message = bannedWords.join(',').replace(/\\/g, '');
const matches = getMatchesByWordArray(message, bannedWords);
expect(matches.length).to.equal(bannedWords.length);
});
it('does not error when bad word is suffix of a word', async () => {
let wordAsSuffix = `prefix${testBannedWordMessage}`;
let message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix});
const wordAsSuffix = `prefix${testBannedWordMessage}`;
const message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix });
expect(message.message.id).to.exist;
});
it('does not error when bad word is prefix of a word', async () => {
let wordAsPrefix = `${testBannedWordMessage}suffix`;
let message = await user.post('/groups/habitrpg/chat', { message: wordAsPrefix});
const wordAsPrefix = `${testBannedWordMessage}suffix`;
const message = await user.post('/groups/habitrpg/chat', { message: wordAsPrefix });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a party', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Party',
type: 'party',
@@ -317,13 +322,13 @@ describe('POST /chat', () => {
members: 1,
});
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a public guild in which banned words are allowed', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'public guild',
type: 'guild',
@@ -334,13 +339,13 @@ describe('POST /chat', () => {
guildsAllowingBannedWords[group._id] = true;
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a private guild', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'private guild',
type: 'guild',
@@ -349,7 +354,7 @@ describe('POST /chat', () => {
members: 1,
});
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
@@ -363,11 +368,11 @@ describe('POST /chat', () => {
afterEach(() => {
sandbox.restore();
user.update({'flags.chatRevoked': false});
user.update({ 'flags.chatRevoked': false });
});
it('errors and revokes privileges when chat message contains a banned slur', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage })).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedSlurUsed'),
@@ -398,7 +403,7 @@ describe('POST /chat', () => {
/* eslint-enable camelcase */
// Chat privileges are revoked
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -406,7 +411,7 @@ describe('POST /chat', () => {
});
it('does not allow slurs in private groups', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Party',
type: 'party',
@@ -415,7 +420,7 @@ describe('POST /chat', () => {
members: 1,
});
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage })).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedSlurUsed'),
@@ -446,7 +451,7 @@ describe('POST /chat', () => {
/* eslint-enable camelcase */
// Chat privileges are revoked
await expect(members[0].post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(members[0].post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -454,8 +459,9 @@ describe('POST /chat', () => {
});
it('errors when slur is typed in mixed case', async () => {
let substrLength = Math.floor(testSlurMessage1.length / 2);
let chatMessage = testSlurMessage1.substring(0, substrLength).toLowerCase() + testSlurMessage1.substring(substrLength).toUpperCase();
const substrLength = Math.floor(testSlurMessage1.length / 2);
const chatMessage = testSlurMessage1.substring(0, substrLength).toLowerCase()
+ testSlurMessage1.substring(substrLength).toUpperCase();
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
@@ -466,7 +472,7 @@ describe('POST /chat', () => {
});
it('creates a chat', async () => {
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const groupMessages = await user.get(`/groups/${groupWithChat._id}/chat`);
expect(newMessage.message.id).to.exist;
@@ -479,7 +485,7 @@ describe('POST /chat', () => {
THIS PART WON'T BE IN THE MESSAGE (over 3000)
`;
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: veryLongMessage});
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: veryLongMessage });
const groupMessages = await user.get(`/groups/${groupWithChat._id}/chat`);
expect(newMessage.message.id).to.exist;
@@ -501,7 +507,7 @@ describe('POST /chat', () => {
});
await userWithStyle.sync();
const message = await userWithStyle.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await userWithStyle.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.userStyles.items.currentMount).to.eql(userWithStyle.items.currentMount);
@@ -511,7 +517,8 @@ describe('POST /chat', () => {
expect(message.message.userStyles.preferences.skin).to.eql(userWithStyle.preferences.skin);
expect(message.message.userStyles.preferences.shirt).to.eql(userWithStyle.preferences.shirt);
expect(message.message.userStyles.preferences.chair).to.eql(userWithStyle.preferences.chair);
expect(message.message.userStyles.preferences.background).to.eql(userWithStyle.preferences.background);
expect(message.message.userStyles.preferences.background)
.to.eql(userWithStyle.preferences.background);
});
it('adds backer info to chat', async () => {
@@ -524,7 +531,7 @@ describe('POST /chat', () => {
backer: backerInfo,
});
const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const messageBackerInfo = message.message.backer;
expect(messageBackerInfo.npc).to.equal(backerInfo.npc);
@@ -533,8 +540,8 @@ describe('POST /chat', () => {
});
it('sends group chat received webhooks', async () => {
let userUuid = generateUUID();
let memberUuid = generateUUID();
const userUuid = generateUUID();
const memberUuid = generateUUID();
await server.start();
await user.post('/user/webhook', {
@@ -554,16 +561,16 @@ describe('POST /chat', () => {
},
});
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
await sleep();
await server.close();
let userBody = server.getWebhookData(userUuid);
let memberBody = server.getWebhookData(memberUuid);
const userBody = server.getWebhookData(userUuid);
const memberBody = server.getWebhookData(memberUuid);
[userBody, memberBody].forEach((body) => {
[userBody, memberBody].forEach(body => {
expect(body.group.id).to.eql(groupWithChat._id);
expect(body.group.name).to.eql(groupWithChat.name);
expect(body.chat).to.eql(message.message);
@@ -572,22 +579,20 @@ describe('POST /chat', () => {
context('chat notifications', () => {
beforeEach(() => {
member.update({newMessages: {}, notifications: []});
member.update({ newMessages: {}, notifications: [] });
});
it('notifies other users of new messages for a guild', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let memberWithNotification = await member.get('/user');
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const memberWithNotification = await member.get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id;
})).to.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id)).to.exist;
});
it('notifies other users of new messages for a party', async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -596,36 +601,32 @@ describe('POST /chat', () => {
members: 1,
});
let message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage });
let memberWithNotification = await members[0].get('/user');
const message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage });
const memberWithNotification = await members[0].get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${group._id}`]).to.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === group._id;
})).to.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === group._id)).to.exist;
});
it('does not notify other users of a new message that is already hidden from shadow-muting', async () => {
await user.update({'flags.chatShadowMuted': true});
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let memberWithNotification = await member.get('/user');
await user.update({ 'flags.chatShadowMuted': true });
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const memberWithNotification = await member.get('/user');
await user.update({'flags.chatShadowMuted': false});
await user.update({ 'flags.chatShadowMuted': false });
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.not.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id;
})).to.not.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id)).to.not.exist;
});
});
context('Spam prevention', () => {
it('Returns an error when the user has been posting too many messages', async () => {
// Post as many messages are needed to reach the spam limit
for (let i = 0; i < SPAM_MESSAGE_LIMIT; i++) {
let result = await additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
for (let i = 0; i < SPAM_MESSAGE_LIMIT; i += 1) {
const result = await additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
expect(result.message.id).to.exist;
}
@@ -637,11 +638,11 @@ describe('POST /chat', () => {
});
it('contributor should not receive spam alert', async () => {
let userSocialite = await member.update({'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL});
const userSocialite = await member.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL });
// Post 1 more message than the spam limit to ensure they do not reach the limit
for (let i = 0; i < SPAM_MESSAGE_LIMIT + 1; i++) {
let result = await userSocialite.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
for (let i = 0; i < SPAM_MESSAGE_LIMIT + 1; i += 1) {
const result = await userSocialite.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
expect(result.message.id).to.exist;
}
});

18
test/api/v3/integration/chat/POST-chat_seen.test.js
View File

@@ -5,10 +5,11 @@ import {
describe('POST /groups/:id/chat/seen', () => {
context('Guild', () => {
let guild, guildLeader, guildMember, guildMessage;
let guild; let guildLeader; let guildMember; let
guildMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -18,7 +19,7 @@ describe('POST /groups/:id/chat/seen', () => {
guild = group;
guildLeader = groupLeader;
guildMember = members[0];
guildMember = members[0]; // eslint-disable-line prefer-destructuring
guildMessage = await guildLeader.post(`/groups/${guild._id}/chat`, { message: 'Some guild message' });
guildMessage = guildMessage.message;
@@ -32,7 +33,7 @@ describe('POST /groups/:id/chat/seen', () => {
await sleep(1);
let guildThatHasSeenChat = await guildMember.get('/user');
const guildThatHasSeenChat = await guildMember.get('/user');
expect(guildThatHasSeenChat.notifications.length).to.equal(initialNotifications - 1);
expect(guildThatHasSeenChat.newMessages).to.be.empty;
@@ -40,10 +41,11 @@ describe('POST /groups/:id/chat/seen', () => {
});
context('Party', () => {
let party, partyLeader, partyMember, partyMessage;
let party; let partyLeader; let partyMember; let
partyMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -53,7 +55,7 @@ describe('POST /groups/:id/chat/seen', () => {
party = group;
partyLeader = groupLeader;
partyMember = members[0];
partyMember = members[0]; // eslint-disable-line prefer-destructuring
partyMessage = await partyLeader.post(`/groups/${party._id}/chat`, { message: 'Some party message' });
partyMessage = partyMessage.message;
@@ -67,7 +69,7 @@ describe('POST /groups/:id/chat/seen', () => {
await sleep(1);
let partyMemberThatHasSeenChat = await partyMember.get('/user');
const partyMemberThatHasSeenChat = await partyMember.get('/user');
expect(partyMemberThatHasSeenChat.notifications.length).to.equal(initialNotifications - 1);
expect(partyMemberThatHasSeenChat.newMessages).to.be.empty;

54
test/api/v3/integration/chat/POST-groups_id_chat_id_clear_flags.test.js
View File

@@ -1,18 +1,19 @@
import moment from 'moment';
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import config from '../../../../../config.json';
import moment from 'moment';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:id/chat/:id/clearflags', () => {
const USER_AGE_FOR_FLAGGING = 3;
let groupWithChat, message, author, nonAdmin, admin;
let groupWithChat; let message; let author; let nonAdmin; let
admin;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -21,8 +22,8 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
groupWithChat = group;
author = groupLeader;
nonAdmin = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
admin = await generateUser({'contributor.admin': true});
nonAdmin = await generateUser({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
admin = await generateUser({ 'contributor.admin': true });
message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
@@ -30,17 +31,15 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
context('Single Message', () => {
it('returns error when non-admin attempts to clear flags', async () => {
return expect(nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupChatAdminClearFlagCount'),
});
});
it('returns error when non-admin attempts to clear flags', async () => expect(nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupChatAdminClearFlagCount'),
}));
it('returns error if message does not exist', async () => {
let fakeMessageID = generateUUID();
const fakeMessageID = generateUUID();
await expect(admin.post(`/groups/${groupWithChat._id}/chat/${fakeMessageID}/clearflags`))
.to.eventually.be.rejected.and.eql({
@@ -52,13 +51,13 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
it('clears flags and leaves old flags on the flag object', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
const messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages[0].flagCount).to.eql(0);
expect(messages[0].flags).to.have.property(admin._id, true);
});
it('clears flags in a private group', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -82,7 +81,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
it('can\'t flag a system message', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -90,7 +89,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
members: 1,
});
let member = members[0];
const member = members[0];
// make member that can use skills
await member.update({
@@ -101,12 +100,12 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
await member.post('/user/class/cast/mpheal');
let [skillMsg] = await member.get(`/groups/${group.id}/chat`);
const [skillMsg] = await member.get(`/groups/${group.id}/chat`);
await expect(member.post(`/groups/${group._id}/chat/${skillMsg.id}/flag`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('messageCannotFlagSystemMessages', {communityManagerEmail: config.EMAILS_COMMUNITY_MANAGER_EMAIL}),
message: t('messageCannotFlagSystemMessages', { communityManagerEmail: config.EMAILS_COMMUNITY_MANAGER_EMAIL }),
});
// let messages = await members[0].get(`/groups/${group._id}/chat`);
// expect(messages[0].id).to.eql(skillMsg.id);
@@ -115,7 +114,8 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
context('admin user, group with multiple messages', () => {
let message2, message3, message4;
let message2; let message3; let
message4;
before(async () => {
message2 = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message 2' });
@@ -133,14 +133,14 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
it('changes only the message that is flagged', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
const messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages).to.have.lengthOf(4);
let messageThatWasUnflagged = messages[3];
let messageWith1Flag = messages[2];
let messageWith2Flag = messages[1];
let messageWithoutFlags = messages[0];
const messageThatWasUnflagged = messages[3];
const messageWith1Flag = messages[2];
const messageWith2Flag = messages[1];
const messageWithoutFlags = messages[0];
expect(messageThatWasUnflagged.flagCount).to.eql(0);
expect(messageThatWasUnflagged.flags).to.have.property(admin._id, true);

6
test/api/v3/integration/content/GET-content.test.js
View File

@@ -6,19 +6,19 @@ import i18n from '../../../../../website/common/script/i18n';
describe('GET /content', () => {
it('returns content (and does not require authentication)', async () => {
let res = await requester().get('/content');
const res = await requester().get('/content');
expect(res).to.have.nested.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(t('backgroundBeachText'));
});
it('returns content not in English', async () => {
let res = await requester().get('/content?language=de');
const res = await requester().get('/content?language=de');
expect(res).to.have.nested.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(i18n.t('backgroundBeachText', 'de'));
});
it('falls back to English if the desired language is not found', async () => {
let res = await requester().get('/content?language=wrong');
const res = await requester().get('/content?language=wrong');
expect(res).to.have.nested.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(t('backgroundBeachText'));
});

6
test/api/v3/integration/coupons/GET-coupons.test.js
View File

@@ -28,9 +28,9 @@ describe('GET /coupons/', () => {
'contributor.sudo': true,
});
let coupons = await user.post('/coupons/generate/wondercon?count=11');
let res = await user.get('/coupons');
let splitRes = res.split('\n');
const coupons = await user.post('/coupons/generate/wondercon?count=11');
const res = await user.get('/coupons');
const splitRes = res.split('\n');
expect(splitRes.length).to.equal(13);
expect(splitRes[0]).to.equal('code,event,date,user');

8
test/api/v3/integration/coupons/POST-coupons_enter_code.test.js
View File

@@ -36,7 +36,7 @@ describe('POST /coupons/enter/:code', () => {
});
it('returns an error if coupon has been used', async () => {
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
const [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
await user.post(`/coupons/enter/${coupon._id}`); // use coupon
await expect(user.post(`/coupons/enter/${coupon._id}`)).to.eventually.be.rejected.and.eql({
@@ -47,8 +47,8 @@ describe('POST /coupons/enter/:code', () => {
});
it('should apply the coupon to the user', async () => {
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
let userRes = await user.post(`/coupons/enter/${coupon._id}`);
const [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
const userRes = await user.post(`/coupons/enter/${coupon._id}`);
expect(userRes._id).to.equal(user._id);
expect(userRes.items.gear.owned.eyewear_special_wondercon_red).to.be.true;
expect(userRes.items.gear.owned.eyewear_special_wondercon_black).to.be.true;
@@ -57,6 +57,6 @@ describe('POST /coupons/enter/:code', () => {
expect(userRes.items.gear.owned.body_special_wondercon_red).to.be.true;
expect(userRes.items.gear.owned.body_special_wondercon_black).to.be.true;
expect(userRes.items.gear.owned.body_special_wondercon_gold).to.be.true;
expect(userRes.extra).to.eql({signupEvent: 'wondercon'});
expect(userRes.extra).to.eql({ signupEvent: 'wondercon' });
});
});

4
test/api/v3/integration/coupons/POST-coupons_generate_event.test.js
View File

@@ -1,9 +1,9 @@
import couponCode from 'coupon-code';
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-integration/v3';
import couponCode from 'coupon-code';
import apiError from '../../../../../website/server/libs/apiError';
describe('POST /coupons/generate/:event', () => {
@@ -51,7 +51,7 @@ describe('POST /coupons/generate/:event', () => {
'contributor.sudo': true,
});
let coupons = await user.post('/coupons/generate/wondercon?count=2');
const coupons = await user.post('/coupons/generate/wondercon?count=2');
expect(coupons.length).to.equal(2);
expect(coupons[0].event).to.equal('wondercon');
expect(couponCode.validate(coupons[1]._id)).to.not.equal(''); // '' means invalid

14
test/api/v3/integration/coupons/POST-coupons_validate_code.test.js
View File

@@ -5,7 +5,7 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('POST /coupons/validate/:code', () => {
let api = requester();
const api = requester();
before(async () => {
await resetHabiticaDB();
@@ -20,17 +20,17 @@ describe('POST /coupons/validate/:code', () => {
});
it('returns true if coupon code is valid', async () => {
let sudoUser = await generateUser({
const sudoUser = await generateUser({
'contributor.sudo': true,
});
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
let res = await api.post(`/coupons/validate/${coupon._id}`);
expect(res).to.eql({valid: true});
const [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
const res = await api.post(`/coupons/validate/${coupon._id}`);
expect(res).to.eql({ valid: true });
});
it('returns false if coupon code is valid', async () => {
let res = await api.post('/coupons/validate/notValid');
expect(res).to.eql({valid: false});
const res = await api.post('/coupons/validate/notValid');
expect(res).to.eql({ valid: false });
});
});

8
test/api/v3/integration/dataexport/GET-export_avatar-memberId.html.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
xdescribe('GET /export/avatar-:memberId.html', () => {
let user;
@@ -20,16 +20,16 @@ xdescribe('GET /export/avatar-:memberId.html', () => {
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.get(`/export/avatar-${dummyId}.html`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
it('returns an html page', async () => {
let res = await user.get(`/export/avatar-${user._id}.html`);
const res = await user.get(`/export/avatar-${user._id}.html`);
expect(res.substring(0, 100).indexOf('<!DOCTYPE html>')).to.equal(0);
});
});

26
test/api/v3/integration/dataexport/GET-export_history.csv.test.js
View File

@@ -1,26 +1,24 @@
import moment from 'moment';
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
import {
updateDocument,
} from '../../../../helpers/mongo';
import moment from 'moment';
describe('GET /export/history.csv', () => {
// TODO disabled because it randomly causes the build to fail
xit('should return a valid CSV file with tasks history data', async () => {
let user = await generateUser();
const user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'daily', text: 'daily 1'},
{type: 'habit', text: 'habit 1'},
{type: 'habit', text: 'habit 2'},
{type: 'todo', text: 'todo 1'},
{ type: 'daily', text: 'daily 1' },
{ type: 'habit', text: 'habit 1' },
{ type: 'habit', text: 'habit 2' },
{ type: 'todo', text: 'todo 1' },
]);
// to handle occasional inconsistency in task creation order
tasks.sort(function (a, b) {
return a.text.localeCompare(b.text);
});
tasks.sort((a, b) => a.text.localeCompare(b.text));
// score all the tasks twice
await user.post(`/tasks/${tasks[0]._id}/score/up`);
@@ -35,16 +33,14 @@ describe('GET /export/history.csv', () => {
// adding an history entry to daily 1 manually because cron didn't run yet
await updateDocument('tasks', tasks[0], {
history: [{value: 3.2, date: Number(new Date())}],
history: [{ value: 3.2, date: Number(new Date()) }],
});
// get updated tasks
tasks = await Promise.all(tasks.map(task => {
return user.get(`/tasks/${task._id}`);
}));
tasks = await Promise.all(tasks.map(task => user.get(`/tasks/${task._id}`)));
let res = await user.get('/export/history.csv');
let splitRes = res.split('\n');
const res = await user.get('/export/history.csv');
const splitRes = res.split('\n');
expect(splitRes[0]).to.equal('Task Name,Task ID,Task Type,Date,Value');
expect(splitRes[1]).to.equal(`daily 1,${tasks[0]._id},daily,${moment(tasks[0].history[0].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[0].history[0].value}`);

14
test/api/v3/integration/dataexport/GET-export_inbox.html.test.js
View File

@@ -6,7 +6,7 @@ describe('GET /export/inbox.html', () => {
let user;
before(async () => {
let otherUser = await generateUser({
const otherUser = await generateUser({
'profile.name': 'Other User',
});
user = await generateUser({
@@ -30,13 +30,13 @@ describe('GET /export/inbox.html', () => {
});
it('returns an html page', async () => {
let res = await user.get('/export/inbox.html');
const res = await user.get('/export/inbox.html');
expect(res.substring(0, 100).indexOf('<!DOCTYPE html>')).to.equal(0);
});
it('renders the markdown messages as html', async () => {
let res = await user.get('/export/inbox.html');
const res = await user.get('/export/inbox.html');
expect(res).to.include('img class="habitica-emoji"');
expect(res).to.include('<h1>Hello!</h1>');
@@ -44,11 +44,11 @@ describe('GET /export/inbox.html', () => {
});
it('sorts messages from newest to oldest', async () => {
let res = await user.get('/export/inbox.html');
const res = await user.get('/export/inbox.html');
let emojiPosition = res.indexOf('img class="habitica-emoji"');
let headingPosition = res.indexOf('<h1>Hello!</h1>');
let listPosition = res.indexOf('<li>list 1</li>');
const emojiPosition = res.indexOf('img class="habitica-emoji"');
const headingPosition = res.indexOf('<h1>Hello!</h1>');
const listPosition = res.indexOf('<li>list 1</li>');
expect(emojiPosition).to.be.greaterThan(headingPosition);
expect(headingPosition).to.be.greaterThan(listPosition);

14
test/api/v3/integration/dataexport/GET-export_userdata.json.test.js
View File

@@ -4,15 +4,15 @@ import {
describe('GET /export/userdata.json', () => {
it('should return a valid JSON file with user data', async () => {
let user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'daily', text: 'daily 1'},
{type: 'reward', text: 'reward 1'},
{type: 'todo', text: 'todo 1'},
const user = await generateUser();
const tasks = await user.post('/tasks/user', [
{ type: 'habit', text: 'habit 1' },
{ type: 'daily', text: 'daily 1' },
{ type: 'reward', text: 'reward 1' },
{ type: 'todo', text: 'todo 1' },
]);
let res = await user.get('/export/userdata.json');
const res = await user.get('/export/userdata.json');
expect(res._id).to.equal(user._id);
expect(res).to.contain.all.keys(['tasks', 'flags', 'tasksOrder', 'auth']);
expect(res.auth.local).not.to.have.keys(['salt', 'hashed_password']);

40
test/api/v3/integration/dataexport/GET-export_userdata.xml.test.js
View File

@@ -1,25 +1,25 @@
import xml2js from 'xml2js';
import util from 'util';
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
import xml2js from 'xml2js';
import util from 'util';
let parseStringAsync = util.promisify(xml2js.parseString).bind(xml2js);
const parseStringAsync = util.promisify(xml2js.parseString).bind(xml2js);
describe('GET /export/userdata.xml', () => {
it('should return a valid XML file with user data', async () => {
let user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'daily', text: 'daily 1'},
{type: 'reward', text: 'reward 1'},
{type: 'todo', text: 'todo 1'},
const user = await generateUser();
const tasks = await user.post('/tasks/user', [
{ type: 'habit', text: 'habit 1' },
{ type: 'daily', text: 'daily 1' },
{ type: 'reward', text: 'reward 1' },
{ type: 'todo', text: 'todo 1' },
// due to how the xml parser works an array is returned only if there's more than one children
// so we create two tasks for each type
{type: 'habit', text: 'habit 2'},
{type: 'daily', text: 'daily 2'},
{type: 'reward', text: 'reward 2'},
{type: 'todo', text: 'todo 2'},
{ type: 'habit', text: 'habit 2' },
{ type: 'daily', text: 'daily 2' },
{ type: 'reward', text: 'reward 2' },
{ type: 'todo', text: 'todo 2' },
]);
@@ -27,15 +27,15 @@ describe('GET /export/userdata.xml', () => {
await user.get('/user/toggle-pinned-item/marketGear/gear.flat.shield_rogue_5');
// add a private message
let receiver = await generateUser();
const receiver = await generateUser();
user.post('/members/send-private-message', {
message: 'Your first message, hi!',
toUserId: receiver._id,
});
let response = await user.get('/export/userdata.xml');
let {user: res} = await parseStringAsync(response, {explicitArray: false});
const response = await user.get('/export/userdata.xml');
const { user: res } = await parseStringAsync(response, { explicitArray: false });
expect(res._id).to.equal(user._id);
expect(res).to.contain.all.keys(['tasks', 'flags', 'tasksOrder', 'auth']);
@@ -43,19 +43,19 @@ describe('GET /export/userdata.xml', () => {
expect(res.tasks).to.have.all.keys(['dailys', 'habits', 'todos', 'rewards']);
expect(res.tasks.habits.length).to.equal(2);
let habitIds = _.map(res.tasks.habits, '_id');
const habitIds = _.map(res.tasks.habits, '_id');
expect(habitIds).to.have.deep.members([tasks[0]._id, tasks[4]._id]);
expect(res.tasks.dailys.length).to.equal(2);
let dailyIds = _.map(res.tasks.dailys, '_id');
const dailyIds = _.map(res.tasks.dailys, '_id');
expect(dailyIds).to.have.deep.members([tasks[1]._id, tasks[5]._id]);
expect(res.tasks.rewards.length).to.equal(2);
let rewardIds = _.map(res.tasks.rewards, '_id');
const rewardIds = _.map(res.tasks.rewards, '_id');
expect(rewardIds).to.have.deep.members([tasks[2]._id, tasks[6]._id]);
expect(res.tasks.todos.length).to.equal(3);
let todoIds = _.map(res.tasks.todos, '_id');
const todoIds = _.map(res.tasks.todos, '_id');
expect(todoIds).to.deep.include.members([tasks[3]._id, tasks[7]._id]);
});
});

2
test/api/v3/integration/debug/POST-debug_addHourglass.test.js
View File

@@ -17,7 +17,7 @@ describe('POST /debug/add-hourglass', () => {
it('adds Hourglass to the current user', async () => {
await userToGetHourGlass.post('/debug/add-hourglass');
let userWithHourGlass = await userToGetHourGlass.get('/user');
const userWithHourGlass = await userToGetHourGlass.get('/user');
expect(userWithHourGlass.purchased.plan.consecutive.trinkets).to.equal(1);
});

2
test/api/v3/integration/debug/POST-debug_addTenGems.test.js
View File

@@ -17,7 +17,7 @@ describe('POST /debug/add-ten-gems', () => {
it('adds ten gems to the current user', async () => {
await userToGainTenGems.post('/debug/add-ten-gems');
let userWithTenGems = await userToGainTenGems.get('/user');
const userWithTenGems = await userToGainTenGems.get('/user');
expect(userWithTenGems.balance).to.equal(2.5);
});

17
test/api/v3/integration/debug/POST-debug_modify-inventory.test.js
View File

@@ -6,7 +6,8 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('POST /debug/modify-inventory', () => {
let user, originalItems;
let user; let
originalItems;
before(async () => {
originalItems = {
@@ -43,7 +44,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets equipment', async () => {
let gear = {
const gear = {
weapon_healer_2: true,
weapon_wizard_1: true,
weapon_special_critical: true,
@@ -59,7 +60,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets special spells', async () => {
let special = {
const special = {
shinySeed: 3,
};
@@ -73,7 +74,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets mounts', async () => {
let mounts = {
const mounts = {
'Orca-Base': true,
'Mammoth-Base': true,
};
@@ -88,7 +89,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets eggs', async () => {
let eggs = {
const eggs = {
Gryphon: 3,
Hedgehog: 7,
};
@@ -103,7 +104,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets hatching potions', async () => {
let hatchingPotions = {
const hatchingPotions = {
White: 7,
Spooky: 2,
};
@@ -118,7 +119,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets food', async () => {
let food = {
const food = {
Meat: 5,
Candy_Red: 7,
};
@@ -133,7 +134,7 @@ describe('POST /debug/modify-inventory', () => {
});
it('sets quests', async () => {
let quests = {
const quests = {
whale: 5,
cheetah: 10,
};

2
test/api/v3/integration/debug/POST-debug_set-cron.test.js
View File

@@ -15,7 +15,7 @@ describe('POST /debug/set-cron', () => {
});
it('sets last cron', async () => {
let newCron = new Date(2015, 11, 20);
const newCron = new Date(2015, 11, 20);
await user.post('/debug/set-cron', {
lastCron: newCron,

18
test/api/v3/integration/emails/GET-email-unsubscribe.test.js
View File

@@ -1,13 +1,13 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { encrypt } from '../../../../../website/server/libs/encryption';
import { v4 as generateUUID } from 'uuid';
describe('GET /email/unsubscribe', () => {
let user;
let testEmail = 'test@habitica.com';
const testEmail = 'test@habitica.com';
beforeEach(async () => {
user = await generateUser();
@@ -22,7 +22,7 @@ describe('GET /email/unsubscribe', () => {
});
it('return error when user is not found', async () => {
let code = encrypt(JSON.stringify({
const code = encrypt(JSON.stringify({
_id: generateUUID(),
}));
@@ -34,34 +34,34 @@ describe('GET /email/unsubscribe', () => {
});
it('unsubscribes a user from email notifications', async () => {
let code = encrypt(JSON.stringify({
const code = encrypt(JSON.stringify({
_id: user._id,
email: user.email,
}));
await user.get(`/email/unsubscribe?code=${code}`);
let unsubscribedUser = await user.get('/user');
const unsubscribedUser = await user.get('/user');
expect(unsubscribedUser.preferences.emailNotifications.unsubscribeFromAll).to.be.true;
});
it('unsubscribes an email from notifications', async () => {
let code = encrypt(JSON.stringify({
const code = encrypt(JSON.stringify({
email: testEmail,
}));
let unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
const unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
expect(unsubscribedMessage).to.equal('<h1>Unsubscribed successfully!</h1> You won\'t receive any other email from Habitica.');
});
it('returns okay when email is already unsubscribed', async () => {
let code = encrypt(JSON.stringify({
const code = encrypt(JSON.stringify({
email: testEmail,
}));
let unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
const unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
expect(unsubscribedMessage).to.equal('<h1>Unsubscribed successfully!</h1> You won\'t receive any other email from Habitica.');
});

4
test/api/v3/integration/groups/GET-group-plans.test.js
View File

@@ -8,7 +8,7 @@ describe('GET /group-plans', () => {
let groupPlan;
before(async () => {
user = await generateUser({balance: 4});
user = await generateUser({ balance: 4 });
groupPlan = await generateGroup(user,
{
name: 'public guild - is member',
@@ -25,7 +25,7 @@ describe('GET /group-plans', () => {
});
it('returns group plans for the user', async () => {
let groupPlans = await user.get('/group-plans');
const groupPlans = await user.get('/group-plans');
expect(groupPlans[0]._id).to.eql(groupPlan._id);
});

47
test/api/v3/integration/groups/GET-groups.test.js
View File

@@ -16,7 +16,7 @@ describe('GET /groups', () => {
const NUMBER_OF_USERS_PRIVATE_GUILDS = 1;
const NUMBER_OF_GROUPS_USER_CAN_VIEW = 5;
const GUILD_PER_PAGE = 30;
let categories = [{
const categories = [{
slug: 'newCat',
name: 'New Category',
}];
@@ -26,15 +26,15 @@ describe('GET /groups', () => {
before(async () => {
await resetHabiticaDB();
let leader = await generateUser({ balance: 10 });
user = await generateUser({balance: 4});
const leader = await generateUser({ balance: 10 });
user = await generateUser({ balance: 4 });
let publicGuildUserIsMemberOf = await generateGroup(leader, {
const publicGuildUserIsMemberOf = await generateGroup(leader, {
name: 'public guild - is member',
type: 'guild',
privacy: 'public',
});
await leader.post(`/groups/${publicGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
await leader.post(`/groups/${publicGuildUserIsMemberOf._id}/invite`, { uuids: [user._id] });
await user.post(`/groups/${publicGuildUserIsMemberOf._id}/join`);
publicGuildNotMember = await generateGroup(leader, {
@@ -50,7 +50,7 @@ describe('GET /groups', () => {
privacy: 'private',
categories,
});
await leader.post(`/groups/${privateGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
await leader.post(`/groups/${privateGuildUserIsMemberOf._id}/invite`, { uuids: [user._id] });
await user.post(`/groups/${privateGuildUserIsMemberOf._id}/join`);
await generateGroup(leader, {
@@ -110,13 +110,13 @@ describe('GET /groups', () => {
describe('filters', () => {
it('returns public guilds filtered by category', async () => {
let guilds = await user.get(`/groups?type=publicGuilds&categories=${categories[0].slug}`);
const guilds = await user.get(`/groups?type=publicGuilds&categories=${categories[0].slug}`);
expect(guilds[0]._id).to.equal(publicGuildNotMember._id);
});
it('returns private guilds filtered by category', async () => {
let guilds = await user.get(`/groups?type=privateGuilds&categories=${categories[0].slug}`);
const guilds = await user.get(`/groups?type=privateGuilds&categories=${categories[0].slug}`);
expect(guilds[0]._id).to.equal(privateGuildUserIsMemberOf._id);
});
@@ -131,7 +131,7 @@ describe('GET /groups', () => {
// @TODO: anyway to set higher memberCount in tests right now?
let guilds = await user.get('/groups?type=publicGuilds&minMemberCount=3');
const guilds = await user.get('/groups?type=publicGuilds&minMemberCount=3');
expect(guilds.length).to.equal(0);
});
@@ -146,7 +146,7 @@ describe('GET /groups', () => {
// @TODO: anyway to set higher memberCount in tests right now?
let guilds = await user.get('/groups?type=privateGuilds&minMemberCount=3');
const guilds = await user.get('/groups?type=privateGuilds&minMemberCount=3');
expect(guilds.length).to.equal(0);
});
@@ -181,26 +181,24 @@ describe('GET /groups', () => {
});
it('returns 30 guilds per page ordered by number of members', async () => {
await user.update({balance: 9000});
let groups = await Promise.all(_.times(60, (i) => {
return generateGroup(user, {
name: `public guild ${i} - is member`,
type: 'guild',
privacy: 'public',
});
}));
await user.update({ balance: 9000 });
const groups = await Promise.all(_.times(60, i => generateGroup(user, {
name: `public guild ${i} - is member`,
type: 'guild',
privacy: 'public',
})));
// update group number 32 and not the first to make sure sorting works
await groups[32].update({name: 'guild with most members', memberCount: 199});
await groups[33].update({name: 'guild with less members', memberCount: -100});
await groups[32].update({ name: 'guild with most members', memberCount: 199 });
await groups[33].update({ name: 'guild with less members', memberCount: -100 });
let page0 = await expect(user.get('/groups?type=publicGuilds&paginate=true'))
const page0 = await expect(user.get('/groups?type=publicGuilds&paginate=true'))
.to.eventually.have.a.lengthOf(GUILD_PER_PAGE);
expect(page0[0].name).to.equal('guild with most members');
await expect(user.get('/groups?type=publicGuilds&paginate=true&page=1'))
.to.eventually.have.a.lengthOf(GUILD_PER_PAGE);
let page2 = await expect(user.get('/groups?type=publicGuilds&paginate=true&page=2'))
const page2 = await expect(user.get('/groups?type=publicGuilds&paginate=true&page=2'))
.to.eventually.have.a.lengthOf(1 + 4); // 1 created now, 4 by other tests
expect(page2[4].name).to.equal('guild with less members');
}).timeout(10000);
@@ -208,7 +206,8 @@ describe('GET /groups', () => {
it('returns all the user\'s guilds when guilds passed in as query', async () => {
await expect(user.get('/groups?type=guilds'))
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER + NUMBER_OF_USERS_PRIVATE_GUILDS);
.to.eventually.have.a
.lengthOf(NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER + NUMBER_OF_USERS_PRIVATE_GUILDS);
});
it('returns all private guilds user is a part of when privateGuilds passed in as query', async () => {
@@ -222,7 +221,7 @@ describe('GET /groups', () => {
});
it('returns a list of groups user has access to', async () => {
let group = await generateGroup(user, {
const group = await generateGroup(user, {
name: 'c++ coders',
type: 'guild',
privacy: 'public',

60
test/api/v3/integration/groups/GET-groups_groupId_invites.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /groups/:groupId/invites', () => {
let user;
@@ -29,8 +29,8 @@ describe('GET /groups/:groupId/invites', () => {
});
it('fails if user doesn\'t have access to the group', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let anotherUser = await generateUser();
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const anotherUser = await generateUser();
await expect(anotherUser.get(`/groups/${group._id}/invites`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -39,17 +39,17 @@ describe('GET /groups/:groupId/invites', () => {
});
it('works when passing party as req.params.groupId', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, {uuids: [invited._id]});
let res = await user.get('/groups/party/invites');
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, { uuids: [invited._id] });
const res = await user.get('/groups/party/invites');
expect(res).to.be.an('array');
expect(res.length).to.equal(1);
expect(res[0]).to.eql({
_id: invited._id,
id: invited._id,
profile: {name: invited.profile.name},
profile: { name: invited.profile.name },
auth: {
local: {
username: invited.auth.local.username,
@@ -62,26 +62,26 @@ describe('GET /groups/:groupId/invites', () => {
});
it('populates only some fields', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, {uuids: [invited._id]});
let res = await user.get('/groups/party/invites');
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, { uuids: [invited._id] });
const res = await user.get('/groups/party/invites');
expect(res[0]).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('returns only first 30 invites', async () => {
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
const leader = await generateUser({ balance: 4 });
const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
let invitesToGenerate = [];
for (let i = 0; i < 31; i++) {
const invitesToGenerate = [];
for (let i = 0; i < 31; i += 1) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate);
await leader.post(`/groups/${group._id}/invite`, {uuids: generatedInvites.map(invite => invite._id)});
const generatedInvites = await Promise.all(invitesToGenerate);
await leader.post(`/groups/${group._id}/invite`, { uuids: generatedInvites.map(invite => invite._id) });
let res = await leader.get(`/groups/${group._id}/invites`);
const res = await leader.get(`/groups/${group._id}/invites`);
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -89,25 +89,25 @@ describe('GET /groups/:groupId/invites', () => {
});
}).timeout(10000);
it('supports using req.query.lastId to get more invites', async function () {
it('supports using req.query.lastId to get more invites', async function test () {
this.timeout(30000); // @TODO: times out after 8 seconds
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
const leader = await generateUser({ balance: 4 });
const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
let invitesToGenerate = [];
for (let i = 0; i < 32; i++) {
const invitesToGenerate = [];
for (let i = 0; i < 32; i += 1) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate); // Group has 32 invites
let expectedIds = generatedInvites.map(generatedInvite => generatedInvite._id);
await user.post(`/groups/${group._id}/invite`, {uuids: expectedIds});
const generatedInvites = await Promise.all(invitesToGenerate); // Group has 32 invites
const expectedIds = generatedInvites.map(generatedInvite => generatedInvite._id);
await user.post(`/groups/${group._id}/invite`, { uuids: expectedIds });
let res = await user.get(`/groups/${group._id}/invites`);
const res = await user.get(`/groups/${group._id}/invites`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/groups/${group._id}/invites?lastId=${res[res.length - 1]._id}`);
const res2 = await user.get(`/groups/${group._id}/invites?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(2);
let resIds = res.concat(res2).map(invite => invite._id);
const resIds = res.concat(res2).map(invite => invite._id);
expect(resIds).to.eql(expectedIds.sort());
});
});

81
test/api/v3/integration/groups/GET-groups_groupId_members.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import common from '../../../../../website/common';
describe('GET /groups/:groupId/members', () => {
@@ -12,8 +12,8 @@ describe('GET /groups/:groupId/members', () => {
beforeEach(async () => {
user = await generateUser({
balance: 10,
contributor: {level: 1},
backer: {tier: 3},
contributor: { level: 1 },
backer: { tier: 3 },
preferences: {
costume: false,
background: 'volcano',
@@ -38,8 +38,8 @@ describe('GET /groups/:groupId/members', () => {
});
it('fails if user doesn\'t have access to the group', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let anotherUser = await generateUser();
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
const anotherUser = await generateUser();
await expect(anotherUser.get(`/groups/${group._id}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -48,14 +48,14 @@ describe('GET /groups/:groupId/members', () => {
});
it('works when passing party as req.params.groupId', async () => {
await generateGroup(user, {type: 'party', name: generateUUID()});
let res = await user.get('/groups/party/members');
await generateGroup(user, { type: 'party', name: generateUUID() });
const res = await user.get('/groups/party/members');
expect(res).to.be.an('array');
expect(res.length).to.equal(1);
expect(res[0]).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
profile: { name: user.profile.name },
auth: {
local: {
username: user.auth.local.username,
@@ -68,15 +68,15 @@ describe('GET /groups/:groupId/members', () => {
});
it('populates only some fields', async () => {
await generateGroup(user, {type: 'party', name: generateUUID()});
let res = await user.get('/groups/party/members');
await generateGroup(user, { type: 'party', name: generateUUID() });
const res = await user.get('/groups/party/members');
expect(res[0]).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('req.query.includeAllPublicFields === true works with guilds', async () => {
let group = await generateGroup(user, {type: 'guild', name: generateUUID()});
let [memberRes] = await user.get(`/groups/${group._id}/members?includeAllPublicFields=true`);
const group = await generateGroup(user, { type: 'guild', name: generateUUID() });
const [memberRes] = await user.get(`/groups/${group._id}/members?includeAllPublicFields=true`);
expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'preferences', 'profile', 'stats', 'achievements', 'party',
@@ -96,8 +96,8 @@ describe('GET /groups/:groupId/members', () => {
});
it('populates all public fields if req.query.includeAllPublicFields === true and it is a party', async () => {
await generateGroup(user, {type: 'party', name: generateUUID()});
let [memberRes] = await user.get('/groups/party/members?includeAllPublicFields=true');
await generateGroup(user, { type: 'party', name: generateUUID() });
const [memberRes] = await user.get('/groups/party/members?includeAllPublicFields=true');
expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'preferences', 'profile', 'stats', 'achievements', 'party',
@@ -117,15 +117,15 @@ describe('GET /groups/:groupId/members', () => {
});
it('returns only first 30 members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({party: {_id: group._id}}));
const usersToGenerate = [];
for (let i = 0; i < 31; i += 1) {
usersToGenerate.push(generateUser({ party: { _id: group._id } }));
}
await Promise.all(usersToGenerate);
let res = await user.get('/groups/party/members');
const res = await user.get('/groups/party/members');
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -134,15 +134,15 @@ describe('GET /groups/:groupId/members', () => {
});
it('returns only first 30 members even when ?includeAllMembers=true', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({party: {_id: group._id}}));
const usersToGenerate = [];
for (let i = 0; i < 31; i += 1) {
usersToGenerate.push(generateUser({ party: { _id: group._id } }));
}
await Promise.all(usersToGenerate);
let res = await user.get('/groups/party/members?includeAllMembers=true');
const res = await user.get('/groups/party/members?includeAllMembers=true');
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'auth', 'flags', 'id', 'profile']);
@@ -150,38 +150,39 @@ describe('GET /groups/:groupId/members', () => {
});
});
it('supports using req.query.lastId to get more members', async function () {
it('supports using req.query.lastId to get more members', async function test () {
this.timeout(30000); // @TODO: times out after 8 seconds
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
const leader = await generateUser({ balance: 4 });
const group = await generateGroup(leader, { type: 'guild', privacy: 'public', name: generateUUID() });
let usersToGenerate = [];
for (let i = 0; i < 57; i++) {
usersToGenerate.push(generateUser({guilds: [group._id]}));
const usersToGenerate = [];
for (let i = 0; i < 57; i += 1) {
usersToGenerate.push(generateUser({ guilds: [group._id] }));
}
let generatedUsers = await Promise.all(usersToGenerate); // Group has 59 members (1 is the leader)
let expectedIds = [leader._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
// Group has 59 members (1 is the leader)
const generatedUsers = await Promise.all(usersToGenerate);
const expectedIds = [leader._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
let res = await user.get(`/groups/${group._id}/members`);
const res = await user.get(`/groups/${group._id}/members`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/groups/${group._id}/members?lastId=${res[res.length - 1]._id}`);
const res2 = await user.get(`/groups/${group._id}/members?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(28);
let resIds = res.concat(res2).map(member => member._id);
const resIds = res.concat(res2).map(member => member._id);
expect(resIds).to.eql(expectedIds.sort());
});
it('searches members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
const group = await generateGroup(user, { type: 'party', name: generateUUID() });
let usersToGenerate = [];
for (let i = 0; i < 2; i++) {
usersToGenerate.push(generateUser({party: {_id: group._id}}));
const usersToGenerate = [];
for (let i = 0; i < 2; i += 1) {
usersToGenerate.push(generateUser({ party: { _id: group._id } }));
}
const usersCreated = await Promise.all(usersToGenerate);
const userToSearch = usersCreated[0].profile.name;
let res = await user.get(`/groups/party/members?search=${userToSearch}`);
const res = await user.get(`/groups/party/members?search=${userToSearch}`);
expect(res.length).to.equal(1);
expect(res[0].profile.name).to.equal(userToSearch);
});

79
test/api/v3/integration/groups/GET-groups_id.test.js
View File

@@ -1,37 +1,38 @@
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import {
each,
} from 'lodash';
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('GET /groups/:id', () => {
let typesOfGroups = {};
const typesOfGroups = {};
typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
typesOfGroups.party = { type: 'party', privacy: 'private' };
each(typesOfGroups, (groupDetails, groupType) => {
context(`Member of a ${groupType}`, () => {
let leader, member, createdGroup;
let leader; let member; let
createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
members: 30,
groupDetails,
});
leader = groupData.groupLeader;
member = groupData.members[0];
member = groupData.members[0]; // eslint-disable-line prefer-destructuring
createdGroup = groupData.group;
});
it('returns the group object', async () => {
let group = await member.get(`/groups/${createdGroup._id}`);
const group = await member.get(`/groups/${createdGroup._id}`);
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
@@ -40,7 +41,7 @@ describe('GET /groups/:id', () => {
});
it('transforms leader id to leader object', async () => {
let group = await member.get(`/groups/${createdGroup._id}`);
const group = await member.get(`/groups/${createdGroup._id}`);
expect(group.leader._id).to.eql(leader._id);
expect(group.leader.profile.name).to.eql(leader.profile.name);
@@ -49,10 +50,11 @@ describe('GET /groups/:id', () => {
});
context('Non-member of a public guild', () => {
let nonMember, createdGroup;
let nonMember; let
createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test guild',
@@ -62,11 +64,11 @@ describe('GET /groups/:id', () => {
});
createdGroup = groupData.group;
nonMember = await generateUser();
nonMember = await generateUser();
});
it('returns the group object for a non-member', async () => {
let group = await nonMember.get(`/groups/${createdGroup._id}`);
const group = await nonMember.get(`/groups/${createdGroup._id}`);
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
@@ -76,10 +78,11 @@ describe('GET /groups/:id', () => {
});
context('Non-member of a private guild', () => {
let nonMember, createdGroup;
let nonMember; let
createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test guild',
@@ -103,10 +106,11 @@ describe('GET /groups/:id', () => {
});
context('Non-member of a party', () => {
let nonMember, createdGroup;
let nonMember; let
createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test party',
@@ -130,10 +134,11 @@ describe('GET /groups/:id', () => {
});
context('Member of a party', () => {
let member, createdGroup;
let member; let
createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test party',
@@ -143,11 +148,11 @@ describe('GET /groups/:id', () => {
});
createdGroup = groupData.group;
member = groupData.members[0];
member = groupData.members[0]; // eslint-disable-line prefer-destructuring
});
it('returns the user\'s party if an id of "party" is passed in', async () => {
let group = await member.get('/groups/party');
const group = await member.get('/groups/party');
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
@@ -173,7 +178,7 @@ describe('GET /groups/:id', () => {
});
it('removes non-existant guild from user\'s guild list', async () => {
let guildId = generateUUID();
const guildId = generateUUID();
await user.update({
guilds: [guildId, generateUUID()],
@@ -193,7 +198,7 @@ describe('GET /groups/:id', () => {
});
it('removes non-existant party from user\'s party object', async () => {
let partyId = generateUUID();
const partyId = generateUUID();
await user.update({
party: { _id: partyId },
@@ -215,20 +220,20 @@ describe('GET /groups/:id', () => {
context('Flagged messages', () => {
let group;
let chat1 = {
const chat1 = {
id: 'chat1',
text: 'chat 1',
flags: {},
};
let chat2 = {
const chat2 = {
id: 'chat2',
text: 'chat 2',
flags: {},
flagCount: 0,
};
let chat3 = {
const chat3 = {
id: 'chat3',
text: 'chat 3',
flags: {
@@ -237,7 +242,7 @@ describe('GET /groups/:id', () => {
flagCount: 1,
};
let chat4 = {
const chat4 = {
id: 'chat4',
text: 'chat 4',
flags: {
@@ -247,7 +252,7 @@ describe('GET /groups/:id', () => {
flagCount: 2,
};
let chat5 = {
const chat5 = {
id: 'chat5',
text: 'chat 5',
flags: {
@@ -259,7 +264,7 @@ describe('GET /groups/:id', () => {
};
beforeEach(async () => {
let groupData = await createAndPopulateGroup({
const groupData = await createAndPopulateGroup({
groupDetails: {
name: 'test guild',
type: 'guild',
@@ -287,7 +292,7 @@ describe('GET /groups/:id', () => {
});
it('does not include messages with a flag count of 2 or greater', async () => {
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
const fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
expect(fetchedGroup.chat).to.have.lengthOf(3);
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
@@ -296,8 +301,8 @@ describe('GET /groups/:id', () => {
});
it('does not include user ids in flags object', async () => {
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
let chatWithOneFlag = fetchedGroup.chat[2];
const fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
const chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true });
@@ -315,7 +320,7 @@ describe('GET /groups/:id', () => {
});
it('includes all messages', async () => {
let fetchedGroup = await admin.get(`/groups/${group._id}`);
const fetchedGroup = await admin.get(`/groups/${group._id}`);
expect(fetchedGroup.chat).to.have.lengthOf(5);
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
@@ -326,8 +331,8 @@ describe('GET /groups/:id', () => {
});
it('includes user ids in flags object', async () => {
let fetchedGroup = await admin.get(`/groups/${group._id}`);
let chatWithOneFlag = fetchedGroup.chat[2];
const fetchedGroup = await admin.get(`/groups/${group._id}`);
const chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true });

25
test/api/v3/integration/groups/POST-group_remove_manager.test.js
View File

@@ -1,13 +1,14 @@
import { find } from 'lodash';
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { find } from 'lodash';
describe('POST /group/:groupId/remove-manager', () => {
let leader, nonLeader, groupToUpdate;
let groupName = 'Test Public Guild';
let groupType = 'guild';
let leader; let nonLeader; let
groupToUpdate;
const groupName = 'Test Public Guild';
const groupType = 'guild';
let nonManager;
function findAssignedTask (memberTask) {
@@ -15,7 +16,7 @@ describe('POST /group/:groupId/remove-manager', () => {
}
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: groupName,
type: groupType,
@@ -26,8 +27,8 @@ describe('POST /group/:groupId/remove-manager', () => {
groupToUpdate = group;
leader = groupLeader;
nonLeader = members[0];
nonManager = members[1];
nonLeader = members[0]; // eslint-disable-line prefer-destructuring
nonManager = members[1]; // eslint-disable-line prefer-destructuring
});
it('returns an error when a non group leader tries to add member', async () => {
@@ -55,7 +56,7 @@ describe('POST /group/:groupId/remove-manager', () => {
managerId: nonLeader._id,
});
let updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/remove-manager`, {
const updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/remove-manager`, {
managerId: nonLeader._id,
});
@@ -66,14 +67,14 @@ describe('POST /group/:groupId/remove-manager', () => {
await leader.post(`/groups/${groupToUpdate._id}/add-manager`, {
managerId: nonLeader._id,
});
let task = await leader.post(`/tasks/group/${groupToUpdate._id}`, {
const task = await leader.post(`/tasks/group/${groupToUpdate._id}`, {
text: 'test todo',
type: 'todo',
requiresApproval: true,
});
await nonLeader.post(`/tasks/${task._id}/assign/${nonManager._id}`);
let memberTasks = await nonManager.get('/tasks/user');
let syncedTask = find(memberTasks, findAssignedTask);
const memberTasks = await nonManager.get('/tasks/user');
const syncedTask = find(memberTasks, findAssignedTask);
await expect(nonManager.post(`/tasks/${syncedTask._id}/score/up`))
.to.eventually.be.rejected.and.to.eql({
code: 401,
@@ -81,7 +82,7 @@ describe('POST /group/:groupId/remove-manager', () => {
message: t('taskApprovalHasBeenRequested'),
});
let updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/remove-manager`, {
const updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/remove-manager`, {
managerId: nonLeader._id,
});

56
test/api/v3/integration/groups/POST-groups.test.js
View File

@@ -13,7 +13,7 @@ describe('POST /group', () => {
context('All Groups', () => {
it('it returns validation error when type is not provided', async () => {
await expect(
user.post('/groups', { name: 'Test Group Without Type' })
user.post('/groups', { name: 'Test Group Without Type' }),
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -23,7 +23,7 @@ describe('POST /group', () => {
it('it returns validation error when type is not supported', async () => {
await expect(
user.post('/groups', { name: 'Group with unsupported type', type: 'foo' })
user.post('/groups', { name: 'Group with unsupported type', type: 'foo' }),
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -32,7 +32,7 @@ describe('POST /group', () => {
});
it('sets the group leader to the user who created the group', async () => {
let group = await user.post('/groups', {
const group = await user.post('/groups', {
name: 'Test Public Guild',
type: 'guild',
});
@@ -80,7 +80,7 @@ describe('POST /group', () => {
user.post('/groups', {
name: 'Test Public Guild',
type: 'guild',
})
}),
).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
@@ -89,13 +89,13 @@ describe('POST /group', () => {
});
it('adds guild to user\'s list of guilds', async () => {
let guild = await user.post('/groups', {
const guild = await user.post('/groups', {
name: 'some guild',
type: 'guild',
privacy: 'public',
});
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.guilds).to.include(guild._id);
});
@@ -107,18 +107,18 @@ describe('POST /group', () => {
privacy: 'public',
});
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.achievements.joinedGuild).to.eql(true);
});
context('public guild', () => {
it('creates a group', async () => {
let groupName = 'Test Public Guild';
let groupType = 'guild';
let groupPrivacy = 'public';
const groupName = 'Test Public Guild';
const groupType = 'guild';
const groupPrivacy = 'public';
let publicGuild = await user.post('/groups', {
const publicGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
@@ -145,7 +145,7 @@ describe('POST /group', () => {
name: 'Test Public Guild',
type: 'guild',
privacy: 'public',
})
}),
).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
@@ -155,12 +155,12 @@ describe('POST /group', () => {
});
context('private guild', () => {
let groupName = 'Test Private Guild';
let groupType = 'guild';
let groupPrivacy = 'private';
const groupName = 'Test Private Guild';
const groupType = 'guild';
const groupPrivacy = 'private';
it('creates a group', async () => {
let privateGuild = await user.post('/groups', {
const privateGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
@@ -181,7 +181,7 @@ describe('POST /group', () => {
it('creates a private guild when the user has no chat privileges', async () => {
await user.update({ 'flags.chatRevoked': true });
let privateGuild = await user.post('/groups', {
const privateGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
@@ -191,7 +191,7 @@ describe('POST /group', () => {
});
it('deducts gems from user and adds them to guild bank', async () => {
let privateGuild = await user.post('/groups', {
const privateGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
@@ -199,7 +199,7 @@ describe('POST /group', () => {
expect(privateGuild.balance).to.eql(1);
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.balance).to.eql(user.balance - 1);
});
@@ -207,11 +207,11 @@ describe('POST /group', () => {
});
context('Parties', () => {
let partyName = 'Test Party';
let partyType = 'party';
const partyName = 'Test Party';
const partyType = 'party';
it('creates a party', async () => {
let party = await user.post('/groups', {
const party = await user.post('/groups', {
name: partyName,
type: partyType,
});
@@ -230,7 +230,7 @@ describe('POST /group', () => {
it('creates a party when the user has no chat privileges', async () => {
await user.update({ 'flags.chatRevoked': true });
let party = await user.post('/groups', {
const party = await user.post('/groups', {
name: partyName,
type: partyType,
});
@@ -241,25 +241,25 @@ describe('POST /group', () => {
it('does not require gems to create a party', async () => {
await user.update({ balance: 0 });
let party = await user.post('/groups', {
const party = await user.post('/groups', {
name: partyName,
type: partyType,
});
expect(party._id).to.exist;
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.balance).to.eql(user.balance);
});
it('sets party id on user object', async () => {
let party = await user.post('/groups', {
const party = await user.post('/groups', {
name: partyName,
type: partyType,
});
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.party._id).to.eql(party._id);
});
@@ -270,7 +270,7 @@ describe('POST /group', () => {
type: partyType,
});
let updatedUser = await user.get('/user');
const updatedUser = await user.get('/user');
expect(updatedUser.achievements.partyUp).to.not.eql(true);
});

62
test/api/v3/integration/groups/POST-groups_groupId_join.test.js
View File

@@ -1,16 +1,16 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
createAndPopulateGroup,
checkExistence,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /group/:groupId/join', () => {
const PET_QUEST = 'whale';
it('returns error when groupId is not for a valid group', async () => {
let joiningUser = await generateUser();
const joiningUser = await generateUser();
await expect(joiningUser.post(`/groups/${generateUUID()}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -20,10 +20,11 @@ describe('POST /group/:groupId/join', () => {
});
context('Joining a public guild', () => {
let user, joiningUser, publicGuild;
let user; let joiningUser; let
publicGuild;
beforeEach(async () => {
let {group, groupLeader} = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -37,7 +38,7 @@ describe('POST /group/:groupId/join', () => {
});
it('allows non-invited users to join public guilds', async () => {
let res = await joiningUser.post(`/groups/${publicGuild._id}/join`);
const res = await joiningUser.post(`/groups/${publicGuild._id}/join`);
await expect(joiningUser.get('/user')).to.eventually.have.property('guilds').to.include(publicGuild._id);
expect(res.leader._id).to.eql(user._id);
@@ -62,7 +63,7 @@ describe('POST /group/:groupId/join', () => {
});
it('increments memberCount when joining guilds', async () => {
let oldMemberCount = publicGuild.memberCount;
const oldMemberCount = publicGuild.memberCount;
await joiningUser.post(`/groups/${publicGuild._id}/join`);
@@ -77,10 +78,11 @@ describe('POST /group/:groupId/join', () => {
});
context('Joining a private guild', () => {
let user, invitedUser, guild;
let user; let invitedUser; let
guild;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
const { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -91,11 +93,11 @@ describe('POST /group/:groupId/join', () => {
guild = group;
user = groupLeader;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('returns error when user is not invited to private guild', async () => {
let userWithoutInvite = await generateUser();
const userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${guild._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -116,11 +118,11 @@ describe('POST /group/:groupId/join', () => {
await expect(invitedUser.get('/user'))
.to.eventually.have.nested.property('invitations.guilds')
.to.not.include({id: guild._id});
.to.not.include({ id: guild._id });
});
it('increments memberCount when joining guilds', async () => {
let oldMemberCount = guild.memberCount;
const oldMemberCount = guild.memberCount;
await invitedUser.post(`/groups/${guild._id}/join`);
@@ -144,8 +146,8 @@ describe('POST /group/:groupId/join', () => {
it('notifies inviting user that their invitation was accepted', async () => {
await invitedUser.post(`/groups/${guild._id}/join`);
let inviter = await user.get('/user');
let expectedData = {
const inviter = await user.get('/user');
const expectedData = {
headerText: t('invitationAcceptedHeader'),
bodyText: t('invitationAcceptedBody', {
username: invitedUser.auth.local.username,
@@ -166,10 +168,11 @@ describe('POST /group/:groupId/join', () => {
});
context('Joining a party', () => {
let user, invitedUser, party;
let user; let invitedUser; let
party;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
const { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -180,11 +183,11 @@ describe('POST /group/:groupId/join', () => {
party = group;
user = groupLeader;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('returns error when user is not invited to party', async () => {
let userWithoutInvite = await generateUser();
const userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${party._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -203,9 +206,9 @@ describe('POST /group/:groupId/join', () => {
it('notifies inviting user that their invitation was accepted', async () => {
await invitedUser.post(`/groups/${party._id}/join`);
let inviter = await user.get('/user');
const inviter = await user.get('/user');
let expectedData = {
const expectedData = {
headerText: t('invitationAcceptedHeader'),
bodyText: t('invitationAcceptedBody', {
username: invitedUser.auth.local.username,
@@ -224,7 +227,7 @@ describe('POST /group/:groupId/join', () => {
});
it('increments memberCount when joining party', async () => {
let oldMemberCount = party.memberCount;
const oldMemberCount = party.memberCount;
await invitedUser.post(`/groups/${party._id}/join`);
@@ -238,7 +241,7 @@ describe('POST /group/:groupId/join', () => {
});
it('increments basilist quest item count to inviter when joining a party', async () => {
await user.update({'items.quests.basilist': 1 });
await user.update({ 'items.quests.basilist': 1 });
await invitedUser.post(`/groups/${party._id}/join`);
@@ -246,8 +249,8 @@ describe('POST /group/:groupId/join', () => {
});
it('deletes previous party where the user was the only member', async () => {
let userToInvite = await generateUser();
let oldParty = await userToInvite.post('/groups', { // add user to a party
const userToInvite = await generateUser();
const oldParty = await userToInvite.post('/groups', { // add user to a party
name: 'Another Test Party',
type: 'party',
});
@@ -263,8 +266,8 @@ describe('POST /group/:groupId/join', () => {
});
it('does not allow user to leave a party if a quest was active and they were the only member', async () => {
let userToInvite = await generateUser();
let oldParty = await userToInvite.post('/groups', { // add user to a party
const userToInvite = await generateUser();
const oldParty = await userToInvite.post('/groups', { // add user to a party
name: 'Another Test Party',
type: 'party',
});
@@ -305,7 +308,8 @@ describe('POST /group/:groupId/join', () => {
});
context('Party incentive achievements', () => {
let leader, member, party;
let leader; let member; let
party;
beforeEach(async () => {
leader = await generateUser();
@@ -337,8 +341,8 @@ describe('POST /group/:groupId/join', () => {
});
it('awards Party On achievement to party of size 4', async () => {
let addlMemberOne = await generateUser();
let addlMemberTwo = await generateUser();
const addlMemberOne = await generateUser();
const addlMemberTwo = await generateUser();
await leader.post(`/groups/${party._id}/invite`, {
uuids: [addlMemberOne._id, addlMemberTwo._id],
});

72
test/api/v3/integration/groups/POST-groups_groupId_leave.js
View File

@@ -1,3 +1,7 @@
import { v4 as generateUUID } from 'uuid';
import {
each,
} from 'lodash';
import {
generateChallenge,
checkExistence,
@@ -6,15 +10,11 @@ import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import {
each,
} from 'lodash';
import { model as User } from '../../../../../website/server/models/user';
import payments from '../../../../../website/server/libs/payments/payments';
describe('POST /groups/:groupId/leave', () => {
let typesOfGroups = {
const typesOfGroups = {
'public guild': { type: 'guild', privacy: 'public' },
'private guild': { type: 'guild', privacy: 'private' },
party: { type: 'party', privacy: 'private' },
@@ -28,19 +28,19 @@ describe('POST /groups/:groupId/leave', () => {
let memberCount;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails,
members: 1,
});
groupToLeave = group;
leader = groupLeader;
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
memberCount = group.memberCount;
});
it('prevents non members from leaving', async () => {
let user = await generateUser();
const user = await generateUser();
await expect(user.post(`/groups/${groupToLeave._id}/leave`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -51,7 +51,7 @@ describe('POST /groups/:groupId/leave', () => {
it(`lets user leave a ${groupType}`, async () => {
await member.post(`/groups/${groupToLeave._id}/leave`);
let userThatLeftGroup = await member.get('/user');
const userThatLeftGroup = await member.get('/user');
expect(userThatLeftGroup.guilds).to.be.empty;
expect(userThatLeftGroup.party._id).to.not.exist;
@@ -74,17 +74,13 @@ describe('POST /groups/:groupId/leave', () => {
await leader.sync();
expect(leader.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id;
})).to.exist;
expect(leader.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.exist;
expect(leader.newMessages[groupToLeave._id]).to.not.be.empty;
await leader.post(`/groups/${groupToLeave._id}/leave`);
await leader.sync();
expect(leader.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id;
})).to.not.exist;
expect(leader.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupToLeave._id)).to.not.exist;
expect(leader.newMessages[groupToLeave._id]).to.be.undefined;
});
@@ -106,7 +102,7 @@ describe('POST /groups/:groupId/leave', () => {
it('removes all challenge tasks when keep parameter is set to remove', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave?keep=remove-all`);
let userWithoutChallengeTasks = await leader.get('/user');
const userWithoutChallengeTasks = await leader.get('/user');
expect(userWithoutChallengeTasks.challenges).to.not.include(challenge._id);
expect(userWithoutChallengeTasks.tasksOrder.habits).to.be.empty;
@@ -115,16 +111,16 @@ describe('POST /groups/:groupId/leave', () => {
it('keeps all challenge tasks when keep parameter is not set', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave`);
let userWithChallengeTasks = await leader.get('/user');
const userWithChallengeTasks = await leader.get('/user');
// @TODO find elegant way to assert against the task existing
expect(userWithChallengeTasks.tasksOrder.habits).to.not.be.empty;
});
it('keeps the user in the challenge when the keepChallenges parameter is set to remain-in-challenges', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave`, {keepChallenges: 'remain-in-challenges'});
await leader.post(`/groups/${groupToLeave._id}/leave`, { keepChallenges: 'remain-in-challenges' });
let userWithChallengeTasks = await leader.get('/user');
const userWithChallengeTasks = await leader.get('/user');
expect(userWithChallengeTasks.challenges).to.include(challenge._id);
});
@@ -132,7 +128,7 @@ describe('POST /groups/:groupId/leave', () => {
it('drops the user in the challenge when the keepChallenges parameter isn\'t set', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave`);
let userWithChallengeTasks = await leader.get('/user');
const userWithChallengeTasks = await leader.get('/user');
expect(userWithChallengeTasks.challenges).to.not.include(challenge._id);
});
@@ -150,7 +146,7 @@ describe('POST /groups/:groupId/leave', () => {
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
const { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Private Guild',
type: 'guild',
@@ -160,7 +156,7 @@ describe('POST /groups/:groupId/leave', () => {
privateGuild = group;
leader = groupLeader;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
await leader.post(`/groups/${group._id}/chat`, { message: 'Some message' });
});
@@ -174,7 +170,7 @@ describe('POST /groups/:groupId/leave', () => {
it('removes invitations when the last member leaves', async () => {
await leader.post(`/groups/${privateGuild._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
const userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.guilds).to.be.empty;
});
@@ -186,7 +182,7 @@ describe('POST /groups/:groupId/leave', () => {
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
const { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Public Guild',
type: 'guild',
@@ -197,7 +193,7 @@ describe('POST /groups/:groupId/leave', () => {
publicGuild = group;
leader = groupLeader;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('keeps the group when the last member leaves', async () => {
@@ -209,14 +205,14 @@ describe('POST /groups/:groupId/leave', () => {
it('keeps the invitations when the last member leaves a public guild', async () => {
await leader.post(`/groups/${publicGuild._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
const userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.guilds).to.not.be.empty;
});
it('deletes non existant guild from user when user tries to leave', async () => {
let nonExistentGuildId = generateUUID();
let userWithNonExistentGuild = await generateUser({guilds: [nonExistentGuildId]});
const nonExistentGuildId = generateUUID();
const userWithNonExistentGuild = await generateUser({ guilds: [nonExistentGuildId] });
expect(userWithNonExistentGuild.guilds).to.contain(nonExistentGuildId);
await expect(userWithNonExistentGuild.post(`/groups/${nonExistentGuildId}/leave`))
@@ -234,7 +230,7 @@ describe('POST /groups/:groupId/leave', () => {
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
const { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -244,7 +240,7 @@ describe('POST /groups/:groupId/leave', () => {
party = group;
leader = groupLeader;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('removes a group when the last member leaves a party', async () => {
@@ -256,15 +252,15 @@ describe('POST /groups/:groupId/leave', () => {
it('removes invitations when the last member leaves a party', async () => {
await leader.post(`/groups/${party._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
const userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.parties[0]).to.be.undefined;
});
});
it('deletes non existant party from user when user tries to leave', async () => {
let nonExistentPartyId = generateUUID();
let userWithNonExistentParty = await generateUser({'party._id': nonExistentPartyId});
const nonExistentPartyId = generateUUID();
const userWithNonExistentParty = await generateUser({ 'party._id': nonExistentPartyId });
expect(userWithNonExistentParty.party._id).to.eql(nonExistentPartyId);
await expect(userWithNonExistentParty.post(`/groups/${nonExistentPartyId}/leave`))
@@ -283,17 +279,17 @@ describe('POST /groups/:groupId/leave', () => {
let member;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails,
members: 1,
});
leader = groupLeader;
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
groupWithPlan = group;
let userWithFreePlan = await User.findById(leader._id).exec();
const userWithFreePlan = await User.findById(leader._id).exec();
// Create subscription
let paymentData = {
const paymentData = {
user: userWithFreePlan,
groupId: groupWithPlan._id,
sub: {
@@ -322,7 +318,7 @@ describe('POST /groups/:groupId/leave', () => {
it('preserves the free subscription when leaving a any other group without a plan', async () => {
// Joining a guild without a group plan
let { group: groupWithNoPlan } = await createAndPopulateGroup({
const { group: groupWithNoPlan } = await createAndPopulateGroup({
groupDetails: {
name: 'Group Without Plan',
type: 'guild',

31
test/api/v3/integration/groups/POST-groups_groupId_reject.test.js
View File

@@ -6,10 +6,11 @@ import {
describe('POST /group/:groupId/reject-invite', () => {
context('Rejecting a public guild invite', () => {
let publicGuild, invitedUser;
let publicGuild; let
invitedUser;
beforeEach(async () => {
let {group, invitees} = await createAndPopulateGroup({
const { group, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -19,11 +20,11 @@ describe('POST /group/:groupId/reject-invite', () => {
});
publicGuild = group;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
const userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${publicGuild._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -37,15 +38,16 @@ describe('POST /group/:groupId/reject-invite', () => {
await expect(invitedUser.get('/user'))
.to.eventually.have.nested.property('invitations.guilds')
.to.not.include({id: publicGuild._id});
.to.not.include({ id: publicGuild._id });
});
});
context('Rejecting a private guild invite', () => {
let invitedUser, guild;
let invitedUser; let
guild;
beforeEach(async () => {
let { group, invitees } = await createAndPopulateGroup({
const { group, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -55,11 +57,11 @@ describe('POST /group/:groupId/reject-invite', () => {
});
guild = group;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
const userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${guild._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -73,15 +75,16 @@ describe('POST /group/:groupId/reject-invite', () => {
await expect(invitedUser.get('/user'))
.to.eventually.have.nested.property('invitations.guilds')
.to.not.include({id: guild._id});
.to.not.include({ id: guild._id });
});
});
context('Rejecting a party invite', () => {
let invitedUser, party;
let invitedUser; let
party;
beforeEach(async () => {
let { group, invitees } = await createAndPopulateGroup({
const { group, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -91,11 +94,11 @@ describe('POST /group/:groupId/reject-invite', () => {
});
party = group;
invitedUser = invitees[0];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
const userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${party._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,

50
test/api/v3/integration/groups/POST-groups_id_removeMember.test.js
View File

@@ -15,7 +15,9 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
let adminUser;
beforeEach(async () => {
let { group, groupLeader, invitees, members } = await createAndPopulateGroup({
const {
group, groupLeader, invitees, members,
} = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -27,15 +29,15 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
guild = group;
leader = groupLeader;
invitedUser = invitees[0];
member = members[0];
member2 = members[1];
invitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
member = members[0]; // eslint-disable-line prefer-destructuring
member2 = members[1]; // eslint-disable-line prefer-destructuring
adminUser = await generateUser({ 'contributor.admin': true });
});
context('All Groups', () => {
it('returns an error when user is not member of the group', async () => {
let nonMember = await generateUser();
const nonMember = await generateUser();
expect(nonMember.post(`/groups/${guild._id}/removeMember/${member._id}`))
.to.eventually.be.rejected.and.eql({
@@ -74,13 +76,13 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
it('can remove other members', async () => {
await leader.post(`/groups/${guild._id}/removeMember/${member._id}`);
let memberRemoved = await member.get('/user');
const memberRemoved = await member.get('/user');
expect(memberRemoved.guilds.indexOf(guild._id)).eql(-1);
});
it('updates memberCount', async () => {
let oldMemberCount = guild.memberCount;
const oldMemberCount = guild.memberCount;
await leader.post(`/groups/${guild._id}/removeMember/${member._id}`);
await expect(leader.get(`/groups/${guild._id}`)).to.eventually.have.property('memberCount', oldMemberCount - 1);
});
@@ -88,14 +90,14 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
it('can remove other invites', async () => {
await leader.post(`/groups/${guild._id}/removeMember/${invitedUser._id}`);
let invitedUserWithoutInvite = await invitedUser.get('/user');
const invitedUserWithoutInvite = await invitedUser.get('/user');
expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, { id: guild._id })).eql(-1);
});
it('allows an admin to remove other members', async () => {
await adminUser.post(`/groups/${guild._id}/removeMember/${member._id}`);
let memberRemoved = await member.get('/user');
const memberRemoved = await member.get('/user');
expect(memberRemoved.guilds.indexOf(guild._id)).eql(-1);
});
@@ -103,7 +105,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
it('allows an admin to remove other invites', async () => {
await adminUser.post(`/groups/${guild._id}/removeMember/${invitedUser._id}`);
let invitedUserWithoutInvite = await invitedUser.get('/user');
const invitedUserWithoutInvite = await invitedUser.get('/user');
expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, { id: guild._id })).eql(-1);
});
@@ -141,7 +143,9 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
let removedMember;
beforeEach(async () => {
let { group, groupLeader, invitees, members } = await createAndPopulateGroup({
const {
group, groupLeader, invitees, members,
} = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -153,9 +157,9 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
party = group;
partyLeader = groupLeader;
partyInvitedUser = invitees[0];
partyMember = members[0];
removedMember = members[1];
partyInvitedUser = invitees[0]; // eslint-disable-line prefer-destructuring
partyMember = members[0]; // eslint-disable-line prefer-destructuring
removedMember = members[1]; // eslint-disable-line prefer-destructuring
sandbox.spy(email, 'sendTxn');
});
@@ -166,13 +170,13 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
it('can remove other members', async () => {
await partyLeader.post(`/groups/${party._id}/removeMember/${partyMember._id}`);
let memberRemoved = await partyMember.get('/user');
const memberRemoved = await partyMember.get('/user');
expect(memberRemoved.party._id).eql(undefined);
});
it('updates memberCount', async () => {
let oldMemberCount = party.memberCount;
const oldMemberCount = party.memberCount;
await partyLeader.post(`/groups/${party._id}/removeMember/${partyMember._id}`);
await expect(partyLeader.get(`/groups/${party._id}`)).to.eventually.have.property('memberCount', oldMemberCount - 1);
});
@@ -182,7 +186,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
await partyLeader.post(`/groups/${party._id}/removeMember/${partyInvitedUser._id}`);
let invitedUserWithoutInvite = await partyInvitedUser.get('/user');
const invitedUserWithoutInvite = await partyInvitedUser.get('/user');
expect(invitedUserWithoutInvite.invitations.parties[0]).to.be.undefined;
});
@@ -192,22 +196,18 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
await sleep(0.5);
await removedMember.sync();
expect(removedMember.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === party._id;
})).to.exist;
expect(removedMember.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === party._id)).to.exist;
expect(removedMember.newMessages[party._id]).to.not.be.empty;
await partyLeader.post(`/groups/${party._id}/removeMember/${removedMember._id}`);
await removedMember.sync();
expect(removedMember.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === party._id;
})).to.not.exist;
expect(removedMember.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === party._id)).to.not.exist;
expect(removedMember.newMessages[party._id]).to.be.undefined;
});
it('removes user from quest when removing user from party after quest starts', async () => {
let petQuest = 'whale';
const petQuest = 'whale';
await partyLeader.update({
[`items.quests.${petQuest}`]: 1,
});
@@ -229,7 +229,7 @@ describe('POST /groups/:groupId/removeMember/:memberId', () => {
});
it('removes user from quest when removing user from party before quest starts', async () => {
let petQuest = 'whale';
const petQuest = 'whale';
await partyLeader.update({
[`items.quests.${petQuest}`]: 1,
});

161
test/api/v3/integration/groups/POST-groups_invite.test.js
View File

@@ -1,10 +1,10 @@
import { v4 as generateUUID } from 'uuid';
import nconf from 'nconf';
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import nconf from 'nconf';
const INVITES_LIMIT = 100;
const PARTY_LIMIT_MEMBERS = 30;
@@ -13,10 +13,10 @@ const MAX_EMAIL_INVITES_BY_USER = 200;
describe('Post /groups/:groupId/invite', () => {
let inviter;
let group;
let groupName = 'Test Public Guild';
const groupName = 'Test Public Guild';
beforeEach(async () => {
inviter = await generateUser({balance: 4});
inviter = await generateUser({ balance: 4 });
group = await inviter.post('/groups', {
name: groupName,
type: 'guild',
@@ -33,7 +33,7 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithUsernameNotFound', {username: fakeID}),
message: t('userWithUsernameNotFound', { username: fakeID }),
});
});
@@ -69,7 +69,10 @@ describe('Post /groups/:groupId/invite', () => {
const userToInvite2 = await generateUser();
await expect(inviter.post(`/groups/${group._id}/invite`, {
usernames: [userToInvite.auth.local.lowerCaseUsername, userToInvite2.auth.local.lowerCaseUsername],
usernames: [
userToInvite.auth.local.lowerCaseUsername,
userToInvite2.auth.local.lowerCaseUsername,
],
})).to.eventually.deep.equal([
{
id: group._id,
@@ -92,8 +95,8 @@ describe('Post /groups/:groupId/invite', () => {
describe('user id invites', () => {
it('returns an error when inviter has no chat privileges', async () => {
let inviterMuted = await inviter.update({'flags.chatRevoked': true});
let userToInvite = await generateUser();
const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
const userToInvite = await generateUser();
await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
}))
@@ -105,7 +108,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when invited user is not found', async () => {
let fakeID = generateUUID();
const fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [fakeID],
@@ -113,7 +116,7 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: fakeID}),
message: t('userWithIDNotFound', { userId: fakeID }),
});
});
@@ -129,10 +132,10 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when uuids is not an array', async () => {
let fakeID = generateUUID();
const fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: {fakeID},
uuids: { fakeID },
}))
.to.eventually.be.rejected.and.eql({
code: 400,
@@ -165,7 +168,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when there are more than INVITES_LIMIT uuids', async () => {
let uuids = [];
const uuids = [];
for (let i = 0; i < 101; i += 1) {
uuids.push(generateUUID());
@@ -177,13 +180,13 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
message: t('canOnlyInviteMaxInvites', { maxInvites: INVITES_LIMIT }),
});
});
it('returns error when recipient has blocked the senders', async () => {
const inviterNoBlocks = await inviter.update({'inbox.blocks': []});
let userWithBlockedInviter = await generateUser({'inbox.blocks': [inviter._id]});
const inviterNoBlocks = await inviter.update({ 'inbox.blocks': [] });
const userWithBlockedInviter = await generateUser({ 'inbox.blocks': [inviter._id] });
await expect(inviterNoBlocks.post(`/groups/${group._id}/invite`, {
uuids: [userWithBlockedInviter._id],
}))
@@ -195,7 +198,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('invites a user to a group by uuid', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
@@ -211,8 +214,8 @@ describe('Post /groups/:groupId/invite', () => {
});
it('invites multiple users to a group by uuid', async () => {
let userToInvite = await generateUser();
let userToInvite2 = await generateUser();
const userToInvite = await generateUser();
const userToInvite2 = await generateUser();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id, userToInvite2._id],
@@ -236,8 +239,8 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when inviting multiple users and a user is not found', async () => {
let userToInvite = await generateUser();
let fakeID = generateUUID();
const userToInvite = await generateUser();
const fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id, fakeID],
@@ -245,16 +248,16 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: fakeID}),
message: t('userWithIDNotFound', { userId: fakeID }),
});
});
});
describe('email invites', () => {
let testInvite = {name: 'test', email: 'test@habitica.com'};
const testInvite = { name: 'test', email: 'test@habitica.com' };
it('returns an error when inviter has no chat privileges', async () => {
let inviterMuted = await inviter.update({'flags.chatRevoked': true});
const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
emails: [testInvite],
inviter: 'inviter name',
@@ -268,7 +271,7 @@ describe('Post /groups/:groupId/invite', () => {
it('returns an error when invite is missing an email', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails: [{name: 'test'}],
emails: [{ name: 'test' }],
}))
.to.eventually.be.rejected.and.eql({
code: 400,
@@ -279,7 +282,7 @@ describe('Post /groups/:groupId/invite', () => {
it('returns an error when emails is not an array', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails: {testInvite},
emails: { testInvite },
}))
.to.eventually.be.rejected.and.eql({
code: 400,
@@ -300,7 +303,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when there are more than INVITES_LIMIT emails', async () => {
let emails = [];
const emails = [];
for (let i = 0; i < 101; i += 1) {
emails.push(`${generateUUID()}@habitica.com`);
@@ -312,16 +315,16 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
message: t('canOnlyInviteMaxInvites', { maxInvites: INVITES_LIMIT }),
});
});
it('returns an error when a user has sent the max number of email invites', async () => {
let inviterWithMax = await generateUser({
const inviterWithMax = await generateUser({
invitesSent: MAX_EMAIL_INVITES_BY_USER,
balance: 4,
});
let tmpGroup = await inviterWithMax.post('/groups', {
const tmpGroup = await inviterWithMax.post('/groups', {
name: groupName,
type: 'guild',
});
@@ -333,28 +336,28 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('inviteLimitReached', {techAssistanceEmail: nconf.get('EMAILS_TECH_ASSISTANCE_EMAIL')}),
message: t('inviteLimitReached', { techAssistanceEmail: nconf.get('EMAILS_TECH_ASSISTANCE_EMAIL') }),
});
});
it('invites a user to a group by email', async () => {
let res = await inviter.post(`/groups/${group._id}/invite`, {
const res = await inviter.post(`/groups/${group._id}/invite`, {
emails: [testInvite],
inviter: 'inviter name',
});
let updatedUser = await inviter.sync();
const updatedUser = await inviter.sync();
expect(res).to.exist;
expect(updatedUser.invitesSent).to.eql(1);
});
it('invites multiple users to a group by email', async () => {
let res = await inviter.post(`/groups/${group._id}/invite`, {
emails: [testInvite, {name: 'test2', email: 'test2@habitica.com'}],
const res = await inviter.post(`/groups/${group._id}/invite`, {
emails: [testInvite, { name: 'test2', email: 'test2@habitica.com' }],
});
let updatedUser = await inviter.sync();
const updatedUser = await inviter.sync();
expect(res).to.exist;
expect(updatedUser.invitesSent).to.eql(2);
@@ -372,8 +375,8 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when there are more than INVITES_LIMIT uuids and emails', async () => {
let emails = [];
let uuids = [];
const emails = [];
const uuids = [];
for (let i = 0; i < 50; i += 1) {
emails.push(`${generateUUID()}@habitica.com`);
@@ -390,35 +393,35 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
message: t('canOnlyInviteMaxInvites', { maxInvites: INVITES_LIMIT }),
});
});
it('invites users to a group by uuid and email', async () => {
let newUser = await generateUser();
let invite = await inviter.post(`/groups/${group._id}/invite`, {
const newUser = await generateUser();
const invite = await inviter.post(`/groups/${group._id}/invite`, {
uuids: [newUser._id],
emails: [{name: 'test', email: 'test@habitica.com'}],
emails: [{ name: 'test', email: 'test@habitica.com' }],
});
let invitedUser = await newUser.get('/user');
const invitedUser = await newUser.get('/user');
expect(invitedUser.invitations.guilds[0].id).to.equal(group._id);
expect(invite).to.exist;
});
it('invites marks invite with cancelled plan', async () => {
let cancelledPlanGroup = await generateGroup(inviter, {
const cancelledPlanGroup = await generateGroup(inviter, {
type: 'guild',
name: generateUUID(),
});
await cancelledPlanGroup.createCancelledSubscription();
let newUser = await generateUser();
let invite = await inviter.post(`/groups/${cancelledPlanGroup._id}/invite`, {
const newUser = await generateUser();
const invite = await inviter.post(`/groups/${cancelledPlanGroup._id}/invite`, {
uuids: [newUser._id],
emails: [{name: 'test', email: 'test@habitica.com'}],
emails: [{ name: 'test', email: 'test@habitica.com' }],
});
let invitedUser = await newUser.get('/user');
const invitedUser = await newUser.get('/user');
expect(invitedUser.invitations.guilds[0].id).to.equal(cancelledPlanGroup._id);
expect(invitedUser.invitations.guilds[0].cancelledPlan).to.be.true;
@@ -428,8 +431,8 @@ describe('Post /groups/:groupId/invite', () => {
describe('guild invites', () => {
it('returns an error when inviter has no chat privileges', async () => {
let inviterMuted = await inviter.update({'flags.chatRevoked': true});
let userToInvite = await generateUser();
const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
const userToInvite = await generateUser();
await expect(inviterMuted.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
}))
@@ -441,7 +444,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when invited user is already invited to the group', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
await inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
});
@@ -452,12 +455,12 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInvitedToGroup', { userId: userToInvite._id, username: userToInvite.profile.name}),
message: t('userAlreadyInvitedToGroup', { userId: userToInvite._id, username: userToInvite.profile.name }),
});
});
it('returns an error when invited user is already in the group', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
await inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
});
@@ -469,17 +472,17 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInGroup', { userId: userToInvite._id, username: userToInvite.profile.name}),
message: t('userAlreadyInGroup', { userId: userToInvite._id, username: userToInvite.profile.name }),
});
});
it('allows 30+ members in a guild', async () => {
let invitesToGenerate = [];
const invitesToGenerate = [];
// Generate 30 users to invite (30 + leader = 31 members)
for (let i = 0; i < PARTY_LIMIT_MEMBERS; i++) {
for (let i = 0; i < PARTY_LIMIT_MEMBERS; i += 1) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate);
const generatedInvites = await Promise.all(invitesToGenerate);
// Invite users
expect(await inviter.post(`/groups/${group._id}/invite`, {
uuids: generatedInvites.map(invite => invite._id),
@@ -488,9 +491,9 @@ describe('Post /groups/:groupId/invite', () => {
// @TODO: Add this after we are able to mock the group plan route
xit('returns an error when a non-leader invites to a group plan', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
let nonGroupLeader = await generateUser();
const nonGroupLeader = await generateUser();
await inviter.post(`/groups/${group._id}/invite`, {
uuids: [nonGroupLeader._id],
});
@@ -518,8 +521,8 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when inviter has no chat privileges', async () => {
let inviterMuted = await inviter.update({'flags.chatRevoked': true});
let userToInvite = await generateUser();
const inviterMuted = await inviter.update({ 'flags.chatRevoked': true });
const userToInvite = await generateUser();
await expect(inviterMuted.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
}))
@@ -531,7 +534,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('returns an error when invited user has a pending invitation to the party', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
await inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
});
@@ -542,13 +545,13 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyPendingInvitation', { userId: userToInvite._id, username: userToInvite.profile.name}),
message: t('userAlreadyPendingInvitation', { userId: userToInvite._id, username: userToInvite.profile.name }),
});
});
it('returns an error when invited user is already in a party of more than 1 member', async () => {
let userToInvite = await generateUser();
let userToInvite2 = await generateUser();
const userToInvite = await generateUser();
const userToInvite2 = await generateUser();
await inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id, userToInvite2._id],
});
@@ -561,12 +564,12 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInAParty', { userId: userToInvite._id, username: userToInvite.profile.name}),
message: t('userAlreadyInAParty', { userId: userToInvite._id, username: userToInvite.profile.name }),
});
});
it('allow inviting a user to a party if they are partying solo', async () => {
let userToInvite = await generateUser();
const userToInvite = await generateUser();
await userToInvite.post('/groups', { // add user to a party
name: 'Another Test Party',
type: 'party',
@@ -580,13 +583,13 @@ describe('Post /groups/:groupId/invite', () => {
it('allow inviting a user to 2 different parties', async () => {
// Create another inviter
let inviter2 = await generateUser();
const inviter2 = await generateUser();
// Create user to invite
let userToInvite = await generateUser();
const userToInvite = await generateUser();
// Create second group
let party2 = await inviter2.post('/groups', {
const party2 = await inviter2.post('/groups', {
name: 'Test Party 2',
type: 'party',
});
@@ -602,7 +605,7 @@ describe('Post /groups/:groupId/invite', () => {
});
// Get updated user
let invitedUser = await userToInvite.get('/user');
const invitedUser = await userToInvite.get('/user');
expect(invitedUser.invitations.parties.length).to.equal(2);
expect(invitedUser.invitations.parties[0].id).to.equal(party._id);
@@ -610,7 +613,7 @@ describe('Post /groups/:groupId/invite', () => {
});
it('allow inviting a user if party id is not associated with a real party', async () => {
let userToInvite = await generateUser({
const userToInvite = await generateUser({
party: { _id: generateUUID() },
});
@@ -621,12 +624,12 @@ describe('Post /groups/:groupId/invite', () => {
});
it('allows 30 members in a party', async () => {
let invitesToGenerate = [];
const invitesToGenerate = [];
// Generate 29 users to invite (29 + leader = 30 members)
for (let i = 0; i < PARTY_LIMIT_MEMBERS - 1; i++) {
for (let i = 0; i < PARTY_LIMIT_MEMBERS - 1; i += 1) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate);
const generatedInvites = await Promise.all(invitesToGenerate);
// Invite users
expect(await inviter.post(`/groups/${party._id}/invite`, {
uuids: generatedInvites.map(invite => invite._id),
@@ -634,12 +637,12 @@ describe('Post /groups/:groupId/invite', () => {
}).timeout(10000);
it('does not allow 30+ members in a party', async () => {
let invitesToGenerate = [];
const invitesToGenerate = [];
// Generate 30 users to invite (30 + leader = 31 members)
for (let i = 0; i < PARTY_LIMIT_MEMBERS; i++) {
for (let i = 0; i < PARTY_LIMIT_MEMBERS; i += 1) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate);
const generatedInvites = await Promise.all(invitesToGenerate);
// Invite users
await expect(inviter.post(`/groups/${party._id}/invite`, {
uuids: generatedInvites.map(invite => invite._id),
@@ -647,7 +650,7 @@ describe('Post /groups/:groupId/invite', () => {
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('partyExceedsMembersLimit', {maxMembersParty: PARTY_LIMIT_MEMBERS}),
message: t('partyExceedsMembersLimit', { maxMembersParty: PARTY_LIMIT_MEMBERS }),
});
}).timeout(10000);
});

22
test/api/v3/integration/groups/POST-groups_manager.test.js
View File

@@ -5,14 +5,15 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('POST /group/:groupId/add-manager', () => {
let leader, nonLeader, groupToUpdate;
let groupName = 'Test Public Guild';
let groupType = 'guild';
let leader; let nonLeader; let
groupToUpdate;
const groupName = 'Test Public Guild';
const groupType = 'guild';
let nonMember;
context('Guilds', () => {
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: groupName,
type: groupType,
@@ -23,7 +24,7 @@ describe('POST /group/:groupId/add-manager', () => {
groupToUpdate = group;
leader = groupLeader;
nonLeader = members[0];
nonLeader = members[0]; // eslint-disable-line prefer-destructuring
nonMember = await generateUser();
});
@@ -48,7 +49,7 @@ describe('POST /group/:groupId/add-manager', () => {
});
it('allows a leader to add managers', async () => {
let updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/add-manager`, {
const updatedGroup = await leader.post(`/groups/${groupToUpdate._id}/add-manager`, {
managerId: nonLeader._id,
});
@@ -57,10 +58,11 @@ describe('POST /group/:groupId/add-manager', () => {
});
context('Party', () => {
let party, partyLeader, partyNonLeader;
let party; let partyLeader; let
partyNonLeader;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: groupName,
type: 'party',
@@ -71,11 +73,11 @@ describe('POST /group/:groupId/add-manager', () => {
party = group;
partyLeader = groupLeader;
partyNonLeader = members[0];
partyNonLeader = members[0]; // eslint-disable-line prefer-destructuring
});
it('allows leader of party to add managers', async () => {
let updatedGroup = await partyLeader.post(`/groups/${party._id}/add-manager`, {
const updatedGroup = await partyLeader.post(`/groups/${party._id}/add-manager`, {
managerId: partyNonLeader._id,
});

23
test/api/v3/integration/groups/PUT-groups.test.js
View File

@@ -5,13 +5,14 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('PUT /group', () => {
let leader, nonLeader, groupToUpdate, adminUser;
let groupName = 'Test Public Guild';
let groupType = 'guild';
let groupUpdatedName = 'Test Public Guild Updated';
let leader; let nonLeader; let groupToUpdate; let
adminUser;
const groupName = 'Test Public Guild';
const groupType = 'guild';
const groupUpdatedName = 'Test Public Guild Updated';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: groupName,
type: groupType,
@@ -22,7 +23,7 @@ describe('PUT /group', () => {
adminUser = await generateUser({ 'contributor.admin': true });
groupToUpdate = group;
leader = groupLeader;
nonLeader = members[0];
nonLeader = members[0]; // eslint-disable-line prefer-destructuring
});
it('returns an error when a user that is not an admin or group leader tries to update', async () => {
@@ -36,7 +37,7 @@ describe('PUT /group', () => {
});
it('updates a group', async () => {
let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
name: groupUpdatedName,
});
@@ -46,12 +47,12 @@ describe('PUT /group', () => {
});
it('updates a group categories', async () => {
let categories = [{
const categories = [{
slug: 'newCat',
name: 'New Category',
}];
let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
categories,
});
@@ -60,7 +61,7 @@ describe('PUT /group', () => {
});
it('allows an admin to update a guild', async () => {
let updatedGroup = await adminUser.put(`/groups/${groupToUpdate._id}`, {
const updatedGroup = await adminUser.put(`/groups/${groupToUpdate._id}`, {
name: groupUpdatedName,
});
expect(updatedGroup.leader._id).to.eql(leader._id);
@@ -69,7 +70,7 @@ describe('PUT /group', () => {
});
it('allows a leader to change leaders', async () => {
let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
const updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
name: groupUpdatedName,
leader: nonLeader._id,
});

12
test/api/v3/integration/hall/GET-hall_heroes.test.js
View File

@@ -7,15 +7,15 @@ describe('GET /hall/heroes', () => {
it('returns all heroes sorted by -contributor.level and with correct fields', async () => {
await resetHabiticaDB();
let nonHero = await generateUser();
let hero1 = await generateUser({
contributor: {level: 1},
const nonHero = await generateUser();
const hero1 = await generateUser({
contributor: { level: 1 },
});
let hero2 = await generateUser({
contributor: {level: 3},
const hero2 = await generateUser({
contributor: { level: 3 },
});
let heroes = await nonHero.get('/hall/heroes');
const heroes = await nonHero.get('/hall/heroes');
expect(heroes.length).to.equal(2);
expect(heroes[0]._id).to.equal(hero2._id);
expect(heroes[1]._id).to.equal(hero1._id);

26
test/api/v3/integration/hall/GET-hall_heroes_heroId.test.js
View File

@@ -1,20 +1,20 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /heroes/:heroId', () => {
let user;
before(async () => {
user = await generateUser({
contributor: {admin: true},
contributor: { admin: true },
});
});
it('requires the caller to be an admin', async () => {
let nonAdmin = await generateUser();
const nonAdmin = await generateUser();
await expect(nonAdmin.get(`/hall/heroes/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -27,24 +27,24 @@ describe('GET /heroes/:heroId', () => {
await expect(user.get('/hall/heroes/invalidUUID')).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: 'invalidUUID'}),
message: t('userWithIDNotFound', { userId: 'invalidUUID' }),
});
});
it('handles non-existing heroes', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.get(`/hall/heroes/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
it('returns only necessary hero data given user id', async () => {
let hero = await generateUser({
contributor: {tier: 23},
const hero = await generateUser({
contributor: { tier: 23 },
});
let heroRes = await user.get(`/hall/heroes/${hero._id}`);
const heroRes = await user.get(`/hall/heroes/${hero._id}`);
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'balance', 'profile', 'purchased',
@@ -55,10 +55,10 @@ describe('GET /heroes/:heroId', () => {
});
it('returns only necessary hero data given username', async () => {
let hero = await generateUser({
contributor: {tier: 23},
const hero = await generateUser({
contributor: { tier: 23 },
});
let heroRes = await user.get(`/hall/heroes/${hero.auth.local.username}`);
const heroRes = await user.get(`/hall/heroes/${hero.auth.local.username}`);
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'balance', 'profile', 'purchased',
@@ -70,7 +70,7 @@ describe('GET /heroes/:heroId', () => {
it('returns correct hero using search with difference case', async () => {
await generateUser({}, { username: 'TestUpperCaseName123' });
let heroRes = await user.get('/hall/heroes/TestuPPerCasEName123');
const heroRes = await user.get('/hall/heroes/TestuPPerCasEName123');
expect(heroRes.auth.local.username).to.equal('TestUpperCaseName123');
});
});

20
test/api/v3/integration/hall/GET-hall_patrons.test.js
View File

@@ -1,9 +1,9 @@
import { times } from 'lodash';
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-integration/v3';
import { times } from 'lodash';
describe('GET /hall/patrons', () => {
let user;
@@ -22,14 +22,14 @@ describe('GET /hall/patrons', () => {
});
it('returns all patrons sorted by -backer.tier and with correct fields', async () => {
let patron1 = await generateUser({
backer: {tier: 1},
const patron1 = await generateUser({
backer: { tier: 1 },
});
let patron2 = await generateUser({
backer: {tier: 3},
const patron2 = await generateUser({
backer: { tier: 3 },
});
let patrons = await user.get('/hall/patrons');
const patrons = await user.get('/hall/patrons');
expect(patrons.length).to.equal(2);
expect(patrons[0]._id).to.equal(patron2._id);
expect(patrons[1]._id).to.equal(patron1._id);
@@ -45,14 +45,12 @@ describe('GET /hall/patrons', () => {
});
it('returns only first 50 patrons per request, more if req.query.page is passed', async () => {
await Promise.all(times(53, n => {
return generateUser({backer: {tier: n}});
}));
await Promise.all(times(53, n => generateUser({ backer: { tier: n } })));
let patrons = await user.get('/hall/patrons');
const patrons = await user.get('/hall/patrons');
expect(patrons.length).to.equal(50);
let morePatrons = await user.get('/hall/patrons?page=1');
const morePatrons = await user.get('/hall/patrons?page=1');
expect(morePatrons.length).to.equal(2);
expect(morePatrons[0].backer.tier).to.equal(2);
expect(morePatrons[1].backer.tier).to.equal(1);

66
test/api/v3/integration/hall/PUT-hall_heores_heroId.test.js
View File

@@ -1,20 +1,20 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('PUT /heroes/:heroId', () => {
let user;
before(async () => {
user = await generateUser({
contributor: {admin: true},
contributor: { admin: true },
});
});
it('requires the caller to be an admin', async () => {
let nonAdmin = await generateUser();
const nonAdmin = await generateUser();
await expect(nonAdmin.put(`/hall/heroes/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -32,22 +32,22 @@ describe('PUT /heroes/:heroId', () => {
});
it('handles non-existing heroes', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.put(`/hall/heroes/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
it('change contributor level, balance, ads', async () => {
let hero = await generateUser();
let prevBlockState = hero.auth.blocked;
let prevSleepState = hero.preferences.sleep;
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
const hero = await generateUser();
const prevBlockState = hero.auth.blocked;
const prevSleepState = hero.preferences.sleep;
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
balance: 3,
contributor: {level: 1},
purchased: {ads: true},
contributor: { level: 1 },
purchased: { ads: true },
});
// test response
@@ -74,10 +74,10 @@ describe('PUT /heroes/:heroId', () => {
});
it('block a user', async () => {
let hero = await generateUser();
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
auth: {blocked: true},
preferences: {sleep: true},
const hero = await generateUser();
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
auth: { blocked: true },
preferences: { sleep: true },
});
// test response values
@@ -89,10 +89,10 @@ describe('PUT /heroes/:heroId', () => {
});
it('unblock a user', async () => {
let hero = await generateUser();
let prevSleepState = hero.preferences.sleep;
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
auth: {blocked: false},
const hero = await generateUser();
const prevSleepState = hero.preferences.sleep;
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
auth: { blocked: false },
});
// test response values
@@ -104,29 +104,29 @@ describe('PUT /heroes/:heroId', () => {
});
it('updates chatRevoked flag', async () => {
let hero = await generateUser();
const hero = await generateUser();
await user.put(`/hall/heroes/${hero._id}`, {
flags: {chatRevoked: true},
flags: { chatRevoked: true },
});
await hero.sync();
expect(hero.flags.chatRevoked).to.eql(true);
});
it('updates chatShadowMuted flag', async () => {
let hero = await generateUser();
const hero = await generateUser();
await user.put(`/hall/heroes/${hero._id}`, {
flags: {chatShadowMuted: true},
flags: { chatShadowMuted: true },
});
await hero.sync();
expect(hero.flags.chatShadowMuted).to.eql(true);
});
it('updates contributor level', async () => {
let hero = await generateUser({
contributor: {level: 5},
const hero = await generateUser({
contributor: { level: 5 },
});
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: {level: 6},
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: { level: 6 },
});
// test response
@@ -149,11 +149,11 @@ describe('PUT /heroes/:heroId', () => {
});
it('updates contributor data', async () => {
let hero = await generateUser({
contributor: {level: 5},
const hero = await generateUser({
contributor: { level: 5 },
});
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: {text: 'Astronaut'},
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: { text: 'Astronaut' },
});
// test response
@@ -174,8 +174,8 @@ describe('PUT /heroes/:heroId', () => {
});
it('updates items', async () => {
let hero = await generateUser();
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
const hero = await generateUser();
const heroRes = await user.put(`/hall/heroes/${hero._id}`, {
itemPath: 'items.special.snowball',
itemVal: 5,
});

2
test/api/v3/integration/inbox/GET-inbox_messages.test.js
View File

@@ -47,7 +47,7 @@ describe('GET /inbox/messages', () => {
it('returns four messages when using page-query ', async () => {
const promises = [];
for (let i = 0; i < 10; i++) {
for (let i = 0; i < 10; i += 1) {
promises.push(user.post('/members/send-private-message', {
toUserId: user.id,
message: 'fourth',

14
test/api/v3/integration/members/GET-achievements.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /members/:memberId/achievements', () => {
let user;
@@ -20,11 +20,11 @@ describe('GET /members/:memberId/achievements', () => {
});
it('returns achievements based on given user', async () => {
let member = await generateUser({
contributor: {level: 1},
backer: {tier: 3},
const member = await generateUser({
contributor: { level: 1 },
backer: { tier: 3 },
});
let achievementsRes = await user.get(`/members/${member._id}/achievements`);
const achievementsRes = await user.get(`/members/${member._id}/achievements`);
expect(achievementsRes.special.achievements.contributor.earned).to.equal(true);
expect(achievementsRes.special.achievements.contributor.value).to.equal(1);
@@ -34,11 +34,11 @@ describe('GET /members/:memberId/achievements', () => {
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.get(`/members/${dummyId}/achievements`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
});

15
test/api/v3/integration/members/GET-members_id.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import common from '../../../../../website/common';
describe('GET /members/:memberId', () => {
@@ -21,15 +21,16 @@ describe('GET /members/:memberId', () => {
});
it('returns a member public data only', async () => {
let member = await generateUser({ // make sure user has all the fields that can be returned by the getMember call
contributor: {level: 1},
backer: {tier: 3},
// make sure user has all the fields that can be returned by the getMember call
const member = await generateUser({
contributor: { level: 1 },
backer: { tier: 3 },
preferences: {
costume: false,
background: 'volcano',
},
});
let memberRes = await user.get(`/members/${member._id}`);
const memberRes = await user.get(`/members/${member._id}`);
expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'preferences', 'profile', 'stats', 'achievements', 'party',
'backer', 'contributor', 'auth', 'items', 'inbox', 'loginIncentives', 'flags',
@@ -48,11 +49,11 @@ describe('GET /members/:memberId', () => {
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.get(`/members/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
});

22
test/api/v3/integration/members/GET-objections_interaction.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /members/:toUserId/objections/:interaction', () => {
let user;
@@ -13,7 +13,7 @@ describe('GET /members/:toUserId/objections/:interaction', () => {
it('validates req.params.memberId', async () => {
await expect(
user.get('/members/invalidUUID/objections/send-private-message')
user.get('/members/invalidUUID/objections/send-private-message'),
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -22,21 +22,21 @@ describe('GET /members/:toUserId/objections/:interaction', () => {
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(
user.get(`/members/${dummyId}/objections/send-private-message`)
user.get(`/members/${dummyId}/objections/send-private-message`),
).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
message: t('userWithIDNotFound', { userId: dummyId }),
});
});
it('handles non-existing interactions', async () => {
let receiver = await generateUser();
const receiver = await generateUser();
await expect(
user.get(`/members/${receiver._id}/objections/hug-a-whole-forest-of-trees`)
user.get(`/members/${receiver._id}/objections/hug-a-whole-forest-of-trees`),
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -45,18 +45,18 @@ describe('GET /members/:toUserId/objections/:interaction', () => {
});
it('returns an empty array if there are no objections', async () => {
let receiver = await generateUser();
const receiver = await generateUser();
await expect(
user.get(`/members/${receiver._id}/objections/send-private-message`)
user.get(`/members/${receiver._id}/objections/send-private-message`),
).to.eventually.be.fulfilled.and.eql([]);
});
it('returns an array of objections if any exist', async () => {
let receiver = await generateUser({'inbox.blocks': [user._id]});
const receiver = await generateUser({ 'inbox.blocks': [user._id] });
await expect(
user.get(`/members/${receiver._id}/objections/send-private-message`)
user.get(`/members/${receiver._id}/objections/send-private-message`),
).to.eventually.be.fulfilled.and.eql([
t('notAuthorizedToSendMessageToThisUser'),
]);

83
test/api/v3/integration/members/POST-send_private_message.test.js
View File

@@ -1,12 +1,12 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /members/send-private-message', () => {
let userToSendMessage;
let messageToSend = 'Test Private Message';
const messageToSend = 'Test Private Message';
beforeEach(async () => {
userToSendMessage = await generateUser();
@@ -43,7 +43,7 @@ describe('POST /members/send-private-message', () => {
});
it('returns error when to user has blocked the sender', async () => {
let receiver = await generateUser({'inbox.blocks': [userToSendMessage._id]});
const receiver = await generateUser({ 'inbox.blocks': [userToSendMessage._id] });
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
@@ -56,8 +56,8 @@ describe('POST /members/send-private-message', () => {
});
it('returns error when sender has blocked to user', async () => {
let receiver = await generateUser();
let sender = await generateUser({'inbox.blocks': [receiver._id]});
const receiver = await generateUser();
const sender = await generateUser({ 'inbox.blocks': [receiver._id] });
await expect(sender.post('/members/send-private-message', {
message: messageToSend,
@@ -70,7 +70,7 @@ describe('POST /members/send-private-message', () => {
});
it('returns error when to user has opted out of messaging', async () => {
let receiver = await generateUser({'inbox.optOut': true});
const receiver = await generateUser({ 'inbox.optOut': true });
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
@@ -83,8 +83,8 @@ describe('POST /members/send-private-message', () => {
});
it('returns an error when chat privileges are revoked', async () => {
let userWithChatRevoked = await generateUser({'flags.chatRevoked': true});
let receiver = await generateUser();
const userWithChatRevoked = await generateUser({ 'flags.chatRevoked': true });
const receiver = await generateUser();
await expect(userWithChatRevoked.post('/members/send-private-message', {
message: messageToSend,
@@ -97,7 +97,7 @@ describe('POST /members/send-private-message', () => {
});
it('sends a private message to a user', async () => {
let receiver = await generateUser();
const receiver = await generateUser();
// const initialNotifications = receiver.notifications.length;
const response = await userToSendMessage.post('/members/send-private-message', {
@@ -105,16 +105,18 @@ describe('POST /members/send-private-message', () => {
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
return message.uuid === userToSendMessage._id && message.text === messageToSend;
});
const sendersMessageInReceiversInbox = _.find(
updatedReceiver.inbox.messages,
message => message.uuid === userToSendMessage._id && message.text === messageToSend,
);
let sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
return message.uuid === receiver._id && message.text === messageToSend;
});
const sendersMessageInSendersInbox = _.find(
updatedSender.inbox.messages,
message => message.uuid === receiver._id && message.text === messageToSend,
);
expect(response.message.text).to.deep.equal(sendersMessageInSendersInbox.text);
expect(response.message.uuid).to.deep.equal(sendersMessageInSendersInbox.uuid);
@@ -135,20 +137,21 @@ describe('POST /members/send-private-message', () => {
// @TODO waiting for mobile support
xit('creates a notification with an excerpt if the message is too long', async () => {
let receiver = await generateUser();
let longerMessageToSend = 'A very long message, that for sure exceeds the limit of 100 chars for the excerpt that we set to 100 chars';
let messageExcerpt = `${longerMessageToSend.substring(0, 100)}...`;
const receiver = await generateUser();
const longerMessageToSend = 'A very long message, that for sure exceeds the limit of 100 chars for the excerpt that we set to 100 chars';
const messageExcerpt = `${longerMessageToSend.substring(0, 100)}...`;
await userToSendMessage.post('/members/send-private-message', {
message: longerMessageToSend,
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
const updatedReceiver = await receiver.get('/user');
let sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
return message.uuid === userToSendMessage._id && message.text === longerMessageToSend;
});
const sendersMessageInReceiversInbox = _.find(
updatedReceiver.inbox.messages,
message => message.uuid === userToSendMessage._id && message.text === longerMessageToSend,
);
const notification = updatedReceiver.notifications[updatedReceiver.notifications.length - 1];
@@ -161,7 +164,7 @@ describe('POST /members/send-private-message', () => {
userToSendMessage = await generateUser({
'contributor.admin': 1,
});
const receiver = await generateUser({'inbox.blocks': [userToSendMessage._id]});
const receiver = await generateUser({ 'inbox.blocks': [userToSendMessage._id] });
await userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
@@ -171,13 +174,15 @@ describe('POST /members/send-private-message', () => {
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
const sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
return message.uuid === userToSendMessage._id && message.text === messageToSend;
});
const sendersMessageInReceiversInbox = _.find(
updatedReceiver.inbox.messages,
message => message.uuid === userToSendMessage._id && message.text === messageToSend,
);
const sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
return message.uuid === receiver._id && message.text === messageToSend;
});
const sendersMessageInSendersInbox = _.find(
updatedSender.inbox.messages,
message => message.uuid === receiver._id && message.text === messageToSend,
);
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInSendersInbox).to.exist;
@@ -187,7 +192,7 @@ describe('POST /members/send-private-message', () => {
userToSendMessage = await generateUser({
'contributor.admin': 1,
});
const receiver = await generateUser({'inbox.optOut': true});
const receiver = await generateUser({ 'inbox.optOut': true });
await userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
@@ -197,13 +202,15 @@ describe('POST /members/send-private-message', () => {
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
const sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
return message.uuid === userToSendMessage._id && message.text === messageToSend;
});
const sendersMessageInReceiversInbox = _.find(
updatedReceiver.inbox.messages,
message => message.uuid === userToSendMessage._id && message.text === messageToSend,
);
const sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
return message.uuid === receiver._id && message.text === messageToSend;
});
const sendersMessageInSendersInbox = _.find(
updatedSender.inbox.messages,
message => message.uuid === receiver._id && message.text === messageToSend,
);
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInSendersInbox).to.exist;

62
test/api/v3/integration/members/POST-transfer_gems.test.js
View File

@@ -1,13 +1,11 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
function findMessage (messages, receiverId) {
let message = _.find(messages, (inboxMessage) => {
return inboxMessage.uuid === receiverId;
});
const message = _.find(messages, inboxMessage => inboxMessage.uuid === receiverId);
return message;
}
@@ -15,11 +13,11 @@ function findMessage (messages, receiverId) {
describe('POST /members/transfer-gems', () => {
let userToSendMessage;
let receiver;
let message = 'Test Private Message';
let gemAmount = 20;
const message = 'Test Private Message';
const gemAmount = 20;
beforeEach(async () => {
userToSendMessage = await generateUser({balance: 5});
userToSendMessage = await generateUser({ balance: 5 });
receiver = await generateUser();
});
@@ -68,7 +66,7 @@ describe('POST /members/transfer-gems', () => {
});
it('returns error when recipient has blocked the sender', async () => {
let receiverWhoBlocksUser = await generateUser({'inbox.blocks': [userToSendMessage._id]});
const receiverWhoBlocksUser = await generateUser({ 'inbox.blocks': [userToSendMessage._id] });
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
@@ -82,7 +80,7 @@ describe('POST /members/transfer-gems', () => {
});
it('returns error when sender has blocked recipient', async () => {
let sender = await generateUser({'inbox.blocks': [receiver._id]});
const sender = await generateUser({ 'inbox.blocks': [receiver._id] });
await expect(sender.post('/members/transfer-gems', {
message,
@@ -96,7 +94,7 @@ describe('POST /members/transfer-gems', () => {
});
it('returns an error when chat privileges are revoked', async () => {
let userWithChatRevoked = await generateUser({'flags.chatRevoked': true});
const userWithChatRevoked = await generateUser({ 'flags.chatRevoked': true });
await expect(userWithChatRevoked.post('/members/transfer-gems', {
message,
@@ -110,7 +108,7 @@ describe('POST /members/transfer-gems', () => {
});
it('works when only the recipient\'s chat privileges are revoked', async () => {
let receiverWithChatRevoked = await generateUser({'flags.chatRevoked': true});
const receiverWithChatRevoked = await generateUser({ 'flags.chatRevoked': true });
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
@@ -118,8 +116,8 @@ describe('POST /members/transfer-gems', () => {
toUserId: receiverWithChatRevoked._id,
})).to.eventually.be.fulfilled;
let updatedReceiver = await receiverWithChatRevoked.get('/user');
let updatedSender = await userToSendMessage.get('/user');
const updatedReceiver = await receiverWithChatRevoked.get('/user');
const updatedSender = await userToSendMessage.get('/user');
expect(updatedReceiver.balance).to.equal(gemAmount / 4);
expect(updatedSender.balance).to.equal(0);
@@ -179,18 +177,20 @@ describe('POST /members/transfer-gems', () => {
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = findMessage(updatedReceiver.inbox.messages, userToSendMessage._id);
let sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
const sendersMessageInReceiversInbox = findMessage(
updatedReceiver.inbox.messages, userToSendMessage._id,
);
const sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
let messageSentContent = t('privateMessageGiftGemsMessage', {
receiverName: receiver.profile.name,
senderName: userToSendMessage.profile.name,
gemAmount,
});
messageSentContent = `\`${messageSentContent}\` `;
messageSentContent = `\`${messageSentContent}\` `;
messageSentContent += message;
expect(sendersMessageInReceiversInbox).to.exist;
@@ -208,18 +208,20 @@ describe('POST /members/transfer-gems', () => {
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = findMessage(updatedReceiver.inbox.messages, userToSendMessage._id);
let sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
const sendersMessageInReceiversInbox = findMessage(
updatedReceiver.inbox.messages, userToSendMessage._id,
);
const sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
let messageSentContent = t('privateMessageGiftGemsMessage', {
receiverName: receiver.profile.name,
senderName: userToSendMessage.profile.name,
gemAmount,
});
messageSentContent = `\`${messageSentContent}\` `;
messageSentContent = `\`${messageSentContent}\` `;
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInReceiversInbox.text).to.equal(messageSentContent);
@@ -242,14 +244,16 @@ describe('POST /members/transfer-gems', () => {
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
const updatedReceiver = await receiver.get('/user');
const updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = findMessage(updatedReceiver.inbox.messages, userToSendMessage._id);
let sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
const sendersMessageInReceiversInbox = findMessage(
updatedReceiver.inbox.messages, userToSendMessage._id,
);
const sendersMessageInSendersInbox = findMessage(updatedSender.inbox.messages, receiver._id);
let [receieversMessageContent, sendersMessageContent] = ['es', 'cs'].map((lang) => {
let messageContent = t('privateMessageGiftGemsMessage', {
const [receieversMessageContent, sendersMessageContent] = ['es', 'cs'].map(lang => {
const messageContent = t('privateMessageGiftGemsMessage', {
receiverName: receiver.profile.name,
senderName: userToSendMessage.profile.name,
gemAmount,

4
test/api/v3/integration/models/GET-model_paths.test.js
View File

@@ -18,10 +18,10 @@ describe('GET /models/:model/paths', () => {
});
});
let models = ['habit', 'daily', 'todo', 'reward', 'user', 'tag', 'challenge', 'group'];
const models = ['habit', 'daily', 'todo', 'reward', 'user', 'tag', 'challenge', 'group'];
models.forEach(model => {
it(`returns the model paths for ${model}`, async () => {
let res = await user.get(`/models/${model}/paths`);
const res = await user.get(`/models/${model}/paths`);
if (model !== 'tag') expect(res._id).to.equal('String');
if (model === 'tag') expect(res.id).to.equal('String');

2
test/api/v3/integration/notFound.test.js
View File

@@ -2,7 +2,7 @@ import { requester } from '../../../helpers/api-integration/v3';
describe('notFound Middleware', () => {
it('returns a 404 error when the resource is not found', async () => {
let request = requester().get('/api/v3/dummy-url');
const request = requester().get('/api/v3/dummy-url');
await expect(request).to.eventually.be.rejected.and.eql({
code: 404,

4
test/api/v3/integration/notifications/POST-notifications_notificationId_read.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /notifications/:notificationId/read', () => {
let user;
@@ -12,7 +12,7 @@ describe('POST /notifications/:notificationId/read', () => {
});
it('errors when notification is not found', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.post(`/notifications/${dummyId}/read`)).to.eventually.be.rejected.and.eql({
code: 404,

4
test/api/v3/integration/notifications/POST-notifications_notificationId_see.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /notifications/:notificationId/see', () => {
let user;
@@ -12,7 +12,7 @@ describe('POST /notifications/:notificationId/see', () => {
});
it('errors when notification is not found', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.post(`/notifications/${dummyId}/see`)).to.eventually.be.rejected.and.eql({
code: 404,

4
test/api/v3/integration/notifications/POST-notifications_read.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /notifications/read', () => {
let user;
@@ -12,7 +12,7 @@ describe('POST /notifications/read', () => {
});
it('errors when notification is not found', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.post('/notifications/read', {
notificationIds: [dummyId],

4
test/api/v3/integration/notifications/POST_notifications_see.test.js
View File

@@ -1,8 +1,8 @@
import { v4 as generateUUID } from 'uuid';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /notifications/see', () => {
let user;
@@ -12,7 +12,7 @@ describe('POST /notifications/see', () => {
});
it('errors when notification is not found', async () => {
let dummyId = generateUUID();
const dummyId = generateUUID();
await expect(user.post('/notifications/see', {
notificationIds: [dummyId],

11
test/api/v3/integration/notifications/prevent-multiple-notification.js
View File

@@ -3,10 +3,11 @@ import {
} from '../../../../helpers/api-integration/v3';
describe('Prevent multiple notifications', () => {
let partyLeader, partyMembers, party;
let partyLeader; let partyMembers; let
party;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -22,10 +23,10 @@ describe('Prevent multiple notifications', () => {
it('does not add the same notification twice', async () => {
const multipleChatMessages = [];
for (let i = 0; i < 4; i++) {
for (let memberIndex = 0; memberIndex < partyMembers.length; memberIndex++) {
for (let i = 0; i < 4; i += 1) {
for (let memberIndex = 0; memberIndex < partyMembers.length; memberIndex += 1) {
multipleChatMessages.push(
partyMembers[memberIndex].post(`/groups/${party._id}/chat`, { message: `Message ${i}_${memberIndex}`}),
partyMembers[memberIndex].post(`/groups/${party._id}/chat`, { message: `Message ${i}_${memberIndex}` }),
);
}
}

5
test/api/v3/integration/payments/amazon/GET-payments_amazon_subscribe_cancel.test.js
View File

@@ -6,8 +6,9 @@ import {
import amzLib from '../../../../../../website/server/libs/payments/amazon';
describe('payments : amazon #subscribeCancel', () => {
let endpoint = '/amazon/subscribe/cancel?noRedirect=true';
let user, group, amazonSubscribeCancelStub;
const endpoint = '/amazon/subscribe/cancel?noRedirect=true';
let user; let group; let
amazonSubscribeCancelStub;
beforeEach(async () => {
user = await generateUser();

9
test/api/v3/integration/payments/amazon/POST-payments_amazon_checkout.test.js
View File

@@ -4,8 +4,9 @@ import {
import amzLib from '../../../../../../website/server/libs/payments/amazon';
describe('payments - amazon - #checkout', () => {
let endpoint = '/amazon/checkout';
let user, amazonCheckoutStub;
const endpoint = '/amazon/checkout';
let user; let
amazonCheckoutStub;
beforeEach(async () => {
user = await generateUser();
@@ -37,7 +38,7 @@ describe('payments - amazon - #checkout', () => {
balance: 2,
});
let gift = {
const gift = {
type: 'gems',
gems: {
amount: 16,
@@ -45,7 +46,7 @@ describe('payments - amazon - #checkout', () => {
},
};
let orderReferenceId = 'orderReferenceId-example';
const orderReferenceId = 'orderReferenceId-example';
await user.post(endpoint, {
gift,

2
test/api/v3/integration/payments/amazon/POST-payments_amazon_createOrderReferenceId.test.js
View File

@@ -3,7 +3,7 @@ import {
} from '../../../../../helpers/api-integration/v3';
describe('payments - amazon - #createOrderReferenceId', () => {
let endpoint = '/amazon/createOrderReferenceId';
const endpoint = '/amazon/createOrderReferenceId';
let user;
beforeEach(async () => {

9
test/api/v3/integration/payments/amazon/POST-payments_amazon_subscribe.test.js
View File

@@ -6,8 +6,9 @@ import {
import amzLib from '../../../../../../website/server/libs/payments/amazon';
describe('payments - amazon - #subscribe', () => {
let endpoint = '/amazon/subscribe';
let user, group, subscribeWithAmazonStub;
const endpoint = '/amazon/subscribe';
let user; let group; let
subscribeWithAmazonStub;
beforeEach(async () => {
user = await generateUser();
@@ -22,8 +23,8 @@ describe('payments - amazon - #subscribe', () => {
});
describe('success', () => {
let billingAgreementId = 'billingAgreementId-example';
let subscription = 'basic_3mo';
const billingAgreementId = 'billingAgreementId-example';
const subscription = 'basic_3mo';
let coupon;
beforeEach(() => {

2
test/api/v3/integration/payments/amazon/POST-payments_amazon_verifyAccessToken.test.js
View File

@@ -3,7 +3,7 @@ import {
} from '../../../../../helpers/api-integration/v3';
describe('payments : amazon', () => {
let endpoint = '/amazon/verifyAccessToken';
const endpoint = '/amazon/verifyAccessToken';
let user;
beforeEach(async () => {

4
test/api/v3/integration/payments/apple/GET-payments_apple_cancelSubscribe.js
View File

@@ -1,8 +1,8 @@
import {generateUser} from '../../../../../helpers/api-integration/v3';
import { generateUser } from '../../../../../helpers/api-integration/v3';
import applePayments from '../../../../../../website/server/libs/payments/apple';
describe('payments : apple #cancelSubscribe', () => {
let endpoint = '/iap/ios/subscribe/cancel?noRedirect=true';
const endpoint = '/iap/ios/subscribe/cancel?noRedirect=true';
let user;
beforeEach(async () => {

8
test/api/v3/integration/payments/apple/POST-payments_apple_norenewsubscribe.test.js
View File

@@ -1,9 +1,9 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import applePayments from '../../../../../../website/server/libs/payments/apple';
describe('payments : apple #norenewsubscribe', () => {
let endpoint = '/iap/ios/norenew-subscribe';
let sku = 'com.habitrpg.ios.habitica.subscription.3month';
const endpoint = '/iap/ios/norenew-subscribe';
const sku = 'com.habitrpg.ios.habitica.subscription.3month';
let user;
beforeEach(async () => {
@@ -50,7 +50,7 @@ describe('payments : apple #norenewsubscribe', () => {
await user.post(endpoint, {
sku,
transaction: {receipt: 'receipt'},
transaction: { receipt: 'receipt' },
gift: {
uuid: '1',
},

6
test/api/v3/integration/payments/apple/POST-payments_apple_subscribe.test.js
View File

@@ -1,8 +1,8 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import applePayments from '../../../../../../website/server/libs/payments/apple';
describe('payments : apple #subscribe', () => {
let endpoint = '/iap/ios/subscribe';
const endpoint = '/iap/ios/subscribe';
let user;
beforeEach(async () => {
@@ -37,7 +37,7 @@ describe('payments : apple #subscribe', () => {
balance: 2,
});
let sku = 'com.habitrpg.ios.habitica.subscription.3month';
const sku = 'com.habitrpg.ios.habitica.subscription.3month';
await user.post(endpoint, {
sku,

10
test/api/v3/integration/payments/apple/POST-payments_apple_verifyiap.js
View File

@@ -1,8 +1,8 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import applePayments from '../../../../../../website/server/libs/payments/apple';
describe('payments : apple #verify', () => {
let endpoint = '/iap/ios/verify';
const endpoint = '/iap/ios/verify';
let user;
beforeEach(async () => {
@@ -36,7 +36,8 @@ describe('payments : apple #verify', () => {
await user.post(endpoint, {
transaction: {
receipt: 'receipt',
}});
},
});
expect(verifyStub).to.be.calledOnce;
expect(verifyStub.args[0][0].user._id).to.eql(user._id);
@@ -56,7 +57,8 @@ describe('payments : apple #verify', () => {
},
gift: {
uuid: '1',
}});
},
});
expect(verifyStub).to.be.calledOnce;
expect(verifyStub.args[0][0].user._id).to.eql(user._id);

4
test/api/v3/integration/payments/google/GET-payments_google_cancelSubscribe.js
View File

@@ -1,8 +1,8 @@
import {generateUser} from '../../../../../helpers/api-integration/v3';
import { generateUser } from '../../../../../helpers/api-integration/v3';
import googlePayments from '../../../../../../website/server/libs/payments/google';
describe('payments : google #cancelSubscribe', () => {
let endpoint = '/iap/android/subscribe/cancel?noRedirect=true';
const endpoint = '/iap/android/subscribe/cancel?noRedirect=true';
let user;
beforeEach(async () => {

6
test/api/v3/integration/payments/google/POST-payments_google_norenewsubscribe.test.js
View File

@@ -1,9 +1,9 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import googlePayments from '../../../../../../website/server/libs/payments/google';
describe('payments : google #norenewsubscribe', () => {
let endpoint = '/iap/android/norenew-subscribe';
let sku = 'com.habitrpg.android.habitica.subscription.3month';
const endpoint = '/iap/android/norenew-subscribe';
const sku = 'com.habitrpg.android.habitica.subscription.3month';
let user;
beforeEach(async () => {

8
test/api/v3/integration/payments/google/POST-payments_google_subscribe.test.js
View File

@@ -1,8 +1,8 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import googlePayments from '../../../../../../website/server/libs/payments/google';
describe('payments : google #subscribe', () => {
let endpoint = '/iap/android/subscribe';
const endpoint = '/iap/android/subscribe';
let user;
beforeEach(async () => {
@@ -37,11 +37,11 @@ describe('payments : google #subscribe', () => {
balance: 2,
});
let sku = 'com.habitrpg.android.habitica.subscription.3month';
const sku = 'com.habitrpg.android.habitica.subscription.3month';
await user.post(endpoint, {
sku,
transaction: {receipt: 'receipt', signature: 'signature'},
transaction: { receipt: 'receipt', signature: 'signature' },
});
expect(subscribeStub).to.be.calledOnce;

10
test/api/v3/integration/payments/google/POST-payments_google_verifyiap.js
View File

@@ -1,8 +1,8 @@
import {generateUser, translate as t} from '../../../../../helpers/api-integration/v3';
import { generateUser, translate as t } from '../../../../../helpers/api-integration/v3';
import googlePayments from '../../../../../../website/server/libs/payments/google';
describe('payments : google #verify', () => {
let endpoint = '/iap/android/verify';
const endpoint = '/iap/android/verify';
let user;
beforeEach(async () => {
@@ -34,7 +34,7 @@ describe('payments : google #verify', () => {
});
await user.post(endpoint, {
transaction: {receipt: 'receipt', signature: 'signature'},
transaction: { receipt: 'receipt', signature: 'signature' },
});
expect(verifyStub).to.be.calledOnce;
@@ -51,8 +51,8 @@ describe('payments : google #verify', () => {
});
await user.post(endpoint, {
transaction: {receipt: 'receipt', signature: 'signature'},
gift: {uuid: '1'},
transaction: { receipt: 'receipt', signature: 'signature' },
gift: { uuid: '1' },
});
expect(verifyStub).to.be.calledOnce;

2
test/api/v3/integration/payments/paypal/GET-payments_paypal_checkout.test.js
View File

@@ -4,7 +4,7 @@ import {
import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
describe('payments : paypal #checkout', () => {
let endpoint = '/paypal/checkout';
const endpoint = '/paypal/checkout';
let user;
beforeEach(async () => {

6
test/api/v3/integration/payments/paypal/GET-payments_paypal_checkout_success.test.js
View File

@@ -5,7 +5,7 @@ import paypalPayments from '../../../../../../website/server/libs/payments/paypa
import apiError from '../../../../../../website/server/libs/apiError';
describe('payments : paypal #checkoutSuccess', () => {
let endpoint = '/paypal/checkout/success';
const endpoint = '/paypal/checkout/success';
let user;
beforeEach(async () => {
@@ -42,8 +42,8 @@ describe('payments : paypal #checkoutSuccess', () => {
});
it('makes a purchase', async () => {
let paymentId = 'test-paymentid';
let customerId = 'test-customerId';
const paymentId = 'test-paymentid';
const customerId = 'test-customerId';
user = await generateUser({
'profile.name': 'sender',

6
test/api/v3/integration/payments/paypal/GET-payments_paypal_subscribe.test.js
View File

@@ -6,7 +6,7 @@ import shared from '../../../../../../website/common';
import apiError from '../../../../../../website/server/libs/apiError';
describe('payments : paypal #subscribe', () => {
let endpoint = '/paypal/subscribe';
const endpoint = '/paypal/subscribe';
let user;
beforeEach(async () => {
@@ -33,8 +33,8 @@ describe('payments : paypal #subscribe', () => {
});
it('makes a purchase', async () => {
let subKey = 'basic_3mo';
let sub = shared.content.subscriptionBlocks[subKey];
const subKey = 'basic_3mo';
const sub = shared.content.subscriptionBlocks[subKey];
user = await generateUser({
'profile.name': 'sender',

2
test/api/v3/integration/payments/paypal/GET-payments_paypal_subscribe_cancel.test.js
View File

@@ -5,7 +5,7 @@ import {
import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
describe('payments : paypal #subscribeCancel', () => {
let endpoint = '/paypal/subscribe/cancel';
const endpoint = '/paypal/subscribe/cancel';
let user;
beforeEach(async () => {

4
test/api/v3/integration/payments/paypal/GET-payments_paypal_subscribe_success.test.js
View File

@@ -5,7 +5,7 @@ import apiError from '../../../../../../website/server/libs/apiError';
import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
describe('payments : paypal #subscribeSuccess', () => {
let endpoint = '/paypal/subscribe/success';
const endpoint = '/paypal/subscribe/success';
let user;
beforeEach(async () => {
@@ -32,7 +32,7 @@ describe('payments : paypal #subscribeSuccess', () => {
});
it('creates a subscription', async () => {
let token = 'test-token';
const token = 'test-token';
user = await generateUser({
'profile.name': 'sender',

4
test/api/v3/integration/payments/paypal/POST-payments_paypal_ipn.test.js
View File

@@ -4,7 +4,7 @@ import {
import paypalPayments from '../../../../../../website/server/libs/payments/paypal';
describe('payments - paypal - #ipn', () => {
let endpoint = '/paypal/ipn';
const endpoint = '/paypal/ipn';
let user;
beforeEach(async () => {
@@ -12,7 +12,7 @@ describe('payments - paypal - #ipn', () => {
});
it('verifies credentials', async () => {
let result = await user.post(endpoint);
const result = await user.post(endpoint);
expect(result).to.eql('OK');
});

5
test/api/v3/integration/payments/stripe/GET-payments_stripe_subscribe_cancel.test.js
View File

@@ -6,8 +6,9 @@ import {
import stripePayments from '../../../../../../website/server/libs/payments/stripe';
describe('payments - stripe - #subscribeCancel', () => {
let endpoint = '/stripe/subscribe/cancel?noRedirect=true';
let user, group, stripeCancelSubscriptionStub;
const endpoint = '/stripe/subscribe/cancel?noRedirect=true';
let user; let group; let
stripeCancelSubscriptionStub;
beforeEach(async () => {
user = await generateUser();

7
test/api/v3/integration/payments/stripe/POST-payments_stripe_checkout.test.js
View File

@@ -5,15 +5,16 @@ import {
import stripePayments from '../../../../../../website/server/libs/payments/stripe';
describe('payments - stripe - #checkout', () => {
let endpoint = '/stripe/checkout';
let user, group;
const endpoint = '/stripe/checkout';
let user; let
group;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.post(endpoint, {id: 123})).to.eventually.be.rejected.and.include({
await expect(user.post(endpoint, { id: 123 })).to.eventually.be.rejected.and.include({
code: 401,
error: 'Error',
message: 'Invalid API Key provided: aaaabbbb********************1111',

5
test/api/v3/integration/payments/stripe/POST-payments_stripe_subscribe_edit.test.js
View File

@@ -6,8 +6,9 @@ import {
import stripePayments from '../../../../../../website/server/libs/payments/stripe';
describe('payments - stripe - #subscribeEdit', () => {
let endpoint = '/stripe/subscribe/edit';
let user, group;
const endpoint = '/stripe/subscribe/edit';
let user; let
group;
beforeEach(async () => {
user = await generateUser();

8
test/api/v3/integration/qrcodes/GET-qrcodes_user.test.js
View File

@@ -1,9 +1,9 @@
import superagent from 'superagent';
import nconf from 'nconf';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import superagent from 'superagent';
import nconf from 'nconf';
const API_TEST_SERVER_PORT = nconf.get('PORT');
xdescribe('GET /qr-code/user/:memberId', () => {
@@ -22,8 +22,8 @@ xdescribe('GET /qr-code/user/:memberId', () => {
});
it('redirects to profile page', async () => {
let url = `http://localhost:${API_TEST_SERVER_PORT}/qr-code/user/${user._id}`;
let response = await superagent.get(url).end(function (err, res) {
const url = `http://localhost:${API_TEST_SERVER_PORT}/qr-code/user/${user._id}`;
const response = await superagent.get(url).end((err, res) => {
expect(err).to.be(undefined);
return res;
});

8
test/api/v3/integration/quests/POST-groups_groupId_quests_accept.test.js
View File

@@ -17,7 +17,7 @@ describe('POST /groups/:groupId/quests/accept', () => {
beforeEach(async () => {
user = await generateUser();
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -51,7 +51,7 @@ describe('POST /groups/:groupId/quests/accept', () => {
});
it('does not accept quest for a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -134,7 +134,7 @@ describe('POST /groups/:groupId/quests/accept', () => {
});
it('cleans up user quest data for non-quest members when last member accepts', async () => {
let rejectingMember = partyMembers[0];
const rejectingMember = partyMembers[0];
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await rejectingMember.post(`/groups/${questingGroup._id}/quests/reject`);
@@ -162,7 +162,7 @@ describe('POST /groups/:groupId/quests/accept', () => {
expect(groupChat[0]._meta).to.exist;
expect(groupChat[0]._meta).to.have.all.keys(['participatingMembers']);
let returnedGroup = await leader.get(`/groups/${questingGroup._id}`);
const returnedGroup = await leader.get(`/groups/${questingGroup._id}`);
expect(returnedGroup.chat[0]._meta).to.be.undefined;
});
});

36
test/api/v3/integration/quests/POST-groups_groupId_quests_force-start.test.js
View File

@@ -14,7 +14,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
let partyMembers;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 3,
});
@@ -30,7 +30,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
context('failure conditions', () => {
it('does not force start a quest for a group in which user is not a member', async () => {
let nonMember = await generateUser();
const nonMember = await generateUser();
await expect(nonMember.post(`/groups/${questingGroup._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
@@ -41,7 +41,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('does not force start quest for a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -91,8 +91,8 @@ describe('POST /groups/:groupId/quests/force-start', () => {
context('successfully force starting a quest', () => {
it('allows quest leader to force start quest', async () => {
let questLeader = partyMembers[0];
await questLeader.update({[`items.quests.${PET_QUEST}`]: 1});
const questLeader = partyMembers[0];
await questLeader.update({ [`items.quests.${PET_QUEST}`]: 1 });
await questLeader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await questLeader.post(`/groups/${questingGroup._id}/quests/force-start`);
@@ -103,8 +103,8 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('allows group leader to force start quest', async () => {
let questLeader = partyMembers[0];
await questLeader.update({[`items.quests.${PET_QUEST}`]: 1});
const questLeader = partyMembers[0];
await questLeader.update({ [`items.quests.${PET_QUEST}`]: 1 });
await questLeader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await leader.post(`/groups/${questingGroup._id}/quests/force-start`);
@@ -117,7 +117,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
it('sends back the quest object', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
let quest = await leader.post(`/groups/${questingGroup._id}/quests/force-start`);
const quest = await leader.post(`/groups/${questingGroup._id}/quests/force-start`);
expect(quest.active).to.eql(true);
expect(quest.key).to.eql(PET_QUEST);
@@ -127,8 +127,8 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('cleans up user quest data for non-quest members', async () => {
let partyMemberThatRejects = partyMembers[1];
let partyMemberThatIgnores = partyMembers[2];
const partyMemberThatRejects = partyMembers[1];
const partyMemberThatIgnores = partyMembers[2];
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
@@ -152,9 +152,9 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('removes users who have not accepted the quest from quest.members', async () => {
let partyMemberThatRejects = partyMembers[1];
let partyMemberThatIgnores = partyMembers[2];
let partyMemberThatAccepts = partyMembers[0];
const partyMemberThatRejects = partyMembers[1];
const partyMemberThatIgnores = partyMembers[2];
const partyMemberThatAccepts = partyMembers[0];
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMemberThatAccepts.post(`/groups/${questingGroup._id}/quests/accept`);
@@ -174,7 +174,7 @@ describe('POST /groups/:groupId/quests/force-start', () => {
it('removes users who are not in the party from quest.members', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
let notInPartyUser = await generateUser();
const notInPartyUser = await generateUser();
await questingGroup.update({
[`quest.members.${notInPartyUser._id}`]: true,
@@ -210,8 +210,8 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('removes users who don\'t have true value in quest.members from quest.members', async () => {
let partyMemberThatRejects = partyMembers[1];
let partyMemberThatIgnores = partyMembers[2];
const partyMemberThatRejects = partyMembers[1];
const partyMemberThatIgnores = partyMembers[2];
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
@@ -234,8 +234,8 @@ describe('POST /groups/:groupId/quests/force-start', () => {
});
it('allows group leader to force start quest and verifies chat', async () => {
let questLeader = partyMembers[0];
await questLeader.update({[`items.quests.${PET_QUEST}`]: 1});
const questLeader = partyMembers[0];
await questLeader.update({ [`items.quests.${PET_QUEST}`]: 1 });
await questLeader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await leader.post(`/groups/${questingGroup._id}/quests/force-start`);

34
test/api/v3/integration/quests/POST-groups_groupId_quests_invite.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
translate as t,
sleep,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import { quests as questScrolls } from '../../../../../website/common/script/content/quests';
import { chatModel as Chat } from '../../../../../website/server/models/message';
import apiError from '../../../../../website/server/libs/apiError';
@@ -15,14 +15,14 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 1,
});
questingGroup = group;
leader = groupLeader;
member = members[0];
member = members[0]; // eslint-disable-line prefer-destructuring
});
context('failure conditions', () => {
@@ -35,12 +35,12 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('does not issue invites for a group in which user is not a member', async () => {
let { group } = await createAndPopulateGroup({
const { group } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 1,
});
let alternateGroup = group;
const alternateGroup = group;
await expect(leader.post(`/groups/${alternateGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 404,
@@ -50,12 +50,12 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('does not issue invites for Guilds', async () => {
let { group } = await createAndPopulateGroup({
const { group } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'public' },
members: 1,
});
let alternateGroup = group;
const alternateGroup = group;
await expect(leader.post(`/groups/${alternateGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
@@ -70,7 +70,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${FAKE_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: apiError('questNotFound', {key: FAKE_QUEST}),
message: apiError('questNotFound', { key: FAKE_QUEST }),
});
});
@@ -94,7 +94,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${LEVELED_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questLevelTooHigh', {level: LEVELED_QUEST_REQ}),
message: t('questLevelTooHigh', { level: LEVELED_QUEST_REQ }),
});
});
@@ -130,7 +130,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
await questingGroup.sync();
let quest = questingGroup.quest;
const { quest } = questingGroup;
expect(quest.key).to.eql(PET_QUEST);
expect(quest.active).to.eql(false);
@@ -157,7 +157,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('sends back the quest object', async () => {
let inviteResponse = await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
const inviteResponse = await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
expect(inviteResponse.key).to.eql(PET_QUEST);
expect(inviteResponse.active).to.eql(false);
@@ -168,7 +168,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('allows non-party-leader party members to send invites', async () => {
let inviteResponse = await member.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
const inviteResponse = await member.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await questingGroup.sync();
@@ -177,9 +177,9 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('starts quest automatically if user is in a solo party', async () => {
let leaderDetails = { balance: 10 };
const leaderDetails = { balance: 10 };
leaderDetails[`items.quests.${PET_QUEST}`] = 1;
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
leaderDetails,
});
@@ -192,9 +192,9 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
});
it('starts quest automatically if user is in a solo party and verifies chat', async () => {
let leaderDetails = { balance: 10 };
const leaderDetails = { balance: 10 };
leaderDetails[`items.quests.${PET_QUEST}`] = 1;
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
leaderDetails,
});
@@ -207,7 +207,7 @@ describe('POST /groups/:groupId/quests/invite/:questKey', () => {
expect(groupChat[0]._meta).to.exist;
expect(groupChat[0]._meta).to.have.all.keys(['participatingMembers']);
let returnedGroup = await groupLeader.get(`/groups/${group._id}`);
const returnedGroup = await groupLeader.get(`/groups/${group._id}`);
expect(returnedGroup.chat[0]._meta).to.be.undefined;
});
});

12
test/api/v3/integration/quests/POST-groups_groupid_quests_abort.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import { model as Group } from '../../../../../website/server/models/group';
describe('POST /groups/:groupId/quests/abort', () => {
@@ -15,7 +15,7 @@ describe('POST /groups/:groupId/quests/abort', () => {
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -50,7 +50,7 @@ describe('POST /groups/:groupId/quests/abort', () => {
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -90,9 +90,9 @@ describe('POST /groups/:groupId/quests/abort', () => {
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
let stub = sandbox.spy(Group.prototype, 'sendChat');
const stub = sandbox.spy(Group.prototype, 'sendChat');
let res = await leader.post(`/groups/${questingGroup._id}/quests/abort`);
const res = await leader.post(`/groups/${questingGroup._id}/quests/abort`);
await Promise.all([
leader.sync(),
questingGroup.sync(),
@@ -100,7 +100,7 @@ describe('POST /groups/:groupId/quests/abort', () => {
partyMembers[1].sync(),
]);
let cleanUserQuestObj = {
const cleanUserQuestObj = {
key: null,
progress: {
up: 0,

12
test/api/v3/integration/quests/POST-groups_groupid_quests_cancel.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import { model as Group } from '../../../../../website/server/models/group';
describe('POST /groups/:groupId/quests/cancel', () => {
@@ -15,7 +15,7 @@ describe('POST /groups/:groupId/quests/cancel', () => {
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -50,7 +50,7 @@ describe('POST /groups/:groupId/quests/cancel', () => {
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -103,9 +103,9 @@ describe('POST /groups/:groupId/quests/cancel', () => {
// partyMembers[1] hasn't accepted the invitation, because if he accepts, invitation phase ends.
// The cancel command can be done only in the invitation phase.
let stub = sandbox.spy(Group.prototype, 'sendChat');
const stub = sandbox.spy(Group.prototype, 'sendChat');
let res = await leader.post(`/groups/${questingGroup._id}/quests/cancel`);
const res = await leader.post(`/groups/${questingGroup._id}/quests/cancel`);
await Promise.all([
leader.sync(),
@@ -114,7 +114,7 @@ describe('POST /groups/:groupId/quests/cancel', () => {
questingGroup.sync(),
]);
let clean = {
const clean = {
key: null,
progress: {
up: 0,

8
test/api/v3/integration/quests/POST-groups_groupid_quests_leave.test.js
View File

@@ -1,9 +1,9 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:groupId/quests/leave', () => {
let questingGroup;
@@ -14,7 +14,7 @@ describe('POST /groups/:groupId/quests/leave', () => {
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -49,7 +49,7 @@ describe('POST /groups/:groupId/quests/leave', () => {
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -102,7 +102,7 @@ describe('POST /groups/:groupId/quests/leave', () => {
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
let leaveResult = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`);
const leaveResult = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`);
await Promise.all([
partyMembers[0].sync(),
questingGroup.sync(),

14
test/api/v3/integration/quests/POST-groups_groupid_quests_reject.test.js
View File

@@ -1,10 +1,10 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
translate as t,
generateUser,
sleep,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import { chatModel as Chat } from '../../../../../website/server/models/message';
describe('POST /groups/:groupId/quests/reject', () => {
@@ -16,7 +16,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
@@ -51,7 +51,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
const { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
@@ -127,7 +127,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
});
context('successfully quest rejection', () => {
let cleanUserQuestObj = {
const cleanUserQuestObj = {
key: null,
progress: {
up: 0,
@@ -142,7 +142,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
it('rejects a quest invitation', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
let res = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
const res = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
await partyMembers[0].sync();
await questingGroup.sync();
@@ -162,7 +162,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
});
it('cleans up user quest data for non-quest members when last member rejects', async () => {
let rejectingMember = partyMembers[1];
const rejectingMember = partyMembers[1];
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
@@ -193,7 +193,7 @@ describe('POST /groups/:groupId/quests/reject', () => {
expect(groupChat[0]._meta).to.exist;
expect(groupChat[0]._meta).to.have.all.keys(['participatingMembers']);
let returnedGroup = await leader.get(`/groups/${questingGroup._id}`);
const returnedGroup = await leader.get(`/groups/${questingGroup._id}`);
expect(returnedGroup.chat[0]._meta).to.be.undefined;
});
});

6
test/api/v3/integration/shops/GET-shops_backgrounds.test.js
View File

@@ -11,15 +11,15 @@ describe('GET /shops/backgrounds', () => {
});
it('returns a valid shop object', async () => {
let shop = await user.get('/shops/backgrounds');
const shop = await user.get('/shops/backgrounds');
expect(shop.identifier).to.equal('backgroundShop');
expect(shop.text).to.eql(t('backgroundShop'));
expect(shop.notes).to.eql(t('backgroundShopText'));
expect(shop.imageName).to.equal('background_shop');
expect(shop.sets).to.be.an('array');
let sets = shop.sets.map(set => set.identifier);
const sets = shop.sets.map(set => set.identifier);
expect(sets).to.include('incentiveBackgrounds');
expect(sets).to.include('backgrounds062014');
});
});
});

16
test/api/v3/integration/shops/GET-shops_market.test.js
View File

@@ -11,7 +11,7 @@ describe('GET /shops/market', () => {
});
it('returns a valid shop object', async () => {
let shop = await user.get('/shops/market');
const shop = await user.get('/shops/market');
expect(shop.identifier).to.equal('market');
expect(shop.text).to.eql(t('market'));
@@ -19,7 +19,7 @@ describe('GET /shops/market', () => {
expect(shop.imageName).to.be.a('string');
expect(shop.categories).to.be.an('array');
let categories = shop.categories.map(cat => cat.identifier);
const categories = shop.categories.map(cat => cat.identifier);
expect(categories).to.include('eggs');
expect(categories).to.include('hatchingPotions');
@@ -32,22 +32,22 @@ describe('GET /shops/market', () => {
'stats.gp': 99999999,
});
let shop = await user.get('/shops/market');
let items = shop.categories.reduce((array, category) => {
category.items.forEach((item) => {
const shop = await user.get('/shops/market');
const items = shop.categories.reduce((array, category) => {
category.items.forEach(item => {
array.push(item);
});
return array;
}, []);
let results = await Promise.all(items.map((item) => {
let { purchaseType, key } = item;
const results = await Promise.all(items.map(item => {
const { purchaseType, key } = item;
return user.post(`/user/purchase/${purchaseType}/${key}`);
}));
expect(results.length).to.be.greaterThan(0);
items.forEach((item) => {
items.forEach(item => {
expect(item).to.include.keys('key', 'text', 'notes', 'class', 'value', 'currency');
});
});

4
test/api/v3/integration/shops/GET-shops_quests.test.js
View File

@@ -11,7 +11,7 @@ describe('GET /shops/quests', () => {
});
it('returns a valid shop object', async () => {
let shop = await user.get('/shops/quests');
const shop = await user.get('/shops/quests');
expect(shop.identifier).to.equal('questShop');
expect(shop.text).to.eql(t('quests'));
@@ -19,7 +19,7 @@ describe('GET /shops/quests', () => {
expect(shop.imageName).to.be.a('string');
expect(shop.categories).to.be.an('array');
let categories = shop.categories.map(cat => cat.identifier);
const categories = shop.categories.map(cat => cat.identifier);
expect(categories).to.include('unlockable');
expect(categories).to.include('gold');

2
test/api/v3/integration/shops/GET-shops_seasonal.test.js
View File

@@ -11,7 +11,7 @@ describe('GET /shops/seasonal', () => {
});
it('returns a valid shop object', async () => {
let shop = await user.get('/shops/seasonal');
const shop = await user.get('/shops/seasonal');
expect(shop.identifier).to.equal('seasonalShop');
expect(shop.text).to.eql(t('seasonalShop'));

Some files were not shown because too many files have changed in this diff Show More