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

Merge branch 'api-v3' into api-v3-groups

Browse Source
This commit is contained in:
Blade Barringer
2016-01-02 22:29:59 -06:00
parent a775c992ab 37916271e8
commit 76c97dfa6e
32 changed files with 697 additions and 868 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
common/script/content/gear/sets/special/index.js
View File

@@ -445,7 +445,7 @@ let head = {
canOwn: ownsItem('head_special_fireCoralCirclet'), canOwn: ownsItem('head_special_fireCoralCirclet'),
}, },
nye: { nye: {
event: EVENTS.winter, event: EVENTS.winter2016,
text: t('headSpecialNyeText'), text: t('headSpecialNyeText'),
notes: t('headSpecialNyeNotes'), notes: t('headSpecialNyeNotes'),
value: 0, value: 0,

4
package.json
View File

@@ -100,13 +100,13 @@
"coverage": "COVERAGE=true mocha --require register-handlers.js --reporter html-cov > coverage.html; open coverage.html" "coverage": "COVERAGE=true mocha --require register-handlers.js --reporter html-cov > coverage.html; open coverage.html"
}, },
"devDependencies": { "devDependencies": {
"babel-eslint": "^4.1.6",
"chai": "^3.4.0", "chai": "^3.4.0",
"chai-as-promised": "^5.1.0", "chai-as-promised": "^5.1.0",
"coveralls": "^2.11.2", "coveralls": "^2.11.2",
"csv": "~0.3.6", "csv": "~0.3.6",
"deep-diff": "~0.1.4", "deep-diff": "~0.1.4",
"eslint": "^1.9.0", "eslint": "^1.9.0",
"babel-eslint": "^4.1.6",
"eslint-plugin-babel": "^3.0.0", "eslint-plugin-babel": "^3.0.0",
"eslint-plugin-mocha": "^1.1.0", "eslint-plugin-mocha": "^1.1.0",
"event-stream": "^3.2.2", "event-stream": "^3.2.2",
@@ -124,7 +124,7 @@
"mongodb": "^2.0.46", "mongodb": "^2.0.46",
"mongoskin": "~0.6.1", "mongoskin": "~0.6.1",
"nock": "^2.17.0", "nock": "^2.17.0",
"phantomjs": "^1.9.18", "phantomjs": "^1.9",
"protractor": "~2.5.1", "protractor": "~2.5.1",
"rewire": "^2.3.3", "rewire": "^2.3.3",
"rimraf": "^2.4.3", "rimraf": "^2.4.3",

1
tasks/gulp-eslint.js
View File

@@ -23,7 +23,6 @@ const TEST_FILES = [
'./test/**/*.js', './test/**/*.js',
// @TODO remove these negations as the test files are cleaned up. // @TODO remove these negations as the test files are cleaned up.
'!./test/api-legacy/**/*', '!./test/api-legacy/**/*',
'!./test/api/v2/**/*',
'!./test/common/simulations/**/*', '!./test/common/simulations/**/*',
'!./test/content/**/*', '!./test/content/**/*',
'!./test/e2e/**/*', '!./test/e2e/**/*',

110
test/api/v2/groups/GET-groups.test.js
View File

@@ -10,81 +10,60 @@ describe('GET /groups', () => {
let user; let user;
before(() => { before(async () => {
let leader, createdGroup;
// Set up a world with a mixture of public and private guilds // Set up a world with a mixture of public and private guilds
// Invite user to a few of them // Invite user to a few of them
return resetHabiticaDB().then(() => { await resetHabiticaDB();
return generateUser();
}).then((_user) => {
user = _user;
return generateUser({ user = await generateUser();
balance: 10, let leader = await generateUser({ balance: 10 });
});
}).then((_user) => {
leader = _user;
let publicGuildWithUserAsMember = generateGroup(leader, { await generateGroup(leader, {
name: 'public guild - is member', name: 'public guild - is member',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
members: [leader._id, user._id], members: [leader._id, user._id],
}); });
let publicGuildWithoutUserAsMember = generateGroup(leader, { await generateGroup(leader, {
name: 'public guild - is not member', name: 'public guild - is not member',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}); });
let privateGuildWithUserAsMember = generateGroup(leader, { await generateGroup(leader, {
name: 'private guild - is member', name: 'private guild - is member',
type: 'guild', type: 'guild',
privacy: 'private', privacy: 'private',
members: [leader._id, user._id], members: [leader._id, user._id],
}); });
let privateGuildWithoutUserAsMember = generateGroup(leader, { await generateGroup(leader, {
name: 'private guild - is not member', name: 'private guild - is not member',
type: 'guild', type: 'guild',
privacy: 'private', privacy: 'private',
}); });
let partyWithoutUserAsMember = generateGroup(leader, { await generateGroup(leader, {
name: 'party name', name: 'party - is not member',
type: 'party', type: 'party',
privacy: 'private', privacy: 'private',
}); });
let promises = [ await user.post('/groups', {
publicGuildWithUserAsMember, name: 'party - is member',
publicGuildWithoutUserAsMember, type: 'party',
privateGuildWithUserAsMember, privacy: 'private',
privateGuildWithoutUserAsMember,
partyWithoutUserAsMember,
];
return Promise.all(promises);
}).then((groups) => {
return user.post('/groups', {
type: 'party',
name: 'user\'s party',
privacy: 'private',
});
}); });
}); });
context('no query passed in', () => { 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'); 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', () => { context('tavern passed in as query', () => {
it('returns only the tavern', async () => {
it('returns only the tavern', () => { await expect(user.get('/groups', null, {type: 'tavern'}))
return expect(user.get('/groups', null, {type: 'tavern'}))
.to.eventually.have.a.lengthOf(1) .to.eventually.have.a.lengthOf(1)
.and.to.have.deep.property('[0]') .and.to.have.deep.property('[0]')
.and.to.have.property('_id', 'habitrpg'); .and.to.have.property('_id', 'habitrpg');
@@ -92,9 +71,8 @@ describe('GET /groups', () => {
}); });
context('party passed in as query', () => { context('party passed in as query', () => {
it('returns only the user\'s party', async () => {
it('returns only the user\'s party', () => { await expect(user.get('/groups', null, {type: 'party'}))
return expect(user.get('/groups', null, {type: 'party'}))
.to.eventually.have.a.lengthOf(1) .to.eventually.have.a.lengthOf(1)
.and.to.have.deep.property('[0]') .and.to.have.deep.property('[0]')
.and.to.have.property('leader', user._id); .and.to.have.property('leader', user._id);
@@ -102,17 +80,15 @@ describe('GET /groups', () => {
}); });
context('public passed in as query', () => { context('public passed in as query', () => {
it('returns all public guilds', async () => {
it('returns all public guilds', () => { await expect(user.get('/groups', null, {type: 'public'}))
return expect(user.get('/groups', null, {type: 'public'}))
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS); .to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
}); });
}); });
context('guilds passed in as query', () => { context('guilds passed in as query', () => {
it('returns all guilds user is a part of ', async () => {
it('returns all guilds user is a part of ', () => { await expect(user.get('/groups', null, {type: 'guilds'}))
return expect(user.get('/groups', null, {type: 'guilds'}))
.to.eventually.have.a.lengthOf(NUMBER_OF_USERS_GUILDS); .to.eventually.have.a.lengthOf(NUMBER_OF_USERS_GUILDS);
}); });
}); });

286
test/api/v2/groups/GET-groups_id.test.js
View File

@@ -5,74 +5,66 @@ import {
} from '../../../helpers/api-integration.helper'; } from '../../../helpers/api-integration.helper';
import { import {
find, find,
each each,
} from 'lodash'; } from 'lodash';
describe('GET /groups/:id', () => { describe('GET /groups/:id', () => {
let typesOfGroups = {}; let typesOfGroups = {};
typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' }; typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' }; typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
typesOfGroups['party'] = { type: 'party', privacy: 'private' }; typesOfGroups.party = { type: 'party', privacy: 'private' };
each(typesOfGroups, (groupData, groupType) => { each(typesOfGroups, (groupDetails, groupType) => {
context(`Member of a ${groupType}`, () => { context(`Member of a ${groupType}`, () => {
let leader, member, createdGroup; let leader, member, createdGroup;
before(() => { before(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 30, members: 30,
groupDetails: { groupDetails,
name: 'test guild',
type: 'guild',
privacy: 'public',
},
}).then((res) => {
leader = res.leader;
member = res.members[0];
createdGroup = res.group;
}); });
leader = groupData.leader;
member = groupData.members[0];
createdGroup = groupData.group;
}); });
it('returns the group object', () => { it('returns the group object', async () => {
return member.get(`/groups/${createdGroup._id}`).then((group) => { let group = await member.get(`/groups/${createdGroup._id}`);
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name); expect(group._id).to.eql(createdGroup._id);
expect(group.type).to.eql(createdGroup.type); expect(group.name).to.eql(createdGroup.name);
expect(group.privacy).to.eql(createdGroup.privacy); expect(group.type).to.eql(createdGroup.type);
}); expect(group.privacy).to.eql(createdGroup.privacy);
}); });
it('transforms members array to an array of user objects', () => { it('transforms members array to an array of user objects', async () => {
return member.get(`/groups/${createdGroup._id}`).then((group) => { let group = await member.get(`/groups/${createdGroup._id}`);
let member = group.members[0]; let someMember = group.members[0];
expect(member._id).to.exist;
expect(member.profile.name).to.exist; expect(someMember._id).to.exist;
expect(member.contributor).to.exist; expect(someMember.profile.name).to.exist;
expect(member.achievements).to.exist; expect(someMember.contributor).to.exist;
expect(member.items).to.exist; expect(someMember.achievements).to.exist;
}); expect(someMember.items).to.exist;
}); });
it('transforms leader id to leader object', () => { it('transforms leader id to leader object', async () => {
return member.get(`/groups/${createdGroup._id}`).then((group) => { 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._id).to.eql(leader._id);
expect(group.leader.items).to.exist; expect(group.leader.profile.name).to.eql(leader.profile.name);
expect(group.leader.stats).to.exist; expect(group.leader.items).to.exist;
expect(group.leader.achievements).to.exist; expect(group.leader.stats).to.exist;
expect(group.leader.contributor).to.exist; expect(group.leader.achievements).to.exist;
}); expect(group.leader.contributor).to.exist;
}); });
it('includes the user in the members list', () => { it('includes the user in the members list', async () => {
return member.get(`/groups/${createdGroup._id}`).then((group) => { let group = await member.get(`/groups/${createdGroup._id}`);
let members = group.members; let userInGroup = find(group.members, '_id', member._id);
let userInGroup = find(members, (user) => {
return member._id === user._id; expect(userInGroup).to.exist;
});
expect(userInGroup).to.be.ok;
});
}); });
}); });
}); });
@@ -123,8 +115,8 @@ describe('GET /groups/:id', () => {
flagCount: 3, flagCount: 3,
}; };
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
@@ -137,134 +129,121 @@ describe('GET /groups/:id', () => {
chat5, chat5,
], ],
}, },
}).then((res) => {
group = res.group;
}); });
group = groupData.group;
}); });
context('non-admin', () => { context('non-admin', () => {
let nonAdmin; let nonAdmin;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((user) => { nonAdmin = await generateUser();
nonAdmin = user;
});
}); });
it('does not include messages with a flag count of 2 or greater', () => { it('does not include messages with a flag count of 2 or greater', async () => {
return nonAdmin.get(`/groups/${group._id}`).then((_group) => { let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
expect(_group.chat).to.have.lengthOf(3);
expect(_group.chat[0].id).to.eql(chat1.id); expect(fetchedGroup.chat).to.have.lengthOf(3);
expect(_group.chat[1].id).to.eql(chat2.id); expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
expect(_group.chat[2].id).to.eql(chat3.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', () => { it('does not include user ids in flags object', async () => {
return nonAdmin.get(`/groups/${group._id}`).then((_group) => { let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
let chatWithOneFlag = _group.chat[2]; let chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true }); expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chatWithOneFlag.flags).to.eql({}); expect(chat3.flags).to.eql({ 'user-id': true });
}); expect(chatWithOneFlag.flags).to.eql({});
}); });
}); });
context('admin', () => { context('admin', () => {
let admin; let admin;
beforeEach(() => { beforeEach(async () => {
return generateUser({ admin = await generateUser({
'contributor.admin': true, 'contributor.admin': true,
}).then((user) => {
admin = user;
}); });
}); });
it('includes all messages', () => { it('includes all messages', async () => {
return admin.get(`/groups/${group._id}`).then((_group) => { let fetchedGroup = await admin.get(`/groups/${group._id}`);
expect(_group.chat).to.have.lengthOf(5);
expect(_group.chat[0].id).to.eql(chat1.id); expect(fetchedGroup.chat).to.have.lengthOf(5);
expect(_group.chat[1].id).to.eql(chat2.id); expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
expect(_group.chat[2].id).to.eql(chat3.id); expect(fetchedGroup.chat[1].id).to.eql(chat2.id);
expect(_group.chat[3].id).to.eql(chat4.id); expect(fetchedGroup.chat[2].id).to.eql(chat3.id);
expect(_group.chat[4].id).to.eql(chat5.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', () => { it('includes user ids in flags object', async () => {
return admin.get(`/groups/${group._id}`).then((_group) => { let fetchedGroup = await admin.get(`/groups/${group._id}`);
let chatWithOneFlag = _group.chat[2]; let chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true }); expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chatWithOneFlag.flags).to.eql(chat3.flags); expect(chat3.flags).to.eql({ 'user-id': true });
}); expect(chatWithOneFlag.flags).to.eql(chat3.flags);
}); });
}); });
}); });
context('Non-member of a public guild', () => { context('Non-member of a public guild', () => {
let leader, nonMember, createdGroup; let nonMember, createdGroup;
before(() => { before(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 1, members: 1,
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
}).then((res) => {
leader = res.leader;
createdGroup = res.group;
return generateUser();
}).then((user) => {
nonMember = user;
}); });
createdGroup = groupData.group;
nonMember = await generateUser();
}); });
it('returns the group object for a non-member', () => { it('returns the group object for a non-member', async () => {
return nonMember.get(`/groups/${createdGroup._id}`) let group = await nonMember.get(`/groups/${createdGroup._id}`);
.then((group) => {
expect(group._id).to.eql(createdGroup._id); expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name); expect(group.name).to.eql(createdGroup.name);
expect(group.type).to.eql(createdGroup.type); expect(group.type).to.eql(createdGroup.type);
expect(group.privacy).to.eql(createdGroup.privacy); expect(group.privacy).to.eql(createdGroup.privacy);
});
}); });
it('does not include user in members list', () => { it('does not include user in members list', async () => {
return nonMember.get(`/groups/${createdGroup._id}`).then((group) => { let group = await nonMember.get(`/groups/${createdGroup._id}`);
let userInGroup = find(group.members, (user) => { let userInGroup = find(group.members, '_id', nonMember._id);
return nonMember._id === user._id;
}); expect(userInGroup).to.not.exist;
expect(userInGroup).to.not.be.ok;
});
}); });
}); });
context('Private Guilds', () => { context('Private Guilds', () => {
let leader, nonMember, createdGroup; let nonMember, createdGroup;
before(() => { before(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 1, members: 1,
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
leader = res.leader;
createdGroup = res.group;
return generateUser();
}).then((user) => {
nonMember = user;
}); });
createdGroup = groupData.group;
nonMember = await generateUser();
}); });
it('does not return the group object for a non-member', () => { it('does not return the group object for a non-member', async () => {
return expect(nonMember.get(`/groups/${createdGroup._id}`)) await expect(nonMember.get(`/groups/${createdGroup._id}`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageGroupNotFound'), text: t('messageGroupNotFound'),
@@ -273,27 +252,24 @@ describe('GET /groups/:id', () => {
}); });
context('Non-member of a party', () => { context('Non-member of a party', () => {
let leader, nonMember, createdGroup; let nonMember, createdGroup;
before(() => { before(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 1, members: 1,
groupDetails: { groupDetails: {
name: 'test party', name: 'test party',
type: 'party', type: 'party',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
leader = res.leader;
createdGroup = res.group;
return generateUser();
}).then((user) => {
nonMember = user;
}); });
createdGroup = groupData.group;
nonMember = await generateUser();
}); });
it('does not return the group object for a non-member', () => { it('does not return the group object for a non-member', async () => {
return expect(nonMember.get(`/groups/${createdGroup._id}`)) await expect(nonMember.get(`/groups/${createdGroup._id}`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageGroupNotFound'), text: t('messageGroupNotFound'),
@@ -302,45 +278,41 @@ describe('GET /groups/:id', () => {
}); });
context('Member of a party', () => { context('Member of a party', () => {
let leader, member, createdGroup; let member, createdGroup;
before(() => { before(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 1, members: 1,
groupDetails: { groupDetails: {
name: 'test party', name: 'test party',
type: 'party', type: 'party',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
leader = res.leader;
createdGroup = res.group;
member = res.members[0];
}); });
createdGroup = groupData.group;
member = groupData.members[0];
}); });
it('returns the user\'s party if an id of "party" is passed in', () => { it('returns the user\'s party if an id of "party" is passed in', async () => {
return member.get('/groups/party') let group = await member.get('/groups/party');
.then((group) => {
expect(group._id).to.eql(createdGroup._id); expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name); expect(group.name).to.eql(createdGroup.name);
expect(group.type).to.eql(createdGroup.type); expect(group.type).to.eql(createdGroup.type);
expect(group.privacy).to.eql(createdGroup.privacy); expect(group.privacy).to.eql(createdGroup.privacy);
});
}); });
}); });
context('Non-existent group', () => { context('Non-existent group', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user;
});
}); });
it('returns error if group does not exist', () => { it('returns error if group does not exist', async () => {
return expect(user.get('/groups/group-that-does-not-exist')) await expect(user.get('/groups/group-that-does-not-exist'))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageGroupNotFound'), text: t('messageGroupNotFound'),

9
test/api/v2/groups/POST-groups.test.js
View File

@@ -12,7 +12,7 @@ describe('POST /groups', () => {
leader = await generateUser(); 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?', () => { 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) => { return leader.post('/groups').then((group) => {
expect(group._id).to.exist; expect(group._id).to.exist;
expect(group.name).to.eql(`${leader.profile.name}'s group`); expect(group.name).to.eql(`${leader.profile.name}'s group`);
@@ -68,7 +68,8 @@ describe('POST /groups', () => {
}); });
it('prevents party creation if user is already in party', async () => { it('prevents party creation if user is already in party', async () => {
let party = await generateGroup(leader, { await generateGroup(leader, {
name: 'first party that user attempts to create',
type: 'party', type: 'party',
}); });
@@ -78,7 +79,7 @@ describe('POST /groups', () => {
}); });
}); });
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?', () => { 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', { return expect(leader.post('/groups', {
type: 'party', type: 'party',
privacy: 'public', privacy: 'public',
@@ -113,7 +114,7 @@ describe('POST /groups', () => {
let guild = await leader.post('/groups', { let guild = await leader.post('/groups', {
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}) });
expect(guild.leader).to.eql(leader._id); expect(guild.leader).to.eql(leader._id);
}); });

39
test/api/v2/groups/POST-groups_id.test.js
View File

@@ -5,11 +5,10 @@ import {
} from '../../../helpers/api-integration.helper'; } from '../../../helpers/api-integration.helper';
describe('POST /groups/:id', () => { describe('POST /groups/:id', () => {
context('user is not the leader of the group', () => { context('user is not the leader of the group', () => {
let user, otherUser, groupUserDoesNotOwn; let user, otherUser, groupUserDoesNotOwn;
beforeEach(() => { beforeEach(async () => {
return Promise.all([ return Promise.all([
generateUser({ balance: 10 }), generateUser({ balance: 10 }),
generateUser({ balance: 10 }), generateUser({ balance: 10 }),
@@ -28,9 +27,9 @@ describe('POST /groups/:id', () => {
}); });
}); });
it('does not allow user to update group', () => { it('does not allow user to update group', async () => {
return expect(user.post(`/groups/${groupUserDoesNotOwn._id}`, { return expect(user.post(`/groups/${groupUserDoesNotOwn._id}`, {
name: 'Change' name: 'Change',
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageGroupOnlyLeaderCanUpdate'), text: t('messageGroupOnlyLeaderCanUpdate'),
@@ -41,32 +40,28 @@ describe('POST /groups/:id', () => {
context('user is the leader of the group', () => { context('user is the leader of the group', () => {
let user, usersGroup; let user, usersGroup;
beforeEach(() => { beforeEach(async () => {
return generateUser({ user = await generateUser({
balance: 10, balance: 10,
}).then((_user) => { });
user = _user;
return generateGroup(user, { usersGroup = await generateGroup(user, {
name: 'Original Group Title', name: 'Original Group Title',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
});
}).then((group) => {
usersGroup = group;
}); });
}); });
it('allows user to update group', () => { it('allows user to update group', async () => {
return user.post(`/groups/${usersGroup._id}`, { await user.post(`/groups/${usersGroup._id}`, {
name: 'New Group Title', name: 'New Group Title',
description: 'New group description', description: 'New group description',
}).then((group) => {
return user.get(`/groups/${usersGroup._id}`);
}).then((group) => {
expect(group.name).to.eql('New Group Title');
expect(group.description).to.eql('New group description');
}); });
let group = await user.get(`/groups/${usersGroup._id}`);
expect(group.name).to.eql('New Group Title');
expect(group.description).to.eql('New group description');
}); });
}); });
}); });

110
test/api/v2/groups/POST-groups_id_join.test.js
View File

@@ -6,7 +6,6 @@ import {
import { each, find } from 'lodash'; import { each, find } from 'lodash';
describe('POST /groups/:id/join', () => { describe('POST /groups/:id/join', () => {
context('user is already a member of the group', () => { context('user is already a member of the group', () => {
it('returns an error'); it('returns an error');
}); });
@@ -14,64 +13,48 @@ describe('POST /groups/:id/join', () => {
each({ each({
'public guild': {type: 'guild', privacy: 'public'}, 'public guild': {type: 'guild', privacy: 'public'},
'private guild': {type: 'guild', privacy: 'private'}, 'private guild': {type: 'guild', privacy: 'private'},
'party': {type: 'party', privacy: 'private'}, party: {type: 'party', privacy: 'private'},
}, (data, groupType) => { }, (groupDetails, groupType) => {
context(`user has invitation to a ${groupType}`, () => { context(`user has invitation to a ${groupType}`, () => {
let group, invitee; let group, invitee;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails,
type: data.type,
privacy: data.privacy,
},
invites: 1, invites: 1,
}).then((res) => {
group = res.group;
invitee = res.invitees[0];
}); });
group = groupData.group;
invitee = groupData.invitees[0];
}); });
it(`allows user to join a ${groupType}`, () => { it(`allows user to join a ${groupType}`, async () => {
return invitee.post(`/groups/${group._id}/join`).then((res) => { await invitee.post(`/groups/${group._id}/join`);
return invitee.get(`/groups/${group._id}`);
}).then((_group) => {
let members = _group.members;
let userInGroup = find(members, (user) => {
return user._id === invitee._id;
});
expect(userInGroup).to.exist; let members = (await invitee.get(`/groups/${group._id}`)).members;
}); let userInGroup = find(members, '_id', invitee._id);
expect(userInGroup).to.exist;
}); });
}); });
}); });
each({ each({
'private guild': {type: 'guild', privacy: 'private'}, 'private guild': {type: 'guild', privacy: 'private'},
'party': {type: 'party', privacy: 'private'}, party: {type: 'party', privacy: 'private'},
}, (data, groupType) => { }, (groupDetails, groupType) => {
context(`user does not have an invitation to a ${groupType}`, () => { context(`user does not have an invitation to a ${groupType}`, () => {
let group, user; let group, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails,
type: data.type,
privacy: data.privacy,
},
}).then((res) => {
group = res.group;
return generateUser();
}).then((generatedUser) => {
user = generatedUser;
}); });
group = groupData.group;
user = await generateUser();
}); });
it(`does not allow user to join a ${groupType}`, () => { it(`does not allow user to join a ${groupType}`, async () => {
return expect(user.post(`/groups/${group._id}/join`).then((res) => { await expect(user.post(`/groups/${group._id}/join`)).to.eventually.be.rejected.and.eql({
return user.get(`/groups/${group._id}`);
})).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageGroupRequiresInvite'), text: t('messageGroupRequiresInvite'),
}); });
@@ -82,58 +65,47 @@ describe('POST /groups/:id/join', () => {
context('user does not have an invitation to a public group', () => { context('user does not have an invitation to a public group', () => {
let group, user; let group, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
}).then((res) => {
group = res.group;
return generateUser();
}).then((generatedUser) => {
user = generatedUser;
}); });
group = groupData.group;
user = await generateUser();
}); });
it('allows user to join a public guild', () => { it('allows user to join a public guild', async () => {
return user.post(`/groups/${group._id}/join`).then((res) => { await user.post(`/groups/${group._id}/join`);
return user.get(`/groups/${group._id}`);
}).then((_group) => {
let members = _group.members;
let userInGroup = find(members, (member) => {
return user._id === user._id;
});
expect(userInGroup).to.exist; let members = (await user.get(`/groups/${group._id}`)).members;
}); let userInGroup = find(members, '_id', user._id);
expect(userInGroup).to.exist;
}); });
}); });
context('public guild has no leader', () => { context('public guild has no leader', () => {
let user, group; let user, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
}).then((res) => {
group = res.group;
return res.leader.post(`/groups/${group._id}/leave`);
}).then((res) => {
return generateUser();
}).then((generatedUser) => {
user = generatedUser;
}); });
group = groupData.group;
await groupData.leader.post(`/groups/${group._id}/leave`);
user = await generateUser();
}); });
it('makes the joining user the leader', () => { it('makes the joining user the leader', async () => {
return expect(user.post(`/groups/${group._id}/join`).then((result) => { await user.post(`/groups/${group._id}/join`);
return user.get(`/groups/${group._id}`);
})).to.eventually.have.deep.property('leader._id', user._id); await expect(user.get(`/groups/${group._id}`)).to.eventually.have.deep.property('leader._id', user._id);
}); });
}); });
}); });

127
test/api/v2/groups/POST-groups_id_leave.test.js
View File

@@ -1,13 +1,10 @@
import { import {
checkExistence, checkExistence,
createAndPopulateGroup, createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../helpers/api-integration.helper'; } from '../../../helpers/api-integration.helper';
import { find } from 'lodash'; import { find } from 'lodash';
describe('POST /groups/:id/leave', () => { describe('POST /groups/:id/leave', () => {
context('user is not member of the group', () => { context('user is not member of the group', () => {
it('returns an error'); it('returns an error');
}); });
@@ -15,141 +12,127 @@ describe('POST /groups/:id/leave', () => {
context('user is a non-leader member of a guild', () => { context('user is a non-leader member of a guild', () => {
let user, group; let user, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
members: 3, members: 3,
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
}).then((res) => {
user = res.members[0];
group = res.group;
}); });
user = groupData.members[0];
group = groupData.group;
}); });
it('leaves the group', () => { it('leaves the group', async () => {
return user.post(`/groups/${group._id}/leave`).then((result) => { await user.post(`/groups/${group._id}/leave`);
return user.get(`/groups/${group._id}`);
}).then((group) => { let members = (await user.get(`/groups/${group._id}`)).members;
let userInGroup = find(group.members, (member) => { let userInGroup = find(members, '_id', user._id);
return member._id === user._id;
}); expect(userInGroup).to.not.be.ok;
expect(userInGroup).to.not.be.ok;
});
}); });
}); });
context('user is the last member of a public guild', () => { context('user is the last member of a public guild', () => {
let user, group; let user, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
}).then((res) => {
user = res.leader;
group = res.group;
}); });
user = groupData.leader;
group = groupData.group;
}); });
it('leaves the group accessible', () => { it('leaves the group accessible', async () => {
return expect(user.post(`/groups/${group._id}/leave`).then((result) => { await user.post(`/groups/${group._id}/leave`);
return user.get(`/groups/${group._id}`);
})).to.eventually.have.property('_id', group._id); await expect(user.get(`/groups/${group._id}`)).to.eventually.have.property('_id', group._id);
}); });
}); });
context('user is the last member of a private group', () => { context('user is the last member of a private group', () => {
let user, group; let user, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
user = res.leader;
group = res.group;
}); });
user = groupData.leader;
group = groupData.group;
}); });
it('group is deleted', () => { it('group is deleted', async () => {
return expect(user.post(`/groups/${group._id}/leave`).then((result) => { await user.post(`/groups/${group._id}/leave`);
return checkExistence('groups', group._id);
})).to.eventually.eql(false); await expect(checkExistence('groups', group._id)).to.eventually.eql(false);
}); });
}); });
context('user is the last member of a private group with pending invites', () => { context('user is the last member of a private group with pending invites', () => {
let user, invitee1, invitee2, group; let user, invitee1, invitee2, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
invites: 2, invites: 2,
groupDetails: { groupDetails: {
name: 'test guild', name: 'test guild',
type: 'guild', type: 'guild',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
user = res.leader;
invitee1 = res.invitees[0];
invitee2 = res.invitees[1];
group = res.group;
}); });
user = groupData.leader;
group = groupData.group;
invitee1 = groupData.invitees[0];
invitee2 = groupData.invitees[1];
}); });
it('deletes the group invitations from users', () => { it('deletes the group invitations from users', async () => {
return user.post(`/groups/${group._id}/leave`).then((result) => { await user.post(`/groups/${group._id}/leave`);
return Promise.all([
expect(invitee1.get(`/user`)) await expect(invitee1.get(`/user`)).to.eventually.have.deep.property('invitations.guilds').and.to.be.empty;
.to.eventually.have.deep.property('invitations.guilds') await expect(invitee2.get(`/user`)).to.eventually.have.deep.property('invitations.guilds').and.to.be.empty;
.and.to.be.empty,
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', () => { context('user is the last member of a party with pending invites', () => {
let user, invitee1, invitee2, group; let user, invitee1, invitee2, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
invites: 2, invites: 2,
groupDetails: { groupDetails: {
name: 'test party', name: 'test guild',
type: 'party', type: 'party',
privacy: 'private', privacy: 'private',
}, },
}).then((res) => {
user = res.leader;
invitee1 = res.invitees[0];
invitee2 = res.invitees[1];
group = res.group;
}); });
user = groupData.leader;
group = groupData.group;
invitee1 = groupData.invitees[0];
invitee2 = groupData.invitees[1];
}); });
it('deletes the group invitations from users', () => { it('deletes the group invitations from users', async () => {
return user.post(`/groups/${group._id}/leave`).then((result) => { await user.post(`/groups/${group._id}/leave`);
return Promise.all([
expect(invitee1.get(`/user`)) await expect(invitee1.get(`/user`)).to.eventually.have.deep.property('invitations.party').and.to.be.empty;
.to.eventually.have.deep.property('invitations.party') await expect(invitee2.get(`/user`)).to.eventually.have.deep.property('invitations.party').and.to.be.empty;
.and.to.be.empty,
expect(invitee2.get(`/user`))
.to.eventually.have.deep.property('invitations.party')
.and.to.be.empty,
]);
});
}); });
}); });
}); });

