mirror of
https://github.com/HabitRPG/habitica.git
synced 2025-12-16 14:17:22 +01:00
Deprecate API v2 (was Revert "Revert "Deprecate API v2"") (#7802)
* Revert "Revert "Deprecate API v2"" * fix path in shops controller
This commit is contained in:
Matteo Pagliazzi
GitHub
@@ -1,34 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateChallenge,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /challenges/:id', () => {
|
||||
context('Member of a challenge', () => {
|
||||
let leader, party, challenge;
|
||||
|
||||
before(async () => {
|
||||
let {
|
||||
group,
|
||||
groupLeader,
|
||||
} = await createAndPopulateGroup();
|
||||
|
||||
party = group;
|
||||
leader = groupLeader;
|
||||
challenge = await generateChallenge(leader, party, {
|
||||
name: 'a created challenge',
|
||||
shortName: 'aCreatedChallenge',
|
||||
description: 'a description for the challenge',
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the challenge object', async () => {
|
||||
let fetchedChallenge = await leader.get(`/challenges/${challenge._id}`);
|
||||
|
||||
expect(fetchedChallenge.name).to.eql(challenge.name);
|
||||
expect(fetchedChallenge.shortName).to.eql(challenge.shortName);
|
||||
expect(fetchedChallenge.description).to.eql(challenge.description);
|
||||
expect(fetchedChallenge.members).to.have.a.lengthOf(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,100 +0,0 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
resetHabiticaDB,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import {
|
||||
TAVERN_ID,
|
||||
} from '../../../../website/server/models/group';
|
||||
|
||||
describe('GET /groups', () => {
|
||||
const NUMBER_OF_PUBLIC_GUILDS = 3;
|
||||
|
||||
let user;
|
||||
let leader;
|
||||
|
||||
before(async () => {
|
||||
// Set up a world with a mixture of public and private guilds
|
||||
// Invite user to a few of them
|
||||
await resetHabiticaDB();
|
||||
|
||||
user = await generateUser();
|
||||
leader = await generateUser({ balance: 10 });
|
||||
|
||||
await generateGroup(leader, {
|
||||
name: 'public guild - is member',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
}, {
|
||||
members: [leader._id, user._id],
|
||||
});
|
||||
|
||||
await generateGroup(leader, {
|
||||
name: 'public guild - is not member',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
|
||||
await generateGroup(leader, {
|
||||
name: 'private guild - is member',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
}, {
|
||||
members: [leader._id, user._id],
|
||||
});
|
||||
|
||||
await generateGroup(leader, {
|
||||
name: 'private guild - is not member',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
await generateGroup(leader, {
|
||||
name: 'party - is not member',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
await user.post('/groups', {
|
||||
name: 'party - is member',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
});
|
||||
});
|
||||
|
||||
context('no query passed in', () => {
|
||||
xit('lists all public guilds, the tavern, user\'s party, and any private guilds that user is a part of - TODO query includes duplicates - IE, tavern is included as tavern and part of public guilds. Refactor so this is not the case');
|
||||
});
|
||||
|
||||
context('tavern passed in as query', () => {
|
||||
it('returns only the tavern', async () => {
|
||||
await expect(user.get('/groups', null, {type: 'tavern'}))
|
||||
.to.eventually.have.a.lengthOf(1)
|
||||
.and.to.have.deep.property('[0]')
|
||||
.and.to.have.property('_id', TAVERN_ID);
|
||||
});
|
||||
});
|
||||
|
||||
context('party passed in as query', () => {
|
||||
it('returns only the user\'s party', async () => {
|
||||
await expect(user.get('/groups', null, {type: 'party'}))
|
||||
.to.eventually.have.a.lengthOf(1)
|
||||
.and.to.have.deep.property('[0]')
|
||||
.and.to.have.property('leader', user._id);
|
||||
});
|
||||
});
|
||||
|
||||
context('public passed in as query', () => {
|
||||
it('returns all public guilds', async () => {
|
||||
await expect(user.get('/groups', null, {type: 'public'}))
|
||||
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
|
||||
});
|
||||
});
|
||||
|
||||
context('guilds passed in as query', () => {
|
||||
it('returns all guilds user is a part of ', async () => {
|
||||
await expect(leader.get('/groups', null, {type: 'guilds'}))
|
||||
.to.eventually.have.a.lengthOf(4);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,322 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import {
|
||||
find,
|
||||
each,
|
||||
} from 'lodash';
|
||||
|
||||
describe('GET /groups/:id', () => {
|
||||
let 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;
|
||||
|
||||
before(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 30,
|
||||
groupDetails,
|
||||
});
|
||||
|
||||
leader = groupData.groupLeader;
|
||||
member = groupData.members[0];
|
||||
createdGroup = groupData.group;
|
||||
});
|
||||
|
||||
it('returns the group object', async () => {
|
||||
let group = await member.get(`/groups/${createdGroup._id}`);
|
||||
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
|
||||
it('transforms members array to an array of user objects', async () => {
|
||||
let group = await member.get(`/groups/${createdGroup._id}`);
|
||||
let someMember = group.members[0];
|
||||
|
||||
expect(someMember._id).to.exist;
|
||||
expect(someMember.profile.name).to.exist;
|
||||
expect(someMember.contributor).to.exist;
|
||||
expect(someMember.achievements).to.exist;
|
||||
expect(someMember.items).to.exist;
|
||||
});
|
||||
|
||||
it('transforms leader id to leader object', async () => {
|
||||
let 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);
|
||||
expect(group.leader.items).to.exist;
|
||||
expect(group.leader.stats).to.exist;
|
||||
expect(group.leader.achievements).to.exist;
|
||||
expect(group.leader.contributor).to.exist;
|
||||
});
|
||||
|
||||
it('includes the user in the members list', async () => {
|
||||
let group = await member.get(`/groups/${createdGroup._id}`);
|
||||
let userInGroup = find(group.members, '_id', member._id);
|
||||
|
||||
expect(userInGroup).to.exist;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('flagged messages', () => {
|
||||
let group;
|
||||
|
||||
let chat1 = {
|
||||
id: 'chat1',
|
||||
text: 'chat 1',
|
||||
flags: {},
|
||||
};
|
||||
|
||||
let chat2 = {
|
||||
id: 'chat2',
|
||||
text: 'chat 2',
|
||||
flags: {},
|
||||
flagCount: 0,
|
||||
};
|
||||
|
||||
let chat3 = {
|
||||
id: 'chat3',
|
||||
text: 'chat 3',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
},
|
||||
flagCount: 1,
|
||||
};
|
||||
|
||||
let chat4 = {
|
||||
id: 'chat4',
|
||||
text: 'chat 4',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
'other-user-id': true,
|
||||
},
|
||||
flagCount: 2,
|
||||
};
|
||||
|
||||
let chat5 = {
|
||||
id: 'chat5',
|
||||
text: 'chat 5',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
'other-user-id': true,
|
||||
'yet-another-user-id': true,
|
||||
},
|
||||
flagCount: 3,
|
||||
};
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
chat: [
|
||||
chat1,
|
||||
chat2,
|
||||
chat3,
|
||||
chat4,
|
||||
chat5,
|
||||
],
|
||||
},
|
||||
});
|
||||
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
context('non-admin', () => {
|
||||
let nonAdmin;
|
||||
|
||||
beforeEach(async () => {
|
||||
nonAdmin = await generateUser();
|
||||
});
|
||||
|
||||
it('does not include messages with a flag count of 2 or greater', async () => {
|
||||
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
|
||||
|
||||
expect(fetchedGroup.chat).to.have.lengthOf(3);
|
||||
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
|
||||
expect(fetchedGroup.chat[1].id).to.eql(chat2.id);
|
||||
expect(fetchedGroup.chat[2].id).to.eql(chat3.id);
|
||||
});
|
||||
|
||||
it('does not include user ids in flags object', async () => {
|
||||
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
|
||||
let chatWithOneFlag = fetchedGroup.chat[2];
|
||||
|
||||
expect(chatWithOneFlag.id).to.eql(chat3.id);
|
||||
expect(chat3.flags).to.eql({ 'user-id': true });
|
||||
expect(chatWithOneFlag.flags).to.eql({});
|
||||
});
|
||||
});
|
||||
|
||||
context('admin', () => {
|
||||
let admin;
|
||||
|
||||
beforeEach(async () => {
|
||||
admin = await generateUser({
|
||||
'contributor.admin': true,
|
||||
});
|
||||
});
|
||||
|
||||
it('includes all messages', async () => {
|
||||
let fetchedGroup = await admin.get(`/groups/${group._id}`);
|
||||
|
||||
expect(fetchedGroup.chat).to.have.lengthOf(5);
|
||||
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
|
||||
expect(fetchedGroup.chat[1].id).to.eql(chat2.id);
|
||||
expect(fetchedGroup.chat[2].id).to.eql(chat3.id);
|
||||
expect(fetchedGroup.chat[3].id).to.eql(chat4.id);
|
||||
expect(fetchedGroup.chat[4].id).to.eql(chat5.id);
|
||||
});
|
||||
|
||||
it('includes user ids in flags object', async () => {
|
||||
let fetchedGroup = await admin.get(`/groups/${group._id}`);
|
||||
let chatWithOneFlag = fetchedGroup.chat[2];
|
||||
|
||||
expect(chatWithOneFlag.id).to.eql(chat3.id);
|
||||
expect(chat3.flags).to.eql({ 'user-id': true });
|
||||
expect(chatWithOneFlag.flags).to.eql(chat3.flags);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-member of a public guild', () => {
|
||||
let nonMember, createdGroup;
|
||||
|
||||
before(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
});
|
||||
|
||||
createdGroup = groupData.group;
|
||||
nonMember = await generateUser();
|
||||
});
|
||||
|
||||
it('returns the group object for a non-member', async () => {
|
||||
let group = await nonMember.get(`/groups/${createdGroup._id}`);
|
||||
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
|
||||
it('does not include user in members list', async () => {
|
||||
let group = await nonMember.get(`/groups/${createdGroup._id}`);
|
||||
let userInGroup = find(group.members, '_id', nonMember._id);
|
||||
|
||||
expect(userInGroup).to.not.exist;
|
||||
});
|
||||
});
|
||||
|
||||
context('Private Guilds', () => {
|
||||
let nonMember, createdGroup;
|
||||
|
||||
before(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
createdGroup = groupData.group;
|
||||
nonMember = await generateUser();
|
||||
});
|
||||
|
||||
it('does not return the group object for a non-member', async () => {
|
||||
await expect(nonMember.get(`/groups/${createdGroup._id}`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-member of a party', () => {
|
||||
let nonMember, createdGroup;
|
||||
|
||||
before(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test party',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
createdGroup = groupData.group;
|
||||
nonMember = await generateUser();
|
||||
});
|
||||
|
||||
it('does not return the group object for a non-member', async () => {
|
||||
await expect(nonMember.get(`/groups/${createdGroup._id}`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Member of a party', () => {
|
||||
let member, createdGroup;
|
||||
|
||||
before(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test party',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
createdGroup = groupData.group;
|
||||
member = groupData.members[0];
|
||||
});
|
||||
|
||||
it('returns the user\'s party if an id of "party" is passed in', async () => {
|
||||
let group = await member.get('/groups/party');
|
||||
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-existent group', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('returns error if group does not exist', async () => {
|
||||
await expect(user.get('/groups/group-that-does-not-exist'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,144 +0,0 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups', () => {
|
||||
context('All groups', () => {
|
||||
let leader;
|
||||
|
||||
beforeEach(async () => {
|
||||
leader = await generateUser();
|
||||
});
|
||||
|
||||
xit('returns defaults? (TODO: it\'s possible to create a group without a type. Should the group default to party? Should we require type to be set?', async () => {
|
||||
return leader.post('/groups').then((group) => {
|
||||
expect(group._id).to.exist;
|
||||
expect(group.name).to.eql(`${leader.profile.name}'s group`);
|
||||
expect(group.type).to.eql('party');
|
||||
expect(group.privacy).to.eql('private');
|
||||
});
|
||||
});
|
||||
|
||||
it('returns a group object', async () => {
|
||||
let group = await leader.post('/groups', {
|
||||
name: 'Test Group',
|
||||
type: 'party',
|
||||
leaderOnly: { challenges: true },
|
||||
description: 'Test Group Description',
|
||||
leaderMessage: 'Test Group Message',
|
||||
});
|
||||
|
||||
expect(group._id).to.exist;
|
||||
expect(group.leader).to.eql(leader._id);
|
||||
expect(group.name).to.eql(group.name);
|
||||
expect(group.description).to.eql(group.description);
|
||||
expect(group.leaderMessage).to.eql(group.leaderMessage);
|
||||
expect(group.leaderOnly).to.eql(group.leaderOnly);
|
||||
expect(group.memberCount).to.eql(1);
|
||||
});
|
||||
|
||||
it('returns a populated members array', async () => {
|
||||
let party = await leader.post('/groups', {
|
||||
type: 'party',
|
||||
});
|
||||
|
||||
let member = party.members[0];
|
||||
|
||||
expect(member._id).to.eql(leader._id);
|
||||
expect(member.profile).to.eql(leader.profile);
|
||||
expect(member.contributor).to.eql(leader.contributor);
|
||||
});
|
||||
});
|
||||
|
||||
context('Parties', () => {
|
||||
let leader;
|
||||
|
||||
beforeEach(async () => {
|
||||
leader = await generateUser();
|
||||
});
|
||||
|
||||
it('allows party creation without gems', async () => {
|
||||
let party = await leader.post('/groups', {
|
||||
type: 'party',
|
||||
});
|
||||
|
||||
expect(party._id).to.exist;
|
||||
});
|
||||
|
||||
it('prevents party creation if user is already in party', async () => {
|
||||
await generateGroup(leader, {
|
||||
name: 'first party that user attempts to create',
|
||||
type: 'party',
|
||||
});
|
||||
|
||||
await expect(leader.post('/groups', { type: 'party' })).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: t('messageGroupAlreadyInParty'),
|
||||
});
|
||||
});
|
||||
|
||||
xit('prevents creating a public party. TODO: it is possible to create a public party. Should we send back an error? Automatically switch the privacy to private?', async () => {
|
||||
return expect(leader.post('/groups', {
|
||||
type: 'party',
|
||||
privacy: 'public',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: 'Parties must be private',
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Guilds', () => {
|
||||
let leader;
|
||||
|
||||
beforeEach(async () => {
|
||||
leader = await generateUser({
|
||||
balance: 2,
|
||||
});
|
||||
});
|
||||
|
||||
it('prevents guild creation when user does not have enough gems', async () => {
|
||||
let userWithoutGems = await generateUser({
|
||||
balance: 0.75,
|
||||
});
|
||||
|
||||
await expect(userWithoutGems.post('/groups', { type: 'guild' })).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageInsufficientGems'),
|
||||
});
|
||||
});
|
||||
|
||||
it('can create a public guild', async () => {
|
||||
let guild = await leader.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
|
||||
expect(guild.leader).to.eql(leader._id);
|
||||
});
|
||||
|
||||
it('can create a private guild', async () => {
|
||||
let privateGuild = await leader.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
expect(privateGuild.leader).to.eql(leader._id);
|
||||
});
|
||||
|
||||
it('deducts gems from user and adds them to guild bank', async () => {
|
||||
let guild = await leader.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
expect(guild.balance).to.eql(1);
|
||||
|
||||
let updatedUser = await leader.get('/user');
|
||||
|
||||
expect(updatedUser.balance).to.eql(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,67 +0,0 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id', () => {
|
||||
context('user is not the leader of the group', () => {
|
||||
let user, otherUser, groupUserDoesNotOwn;
|
||||
|
||||
beforeEach(async () => {
|
||||
return Promise.all([
|
||||
generateUser({ balance: 10 }),
|
||||
generateUser({ balance: 10 }),
|
||||
]).then((users) => {
|
||||
user = users[0];
|
||||
otherUser = users[1];
|
||||
|
||||
return generateGroup(otherUser, {
|
||||
name: 'Group not Owned By User',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: [user, otherUser],
|
||||
});
|
||||
}).then((group) => {
|
||||
groupUserDoesNotOwn = group;
|
||||
});
|
||||
});
|
||||
|
||||
it('does not allow user to update group', async () => {
|
||||
return expect(user.post(`/groups/${groupUserDoesNotOwn._id}`, {
|
||||
name: 'Change',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupOnlyLeaderCanUpdate'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the leader of the group', () => {
|
||||
let user, usersGroup;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser({
|
||||
balance: 10,
|
||||
});
|
||||
|
||||
usersGroup = await generateGroup(user, {
|
||||
name: 'Original Group Title',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
});
|
||||
|
||||
it('allows user to update group', async () => {
|
||||
await user.post(`/groups/${usersGroup._id}`, {
|
||||
name: 'New Group Title',
|
||||
description: 'New group description',
|
||||
});
|
||||
|
||||
await usersGroup.sync();
|
||||
|
||||
expect(usersGroup.name).to.eql('New Group Title');
|
||||
expect(usersGroup.description).to.eql('New group description');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,89 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import { each } from 'lodash';
|
||||
|
||||
describe('POST /groups/:id/invite', () => {
|
||||
context('user is a member of the group', () => {
|
||||
each({
|
||||
'public guild': {type: 'guild', privacy: 'public'},
|
||||
'private guild': {type: 'guild', privacy: 'private'},
|
||||
party: {type: 'party', privacy: 'private'},
|
||||
}, (groupDetails, groupType) => {
|
||||
let group, invitee, inviter;
|
||||
|
||||
beforeEach(async () => {
|
||||
invitee = await generateUser();
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails,
|
||||
members: 1,
|
||||
});
|
||||
group = groupData.group;
|
||||
inviter = groupData.members[0];
|
||||
});
|
||||
|
||||
it(`allows user to send an invitation for a ${groupType}`, async () => {
|
||||
await inviter.post(`/groups/${group._id}/invite`, {
|
||||
uuids: [invitee._id],
|
||||
});
|
||||
group = await inviter.get(`/groups/${group._id}`);
|
||||
expect(_.find(group.invites, {_id: invitee._id})._id).to.exists;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user is a not member of the group', () => {
|
||||
each({
|
||||
'public guild': {type: 'guild', privacy: 'public'},
|
||||
}, (groupDetails, groupType) => {
|
||||
context(`the group is a ${groupType}`, () => {
|
||||
let group, invitee, inviter;
|
||||
|
||||
beforeEach(async () => {
|
||||
invitee = await generateUser();
|
||||
inviter = await generateUser();
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails,
|
||||
});
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
it(`allows user to send an invitation for a ${groupType}`, async () => {
|
||||
await inviter.post(`/groups/${group._id}/invite`, {
|
||||
uuids: [invitee._id],
|
||||
});
|
||||
group = await inviter.get(`/groups/${group._id}`);
|
||||
expect(_.find(group.invites, {_id: invitee._id})._id).to.exists;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
each({
|
||||
'private guild': {type: 'guild', privacy: 'private'},
|
||||
party: {type: 'party', privacy: 'private'},
|
||||
}, (groupDetails, groupType) => {
|
||||
context(`the group is a ${groupType}`, () => {
|
||||
let group, invitee, inviter;
|
||||
|
||||
beforeEach(async () => {
|
||||
invitee = await generateUser();
|
||||
inviter = await generateUser();
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails,
|
||||
});
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
it(`does not allows user to send an invitation for a ${groupType}`, async () => {
|
||||
return expect(inviter.post(`/groups/${group._id}/invite`, {
|
||||
uuids: [invitee._id],
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: 'Only a member can invite new members!',
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,110 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import { each } from 'lodash';
|
||||
|
||||
describe('POST /groups/:id/join', () => {
|
||||
context('user is already a member of the group', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
each({
|
||||
'public guild': {type: 'guild', privacy: 'public'},
|
||||
'private guild': {type: 'guild', privacy: 'private'},
|
||||
party: {type: 'party', privacy: 'private'},
|
||||
}, (groupDetails, groupType) => {
|
||||
context(`user has invitation to a ${groupType}`, () => {
|
||||
let group, invitee;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails,
|
||||
invites: 1,
|
||||
});
|
||||
group = groupData.group;
|
||||
invitee = groupData.invitees[0];
|
||||
});
|
||||
|
||||
it(`allows user to join a ${groupType}`, async () => {
|
||||
await invitee.post(`/groups/${group._id}/join`);
|
||||
|
||||
group = await invitee.get(`/groups/${group._id}`);
|
||||
expect(_.find(group.members, {_id: invitee._id})._id).to.exists;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
each({
|
||||
'private guild': {type: 'guild', privacy: 'private'},
|
||||
party: {type: 'party', privacy: 'private'},
|
||||
}, (groupDetails, groupType) => {
|
||||
context(`user does not have an invitation to a ${groupType}`, () => {
|
||||
let group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails,
|
||||
});
|
||||
group = groupData.group;
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it(`does not allow user to join a ${groupType}`, async () => {
|
||||
await expect(user.post(`/groups/${group._id}/join`)).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupRequiresInvite'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user does not have an invitation to a public group', () => {
|
||||
let group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
});
|
||||
group = groupData.group;
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('allows user to join a public guild', async () => {
|
||||
await user.post(`/groups/${group._id}/join`);
|
||||
|
||||
group = await user.get(`/groups/${group._id}`);
|
||||
|
||||
expect(_.find(group.members, {_id: user._id})._id).to.exists;
|
||||
});
|
||||
});
|
||||
|
||||
context('public guild has no leader', () => {
|
||||
let user, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
});
|
||||
group = groupData.group;
|
||||
await groupData.groupLeader.post(`/groups/${group._id}/leave`);
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('makes the joining user the leader', async () => {
|
||||
await user.post(`/groups/${group._id}/join`);
|
||||
|
||||
group = await user.get(`/groups/${group._id}`);
|
||||
|
||||
expect(group.leader._id).to.eql(user._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,136 +0,0 @@
|
||||
import {
|
||||
checkExistence,
|
||||
createAndPopulateGroup,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/leave', () => {
|
||||
context('user is not member of the group', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is a non-leader member of a guild', () => {
|
||||
let user, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
members: 3,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
});
|
||||
|
||||
user = groupData.members[0];
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
it('leaves the group', async () => {
|
||||
await user.post(`/groups/${group._id}/leave`);
|
||||
|
||||
await user.sync();
|
||||
|
||||
expect(user.guilds).to.not.include(group._id);
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a public guild', () => {
|
||||
let user, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
});
|
||||
|
||||
user = groupData.groupLeader;
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
it('leaves the group accessible', async () => {
|
||||
await user.post(`/groups/${group._id}/leave`);
|
||||
|
||||
await expect(user.get(`/groups/${group._id}`)).to.eventually.have.property('_id', group._id);
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a private group', () => {
|
||||
let user, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
user = groupData.groupLeader;
|
||||
group = groupData.group;
|
||||
});
|
||||
|
||||
it('group is deleted', async () => {
|
||||
await user.post(`/groups/${group._id}/leave`);
|
||||
|
||||
await expect(checkExistence('groups', group._id)).to.eventually.eql(false);
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a private group with pending invites', () => {
|
||||
let user, invitee1, invitee2, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
invites: 2,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
user = groupData.groupLeader;
|
||||
group = groupData.group;
|
||||
invitee1 = groupData.invitees[0];
|
||||
invitee2 = groupData.invitees[1];
|
||||
});
|
||||
|
||||
it('deletes the group invitations from users', async () => {
|
||||
await user.post(`/groups/${group._id}/leave`);
|
||||
|
||||
await expect(invitee1.get('/user')).to.eventually.have.deep.property('invitations.guilds').and.to.be.empty;
|
||||
await expect(invitee2.get('/user')).to.eventually.have.deep.property('invitations.guilds').and.to.be.empty;
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a party with pending invites', () => {
|
||||
let user, invitee1, invitee2, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
invites: 2,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
});
|
||||
|
||||
user = groupData.groupLeader;
|
||||
group = groupData.group;
|
||||
invitee1 = groupData.invitees[0];
|
||||
invitee2 = groupData.invitees[1];
|
||||
});
|
||||
|
||||
it('deletes the group invitations from users', async () => {
|
||||
await user.post(`/groups/${group._id}/leave`);
|
||||
|
||||
await expect(invitee1.get('/user')).to.eventually.have.deep.property('invitations.party').and.to.be.empty;
|
||||
await expect(invitee2.get('/user')).to.eventually.have.deep.property('invitations.party').and.to.be.empty;
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,53 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/removeMember', () => {
|
||||
context('user is not member of the group', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is a non-leader member of a guild', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is the leader of a guild', () => {
|
||||
let leader, member, group;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test group',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.groupLeader;
|
||||
member = res.members[0];
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('does not allow leader to remove themselves', async () => {
|
||||
return expect(leader.post(`/groups/${group._id}/removeMember`, null, {
|
||||
uuid: leader._id,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupCannotRemoveSelf'),
|
||||
});
|
||||
});
|
||||
|
||||
it('can remove other members of guild', async () => {
|
||||
return leader.post(`/groups/${group._id}/removeMember`, null, {
|
||||
uuid: member._id,
|
||||
}).then(() => {
|
||||
return leader.get(`/groups/${group._id}`);
|
||||
}).then((guild) => {
|
||||
expect(guild.members).to.have.a.lengthOf(1);
|
||||
expect(guild.members[0]._id).to.not.eql(member._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,39 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('DELETE /groups/:id/chat', () => {
|
||||
let group, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
|
||||
return user.post(`/groups/${group._id}/chat`, null, { message: 'Some message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes a message', async () => {
|
||||
return user.del(`/groups/${group._id}/chat/${message.id}`).then(() => {
|
||||
return user.get(`/groups/${group._id}/chat/`);
|
||||
}).then((messages) => {
|
||||
expect(messages).to.have.length(0);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error is message does not exist', async () => {
|
||||
return expect(user.del(`/groups/${group._id}/chat/some-fake-id`)).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,38 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /groups/:id/chat', () => {
|
||||
context('group with multiple messages', () => {
|
||||
let group, member, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
});
|
||||
|
||||
group = groupData.group;
|
||||
user = groupData.groupLeader;
|
||||
member = groupData.members[0];
|
||||
|
||||
await member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
|
||||
await user.post(`/groups/${group._id}/chat`, null, { message: 'User message' });
|
||||
});
|
||||
|
||||
it('gets messages', async () => {
|
||||
let messages = await user.get(`/groups/${group._id}/chat`);
|
||||
|
||||
expect(messages).to.have.length(2);
|
||||
|
||||
let message = messages[0];
|
||||
|
||||
expect(message.id).to.exist;
|
||||
expect(message.text).to.exist;
|
||||
expect(message.uuid).to.exist;
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,42 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/chat', () => {
|
||||
let group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
});
|
||||
});
|
||||
|
||||
it('creates a chat message', async () => {
|
||||
return user.post(`/groups/${group._id}/chat`, null, {
|
||||
message: 'Test Message',
|
||||
}).then((res) => {
|
||||
let message = res.message;
|
||||
|
||||
expect(message.id).to.exist;
|
||||
expect(message.timestamp).to.exist;
|
||||
expect(message.text).to.eql('Test Message');
|
||||
expect(message.uuid).to.eql(user._id);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not post an empty message', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat`, null, {
|
||||
message: '',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: t('messageGroupChatBlankMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,130 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/chat/:id/clearflags', () => {
|
||||
let guild;
|
||||
|
||||
beforeEach(async () => {
|
||||
let { group } = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: 1,
|
||||
chat: [{
|
||||
id: 'message-to-clear',
|
||||
flagCount: 1,
|
||||
flags: { 'some-id': true },
|
||||
}],
|
||||
},
|
||||
});
|
||||
|
||||
guild = group;
|
||||
});
|
||||
|
||||
context('non admin', () => {
|
||||
let nonadmin;
|
||||
|
||||
beforeEach(async () => {
|
||||
nonadmin = await generateUser();
|
||||
});
|
||||
|
||||
it('cannot clear flags', async () => {
|
||||
return expect(nonadmin.post(`/groups/${guild._id}/chat/message-to-clear/clearflags`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatAdminClearFlagCount'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('admin', () => {
|
||||
let admin;
|
||||
|
||||
beforeEach(async () => {
|
||||
return generateUser({
|
||||
'contributor.admin': true,
|
||||
}).then((user) => {
|
||||
admin = user;
|
||||
});
|
||||
});
|
||||
|
||||
it('clears flags', async () => {
|
||||
return admin.post(`/groups/${guild._id}/chat/message-to-clear/clearflags`).then(() => {
|
||||
return admin.get(`/groups/${guild._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages[0].flagCount).to.eql(0);
|
||||
});
|
||||
});
|
||||
|
||||
it('leaves old flags on the flag object', async () => {
|
||||
return admin.post(`/groups/${guild._id}/chat/message-to-clear/clearflags`).then(() => {
|
||||
return admin.get(`/groups/${guild._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages[0].flags).to.have.property('some-id', true);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error if message does not exist', async () => {
|
||||
return expect(admin.post(`/groups/${guild._id}/chat/non-existant-message/clearflags`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('admin user, group with multiple messages', () => {
|
||||
let admin, author, groupWithMessages;
|
||||
|
||||
beforeEach(async () => {
|
||||
author = await generateUser();
|
||||
admin = await generateUser({
|
||||
'contributor.admin': true,
|
||||
});
|
||||
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
chat: [
|
||||
{ id: 'message-to-unflag', uuid: author._id, flagCount: 1, flags: {'some-user': true} },
|
||||
{ id: '1-flag-message', uuid: author._id, flagCount: 1, flags: { id1: true } },
|
||||
{ id: '2-flag-message', uuid: author._id, flagCount: 2, flags: { id1: true, id2: true } },
|
||||
{ id: 'no-flags', uuid: author._id, flagCount: 0, flags: {} },
|
||||
],
|
||||
},
|
||||
members: 1,
|
||||
});
|
||||
|
||||
groupWithMessages = groupData.group;
|
||||
});
|
||||
|
||||
it('changes only the message that is flagged', async () => {
|
||||
return admin.post(`/groups/${groupWithMessages._id}/chat/message-to-unflag/clearflags`).then(() => {
|
||||
return admin.get(`/groups/${groupWithMessages._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages).to.have.lengthOf(4);
|
||||
|
||||
let messageThatWasUnflagged = messages[0];
|
||||
let messageWith1Flag = messages[1];
|
||||
let messageWith2Flag = messages[2];
|
||||
let messageWithoutFlags = messages[3];
|
||||
|
||||
expect(messageThatWasUnflagged.flagCount).to.eql(0);
|
||||
expect(messageThatWasUnflagged.flags).to.have.property('some-user', true);
|
||||
|
||||
expect(messageWith1Flag.flagCount).to.eql(1);
|
||||
expect(messageWith1Flag.flags).to.have.property('id1', true);
|
||||
|
||||
expect(messageWith2Flag.flagCount).to.eql(2);
|
||||
expect(messageWith2Flag.flags).to.have.property('id1', true);
|
||||
|
||||
expect(messageWithoutFlags.flagCount).to.eql(0);
|
||||
expect(messageWithoutFlags.flags).to.eql({});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,186 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/chat/:id/flag', () => {
|
||||
context('another member\'s message', () => {
|
||||
let group, member, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
member = res.members[0];
|
||||
|
||||
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('flags message', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
|
||||
return user.get(`/groups/${group._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages[0].flagCount).to.eql(1);
|
||||
});
|
||||
});
|
||||
|
||||
it('cannot flag the same message twice', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
|
||||
return user.post(`/groups/${group._id}/chat/${message.id}/flag`);
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatFlagAlreadyReported'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('own message', () => {
|
||||
let group, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: 1,
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
|
||||
return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('cannot flag message', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatFlagOwnMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('nonexistant message', () => {
|
||||
let group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat/non-existant-message/flag`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('group with multiple messages', () => {
|
||||
let admin, author, group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
author = await generateUser();
|
||||
admin = await generateUser({
|
||||
'contributor.admin': true,
|
||||
});
|
||||
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
chat: [
|
||||
{ id: 'message-to-be-flagged', uuid: author._id, flagCount: 0, flags: {} },
|
||||
{ id: '1-flag-message', uuid: author._id, flagCount: 1, flags: { id1: true } },
|
||||
{ id: '2-flag-message', uuid: author._id, flagCount: 2, flags: { id1: true, id2: true } },
|
||||
{ id: 'no-flags', uuid: author._id, flagCount: 0, flags: {} },
|
||||
],
|
||||
},
|
||||
members: 1,
|
||||
});
|
||||
|
||||
group = groupData.group;
|
||||
user = groupData.groupLeader;
|
||||
});
|
||||
|
||||
it('changes only the message that is flagged', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/message-to-be-flagged/flag`).then(() => {
|
||||
return admin.get(`/groups/${group._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages).to.have.lengthOf(4);
|
||||
|
||||
let messageThatWasFlagged = messages[0];
|
||||
let messageWith1Flag = messages[1];
|
||||
let messageWith2Flag = messages[2];
|
||||
let messageWithoutFlags = messages[3];
|
||||
|
||||
expect(messageThatWasFlagged.flagCount).to.eql(1);
|
||||
expect(messageThatWasFlagged.flags).to.have.property(user._id, true);
|
||||
|
||||
expect(messageWith1Flag.flagCount).to.eql(1);
|
||||
expect(messageWith1Flag.flags).to.have.property('id1', true);
|
||||
|
||||
expect(messageWith2Flag.flagCount).to.eql(2);
|
||||
expect(messageWith2Flag.flags).to.have.property('id1', true);
|
||||
|
||||
expect(messageWithoutFlags.flagCount).to.eql(0);
|
||||
expect(messageWithoutFlags.flags).to.eql({});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('admin flagging a message', () => {
|
||||
let group, member, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
leaderDetails: {
|
||||
'contributor.admin': true,
|
||||
balance: 10,
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
member = res.members[0];
|
||||
|
||||
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('sets flagCount to 5', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
|
||||
return user.get(`/groups/${group._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages[0].flagCount).to.eql(5);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,149 +0,0 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /groups/:id/chat/:id/like', () => {
|
||||
context('another member\'s message', () => {
|
||||
let group, member, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
member = res.members[0];
|
||||
|
||||
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('likes message', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
|
||||
expect(messages[0].likes[user._id]).to.eql(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the message object', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
|
||||
expect(messages[0].text).to.eql('Group member message');
|
||||
expect(messages[0].uuid).to.eql(member._id);
|
||||
expect(messages[0].user).to.eql(member.profile.name);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('own message', () => {
|
||||
let group, message, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: 1,
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
|
||||
return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message' });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('cannot like message', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat/${message.id}/like`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatLikeOwnMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('group with multiple messages', () => {
|
||||
let admin, author, group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
author = await generateUser();
|
||||
admin = await generateUser({
|
||||
'contributor.admin': true,
|
||||
});
|
||||
|
||||
let groupData = await createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
chat: [
|
||||
{ id: 'message-to-be-liked', likes: {}, uuid: author._id, flagCount: 0, flags: {} },
|
||||
{ id: '1-like-message', likes: { id: true }, uuid: author._id, flagCount: 1, flags: { id1: true } },
|
||||
{ id: '2-like-message', likes: { id: true, id2: true }, uuid: author._id, flagCount: 2, flags: { id1: true, id2: true } },
|
||||
{ id: 'no-likes', likes: {}, uuid: author._id, flagCount: 0, flags: {} },
|
||||
],
|
||||
},
|
||||
members: 1,
|
||||
});
|
||||
|
||||
group = groupData.group;
|
||||
user = groupData.groupLeader;
|
||||
});
|
||||
|
||||
it('changes only the message that is liked', async () => {
|
||||
return user.post(`/groups/${group._id}/chat/message-to-be-liked/like`).then(() => {
|
||||
return admin.get(`/groups/${group._id}/chat`);
|
||||
}).then((messages) => {
|
||||
expect(messages).to.have.lengthOf(4);
|
||||
|
||||
let messageThatWasLiked = messages[0];
|
||||
let messageWith1Like = messages[1];
|
||||
let messageWith2Like = messages[2];
|
||||
let messageWithoutLike = messages[3];
|
||||
|
||||
expect(messageThatWasLiked.likes).to.have.property(user._id, true);
|
||||
|
||||
expect(messageWith1Like.flagCount).to.eql(1);
|
||||
expect(messageWith1Like.flags).to.have.property('id1', true);
|
||||
|
||||
expect(messageWith2Like.flagCount).to.eql(2);
|
||||
expect(messageWith2Like.flags).to.have.property('id1', true);
|
||||
expect(messageWith2Like.flags).to.have.property('id2', true);
|
||||
|
||||
expect(messageWithoutLike.flagCount).to.eql(0);
|
||||
expect(messageWithoutLike.flags).to.eql({});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('nonexistant message', () => {
|
||||
let group, user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.groupLeader;
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error', async () => {
|
||||
return expect(user.post(`/groups/${group._id}/chat/non-existant-message/like`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,61 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /members/id/gift', () => {
|
||||
let userWithBalance, userWithoutBalance;
|
||||
|
||||
beforeEach(async () => {
|
||||
userWithBalance = await generateUser({ balance: 10 });
|
||||
userWithoutBalance = await generateUser({ balance: 0 });
|
||||
});
|
||||
|
||||
context('send gems from balance', () => {
|
||||
it('subtracts gems from sender\'s balance and adds it to recipient\'s balance', async () => {
|
||||
await userWithBalance.post(`/members/${userWithoutBalance._id}/gift`, {
|
||||
type: 'gems',
|
||||
gems: {
|
||||
amount: 1,
|
||||
},
|
||||
});
|
||||
|
||||
await Promise.all([
|
||||
userWithoutBalance.sync(),
|
||||
userWithBalance.sync(),
|
||||
]);
|
||||
|
||||
expect(userWithBalance.balance).to.eql(9.75);
|
||||
expect(userWithoutBalance.balance).to.eql(0.25);
|
||||
});
|
||||
|
||||
it('adds a message to sender\'s inbox', async () => {
|
||||
expect(userWithBalance.inbox.messages).to.be.empty;
|
||||
|
||||
await userWithBalance.post(`/members/${userWithoutBalance._id}/gift`, {
|
||||
type: 'gems',
|
||||
gems: {
|
||||
amount: 1,
|
||||
},
|
||||
});
|
||||
|
||||
await userWithBalance.sync();
|
||||
|
||||
expect(userWithBalance.inbox.messages).to.not.be.empty;
|
||||
});
|
||||
|
||||
it('adds a message to recipients\'s inbox', async () => {
|
||||
expect(userWithoutBalance.inbox.messages).to.be.empty;
|
||||
|
||||
await userWithBalance.post(`/members/${userWithoutBalance._id}/gift`, {
|
||||
type: 'gems',
|
||||
gems: {
|
||||
amount: 1,
|
||||
},
|
||||
});
|
||||
|
||||
await userWithoutBalance.sync();
|
||||
|
||||
expect(userWithoutBalance.inbox.messages).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,70 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /members/id/message', () => {
|
||||
let sender, recipient;
|
||||
|
||||
beforeEach(async () => {
|
||||
sender = await generateUser();
|
||||
recipient = await generateUser();
|
||||
});
|
||||
|
||||
it('adds the sent message to sender\'s inbox', async () => {
|
||||
expect(sender.inbox.messages).to.be.empty;
|
||||
|
||||
await sender.post(`/members/${recipient._id}/message`, {
|
||||
message: 'hello frodo',
|
||||
});
|
||||
|
||||
await sender.sync();
|
||||
|
||||
expect(sender.inbox.messages).to.not.be.empty;
|
||||
|
||||
let messageKey = Object.keys(sender.inbox.messages)[0];
|
||||
let message = sender.inbox.messages[messageKey];
|
||||
|
||||
expect(message.text).to.eql('hello frodo');
|
||||
});
|
||||
|
||||
it('adds a message to recipients\'s inbox', async () => {
|
||||
expect(recipient.inbox.messages).to.be.empty;
|
||||
|
||||
await sender.post(`/members/${recipient._id}/message`, {
|
||||
message: 'hello frodo',
|
||||
});
|
||||
|
||||
await recipient.sync();
|
||||
|
||||
expect(recipient.inbox.messages).to.not.be.empty;
|
||||
|
||||
let messageKey = Object.keys(recipient.inbox.messages)[0];
|
||||
let message = recipient.inbox.messages[messageKey];
|
||||
|
||||
expect(message.text).to.eql('hello frodo');
|
||||
});
|
||||
|
||||
it('does not increment the sender\'s new messages field', async () => {
|
||||
expect(sender.inbox.messages).to.be.empty;
|
||||
|
||||
await sender.post(`/members/${recipient._id}/message`, {
|
||||
message: 'hello frodo',
|
||||
});
|
||||
|
||||
await sender.sync();
|
||||
|
||||
expect(sender.inbox.newMessages).to.eql(0);
|
||||
});
|
||||
|
||||
it('increments the recipient\'s new messages field', async () => {
|
||||
expect(recipient.inbox.messages).to.be.empty;
|
||||
|
||||
await sender.post(`/members/${recipient._id}/message`, {
|
||||
message: 'hello frodo',
|
||||
});
|
||||
|
||||
await recipient.sync();
|
||||
|
||||
expect(recipient.inbox.newMessages).to.eql(1);
|
||||
});
|
||||
});
|
||||
@@ -1,293 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import { v4 as generateRandomUserName } from 'uuid';
|
||||
import { each } from 'lodash';
|
||||
|
||||
describe('POST /register', () => {
|
||||
context('username and email are free', () => {
|
||||
it('registers a new user', async () => {
|
||||
let api = requester();
|
||||
let username = generateRandomUserName();
|
||||
let email = `${username}@example.com`;
|
||||
let password = 'password';
|
||||
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user._id).to.exist;
|
||||
expect(user.apiToken).to.exist;
|
||||
expect(user.auth.local.username).to.eql(username);
|
||||
});
|
||||
});
|
||||
|
||||
it('requires password and confirmPassword to match', async () => {
|
||||
let api = requester();
|
||||
let username = generateRandomUserName();
|
||||
let email = `${username}@example.com`;
|
||||
let password = 'password';
|
||||
let confirmPassword = 'not password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthPasswordMustMatch'),
|
||||
});
|
||||
});
|
||||
|
||||
it('requires a username', async () => {
|
||||
let api = requester();
|
||||
let email = `${generateRandomUserName()}@example.com`;
|
||||
let password = 'password';
|
||||
let confirmPassword = 'password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
email,
|
||||
password,
|
||||
confirmPassword,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthCredentialsRequired'),
|
||||
});
|
||||
});
|
||||
|
||||
it('requires an email', async () => {
|
||||
let api = requester();
|
||||
let username = generateRandomUserName();
|
||||
let password = 'password';
|
||||
let confirmPassword = 'password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
username,
|
||||
password,
|
||||
confirmPassword,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthCredentialsRequired'),
|
||||
});
|
||||
});
|
||||
|
||||
it('requires a password', async () => {
|
||||
let api = requester();
|
||||
let username = generateRandomUserName();
|
||||
let email = `${username}@example.com`;
|
||||
let confirmPassword = 'password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
confirmPassword,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthCredentialsRequired'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('login is already taken', () => {
|
||||
let username, email;
|
||||
beforeEach(async () => {
|
||||
username = generateRandomUserName();
|
||||
email = `${username}@example.com`;
|
||||
return generateUser({
|
||||
'auth.local.username': username,
|
||||
'auth.local.lowerCaseUsername': username,
|
||||
'auth.local.email': email,
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects if username is already taken', async () => {
|
||||
let api = requester();
|
||||
let uniqueEmail = `${generateRandomUserName()}@exampe.com`;
|
||||
let password = 'password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
username,
|
||||
email: uniqueEmail,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthUsernameTaken'),
|
||||
});
|
||||
});
|
||||
|
||||
it('rejects if email is already taken', async () => {
|
||||
let api = requester();
|
||||
let uniqueUsername = generateRandomUserName();
|
||||
let password = 'password';
|
||||
|
||||
return expect(api.post('/register', {
|
||||
username: uniqueUsername,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageAuthEmailTaken'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('successful login via api', () => {
|
||||
let api, username, email, password;
|
||||
|
||||
beforeEach(async () => {
|
||||
api = requester();
|
||||
username = generateRandomUserName();
|
||||
email = `${username}@example.com`;
|
||||
password = 'password';
|
||||
});
|
||||
|
||||
it('sets all site tour values to -2 (already seen)', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.flags.tour).to.not.be.empty;
|
||||
|
||||
each(user.flags.tour, (value) => {
|
||||
expect(value).to.eql(-2);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default todos, not no other task types', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.todos).to.not.be.empty;
|
||||
expect(user.dailys).to.be.empty;
|
||||
expect(user.habits).to.be.empty;
|
||||
expect(user.rewards).to.be.empty;
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default tags', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.tags).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('successful login with habitica-web header', () => {
|
||||
let api, username, email, password;
|
||||
|
||||
beforeEach(async () => {
|
||||
api = requester({}, {'x-client': 'habitica-web'});
|
||||
username = generateRandomUserName();
|
||||
email = `${username}@example.com`;
|
||||
password = 'password';
|
||||
});
|
||||
|
||||
it('sets all common tutorial flags to true', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.flags.tour).to.not.be.empty;
|
||||
|
||||
each(user.flags.tutorial.common, (value) => {
|
||||
expect(value).to.eql(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default todos, habits, and rewards', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.todos).to.not.be.empty;
|
||||
expect(user.dailys).to.be.empty;
|
||||
expect(user.habits).to.not.be.empty;
|
||||
expect(user.rewards).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default tags', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.tags).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('successful login with habitica-android header', () => {
|
||||
let api, username, email, password;
|
||||
|
||||
beforeEach(async () => {
|
||||
api = requester({}, {'x-client': 'habitica-android'});
|
||||
username = generateRandomUserName();
|
||||
email = `${username}@example.com`;
|
||||
password = 'password';
|
||||
});
|
||||
|
||||
it('sets all common tutorial flags to true', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.flags.tour).to.not.be.empty;
|
||||
|
||||
each(user.flags.tutorial.common, (value) => {
|
||||
expect(value).to.eql(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default todos, habits, and rewards', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.todos).to.not.be.empty;
|
||||
expect(user.dailys).to.be.empty;
|
||||
expect(user.habits).to.not.be.empty;
|
||||
expect(user.rewards).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
|
||||
it('populates user with default tags', async () => {
|
||||
return api.post('/register', {
|
||||
username,
|
||||
email,
|
||||
password,
|
||||
confirmPassword: password,
|
||||
}).then((user) => {
|
||||
expect(user.tags).to.not.be.empty;
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,9 +0,0 @@
|
||||
import {requester} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('Status', () => {
|
||||
it('returns a status of up when server is up', async () => {
|
||||
let api = requester();
|
||||
|
||||
await expect(api.get('/status')).to.eventually.eql({status: 'up'});
|
||||
});
|
||||
});
|
||||
@@ -1,186 +0,0 @@
|
||||
import {
|
||||
checkExistence,
|
||||
createAndPopulateGroup,
|
||||
generateGroup,
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
import {
|
||||
find,
|
||||
map,
|
||||
} from 'lodash';
|
||||
import Bluebird from 'bluebird';
|
||||
|
||||
describe('DELETE /user', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('deletes the user', async () => {
|
||||
return expect(user.del('/user').then(() => {
|
||||
return checkExistence('users', user._id);
|
||||
})).to.eventually.eql(false);
|
||||
});
|
||||
|
||||
it('deletes the user\'s tasks', async () => {
|
||||
// gets the user's todos ids
|
||||
let ids = user.todos.map(todo => todo._id);
|
||||
expect(ids.length).to.be.above(0); // make sure the user has some task to delete
|
||||
|
||||
await user.del('/user');
|
||||
|
||||
await Bluebird.all(map(ids, id => {
|
||||
return expect(checkExistence('tasks', id)).to.eventually.eql(false);
|
||||
}));
|
||||
});
|
||||
|
||||
context('user has active subscription', () => {
|
||||
it('does not delete account');
|
||||
});
|
||||
|
||||
context('last member of a party', () => {
|
||||
let party;
|
||||
|
||||
beforeEach(async () => {
|
||||
return generateGroup(user, {
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
}).then((group) => {
|
||||
party = group;
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes party when user is the only member', async () => {
|
||||
await user.del('/user');
|
||||
await expect(checkExistence('groups', party._id)).to.eventually.eql(false);
|
||||
});
|
||||
});
|
||||
|
||||
context('last member of a private guild', () => {
|
||||
let guild, lastMember;
|
||||
|
||||
beforeEach(async () => {
|
||||
let {
|
||||
groupLeader,
|
||||
group,
|
||||
} = await createAndPopulateGroup({
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
guild = group;
|
||||
lastMember = groupLeader;
|
||||
});
|
||||
|
||||
it('deletes guild when user is the only member', async () => {
|
||||
await lastMember.del('/user');
|
||||
await expect(checkExistence('groups', guild._id)).to.eventually.eql(false);
|
||||
});
|
||||
});
|
||||
|
||||
context('groups user is leader of', () => {
|
||||
let group, oldLeader, newLeader;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 3,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
newLeader = res.members[0];
|
||||
oldLeader = res.groupLeader;
|
||||
});
|
||||
});
|
||||
|
||||
it('chooses new group leader for any group user was the leader of', async () => {
|
||||
return oldLeader.del('/user').then(() => {
|
||||
return newLeader.get(`/groups/${group._id}`);
|
||||
}).then((guild) => {
|
||||
expect(guild.leader).to.exist;
|
||||
expect(guild.leader._id).to.not.eql(oldLeader._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('groups user is a part of', () => {
|
||||
let group1, group2, userToDelete, otherUser;
|
||||
|
||||
beforeEach(async () => {
|
||||
return generateUser({
|
||||
balance: 10,
|
||||
}).then((_user) => {
|
||||
userToDelete = _user;
|
||||
|
||||
return generateGroup(userToDelete, {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
}).then((newGroup) => {
|
||||
group1 = newGroup;
|
||||
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 3,
|
||||
});
|
||||
}).then((res) => {
|
||||
group2 = res.group;
|
||||
otherUser = res.members[0];
|
||||
|
||||
return userToDelete.post(`/groups/${group2._id}/join`);
|
||||
});
|
||||
});
|
||||
|
||||
it('removes user from all groups user was a part of', async () => {
|
||||
return userToDelete.del('/user').then(() => {
|
||||
return otherUser.get(`/groups/${group1._id}`);
|
||||
}).then((fetchedGroup1) => {
|
||||
expect(fetchedGroup1.members).to.be.empty;
|
||||
|
||||
return otherUser.get(`/groups/${group2._id}`);
|
||||
}).then((fetchedGroup2) => {
|
||||
expect(fetchedGroup2.members).to.not.be.empty;
|
||||
|
||||
let userInGroup = find(fetchedGroup2.members, (member) => {
|
||||
return member._id === userToDelete._id;
|
||||
});
|
||||
|
||||
expect(userInGroup).to.not.be.ok;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('pending invitation to group', () => {
|
||||
let group, userToDelete, otherUser;
|
||||
|
||||
beforeEach(async () => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 3,
|
||||
invites: 2,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
otherUser = res.members[0];
|
||||
userToDelete = res.invitees[0];
|
||||
});
|
||||
});
|
||||
|
||||
it('removes invitations from groups', async () => {
|
||||
return userToDelete.del('/user').then(() => {
|
||||
return otherUser.get(`/groups/${group._id}`);
|
||||
}).then((fetchedGroup) => {
|
||||
expect(fetchedGroup.invites).to.have.a.lengthOf(1);
|
||||
expect(fetchedGroup.invites[0]._id).to.not.eql(userToDelete._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,28 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /user', () => {
|
||||
let user;
|
||||
|
||||
before(async () => {
|
||||
let usr = await generateUser();
|
||||
user = await usr.get('/user');
|
||||
});
|
||||
|
||||
it('gets the user object', async () => {
|
||||
expect(user._id).to.eql(user._id);
|
||||
expect(user.auth.local.username).to.eql(user.auth.local.username);
|
||||
expect(user.todos).to.eql(user.todos);
|
||||
expect(user.items).to.eql(user.items);
|
||||
});
|
||||
|
||||
it('does not include password information', async () => {
|
||||
expect(user.auth.local.hashed_password).to.not.exist;
|
||||
expect(user.auth.local.salt).to.not.exist;
|
||||
});
|
||||
|
||||
it('does not include api token', async () => {
|
||||
expect(user.apiToken).to.not.exist;
|
||||
});
|
||||
});
|
||||
@@ -1,16 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /user/tags', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('gets the user\'s tags', async () => {
|
||||
return expect(user.get('/user/tags'))
|
||||
.to.eventually.eql(user.tags);
|
||||
});
|
||||
});
|
||||
@@ -1,25 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /user/tags/id', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('gets a user\'s tag by id', async () => {
|
||||
return expect(user.get(`/user/tags/${user.tags[0].id}`))
|
||||
.to.eventually.eql(user.tags[0]);
|
||||
});
|
||||
|
||||
it('fails for non-existent tags', async () => {
|
||||
return expect(user.get('/user/tags/not-an-id'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageTagNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,201 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration/v2';
|
||||
|
||||
import { each, get } from 'lodash';
|
||||
|
||||
describe('PUT /user', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
context('Allowed Operations', () => {
|
||||
it('updates the user', async () => {
|
||||
await user.put('/user', {
|
||||
'profile.name': 'Frodo',
|
||||
'preferences.costume': true,
|
||||
'stats.hp': 14,
|
||||
});
|
||||
|
||||
await user.sync();
|
||||
|
||||
expect(user.profile.name).to.eql('Frodo');
|
||||
expect(user.preferences.costume).to.eql(true);
|
||||
expect(user.stats.hp).to.eql(14);
|
||||
});
|
||||
});
|
||||
|
||||
context('Top Level Protected Operations', () => {
|
||||
let protectedOperations = {
|
||||
'gem balance': {balance: 100},
|
||||
auth: {'auth.blocked': true, 'auth.timestamps.created': new Date()},
|
||||
contributor: {'contributor.level': 9, 'contributor.admin': true, 'contributor.text': 'some text'},
|
||||
backer: {'backer.tier': 10, 'backer.npc': 'Bilbo'},
|
||||
subscriptions: {'purchased.plan.extraMonths': 500, 'purchased.plan.consecutive.trinkets': 1000},
|
||||
'customization gem purchases': {'purchased.background.tavern': true, 'purchased.skin.bear': true},
|
||||
tasks: {todos: [], habits: [], dailys: [], rewards: []},
|
||||
};
|
||||
|
||||
each(protectedOperations, (data, testName) => {
|
||||
it(`does not allow updating ${testName}`, async () => {
|
||||
let errorText = [];
|
||||
each(data, (value, operation) => {
|
||||
errorText.push(t('messageUserOperationProtected', { operation }));
|
||||
});
|
||||
|
||||
await expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: errorText,
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Sub-Level Protected Operations', () => {
|
||||
let protectedOperations = {
|
||||
'class stat': {'stats.class': 'wizard'},
|
||||
};
|
||||
|
||||
each(protectedOperations, (data, testName) => {
|
||||
it(`does not allow updating ${testName}`, async () => {
|
||||
let errorText = [];
|
||||
each(data, (value, operation) => {
|
||||
errorText.push(t('messageUserOperationProtected', { operation }));
|
||||
});
|
||||
|
||||
await expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: errorText,
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Default Appearance Preferences', () => {
|
||||
let testCases = {
|
||||
shirt: 'yellow',
|
||||
skin: 'ddc994',
|
||||
'hair.color': 'blond',
|
||||
'hair.bangs': 2,
|
||||
'hair.base': 1,
|
||||
'hair.flower': 4,
|
||||
size: 'broad',
|
||||
};
|
||||
|
||||
each(testCases, (item, type) => {
|
||||
const update = {};
|
||||
update[`preferences.${type}`] = item;
|
||||
|
||||
it(`updates user with ${type} that is a default`, async () => {
|
||||
let dbUpdate = {};
|
||||
dbUpdate[`purchased.${type}.${item}`] = true;
|
||||
await user.update(dbUpdate);
|
||||
|
||||
// Sanity checks to make sure user is not already equipped with item
|
||||
expect(get(user.preferences, type)).to.not.eql(item);
|
||||
|
||||
let updatedUser = await user.put('/user', update);
|
||||
|
||||
expect(get(updatedUser.preferences, type)).to.eql(item);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error if user tries to update body size with invalid type', async () => {
|
||||
await expect(user.put('/user', {
|
||||
'preferences.size': 'round',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: ['Must purchase round to set it on preferences.size'],
|
||||
});
|
||||
});
|
||||
|
||||
it('can set beard to default', async () => {
|
||||
await user.update({
|
||||
'purchased.hair.beard': 3,
|
||||
'preferences.hair.beard': 3,
|
||||
});
|
||||
|
||||
let updatedUser = await user.put('/user', {
|
||||
'preferences.hair.beard': 0,
|
||||
});
|
||||
|
||||
expect(updatedUser.preferences.hair.beard).to.eql(0);
|
||||
});
|
||||
|
||||
it('can set mustache to default', async () => {
|
||||
await user.update({
|
||||
'purchased.hair.mustache': 2,
|
||||
'preferences.hair.mustache': 2,
|
||||
});
|
||||
|
||||
let updatedUser = await user.put('/user', {
|
||||
'preferences.hair.mustache': 0,
|
||||
});
|
||||
|
||||
expect(updatedUser.preferences.hair.mustache).to.eql(0);
|
||||
});
|
||||
});
|
||||
|
||||
context('Purchasable Appearance Preferences', () => {
|
||||
let testCases = {
|
||||
background: 'volcano',
|
||||
shirt: 'convict',
|
||||
skin: 'cactus',
|
||||
'hair.base': 7,
|
||||
'hair.beard': 2,
|
||||
'hair.color': 'rainbow',
|
||||
'hair.mustache': 2,
|
||||
};
|
||||
|
||||
each(testCases, (item, type) => {
|
||||
const update = {};
|
||||
update[`preferences.${type}`] = item;
|
||||
|
||||
it(`returns an error if user tries to update ${type} with ${type} the user does not own`, async () => {
|
||||
await expect(user.put('/user', update)).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: [`Must purchase ${item} to set it on preferences.${type}`],
|
||||
});
|
||||
});
|
||||
|
||||
it(`updates user with ${type} user does own`, async () => {
|
||||
let dbUpdate = {};
|
||||
dbUpdate[`purchased.${type}.${item}`] = true;
|
||||
await user.update(dbUpdate);
|
||||
|
||||
// Sanity check to make sure user is not already equipped with item
|
||||
expect(get(user.preferences, type)).to.not.eql(item);
|
||||
|
||||
let updatedUser = await user.put('/user', update);
|
||||
|
||||
expect(get(updatedUser.preferences, type)).to.eql(item);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Improvement Categories', () => {
|
||||
it('sets valid categories', async () => {
|
||||
await user.put('/user', {
|
||||
'preferences.improvementCategories': ['work', 'school'],
|
||||
});
|
||||
|
||||
await user.sync();
|
||||
|
||||
expect(user.preferences.improvementCategories).to.eql(['work', 'school']);
|
||||
});
|
||||
|
||||
it('discards invalid categories', async () => {
|
||||
await expect(user.put('/user', {
|
||||
'preferences.improvementCategories': ['work', 'procrastination', 'school'],
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: [
|
||||
'Validator failed for path `preferences.improvementCategories` with value `work,procrastination,school`',
|
||||
],
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,98 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
import { each } from 'lodash';
|
||||
|
||||
describe('GET /user/anonymized', () => {
|
||||
let user, anonymizedUser;
|
||||
|
||||
before(async () => {
|
||||
user = await generateUser({
|
||||
'inbox.messages': {
|
||||
'the-message-id': {
|
||||
sort: 214,
|
||||
user: 'Some user',
|
||||
backer: {},
|
||||
contributor: {
|
||||
text: 'Blacksmith',
|
||||
level: 2,
|
||||
contributions: 'Made some contributions',
|
||||
admin: false,
|
||||
},
|
||||
uuid: 'some-users-uuid',
|
||||
flagCount: 0,
|
||||
flags: {},
|
||||
likes: {},
|
||||
timestamp: 1444154258699.0000000000000000,
|
||||
text: 'Lorem ipsum',
|
||||
id: 'the-messages-id',
|
||||
sent: true,
|
||||
},
|
||||
},
|
||||
});
|
||||
|
||||
await user.post('/user/tasks', {
|
||||
text: 'some private text',
|
||||
notes: 'some private notes',
|
||||
checklist: [
|
||||
{text: 'a private checklist'},
|
||||
{text: 'another private checklist'},
|
||||
],
|
||||
type: 'daily',
|
||||
});
|
||||
|
||||
anonymizedUser = await user.get('/user/anonymized');
|
||||
});
|
||||
|
||||
it('retains user id', async () => {
|
||||
expect(anonymizedUser._id).to.eql(user._id);
|
||||
});
|
||||
|
||||
it('removes credentials and financial information', async () => {
|
||||
expect(anonymizedUser.apiToken).to.not.exist;
|
||||
expect(anonymizedUser.auth.local).to.not.exist;
|
||||
expect(anonymizedUser.auth.facebook).to.not.exist;
|
||||
expect(anonymizedUser.purchased.plan).to.not.exist;
|
||||
});
|
||||
|
||||
it('removes profile information', async () => {
|
||||
expect(anonymizedUser.profile).to.not.exist;
|
||||
expect(anonymizedUser.contributor).to.not.exist;
|
||||
expect(anonymizedUser.achievements.challenges).to.not.exist;
|
||||
});
|
||||
|
||||
it('removes social information', async () => {
|
||||
expect(anonymizedUser.newMessages).to.not.exist;
|
||||
expect(anonymizedUser.invitations).to.not.exist;
|
||||
expect(anonymizedUser.items.special.nyeReceived).to.not.exist;
|
||||
expect(anonymizedUser.items.special.valentineReceived).to.not.exist;
|
||||
|
||||
each(anonymizedUser.inbox.messages, (msg) => {
|
||||
expect(msg.text).to.eql('inbox message text');
|
||||
});
|
||||
});
|
||||
|
||||
it('anonymizes task info', async () => {
|
||||
each(['habits', 'todos', 'dailys', 'rewards'], (tasks) => {
|
||||
each(anonymizedUser[tasks], (task) => {
|
||||
expect(task.text).to.eql('task text');
|
||||
expect(task.notes).to.eql('task notes');
|
||||
|
||||
each(task.checklist, (box) => {
|
||||
expect(box.text).to.match(/item\d*/);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it('anonymizes tags', async () => {
|
||||
each(anonymizedUser.tags, (tag) => {
|
||||
expect(tag.name).to.eql('tag');
|
||||
expect(tag.challenge).to.eql('challenge');
|
||||
});
|
||||
});
|
||||
|
||||
it('removes webhooks', async () => {
|
||||
expect(anonymizedUser.webhooks).to.not.exist;
|
||||
});
|
||||
});
|
||||
@@ -1,62 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
import { each } from 'lodash';
|
||||
|
||||
describe('POST /user/batch-update', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
context('allowed operations', () => {
|
||||
it('makes batch operations', async () => {
|
||||
let task = (await user.get('/user/tasks'))[0];
|
||||
|
||||
let updatedUser = await user.post('/user/batch-update', [
|
||||
{op: 'update', body: {'stats.hp': 30}},
|
||||
{op: 'update', body: {'profile.name': 'Samwise'}},
|
||||
{op: 'score', params: { direction: 'up', id: task.id }},
|
||||
]);
|
||||
|
||||
expect(updatedUser.stats.hp).to.eql(30);
|
||||
expect(updatedUser.profile.name).to.eql('Samwise');
|
||||
|
||||
let fetchedTask = await user.get(`/user/tasks/${task.id}`);
|
||||
|
||||
expect(fetchedTask.value).to.be.greaterThan(task.value);
|
||||
});
|
||||
});
|
||||
|
||||
xcontext('development only operations', () => { // These tests will fail if your NODE_ENV is set to 'development' instead of 'testing'
|
||||
let protectedOperations = {
|
||||
'Add Ten Gems': 'addTenGems',
|
||||
'Add Hourglass': 'addHourglass',
|
||||
};
|
||||
|
||||
each(protectedOperations, (operation, description) => {
|
||||
it(`it sends back a 500 error for ${description} operation`, async () => {
|
||||
return expect(user.post('/user/batch-update', [
|
||||
{ op: operation },
|
||||
])).to.eventually.be.rejected.and.eql({
|
||||
code: 500,
|
||||
text: t('messageUserOperationNotFound', { operation }),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('unknown operations', () => {
|
||||
it('sends back a 500 error', async () => {
|
||||
return expect(user.post('/user/batch-update', [
|
||||
{op: 'aNotRealOperation'},
|
||||
])).to.eventually.be.rejected.and.eql({
|
||||
code: 500,
|
||||
text: t('messageUserOperationNotFound', { operation: 'aNotRealOperation' }),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,24 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
xdescribe('POST /user/pushDevice', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('registers a device id', async () => {
|
||||
return user.post('/user/pushDevice', {
|
||||
regId: '123123',
|
||||
type: 'android',
|
||||
}).then((devices) => {
|
||||
let device = devices[0];
|
||||
|
||||
expect(device._id).to.exist;
|
||||
expect(device.regId).to.eql('123123');
|
||||
expect(device.type).to.eql('android');
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,40 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('DELETE /user/tasks/:id', () => {
|
||||
let user, task;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
task = user.todos[0];
|
||||
});
|
||||
|
||||
it('deletes a task', async () => {
|
||||
await user.del(`/user/tasks/${task.id}`);
|
||||
|
||||
await expect(user.get(`/user/tasks/${task.id}`)).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageTaskNotFound'),
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error if the task does not exist', async () => {
|
||||
return expect(user.del('/user/tasks/task-that-does-not-exist'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageTaskNotFound'),
|
||||
});
|
||||
});
|
||||
|
||||
it('does not delete another user\'s task', async () => {
|
||||
return expect(generateUser().then((otherUser) => {
|
||||
let otherUsersTask = otherUser.todos[0];
|
||||
return user.del(`/user/tasks/${otherUsersTask.id}`);
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: 'Task not found.',
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,25 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /user/tasks/', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return generateUser().then((_user) => {
|
||||
user = _user;
|
||||
});
|
||||
});
|
||||
|
||||
it('gets all tasks', async () => {
|
||||
return user.get('/user/tasks/').then((tasks) => {
|
||||
expect(tasks).to.be.an('array');
|
||||
expect(tasks.length).to.equal(1);
|
||||
|
||||
let task = tasks[0];
|
||||
expect(task.id).to.exist;
|
||||
expect(task.type).to.exist;
|
||||
expect(task.text).to.exist;
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,42 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('GET /user/tasks/:id', () => {
|
||||
let user, task;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
task = user.todos[0];
|
||||
});
|
||||
|
||||
it('gets a task', async () => {
|
||||
return user.get(`/user/tasks/${task.id}`).then((foundTask) => {
|
||||
expect(foundTask.id).to.eql(task.id);
|
||||
expect(foundTask.text).to.eql(task.text);
|
||||
expect(foundTask.notes).to.eql(task.notes);
|
||||
expect(foundTask.value).to.eql(task.value);
|
||||
expect(foundTask.type).to.eql(task.type);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error if the task does not exist', async () => {
|
||||
return expect(user.get('/user/tasks/task-that-does-not-exist'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageTaskNotFound'),
|
||||
});
|
||||
});
|
||||
|
||||
it('does not get another user\'s task', async () => {
|
||||
return expect(generateUser().then((otherUser) => {
|
||||
let otherUsersTask = otherUser.todos[0];
|
||||
|
||||
return user.get(`/user/tasks/${otherUsersTask.id}`);
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageTaskNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,26 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /user/tasks/clear-completed', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
return generateUser().then((_user) => {
|
||||
user = _user;
|
||||
});
|
||||
});
|
||||
|
||||
it('removes all completed todos', async () => {
|
||||
let toComplete = await user.post('/user/tasks', {
|
||||
type: 'todo',
|
||||
text: 'done',
|
||||
});
|
||||
|
||||
await user.post(`/user/tasks/${toComplete._id}/up`);
|
||||
|
||||
let todos = await user.get('/user/tasks?type=todo');
|
||||
let uncomplete = await user.post('/user/tasks/clear-completed');
|
||||
expect(todos.length).to.equal(uncomplete.length + 1);
|
||||
});
|
||||
});
|
||||
@@ -1,66 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('POST /user/tasks', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
});
|
||||
|
||||
it('creates a task', async () => {
|
||||
return user.post('/user/tasks').then((task) => {
|
||||
expect(task.id).to.exist;
|
||||
});
|
||||
});
|
||||
|
||||
it('creates a habit by default', async () => {
|
||||
return expect(user.post('/user/tasks'))
|
||||
.to.eventually.have.property('type', 'habit');
|
||||
});
|
||||
|
||||
it('creates a task with specified values', async () => {
|
||||
return user.post('/user/tasks', {
|
||||
type: 'daily',
|
||||
text: 'My task',
|
||||
notes: 'My notes',
|
||||
frequency: 'daily',
|
||||
}).then((task) => {
|
||||
expect(task.type).to.eql('daily');
|
||||
expect(task.text).to.eql('My task');
|
||||
expect(task.notes).to.eql('My notes');
|
||||
expect(task.frequency).to.eql('daily');
|
||||
});
|
||||
});
|
||||
|
||||
xit('does not create a task with an id that already exists', async () => {
|
||||
let todo = user.todos[0];
|
||||
|
||||
return expect(user.post('/user/tasks', {
|
||||
id: todo.id,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 409,
|
||||
text: t('messageDuplicateTaskID'),
|
||||
});
|
||||
});
|
||||
|
||||
xit('TODO: no error is thrown - throws a 500 validation error if invalid type is posted', async () => {
|
||||
return expect(user.post('/user/tasks', {
|
||||
type: 'not-valid',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 500,
|
||||
text: 'Cannot call method \'indexOf\' of undefined',
|
||||
});
|
||||
});
|
||||
|
||||
xit('TODO: no error is thrown - throws a 500 validation error if invalid data is posted', async () => {
|
||||
return expect(user.post('/user/tasks', {
|
||||
frequency: 'not-valid',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 500,
|
||||
text: 'Task validation failed',
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -1,64 +0,0 @@
|
||||
import {
|
||||
generateUser,
|
||||
} from '../../../../helpers/api-integration/v2';
|
||||
|
||||
describe('PUT /user/tasks/:id', () => {
|
||||
let user, task;
|
||||
|
||||
beforeEach(async () => {
|
||||
user = await generateUser();
|
||||
task = user.todos[0];
|
||||
});
|
||||
|
||||
it('does not update the id of the task', async () => {
|
||||
return user.put(`/user/tasks/${task.id}`, {
|
||||
id: 'some-thing',
|
||||
}).then((updatedTask) => {
|
||||
expect(updatedTask.id).to.eql(task.id);
|
||||
expect(updatedTask.id).to.not.eql('some-thing');
|
||||
});
|
||||
});
|
||||
|
||||
it('does not update the type of the task', async () => {
|
||||
return user.put(`/user/tasks/${task.id}`, {
|
||||
type: 'habit',
|
||||
}).then((updatedTask) => {
|
||||
expect(updatedTask.type).to.eql(task.type);
|
||||
expect(updatedTask.type).to.not.eql('habit');
|
||||
});
|
||||
});
|
||||
|
||||
it('updates text, attribute, priority and notes', async () => {
|
||||
return user.put(`/user/tasks/${task.id}`, {
|
||||
text: 'new text',
|
||||
notes: 'new notes',
|
||||
priority: 0.1,
|
||||
attribute: 'str',
|
||||
}).then((updatedTask) => {
|
||||
expect(updatedTask.text).to.eql('new text');
|
||||
expect(updatedTask.notes).to.eql('new notes');
|
||||
expect(updatedTask.priority).to.eql(0.1);
|
||||
expect(updatedTask.attribute).to.eql('str');
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error if the task does not exist', async () => {
|
||||
return expect(user.put('/user/tasks/task-id-that-does-not-exist'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: 'Task not found.',
|
||||
});
|
||||
});
|
||||
|
||||
it('does not update another user\'s task', async () => {
|
||||
return expect(generateUser().then((otherUser) => {
|
||||
let otherUsersTask = otherUser.todos[0];
|
||||
return user.put(`/user/tasks/${otherUsersTask._id}`, {
|
||||
name: 'some name',
|
||||
});
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: 'Task not found.',
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -2,7 +2,7 @@ import {
|
||||
generateUser,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-v3-integration.helper';
|
||||
import { encrypt } from '../../../../../website/server/libs/api-v3/encryption';
|
||||
import { encrypt } from '../../../../../website/server/libs/encryption';
|
||||
import { v4 as generateUUID } from 'uuid';
|
||||
|
||||
describe('GET /email/unsubscribe', () => {
|
||||
|
||||
@@ -6,7 +6,7 @@ import {
|
||||
} from '../../../../../helpers/api-integration/v3';
|
||||
import { v4 as generateRandomUserName } from 'uuid';
|
||||
import { each } from 'lodash';
|
||||
import { encrypt } from '../../../../../../website/server/libs/api-v3/encryption';
|
||||
import { encrypt } from '../../../../../../website/server/libs/encryption';
|
||||
|
||||
describe('POST /user/auth/local/register', () => {
|
||||
context('username and email are free', () => {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
// TODO These tests are pretty brittle
|
||||
// rewrite them to not depend on nock
|
||||
// Trust that the amplitude module works as intended and sends the requests
|
||||
import analyticsService from '../../../../../website/server/libs/api-v3/analyticsService';
|
||||
import analyticsService from '../../../../../website/server/libs/analyticsService';
|
||||
|
||||
import nock from 'nock';
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import baseModel from '../../../../../website/server/libs/api-v3/baseModel';
|
||||
import baseModel from '../../../../../website/server/libs/baseModel';
|
||||
import mongoose from 'mongoose';
|
||||
|
||||
describe('Base model plugin', () => {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import {
|
||||
getManifestFiles,
|
||||
} from '../../../../../website/server/libs/api-v3/buildManifest';
|
||||
} from '../../../../../website/server/libs/buildManifest';
|
||||
|
||||
describe('Build Manifest', () => {
|
||||
describe('getManifestFiles', () => {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import mongoose from 'mongoose';
|
||||
import {
|
||||
removeFromArray,
|
||||
} from '../../../../../website/server/libs/api-v3/collectionManipulators';
|
||||
} from '../../../../../website/server/libs/collectionManipulators';
|
||||
|
||||
describe('Collection Manipulators', () => {
|
||||
describe('removeFromArray', () => {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
/* eslint-disable global-require */
|
||||
import moment from 'moment';
|
||||
import Bluebird from 'bluebird';
|
||||
import { recoverCron, cron } from '../../../../../website/server/libs/api-v3/cron';
|
||||
import { recoverCron, cron } from '../../../../../website/server/libs/cron';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
import * as Tasks from '../../../../../website/server/models/task';
|
||||
import { clone } from 'lodash';
|
||||
|
||||
@@ -4,7 +4,7 @@ import nconf from 'nconf';
|
||||
import nodemailer from 'nodemailer';
|
||||
import Bluebird from 'bluebird';
|
||||
import requireAgain from 'require-again';
|
||||
import logger from '../../../../../website/server/libs/api-v3/logger';
|
||||
import logger from '../../../../../website/server/libs/logger';
|
||||
import { TAVERN_ID } from '../../../../../website/server/models/group';
|
||||
|
||||
function defer () {
|
||||
@@ -50,7 +50,7 @@ function getUser () {
|
||||
}
|
||||
|
||||
describe('emails', () => {
|
||||
let pathToEmailLib = '../../../../../website/server/libs/api-v3/email';
|
||||
let pathToEmailLib = '../../../../../website/server/libs/email';
|
||||
|
||||
describe('sendEmail', () => {
|
||||
it('can send an email using the default transport', () => {
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import {
|
||||
encrypt,
|
||||
decrypt,
|
||||
} from '../../../../../website/server/libs/api-v3/encryption';
|
||||
} from '../../../../../website/server/libs/encryption';
|
||||
|
||||
describe('encryption', () => {
|
||||
it('can encrypt and decrypt', () => {
|
||||
|
||||
@@ -5,7 +5,7 @@ import {
|
||||
BadRequest,
|
||||
InternalServerError,
|
||||
NotFound,
|
||||
} from '../../../../../website/server/libs/api-v3/errors';
|
||||
} from '../../../../../website/server/libs/errors';
|
||||
|
||||
describe('Custom Errors', () => {
|
||||
describe('CustomError', () => {
|
||||
|
||||
@@ -2,7 +2,7 @@ import {
|
||||
translations,
|
||||
localePath,
|
||||
langCodes,
|
||||
} from '../../../../../website/server/libs/api-v3/i18n';
|
||||
} from '../../../../../website/server/libs/i18n';
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@ import requireAgain from 'require-again';
|
||||
|
||||
/* eslint-disable global-require */
|
||||
describe('logger', () => {
|
||||
let pathToLoggerLib = '../../../../../website/server/libs/api-v3/logger';
|
||||
let pathToLoggerLib = '../../../../../website/server/libs/logger';
|
||||
let infoSpy;
|
||||
let errorSpy;
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
import {
|
||||
encrypt as encryptPassword,
|
||||
makeSalt,
|
||||
} from '../../../../../website/server/libs/api-v3/password';
|
||||
} from '../../../../../website/server/libs/password';
|
||||
|
||||
describe('Password Utilities', () => {
|
||||
describe('Encrypt', () => {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import * as sender from '../../../../../website/server/libs/api-v3/email';
|
||||
import * as api from '../../../../../website/server/libs/api-v3/payments';
|
||||
import analytics from '../../../../../website/server/libs/api-v3/analyticsService';
|
||||
import * as sender from '../../../../../website/server/libs/email';
|
||||
import * as api from '../../../../../website/server/libs/payments';
|
||||
import analytics from '../../../../../website/server/libs/analyticsService';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
import moment from 'moment';
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import { preenHistory } from '../../../../../website/server/libs/api-v3/preening';
|
||||
import { preenHistory } from '../../../../../website/server/libs/preening';
|
||||
import moment from 'moment';
|
||||
import sinon from 'sinon'; // eslint-disable-line no-shadow
|
||||
import { generateHistory } from '../../../../helpers/api-unit.helper.js';
|
||||
|
||||
@@ -6,7 +6,7 @@ import nconf from 'nconf';
|
||||
describe('pushNotifications', () => {
|
||||
let user;
|
||||
let sendPushNotification;
|
||||
let pathToPushNotifications = '../../../../../website/server/libs/api-v3/pushNotifications';
|
||||
let pathToPushNotifications = '../../../../../website/server/libs/pushNotifications';
|
||||
let gcmSendSpy;
|
||||
let apnSendSpy;
|
||||
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
import setupNconf from '../../../../../website/server/libs/api-v3/setupNconf';
|
||||
import setupNconf from '../../../../../website/server/libs/setupNconf';
|
||||
|
||||
import path from 'path';
|
||||
import nconf from 'nconf';
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import request from 'request';
|
||||
import { sendTaskWebhook } from '../../../../../website/server/libs/api-v3/webhook';
|
||||
import { sendTaskWebhook } from '../../../../../website/server/libs/webhook';
|
||||
|
||||
describe('webhooks', () => {
|
||||
beforeEach(() => {
|
||||
|
||||
@@ -4,13 +4,13 @@ import {
|
||||
generateReq,
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import analyticsService from '../../../../../website/server/libs/api-v3/analyticsService';
|
||||
import analyticsService from '../../../../../website/server/libs/analyticsService';
|
||||
import nconf from 'nconf';
|
||||
import requireAgain from 'require-again';
|
||||
|
||||
describe('analytics middleware', () => {
|
||||
let res, req, next;
|
||||
let pathToAnalyticsMiddleware = '../../../../../website/server/middlewares/api-v3/analytics';
|
||||
let pathToAnalyticsMiddleware = '../../../../../website/server/middlewares/analytics';
|
||||
|
||||
beforeEach(() => {
|
||||
res = generateRes();
|
||||
|
||||
@@ -4,7 +4,7 @@ import {
|
||||
generateReq,
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import cors from '../../../../../website/server/middlewares/api-v3/cors';
|
||||
import cors from '../../../../../website/server/middlewares/cors';
|
||||
|
||||
describe('cors middleware', () => {
|
||||
let res, req, next;
|
||||
|
||||
@@ -5,13 +5,13 @@ import {
|
||||
generateDaily,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import { cloneDeep } from 'lodash';
|
||||
import cronMiddleware from '../../../../../website/server/middlewares/api-v3/cron';
|
||||
import cronMiddleware from '../../../../../website/server/middlewares/cron';
|
||||
import moment from 'moment';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
import { model as Group } from '../../../../../website/server/models/group';
|
||||
import * as Tasks from '../../../../../website/server/models/task';
|
||||
import analyticsService from '../../../../../website/server/libs/api-v3/analyticsService';
|
||||
import * as cronLib from '../../../../../website/server/libs/api-v3/cron';
|
||||
import analyticsService from '../../../../../website/server/libs/analyticsService';
|
||||
import * as cronLib from '../../../../../website/server/libs/cron';
|
||||
import { v4 as generateUUID } from 'uuid';
|
||||
|
||||
describe('cron middleware', () => {
|
||||
|
||||
@@ -5,8 +5,8 @@ import {
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import i18n from '../../../../../common/script/i18n';
|
||||
import { ensureAdmin, ensureSudo } from '../../../../../website/server/middlewares/api-v3/ensureAccessRight';
|
||||
import { NotAuthorized } from '../../../../../website/server/libs/api-v3/errors';
|
||||
import { ensureAdmin, ensureSudo } from '../../../../../website/server/middlewares/ensureAccessRight';
|
||||
import { NotAuthorized } from '../../../../../website/server/libs/errors';
|
||||
|
||||
describe('ensure access middlewares', () => {
|
||||
let res, req, next;
|
||||
|
||||
@@ -4,8 +4,8 @@ import {
|
||||
generateReq,
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import ensureDevelpmentMode from '../../../../../website/server/middlewares/api-v3/ensureDevelpmentMode';
|
||||
import { NotFound } from '../../../../../website/server/libs/api-v3/errors';
|
||||
import ensureDevelpmentMode from '../../../../../website/server/middlewares/ensureDevelpmentMode';
|
||||
import { NotFound } from '../../../../../website/server/libs/errors';
|
||||
import nconf from 'nconf';
|
||||
|
||||
describe('developmentMode middleware', () => {
|
||||
|
||||
@@ -4,15 +4,15 @@ import {
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
|
||||
import errorHandler from '../../../../../website/server/middlewares/api-v3/errorHandler';
|
||||
import responseMiddleware from '../../../../../website/server/middlewares/api-v3/response';
|
||||
import errorHandler from '../../../../../website/server/middlewares/errorHandler';
|
||||
import responseMiddleware from '../../../../../website/server/middlewares/response';
|
||||
import {
|
||||
getUserLanguage,
|
||||
attachTranslateFunction,
|
||||
} from '../../../../../website/server/middlewares/api-v3/language';
|
||||
} from '../../../../../website/server/middlewares/language';
|
||||
|
||||
import { BadRequest } from '../../../../../website/server/libs/api-v3/errors';
|
||||
import logger from '../../../../../website/server/libs/api-v3/logger';
|
||||
import { BadRequest } from '../../../../../website/server/libs/errors';
|
||||
import logger from '../../../../../website/server/libs/logger';
|
||||
|
||||
describe('errorHandler', () => {
|
||||
let res, req, next;
|
||||
|
||||
@@ -6,7 +6,7 @@ import {
|
||||
import {
|
||||
getUserLanguage,
|
||||
attachTranslateFunction,
|
||||
} from '../../../../../website/server/middlewares/api-v3/language';
|
||||
} from '../../../../../website/server/middlewares/language';
|
||||
import common from '../../../../../common';
|
||||
import Bluebird from 'bluebird';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
|
||||
@@ -8,7 +8,7 @@ import requireAgain from 'require-again';
|
||||
|
||||
describe('maintenance mode middleware', () => {
|
||||
let res, req, next;
|
||||
let pathToMaintenanceModeMiddleware = '../../../../../website/server/middlewares/api-v3/maintenanceMode';
|
||||
let pathToMaintenanceModeMiddleware = '../../../../../website/server/middlewares/maintenanceMode';
|
||||
|
||||
beforeEach(() => {
|
||||
res = generateRes();
|
||||
|
||||
@@ -3,7 +3,7 @@ import {
|
||||
generateReq,
|
||||
generateNext,
|
||||
} from '../../../../helpers/api-unit.helper';
|
||||
import responseMiddleware from '../../../../../website/server/middlewares/api-v3/response';
|
||||
import responseMiddleware from '../../../../../website/server/middlewares/response';
|
||||
|
||||
describe('response middleware', () => {
|
||||
let res, req, next;
|
||||
|
||||
@@ -2,7 +2,7 @@ import { sleep } from '../../../../helpers/api-unit.helper';
|
||||
import { model as Group } from '../../../../../website/server/models/group';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
import { quests as questScrolls } from '../../../../../common/script/content';
|
||||
import * as email from '../../../../../website/server/libs/api-v3/email';
|
||||
import * as email from '../../../../../website/server/libs/email';
|
||||
import validator from 'validator';
|
||||
import { TAVERN_ID } from '../../../../../common/script/';
|
||||
|
||||
|
||||
@@ -2,7 +2,7 @@ import { model as Challenge } from '../../../../../website/server/models/challen
|
||||
import { model as Group } from '../../../../../website/server/models/group';
|
||||
import { model as User } from '../../../../../website/server/models/user';
|
||||
import * as Tasks from '../../../../../website/server/models/task';
|
||||
import { InternalServerError } from '../../../../../website/server/libs/api-v3/errors';
|
||||
import { InternalServerError } from '../../../../../website/server/libs/errors';
|
||||
import { each } from 'lodash';
|
||||
import { generateHistory } from '../../../../helpers/api-unit.helper.js';
|
||||
|
||||
|
||||
Reference in New Issue
Block a user