11
test/api/v2/groups/POST-groups_id_removeMember.test.js
View File

@@ -1,12 +1,9 @@
import { import {
createAndPopulateGroup, createAndPopulateGroup,
generateGroup,
generateUser,
translate as t, translate as t,
} from '../../../helpers/api-integration.helper'; } from '../../../helpers/api-integration.helper';
describe('POST /groups/:id/removeMember', () => { describe('POST /groups/:id/removeMember', () => {
context('user is not member of the group', () => { context('user is not member of the group', () => {
it('returns an error'); it('returns an error');
}); });
@@ -18,7 +15,7 @@ describe('POST /groups/:id/removeMember', () => {
context('user is the leader of a guild', () => { context('user is the leader of a guild', () => {
let leader, member, group; let leader, member, group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
members: 1, members: 1,
groupDetails: { groupDetails: {
@@ -33,7 +30,7 @@ describe('POST /groups/:id/removeMember', () => {
}); });
}); });
it('does not allow leader to remove themselves', () => { it('does not allow leader to remove themselves', async () => {
return expect(leader.post(`/groups/${group._id}/removeMember`, null, { return expect(leader.post(`/groups/${group._id}/removeMember`, null, {
uuid: leader._id, uuid: leader._id,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
@@ -42,10 +39,10 @@ describe('POST /groups/:id/removeMember', () => {
}); });
}); });
it('can remove other members of guild', () => { it('can remove other members of guild', async () => {
return leader.post(`/groups/${group._id}/removeMember`, null, { return leader.post(`/groups/${group._id}/removeMember`, null, {
uuid: member._id, uuid: member._id,
}).then((res) => { }).then(() => {
return leader.get(`/groups/${group._id}`); return leader.get(`/groups/${group._id}`);
}).then((guild) => { }).then((guild) => {
expect(guild.members).to.have.a.lengthOf(1); expect(guild.members).to.have.a.lengthOf(1);

11
test/api/v2/groups/chat/DELETE-groups_id_chat.test.js
View File

@@ -1,13 +1,12 @@
import { import {
createAndPopulateGroup, createAndPopulateGroup,
generateUser,
translate as t, translate as t,
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('DELETE /groups/:id/chat', () => { describe('DELETE /groups/:id/chat', () => {
let group, message, user; let group, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -17,21 +16,21 @@ describe('DELETE /groups/:id/chat', () => {
group = res.group; group = res.group;
user = res.leader; user = res.leader;
return user.post(`/groups/${group._id}/chat`, null, { message: 'Some message', }); return user.post(`/groups/${group._id}/chat`, null, { message: 'Some message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('deletes a message', () => { it('deletes a message', async () => {
return user.del(`/groups/${group._id}/chat/${message.id}`).then((res) => { return user.del(`/groups/${group._id}/chat/${message.id}`).then(() => {
return user.get(`/groups/${group._id}/chat/`); return user.get(`/groups/${group._id}/chat/`);
}).then((messages) => { }).then((messages) => {
expect(messages).to.have.length(0); expect(messages).to.have.length(0);
}); });
}); });
it('returns an error is message does not exist', () => { 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({ return expect(user.del(`/groups/${group._id}/chat/some-fake-id`)).to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageGroupChatNotFound'), text: t('messageGroupChatNotFound'),

45
test/api/v2/groups/chat/GET-groups_id_chat.test.js
View File

@@ -1,45 +1,38 @@
import { import {
createAndPopulateGroup, createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('GET /groups/:id/chat', () => { describe('GET /groups/:id/chat', () => {
context('group with multiple messages', () => { context('group with multiple messages', () => {
let group, member, message1, message2, user; let group, member, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ let groupData = await createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
privacy: 'public', privacy: 'public',
}, },
members: 1, members: 1,
}).then((res) => {
group = res.group;
user = res.leader;
member = res.members[0];
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
}).then((res) => {
message1 = res.message;
return user.post(`/groups/${group._id}/chat`, null, { message: 'User message' });
}).then((res) => {
message2 = res.message;
}); });
group = groupData.group;
user = groupData.leader;
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', () => { it('gets messages', async () => {
return user.get(`/groups/${group._id}/chat`).then((messages) => { let messages = await user.get(`/groups/${group._id}/chat`);
expect(messages).to.have.length(2);
let message = messages[0]; expect(messages).to.have.length(2);
expect(message.id).to.exist;
expect(message.text).to.exist; let message = messages[0];
expect(message.uuid).to.exist;
}); expect(message.id).to.exist;
expect(message.text).to.exist;
expect(message.uuid).to.exist;
}); });
}); });
}); });

8
test/api/v2/groups/chat/POST-groups_id_chat.test.js
View File

@@ -1,14 +1,12 @@
import { import {
createAndPopulateGroup, createAndPopulateGroup,
generateUser,
translate as t, translate as t,
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('POST /groups/:id/chat', () => { describe('POST /groups/:id/chat', () => {
let group, user; let group, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -20,7 +18,7 @@ describe('POST /groups/:id/chat', () => {
}); });
}); });
it('creates a chat message', () => { it('creates a chat message', async () => {
return user.post(`/groups/${group._id}/chat`, null, { return user.post(`/groups/${group._id}/chat`, null, {
message: 'Test Message', message: 'Test Message',
}).then((res) => { }).then((res) => {
@@ -33,7 +31,7 @@ describe('POST /groups/:id/chat', () => {
}); });
}); });
it('does not post an empty message', () => { it('does not post an empty message', async () => {
return expect(user.post(`/groups/${group._id}/chat`, null, { return expect(user.post(`/groups/${group._id}/chat`, null, {
message: '', message: '',
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({

74
test/api/v2/groups/chat/POST-groups_id_chat_id_clearflags.test.js
View File

@@ -7,7 +7,7 @@ import {
describe('POST /groups/:id/chat/:id/clearflags', () => { describe('POST /groups/:id/chat/:id/clearflags', () => {
let group; let group;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -28,13 +28,11 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
context('non admin', () => { context('non admin', () => {
let nonadmin; let nonadmin;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((user) => { nonadmin = await generateUser();
nonadmin = user;
});
}); });
it('cannot clear flags', () => { it('cannot clear flags', async () => {
return expect(nonadmin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`)) return expect(nonadmin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -46,7 +44,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
context('admin', () => { context('admin', () => {
let admin; let admin;
beforeEach(() => { beforeEach(async () => {
return generateUser({ return generateUser({
'contributor.admin': true, 'contributor.admin': true,
}).then((user) => { }).then((user) => {
@@ -54,23 +52,23 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
}); });
}); });
it('clears flags', () => { it('clears flags', async () => {
return admin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`).then((res) => { return admin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`).then(() => {
return admin.get(`/groups/${group._id}/chat`); return admin.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
expect(messages[0].flagCount).to.eql(0); expect(messages[0].flagCount).to.eql(0);
}); });
}); });
it('leaves old flags on the flag object', () => { it('leaves old flags on the flag object', async () => {
return admin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`).then((res) => { return admin.post(`/groups/${group._id}/chat/message-to-clear/clearflags`).then(() => {
return admin.get(`/groups/${group._id}/chat`); return admin.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
expect(messages[0].flags).to.have.property('some-id', true); expect(messages[0].flags).to.have.property('some-id', true);
}); });
}); });
it('returns error if message does not exist', () => { it('returns error if message does not exist', async () => {
return expect(admin.post(`/groups/${group._id}/chat/non-existant-message/clearflags`)) return expect(admin.post(`/groups/${group._id}/chat/non-existant-message/clearflags`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
@@ -80,38 +78,34 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
}); });
context('admin user, group with multiple messages', () => { context('admin user, group with multiple messages', () => {
let admin, author, group, member; let admin, author, groupWithMessages;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((user) => { author = await generateUser();
author = user; admin = await generateUser({
'contributor.admin': true,
return 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,
});
}).then((res) => {
group = res.group;
return generateUser({
'contributor.admin': true,
});
}).then((user) => {
admin = user;
}); });
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', () => { it('changes only the message that is flagged', async () => {
return admin.post(`/groups/${group._id}/chat/message-to-unflag/clearflags`).then((messages) => { return admin.post(`/groups/${groupWithMessages._id}/chat/message-to-unflag/clearflags`).then(() => {
return admin.get(`/groups/${group._id}/chat`); return admin.get(`/groups/${groupWithMessages._id}/chat`);
}).then((messages) => { }).then((messages) => {
expect(messages).to.have.lengthOf(4); expect(messages).to.have.lengthOf(4);

92
test/api/v2/groups/chat/POST-groups_id_chat_id_flag.test.js
View File

@@ -5,11 +5,10 @@ import {
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('POST /groups/:id/chat/:id/flag', () => { describe('POST /groups/:id/chat/:id/flag', () => {
context('another member\'s message', () => { context('another member\'s message', () => {
let group, member, message, user; let group, member, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -21,23 +20,22 @@ describe('POST /groups/:id/chat/:id/flag', () => {
user = res.leader; user = res.leader;
member = res.members[0]; member = res.members[0];
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message', }); return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('flags message', () => { it('flags message', async () => {
return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then((messages) => { return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
return user.get(`/groups/${group._id}/chat`); return user.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
let message = messages[0]; expect(messages[0].flagCount).to.eql(1);
expect(message.flagCount).to.eql(1);
}); });
}); });
it('cannot flag the same message twice', () => { it('cannot flag the same message twice', async () => {
return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`).then((messages) => { return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
return user.post(`/groups/${group._id}/chat/${message.id}/flag`); return user.post(`/groups/${group._id}/chat/${message.id}/flag`);
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -49,7 +47,7 @@ describe('POST /groups/:id/chat/:id/flag', () => {
context('own message', () => { context('own message', () => {
let group, message, user; let group, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -60,13 +58,13 @@ describe('POST /groups/:id/chat/:id/flag', () => {
group = res.group; group = res.group;
user = res.leader; user = res.leader;
return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message', }); return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('cannot flag message', () => { it('cannot flag message', async () => {
return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`)) return expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -76,9 +74,9 @@ describe('POST /groups/:id/chat/:id/flag', () => {
}); });
context('nonexistant message', () => { context('nonexistant message', () => {
let group, message, user; let group, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -90,7 +88,7 @@ describe('POST /groups/:id/chat/:id/flag', () => {
}); });
}); });
it('returns error', () => { it('returns error', async () => {
return expect(user.post(`/groups/${group._id}/chat/non-existant-message/flag`)) return expect(user.post(`/groups/${group._id}/chat/non-existant-message/flag`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
@@ -100,39 +98,34 @@ describe('POST /groups/:id/chat/:id/flag', () => {
}); });
context('group with multiple messages', () => { context('group with multiple messages', () => {
let admin, author, group, member, message, user; let admin, author, group, user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((user) => { author = await generateUser();
author = user; admin = await generateUser({
'contributor.admin': true,
return 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,
});
}).then((res) => {
group = res.group;
user = res.leader;
member = res.members[0];
return generateUser({
'contributor.admin': true,
});
}).then((user) => {
admin = user;
}); });
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.leader;
}); });
it('changes only the message that is flagged', () => { it('changes only the message that is flagged', async () => {
return user.post(`/groups/${group._id}/chat/message-to-be-flagged/flag`).then((messages) => { return user.post(`/groups/${group._id}/chat/message-to-be-flagged/flag`).then(() => {
return admin.get(`/groups/${group._id}/chat`); return admin.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
expect(messages).to.have.lengthOf(4); expect(messages).to.have.lengthOf(4);
@@ -160,7 +153,7 @@ describe('POST /groups/:id/chat/:id/flag', () => {
context('admin flagging a message', () => { context('admin flagging a message', () => {
let group, member, message, user; let group, member, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -176,18 +169,17 @@ describe('POST /groups/:id/chat/:id/flag', () => {
user = res.leader; user = res.leader;
member = res.members[0]; member = res.members[0];
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message', }); return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('sets flagCount to 5', () => { it('sets flagCount to 5', async () => {
return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then((messages) => { return user.post(`/groups/${group._id}/chat/${message.id}/flag`).then(() => {
return user.get(`/groups/${group._id}/chat`); return user.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
let message = messages[0]; expect(messages[0].flagCount).to.eql(5);
expect(message.flagCount).to.eql(5);
}); });
}); });
}); });

84
test/api/v2/groups/chat/POST-groups_id_chat_id_like.test.js
View File

@@ -5,11 +5,10 @@ import {
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('POST /groups/:id/chat/:id/like', () => { describe('POST /groups/:id/chat/:id/like', () => {
context('another member\'s message', () => { context('another member\'s message', () => {
let group, member, message, user; let group, member, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -21,25 +20,23 @@ describe('POST /groups/:id/chat/:id/like', () => {
user = res.leader; user = res.leader;
member = res.members[0]; member = res.members[0];
return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message', }); return member.post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('likes message', () => { it('likes message', async () => {
return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => { return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
let message = messages[0]; expect(messages[0].likes[user._id]).to.eql(true);
expect(message.likes[user._id]).to.eql(true);
}); });
}); });
it('returns the message object', () => { it('returns the message object', async () => {
return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => { return user.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
let message = messages[0]; expect(messages[0].text).to.eql('Group member message');
expect(message.text).to.eql('Group member message'); expect(messages[0].uuid).to.eql(member._id);
expect(message.uuid).to.eql(member._id); expect(messages[0].user).to.eql(member.profile.name);
expect(message.user).to.eql(member.profile.name);
}); });
}); });
}); });
@@ -47,7 +44,7 @@ describe('POST /groups/:id/chat/:id/like', () => {
context('own message', () => { context('own message', () => {
let group, message, user; let group, message, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -58,13 +55,13 @@ describe('POST /groups/:id/chat/:id/like', () => {
group = res.group; group = res.group;
user = res.leader; user = res.leader;
return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message', }); return user.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message' });
}).then((res) => { }).then((res) => {
message = res.message; message = res.message;
}); });
}); });
it('cannot like message', () => { it('cannot like message', async () => {
return expect(user.post(`/groups/${group._id}/chat/${message.id}/like`)) return expect(user.post(`/groups/${group._id}/chat/${message.id}/like`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -74,39 +71,34 @@ describe('POST /groups/:id/chat/:id/like', () => {
}); });
context('group with multiple messages', () => { context('group with multiple messages', () => {
let admin, author, group, member, message, user; let admin, author, group, user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((user) => { author = await generateUser();
author = user; admin = await generateUser({
'contributor.admin': true,
return 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,
});
}).then((res) => {
group = res.group;
user = res.leader;
member = res.members[0];
return generateUser({
'contributor.admin': true,
});
}).then((user) => {
admin = user;
}); });
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.leader;
}); });
it('changes only the message that is liked', () => { it('changes only the message that is liked', async () => {
return user.post(`/groups/${group._id}/chat/message-to-be-liked/like`).then((messages) => { return user.post(`/groups/${group._id}/chat/message-to-be-liked/like`).then(() => {
return admin.get(`/groups/${group._id}/chat`); return admin.get(`/groups/${group._id}/chat`);
}).then((messages) => { }).then((messages) => {
expect(messages).to.have.lengthOf(4); expect(messages).to.have.lengthOf(4);
@@ -132,9 +124,9 @@ describe('POST /groups/:id/chat/:id/like', () => {
}); });
context('nonexistant message', () => { context('nonexistant message', () => {
let group, message, user; let group, user;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -146,7 +138,7 @@ describe('POST /groups/:id/chat/:id/like', () => {
}); });
}); });
it('returns error', () => { it('returns error', async () => {
return expect(user.post(`/groups/${group._id}/chat/non-existant-message/like`)) return expect(user.post(`/groups/${group._id}/chat/non-existant-message/like`))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,

147
test/api/v2/register/POST-register.test.js
View File

@@ -7,18 +7,17 @@ import { v4 as generateRandomUserName } from 'uuid';
import { each } from 'lodash'; import { each } from 'lodash';
describe('POST /register', () => { describe('POST /register', () => {
context('username and email are free', () => { context('username and email are free', () => {
it('registers a new user', () => { it('registers a new user', async () => {
let api = requester(); let api = requester();
let username = generateRandomUserName(); let username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
let password = 'password'; let password = 'password';
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user._id).to.exist; expect(user._id).to.exist;
@@ -27,7 +26,7 @@ describe('POST /register', () => {
}); });
}); });
it('requires password and confirmPassword to match', () => { it('requires password and confirmPassword to match', async () => {
let api = requester(); let api = requester();
let username = generateRandomUserName(); let username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
@@ -35,58 +34,58 @@ describe('POST /register', () => {
let confirmPassword = 'not password'; let confirmPassword = 'not password';
return expect(api.post('/register', { return expect(api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: confirmPassword, confirmPassword,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageAuthPasswordMustMatch'), text: t('messageAuthPasswordMustMatch'),
}); });
}); });
it('requires a username', () => { it('requires a username', async () => {
let api = requester(); let api = requester();
let email = `${generateRandomUserName()}@example.com`; let email = `${generateRandomUserName()}@example.com`;
let password = 'password'; let password = 'password';
let confirmPassword = 'password'; let confirmPassword = 'password';
return expect(api.post('/register', { return expect(api.post('/register', {
email: email, email,
password: password, password,
confirmPassword: confirmPassword, confirmPassword,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageAuthCredentialsRequired'), text: t('messageAuthCredentialsRequired'),
}); });
}); });
it('requires an email', () => { it('requires an email', async () => {
let api = requester(); let api = requester();
let username = generateRandomUserName(); let username = generateRandomUserName();
let password = 'password'; let password = 'password';
let confirmPassword = 'password'; let confirmPassword = 'password';
return expect(api.post('/register', { return expect(api.post('/register', {
username: username, username,
password: password, password,
confirmPassword: confirmPassword, confirmPassword,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageAuthCredentialsRequired'), text: t('messageAuthCredentialsRequired'),
}); });
}); });
it('requires a password', () => { it('requires a password', async () => {
let api = requester(); let api = requester();
let username = generateRandomUserName(); let username = generateRandomUserName();
let email = `${username}@example.com`; let email = `${username}@example.com`;
let confirmPassword = 'password'; let confirmPassword = 'password';
return expect(api.post('/register', { return expect(api.post('/register', {
username: username, username,
email: email, email,
confirmPassword: confirmPassword, confirmPassword,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: t('messageAuthCredentialsRequired'), text: t('messageAuthCredentialsRequired'),
@@ -96,25 +95,25 @@ describe('POST /register', () => {
context('login is already taken', () => { context('login is already taken', () => {
let username, email; let username, email;
beforeEach(() => { beforeEach(async () => {
username = generateRandomUserName(); username = generateRandomUserName();
email = `${username}@example.com`; email = `${username}@example.com`;
return generateUser({ return generateUser({
'auth.local.username': username, 'auth.local.username': username,
'auth.local.lowerCaseUsername': username, 'auth.local.lowerCaseUsername': username,
'auth.local.email': email 'auth.local.email': email,
}); });
}); });
it('rejects if username is already taken', () => { it('rejects if username is already taken', async () => {
let api = requester(); let api = requester();
let uniqueEmail = `${generateRandomUserName()}@exampe.com`; let uniqueEmail = `${generateRandomUserName()}@exampe.com`;
let password = 'password'; let password = 'password';
return expect(api.post('/register', { return expect(api.post('/register', {
username: username, username,
email: uniqueEmail, email: uniqueEmail,
password: password, password,
confirmPassword: password, confirmPassword: password,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -122,15 +121,15 @@ describe('POST /register', () => {
}); });
}); });
it('rejects if email is already taken', () => { it('rejects if email is already taken', async () => {
let api = requester(); let api = requester();
let uniqueUsername = generateRandomUserName(); let uniqueUsername = generateRandomUserName();
let password = 'password'; let password = 'password';
return expect(api.post('/register', { return expect(api.post('/register', {
username: uniqueUsername, username: uniqueUsername,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
@@ -142,33 +141,33 @@ describe('POST /register', () => {
context('successful login via api', () => { context('successful login via api', () => {
let api, username, email, password; let api, username, email, password;
beforeEach(() => { beforeEach(async () => {
api = requester(); api = requester();
username = generateRandomUserName(); username = generateRandomUserName();
email = `${username}@example.com`; email = `${username}@example.com`;
password = 'password'; password = 'password';
}); });
it('sets all site tour values to -2 (already seen)', () => { it('sets all site tour values to -2 (already seen)', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.flags.tour).to.not.be.empty; expect(user.flags.tour).to.not.be.empty;
each(user.flags.tour, (value, attribute) => { each(user.flags.tour, (value) => {
expect(value).to.eql(-2); expect(value).to.eql(-2);
}); });
}); });
}); });
it('populates user with default todos, not no other task types', () => { it('populates user with default todos, not no other task types', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.todos).to.not.be.empty; expect(user.todos).to.not.be.empty;
@@ -178,11 +177,11 @@ describe('POST /register', () => {
}); });
}); });
it('populates user with default tags', () => { it('populates user with default tags', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.tags).to.not.be.empty; expect(user.tags).to.not.be.empty;
@@ -193,33 +192,33 @@ describe('POST /register', () => {
context('successful login with habitica-web header', () => { context('successful login with habitica-web header', () => {
let api, username, email, password; let api, username, email, password;
beforeEach(() => { beforeEach(async () => {
api = requester({}, {'x-client': 'habitica-web'}); api = requester({}, {'x-client': 'habitica-web'});
username = generateRandomUserName(); username = generateRandomUserName();
email = `${username}@example.com`; email = `${username}@example.com`;
password = 'password'; password = 'password';
}); });
it('sets all common tutorial flags to true', () => { it('sets all common tutorial flags to true', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.flags.tour).to.not.be.empty; expect(user.flags.tour).to.not.be.empty;
each(user.flags.tutorial.common, (value, attribute) => { each(user.flags.tutorial.common, (value) => {
expect(value).to.eql(true); expect(value).to.eql(true);
}); });
}); });
}); });
it('populates user with default todos, habits, and rewards', () => { it('populates user with default todos, habits, and rewards', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.todos).to.not.be.empty; expect(user.todos).to.not.be.empty;
@@ -229,11 +228,11 @@ describe('POST /register', () => {
}); });
}); });
it('populates user with default tags', () => { it('populates user with default tags', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.tags).to.not.be.empty; expect(user.tags).to.not.be.empty;
@@ -244,33 +243,33 @@ describe('POST /register', () => {
context('successful login with habitica-android header', () => { context('successful login with habitica-android header', () => {
let api, username, email, password; let api, username, email, password;
beforeEach(() => { beforeEach(async () => {
api = requester({}, {'x-client': 'habitica-android'}); api = requester({}, {'x-client': 'habitica-android'});
username = generateRandomUserName(); username = generateRandomUserName();
email = `${username}@example.com`; email = `${username}@example.com`;
password = 'password'; password = 'password';
}); });
it('sets all common tutorial flags to true', () => { it('sets all common tutorial flags to true', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.flags.tour).to.not.be.empty; expect(user.flags.tour).to.not.be.empty;
each(user.flags.tutorial.common, (value, attribute) => { each(user.flags.tutorial.common, (value) => {
expect(value).to.eql(true); expect(value).to.eql(true);
}); });
}); });
}); });
it('populates user with default todos, habits, and rewards', () => { it('populates user with default todos, habits, and rewards', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.todos).to.not.be.empty; expect(user.todos).to.not.be.empty;
@@ -280,11 +279,11 @@ describe('POST /register', () => {
}); });
}); });
it('populates user with default tags', () => { it('populates user with default tags', async () => {
return api.post('/register', { return api.post('/register', {
username: username, username,
email: email, email,
password: password, password,
confirmPassword: password, confirmPassword: password,
}).then((user) => { }).then((user) => {
expect(user.tags).to.not.be.empty; expect(user.tags).to.not.be.empty;

5
test/api/v2/status/GET-status.test.js
View File

@@ -1,10 +1,9 @@
import {requester} from '../../../helpers/api-integration.helper'; import {requester} from '../../../helpers/api-integration.helper';
describe('Status', () => { describe('Status', () => {
it('returns a status of up when server is up', () => { it('returns a status of up when server is up', async () => {
let api = requester(); let api = requester();
return expect(api.get('/status')) await expect(api.get('/status')).to.eventually.eql({status: 'up'});
.to.eventually.eql({status: 'up'});
}); });
}); });

50
test/api/v2/user/DELETE-user.test.js
View File

@@ -3,21 +3,18 @@ import {
createAndPopulateGroup, createAndPopulateGroup,
generateGroup, generateGroup,
generateUser, generateUser,
translate as t,
} from '../../../helpers/api-integration.helper'; } from '../../../helpers/api-integration.helper';
import { find } from 'lodash'; import { find } from 'lodash';
describe('DELETE /user', () => { describe('DELETE /user', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((usr) => { user = await generateUser();
user = usr;
});
}); });
it('deletes the user', () => { it('deletes the user', async () => {
return expect(user.del('/user').then((fetchedUser) => { return expect(user.del('/user').then(() => {
return checkExistence('users', user._id); return checkExistence('users', user._id);
})).to.eventually.eql(false); })).to.eventually.eql(false);
}); });
@@ -29,17 +26,17 @@ describe('DELETE /user', () => {
context('last member of a party', () => { context('last member of a party', () => {
let party; let party;
beforeEach(() => { beforeEach(async () => {
return generateGroup(user, { return generateGroup(user, {
type: 'party', type: 'party',
privacy: 'private' privacy: 'private',
}).then((group) => { }).then((group) => {
party = group; party = group;
}); });
}); });
it('deletes party when user is the only member', () => { it('deletes party when user is the only member', async () => {
return expect(user.del('/user').then((result) => { return expect(user.del('/user').then(() => {
return checkExistence('groups', party._id); return checkExistence('groups', party._id);
})).to.eventually.eql(false); })).to.eventually.eql(false);
}); });
@@ -48,17 +45,17 @@ describe('DELETE /user', () => {
context('last member of a private guild', () => { context('last member of a private guild', () => {
let guild; let guild;
beforeEach(() => { beforeEach(async () => {
return generateGroup(user, { return generateGroup(user, {
type: 'guild', type: 'guild',
privacy: 'private' privacy: 'private',
}).then((group) => { }).then((group) => {
guild = group; guild = group;
}); });
}); });
it('deletes guild when user is the only member', () => { it('deletes guild when user is the only member', async () => {
return expect(user.del('/user').then((result) => { return expect(user.del('/user').then(() => {
return checkExistence('groups', guild._id); return checkExistence('groups', guild._id);
})).to.eventually.eql(false); })).to.eventually.eql(false);
}); });
@@ -67,7 +64,7 @@ describe('DELETE /user', () => {
context('groups user is leader of', () => { context('groups user is leader of', () => {
let group, oldLeader, newLeader; let group, oldLeader, newLeader;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -81,8 +78,8 @@ describe('DELETE /user', () => {
}); });
}); });
it('chooses new group leader for any group user was the leader of', () => { it('chooses new group leader for any group user was the leader of', async () => {
return oldLeader.del('/user').then((res) => { return oldLeader.del('/user').then(() => {
return newLeader.get(`/groups/${group._id}`); return newLeader.get(`/groups/${group._id}`);
}).then((guild) => { }).then((guild) => {
expect(guild.leader).to.exist; expect(guild.leader).to.exist;
@@ -94,11 +91,11 @@ describe('DELETE /user', () => {
context('groups user is a part of', () => { context('groups user is a part of', () => {
let group1, group2, userToDelete, otherUser; let group1, group2, userToDelete, otherUser;
beforeEach(() => { beforeEach(async () => {
return generateUser({ return generateUser({
balance: 10, balance: 10,
}).then((user) => { }).then((_user) => {
userToDelete = user; userToDelete = _user;
return generateGroup(userToDelete, { return generateGroup(userToDelete, {
type: 'guild', type: 'guild',
@@ -122,8 +119,8 @@ describe('DELETE /user', () => {
}); });
}); });
it('removes user from all groups user was a part of', () => { it('removes user from all groups user was a part of', async () => {
return userToDelete.del('/user').then((res) => { return userToDelete.del('/user').then(() => {
return otherUser.get(`/groups/${group1._id}`); return otherUser.get(`/groups/${group1._id}`);
}).then((fetchedGroup1) => { }).then((fetchedGroup1) => {
expect(fetchedGroup1.members).to.be.empty; expect(fetchedGroup1.members).to.be.empty;
@@ -139,13 +136,12 @@ describe('DELETE /user', () => {
expect(userInGroup).to.not.be.ok; expect(userInGroup).to.not.be.ok;
}); });
}); });
}); });
context('pending invitation to group', () => { context('pending invitation to group', () => {
let group, userToDelete, otherUser; let group, userToDelete, otherUser;
beforeEach(() => { beforeEach(async () => {
return createAndPopulateGroup({ return createAndPopulateGroup({
groupDetails: { groupDetails: {
type: 'guild', type: 'guild',
@@ -160,8 +156,8 @@ describe('DELETE /user', () => {
}); });
}); });
it('removes invitations from groups', () => { it('removes invitations from groups', async () => {
return userToDelete.del('/user').then((res) => { return userToDelete.del('/user').then(() => {
return otherUser.get(`/groups/${group._id}`); return otherUser.get(`/groups/${group._id}`);
}).then((fetchedGroup) => { }).then((fetchedGroup) => {
expect(fetchedGroup.invites).to.have.a.lengthOf(1); expect(fetchedGroup.invites).to.have.a.lengthOf(1);

12
test/api/v2/user/GET-user.test.js
View File

@@ -10,19 +10,19 @@ describe('GET /user', () => {
user = await usr.get('/user'); user = await usr.get('/user');
}); });
it('gets the user object', () => { it('gets the user object', async () => {
expect(user._id).to.eql(user._id); expect(user._id).to.eql(user._id);
expect(user.auth.local.username).to.eql(user.auth.local.username); expect(user.auth.local.username).to.eql(user.auth.local.username);
expect(user.todos).to.eql(user.todos); expect(user.todos).to.eql(user.todos);
expect(user.items).to.eql(user.items); expect(user.items).to.eql(user.items);
}); });
it('does not include password information', () => { it('does not include password information', async () => {
expect(user.auth.local.hashed_password).to.not.exist expect(user.auth.local.hashed_password).to.not.exist;
expect(user.auth.local.salt).to.not.exist expect(user.auth.local.salt).to.not.exist;
}); });
it('does not include api token', () => { it('does not include api token', async () => {
expect(user.apiToken).to.not.exist expect(user.apiToken).to.not.exist;
}); });
}); });

8
test/api/v2/user/GET-user_tags.test.js
View File

@@ -5,13 +5,11 @@ import {
describe('GET /user/tags', () => { describe('GET /user/tags', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((usr) => { user = await generateUser();
user = usr;
});
}); });
it('gets the user\'s tags', () => { it('gets the user\'s tags', async () => {
return expect(user.get('/user/tags')) return expect(user.get('/user/tags'))
.to.eventually.eql(user.tags); .to.eventually.eql(user.tags);
}); });

12
test/api/v2/user/GET-user_tags_id.test.js
View File

@@ -6,18 +6,16 @@ import {
describe('GET /user/tags/id', () => { describe('GET /user/tags/id', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((usr) => { user = await generateUser();
user = usr;
});
}); });
it('gets a user\'s tag by id', () => { it('gets a user\'s tag by id', async () => {
return expect(user.get('/user/tags/' + user.tags[0].id)) return expect(user.get(`/user/tags/${user.tags[0].id}`))
.to.eventually.eql(user.tags[0]); .to.eventually.eql(user.tags[0]);
}); });
it('fails for non-existent tags', () => { it('fails for non-existent tags', async () => {
return expect(user.get('/user/tags/not-an-id')) return expect(user.get('/user/tags/not-an-id'))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,

44
test/api/v2/user/PUT-user.test.js
View File

@@ -8,44 +8,43 @@ import { each } from 'lodash';
describe('PUT /user', () => { describe('PUT /user', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((usr) => { user = await generateUser();
user = usr;
});
}); });
context('allowed operations', () => { context('allowed operations', () => {
it('updates the user', () => { it('updates the user', async () => {
return user.put('/user', { let updatedUser = await user.put('/user', {
'profile.name' : 'Frodo', 'profile.name': 'Frodo',
'preferences.costume': true, 'preferences.costume': true,
'stats.hp': 14, 'stats.hp': 14,
}).then((updatedUser) => {
expect(updatedUser.profile.name).to.eql('Frodo');
expect(updatedUser.preferences.costume).to.eql(true);
expect(updatedUser.stats.hp).to.eql(14);
}); });
expect(updatedUser.profile.name).to.eql('Frodo');
expect(updatedUser.preferences.costume).to.eql(true);
expect(updatedUser.stats.hp).to.eql(14);
}); });
}); });
context('top level protected operations', () => { context('top level protected operations', () => {
let protectedOperations = { let protectedOperations = {
'gem balance': {balance: 100}, 'gem balance': {balance: 100},
'auth': {'auth.blocked': true, 'auth.timestamps.created': new Date()}, auth: {'auth.blocked': true, 'auth.timestamps.created': new Date()},
'contributor': {'contributor.level': 9, 'contributor.admin': true, 'contributor.text': 'some text'}, contributor: {'contributor.level': 9, 'contributor.admin': true, 'contributor.text': 'some text'},
'backer': {'backer.tier': 10, 'backer.npc': 'Bilbo'}, backer: {'backer.tier': 10, 'backer.npc': 'Bilbo'},
'subscriptions': {'purchased.plan.extraMonths': 500, 'purchased.plan.consecutive.trinkets': 1000}, subscriptions: {'purchased.plan.extraMonths': 500, 'purchased.plan.consecutive.trinkets': 1000},
'customization gem purchases': {'purchased.background.tavern': true, 'purchased.skin.bear': true}, 'customization gem purchases': {'purchased.background.tavern': true, 'purchased.skin.bear': true},
'tasks': {todos: [], habits: [], dailys: [], rewards: []}, tasks: {todos: [], habits: [], dailys: [], rewards: []},
}; };
each(protectedOperations, (data, testName) => { each(protectedOperations, (data, testName) => {
it(`does not allow updating ${testName}`, () => { it(`does not allow updating ${testName}`, async () => {
let errorText = []; let errorText = [];
each(data, (value, operation) => { each(data, (value, operation) => {
errorText.push(t('messageUserOperationProtected', { operation: operation })); errorText.push(t('messageUserOperationProtected', { operation }));
}); });
return expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
await expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: errorText, text: errorText,
}); });
@@ -59,12 +58,13 @@ describe('PUT /user', () => {
}; };
each(protectedOperations, (data, testName) => { each(protectedOperations, (data, testName) => {
it(`does not allow updating ${testName}`, () => { it(`does not allow updating ${testName}`, async () => {
let errorText = []; let errorText = [];
each(data, (value, operation) => { each(data, (value, operation) => {
errorText.push(t('messageUserOperationProtected', { operation: operation })); errorText.push(t('messageUserOperationProtected', { operation }));
}); });
return expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
await expect(user.put('/user', data)).to.eventually.be.rejected.and.eql({
code: 401, code: 401,
text: errorText, text: errorText,
}); });

119
test/api/v2/user/anonymized/GET-user_anonymized.test.js
View File

@@ -4,80 +4,77 @@ import {
import { each } from 'lodash'; import { each } from 'lodash';
describe('GET /user/anonymized', () => { describe('GET /user/anonymized', () => {
let user; let user, anonymizedUser;
before(() => { before(async () => {
return generateUser({ user = await generateUser({
'inbox.messages' : { 'inbox.messages': {
'the-message-id' : { 'the-message-id': {
sort : 214, sort: 214,
user : 'Some user', user: 'Some user',
backer : {}, backer: {},
contributor : { contributor: {
text : 'Blacksmith', text: 'Blacksmith',
level : 2, level: 2,
contributions : 'Made some contributions', contributions: 'Made some contributions',
admin : false admin: false,
}, },
uuid : 'some-users-uuid', uuid: 'some-users-uuid',
flagCount : 0, flagCount: 0,
flags : {}, flags: {},
likes : {}, likes: {},
timestamp : 1444154258699.0000000000000000, timestamp: 1444154258699.0000000000000000,
text : 'Lorem ipsum', text: 'Lorem ipsum',
id : 'the-messages-id', id: 'the-messages-id',
sent : true sent: true,
} },
} },
}).then((usr) => {
user = usr;
return user.post('/user/tasks', {
text: 'some private text',
notes: 'some private notes',
checklist: [
{text: 'a private checklist'},
{text: 'another private checklist'},
],
type: 'daily',
});
}).then((result) => {
return user.get('/user/anonymized');
}).then((anonymizedUser) => {
user = anonymizedUser;
}); });
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', () => { it('retains user id', async () => {
expect(user._id).to.exist; expect(anonymizedUser._id).to.eql(user._id);
}); });
it('removes credentials and financial information', () => { it('removes credentials and financial information', async () => {
expect(user.apiToken).to.not.exist; expect(anonymizedUser.apiToken).to.not.exist;
expect(user.auth.local).to.not.exist; expect(anonymizedUser.auth.local).to.not.exist;
expect(user.auth.facebook).to.not.exist; expect(anonymizedUser.auth.facebook).to.not.exist;
expect(user.purchased.plan).to.not.exist; expect(anonymizedUser.purchased.plan).to.not.exist;
}); });
it('removes profile information', () => { it('removes profile information', async () => {
expect(user.profile).to.not.exist; expect(anonymizedUser.profile).to.not.exist;
expect(user.contributor).to.not.exist; expect(anonymizedUser.contributor).to.not.exist;
expect(user.achievements.challenges).to.not.exist; expect(anonymizedUser.achievements.challenges).to.not.exist;
}); });
it('removes social information', () => { it('removes social information', async () => {
expect(user.newMessages).to.not.exist; expect(anonymizedUser.newMessages).to.not.exist;
expect(user.invitations).to.not.exist; expect(anonymizedUser.invitations).to.not.exist;
expect(user.items.special.nyeReceived).to.not.exist; expect(anonymizedUser.items.special.nyeReceived).to.not.exist;
expect(user.items.special.valentineReceived).to.not.exist; expect(anonymizedUser.items.special.valentineReceived).to.not.exist;
each(user.inbox.messages, (msg) => { each(anonymizedUser.inbox.messages, (msg) => {
expect(msg.text).to.eql('inbox message text'); expect(msg.text).to.eql('inbox message text');
}); });
}); });
it('anonymizes task info', () => { it('anonymizes task info', async () => {
each(['habits', 'todos', 'dailys', 'rewards'], (tasks) => { each(['habits', 'todos', 'dailys', 'rewards'], (tasks) => {
each(user[tasks], (task) => { each(anonymizedUser[tasks], (task) => {
expect(task.text).to.eql('task text'); expect(task.text).to.eql('task text');
expect(task.notes).to.eql('task notes'); expect(task.notes).to.eql('task notes');
@@ -88,14 +85,14 @@ describe('GET /user/anonymized', () => {
}); });
}); });
it('anonymizes tags', () => { it('anonymizes tags', async () => {
each(user.tags, (tag) => { each(anonymizedUser.tags, (tag) => {
expect(tag.name).to.eql('tag'); expect(tag.name).to.eql('tag');
expect(tag.challenge).to.eql('challenge'); expect(tag.challenge).to.eql('challenge');
}); });
}); });
it('removes webhooks', () => { it('removes webhooks', async () => {
expect(user.webhooks).to.not.exist; expect(anonymizedUser.webhooks).to.not.exist;
}); });
}); });

51
test/api/v2/user/batch-update/POST-user_batch-update.test.js
View File

@@ -8,32 +8,26 @@ import { each } from 'lodash';
describe('POST /user/batch-update', () => { describe('POST /user/batch-update', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((usr) => { user = await generateUser();
user = usr;
});
}); });
context('allowed operations', () => { context('allowed operations', () => {
it('makes batch operations', () => { it('makes batch operations', async () => {
let task; let task = (await user.get('/user/tasks'))[0];
return user.get('/user/tasks').then((tasks) => { let updatedUser = await user.post('/user/batch-update', [
task = tasks[0]; {op: 'update', body: {'stats.hp': 30}},
{op: 'update', body: {'profile.name': 'Samwise'}},
{op: 'score', params: { direction: 'up', id: task.id }},
]);
return user.post('/user/batch-update', [ expect(updatedUser.stats.hp).to.eql(30);
{op: 'update', body: {'stats.hp': 30}}, expect(updatedUser.profile.name).to.eql('Samwise');
{op: 'update', body: {'profile.name': 'Samwise'}},
{op: 'score', params: { direction: 'up', id: task.id }},
]);
}).then((updatedUser) => {
expect(updatedUser.stats.hp).to.eql(30);
expect(updatedUser.profile.name).to.eql('Samwise');
return user.get(`/user/tasks/${task.id}`); let fetchedTask = await user.get(`/user/tasks/${task.id}`);
}).then((task) => {
expect(task.value).to.be.greaterThan(0); expect(fetchedTask.value).to.be.greaterThan(task.value);
});
}); });
}); });
@@ -44,26 +38,25 @@ describe('POST /user/batch-update', () => {
}; };
each(protectedOperations, (operation, description) => { each(protectedOperations, (operation, description) => {
it(`it sends back a 500 error for ${description} operation`, async () => {
it(`it sends back a 500 error for ${description} operation`, () => {
return expect(user.post('/user/batch-update', [ return expect(user.post('/user/batch-update', [
{ op: operation }, { op: operation },
])).to.eventually.be.rejected.and.eql({ ])).to.eventually.be.rejected.and.eql({
code: 500, code: 500,
text: t('messageUserOperationNotFound', { operation }), text: t('messageUserOperationNotFound', { operation }),
}); });
}); });
}); });
}); });
context('unknown operations', () => { context('unknown operations', () => {
it('sends back a 500 error', () => { it('sends back a 500 error', async () => {
return expect(user.post('/user/batch-update', [ return expect(user.post('/user/batch-update', [
{op: 'aNotRealOperation'}, {op: 'aNotRealOperation'},
])).to.eventually.be.rejected.and.eql({ ])).to.eventually.be.rejected.and.eql({
code: 500, code: 500,
text: t('messageUserOperationNotFound', { operation: 'aNotRealOperation' }), text: t('messageUserOperationNotFound', { operation: 'aNotRealOperation' }),
}); });
}); });
}); });
}); });

8
test/api/v2/user/pushDevice/POST-pushDevice.test.js
View File

@@ -5,13 +5,11 @@ import {
describe('POST /user/pushDevice', () => { describe('POST /user/pushDevice', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user;
});
}); });
it('registers a device id', () => { it('registers a device id', async () => {
return user.post('/user/pushDevice', { return user.post('/user/pushDevice', {
regId: '123123', regId: '123123',
type: 'android', type: 'android',

31
test/api/v2/user/tasks/DELETE-tasks_id.test.js
View File

@@ -6,32 +6,29 @@ import {
describe('DELETE /user/tasks/:id', () => { describe('DELETE /user/tasks/:id', () => {
let user, task; let user, task;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user; task = user.todos[0];
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('deletes a task', () => { it('returns an error if the task does not exist', async () => {
return expect(user.del(`/user/tasks/${task.id}`)
.then((res) => {
return 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', () => {
return expect(user.del('/user/tasks/task-that-does-not-exist')) return expect(user.del('/user/tasks/task-that-does-not-exist'))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageTaskNotFound'), text: t('messageTaskNotFound'),
}); });
}); });
it('does not delete another user\'s task', () => { it('does not delete another user\'s task', async () => {
return expect(generateUser().then((otherUser) => { return expect(generateUser().then((otherUser) => {
let otherUsersTask = otherUser.todos[0]; let otherUsersTask = otherUser.todos[0];
return user.del(`/user/tasks/${otherUsersTask.id}`); return user.del(`/user/tasks/${otherUsersTask.id}`);

5
test/api/v2/user/tasks/GET-tasks.test.js
View File

@@ -1,12 +1,11 @@
import { import {
generateUser, generateUser,
translate as t,
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('GET /user/tasks/', () => { describe('GET /user/tasks/', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser({ return generateUser({
dailys: [ dailys: [
{text: 'daily', type: 'daily'}, {text: 'daily', type: 'daily'},
@@ -19,7 +18,7 @@ describe('GET /user/tasks/', () => {
}); });
}); });
it('gets all tasks', () => { it('gets all tasks', async () => {
return user.get(`/user/tasks/`).then((tasks) => { return user.get(`/user/tasks/`).then((tasks) => {
expect(tasks).to.be.an('array'); expect(tasks).to.be.an('array');
expect(tasks.length).to.be.greaterThan(3); expect(tasks.length).to.be.greaterThan(3);

16
test/api/v2/user/tasks/GET-tasks_id.test.js
View File

@@ -6,14 +6,12 @@ import {
describe('GET /user/tasks/:id', () => { describe('GET /user/tasks/:id', () => {
let user, task; let user, task;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user; task = user.todos[0];
task = user.todos[0];
});
}); });
it('gets a task', () => { it('gets a task', async () => {
return user.get(`/user/tasks/${task.id}`).then((foundTask) => { return user.get(`/user/tasks/${task.id}`).then((foundTask) => {
expect(foundTask.id).to.eql(task.id); expect(foundTask.id).to.eql(task.id);
expect(foundTask.text).to.eql(task.text); expect(foundTask.text).to.eql(task.text);
@@ -23,15 +21,15 @@ describe('GET /user/tasks/:id', () => {
}); });
}); });
it('returns an error if the task does not exist', () => { it('returns an error if the task does not exist', async () => {
return expect(user.get('/user/tasks/task-that-does-not-exist')) return expect(user.get('/user/tasks/task-that-does-not-exist'))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
text: t('messageTaskNotFound'), text: t('messageTaskNotFound'),
}); });
}); });
it('does not get another user\'s task', () => { it('does not get another user\'s task', async () => {
return expect(generateUser().then((otherUser) => { return expect(generateUser().then((otherUser) => {
let otherUsersTask = otherUser.todos[0]; let otherUsersTask = otherUser.todos[0];

19
test/api/v2/user/tasks/POST-tasks.test.js
View File

@@ -4,27 +4,24 @@ import {
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('POST /user/tasks', () => { describe('POST /user/tasks', () => {
let user; let user;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user;
});
}); });
it('creates a task', () => { it('creates a task', async () => {
return user.post('/user/tasks').then((task) => { return user.post('/user/tasks').then((task) => {
expect(task.id).to.exist; expect(task.id).to.exist;
}); });
}); });
it('creates a habit by default', () => { it('creates a habit by default', async () => {
return expect(user.post('/user/tasks')) return expect(user.post('/user/tasks'))
.to.eventually.have.property('type', 'habit'); .to.eventually.have.property('type', 'habit');
}); });
it('creates a task with specified values', () => { it('creates a task with specified values', async () => {
return user.post('/user/tasks', { return user.post('/user/tasks', {
type: 'daily', type: 'daily',
text: 'My task', text: 'My task',
@@ -38,7 +35,7 @@ describe('POST /user/tasks', () => {
}); });
}); });
it('does not create a task with an id that already exists', () => { it('does not create a task with an id that already exists', async () => {
let todo = user.todos[0]; let todo = user.todos[0];
return expect(user.post('/user/tasks', { return expect(user.post('/user/tasks', {
@@ -49,7 +46,7 @@ describe('POST /user/tasks', () => {
}); });
}); });
xit('TODO: no error is thrown - throws a 500 validation error if invalid type is posted', () => { xit('TODO: no error is thrown - throws a 500 validation error if invalid type is posted', async () => {
return expect(user.post('/user/tasks', { return expect(user.post('/user/tasks', {
type: 'not-valid', type: 'not-valid',
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({
@@ -58,7 +55,7 @@ describe('POST /user/tasks', () => {
}); });
}); });
xit('TODO: no error is thrown - throws a 500 validation error if invalid data is posted', () => { xit('TODO: no error is thrown - throws a 500 validation error if invalid data is posted', async () => {
return expect(user.post('/user/tasks', { return expect(user.post('/user/tasks', {
frequency: 'not-valid', frequency: 'not-valid',
})).to.eventually.be.rejected.and.eql({ })).to.eventually.be.rejected.and.eql({

23
test/api/v2/user/tasks/PUT-tasks_id.test.js
View File

@@ -1,19 +1,16 @@
import { import {
generateUser, generateUser,
translate as t,
} from '../../../../helpers/api-integration.helper'; } from '../../../../helpers/api-integration.helper';
describe('PUT /user/tasks/:id', () => { describe('PUT /user/tasks/:id', () => {
let user, task; let user, task;
beforeEach(() => { beforeEach(async () => {
return generateUser().then((_user) => { user = await generateUser();
user = _user; task = user.todos[0];
task = user.todos[0];
});
}); });
it('does not update the id of the task', () => { it('does not update the id of the task', async () => {
return user.put(`/user/tasks/${task.id}`, { return user.put(`/user/tasks/${task.id}`, {
id: 'some-thing', id: 'some-thing',
}).then((updatedTask) => { }).then((updatedTask) => {
@@ -22,7 +19,7 @@ describe('PUT /user/tasks/:id', () => {
}); });
}); });
it('does not update the type of the task', () => { it('does not update the type of the task', async () => {
return user.put(`/user/tasks/${task.id}`, { return user.put(`/user/tasks/${task.id}`, {
type: 'habit', type: 'habit',
}).then((updatedTask) => { }).then((updatedTask) => {
@@ -31,23 +28,23 @@ describe('PUT /user/tasks/:id', () => {
}); });
}); });
it('updates text, attribute, priority, value and notes', () => { it('updates text, attribute, priority, value and notes', async () => {
return user.put(`/user/tasks/${task.id}`, { return user.put(`/user/tasks/${task.id}`, {
text: 'new text', text: 'new text',
notes: 'new notes', notes: 'new notes',
value: 10000, value: 10000,
priority: .5, priority: 0.5,
attribute: 'str', attribute: 'str',
}).then((updatedTask) => { }).then((updatedTask) => {
expect(updatedTask.text).to.eql('new text'); expect(updatedTask.text).to.eql('new text');
expect(updatedTask.notes).to.eql('new notes'); expect(updatedTask.notes).to.eql('new notes');
expect(updatedTask.value).to.eql(10000); expect(updatedTask.value).to.eql(10000);
expect(updatedTask.priority).to.eql(.5); expect(updatedTask.priority).to.eql(0.5);
expect(updatedTask.attribute).to.eql('str'); expect(updatedTask.attribute).to.eql('str');
}); });
}); });
it('returns an error if the task does not exist', () => { it('returns an error if the task does not exist', async () => {
return expect(user.put('/user/tasks/task-id-that-does-not-exist')) return expect(user.put('/user/tasks/task-id-that-does-not-exist'))
.to.eventually.be.rejected.and.eql({ .to.eventually.be.rejected.and.eql({
code: 404, code: 404,
@@ -55,7 +52,7 @@ describe('PUT /user/tasks/:id', () => {
}); });
}); });
it('does not update another user\'s task', () => { it('does not update another user\'s task', async () => {
return expect(generateUser().then((otherUser) => { return expect(generateUser().then((otherUser) => {
let otherUsersTask = otherUser.todos[0]; let otherUsersTask = otherUser.todos[0];
return user.put(`/user/tasks/${otherUsersTask._id}`, { return user.put(`/user/tasks/${otherUsersTask._id}`, {

2
website/views/shared/new-stuff.jade
View File

@@ -4,7 +4,7 @@ h2 12/30/2015 - NEW YEAR'S EVE CELEBRATION: PARTY HATS, NEW YEAR'S CARDS, BEEMIN
td td
.npc_matt.pull-right .npc_matt.pull-right
h3 Party Hats h3 Party Hats
p In honor of the new year, some free Party Hats are available in the Rewards store! New users get the ever-handsome Absurd Party Hat, and users who already received one last year get the Silly Party Hat or the new Ridiculous Party Hat. These hats will be available to purchase until January 31st, but once you've bought them, you'll have them forever. Enjoy! p In honor of the new year, there's a free Party Hat available in the Rewards store! New users get the ever-handsome Absurd Party Hat, and users who already received one last year get the Silly Party Hat or the new Ridiculous Party Hat. These hats will be available to purchase until January 31st, but once you've bought them, you'll have them forever. Enjoy!
p.small.muted by Lemoness and SabreCat p.small.muted by Lemoness and SabreCat
tr tr
td td