Kai/habitica
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

API v3 [WIP] (#6144)

Browse Source 
* Fixed more tests

* Added tags into user service

* Added api-v3 auth urls

* v3: fix package.json

* v3: fix package.json

* Fixed auth tests. Updated Authctrl response

* v3: remove newrelic config file in favour of env variables

* v3: upgrade some deps

* switch from Q to Bluebird

* v3 fix tests with deferred

* Removed extra consoles.log. Changed data.data to res.data

* v3 fix tests and use coroutines instead of regenerator

* v3: fix tests

* v3: do not await a non promise

* v3: q -> bluebird

* Changed id param for registration response

* Updated party query and create

* Ensured login callback happens after user sync

* Add challenges to groups. Fixed isMemberOfGuild check

* Updated party and group tests

* Fixed cron test

* return user.id and send analytics event before changing page

* fix trailing spaces

* disable redirects

* Api v3 party tavern fixes (#7191)

* Added check if user is in party before query

* Cached party query. Prevented party request when user is not in party. Updated Party create with no invites

* Update tavern ctrl to use new promise

* v3: misc fixes

* Api v3 task fixes (#7193)

* Update task view to use _id

* Added try catch to user service ops calls

* v3 client: saving after syncing is complete

* Fixed test broken by part sync change (#7195)

* v3: fix todo scoring and try to fix production testing problem

* revert changes to mongoose config

* mongoose: increase keepAlive

* test mongoose fix

* fix: Only apply captureStackTrace if it exists on the error object

* v3: fix reminders with no startDate

* mongoose: use options

* chore(): rename website/src -> website/server and website/public -> website/client (#7199)

* v3 fix GET /groups: return an error only if an invalid type is supplied not when there are 0 results (#7203)

* [API v3] Fix calls to user.ops and deleting tags (#7204)

* v3: fixes calls to user.ops from views and deleting tags

* v3: fix tests that use user._statsComputed

* Api v3 fixes continued (#7205)

* Added timzeone offset back

* Added APIToken back to settings page

* Fixed fetch recent messages for party

* Fixed returning group description

* Fixed check if user is member of challenge

* Fixed party members appearing in header

* Updated get myGroups param to include public groups. Fixed isMemberOf group

* Fixed hourglass purchase

* Fixed challenge addding tasks on first creating

* Updated tests to accomidate new changes

* fix: Correct checklist on client

Closes #7207

* fix: Pin eslint to 2.9

* minor improvements to cron code for clarity; fix inaccurate comments; add TODOs for rest-in-inn actions

* fix: Add missing type param to equip call

closes #7212

* rename and reword pubChalsMinPrize to reflect that it's only for Tavern challenges

* allows players to send gems to each other; other minor related changes - fixes https://github.com/HabitRPG/habitrpg/issues/7227

* fix tests for /members/transfer-gems

* fix: Set gems sent notification as translatable string

* chore: Remove unusued variable

* fix: Remove requirement on message paramter in transfer-gems

* add a missing variable declaration

* chore: clarify comments on cron code

* fix: Correct client request from habitrpg -> tavern

* update apidoc URL in package.json

Closes #7222

* Fixed start party by invites

* Updated spell casting to v3

* Fixed adding and removing tags on tasks

* Fixed page reload on settings change

* Fixed battle monsters with friends button

* Loaded completed todos when done is clicked

* chore: Reinstate floating version number for eslint

babel-eslint regression fixed

* Fixed reload tests

* change "an user" to "a user" in comments and text (no code changes) (#7257)

* fix: Alert user that drops were recieved

* remove userServices.js from karma.conf - it's been moved to website/client/js/services

* feat: Create debug update user route

* fix: Correct set cron debug function

* feat: Add make admin button to debug menu

* lint: Add missing semicolons in test

* fix: Temporarilly comment out udpate user debug route

* v3: fix _tmp for crit and streakBonus

* v3: execute all actions when leaving a solo party

* v3 client: fix group not found when leaving party

* v3 migration: fix challenge prize

* v3 cron: only save modified tasks

* v3: add CHALLENGE_TASK_NOT_FOUND to valid broken reasons

* v3: fix tasks chart

* v3 client: fix ability to leave challenge

* v3 client: fix filtering by tag and correctly show tag tooltip

* v3 common: fix tags tests

* v3 client: support unlinking not found challenges tasks

* v3: disable Bluebird warning for missing return, fixes #7269

* feat: Separate out update-user into set-cron and make-admin debug routes

* chore: Disable make admin debug route for v3 prod testing

* v3: misc fixes

* v3: misc fixes

* v3: fix adding multiple tasks

* Fixed join/leave button updates

* Queried only user groups to be available when creating challenges

* Fixed bulk add tasks to challenge

* Synced challenge tasks after leave and join.

* Fixed default selected group

* Fixed challenge member info. Fixed challenge winner selection

* Fixed deleting challenge tasks

* Fixed particiapting filter

* v3 client: fix casting spells

* v3: do not log sensitive data

* v3: always save user when casting spell

* v3: always save user when casting spell

* v3: more fixes for spells

* fix typos and missing information in apidocs - fixes https://github.com/HabitRPG/habitrpg/issues/7277 (#7282)

* v3: add TODO for client side spells

* feat: Add modify inventory debug menu

* Fixed viewing user progress on challenge

* Updated tests

* fix: Fix quest progress button

* fix incorrect Armoire test; remove unneeded param details from apidocs; disambiguate health potion

* v3: fix stealth casting

* v3: fix tasks saving and selection for rebirth reroll and reset (server-only)

* v3: fix auto allocation

* v3 client: misc fixes

* rename buyPotion and buy-potion to buyHealthPotion and buy-health-potion; fix apidoc param error

* Added delete for saved challenge task

* Fixed member modal on front page

* adjust text in apidocs for errors / clarity / consistency / standard terminology (no code changes) (#7298)

* fix bug in Rebirth test, add new tests, adjust apidocs (#7293)

* Updated task model to allow setting streak (#7306)

* fix: Correct missing * in apidoc comments

* Api v3 challenge fixes (#7287)

* Fixed join/leave button updates

* Queried only user groups to be available when creating challenges

* Fixed bulk add tasks to challenge

* Synced challenge tasks after leave and join.

* Fixed default selected group

* Fixed challenge member info. Fixed challenge winner selection

* Fixed deleting challenge tasks

* Fixed particiapting filter

* Fixed viewing user progress on challenge

* Updated tests

* Added delete for saved challenge task

* v3: fix sorting

* [API v3] add CRON_SAFE_MODE (#7286)

* add CRON_SAFE_MODE to example config file, fix some bugs, add an unrelated low-priority TODO

* create CRON_SAFE_MODE to disable parts of cron for use after extended outage - fixes https://github.com/HabitRPG/habitrpg/issues/7161

* fix a bug with CRON_SAFE_MODE, remove duplicated code, remove completed TODO comment

* fix check for CRON_SAFE_MODE

* v3 client: fix typo

* adjust debug menu Modify Inventory: hungrier pets, fewer Special items, "Hide" buttons

* completed To-Dos: return the 30 most recent instead of 30 oldest (#7318)

* v3 migration: fix createdAt date

* adjust locales text, key names, and files for Rebirth, Reset, and Fortify / ReRoll for consistency with existing strings (#7321)

* v3: fix unlinking multiple tasks

* v3 fix releasing pets

* v3: fix authenticating with apiUrl

* v3: fix typo

* v3 fix client tests for unlinking

* v3 client: do not show start quest button when quest is active

* v3 client: fix ability to send cards

* v3 client: fix misc challenge issues

* v3: fix notifications

* v3 client: more user friendly errors

* v3 client: only load completed todos once

* v3 client: fix tests

* v3: move TAVERN_ID to common code

* fix: Provide default type and text for new task creation in score route

* fix: Provide default history [] for habit in score route

* fix: Add _legacyId prop to tasks to support non-uuid identifiers

* chore: Change v3 migration to use _legacyId instead of legacyId

* fix: check for _legacyId in tasks if id does not exist

* refactor: Extract out finding task by id or _legacyId into a function

* Api v3 party quest fixes (#7341)

* Fix display of add challenge message when group challenges are empty

* Fixed forced quest start to update quest without reload

* Fixed needing to reload when accepting party invite

* Fix group leave and join reload

* Fixed leave current party and join another

* Updated party tests

* v3 client: remove console.log statement

* v3: misc fixes

* v3 client: fix predicatbale random

* v3: info about API v3

* v3: update footer with links to developer resources

* v3: support party invitation from email

* v3 client: fix chat flagging

* fix: Correct get tasks route to properly get todos (#7349)

* move locales strings from api-v3.json to other locales files (#7347)

* move locales strings from api-v3.json: authentication strings -> front.json

* move locales strings from api-v3.json: authentication strings -> tasks.json

* move locales strings from api-v3.json: authentication strings -> groups.json

* move locales strings from api-v3.json: authentication strings -> challenge.json

* move locales strings from api-v3.json: authentication strings -> groups.json (again)

* move locales strings from api-v3.json: authentication strings -> quests.json

* move locales strings from api-v3.json: authentication strings -> subscriber.json

* move locales strings from api-v3.json: authentication strings -> spells.json

* move locales strings from api-v3.json: authentication strings -> character.json

* move locales strings from api-v3.json: authentication strings -> groups.json (PMs)

* move locales strings from api-v3.json: authentication strings -> npc.json

* move locales strings from api-v3.json: authentication strings -> pets.json

* move locales strings from api-v3.json: authentication strings -> miscellaneous

* move locales strings from api-v3.json: authentication strings -> contrib.json and settings.json

* move locales strings from api-v3.json: delete unused string (invalidTasksOwner), delete api-v3.json, whitespace cleanup

* v3 client: fix sticky header

* v3: remove unused code

* v3 client: correctly redirect after inviting

* Removed v2 calls from views (#7351)

* v3: fix tests for challenge export

* v3: fallbackto authWithHeaders if wuthWithSession or authWithUrl fails

* Added force cache update when fetching new messages (#7360)

* v3: fetch whole user when booting from group tto avoid issues with pre save hook expecting all data

* v3: misc fixes for payments

* v3: limit fields of challenge tasks that can be updated

* fix(tests): never connect to NODE_DB_URI for tests

* Added new route for setting last cron and updated front end

* v3: fix iap url

* v3: fix build and ios IAP

* Changed route to user set custom day start

* v3: iap accessible under /api/v3, fixes to spells and groups invitations

* v3: correctly use v3 routes in client

* remove XP, GP when unticking a Daily with a completed checklist - fixes https://github.com/HabitRPG/habitrpg/issues/7246

* use natural language for error message about skills on challenge tasks (#7336), fix other gramatical error

* Updated ui when user rejects a guild invite (#7368)

* feat: complete custom day start route

Closes #7363

* fix: Correct spelling of healAll skill

fix: Correct sprite name of healAll skill

* fix: Change all instances of spookDust -> spookySparkles

* add dateCreated to all tasks; add empty challenge object to tasks that don't have one (#7386)

* add plumilla to artists for Tangle Tree in Bailey message

* Fixed quest drop modal (#7377)

* Fixed quest drop modal

* Fixed broken party test

* [API v3] Maintenance Mode (#7367)

* WIP(maintenance): maintenance

* WIP(maintenance): working locale features

* fix(maintenance): don't translate info page target

* WIP(maintenance): start adding info page

* fix(maintenance): linting

* feat: Add container to maintenance info page

* fix(maintenance): add config.json edits
Also DRY variables for main vs info pages

* fix(maintenance): linting

* refactor(maintenance): further slim down variables

* refactor: Remove unnecessary variables

* fix: Correct string interpolation in maintenace view

* feat: Dynamically add time to maintenance pages

* maintenance mode: do not connect to mongodb

* fix(maintenance): clean up timezones etc.

* fix(maintenance): remove unneeded sprite

* Tavern party challenges invites fix (#7394)

* Added challenges and invitations to party

* Loaded tavern challenges

* Updated group and quest services tests

* v3: implement automatic syncing if user is not up to date

* Removed unnecessary fields when updating groups and challenges (#7395)

* v3: do not saved populated user

* v3: correctly return user subset

* Chained party promises together (#7396)

* v3: $w -> splitWhitespace

* use bluebird

* use babel polyfill

* migration: fix items

* update links for v3

* Updated shortname validation to support multiple browsers

* Docs changes (#7401)

* chore: Clarify transfer-gems documentation

* chore: Clarify api status route documentation

* chore: Mark webhooks as BETA

* Added tags update route. Added sort to user service (#7381)

* Added tags update route. Added sort to user service

* Change update tasks route to reorder tasks

* Fixed linting issue

* Changed params for reorder tags route

* Fixed not found tag and added test

* Added password confirmation when deleteing account (#7402)

* fix production logging

* feat(commit): push

* empty commit

* feat(maintenance): post-downtime news & awards (#7406)

* fix exporting avatar

* second attempt at fixing exporting avatar

* fix production logging

* s3: convert moment to date instance

* fix avatar sharing and caching (30 minutes)

* fix: Correct missing parameter

Closes #7433

* fix: Validate challenge shortname on server

* adjust text strings - fixes https://github.com/HabitRPG/habitrpg/issues/5631 and also Short Name -> Tag Name
This commit is contained in:
Matteo Pagliazzi
2016-05-23 13:58:31 +02:00
parent ef3a2fc286
commit 28f2e9c356
993 changed files with 44888 additions and 12883 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/api/v3/integration/challenges/DELETE-challenges_challengeId.test.js
+94
View File
@@ -0,0 +1,94 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
sleep,
checkExistence,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /challenges/:challengeId', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
await expect(user.del('/challenges/test')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
await expect(user.del(`/challenges/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
context('Deleting a valid challenge', () => {
let groupLeader;
let group;
let challenge;
let taskText = 'A challenge task text';
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup();
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
challenge = await generateChallenge(groupLeader, group);
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
]);
await challenge.sync();
});
it('returns an error when user doesn\'t have permissions to delete the challenge', async () => {
let user = await generateUser();
await expect(user.del(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyLeaderDeleteChal'),
});
});
it('deletes challenge', async () => {
await groupLeader.del(`/challenges/${challenge._id}`);
await sleep(0.5);
await expect(checkExistence('challenges', challenge._id)).to.eventually.equal(false);
});
it('refunds gems to group leader', async () => {
let oldBalance = (await groupLeader.sync()).balance;
await groupLeader.del(`/challenges/${challenge._id}`);
await sleep(0.5);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldBalance + challenge.prize / 4);
});
it('sets broken and doesn\'t set winner flags for user\'s challenge tasks', async () => {
await groupLeader.del(`/challenges/${challenge._id}`);
await sleep(0.5);
let tasks = await groupLeader.get('/tasks/user');
let testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
expect(testTask.challenge.broken).to.eql('CHALLENGE_DELETED');
expect(testTask.challenge.winner).to.be.null;
});
});
});
test/api/v3/integration/challenges/GET-challenges_challengeId.test.js
+142
View File
@@ -0,0 +1,142 @@
import {
generateUser,
createAndPopulateGroup,
generateChallenge,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId', () => {
it('fails if challenge doesn\'t exists', async () => {
let user = await generateUser();
await expect(user.get(`/challenges/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
context('public guild', () => {
let groupLeader;
let group;
let challenge;
let user;
beforeEach(async () => {
user = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'guild', privacy: 'public'},
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
challenge = await generateChallenge(groupLeader, group);
});
it('should return challenge data', async () => {
let chal = await user.get(`/challenges/${challenge._id}`);
expect(chal.memberCount).to.equal(challenge.memberCount);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
});
expect(chal.group).to.eql(_.pick(group, ['_id', 'id', 'name', 'type', 'privacy']));
});
});
context('private guild', () => {
let groupLeader;
let group;
let challenge;
let members;
let user;
beforeEach(async () => {
user = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'guild', privacy: 'private'},
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
members = populatedGroup.members;
challenge = await generateChallenge(groupLeader, group);
await members[0].post(`/challenges/${challenge._id}/join`);
});
it('fails if user doesn\'t have access to the challenge', async () => {
await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('should return challenge data', async () => {
let chal = await members[0].get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
});
expect(chal.group).to.eql(_.pick(group, ['_id', 'id', 'name', 'type', 'privacy']));
});
});
context('party', () => {
let groupLeader;
let group;
let challenge;
let members;
let user;
beforeEach(async () => {
user = await generateUser();
let populatedGroup = await createAndPopulateGroup({
groupDetails: {type: 'party'},
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
members = populatedGroup.members;
challenge = await generateChallenge(groupLeader, group);
await members[0].post(`/challenges/${challenge._id}/join`);
});
it('fails if user doesn\'t have access to the challenge', async () => {
await expect(user.get(`/challenges/${challenge._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('should return challenge data', async () => {
let chal = await members[0].get(`/challenges/${challenge._id}`);
expect(chal.name).to.equal(challenge.name);
expect(chal._id).to.equal(challenge._id);
expect(chal.leader).to.eql({
_id: groupLeader._id,
id: groupLeader.id,
profile: {name: groupLeader.profile.name},
});
expect(chal.group).to.eql(_.pick(group, ['_id', 'id', 'name', 'type', 'privacy']));
});
});
});
test/api/v3/integration/challenges/GET-challenges_challengeId_export_csv.test.js
+74
View File
@@ -0,0 +1,74 @@
import {
generateUser,
createAndPopulateGroup,
generateChallenge,
translate as t,
sleep,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/export/csv', () => {
let groupLeader;
let group;
let challenge;
let members;
let user;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
members: 3,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
members = populatedGroup.members;
challenge = await generateChallenge(groupLeader, group);
await members[0].post(`/challenges/${challenge._id}/join`);
await members[1].post(`/challenges/${challenge._id}/join`);
await members[2].post(`/challenges/${challenge._id}/join`);
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: 'Task 1'},
{type: 'todo', text: 'Task 2'},
]);
await sleep(0.5); // Make sure tasks are synced to the users
await members[0].sync();
await members[1].sync();
await members[2].sync();
});
it('fails if challenge doesn\'t exists', async () => {
user = await generateUser();
user.get('/user');
await expect(user.get(`/challenges/${generateUUID()}/export/csv`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('fails if user doesn\'t have access to the challenge', async () => {
user = await generateUser();
user.get('/user');
await expect(user.get(`/challenges/${challenge._id}/export/csv`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('should return a valid CSV file with export data', async () => {
let res = await members[0].get(`/challenges/${challenge._id}/export/csv`);
let sortedMembers = _.sortBy([members[0], members[1], members[2], groupLeader], '_id');
let splitRes = res.split('\n');
expect(splitRes[0]).to.equal('UUID,name,Task,Value,Notes,Task,Value,Notes');
expect(splitRes[1]).to.equal(`${sortedMembers[0]._id},${sortedMembers[0].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
expect(splitRes[2]).to.equal(`${sortedMembers[1]._id},${sortedMembers[1].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
expect(splitRes[3]).to.equal(`${sortedMembers[2]._id},${sortedMembers[2].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
expect(splitRes[4]).to.equal(`${sortedMembers[3]._id},${sortedMembers[3].profile.name},habit:Task 1,0,,todo:Task 2,0,`);
expect(splitRes[5]).to.equal('');
});
});
test/api/v3/integration/challenges/GET-challenges_challengeId_members.test.js
+109
View File
@@ -0,0 +1,109 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/members', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('validates optional req.query.lastId to be an UUID', async () => {
await expect(user.get(`/challenges/${generateUUID()}/members?lastId=invalidUUID`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('fails if challenge doesn\'t exists', async () => {
await expect(user.get(`/challenges/${generateUUID()}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('fails if user doesn\'t have access to the challenge', async () => {
let group = await generateGroup(user);
let challenge = await generateChallenge(user, group);
let anotherUser = await generateUser();
await expect(anotherUser.get(`/challenges/${challenge._id}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('works with challenges belonging to public guild', async () => {
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(leader, group);
let res = await user.get(`/challenges/${challenge._id}/members`);
expect(res[0]).to.eql({
_id: leader._id,
id: leader._id,
profile: {name: leader.profile.name},
});
expect(res[0]).to.have.all.keys(['_id', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('populates only some fields', async () => {
let anotherUser = await generateUser({balance: 3});
let group = await generateGroup(anotherUser, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(anotherUser, group);
let res = await user.get(`/challenges/${challenge._id}/members`);
expect(res[0]).to.eql({
_id: anotherUser._id,
id: anotherUser._id,
profile: {name: anotherUser.profile.name},
});
expect(res[0]).to.have.all.keys(['_id', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('returns only first 30 members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
}
await Promise.all(usersToGenerate);
let res = await user.get(`/challenges/${challenge._id}/members`);
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'id', 'profile']);
expect(member.profile).to.have.all.keys(['name']);
});
});
it('supports using req.query.lastId to get more members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
let usersToGenerate = [];
for (let i = 0; i < 57; i++) {
usersToGenerate.push(generateUser({challenges: [challenge._id]}));
}
let generatedUsers = await Promise.all(usersToGenerate); // Group has 59 members (1 is the leader)
let expectedIds = [user._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
let res = await user.get(`/challenges/${challenge._id}/members`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/challenges/${challenge._id}/members?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(28);
let resIds = res.concat(res2).map(member => member._id);
expect(resIds).to.eql(expectedIds.sort());
});
});
test/api/v3/integration/challenges/GET-challenges_challengeId_members_memberId.test.js
+107
View File
@@ -0,0 +1,107 @@
import {
generateUser,
generateChallenge,
generateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /challenges/:challengeId/members/:memberId', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('validates req.params.memberId to be an UUID', async () => {
await expect(user.get(`/challenges/invalidUUID/members/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('validates req.params.memberId to be an UUID', async () => {
await expect(user.get(`/challenges/${generateUUID()}/members/invalidUUID`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('fails if member doesn\'t exists', async () => {
let userId = generateUUID();
await expect(user.get(`/challenges/${generateUUID()}/members/${userId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId}),
});
});
it('fails if challenge doesn\'t exists', async () => {
let member = await generateUser();
await expect(user.get(`/challenges/${generateUUID()}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('fails if user doesn\'t have access to the challenge', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
let anotherUser = await generateUser();
let member = await generateUser();
await expect(anotherUser.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('fails if member is not part of the challenge', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
let member = await generateUser();
await expect(user.get(`/challenges/${challenge._id}/members/${member._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeMemberNotFound'),
});
});
it('works with challenges belonging to a public guild', async () => {
let groupLeader = await generateUser({balance: 4});
let group = await generateGroup(groupLeader, {type: 'guild', privacy: 'public', name: generateUUID()});
let challenge = await generateChallenge(groupLeader, group);
let taskText = 'Test Text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: taskText}]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${groupLeader._id}`);
expect(memberProgress).to.have.all.keys(['_id', 'id', 'profile', 'tasks']);
expect(memberProgress.profile).to.have.all.keys(['name']);
expect(memberProgress.tasks.length).to.equal(1);
});
it('returns the member tasks for the challenges', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
await user.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: 'Test Text'}]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
let chalTasks = await user.get(`/tasks/challenge/${challenge._id}`);
expect(memberProgress.tasks.length).to.equal(chalTasks.length);
expect(memberProgress.tasks[0].challenge.id).to.equal(challenge._id);
expect(memberProgress.tasks[0].challenge.taskId).to.equal(chalTasks[0]._id);
});
it('returns the tasks without the tags', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let challenge = await generateChallenge(user, group);
let taskText = 'Test Text';
await user.post(`/tasks/challenge/${challenge._id}`, [{type: 'habit', text: taskText}]);
let memberProgress = await user.get(`/challenges/${challenge._id}/members/${user._id}`);
expect(memberProgress.tasks[0]).not.to.have.key('tags');
});
});
test/api/v3/integration/challenges/GET-challenges_group_groupid.test.js
+118
View File
@@ -0,0 +1,118 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET challenges/group/:groupId', () => {
context('Public Guild', () => {
let publicGuild, user, nonMember, challenge, challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
privacy: 'public',
},
});
publicGuild = group;
user = groupLeader;
nonMember = await generateUser();
challenge = await generateChallenge(user, group);
challenge2 = await generateChallenge(user, group);
});
it('should return group challenges for non member with populated leader', async () => {
let challenges = await nonMember.get(`/challenges/groups/${publicGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
});
it('should return group challenges for member with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${publicGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
});
});
context('Private Guild', () => {
let privateGuild, user, nonMember, challenge, challenge2;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
type: 'guild',
privacy: 'private',
},
});
privateGuild = group;
user = groupLeader;
nonMember = await generateUser();
challenge = await generateChallenge(user, group);
challenge2 = await generateChallenge(user, group);
});
it('should prevent non-member from seeing challenges', async () => {
await expect(nonMember.get(`/challenges/groups/${privateGuild._id}`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('should return group challenges for member with populated leader', async () => {
let challenges = await user.get(`/challenges/groups/${privateGuild._id}`);
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: privateGuild.leader._id,
id: privateGuild.leader._id,
profile: {name: user.profile.name},
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: privateGuild.leader._id,
id: privateGuild.leader._id,
profile: {name: user.profile.name},
});
});
});
});
test/api/v3/integration/challenges/GET-challenges_user.test.js
+132
View File
@@ -0,0 +1,132 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET challenges/user', () => {
let user, member, nonMember, challenge, challenge2, publicGuild;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'TestGuild',
type: 'guild',
privacy: 'public',
},
members: 1,
});
user = groupLeader;
publicGuild = group;
member = members[0];
nonMember = await generateUser();
challenge = await generateChallenge(user, group);
challenge2 = await generateChallenge(user, group);
});
it('should return challenges user has joined', async () => {
await nonMember.post(`/challenges/${challenge._id}/join`);
let challenges = await nonMember.get('/challenges/user');
let foundChallenge = _.find(challenges, { _id: challenge._id });
expect(foundChallenge).to.exist;
expect(foundChallenge.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
expect(foundChallenge.group).to.eql({
_id: publicGuild._id,
id: publicGuild._id,
type: publicGuild.type,
privacy: publicGuild.privacy,
name: publicGuild.name,
});
});
it('should return challenges user has created', async () => {
let challenges = await user.get('/challenges/user');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
expect(foundChallenge1.group).to.eql({
_id: publicGuild._id,
id: publicGuild._id,
type: publicGuild.type,
privacy: publicGuild.privacy,
name: publicGuild.name,
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
expect(foundChallenge2.group).to.eql({
_id: publicGuild._id,
id: publicGuild._id,
type: publicGuild.type,
privacy: publicGuild.privacy,
name: publicGuild.name,
});
});
it('should return challenges in user\'s group', async () => {
let challenges = await member.get('/challenges/user');
let foundChallenge1 = _.find(challenges, { _id: challenge._id });
expect(foundChallenge1).to.exist;
expect(foundChallenge1.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
expect(foundChallenge1.group).to.eql({
_id: publicGuild._id,
id: publicGuild._id,
type: publicGuild.type,
privacy: publicGuild.privacy,
name: publicGuild.name,
});
let foundChallenge2 = _.find(challenges, { _id: challenge2._id });
expect(foundChallenge2).to.exist;
expect(foundChallenge2.leader).to.eql({
_id: publicGuild.leader._id,
id: publicGuild.leader._id,
profile: {name: user.profile.name},
});
expect(foundChallenge2.group).to.eql({
_id: publicGuild._id,
id: publicGuild._id,
type: publicGuild.type,
privacy: publicGuild.privacy,
name: publicGuild.name,
});
});
it('should not return challenges user doesn\'t have access to', async () => {
let { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
type: 'guild',
privacy: 'private',
},
});
let privateChallenge = await generateChallenge(groupLeader, group);
let challenges = await nonMember.get('/challenges/user');
let foundChallenge = _.find(challenges, { _id: privateChallenge._id });
expect(foundChallenge).to.not.exist;
});
});
test/api/v3/integration/challenges/POST-challenges.test.js
+308
View File
@@ -0,0 +1,308 @@
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges', () => {
it('returns error when group is empty', async () => {
let user = await generateUser();
await expect(user.post('/challenges')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when groupId is not for a valid group', async () => {
let user = await generateUser();
await expect(user.post('/challenges', {
group: generateUUID(),
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns error when creating a challenge in the tavern with no prize', async () => {
let user = await generateUser();
await expect(user.post('/challenges', {
group: 'habitrpg',
prize: 0,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('tavChalsMinPrize'),
});
});
it('returns error when creating a challenge in a public guild and you are not a member of it', async () => {
let user = await generateUser();
let { group } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
},
});
await expect(user.post('/challenges', {
group: group._id,
prize: 4,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('mustBeGroupMember'),
});
});
context('Creating a challenge for a valid group', () => {
let groupLeader;
let group;
let groupMember;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
members: 1,
leaderDetails: {
balance: 3,
},
groupDetails: {
type: 'guild',
leaderOnly: {
challenges: true,
},
},
});
groupLeader = await populatedGroup.groupLeader.sync();
group = populatedGroup.group;
groupMember = populatedGroup.members[0];
});
it('returns an error when non-leader member creates a challenge in leaderOnly group', async () => {
await expect(groupMember.post('/challenges', {
group: group._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyGroupLeaderChal'),
});
});
it('returns an error when non-leader member creates a challenge in leaderOnly group', async () => {
await expect(groupMember.post('/challenges', {
group: group._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyGroupLeaderChal'),
});
});
it('allows non-leader member to create a challenge', async () => {
let populatedGroup = await createAndPopulateGroup({
members: 1,
});
group = populatedGroup.group;
groupMember = populatedGroup.members[0];
let chal = await groupMember.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
});
expect(chal.leader).to.eql({
_id: groupMember._id,
profile: {name: groupMember.profile.name},
});
});
it('doesn\'t take gems from user or group when challenge has no prize', async () => {
let oldUserBalance = groupLeader.balance;
let oldGroupBalance = group.balance;
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
prize: 0,
});
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance);
await expect(group.sync()).to.eventually.have.property('balance', oldGroupBalance);
});
it('returns error when user and group can\'t pay prize', async () => {
await expect(groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
prize: 20,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('cantAfford'),
});
});
it('takes prize out of group if it has sufficient funds', async () => {
let oldUserBalance = groupLeader.balance;
let oldGroupBalance = group.balance;
let prize = 4;
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
prize,
});
await expect(group.sync()).to.eventually.have.property('balance', oldGroupBalance - prize / 4);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance);
});
it('takes prize out of both group and user if group doesn\'t have enough', async () => {
let oldUserBalance = groupLeader.balance;
let prize = 8;
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
prize,
});
await expect(group.sync()).to.eventually.have.property('balance', 0);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance - (prize / 4 - 1));
});
it('takes prize out of user if group has no balance', async () => {
let oldUserBalance = groupLeader.balance;
let prize = 8;
await group.update({ balance: 0});
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
prize,
});
await expect(group.sync()).to.eventually.have.property('balance', 0);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldUserBalance - prize / 4);
});
it('increases challenge count of group', async () => {
let oldChallengeCount = group.challengeCount;
await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
});
await expect(group.sync()).to.eventually.have.property('challengeCount', oldChallengeCount + 1);
});
it('sets challenge as official if created by admin and official flag is set', async () => {
await groupLeader.update({
contributor: {
admin: true,
},
});
let challenge = await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
official: true,
});
expect(challenge.official).to.eql(true);
});
it('doesn\'t set challenge as official if official flag is set by non-admin', async () => {
let challenge = await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
official: true,
});
expect(challenge.official).to.eql(false);
});
it('returns an error when challenge validation fails; doesn\'s save user or group', async () => {
let oldChallengeCount = group.challengeCount;
let oldUserBalance = groupLeader.balance;
let oldUserChallenges = groupLeader.challenges;
let oldGroupBalance = group.balance;
await expect(groupLeader.post('/challenges', {
group: group._id,
prize: 8,
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Challenge validation failed',
});
group = await group.sync();
groupLeader = await groupLeader.sync();
expect(group.challengeCount).to.eql(oldChallengeCount);
expect(group.balance).to.eql(oldGroupBalance);
expect(groupLeader.balance).to.eql(oldUserBalance);
expect(groupLeader.challenges).to.eql(oldUserChallenges);
});
it('sets all properites of the challenge as passed', async () => {
let name = 'Test Challenge';
let shortName = 'TC Label';
let description = 'Test Description';
let prize = 4;
let challenge = await groupLeader.post('/challenges', {
group: group._id,
name,
shortName,
description,
prize,
});
expect(challenge.leader).to.eql({
_id: groupLeader._id,
profile: {name: groupLeader.profile.name},
});
expect(challenge.name).to.eql(name);
expect(challenge.shortName).to.eql(shortName);
expect(challenge.description).to.eql(description);
expect(challenge.official).to.eql(false);
expect(challenge.group).to.eql({
_id: group._id,
privacy: group.privacy,
name: group.name,
type: group.type,
});
expect(challenge.memberCount).to.eql(1);
expect(challenge.prize).to.eql(prize);
});
it('adds challenge to creator\'s challenges', async () => {
let challenge = await groupLeader.post('/challenges', {
group: group._id,
name: 'Test Challenge',
shortName: 'TC Label',
});
await expect(groupLeader.sync()).to.eventually.have.property('challenges').to.include(challenge._id);
});
});
});
test/api/v3/integration/challenges/POST-challenges_challengeId_join.test.js
+127
View File
@@ -0,0 +1,127 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/join', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser({ balance: 1});
await expect(user.post('/challenges/test/join')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser({ balance: 1});
await expect(user.post(`/challenges/${generateUUID()}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
context('Joining a valid challenge', () => {
let groupLeader;
let group;
let challenge;
let authorizedUser;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
authorizedUser = populatedGroup.members[0];
challenge = await generateChallenge(groupLeader, group);
});
it('returns an error when user doesn\'t have permissions to access the challenge', async () => {
let unauthorizedUser = await generateUser();
await expect(unauthorizedUser.post(`/challenges/${challenge._id}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('returns challenge data', async () => {
let res = await authorizedUser.post(`/challenges/${challenge._id}/join`);
expect(res.group).to.eql({
_id: group._id,
privacy: group.privacy,
name: group.name,
type: group.type,
});
expect(res.leader).to.eql({
_id: groupLeader._id,
id: groupLeader._id,
profile: {name: groupLeader.profile.name},
});
expect(res.name).to.equal(challenge.name);
});
it('adds challenge to user challenges', async () => {
await authorizedUser.post(`/challenges/${challenge._id}/join`);
await authorizedUser.sync();
expect(authorizedUser).to.have.property('challenges').to.include(challenge._id);
});
it('returns error when user has already joined the challenge', async () => {
await authorizedUser.post(`/challenges/${challenge._id}/join`);
await expect(authorizedUser.post(`/challenges/${challenge._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInChallenge'),
});
});
it('increases memberCount of challenge', async () => {
let oldMemberCount = challenge.memberCount;
await authorizedUser.post(`/challenges/${challenge._id}/join`);
await challenge.sync();
expect(challenge).to.have.property('memberCount', oldMemberCount + 1);
});
it('syncs challenge tasks to joining user', async () => {
let taskText = 'A challenge task text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
]);
await authorizedUser.post(`/challenges/${challenge._id}/join`);
let tasks = await authorizedUser.get('/tasks/user');
let tasksTexts = tasks.map((task) => {
return task.text;
});
expect(tasksTexts).to.include(taskText);
});
it('adds challenge tag to user tags', async () => {
let userTagsLength = (await authorizedUser.get('/tags')).length;
await authorizedUser.post(`/challenges/${challenge._id}/join`);
await expect(authorizedUser.get('/tags')).to.eventually.have.length(userTagsLength + 1);
});
});
});
test/api/v3/integration/challenges/POST-challenges_challengeId_leave.test.js
+123
View File
@@ -0,0 +1,123 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/leave', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
await expect(user.post('/challenges/test/leave')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/leave`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
context('Leaving a valid challenge', () => {
let groupLeader;
let group;
let challenge;
let notInChallengeUser;
let leavingUser;
let taskText;
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
members: 2,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
leavingUser = populatedGroup.members[0];
notInChallengeUser = populatedGroup.members[1];
challenge = await generateChallenge(groupLeader, group);
taskText = 'A challenge task text';
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
]);
await leavingUser.post(`/challenges/${challenge._id}/join`);
await challenge.sync();
});
it('returns an error when user doesn\'t have permissions to view the challenge', async () => {
let unauthorizedUser = await generateUser();
await expect(unauthorizedUser.post(`/challenges/${challenge._id}/leave`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('returns an error when user isn\'t a member of the challenge', async () => {
await expect(notInChallengeUser.post(`/challenges/${challenge._id}/leave`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('challengeMemberNotFound'),
});
});
it('removes challenge from user challenges', async () => {
await leavingUser.post(`/challenges/${challenge._id}/leave`);
await leavingUser.sync();
expect(leavingUser).to.have.property('challenges').to.not.include(challenge._id);
});
it('decreases memberCount of challenge', async () => {
let oldMemberCount = challenge.memberCount;
await leavingUser.post(`/challenges/${challenge._id}/leave`);
await challenge.sync();
expect(challenge).to.have.property('memberCount', oldMemberCount - 1);
});
it('unlinks challenge tasks from leaving user when remove-all is passed', async () => {
await leavingUser.post(`/challenges/${challenge._id}/leave`, {
keep: 'remove-all',
});
let tasks = await leavingUser.get('/tasks/user');
let tasksTexts = tasks.map((task) => {
return task.text;
});
expect(tasksTexts).to.not.include(taskText);
});
it('doesn\'t unlink challenge tasks from leaving user when remove-all isn\'t passed', async () => {
await leavingUser.post(`/challenges/${challenge._id}/leave`, {
keep: 'test',
});
let tasks = await leavingUser.get('/tasks/user');
let testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
expect(testTask).to.not.be.undefined;
expect(testTask.challenge).to.be.undefined;
});
});
});
test/api/v3/integration/challenges/POST-challenges_challengeId_winner_winnerId.test.js
+139
View File
@@ -0,0 +1,139 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
sleep,
checkExistence,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /challenges/:challengeId/winner/:winnerId', () => {
it('returns error when challengeId is not a valid UUID', async () => {
let user = await generateUser();
await expect(user.post(`/challenges/test/selectWinner/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when winnerId is not a valid UUID', async () => {
let user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/selectWinner/test`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns error when challengeId is not for a valid challenge', async () => {
let user = await generateUser();
await expect(user.post(`/challenges/${generateUUID()}/selectWinner/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
context('Selecting winner for a valid challenge', () => {
let groupLeader;
let group;
let challenge;
let winningUser;
let taskText = 'A challenge task text';
beforeEach(async () => {
let populatedGroup = await createAndPopulateGroup({
members: 1,
});
groupLeader = populatedGroup.groupLeader;
group = populatedGroup.group;
winningUser = populatedGroup.members[0];
challenge = await generateChallenge(groupLeader, group, {
prize: 1,
});
await groupLeader.post(`/tasks/challenge/${challenge._id}`, [
{type: 'habit', text: taskText},
]);
await winningUser.post(`/challenges/${challenge._id}/join`);
await challenge.sync();
});
it('returns an error when user doesn\'t have permissions to select winner', async () => {
await expect(winningUser.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyLeaderDeleteChal'),
});
});
it('returns an error when winning user isn\'t part of the challenge', async () => {
let notInChallengeUser = await generateUser();
await expect(groupLeader.post(`/challenges/${challenge._id}/selectWinner/${notInChallengeUser._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('winnerNotFound', {userId: notInChallengeUser._id}),
});
});
it('deletes challenge after winner is selected', async () => {
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
await sleep(0.5);
await expect(checkExistence('challenges', challenge._id)).to.eventually.equal(false);
});
it('adds challenge to winner\'s achievements', async () => {
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
await sleep(0.5);
await expect(winningUser.sync()).to.eventually.have.deep.property('achievements.challenges').to.include(challenge.name);
});
it('gives winner gems as reward', async () => {
let oldBalance = winningUser.balance;
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
await sleep(0.5);
await expect(winningUser.sync()).to.eventually.have.property('balance', oldBalance + challenge.prize / 4);
});
it('doesn\'t refund gems to group leader', async () => {
let oldBalance = (await groupLeader.sync()).balance;
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
await sleep(0.5);
await expect(groupLeader.sync()).to.eventually.have.property('balance', oldBalance);
});
it('sets broken and winner flags for user\'s challenge tasks', async () => {
await groupLeader.post(`/challenges/${challenge._id}/selectWinner/${winningUser._id}`);
await sleep(0.5);
let tasks = await winningUser.get('/tasks/user');
let testTask = _.find(tasks, (task) => {
return task.text === taskText;
});
expect(testTask.challenge.broken).to.eql('CHALLENGE_CLOSED');
expect(testTask.challenge.winner).to.eql(winningUser.profile.name);
});
});
});
test/api/v3/integration/challenges/PUT-challenges_challengeId.test.js
+85
View File
@@ -0,0 +1,85 @@
import {
generateUser,
generateChallenge,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('PUT /challenges/:challengeId', () => {
let privateGuild, user, nonMember, challenge, member;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'TestPrivateGuild',
type: 'guild',
privacy: 'private',
},
members: 1,
});
privateGuild = group;
user = groupLeader;
nonMember = await generateUser();
member = members[0];
challenge = await generateChallenge(user, group);
await member.post(`/challenges/${challenge._id}/join`);
});
it('fails if the user can\'t view the challenge', async () => {
await expect(nonMember.put(`/challenges/${challenge._id}`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('should only allow the leader or an admin to update the challenge', async () => {
await expect(member.put(`/challenges/${challenge._id}`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyLeaderUpdateChal'),
});
});
it('only updates allowed fields', async () => {
let res = await user.put(`/challenges/${challenge._id}`, {
// ignored
prize: 33,
group: 'blabla',
memberCount: 33,
tasksOrder: 'new order',
official: true,
shortName: 'new short name',
// applied
name: 'New Challenge Name',
description: 'New challenge description.',
leader: member._id,
});
expect(res.prize).to.equal(0);
expect(res.group).to.eql({
_id: privateGuild._id,
privacy: privateGuild.privacy,
name: privateGuild.name,
type: privateGuild.type,
});
expect(res.memberCount).to.equal(2);
expect(res.tasksOrder).not.to.equal('new order');
expect(res.official).to.equal(false);
expect(res.shortName).not.to.equal('new short name');
expect(res.leader).to.eql({
_id: member._id,
id: member._id,
profile: {name: member.profile.name},
});
expect(res.name).to.equal('New Challenge Name');
expect(res.description).to.equal('New challenge description.');
});
});
test/api/v3/integration/chat/DELETE-chat_id.test.js
+81
View File
@@ -0,0 +1,81 @@
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /groups/:groupId/chat/:chatId', () => {
let groupWithChat, message, user, userThatDidNotCreateChat, admin;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
},
});
groupWithChat = group;
user = groupLeader;
message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
userThatDidNotCreateChat = await generateUser();
admin = await generateUser({'contributor.admin': true});
});
context('Chat errors', () => {
it('returns an error is message does not exist', async () => {
let fakeChatId = generateUUID();
await expect(user.del(`/groups/${groupWithChat._id}/chat/${fakeChatId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatNotFound'),
});
});
it('returns an error when user does not have permission to delete', async () => {
await expect(userThatDidNotCreateChat.del(`/groups/${groupWithChat._id}/chat/${message.id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyCreatorOrAdminCanDeleteChat'),
});
});
});
context('Chat success', () => {
let nextMessage;
beforeEach(async () => {
nextMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some new message' });
nextMessage = nextMessage.message;
});
it('allows creator to delete a their message', async () => {
await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
let messages = await user.get(`/groups/${groupWithChat._id}/chat/`);
expect(messages).is.an('array');
expect(messages).to.not.include(nextMessage);
});
it('allows admin to delete another user\'s message', async () => {
await admin.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
let messages = await user.get(`/groups/${groupWithChat._id}/chat/`);
expect(messages).is.an('array');
expect(messages).to.not.include(nextMessage);
});
it('returns empty when previous message parameter is passed and the last message was deleted', async () => {
await expect(user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}?previousMsg=${nextMessage.id}`))
.to.eventually.be.empty;
});
it('returns the update chat when previous message parameter is passed and the chat is updated', async () => {
await expect(user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}?previousMsg=${message.id}`))
.eventually
.is.an('array')
.to.include(message)
.to.be.lengthOf(1);
});
});
});
test/api/v3/integration/chat/GET-chat.test.js
+65
View File
@@ -0,0 +1,65 @@
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET /groups/:groupId/chat', () => {
let user;
before(async () => {
user = await generateUser();
});
context('public Guild', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
group = await generateGroup(leader, {
name: 'test group',
type: 'guild',
privacy: 'public',
}, {
chat: [
{text: 'Hello', flags: {}},
{text: 'Welcome to the Guild', flags: {}},
],
});
});
it('returns Guild chat', async () => {
let chat = await user.get(`/groups/${group._id}/chat`);
expect(chat).to.eql(group.chat);
});
});
context('private Guild', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
group = await generateGroup(leader, {
name: 'test group',
type: 'guild',
privacy: 'private',
}, {
chat: [
'Hello',
'Welcome to the Guild',
],
});
});
it('returns error if user is not member of requested private group', async () => {
await expect(user.get(`/groups/${group._id}/chat`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
});
});
test/api/v3/integration/chat/POST-chat.flag.test.js
+84
View File
@@ -0,0 +1,84 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { find } from 'lodash';
describe('POST /chat/:chatId/flag', () => {
let user, admin, anotherUser, group;
const TEST_MESSAGE = 'Test Message';
before(async () => {
user = await generateUser({balance: 1});
admin = await generateUser({balance: 1, 'contributor.admin': true});
anotherUser = await generateUser();
group = await user.post('/groups', {
name: 'Test Guild',
type: 'guild',
privacy: 'public',
});
});
it('Returns an error when chat message is not found', async () => {
await expect(user.post(`/groups/${group._id}/chat/incorrectMessage/flag`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatNotFound'),
});
});
it('Returns an error when user tries to flag their own message', async () => {
let message = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await expect(user.post(`/groups/${group._id}/chat/${message.message.id}/flag`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatFlagOwnMessage'),
});
});
it('Flags a chat', async () => {
let message = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE});
message = message.message;
let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[user._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(1);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
expect(messageToCheck.flags[user._id]).to.equal(true);
});
it('Flags a chat with a higher flag acount when an admin flags the message', async () => {
let message = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE});
message = message.message;
let flagResult = await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[admin._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(5);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
expect(messageToCheck.flags[admin._id]).to.equal(true);
expect(messageToCheck.flagCount).to.equal(5);
});
it('Returns an error when user tries to flag a message that is already flagged', async () => {
let message = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE});
message = message.message;
await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
await expect(user.post(`/groups/${group._id}/chat/${message.id}/flag`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatFlagAlreadyReported'),
});
});
});
test/api/v3/integration/chat/POST-chat.like.test.js
+75
View File
@@ -0,0 +1,75 @@
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { find } from 'lodash';
describe('POST /chat/:chatId/like', () => {
let user;
let groupWithChat;
let testMessage = 'Test Message';
let anotherUser;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'public',
},
members: 1,
});
user = groupLeader;
groupWithChat = group;
anotherUser = members[0];
});
it('Returns an error when chat message is not found', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat/incorrectMessage/like`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatNotFound'),
});
});
it('Returns an error when user tries to like their own message', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
await expect(user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatLikeOwnMessage'),
});
});
it('Likes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithChatLikes.chat, {id: message.message.id});
expect(messageToCheck.likes[user._id]).to.equal(true);
});
it('Unlikes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let unlikeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(unlikeResult.likes[user._id]).to.equal(false);
let groupWithoutChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithoutChatLikes.chat, {id: message.message.id});
expect(messageToCheck.likes[user._id]).to.equal(false);
});
});
test/api/v3/integration/chat/POST-chat.test.js
+81
View File
@@ -0,0 +1,81 @@
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /chat', () => {
let user, groupWithChat, userWithChatRevoked, member;
let testMessage = 'Test Message';
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'public',
},
members: 2,
});
user = groupLeader;
groupWithChat = group;
userWithChatRevoked = await members[0].update({'flags.chatRevoked': true});
member = members[0];
});
it('Returns an error when no message is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ''}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('Returns an error when group is not found', async () => {
await expect(user.post('/groups/invalidID/chat', { message: testMessage})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('Returns an error when chat privileges are revoked', async () => {
await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: 'Your chat privileges have been revoked.',
});
});
it('creates a chat', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
expect(message.message.id).to.exist;
});
it('notifies other users of new messages for a guild', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
let memberWithNotification = await member.get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.exist;
});
it('notifies other users of new messages for a party', async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
privacy: 'private',
},
members: 1,
});
let message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage});
let memberWithNotification = await members[0].get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${group._id}`]).to.exist;
});
});
test/api/v3/integration/chat/POST-chat_seen.test.js
+63
View File
@@ -0,0 +1,63 @@
import {
createAndPopulateGroup,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /groups/:id/chat/seen', () => {
context('Guild', () => {
let guild, guildLeader, guildMember, guildMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
},
members: 1,
});
guild = group;
guildLeader = groupLeader;
guildMember = members[0];
guildMessage = await guildLeader.post(`/groups/${guild._id}/chat`, { message: 'Some guild message' });
guildMessage = guildMessage.message;
});
it('clears new messages for a guild', async () => {
await guildMember.post(`/groups/${guild._id}/chat/seen`);
let guildThatHasSeenChat = await guildMember.get('/user');
expect(guildThatHasSeenChat.newMessages).to.be.empty;
});
});
context('Party', () => {
let party, partyLeader, partyMember, partyMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
},
members: 1,
});
party = group;
partyLeader = groupLeader;
partyMember = members[0];
partyMessage = await partyLeader.post(`/groups/${party._id}/chat`, { message: 'Some party message' });
partyMessage = partyMessage.message;
});
it('clears new messages for a party', async () => {
await partyMember.post(`/groups/${party._id}/chat/seen`);
let partyMemberThatHasSeenChat = await partyMember.get('/user');
expect(partyMemberThatHasSeenChat.newMessages).to.be.empty;
});
});
});
test/api/v3/integration/chat/POST-groups_id_chat_id_clear_flags.test.js
+101
View File
@@ -0,0 +1,101 @@
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:id/chat/:id/clearflags', () => {
let groupWithChat, message, author, nonAdmin, admin;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
},
members: 1,
});
groupWithChat = group;
author = groupLeader;
nonAdmin = members[0];
admin = await generateUser({'contributor.admin': true});
message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/flag`);
});
context('Single Message', () => {
it('returns error when non-admin attempts to clear flags', async () => {
return expect(nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupChatAdminClearFlagCount'),
});
});
it('returns error if message does not exist', async () => {
let fakeMessageID = generateUUID();
await expect(admin.post(`/groups/${groupWithChat._id}/chat/${fakeMessageID}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('messageGroupChatNotFound'),
});
});
it('clears flags and leaves old flags on the flag object', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages[0].flagCount).to.eql(0);
expect(messages[0].flags).to.have.property(admin._id, true);
});
});
context('admin user, group with multiple messages', () => {
let message2, message3, message4;
before(async () => {
message2 = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message 2' });
message2 = message2.message;
await admin.post(`/groups/${groupWithChat._id}/chat/${message2.id}/flag`);
message3 = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message 3' });
message3 = message3.message;
await admin.post(`/groups/${groupWithChat._id}/chat/${message3.id}/flag`);
await nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message3.id}/flag`);
message4 = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message 4' });
message4 = message4.message;
});
it('changes only the message that is flagged', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages).to.have.lengthOf(4);
let messageThatWasUnflagged = messages[3];
let messageWith1Flag = messages[2];
let messageWith2Flag = messages[1];
let messageWithoutFlags = messages[0];
expect(messageThatWasUnflagged.flagCount).to.eql(0);
expect(messageThatWasUnflagged.flags).to.have.property(admin._id, true);
expect(messageWith1Flag.flagCount).to.eql(5);
expect(messageWith1Flag.flags).to.have.property(admin._id, true);
expect(messageWith2Flag.flagCount).to.eql(6);
expect(messageWith2Flag.flags).to.have.property(admin._id, true);
expect(messageWith2Flag.flags).to.have.property(nonAdmin._id, true);
expect(messageWithoutFlags.flagCount).to.eql(0);
expect(messageWithoutFlags.flags).to.eql({});
});
});
});
test/api/v3/integration/content/GET-content.test.js
+25
View File
@@ -0,0 +1,25 @@
import {
requester,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import i18n from '../../../../../common/script/i18n';
describe('GET /content', () => {
it('returns content (and does not require authentication)', async () => {
let res = await requester().get('/content');
expect(res).to.have.deep.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(t('backgroundBeachText'));
});
it('returns content not in English', async () => {
let res = await requester().get('/content?language=de');
expect(res).to.have.deep.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(i18n.t('backgroundBeachText', 'de'));
});
it('falls back to English if the desired language is not found', async () => {
let res = await requester().get('/content?language=wrong');
expect(res).to.have.deep.property('backgrounds.backgrounds062014.beach');
expect(res.backgrounds.backgrounds062014.beach.text).to.equal(t('backgroundBeachText'));
});
});
test/api/v3/integration/coupons/GET-coupons.test.js
+39
View File
@@ -0,0 +1,39 @@
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET /coupons/', () => {
let user;
before(async () => {
await resetHabiticaDB();
});
beforeEach(async () => {
user = await generateUser();
});
it('returns an error if user has no sudo permission', async () => {
await user.get('/user'); // needed so the request after this will authenticate with the correct cookie session
await expect(user.get('/coupons')).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('noSudoAccess'),
});
});
it('should return the coupons in CSV format ordered by creation date', async () => {
await user.update({
'contributor.sudo': true,
});
let coupons = await user.post('/coupons/generate/wondercon?count=11');
let res = await user.get('/coupons');
let splitRes = res.split('\n');
expect(splitRes.length).to.equal(13);
expect(splitRes[0]).to.equal('code,event,date,user');
expect(splitRes[6].split(',')[1]).to.equal(coupons[5].event);
});
});
test/api/v3/integration/coupons/POST-coupons_enter_code.test.js
+62
View File
@@ -0,0 +1,62 @@
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /coupons/enter/:code', () => {
let user;
let sudoUser;
before(async () => {
await resetHabiticaDB();
});
beforeEach(async () => {
user = await generateUser();
sudoUser = await generateUser({
'contributor.sudo': true,
});
});
it('returns an error if code is missing', async () => {
await expect(user.post('/coupons/enter')).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
it('returns an error if code is invalid', async () => {
await expect(user.post('/coupons/enter/notValid')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidCoupon'),
});
});
it('returns an error if coupon has been used', async () => {
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
await user.post(`/coupons/enter/${coupon._id}`); // use coupon
await expect(user.post(`/coupons/enter/${coupon._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('couponUsed'),
});
});
it('should apply the coupon to the user', async () => {
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
let userRes = await user.post(`/coupons/enter/${coupon._id}`);
expect(userRes._id).to.equal(user._id);
expect(userRes.items.gear.owned.eyewear_special_wondercon_red).to.be.true;
expect(userRes.items.gear.owned.eyewear_special_wondercon_black).to.be.true;
expect(userRes.items.gear.owned.back_special_wondercon_black).to.be.true;
expect(userRes.items.gear.owned.back_special_wondercon_red).to.be.true;
expect(userRes.items.gear.owned.body_special_wondercon_red).to.be.true;
expect(userRes.items.gear.owned.body_special_wondercon_black).to.be.true;
expect(userRes.items.gear.owned.body_special_wondercon_gold).to.be.true;
expect(userRes.extra).to.eql({signupEvent: 'wondercon'});
});
});
test/api/v3/integration/coupons/POST-coupons_generate_event.test.js
+66
View File
@@ -0,0 +1,66 @@
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-v3-integration.helper';
import couponCode from 'coupon-code';
describe('POST /coupons/generate/:event', () => {
let user;
before(async () => {
await resetHabiticaDB();
});
beforeEach(async () => {
user = await generateUser({
'contributor.sudo': true,
});
});
it('returns an error if user has no sudo permission', async () => {
await user.update({
'contributor.sudo': false,
});
await expect(user.post('/coupons/generate/aaa')).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('noSudoAccess'),
});
});
it('returns an error if event is missing', async () => {
await expect(user.post('/coupons/generate')).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
it('returns an error if event is invalid', async () => {
await expect(user.post('/coupons/generate/notValid?count=1')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Coupon validation failed',
});
});
it('returns an error if count is missing', async () => {
await expect(user.post('/coupons/generate/notValid')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('should generate coupons', async () => {
await user.update({
'contributor.sudo': true,
});
let coupons = await user.post('/coupons/generate/wondercon?count=2');
expect(coupons.length).to.equal(2);
expect(coupons[0].event).to.equal('wondercon');
expect(couponCode.validate(coupons[1]._id)).to.not.equal(''); // '' means invalid
});
});
test/api/v3/integration/coupons/POST-coupons_validate_code.test.js
+36
View File
@@ -0,0 +1,36 @@
import {
generateUser,
requester,
resetHabiticaDB,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /coupons/validate/:code', () => {
let api = requester();
before(async () => {
await resetHabiticaDB();
});
it('returns an error if code is missing', async () => {
await expect(api.post('/coupons/validate')).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
it('returns true if coupon code is valid', async () => {
let sudoUser = await generateUser({
'contributor.sudo': true,
});
let [coupon] = await sudoUser.post('/coupons/generate/wondercon?count=1');
let res = await api.post(`/coupons/validate/${coupon._id}`);
expect(res).to.eql({valid: true});
});
it('returns false if coupon code is valid', async () => {
let res = await api.post('/coupons/validate/notValid');
expect(res).to.eql({valid: false});
});
});
test/api/v3/integration/dataexport/GET-export_avatar-memberId.html.test.js
+35
View File
@@ -0,0 +1,35 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /export/avatar-:memberId.html', () => {
let user;
before(async () => {
user = await generateUser();
});
it('validates req.params.memberId', async () => {
await expect(user.get('/export/avatar-:memberId.html')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
await expect(user.get(`/export/avatar-${dummyId}.html`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
});
});
it('returns an html page', async () => {
let res = await user.get(`/export/avatar-${user._id}.html`);
expect(res.substring(0, 100).indexOf('<!DOCTYPE html>')).to.equal(0);
});
});
test/api/v3/integration/dataexport/GET-export_avatar-memberId.png.test.js
+3
View File
@@ -0,0 +1,3 @@
// TODO how to test this route since it points to a file on AWS s3?
describe('GET /export/avatar-:memberId.png', () => {});
test/api/v3/integration/dataexport/GET-export_history.csv.test.js
+47
View File
@@ -0,0 +1,47 @@
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import {
updateDocument,
} from '../../../../helpers/mongo';
import moment from 'moment';
describe('GET /export/history.csv', () => {
it('should return a valid CSV file with tasks history data', async () => {
let user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'daily', text: 'daily 1'},
{type: 'habit', text: 'habit 2'},
{type: 'todo', text: 'todo 1'},
]);
// score all the tasks twice
await Promise.all(tasks.map(task => {
return user.post(`/tasks/${task._id}/score/up`);
}));
await Promise.all(tasks.map(task => {
return user.post(`/tasks/${task._id}/score/up`);
}));
// adding an history entry to daily 1 manually because cron didn't run yet
await updateDocument('tasks', tasks[1], {
history: {value: 3.2, date: Number(new Date())},
});
// get updated tasks
tasks = await Promise.all(tasks.map(task => {
return user.get(`/tasks/${task._id}`);
}));
let res = await user.get('/export/history.csv');
let splitRes = res.split('\n');
expect(splitRes[0]).to.equal('Task Name,Task ID,Task Type,Date,Value');
expect(splitRes[1]).to.equal(`habit 1,${tasks[0]._id},habit,${moment(tasks[0].history[0].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[0].history[0].value}`);
expect(splitRes[2]).to.equal(`habit 1,${tasks[0]._id},habit,${moment(tasks[0].history[1].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[0].history[1].value}`);
expect(splitRes[3]).to.equal(`daily 1,${tasks[1]._id},daily,${moment(tasks[1].history[0].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[1].history[0].value}`);
expect(splitRes[4]).to.equal(`habit 2,${tasks[2]._id},habit,${moment(tasks[2].history[0].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[2].history[0].value}`);
expect(splitRes[5]).to.equal(`habit 2,${tasks[2]._id},habit,${moment(tasks[2].history[1].date).format('YYYY-MM-DD HH:mm:ss')},${tasks[2].history[1].value}`);
expect(splitRes[6]).to.equal('');
});
});
test/api/v3/integration/dataexport/GET-export_userdata.json.test.js
+29
View File
@@ -0,0 +1,29 @@
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET /export/userdata.json', () => {
it('should return a valid JSON file with user data', async () => {
let user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'daily', text: 'daily 1'},
{type: 'reward', text: 'reward 1'},
{type: 'todo', text: 'todo 1'},
]);
let res = await user.get('/export/userdata.json');
expect(res._id).to.equal(user._id);
expect(res).to.contain.all.keys(['tasks', 'flags', 'tasksOrder', 'auth']);
expect(res.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(res.tasks).to.have.all.keys(['dailys', 'habits', 'todos', 'rewards']);
expect(res.tasks.habits.length).to.equal(1);
expect(res.tasks.habits[0]._id).to.equal(tasks[0]._id);
expect(res.tasks.dailys.length).to.equal(1);
expect(res.tasks.dailys[0]._id).to.equal(tasks[1]._id);
expect(res.tasks.rewards.length).to.equal(1);
expect(res.tasks.rewards[0]._id).to.equal(tasks[2]._id);
expect(res.tasks.todos.length).to.equal(2);
expect(res.tasks.todos[1]._id).to.equal(tasks[3]._id);
});
});
test/api/v3/integration/dataexport/GET-export_userdata.xml.test.js
+42
View File
@@ -0,0 +1,42 @@
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import xml2js from 'xml2js';
import Bluebird from 'bluebird';
let parseStringAsync = Bluebird.promisify(xml2js.parseString, {context: xml2js});
describe('GET /export/userdata.xml', () => {
it('should return a valid XML file with user data', async () => {
let user = await generateUser();
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'daily', text: 'daily 1'},
{type: 'reward', text: 'reward 1'},
{type: 'todo', text: 'todo 1'},
// due to how the xml parser works an array is returned only if there's more than one children
// so we create two tasks for each type
{type: 'habit', text: 'habit 2'},
{type: 'daily', text: 'daily 2'},
{type: 'reward', text: 'reward 2'},
{type: 'todo', text: 'todo 2'},
]);
let response = await user.get('/export/userdata.xml');
let {user: res} = await parseStringAsync(response, {explicitArray: false});
expect(res._id).to.equal(user._id);
expect(res).to.contain.all.keys(['tasks', 'flags', 'tasksOrder', 'auth']);
expect(res.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(res.tasks).to.have.all.keys(['dailys', 'habits', 'todos', 'rewards']);
expect(res.tasks.habits.length).to.equal(2);
expect(res.tasks.habits[0]._id).to.equal(tasks[0]._id);
expect(res.tasks.dailys.length).to.equal(2);
expect(res.tasks.dailys[0]._id).to.equal(tasks[1]._id);
expect(res.tasks.rewards.length).to.equal(2);
expect(res.tasks.rewards[0]._id).to.equal(tasks[2]._id);
expect(res.tasks.todos.length).to.equal(3);
expect(res.tasks.todos[1]._id).to.equal(tasks[3]._id);
});
});
test/api/v3/integration/debug/POST-debug_addHourglass.test.js
+35
View File
@@ -0,0 +1,35 @@
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /debug/add-hourglass', () => {
let userToGetHourGlass;
before(async () => {
userToGetHourGlass = await generateUser();
});
after(() => {
nconf.set('IS_PROD', false);
});
it('adds Hourglass to the current user', async () => {
await userToGetHourGlass.post('/debug/add-hourglass');
let userWithHourGlass = await userToGetHourGlass.get('/user');
expect(userWithHourGlass.purchased.plan.consecutive.trinkets).to.equal(1);
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(userToGetHourGlass.post('/debug/add-hourglass'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/debug/POST-debug_addTenGems.test.js
+35
View File
@@ -0,0 +1,35 @@
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /debug/add-ten-gems', () => {
let userToGainTenGems;
before(async () => {
userToGainTenGems = await generateUser();
});
after(() => {
nconf.set('IS_PROD', false);
});
it('adds ten gems to the current user', async () => {
await userToGainTenGems.post('/debug/add-ten-gems');
let userWithTenGems = await userToGainTenGems.get('/user');
expect(userWithTenGems.balance).to.equal(2.5);
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(userToGainTenGems.post('/debug/add-ten-gems'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/debug/POST-debug_make-admin.test.js
+35
View File
@@ -0,0 +1,35 @@
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
xdescribe('POST /debug/make-admin (pended for v3 prod testing)', () => {
let user;
before(async () => {
user = await generateUser();
});
afterEach(() => {
nconf.set('IS_PROD', false);
});
it('makes user an admine', async () => {
await user.post('/debug/make-admin');
await user.sync();
expect(user.contributor.admin).to.eql(true);
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(user.post('/debug/make-admin'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/debug/POST-debug_modify-inventory.test.js
+160
View File
@@ -0,0 +1,160 @@
/* eslint-disable camelcase */
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /debug/modify-inventory', () => {
let user, originalItems;
before(async () => {
originalItems = {
gear: { owned: { armor_base_0: true } },
special: {
snowball: 1,
},
pets: {
'Wolf-Desert': 5,
},
mounts: {
'Wolf-Desert': true,
},
eggs: {
Wolf: 5,
},
hatchingPotions: {
Desert: 5,
},
food: {
Watermelon: 5,
},
quests: {
gryphon: 5,
},
};
user = await generateUser({
items: originalItems,
});
});
afterEach(() => {
nconf.set('IS_PROD', false);
});
it('sets equipment', async () => {
let gear = {
weapon_healer_2: true,
weapon_wizard_1: true,
weapon_special_critical: true,
};
await user.post('/debug/modify-inventory', {
gear,
});
await user.sync();
expect(user.items.gear.owned).to.eql(gear);
});
it('sets special spells', async () => {
let special = {
shinySeed: 3,
};
await user.post('/debug/modify-inventory', {
special,
});
await user.sync();
expect(user.items.special).to.eql(special);
});
it('sets mounts', async () => {
let mounts = {
'Orca-Base': true,
'Mammoth-Base': true,
};
await user.post('/debug/modify-inventory', {
mounts,
});
await user.sync();
expect(user.items.mounts).to.eql(mounts);
});
it('sets eggs', async () => {
let eggs = {
Gryphon: 3,
Hedgehog: 7,
};
await user.post('/debug/modify-inventory', {
eggs,
});
await user.sync();
expect(user.items.eggs).to.eql(eggs);
});
it('sets hatching potions', async () => {
let hatchingPotions = {
White: 7,
Spooky: 2,
};
await user.post('/debug/modify-inventory', {
hatchingPotions,
});
await user.sync();
expect(user.items.hatchingPotions).to.eql(hatchingPotions);
});
it('sets food', async () => {
let food = {
Meat: 5,
Candy_Red: 7,
};
await user.post('/debug/modify-inventory', {
food,
});
await user.sync();
expect(user.items.food).to.eql(food);
});
it('sets quests', async () => {
let quests = {
whale: 5,
cheetah: 10,
};
await user.post('/debug/modify-inventory', {
quests,
});
await user.sync();
expect(user.items.quests).to.eql(quests);
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(user.post('/debug/modify-inventory'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/debug/POST-debug_quest-progress.test.js
+63
View File
@@ -0,0 +1,63 @@
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /debug/quest-progress', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
afterEach(() => {
nconf.set('IS_PROD', false);
});
it('errors if user is not on a quest', async () => {
await expect(user.post('/debug/quest-progress'))
.to.eventually.be.rejected.and.to.deep.equal({
code: 400,
error: 'BadRequest',
message: 'User is not on a valid quest.',
});
});
it('increases boss quest progress by 1000', async () => {
await user.update({
'party.quest.key': 'whale',
});
await user.post('/debug/quest-progress');
await user.sync();
expect(user.party.quest.progress.up).to.eql(1000);
});
it('increases collection quest progress by 300 items', async () => {
await user.update({
'party.quest.key': 'evilsanta2',
});
await user.post('/debug/quest-progress');
await user.sync();
expect(user.party.quest.progress.collect).to.eql({
tracks: 300,
branches: 300,
});
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(user.post('/debug/quest-progress'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/debug/POST-debug_set-cron.test.js
+39
View File
@@ -0,0 +1,39 @@
import nconf from 'nconf';
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /debug/set-cron', () => {
let user;
before(async () => {
user = await generateUser();
});
afterEach(() => {
nconf.set('IS_PROD', false);
});
it('sets last cron', async () => {
let newCron = new Date(2015, 11, 20);
await user.post('/debug/set-cron', {
lastCron: newCron,
});
await user.sync();
expect(user.lastCron).to.eql(newCron);
});
it('returns error when not in production mode', async () => {
nconf.set('IS_PROD', true);
await expect(user.post('/debug/set-cron'))
.eventually.be.rejected.and.to.deep.equal({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/emails/GET-email-unsubscribe.test.js
+68
View File
@@ -0,0 +1,68 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { encrypt } from '../../../../../website/server/libs/api-v3/encryption';
import { v4 as generateUUID } from 'uuid';
describe('GET /email/unsubscribe', () => {
let user;
let testEmail = 'test@habitica.com';
beforeEach(async () => {
user = await generateUser();
});
it('return error when code is not provided', async () => {
await expect(user.get('/email/unsubscribe')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('return error when user is not found', async () => {
let code = encrypt(JSON.stringify({
_id: generateUUID(),
}));
await expect(user.get(`/email/unsubscribe?code=${code}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userNotFound'),
});
});
it('unsubscribes a user from email notifications', async () => {
let code = encrypt(JSON.stringify({
_id: user._id,
email: user.email,
}));
await user.get(`/email/unsubscribe?code=${code}`);
let unsubscribedUser = await user.get('/user');
expect(unsubscribedUser.preferences.emailNotifications.unsubscribeFromAll).to.be.true;
});
it('unsubscribes an email from notifications', async () => {
let code = encrypt(JSON.stringify({
email: testEmail,
}));
let unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
expect(unsubscribedMessage).to.equal('<h1>Unsubscribed successfully!</h1> You won\'t receive any other email from Habitica.');
});
it('returns okay when email is already unsubscribed', async () => {
let code = encrypt(JSON.stringify({
email: testEmail,
}));
let unsubscribedMessage = await user.get(`/email/unsubscribe?code=${code}`);
expect(unsubscribedMessage).to.equal('<h1>Unsubscribed successfully!</h1> You won\'t receive any other email from Habitica.');
});
});
test/api/v3/integration/groups/GET-groups.test.js
+115
View File
@@ -0,0 +1,115 @@
import {
generateUser,
resetHabiticaDB,
generateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import {
TAVERN_ID,
} from '../../../../../website/server/models/group';
describe('GET /groups', () => {
let user;
const NUMBER_OF_PUBLIC_GUILDS = 3; // 2 + the tavern
const NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER = 1;
const NUMBER_OF_USERS_PRIVATE_GUILDS = 1;
const NUMBER_OF_GROUPS_USER_CAN_VIEW = 5;
before(async () => {
await resetHabiticaDB();
let leader = await generateUser({ balance: 10 });
user = await generateUser({balance: 4});
let publicGuildUserIsMemberOf = await generateGroup(leader, {
name: 'public guild - is member',
type: 'guild',
privacy: 'public',
});
await leader.post(`/groups/${publicGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
await user.post(`/groups/${publicGuildUserIsMemberOf._id}/join`);
await generateGroup(leader, {
name: 'public guild - is not member',
type: 'guild',
privacy: 'public',
});
let privateGuildUserIsMemberOf = await generateGroup(leader, {
name: 'private guild - is member',
type: 'guild',
privacy: 'private',
});
await leader.post(`/groups/${privateGuildUserIsMemberOf._id}/invite`, { uuids: [user._id]});
await user.post(`/groups/${privateGuildUserIsMemberOf._id}/join`);
await generateGroup(leader, {
name: 'private guild - is not member',
type: 'guild',
privacy: 'private',
});
await generateGroup(leader, {
name: 'party - is not member',
type: 'party',
privacy: 'private',
});
await user.post('/groups', {
name: 'party - is member',
type: 'party',
privacy: 'private',
});
});
it('returns error when no query passed in', async () => {
await expect(user.get('/groups'))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when an invalid ?type query is passed', async () => {
await expect(user.get('/groups?type=invalid'))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('groupTypesRequired'),
});
});
it('returns only the tavern when tavern passed in as query', async () => {
await expect(user.get('/groups?type=tavern'))
.to.eventually.have.a.lengthOf(1)
.and.to.have.deep.property('[0]')
.and.to.have.property('_id', TAVERN_ID);
});
it('returns only the user\'s party when party passed in as query', async () => {
await expect(user.get('/groups?type=party'))
.to.eventually.have.a.lengthOf(1)
.and.to.have.deep.property('[0]');
});
it('returns all public guilds when publicGuilds passed in as query', async () => {
await expect(user.get('/groups?type=publicGuilds'))
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
});
it('returns all the user\'s guilds when guilds passed in as query', async () => {
await expect(user.get('/groups?type=guilds'))
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS_USER_IS_MEMBER + NUMBER_OF_USERS_PRIVATE_GUILDS);
});
it('returns all private guilds user is a part of when privateGuilds passed in as query', async () => {
await expect(user.get('/groups?type=privateGuilds'))
.to.eventually.have.a.lengthOf(NUMBER_OF_USERS_PRIVATE_GUILDS);
});
it('returns a list of groups user has access to', async () => {
await expect(user.get('/groups?type=privateGuilds,publicGuilds,party,tavern'))
.to.eventually.have.lengthOf(NUMBER_OF_GROUPS_USER_CAN_VIEW);
});
});
test/api/v3/integration/groups/GET-groups_groupId_invites.test.js
+102
View File
@@ -0,0 +1,102 @@
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /groups/:groupId/invites', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('validates optional req.query.lastId to be an UUID', async () => {
await expect(user.get('/groups/groupId/invites?lastId=invalidUUID')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('fails if group doesn\'t exists', async () => {
await expect(user.get(`/groups/${generateUUID()}/invites`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('fails if user doesn\'t have access to the group', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let anotherUser = await generateUser();
await expect(anotherUser.get(`/groups/${group._id}/invites`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('works when passing party as req.params.groupId', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, {uuids: [invited._id]});
let res = await user.get('/groups/party/invites');
expect(res).to.be.an('array');
expect(res.length).to.equal(1);
expect(res[0]).to.eql({
_id: invited._id,
id: invited._id,
profile: {name: invited.profile.name},
});
});
it('populates only some fields', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let invited = await generateUser();
await user.post(`/groups/${group._id}/invite`, {uuids: [invited._id]});
let res = await user.get('/groups/party/invites');
expect(res[0]).to.have.all.keys(['_id', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('returns only first 30 invites', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let invitesToGenerate = [];
for (let i = 0; i < 31; i++) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate);
await user.post(`/groups/${group._id}/invite`, {uuids: generatedInvites.map(invite => invite._id)});
let res = await user.get('/groups/party/invites');
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'id', 'profile']);
expect(member.profile).to.have.all.keys(['name']);
});
});
it('supports using req.query.lastId to get more invites', async () => {
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
let invitesToGenerate = [];
for (let i = 0; i < 32; i++) {
invitesToGenerate.push(generateUser());
}
let generatedInvites = await Promise.all(invitesToGenerate); // Group has 32 invites
let expectedIds = generatedInvites.map(generatedInvite => generatedInvite._id);
await user.post(`/groups/${group._id}/invite`, {uuids: expectedIds});
let res = await user.get(`/groups/${group._id}/invites`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/groups/${group._id}/invites?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(2);
let resIds = res.concat(res2).map(invite => invite._id);
expect(resIds).to.eql(expectedIds.sort());
});
});
test/api/v3/integration/groups/GET-groups_groupId_members.test.js
+96
View File
@@ -0,0 +1,96 @@
import {
generateUser,
generateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /groups/:groupId/members', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('validates optional req.query.lastId to be an UUID', async () => {
await expect(user.get('/groups/groupId/members?lastId=invalidUUID')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('fails if group doesn\'t exists', async () => {
await expect(user.get(`/groups/${generateUUID()}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('fails if user doesn\'t have access to the group', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let anotherUser = await generateUser();
await expect(anotherUser.get(`/groups/${group._id}/members`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('works when passing party as req.params.groupId', async () => {
await generateGroup(user, {type: 'party', name: generateUUID()});
let res = await user.get('/groups/party/members');
expect(res).to.be.an('array');
expect(res.length).to.equal(1);
expect(res[0]).to.eql({
_id: user._id,
id: user._id,
profile: {name: user.profile.name},
});
});
it('populates only some fields', async () => {
await generateGroup(user, {type: 'party', name: generateUUID()});
let res = await user.get('/groups/party/members');
expect(res[0]).to.have.all.keys(['_id', 'id', 'profile']);
expect(res[0].profile).to.have.all.keys(['name']);
});
it('returns only first 30 members', async () => {
let group = await generateGroup(user, {type: 'party', name: generateUUID()});
let usersToGenerate = [];
for (let i = 0; i < 31; i++) {
usersToGenerate.push(generateUser({party: {_id: group._id}}));
}
await Promise.all(usersToGenerate);
let res = await user.get('/groups/party/members');
expect(res.length).to.equal(30);
res.forEach(member => {
expect(member).to.have.all.keys(['_id', 'id', 'profile']);
expect(member.profile).to.have.all.keys(['name']);
});
});
it('supports using req.query.lastId to get more members', async () => {
let leader = await generateUser({balance: 4});
let group = await generateGroup(leader, {type: 'guild', privacy: 'public', name: generateUUID()});
let usersToGenerate = [];
for (let i = 0; i < 57; i++) {
usersToGenerate.push(generateUser({guilds: [group._id]}));
}
let generatedUsers = await Promise.all(usersToGenerate); // Group has 59 members (1 is the leader)
let expectedIds = [leader._id].concat(generatedUsers.map(generatedUser => generatedUser._id));
let res = await user.get(`/groups/${group._id}/members`);
expect(res.length).to.equal(30);
let res2 = await user.get(`/groups/${group._id}/members?lastId=${res[res.length - 1]._id}`);
expect(res2.length).to.equal(28);
let resIds = res.concat(res2).map(member => member._id);
expect(resIds).to.eql(expectedIds.sort());
});
});
test/api/v3/integration/groups/GET-groups_id.test.js
+298
View File
@@ -0,0 +1,298 @@
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import {
each,
} from 'lodash';
describe('GET /groups/:id', () => {
let typesOfGroups = {};
typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
typesOfGroups.party = { type: 'party', privacy: 'private' };
each(typesOfGroups, (groupDetails, groupType) => {
context(`Member of a ${groupType}`, () => {
let leader, member, createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
members: 30,
groupDetails,
});
leader = groupData.groupLeader;
member = groupData.members[0];
createdGroup = groupData.group;
});
it('returns the group object', async () => {
let group = await member.get(`/groups/${createdGroup._id}`);
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
expect(group.type).to.eql(createdGroup.type);
expect(group.privacy).to.eql(createdGroup.privacy);
});
it('transforms leader id to leader object', async () => {
let group = await member.get(`/groups/${createdGroup._id}`);
expect(group.leader._id).to.eql(leader._id);
expect(group.leader.profile.name).to.eql(leader.profile.name);
});
});
});
context('Non-member of a public guild', () => {
let nonMember, createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test guild',
type: 'guild',
privacy: 'public',
},
});
createdGroup = groupData.group;
nonMember = await generateUser();
});
it('returns the group object for a non-member', async () => {
let group = await nonMember.get(`/groups/${createdGroup._id}`);
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
expect(group.type).to.eql(createdGroup.type);
expect(group.privacy).to.eql(createdGroup.privacy);
});
});
context('Non-member of a private guild', () => {
let nonMember, createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test guild',
type: 'guild',
privacy: 'private',
},
});
createdGroup = groupData.group;
nonMember = await generateUser();
});
it('does not return the group object for a non-member', async () => {
await expect(nonMember.get(`/groups/${createdGroup._id}`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
});
context('Non-member of a party', () => {
let nonMember, createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test party',
type: 'party',
privacy: 'private',
},
});
createdGroup = groupData.group;
nonMember = await generateUser();
});
it('does not return the group object for a non-member', async () => {
await expect(nonMember.get(`/groups/${createdGroup._id}`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
});
context('Member of a party', () => {
let member, createdGroup;
before(async () => {
let groupData = await createAndPopulateGroup({
members: 1,
groupDetails: {
name: 'test party',
type: 'party',
privacy: 'private',
},
});
createdGroup = groupData.group;
member = groupData.members[0];
});
it('returns the user\'s party if an id of "party" is passed in', async () => {
let group = await member.get('/groups/party');
expect(group._id).to.eql(createdGroup._id);
expect(group.name).to.eql(createdGroup.name);
expect(group.type).to.eql(createdGroup.type);
expect(group.privacy).to.eql(createdGroup.privacy);
});
});
context('Non-existent group', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('returns error if group does not exist', async () => {
await expect(user.get('/groups/group-that-does-not-exist'))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
});
context('Flagged messages', () => {
let group;
let chat1 = {
id: 'chat1',
text: 'chat 1',
flags: {},
};
let chat2 = {
id: 'chat2',
text: 'chat 2',
flags: {},
flagCount: 0,
};
let chat3 = {
id: 'chat3',
text: 'chat 3',
flags: {
'user-id': true,
},
flagCount: 1,
};
let chat4 = {
id: 'chat4',
text: 'chat 4',
flags: {
'user-id': true,
'other-user-id': true,
},
flagCount: 2,
};
let chat5 = {
id: 'chat5',
text: 'chat 5',
flags: {
'user-id': true,
'other-user-id': true,
'yet-another-user-id': true,
},
flagCount: 3,
};
beforeEach(async () => {
let groupData = await createAndPopulateGroup({
groupDetails: {
name: 'test guild',
type: 'guild',
privacy: 'public',
chat: [
chat1,
chat2,
chat3,
chat4,
chat5,
],
},
});
group = groupData.group;
await group.addChat([chat1, chat2, chat3, chat4, chat5]);
});
context('non-admin', () => {
let nonAdmin;
beforeEach(async () => {
nonAdmin = await generateUser();
});
it('does not include messages with a flag count of 2 or greater', async () => {
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
expect(fetchedGroup.chat).to.have.lengthOf(3);
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
expect(fetchedGroup.chat[1].id).to.eql(chat2.id);
expect(fetchedGroup.chat[2].id).to.eql(chat3.id);
});
it('does not include user ids in flags object', async () => {
let fetchedGroup = await nonAdmin.get(`/groups/${group._id}`);
let chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true });
expect(chatWithOneFlag.flags).to.eql({});
});
});
context('admin', () => {
let admin;
beforeEach(async () => {
admin = await generateUser({
'contributor.admin': true,
});
});
it('includes all messages', async () => {
let fetchedGroup = await admin.get(`/groups/${group._id}`);
expect(fetchedGroup.chat).to.have.lengthOf(5);
expect(fetchedGroup.chat[0].id).to.eql(chat1.id);
expect(fetchedGroup.chat[1].id).to.eql(chat2.id);
expect(fetchedGroup.chat[2].id).to.eql(chat3.id);
expect(fetchedGroup.chat[3].id).to.eql(chat4.id);
expect(fetchedGroup.chat[4].id).to.eql(chat5.id);
});
it('includes user ids in flags object', async () => {
let fetchedGroup = await admin.get(`/groups/${group._id}`);
let chatWithOneFlag = fetchedGroup.chat[2];
expect(chatWithOneFlag.id).to.eql(chat3.id);
expect(chat3.flags).to.eql({ 'user-id': true });
expect(chatWithOneFlag.flags).to.eql(chat3.flags);
});
});
});
});
test/api/v3/integration/groups/POST-groups.test.js
+228
View File
@@ -0,0 +1,228 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /group', () => {
let user;
beforeEach(async () => {
user = await generateUser({ balance: 10 });
});
context('All Groups', () => {
it('it returns validation error when type is not provided', async () => {
await expect(
user.post('/groups', { name: 'Test Group Without Type' })
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Group validation failed',
});
});
it('it returns validation error when type is not supported', async () => {
await expect(
user.post('/groups', { name: 'Group with unsupported type', type: 'foo' })
).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Group validation failed',
});
});
it('sets the group leader to the user who created the group', async () => {
let group = await user.post('/groups', {
name: 'Test Public Guild',
type: 'guild',
});
expect(group.leader).to.eql({
_id: user._id,
profile: {
name: user.profile.name,
},
});
});
});
context('Guilds', () => {
it('returns an error when a user with insufficient funds attempts to create a guild', async () => {
await user.update({ balance: 0 });
await expect(
user.post('/groups', {
name: 'Test Public Guild',
type: 'guild',
})
).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageInsufficientGems'),
});
});
it('adds guild to user\'s list of guilds', async () => {
let guild = await user.post('/groups', {
name: 'some guild',
type: 'guild',
privacy: 'public',
});
let updatedUser = await user.get('/user');
expect(updatedUser.guilds).to.include(guild._id);
});
context('public guild', () => {
it('creates a group', async () => {
let groupName = 'Test Public Guild';
let groupType = 'guild';
let groupPrivacy = 'public';
let publicGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
});
expect(publicGuild._id).to.exist;
expect(publicGuild.name).to.equal(groupName);
expect(publicGuild.type).to.equal(groupType);
expect(publicGuild.memberCount).to.equal(1);
expect(publicGuild.privacy).to.equal(groupPrivacy);
expect(publicGuild.leader).to.eql({
_id: user._id,
profile: {
name: user.profile.name,
},
});
});
});
context('private guild', () => {
let groupName = 'Test Private Guild';
let groupType = 'guild';
let groupPrivacy = 'private';
it('creates a group', async () => {
let privateGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
});
expect(privateGuild._id).to.exist;
expect(privateGuild.name).to.equal(groupName);
expect(privateGuild.type).to.equal(groupType);
expect(privateGuild.memberCount).to.equal(1);
expect(privateGuild.privacy).to.equal(groupPrivacy);
expect(privateGuild.leader).to.eql({
_id: user._id,
profile: {
name: user.profile.name,
},
});
});
it('deducts gems from user and adds them to guild bank', async () => {
let privateGuild = await user.post('/groups', {
name: groupName,
type: groupType,
privacy: groupPrivacy,
});
expect(privateGuild.balance).to.eql(1);
let updatedUser = await user.get('/user');
expect(updatedUser.balance).to.eql(user.balance - 1);
});
});
});
context('Parties', () => {
let partyName = 'Test Party';
let partyType = 'party';
it('creates a party', async () => {
let party = await user.post('/groups', {
name: partyName,
type: partyType,
});
expect(party._id).to.exist;
expect(party.name).to.equal(partyName);
expect(party.type).to.equal(partyType);
expect(party.memberCount).to.equal(1);
expect(party.leader).to.eql({
_id: user._id,
profile: {
name: user.profile.name,
},
});
});
it('does not require gems to create a party', async () => {
await user.update({ balance: 0 });
let party = await user.post('/groups', {
name: partyName,
type: partyType,
});
expect(party._id).to.exist;
let updatedUser = await user.get('/user');
expect(updatedUser.balance).to.eql(user.balance);
});
it('sets party id on user object', async () => {
let party = await user.post('/groups', {
name: partyName,
type: partyType,
});
let updatedUser = await user.get('/user');
expect(updatedUser.party._id).to.eql(party._id);
});
it('does not award Party Up achievement to solo partier', async () => {
await user.post('/groups', {
name: partyName,
type: partyType,
});
let updatedUser = await user.get('/user');
expect(updatedUser.achievements.partyUp).to.not.eql(true);
});
it('prevents user in a party from creating another party', async () => {
await user.post('/groups', {
name: partyName,
type: partyType,
});
await expect(user.post('/groups')).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupAlreadyInParty'),
});
});
it('prevents creating a public party', async () => {
await expect(user.post('/groups', {
name: partyName,
type: partyType,
privacy: 'public',
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('partyMustbePrivate'),
});
});
});
});
test/api/v3/integration/groups/POST-groups_groupId_join.test.js
+286
View File
@@ -0,0 +1,286 @@
import {
generateUser,
createAndPopulateGroup,
checkExistence,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /group/:groupId/join', () => {
const PET_QUEST = 'whale';
it('returns error when groupId is not for a valid group', async () => {
let joiningUser = await generateUser();
await expect(joiningUser.post(`/groups/${generateUUID()}/join`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
context('Joining a public guild', () => {
let user, joiningUser, publicGuild;
beforeEach(async () => {
let {group, groupLeader} = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'public',
},
});
publicGuild = group;
user = groupLeader;
joiningUser = await generateUser();
});
it('allows non-invited users to join public guilds', async () => {
let res = await joiningUser.post(`/groups/${publicGuild._id}/join`);
await expect(joiningUser.get('/user')).to.eventually.have.property('guilds').to.include(publicGuild._id);
expect(res.leader._id).to.eql(user._id);
expect(res.leader.profile.name).to.eql(user.profile.name);
});
it('returns an error is user was already a member', async () => {
await joiningUser.post(`/groups/${publicGuild._id}/join`);
await expect(joiningUser.post(`/groups/${publicGuild._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInGroup'),
});
});
it('promotes joining member in a public empty guild to leader', async () => {
await user.post(`/groups/${publicGuild._id}/leave`);
await joiningUser.post(`/groups/${publicGuild._id}/join`);
await expect(joiningUser.get(`/groups/${publicGuild._id}`)).to.eventually.have.deep.property('leader._id', joiningUser._id);
});
it('increments memberCount when joining guilds', async () => {
let oldMemberCount = publicGuild.memberCount;
await joiningUser.post(`/groups/${publicGuild._id}/join`);
await expect(joiningUser.get(`/groups/${publicGuild._id}`)).to.eventually.have.property('memberCount', oldMemberCount + 1);
});
});
context('Joining a private guild', () => {
let user, invitedUser, guild;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'private',
},
invites: 1,
});
guild = group;
user = groupLeader;
invitedUser = invitees[0];
});
it('returns error when user is not invited to private guild', async () => {
let userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${guild._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupRequiresInvite'),
});
});
context('User is invited', () => {
it('allows invited user to join private guilds', async () => {
await invitedUser.post(`/groups/${guild._id}/join`);
await expect(invitedUser.get('/user')).to.eventually.have.property('guilds').to.include(guild._id);
});
it('clears invitation from user when joining guilds', async () => {
await invitedUser.post(`/groups/${guild._id}/join`);
await expect(invitedUser.get('/user'))
.to.eventually.have.deep.property('invitations.guilds')
.to.not.include({id: guild._id});
});
it('increments memberCount when joining guilds', async () => {
let oldMemberCount = guild.memberCount;
await invitedUser.post(`/groups/${guild._id}/join`);
await expect(invitedUser.get(`/groups/${guild._id}`)).to.eventually.have.property('memberCount', oldMemberCount + 1);
});
it('does not give basilist quest to inviter when joining a guild', async () => {
await invitedUser.post(`/groups/${guild._id}/join`);
await expect(user.get('/user')).to.eventually.not.have.deep.property('items.quests.basilist');
});
it('does not increment basilist quest count to inviter with basilist when joining a guild', async () => {
await user.update({ 'items.quests.basilist': 1 });
await invitedUser.post(`/groups/${guild._id}/join`);
await expect(user.get('/user')).to.eventually.have.deep.property('items.quests.basilist', 1);
});
});
});
context('Joining a party', () => {
let user, invitedUser, party;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
},
members: 2,
invites: 1,
});
party = group;
user = groupLeader;
invitedUser = invitees[0];
});
it('returns error when user is not invited to party', async () => {
let userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${party._id}/join`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupRequiresInvite'),
});
});
context('User is invited', () => {
it('allows invited user to join party', async () => {
await invitedUser.post(`/groups/${party._id}/join`);
await expect(invitedUser.get('/user')).to.eventually.have.deep.property('party._id', party._id);
});
it('clears invitation from user when joining party', async () => {
await invitedUser.post(`/groups/${party._id}/join`);
await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.party.id');
});
it('increments memberCount when joining party', async () => {
let oldMemberCount = party.memberCount;
await invitedUser.post(`/groups/${party._id}/join`);
await expect(invitedUser.get(`/groups/${party._id}`)).to.eventually.have.property('memberCount', oldMemberCount + 1);
});
it('gives basilist quest item to the inviter when joining a party', async () => {
await invitedUser.post(`/groups/${party._id}/join`);
await expect(user.get('/user')).to.eventually.have.deep.property('items.quests.basilist', 1);
});
it('increments basilist quest item count to inviter when joining a party', async () => {
await user.update({'items.quests.basilist': 1 });
await invitedUser.post(`/groups/${party._id}/join`);
await expect(user.get('/user')).to.eventually.have.deep.property('items.quests.basilist', 2);
});
it('deletes previous party where the user was the only member', async () => {
let userToInvite = await generateUser();
let oldParty = await userToInvite.post('/groups', { // add user to a party
name: 'Another Test Party',
type: 'party',
});
await expect(checkExistence('groups', oldParty._id)).to.eventually.equal(true);
await user.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
});
await userToInvite.post(`/groups/${party._id}/join`);
await expect(user.get('/user')).to.eventually.have.deep.property('party._id', party._id);
await expect(checkExistence('groups', oldParty._id)).to.eventually.equal(false);
});
it('invites joining member to active quest', async () => {
await user.update({
[`items.quests.${PET_QUEST}`]: 1,
});
await user.post(`/groups/${party._id}/quests/invite/${PET_QUEST}`);
await invitedUser.post(`/groups/${party._id}/join`);
await invitedUser.sync();
await party.sync();
expect(invitedUser).to.have.deep.property('party.quest.RSVPNeeded', true);
expect(invitedUser).to.have.deep.property('party.quest.key', party.quest.key);
expect(party.quest.members[invitedUser._id]).to.be.null;
});
});
});
context('Party incentive achievements', () => {
let leader, member, party;
beforeEach(async () => {
leader = await generateUser();
member = await generateUser();
party = await leader.post('/groups', {
name: 'Testing Party',
type: 'party',
});
await leader.post(`/groups/${party._id}/invite`, {
uuids: [member._id],
});
await member.post(`/groups/${party._id}/join`);
});
it('awards Party Up achievement to party of size 2', async () => {
await member.sync();
await leader.sync();
expect(member).to.have.deep.property('achievements.partyUp', true);
expect(leader).to.have.deep.property('achievements.partyUp', true);
});
it('does not award Party On achievement to party of size 2', async () => {
await member.sync();
await leader.sync();
expect(member).to.not.have.deep.property('achievements.partyOn');
expect(leader).to.not.have.deep.property('achievements.partyOn');
});
it('awards Party On achievement to party of size 4', async () => {
let addlMemberOne = await generateUser();
let addlMemberTwo = await generateUser();
await leader.post(`/groups/${party._id}/invite`, {
uuids: [addlMemberOne._id, addlMemberTwo._id],
});
await addlMemberOne.post(`/groups/${party._id}/join`);
await addlMemberTwo.post(`/groups/${party._id}/join`);
await member.sync();
await leader.sync();
expect(member).to.have.deep.property('achievements.partyOn', true);
expect(leader).to.have.deep.property('achievements.partyOn', true);
});
});
});
test/api/v3/integration/groups/POST-groups_groupId_leave.js
+210
View File
@@ -0,0 +1,210 @@
import {
generateChallenge,
checkExistence,
createAndPopulateGroup,
sleep,
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import {
each,
} from 'lodash';
describe('POST /groups/:groupId/leave', () => {
let typesOfGroups = {
'public guild': { type: 'guild', privacy: 'public' },
'private guild': { type: 'guild', privacy: 'private' },
party: { type: 'party', privacy: 'private' },
};
each(typesOfGroups, (groupDetails, groupType) => {
context(`Leaving a ${groupType}`, () => {
let groupToLeave;
let leader;
let member;
let memberCount;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails,
members: 1,
});
groupToLeave = group;
leader = groupLeader;
member = members[0];
memberCount = group.memberCount;
});
it('prevents non members from leaving', async () => {
let user = await generateUser();
await expect(user.post(`/groups/${groupToLeave._id}/leave`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it(`lets user leave a ${groupType}`, async () => {
await member.post(`/groups/${groupToLeave._id}/leave`);
let userThatLeftGroup = await member.get('/user');
expect(userThatLeftGroup.guilds).to.be.empty;
expect(userThatLeftGroup.party._id).to.not.exist;
await groupToLeave.sync();
expect(groupToLeave.memberCount).to.equal(memberCount - 1);
});
it(`sets a new group leader when leader leaves a ${groupType}`, async () => {
await leader.post(`/groups/${groupToLeave._id}/leave`);
await groupToLeave.sync();
expect(groupToLeave.memberCount).to.equal(memberCount - 1);
expect(groupToLeave.leader).to.equal(member._id);
});
context('With challenges', () => {
let challenge;
beforeEach(async () => {
challenge = await generateChallenge(leader, groupToLeave);
await leader.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
await sleep(0.5);
});
it('removes all challenge tasks when keep parameter is set to remove', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave?keep=remove-all`);
let userWithoutChallengeTasks = await leader.get('/user');
expect(userWithoutChallengeTasks.challenges).to.not.include(challenge._id);
expect(userWithoutChallengeTasks.tasksOrder.habits).to.be.empty;
});
it('keeps all challenge tasks when keep parameter is not set', async () => {
await leader.post(`/groups/${groupToLeave._id}/leave`);
let userWithChallengeTasks = await leader.get('/user');
expect(userWithChallengeTasks.challenges).to.not.include(challenge._id);
// @TODO find elegant way to assert against the task existing
expect(userWithChallengeTasks.tasksOrder.habits).to.not.be.empty;
});
});
it('prevents quest leader from leaving a groupToLeave');
it('prevents a user from leaving during an active quest');
});
});
context('Leaving a group as the last member', () => {
context('private guild', () => {
let privateGuild;
let leader;
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Private Guild',
type: 'guild',
},
invites: 1,
});
privateGuild = group;
leader = groupLeader;
invitedUser = invitees[0];
});
it('removes a group when the last member leaves', async () => {
await leader.post(`/groups/${privateGuild._id}/leave`);
await expect(checkExistence('groups', privateGuild._id)).to.eventually.equal(false);
});
it('removes invitations when the last member leaves', async () => {
await leader.post(`/groups/${privateGuild._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.guilds).to.be.empty;
});
});
context('public guild', () => {
let publicGuild;
let leader;
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Public Guild',
type: 'guild',
privacy: 'public',
},
invites: 1,
});
publicGuild = group;
leader = groupLeader;
invitedUser = invitees[0];
});
it('keeps the group when the last member leaves', async () => {
await leader.post(`/groups/${publicGuild._id}/leave`);
await expect(checkExistence('groups', publicGuild._id)).to.eventually.equal(true);
});
it('keeps the invitations when the last member leaves a public guild', async () => {
await leader.post(`/groups/${publicGuild._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.guilds).to.not.be.empty;
});
});
context('party', () => {
let party;
let leader;
let invitedUser;
beforeEach(async () => {
let { group, groupLeader, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
},
invites: 1,
});
party = group;
leader = groupLeader;
invitedUser = invitees[0];
});
it('removes a group when the last member leaves a party', async () => {
await leader.post(`/groups/${party._id}/leave`);
await expect(checkExistence('party', party._id)).to.eventually.equal(false);
});
it('removes invitations when the last member leaves a party', async () => {
await leader.post(`/groups/${party._id}/leave`);
let userWithoutInvitation = await invitedUser.get('/user');
expect(userWithoutInvitation.invitations.party).to.be.empty;
});
});
});
});
test/api/v3/integration/groups/POST-groups_groupId_reject.test.js
+113
View File
@@ -0,0 +1,113 @@
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /group/:groupId/reject-invite', () => {
context('Rejecting a public guild invite', () => {
let publicGuild, invitedUser;
beforeEach(async () => {
let {group, invitees} = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'public',
},
invites: 1,
});
publicGuild = group;
invitedUser = invitees[0];
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${publicGuild._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupRequiresInvite'),
});
});
it('clears invitation from user', async () => {
await invitedUser.post(`/groups/${publicGuild._id}/reject-invite`);
await expect(invitedUser.get('/user'))
.to.eventually.have.deep.property('invitations.guilds')
.to.not.include({id: publicGuild._id});
});
});
context('Rejecting a private guild invite', () => {
let invitedUser, guild;
beforeEach(async () => {
let { group, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'private',
},
invites: 1,
});
guild = group;
invitedUser = invitees[0];
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${guild._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupRequiresInvite'),
});
});
it('clears invitation from user', async () => {
await invitedUser.post(`/groups/${guild._id}/reject-invite`);
await expect(invitedUser.get('/user'))
.to.eventually.have.deep.property('invitations.guilds')
.to.not.include({id: guild._id});
});
});
context('Rejecting a party invite', () => {
let invitedUser, party;
beforeEach(async () => {
let { group, invitees } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
},
members: 2,
invites: 1,
});
party = group;
invitedUser = invitees[0];
});
it('returns error when user is not invited', async () => {
let userWithoutInvite = await generateUser();
await expect(userWithoutInvite.post(`/groups/${party._id}/reject-invite`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupRequiresInvite'),
});
});
it('clears invitation from user', async () => {
await invitedUser.post(`/groups/${party._id}/reject-invite`);
await expect(invitedUser.get('/user')).to.eventually.not.have.deep.property('invitations.party.id');
});
});
});
test/api/v3/integration/groups/POST-groups_id_removeMember.test.js
+130
View File
@@ -0,0 +1,130 @@
import {
generateUser,
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /groups/:groupId/removeMember/:memberId', () => {
let leader;
let invitedUser;
let guild;
let member;
let member2;
beforeEach(async () => {
let { group, groupLeader, invitees, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
privacy: 'private',
},
invites: 1,
members: 2,
});
guild = group;
leader = groupLeader;
invitedUser = invitees[0];
member = members[0];
member2 = members[1];
});
context('All Groups', () => {
it('returns an error when user is not member of the group', async () => {
let nonMember = await generateUser();
expect(nonMember.post(`/groups/${guild._id}/removeMember/${member._id}`))
.to.eventually.be.rejected.and.eql({
code: 401,
type: 'NotAuthorized',
message: t('onlyLeaderCanRemoveMember'),
});
});
it('returns an error when user is a non-leader member of a group', async () => {
expect(member2.post(`/groups/${guild._id}/removeMember/${member._id}`))
.to.eventually.be.rejected.and.eql({
code: 401,
type: 'NotAuthorized',
message: t('onlyLeaderCanRemoveMember'),
});
});
it('does not allow leader to remove themselves', async () => {
expect(leader.post(`/groups/${guild._id}/removeMember/${leader._id}`))
.to.eventually.be.rejected.and.eql({
code: 401,
text: t('messageGroupCannotRemoveSelf'),
});
});
});
context('Guilds', () => {
it('can remove other members', async () => {
await leader.post(`/groups/${guild._id}/removeMember/${member._id}`);
let memberRemoved = await member.get('/user');
expect(memberRemoved.guilds.indexOf(guild._id)).eql(-1);
});
it('updates memberCount', async () => {
let oldMemberCount = guild.memberCount;
await leader.post(`/groups/${guild._id}/removeMember/${member._id}`);
await expect(leader.get(`/groups/${guild._id}`)).to.eventually.have.property('memberCount', oldMemberCount - 1);
});
it('can remove other invites', async () => {
await leader.post(`/groups/${guild._id}/removeMember/${invitedUser._id}`);
let invitedUserWithoutInvite = await invitedUser.get('/user');
expect(_.findIndex(invitedUserWithoutInvite.invitations.guilds, {id: guild._id})).eql(-1);
});
});
context('Party', () => {
let party;
let partyleader;
let partyInvitedUser;
let partyMember;
beforeEach(async () => {
let { group, groupLeader, invitees, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
privacy: 'private',
},
invites: 1,
members: 1,
});
party = group;
partyleader = groupLeader;
partyInvitedUser = invitees[0];
partyMember = members[0];
});
it('can remove other members', async () => {
await partyleader.post(`/groups/${party._id}/removeMember/${partyMember._id}`);
let memberRemoved = await partyMember.get('/user');
expect(memberRemoved.party._id).eql(undefined);
});
it('updates memberCount', async () => {
let oldMemberCount = party.memberCount;
await partyleader.post(`/groups/${party._id}/removeMember/${partyMember._id}`);
await expect(partyleader.get(`/groups/${party._id}`)).to.eventually.have.property('memberCount', oldMemberCount - 1);
});
it('can remove other invites', async () => {
await partyleader.post(`/groups/${party._id}/removeMember/${partyInvitedUser._id}`);
let invitedUserWithoutInvite = await partyInvitedUser.get('/user');
expect(_.findIndex(invitedUserWithoutInvite.invitations.party, {id: party._id})).eql(-1);
});
});
});
test/api/v3/integration/groups/POST-groups_invite.test.js
+332
View File
@@ -0,0 +1,332 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
const INVITES_LIMIT = 100;
describe('Post /groups/:groupId/invite', () => {
let inviter;
let group;
let groupName = 'Test Public Guild';
beforeEach(async () => {
inviter = await generateUser({balance: 1});
group = await inviter.post('/groups', {
name: groupName,
type: 'guild',
});
});
describe('user id invites', () => {
it('returns an error when invited user is not found', async () => {
let fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [fakeID],
}))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: fakeID}),
});
});
it('returns an error when uuids is not an array', async () => {
let fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: {fakeID},
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('uuidsMustBeAnArray'),
});
});
it('returns empty when uuids is empty', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [],
}))
.to.eventually.be.empty;
});
it('returns an error when there are more than INVITES_LIMIT uuids', async () => {
let uuids = [];
for (let i = 0; i < 101; i += 1) {
uuids.push(generateUUID());
}
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids,
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
});
});
it('invites a user to a group by uuid', async () => {
let userToInvite = await generateUser();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
})).to.eventually.deep.equal([{
id: group._id,
name: groupName,
inviter: inviter._id,
}]);
await expect(userToInvite.get('/user'))
.to.eventually.have.deep.property('invitations.guilds[0].id', group._id);
});
it('invites multiple users to a group by uuid', async () => {
let userToInvite = await generateUser();
let userToInvite2 = await generateUser();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id, userToInvite2._id],
})).to.eventually.deep.equal([
{
id: group._id,
name: groupName,
inviter: inviter._id,
},
{
id: group._id,
name: groupName,
inviter: inviter._id,
},
]);
await expect(userToInvite.get('/user')).to.eventually.have.deep.property('invitations.guilds[0].id', group._id);
await expect(userToInvite2.get('/user')).to.eventually.have.deep.property('invitations.guilds[0].id', group._id);
});
it('returns an error when inviting multiple users and a user is not found', async () => {
let userToInvite = await generateUser();
let fakeID = generateUUID();
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id, fakeID],
}))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: fakeID}),
});
});
});
describe('email invites', () => {
let testInvite = {name: 'test', email: 'test@habitica.com'};
it('returns an error when invite is missing an email', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails: [{name: 'test'}],
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('inviteMissingEmail'),
});
});
it('returns an error when emails is not an array', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails: {testInvite},
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('emailsMustBeAnArray'),
});
});
it('returns empty when emails is an empty array', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails: [],
}))
.to.eventually.be.empty;
});
it('returns an error when there are more than INVITES_LIMIT emails', async () => {
let emails = [];
for (let i = 0; i < 101; i += 1) {
emails.push(`${generateUUID()}@habitica.com`);
}
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails,
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
});
});
it('invites a user to a group by email', async () => {
let res = await inviter.post(`/groups/${group._id}/invite`, {
emails: [testInvite],
inviter: 'inviter name',
});
expect(res).to.exist;
});
it('invites multiple users to a group by email', async () => {
let res = await inviter.post(`/groups/${group._id}/invite`, {
emails: [testInvite, {name: 'test2', email: 'test2@habitica.com'}],
});
expect(res).to.exist;
});
});
describe('user and email invites', () => {
it('returns an error when emails and uuids are not provided', async () => {
await expect(inviter.post(`/groups/${group._id}/invite`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteEmailUuid'),
});
});
it('returns an error when there are more than INVITES_LIMIT uuids and emails', async () => {
let emails = [];
let uuids = [];
for (let i = 0; i < 50; i += 1) {
emails.push(`${generateUUID()}@habitica.com`);
}
for (let i = 0; i < 51; i += 1) {
uuids.push(generateUUID());
}
await expect(inviter.post(`/groups/${group._id}/invite`, {
emails,
uuids,
}))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('canOnlyInviteMaxInvites', {maxInvites: INVITES_LIMIT}),
});
});
it('invites users to a group by uuid and email', async () => {
let newUser = await generateUser();
let invite = await inviter.post(`/groups/${group._id}/invite`, {
uuids: [newUser._id],
emails: [{name: 'test', email: 'test@habitica.com'}],
});
let invitedUser = await newUser.get('/user');
expect(invitedUser.invitations.guilds[0].id).to.equal(group._id);
expect(invite).to.exist;
});
});
describe('guild invites', () => {
it('returns an error when invited user is already invited to the group', async () => {
let userToInivite = await generateUser();
await inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInivite._id],
});
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInivite._id],
}))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInvitedToGroup'),
});
});
it('returns an error when invited user is already in the group', async () => {
let userToInvite = await generateUser();
await inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
});
await userToInvite.post(`/groups/${group._id}/join`);
await expect(inviter.post(`/groups/${group._id}/invite`, {
uuids: [userToInvite._id],
}))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInGroup'),
});
});
});
describe('party invites', () => {
let party;
beforeEach(async () => {
party = await inviter.post('/groups', {
name: 'Test Party',
type: 'party',
});
});
it('returns an error when invited user has a pending invitation to the party', async () => {
let userToInvite = await generateUser();
await inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
});
await expect(inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
}))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyPendingInvitation'),
});
});
it('returns an error when invited user is already in a party of more than 1 member', async () => {
let userToInvite = await generateUser();
let userToInvite2 = await generateUser();
await inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id, userToInvite2._id],
});
await userToInvite.post(`/groups/${party._id}/join`);
await userToInvite2.post(`/groups/${party._id}/join`);
await expect(inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
}))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('userAlreadyInAParty'),
});
});
it('allow inviting a user to a party if he\'s partying solo', async () => {
let userToInvite = await generateUser();
await userToInvite.post('/groups', { // add user to a party
name: 'Another Test Party',
type: 'party',
});
await inviter.post(`/groups/${party._id}/invite`, {
uuids: [userToInvite._id],
});
expect((await userToInvite.get('/user')).invitations.party.id).to.equal(party._id);
});
});
});
test/api/v3/integration/groups/PUT-groups.test.js
+46
View File
@@ -0,0 +1,46 @@
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
describe('PUT /group', () => {
let leader, nonLeader, groupToUpdate;
let groupName = 'Test Public Guild';
let groupType = 'guild';
let groupUpdatedName = 'Test Public Guild Updated';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: groupName,
type: groupType,
privacy: 'public',
},
members: 1,
});
groupToUpdate = group;
leader = groupLeader;
nonLeader = members[0];
});
it('returns an error when a non group leader tries to update', async () => {
await expect(nonLeader.put(`/groups/${groupToUpdate._id}`, {
name: groupUpdatedName,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupOnlyLeaderCanUpdate'),
});
});
it('updates a group', async () => {
let updatedGroup = await leader.put(`/groups/${groupToUpdate._id}`, {
name: groupUpdatedName,
});
expect(updatedGroup.leader._id).to.eql(leader._id);
expect(updatedGroup.leader.profile.name).to.eql(leader.profile.name);
expect(updatedGroup.name).to.equal(groupUpdatedName);
});
});
test/api/v3/integration/hall/GET-hall_heroes.test.js
+29
View File
@@ -0,0 +1,29 @@
import {
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET /hall/heroes', () => {
it('returns all heroes sorted by -contributor.level and with correct fields', async () => {
let nonHero = await generateUser();
let hero1 = await generateUser({
contributor: {level: 1},
});
let hero2 = await generateUser({
contributor: {level: 3},
});
let heroes = await nonHero.get('/hall/heroes');
expect(heroes.length).to.equal(2);
expect(heroes[0]._id).to.equal(hero2._id);
expect(heroes[1]._id).to.equal(hero1._id);
expect(heroes[0]).to.have.all.keys(['_id', 'contributor', 'backer', 'profile']);
expect(heroes[1]).to.have.all.keys(['_id', 'contributor', 'backer', 'profile']);
expect(heroes[0].profile).to.have.all.keys(['name']);
expect(heroes[1].profile).to.have.all.keys(['name']);
expect(heroes[0].profile.name).to.equal(hero2.profile.name);
expect(heroes[1].profile.name).to.equal(hero1.profile.name);
});
});
test/api/v3/integration/hall/GET-hall_heroes_heroId.test.js
+56
View File
@@ -0,0 +1,56 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /heroes/:heroId', () => {
let user;
before(async () => {
user = await generateUser({
contributor: {admin: true},
});
});
it('requires the caller to be an admin', async () => {
let nonAdmin = await generateUser();
await expect(nonAdmin.get(`/hall/heroes/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('noAdminAccess'),
});
});
it('validates req.params.heroId', async () => {
await expect(user.get('/hall/heroes/invalidUUID')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('handles non-existing heroes', async () => {
let dummyId = generateUUID();
await expect(user.get(`/hall/heroes/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
});
});
it('returns only necessary hero data', async () => {
let hero = await generateUser({
contributor: {tier: 23},
});
let heroRes = await user.get(`/hall/heroes/${hero._id}`);
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'balance', 'profile', 'purchased',
'contributor', 'auth', 'items',
]);
expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(heroRes.profile).to.have.all.keys(['name']);
});
});
test/api/v3/integration/hall/GET-hall_patrons.test.js
+60
View File
@@ -0,0 +1,60 @@
import {
generateUser,
translate as t,
resetHabiticaDB,
} from '../../../../helpers/api-v3-integration.helper';
import { times } from 'lodash';
describe('GET /hall/patrons', () => {
let user;
beforeEach(async () => {
await resetHabiticaDB();
user = await generateUser();
});
it('fails if req.query.page is not numeric', async () => {
await expect(user.get('/hall/patrons?page=notNumber')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns all patrons sorted by -backer.tier and with correct fields', async () => {
let patron1 = await generateUser({
backer: {tier: 1},
});
let patron2 = await generateUser({
backer: {tier: 3},
});
let patrons = await user.get('/hall/patrons');
expect(patrons.length).to.equal(2);
expect(patrons[0]._id).to.equal(patron2._id);
expect(patrons[1]._id).to.equal(patron1._id);
expect(patrons[0]).to.have.all.keys(['_id', 'contributor', 'backer', 'profile']);
expect(patrons[1]).to.have.all.keys(['_id', 'contributor', 'backer', 'profile']);
expect(patrons[0].profile).to.have.all.keys(['name']);
expect(patrons[1].profile).to.have.all.keys(['name']);
expect(patrons[0].profile.name).to.equal(patron2.profile.name);
expect(patrons[1].profile.name).to.equal(patron1.profile.name);
});
it('returns only first 50 patrons per request, more if req.query.page is passed', async () => {
await Promise.all(times(53, n => {
return generateUser({backer: {tier: n}});
}));
let patrons = await user.get('/hall/patrons');
expect(patrons.length).to.equal(50);
let morePatrons = await user.get('/hall/patrons?page=1');
expect(morePatrons.length).to.equal(2);
expect(morePatrons[0].backer.tier).to.equal(2);
expect(morePatrons[1].backer.tier).to.equal(1);
});
});
test/api/v3/integration/hall/PUT-hall_heores_heroId.test.js
+148
View File
@@ -0,0 +1,148 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('PUT /heroes/:heroId', () => {
let user;
before(async () => {
user = await generateUser({
contributor: {admin: true},
});
});
it('requires the caller to be an admin', async () => {
let nonAdmin = await generateUser();
await expect(nonAdmin.put(`/hall/heroes/${user._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('noAdminAccess'),
});
});
it('validates req.params.heroId', async () => {
await expect(user.put('/hall/heroes/invalidUUID')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('handles non-existing heroes', async () => {
let dummyId = generateUUID();
await expect(user.put(`/hall/heroes/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
});
});
it('updates contributor level, balance, ads, blocked', async () => {
let hero = await generateUser();
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
balance: 3,
contributor: {level: 1},
purchased: {ads: true},
auth: {blocked: true},
});
// test response
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'balance', 'profile', 'purchased',
'contributor', 'auth', 'items',
]);
expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(heroRes.profile).to.have.all.keys(['name']);
// test response values
expect(heroRes.balance).to.equal(3 + 0.75); // 3+0.75 for first contrib level
expect(heroRes.contributor.level).to.equal(1);
expect(heroRes.purchased.ads).to.equal(true);
expect(heroRes.auth.blocked).to.equal(true);
// test hero values
await hero.sync();
expect(hero.balance).to.equal(3 + 0.75); // 3+0.75 for first contrib level
expect(hero.contributor.level).to.equal(1);
expect(hero.flags.contributor).to.equal(true);
expect(hero.purchased.ads).to.equal(true);
expect(hero.auth.blocked).to.equal(true);
});
it('updates contributor level', async () => {
let hero = await generateUser({
contributor: {level: 5},
});
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: {level: 6},
});
// test response
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'balance', 'profile', 'purchased',
'contributor', 'auth', 'items',
]);
expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(heroRes.profile).to.have.all.keys(['name']);
// test response values
expect(heroRes.balance).to.equal(1); // 0+1 for sixth contrib level
expect(heroRes.contributor.level).to.equal(6);
expect(heroRes.items.pets['Dragon-Hydra']).to.equal(5);
// test hero values
await hero.sync();
expect(hero.balance).to.equal(1); // 0+1 for sixth contrib level
expect(hero.contributor.level).to.equal(6);
expect(hero.flags.contributor).to.equal(true);
expect(hero.items.pets['Dragon-Hydra']).to.equal(5);
});
it('updates contributor data', async () => {
let hero = await generateUser({
contributor: {level: 5},
});
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
contributor: {text: 'Astronaut'},
});
// test response
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'balance', 'profile', 'purchased',
'contributor', 'auth', 'items',
]);
expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(heroRes.profile).to.have.all.keys(['name']);
// test response values
expect(heroRes.contributor.level).to.equal(5); // doesn't modify previous values
expect(heroRes.contributor.text).to.equal('Astronaut');
// test hero values
await hero.sync();
expect(hero.contributor.level).to.equal(5); // doesn't modify previous values
expect(hero.contributor.text).to.equal('Astronaut');
});
it('updates items', async () => {
let hero = await generateUser();
let heroRes = await user.put(`/hall/heroes/${hero._id}`, {
itemPath: 'items.special.snowball',
itemVal: 5,
});
// test response
expect(heroRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'balance', 'profile', 'purchased',
'contributor', 'auth', 'items',
]);
expect(heroRes.auth.local).not.to.have.keys(['salt', 'hashed_password']);
expect(heroRes.profile).to.have.all.keys(['name']);
// test response values
expect(heroRes.items.special.snowball).to.equal(5);
// test hero values
await hero.sync();
expect(hero.items.special.snowball).to.equal(5);
});
});
test/api/v3/integration/members/GET-members_id.test.js
+49
View File
@@ -0,0 +1,49 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('GET /members/:memberId', () => {
let user;
before(async () => {
user = await generateUser();
});
it('validates req.params.memberId', async () => {
await expect(user.get('/members/invalidUUID')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('returns a member public data only', async () => {
let member = await generateUser({ // make sure user has all the fields that can be returned by the getMember call
contributor: {level: 1},
backer: {tier: 3},
preferences: {
costume: false,
background: 'volcano',
},
});
let memberRes = await user.get(`/members/${member._id}`);
expect(memberRes).to.have.all.keys([ // works as: object has all and only these keys
'_id', 'id', 'preferences', 'profile', 'stats', 'achievements', 'party',
'backer', 'contributor', 'auth', 'items',
]);
expect(Object.keys(memberRes.auth)).to.eql(['timestamps']);
expect(Object.keys(memberRes.preferences).sort()).to.eql(['size', 'hair', 'skin', 'shirt',
'costume', 'sleep', 'background'].sort());
});
it('handles non-existing members', async () => {
let dummyId = generateUUID();
await expect(user.get(`/members/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userWithIDNotFound', {userId: dummyId}),
});
});
});
test/api/v3/integration/members/POST-send_private_message.test.js
+107
View File
@@ -0,0 +1,107 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /members/send-private-message', () => {
let userToSendMessage;
let messageToSend = 'Test Private Message';
beforeEach(async () => {
userToSendMessage = await generateUser();
});
it('returns error when message is not provided', async () => {
await expect(userToSendMessage.post('/members/send-private-message'))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when toUserId is not provided', async () => {
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when to user is not found', async () => {
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
toUserId: generateUUID(),
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userNotFound'),
});
});
it('returns error when to user has blocked the sender', async () => {
let receiver = await generateUser({'inbox.blocks': [userToSendMessage._id]});
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('notAuthorizedToSendMessageToThisUser'),
});
});
it('returns error when sender has blocked to user', async () => {
let receiver = await generateUser();
let sender = await generateUser({'inbox.blocks': [receiver._id]});
await expect(sender.post('/members/send-private-message', {
message: messageToSend,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('notAuthorizedToSendMessageToThisUser'),
});
});
it('returns error when to user has opted out of messaging', async () => {
let receiver = await generateUser({'inbox.optOut': true});
await expect(userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('notAuthorizedToSendMessageToThisUser'),
});
});
it('sends a private message to a user', async () => {
let receiver = await generateUser();
await userToSendMessage.post('/members/send-private-message', {
message: messageToSend,
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (message) => {
return message.uuid === userToSendMessage._id && message.text === messageToSend;
});
let sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (message) => {
return message.uuid === receiver._id && message.text === messageToSend;
});
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInSendersInbox).to.exist;
});
});
test/api/v3/integration/members/POST-transfer_gems.test.js
+174
View File
@@ -0,0 +1,174 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /members/transfer-gems', () => {
let userToSendMessage;
let receiver;
let message = 'Test Private Message';
let gemAmount = 20;
beforeEach(async () => {
userToSendMessage = await generateUser({balance: 5});
receiver = await generateUser();
});
it('returns error when no parameters are provided', async () => {
await expect(userToSendMessage.post('/members/transfer-gems'))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when toUserId is not provided', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount,
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when to user is not found', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount,
toUserId: generateUUID(),
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('userNotFound'),
});
});
it('returns error when to user attempts to send gems to themselves', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount,
toUserId: userToSendMessage._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('cannotSendGemsToYourself'),
});
});
it('returns error when there is no gemAmount', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when gemAmount is not an integer', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount: 1.5,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when gemAmount is negative', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount: -5,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('badAmountOfGemsToSend'),
});
});
it('returns error when gemAmount is more than the sender\'s balance', async () => {
await expect(userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount: gemAmount + 4,
toUserId: receiver._id,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('badAmountOfGemsToSend'),
});
});
it('sends a private message about gems to a user', async () => {
await userToSendMessage.post('/members/transfer-gems', {
message,
gemAmount,
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (inboxMessage) => {
return inboxMessage.uuid === userToSendMessage._id;
});
let sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (inboxMessage) => {
return inboxMessage.uuid === receiver._id;
});
let messageSentContent = t('privateMessageGiftIntro', {
receiverName: receiver.profile.name,
senderName: userToSendMessage.profile.name,
});
messageSentContent += t('privateMessageGiftGemsMessage', {gemAmount});
messageSentContent += message;
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInReceiversInbox.text).to.equal(messageSentContent);
expect(updatedReceiver.balance).to.equal(gemAmount / 4);
expect(sendersMessageInSendersInbox).to.exist;
expect(sendersMessageInSendersInbox.text).to.equal(messageSentContent);
expect(updatedSender.balance).to.equal(0);
});
it('does not requrie a message', async () => {
await userToSendMessage.post('/members/transfer-gems', {
gemAmount,
toUserId: receiver._id,
});
let updatedReceiver = await receiver.get('/user');
let updatedSender = await userToSendMessage.get('/user');
let sendersMessageInReceiversInbox = _.find(updatedReceiver.inbox.messages, (inboxMessage) => {
return inboxMessage.uuid === userToSendMessage._id;
});
let sendersMessageInSendersInbox = _.find(updatedSender.inbox.messages, (inboxMessage) => {
return inboxMessage.uuid === receiver._id;
});
let messageSentContent = t('privateMessageGiftIntro', {
receiverName: receiver.profile.name,
senderName: userToSendMessage.profile.name,
});
messageSentContent += t('privateMessageGiftGemsMessage', {gemAmount});
expect(sendersMessageInReceiversInbox).to.exist;
expect(sendersMessageInReceiversInbox.text).to.equal(messageSentContent);
expect(updatedReceiver.balance).to.equal(gemAmount / 4);
expect(sendersMessageInSendersInbox).to.exist;
expect(sendersMessageInSendersInbox.text).to.equal(messageSentContent);
expect(updatedSender.balance).to.equal(0);
});
});
test/api/v3/integration/models/GET-model_paths.test.js
+32
View File
@@ -0,0 +1,32 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('GET /models/:model/paths', () => {
let user;
before(async () => {
user = await generateUser();
});
it('returns an error when model is not accessible or doesn\'t exists', async () => {
await expect(user.get('/models/1234/paths')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
let models = ['habit', 'daily', 'todo', 'reward', 'user', 'tag', 'challenge', 'group'];
models.forEach(model => {
it(`returns the model paths for ${model}`, async () => {
let res = await user.get(`/models/${model}/paths`);
if (model !== 'tag') expect(res._id).to.equal('String');
if (model === 'tag') expect(res.id).to.equal('String');
expect(res).to.not.have.keys('__v');
});
});
});
test/api/v3/integration/notFound.test.js
+13
View File
@@ -0,0 +1,13 @@
import { requester } from '../../../helpers/api-integration/v3';
describe('notFound Middleware', () => {
it('returns a 404 error when the resource is not found', async () => {
let request = requester().get('/api/v3/dummy-url');
await expect(request).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: 'Not found.',
});
});
});
test/api/v3/integration/payments/GET-payments_amazon_subscribe_cancel.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('payments : amazon #subscribeCancel', () => {
let endpoint = '/amazon/subscribe/cancel';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies subscription', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_paypal_checkout.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
xdescribe('payments : paypal #checkout', () => {
let endpoint = '/paypal/checkout';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies subscription', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_paypal_checkout_success.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
xdescribe('payments : paypal #checkoutSuccess', () => {
let endpoint = '/paypal/checkout/success';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies subscription', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_paypal_subscribe.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
xdescribe('payments : paypal #subscribe', () => {
let endpoint = '/paypal/subscribe';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_paypal_subscribe_cancel.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('payments : paypal #subscribeCancel', () => {
let endpoint = '/paypal/subscribe/cancel';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_paypal_subscribe_success.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
xdescribe('payments : paypal #subscribeSuccess', () => {
let endpoint = '/paypal/subscribe/success';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/GET-payments_stripe_subscribe_cancel.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('payments - stripe - #subscribeCancel', () => {
let endpoint = '/stripe/subscribe/cancel';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.get(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/payments/POST-payments_amazon_checkout.test.js
+20
View File
@@ -0,0 +1,20 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('payments - amazon - #checkout', () => {
let endpoint = '/amazon/checkout';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.post(endpoint)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Missing req.body.orderReferenceId',
});
});
});
test/api/v3/integration/payments/POST-payments_amazon_createOrderReferenceId.test.js
+22
View File
@@ -0,0 +1,22 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('payments - amazon - #createOrderReferenceId', () => {
let endpoint = '/amazon/createOrderReferenceId';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies billingAgreementId', async (done) => {
try {
await user.post(endpoint);
} catch (e) {
// Parameter AWSAccessKeyId cannot be empty.
expect(e.error).to.eql('BadRequest');
done();
}
});
});
test/api/v3/integration/payments/POST-payments_amazon_subscribe.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('payments - amazon - #subscribe', () => {
let endpoint = '/amazon/subscribe';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies subscription code', async () => {
await expect(user.post(endpoint)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('missingSubscriptionCode'),
});
});
});
test/api/v3/integration/payments/POST-payments_amazon_verifyAccessToken.test.js
+20
View File
@@ -0,0 +1,20 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('payments : amazon', () => {
let endpoint = '/amazon/verifyAccessToken';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies access token', async () => {
await expect(user.post(endpoint)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Missing req.body.access_token',
});
});
});
test/api/v3/integration/payments/POST-payments_paypal_ipn.test.js
+17
View File
@@ -0,0 +1,17 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('payments - paypal - #ipn', () => {
let endpoint = '/paypal/ipn';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
let result = await user.post(endpoint);
expect(result).to.eql('OK');
});
});
test/api/v3/integration/payments/POST-payments_stripe_checkout.test.js
+20
View File
@@ -0,0 +1,20 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('payments - stripe - #checkout', () => {
let endpoint = '/stripe/checkout';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.post(endpoint, {id: 123})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'Error',
message: 'Invalid API Key provided: ****************************1111',
});
});
});
test/api/v3/integration/payments/POST-payments_stripe_subscribe_edit.test.js
+21
View File
@@ -0,0 +1,21 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('payments - stripe - #subscribeEdit', () => {
let endpoint = '/stripe/subscribe/edit';
let user;
beforeEach(async () => {
user = await generateUser();
});
it('verifies credentials', async () => {
await expect(user.post(endpoint)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('missingSubscription'),
});
});
});
test/api/v3/integration/quests/POST-groups_groupId_quests_accept.test.js
+119
View File
@@ -0,0 +1,119 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /groups/:groupId/quests/accept', () => {
const PET_QUEST = 'whale';
let questingGroup;
let leader;
let partyMembers;
let user;
beforeEach(async () => {
user = await generateUser();
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
});
context('failure conditions', () => {
it('does not accept quest without an invite', async () => {
await expect(leader.post(`/groups/${questingGroup._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('questInviteNotFound'),
});
});
it('does not accept quest for a group in which user is not a member', async () => {
await expect(user.post(`/groups/${questingGroup._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not accept quest for a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('does not accept invite twice', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('questAlreadyAccepted'),
});
});
it('does not accept invite for a quest already underway', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
// quest will start after everyone has accepted
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questAlreadyUnderway'),
});
});
});
context('successfully accepting a quest invitation', () => {
it('joins a quest from an invitation', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await Promise.all([partyMembers[0].sync(), questingGroup.sync()]);
expect(leader.party.quest.RSVPNeeded).to.equal(false);
expect(questingGroup.quest.members[partyMembers[0]._id]);
});
it('does not begin the quest if pending invitations remain', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await questingGroup.sync();
expect(questingGroup.quest.active).to.equal(false);
});
it('begins the quest if accepting the last pending invite', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
// quest will start after everyone has accepted
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await questingGroup.sync();
expect(questingGroup.quest.active).to.equal(true);
});
});
});
test/api/v3/integration/quests/POST-groups_groupId_quests_force-start.test.js
+126
View File
@@ -0,0 +1,126 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
describe('POST /groups/:groupId/quests/force-start', () => {
const PET_QUEST = 'whale';
let questingGroup;
let leader;
let partyMembers;
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
});
context('failure conditions', () => {
it('does not force start a quest for a group in which user is not a member', async () => {
let nonMember = await generateUser();
await expect(nonMember.post(`/groups/${questingGroup._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not force start quest for a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('does not force start for a party without a pending quest', async () => {
await expect(leader.post(`/groups/${questingGroup._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('questNotPending'),
});
});
it('does not force start for a quest already underway', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
// quest will start after everyone has accepted
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(leader.post(`/groups/${questingGroup._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questAlreadyUnderway'),
});
});
it('does not allow non-quest leader or non-group leader to force start a quest', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/force-start`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questOrGroupLeaderOnlyStartQuest'),
});
});
});
context('successfully force starting a quest', () => {
it('allows quest leader to force start quest', async () => {
let questLeader = partyMembers[0];
await questLeader.update({[`items.quests.${PET_QUEST}`]: 1});
await questLeader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await questLeader.post(`/groups/${questingGroup._id}/quests/force-start`);
await questingGroup.sync();
expect(questingGroup.quest.active).to.eql(true);
});
it('allows group leader to force start quest', async () => {
let questLeader = partyMembers[0];
await questLeader.update({[`items.quests.${PET_QUEST}`]: 1});
await questLeader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await leader.post(`/groups/${questingGroup._id}/quests/force-start`);
await questingGroup.sync();
expect(questingGroup.quest.active).to.eql(true);
});
it('sends back the quest object', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
let quest = await leader.post(`/groups/${questingGroup._id}/quests/force-start`);
expect(quest.active).to.eql(true);
expect(quest.key).to.eql(PET_QUEST);
expect(quest.members).to.eql({
[`${leader._id}`]: true,
});
});
});
});
test/api/v3/integration/quests/POST-groups_groupId_quests_invite.test.js
+192
View File
@@ -0,0 +1,192 @@
import {
createAndPopulateGroup,
translate as t,
sleep,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
import { quests as questScrolls } from '../../../../../common/script/content';
describe('POST /groups/:groupId/quests/invite/:questKey', () => {
let questingGroup;
let leader;
let member;
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 1,
});
questingGroup = group;
leader = groupLeader;
member = members[0];
});
context('failure conditions', () => {
it('does not issue invites with an invalid group ID', async () => {
await expect(leader.post(`/groups/${generateUUID()}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not issue invites for a group in which user is not a member', async () => {
let { group } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 1,
});
let alternateGroup = group;
await expect(leader.post(`/groups/${alternateGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not issue invites for Guilds', async () => {
let { group } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'public' },
members: 1,
});
let alternateGroup = group;
await expect(leader.post(`/groups/${alternateGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('does not issue invites with an invalid quest key', async () => {
const FAKE_QUEST = 'herkimer';
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${FAKE_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('questNotFound', {key: FAKE_QUEST}),
});
});
it('does not issue invites for a quest the user does not own', async () => {
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questNotOwned'),
});
});
it('does not issue invites if the user is of insufficient Level', async () => {
const LEVELED_QUEST = 'atom1';
const LEVELED_QUEST_REQ = questScrolls[LEVELED_QUEST].lvl;
const leaderUpdate = {};
leaderUpdate[`items.quests.${LEVELED_QUEST}`] = 1;
leaderUpdate['stats.lvl'] = LEVELED_QUEST_REQ - 1;
await leader.update(leaderUpdate);
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${LEVELED_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questLevelTooHigh', {level: LEVELED_QUEST_REQ}),
});
});
it('does not issue invites if a quest is already underway', async () => {
const QUEST_IN_PROGRESS = 'atom1';
const leaderUpdate = {};
leaderUpdate[`items.quests.${PET_QUEST}`] = 1;
await leader.update(leaderUpdate);
await questingGroup.update({ 'quest.key': QUEST_IN_PROGRESS });
await expect(leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questAlreadyUnderway'),
});
});
});
context('successfully issuing a quest invitation', () => {
beforeEach(async () => {
const memberUpdate = {};
memberUpdate[`items.quests.${PET_QUEST}`] = 1;
await Promise.all([
leader.update(memberUpdate),
member.update(memberUpdate),
]);
});
it('adds quest details to group object', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await questingGroup.sync();
let quest = questingGroup.quest;
expect(quest.key).to.eql(PET_QUEST);
expect(quest.active).to.eql(false);
expect(quest.leader).to.eql(leader._id);
expect(quest.members).to.have.property(leader._id, true);
expect(quest.members).to.have.property(member._id, null);
expect(quest).to.have.property('progress');
});
it('adds quest details to user objects', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await sleep(0.1); // member updates happen in the background
await Promise.all([
leader.sync(),
member.sync(),
]);
expect(leader.party.quest.key).to.eql(PET_QUEST);
expect(member.party.quest.key).to.eql(PET_QUEST);
expect(leader.party.quest.RSVPNeeded).to.eql(false);
expect(member.party.quest.RSVPNeeded).to.eql(true);
});
it('sends back the quest object', async () => {
let inviteResponse = await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
expect(inviteResponse.key).to.eql(PET_QUEST);
expect(inviteResponse.active).to.eql(false);
expect(inviteResponse.leader).to.eql(leader._id);
expect(inviteResponse.members).to.have.property(leader._id, true);
expect(inviteResponse.members).to.have.property(member._id, null);
expect(inviteResponse).to.have.property('progress');
});
it('allows non-party-leader party members to send invites', async () => {
let inviteResponse = await member.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await questingGroup.sync();
expect(inviteResponse.key).to.eql(PET_QUEST);
expect(questingGroup.quest.key).to.eql(PET_QUEST);
});
it('starts quest automatically if user is in a solo party', async () => {
let leaderDetails = { balance: 10 };
leaderDetails[`items.quests.${PET_QUEST}`] = 1;
let { group, groupLeader } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
leaderDetails,
});
await groupLeader.post(`/groups/${group._id}/quests/invite/${PET_QUEST}`);
await group.sync();
expect(group.quest.active).to.eql(true);
});
});
});
test/api/v3/integration/quests/POST-groups_groupid_quests_abort.test.js
+126
View File
@@ -0,0 +1,126 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:groupId/quests/abort', () => {
let questingGroup;
let partyMembers;
let user;
let leader;
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
user = await generateUser();
});
context('failure conditions', () => {
it('returns an error when group is not found', async () => {
await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/abort`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error for a group in which user is not a member', async () => {
await expect(user.post(`/groups/${questingGroup._id}/quests/abort`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/abort`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('returns an error when quest is not active', async () => {
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/abort`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('noActiveQuestToAbort'),
});
});
it('returns an error when non quest leader attempts to abort', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/abort`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyLeaderAbortQuest'),
});
});
});
it('aborts a quest', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
let res = await leader.post(`/groups/${questingGroup._id}/quests/abort`);
await Promise.all([
leader.sync(),
questingGroup.sync(),
partyMembers[0].sync(),
partyMembers[1].sync(),
]);
let cleanUserQuestObj = {
key: null,
progress: {
up: 0,
down: 0,
collect: {},
},
completed: null,
RSVPNeeded: false,
};
expect(leader.party.quest).to.eql(cleanUserQuestObj);
expect(partyMembers[0].party.quest).to.eql(cleanUserQuestObj);
expect(partyMembers[1].party.quest).to.eql(cleanUserQuestObj);
expect(leader.items.quests[PET_QUEST]).to.equal(1);
expect(questingGroup.quest).to.deep.equal(res);
expect(questingGroup.quest).to.eql({
key: null,
active: false,
leader: null,
progress: {
collect: {},
},
members: {},
});
});
});
test/api/v3/integration/quests/POST-groups_groupid_quests_cancel.test.js
+138
View File
@@ -0,0 +1,138 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:groupId/quests/cancel', () => {
let questingGroup;
let partyMembers;
let user;
let leader;
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
user = await generateUser();
});
context('failure conditions', () => {
it('returns an error when group is not found', async () => {
await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not reject quest for a group in which user is not a member', async () => {
await expect(user.post(`/groups/${questingGroup._id}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('returns an error when group is not on a quest', async () => {
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('questInvitationDoesNotExist'),
});
});
it('only the leader can cancel the quest', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyLeaderCancelQuest'),
});
});
it('does not cancel a quest already underway', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
// quest will start after everyone has accepted
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(leader.post(`/groups/${questingGroup._id}/quests/cancel`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('cantCancelActiveQuest'),
});
});
});
it('cancels a quest', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
let res = await leader.post(`/groups/${questingGroup._id}/quests/cancel`);
await Promise.all([
leader.sync(),
partyMembers[0].sync(),
partyMembers[1].sync(),
questingGroup.sync(),
]);
let clean = {
key: null,
progress: {
up: 0,
down: 0,
collect: {},
},
completed: null,
RSVPNeeded: false,
};
expect(leader.party.quest).to.eql(clean);
expect(partyMembers[1].party.quest).to.eql(clean);
expect(partyMembers[0].party.quest).to.eql(clean);
expect(res).to.eql(questingGroup.quest);
expect(questingGroup.quest).to.eql({
key: null,
active: false,
leader: null,
progress: {
collect: {},
},
members: {},
});
});
});
test/api/v3/integration/quests/POST-groups_groupid_quests_leave.test.js
+124
View File
@@ -0,0 +1,124 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:groupId/quests/leave', () => {
let questingGroup;
let partyMembers;
let user;
let leader;
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
user = await generateUser();
});
context('failure conditions', () => {
it('returns an error when group is not found', async () => {
await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error for a group in which user is not a member', async () => {
await expect(user.post(`/groups/${questingGroup._id}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('returns an error when quest is not active', async () => {
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('noActiveQuestToLeave'),
});
});
it('returns an error when quest leader attempts to leave', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(leader.post(`/groups/${questingGroup._id}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questLeaderCannotLeaveQuest'),
});
});
it('returns an error when non quest member attempts to leave', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/reject`);
await expect(partyMembers[1].post(`/groups/${questingGroup._id}/quests/leave`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('notPartOfQuest'),
});
});
});
it('leaves a quest', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
let leaveResult = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`);
await Promise.all([
partyMembers[0].sync(),
questingGroup.sync(),
]);
expect(partyMembers[0].party.quest).to.eql({
key: null,
progress: {
up: 0,
down: 0,
collect: {},
},
completed: null,
RSVPNeeded: false,
});
expect(questingGroup.quest).to.deep.equal(leaveResult);
expect(questingGroup.quest.members[partyMembers[0]._id]).to.be.false;
});
});
test/api/v3/integration/quests/POST-groups_groupid_quests_reject.test.js
+146
View File
@@ -0,0 +1,146 @@
import {
createAndPopulateGroup,
translate as t,
generateUser,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:groupId/quests/reject', () => {
let questingGroup;
let partyMembers;
let user;
let leader;
const PET_QUEST = 'whale';
beforeEach(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: { type: 'party', privacy: 'private' },
members: 2,
});
questingGroup = group;
leader = groupLeader;
partyMembers = members;
await leader.update({
[`items.quests.${PET_QUEST}`]: 1,
});
user = await generateUser();
});
context('failure conditions', () => {
it('returns an error when group is not found', async () => {
await expect(partyMembers[0].post(`/groups/${generateUUID()}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('does not accept quest for a group in which user is not a member', async () => {
await expect(user.post(`/groups/${questingGroup._id}/quests/accept`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
});
});
it('returns an error when group is a guild', async () => {
let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
groupDetails: { type: 'guild', privacy: 'private' },
});
await expect(guildLeader.post(`/groups/${guild._id}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('guildQuestsNotSupported'),
});
});
it('returns an error when group is not on a quest', async () => {
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('questInvitationDoesNotExist'),
});
});
it('return an error when a user rejects an invite twice', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('questAlreadyRejected'),
});
});
it('return an error when a user rejects an invite already accepted', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('questAlreadyAccepted'),
});
});
it('does not reject invite for a quest already underway', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
// quest will start after everyone has accepted
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/accept`);
await expect(partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('questAlreadyUnderway'),
});
});
});
context('successfully quest rejection', () => {
let cleanUserQuestObj = {
key: null,
progress: {
up: 0,
down: 0,
collect: {},
},
completed: null,
RSVPNeeded: false,
};
it('rejects a quest invitation', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
let res = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/reject`);
await partyMembers[0].sync();
await questingGroup.sync();
expect(partyMembers[0].party.quest).to.eql(cleanUserQuestObj);
expect(questingGroup.quest.members[partyMembers[0]._id]).to.be.false;
expect(questingGroup.quest.active).to.be.false;
expect(res).to.eql(questingGroup.quest);
});
it('starts the quest when the last user reject', async () => {
await leader.post(`/groups/${questingGroup._id}/quests/invite/${PET_QUEST}`);
await partyMembers[0].post(`/groups/${questingGroup._id}/quests/accept`);
await partyMembers[1].post(`/groups/${questingGroup._id}/quests/reject`);
await questingGroup.sync();
expect(questingGroup.quest.active).to.be.true;
});
});
});
test/api/v3/integration/status/GET-status.test.js
+12
View File
@@ -0,0 +1,12 @@
import {
requester,
} from '../../../../helpers/api-v3-integration.helper';
describe('GET /status', () => {
it('returns status: up', async () => {
let res = await requester().get('/status');
expect(res).to.eql({
status: 'up',
});
});
});
test/api/v3/integration/tags/DELETE-tags_id.test.js
+27
View File
@@ -0,0 +1,27 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('DELETE /tags/:tagId', () => {
let user;
before(async () => {
user = await generateUser();
});
it('deletes a tag given it\'s id', async () => {
let tagName = 'Tag 1';
let tag = await user.post('/tags', {name: tagName});
let numberOfTags = (await user.get('/tags')).length;
await user.del(`/tags/${tag.id}`);
let tags = await user.get('/tags');
let tagNames = tags.map((t) => {
return t.name;
});
expect(tags.length).to.equal(numberOfTags - 1);
expect(tagNames).to.not.include(tagName);
});
});
test/api/v3/integration/tags/GET-tags.test.js
+22
View File
@@ -0,0 +1,22 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('GET /tags', () => {
let user;
before(async () => {
user = await generateUser();
});
it('returns all user\'s tags', async () => {
let tag1 = await user.post('/tags', {name: 'Tag 1'});
let tag2 = await user.post('/tags', {name: 'Tag 2'});
let tags = await user.get('/tags');
expect(tags.length).to.equal(2 + 3); // + 3 because 1 is a default task
expect(tags[tags.length - 2].name).to.equal(tag1.name);
expect(tags[tags.length - 1].name).to.equal(tag2.name);
});
});
test/api/v3/integration/tags/GET-tags_id.test.js
+20
View File
@@ -0,0 +1,20 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('GET /tags/:tagId', () => {
let user;
before(async () => {
user = await generateUser();
});
it('returns a tag given it\'s id', async () => {
let createdTag = await user.post('/tags', {name: 'Tag 1'});
let tag = await user.get(`/tags/${createdTag.id}`);
expect(tag).to.deep.equal(createdTag);
});
it('handles non-existing tags');
});
test/api/v3/integration/tags/POST-tag-reorder.test.js
+44
View File
@@ -0,0 +1,44 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('POST /reorder-tags', () => {
let user;
before(async () => {
user = await generateUser();
});
it('returns error when no parameters are provided', async () => {
await expect(user.post('/reorder-tags'))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'Invalid request parameters.',
});
});
it('returns error when tag is not found', async () => {
await expect(user.post('/reorder-tags', {tagId: 'fake-id', to: 3}))
.to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('tagNotFound'),
});
});
it('updates tags', async () => {
let tag1Name = 'Tag 1';
let tag2Name = 'Tag 2';
await user.post('/tags', {name: tag1Name});
await user.post('/tags', {name: tag2Name});
await user.sync();
await user.post('/reorder-tags', {tagId: user.tags[4].id, to: 3});
await user.sync();
expect(user.tags[3].name).to.equal(tag2Name);
expect(user.tags[4].name).to.equal(tag1Name);
});
});
test/api/v3/integration/tags/POST-tags.test.js
+25
View File
@@ -0,0 +1,25 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('POST /tags', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('creates a tag correctly', async () => {
let tagName = 'Tag 1';
let createdTag = await user.post('/tags', {
name: tagName,
ignored: false,
});
let tag = await user.get(`/tags/${createdTag.id}`);
expect(tag.name).to.equal(tagName);
expect(tag.ignored).to.not.exist;
expect(tag).to.deep.equal(createdTag);
});
});
test/api/v3/integration/tags/PUT-tags_id.test.js
+28
View File
@@ -0,0 +1,28 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('PUT /tags/:tagId', () => {
let user;
before(async () => {
user = await generateUser();
});
it('updates a tag given it\'s id', async () => {
let updatedTagName = 'Tag updated';
let createdTag = await user.post('/tags', {name: 'Tag 1'});
let updatedTag = await user.put(`/tags/${createdTag.id}`, {
name: updatedTagName,
ignored: true,
});
createdTag = await user.get(`/tags/${updatedTag.id}`);
expect(updatedTag.name).to.equal(updatedTagName);
expect(updatedTag.ignored).to.not.exist;
expect(createdTag.name).to.equal(updatedTagName);
expect(createdTag.ignored).to.not.exist;
});
});
test/api/v3/integration/tasks/DELETE-tasks_id.test.js
+59
View File
@@ -0,0 +1,59 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
describe('DELETE /tasks/:id', () => {
let user;
before(async () => {
user = await generateUser();
});
context('task can be deleted', () => {
let task;
beforeEach(async () => {
task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
});
it('deletes a user\'s task', async () => {
await user.del(`/tasks/${task._id}`);
await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
context('task cannot be deleted', () => {
it('cannot delete a non-existant task', async () => {
await expect(user.del('/tasks/550e8400-e29b-41d4-a716-446655440000')).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('cannot delete a task owned by someone else', async () => {
let anotherUser = await generateUser();
let anotherUsersTask = await anotherUser.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
await expect(user.del(`/tasks/${anotherUsersTask._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('removes a task from user.tasksOrder'); // TODO
});
});
test/api/v3/integration/tasks/GET-tasks_challenge_challengeId.test.js
+75
View File
@@ -0,0 +1,75 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { each } from 'lodash';
import { v4 as generateUUID } from 'uuid';
describe('GET /tasks/:taskId', () => {
let user;
let guild;
let challenge;
let task;
let tasksToTest = {
habit: {
text: 'test habit',
type: 'habit',
up: false,
down: true,
},
todo: {
text: 'test todo',
type: 'todo',
},
daily: {
text: 'test daily',
type: 'daily',
frequency: 'daily',
everyX: 5,
startDate: new Date(),
},
reward: {
text: 'test reward',
type: 'reward',
},
};
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
it('returns error when incorrect id is passed', async () => {
await expect(user.get(`/tasks/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
each(tasksToTest, (taskValue, taskType) => {
context(`${taskType}`, () => {
before(async () => {
task = await user.post(`/tasks/challenge/${challenge._id}`, taskValue);
});
it('gets challenge task', async () => {
let getTask = await user.get(`/tasks/${task._id}`);
expect(getTask).to.eql(task);
});
it('returns error when user is not a member of the challenge', async () => {
let anotherUser = await generateUser();
await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
});
});
test/api/v3/integration/tasks/GET-tasks_id.test.js
+58
View File
@@ -0,0 +1,58 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('GET /tasks/:id', () => {
let user;
before(async () => {
user = await generateUser();
});
context('task can be accessed', async () => {
let task;
beforeEach(async () => {
task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
});
it('gets specified task', async () => {
let getTask = await user.get(`/tasks/${task._id}`);
expect(getTask).to.eql(task);
});
// TODO after challenges are implemented
it('can get active challenge task that user does not own'); // Yes?
});
context('task cannot be accessed', () => {
it('cannot get a non-existant task', async () => {
let dummyId = generateUUID();
await expect(user.get(`/tasks/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('cannot get a task owned by someone else', async () => {
let anotherUser = await generateUser();
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
});
test/api/v3/integration/tasks/GET-tasks_user.test.js
+84
View File
@@ -0,0 +1,84 @@
import {
generateUser,
} from '../../../../helpers/api-integration/v3';
describe('GET /tasks/user', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('returns all user\'s tasks', async () => {
let createdTasks = await user.post('/tasks/user', [{text: 'test habit', type: 'habit'}, {text: 'test todo', type: 'todo'}]);
let tasks = await user.get('/tasks/user');
expect(tasks.length).to.equal(createdTasks.length + 1); // + 1 because 1 is a default task
});
it('returns only a type of user\'s tasks if req.query.type is specified', async () => {
let createdTasks = await user.post('/tasks/user', [
{text: 'test habit', type: 'habit'},
{text: 'test daily', type: 'daily'},
{text: 'test reward', type: 'reward'},
{text: 'test todo', type: 'todo'},
]);
let habits = await user.get('/tasks/user?type=habits');
let dailys = await user.get('/tasks/user?type=dailys');
let rewards = await user.get('/tasks/user?type=rewards');
expect(habits.length).to.be.at.least(1);
expect(habits[0]._id).to.equal(createdTasks[0]._id);
expect(dailys.length).to.be.at.least(1);
expect(dailys[0]._id).to.equal(createdTasks[1]._id);
expect(rewards.length).to.be.at.least(1);
expect(rewards[0]._id).to.equal(createdTasks[2]._id);
});
it('returns uncompleted todos if req.query.type is "todos"', async () => {
let existingTodos = await user.get('/tasks/user?type=todos');
// populate user with other task types
await user.post('/tasks/user', [
{text: 'daily', type: 'daily'},
{text: 'reward', type: 'reward'},
{text: 'habit', type: 'habit'},
]);
let newUncompletedTodos = await user.post('/tasks/user', [
{text: 'test todo 1', type: 'todo'},
{text: 'test todo 2', type: 'todo'},
]);
let todoToBeCompleted = await user.post('/tasks/user', {
text: 'wll be completed todo', type: 'todo',
});
await user.post(`/tasks/${todoToBeCompleted._id}/score/up`);
let uncompletedTodos = [...existingTodos, ...newUncompletedTodos];
let todos = await user.get('/tasks/user?type=todos');
expect(todos.length).to.be.gte(2);
expect(todos.length).to.eql(uncompletedTodos.length);
expect(todos.every(task => task.type === 'todo'));
expect(todos.every(task => task.completed === false));
});
it('returns completed todos sorted by reverse completion date if req.query.type is "completeTodos"', async () => {
let todo1 = await user.post('/tasks/user', {text: 'todo to complete 1', type: 'todo'});
let todo2 = await user.post('/tasks/user', {text: 'todo to complete 2', type: 'todo'});
await user.sync();
let initialTodoCount = user.tasksOrder.todos.length;
await user.post(`/tasks/${todo2._id}/score/up`);
await user.post(`/tasks/${todo1._id}/score/up`);
await user.sync();
expect(user.tasksOrder.todos.length).to.equal(initialTodoCount - 2);
let completedTodos = await user.get('/tasks/user?type=completedTodos');
expect(completedTodos.length).to.equal(2);
expect(completedTodos[completedTodos.length - 1].text).to.equal('todo to complete 2'); // last is the todo that was completed most recently
});
});
test/api/v3/integration/tasks/POST-tasks_clearCompletedTodos.test.js
+43
View File
@@ -0,0 +1,43 @@
import {
generateUser,
generateGroup,
generateChallenge,
} from '../../../../helpers/api-integration/v3';
describe('POST /tasks/clearCompletedTodos', () => {
it('deletes all completed todos except the ones from a challenge', async () => {
let user = await generateUser({balance: 1});
let guild = await generateGroup(user);
let challenge = await generateChallenge(user, guild);
let initialTodoCount = user.tasksOrder.todos.length;
await user.post('/tasks/user', [
{text: 'todo 1', type: 'todo'},
{text: 'todo 2', type: 'todo'},
{text: 'todo 3', type: 'todo'},
{text: 'todo 4', type: 'todo'},
{text: 'todo 5', type: 'todo'},
]);
await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'todo 6',
type: 'todo',
});
let tasks = await user.get('/tasks/user?type=todos');
expect(tasks.length).to.equal(initialTodoCount + 6);
for (let task of tasks) {
if (['todo 2', 'todo 3', 'todo 6'].indexOf(task.text) !== -1) {
await user.post(`/tasks/${task._id}/score/up`); // eslint-disable-line babel/no-await-in-loop
}
}
await user.post('/tasks/clearCompletedTodos');
let completedTodos = await user.get('/tasks/user?type=completedTodos');
let todos = await user.get('/tasks/user?type=todos');
let allTodos = todos.concat(completedTodos);
expect(allTodos.length).to.equal(initialTodoCount + 4); // + 6 - 3 completed (but one is from challenge)
expect(allTodos[allTodos.length - 1].text).to.equal('todo 6');
});
});
test/api/v3/integration/tasks/POST-tasks_id_score_direction.test.js
+298
View File
@@ -0,0 +1,298 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:id/score/:direction', () => {
let user;
beforeEach(async () => {
user = await generateUser({
'stats.gp': 100,
});
});
context('all', () => {
it('requires a task id', async () => {
await expect(user.post('/tasks/123/score/up')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('requires a task direction', async () => {
await expect(user.post(`/tasks/${generateUUID()}/score/tt`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
});
context('todos', () => {
let todo;
beforeEach(async () => {
todo = await user.post('/tasks/user', {
text: 'test todo',
type: 'todo',
});
});
it('completes todo when direction is up', async () => {
await user.post(`/tasks/${todo._id}/score/up`);
let task = await user.get(`/tasks/${todo._id}`);
expect(task.completed).to.equal(true);
expect(task.dateCompleted).to.be.a('string'); // date gets converted to a string as json doesn't have a Date type
});
it('moves completed todos out of user.tasksOrder.todos', async () => {
let getUser = await user.get('/user');
expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
await user.post(`/tasks/${todo._id}/score/up`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(true);
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(-1);
});
it('moves un-completed todos back into user.tasksOrder.todos', async () => {
let getUser = await user.get('/user');
expect(getUser.tasksOrder.todos.indexOf(todo._id)).to.not.equal(-1);
await user.post(`/tasks/${todo._id}/score/up`);
await user.post(`/tasks/${todo._id}/score/down`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(false);
let updatedUser = await user.get('/user');
let l = updatedUser.tasksOrder.todos.length;
expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).not.to.equal(-1);
expect(updatedUser.tasksOrder.todos.indexOf(todo._id)).to.equal(l - 1); // Check that it was pushed at the bottom
});
it('uncompletes todo when direction is down', async () => {
await user.post(`/tasks/${todo._id}/score/down`);
let updatedTask = await user.get(`/tasks/${todo._id}`);
expect(updatedTask.completed).to.equal(false);
expect(updatedTask.dateCompleted).to.be.a('undefined');
});
it('scores up todo even if it is already completed'); // Yes?
it('scores down todo even if it is already uncompleted'); // Yes?
context('user stats when direction is up', () => {
let updatedUser;
beforeEach(async () => {
await user.post(`/tasks/${todo._id}/score/up`);
updatedUser = await user.get('/user');
});
it('increases user\'s mp', () => {
expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
});
it('increases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
it('increases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
context('user stats when direction is down', () => {
let updatedUser;
beforeEach(async () => {
await user.post(`/tasks/${todo._id}/score/down`);
updatedUser = await user.get('/user');
});
it('decreases user\'s mp', () => {
expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
});
it('decreases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
});
it('decreases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
});
});
});
context('dailys', () => {
let daily;
beforeEach(async () => {
daily = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
});
});
it('completes daily when direction is up', async () => {
await user.post(`/tasks/${daily._id}/score/up`);
let task = await user.get(`/tasks/${daily._id}`);
expect(task.completed).to.equal(true);
});
it('uncompletes daily when direction is down', async () => {
await user.post(`/tasks/${daily._id}/score/down`);
let task = await user.get(`/tasks/${daily._id}`);
expect(task.completed).to.equal(false);
});
it('scores up daily even if it is already completed'); // Yes?
it('scores down daily even if it is already uncompleted'); // Yes?
context('user stats when direction is up', () => {
let updatedUser;
beforeEach(async () => {
await user.post(`/tasks/${daily._id}/score/up`);
updatedUser = await user.get('/user');
});
it('increases user\'s mp', () => {
expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
});
it('increases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
it('increases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
context('user stats when direction is down', () => {
let updatedUser;
beforeEach(async () => {
await user.post(`/tasks/${daily._id}/score/down`);
updatedUser = await user.get('/user');
});
it('decreases user\'s mp', () => {
expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
});
it('decreases user\'s exp', () => {
expect(updatedUser.stats.exp).to.be.lessThan(user.stats.exp);
});
it('decreases user\'s gold', () => {
expect(updatedUser.stats.gp).to.be.lessThan(user.stats.gp);
});
});
});
context('habits', () => {
let habit, minusHabit, plusHabit, neitherHabit; // eslint-disable-line no-unused-vars
beforeEach(async () => {
habit = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
minusHabit = await user.post('/tasks/user', {
text: 'test min habit',
type: 'habit',
up: false,
});
plusHabit = await user.post('/tasks/user', {
text: 'test plus habit',
type: 'habit',
down: false,
});
neitherHabit = await user.post('/tasks/user', {
text: 'test neither habit',
type: 'habit',
up: false,
down: false,
});
});
it('prevents plus only habit from scoring down'); // Yes?
it('prevents minus only habit from scoring up'); // Yes?
it('increases user\'s mp when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get('/user');
expect(updatedUser.stats.mp).to.be.greaterThan(user.stats.mp);
});
it('decreases user\'s mp when direction is down', async () => {
await user.post(`/tasks/${habit._id}/score/down`);
let updatedUser = await user.get('/user');
expect(updatedUser.stats.mp).to.be.lessThan(user.stats.mp);
});
it('increases user\'s exp when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get('/user');
expect(updatedUser.stats.exp).to.be.greaterThan(user.stats.exp);
});
it('increases user\'s gold when direction is up', async () => {
await user.post(`/tasks/${habit._id}/score/up`);
let updatedUser = await user.get('/user');
expect(updatedUser.stats.gp).to.be.greaterThan(user.stats.gp);
});
});
context('reward', () => {
let reward, updatedUser;
beforeEach(async () => {
reward = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
value: 5,
});
await user.post(`/tasks/${reward._id}/score/up`);
updatedUser = await user.get('/user');
});
it('purchases reward', () => {
expect(user.stats.gp).to.equal(updatedUser.stats.gp + 5);
});
it('does not change user\'s mp', () => {
expect(user.stats.mp).to.equal(updatedUser.stats.mp);
});
it('does not change user\'s exp', () => {
expect(user.stats.exp).to.equal(updatedUser.stats.exp);
});
it('does not allow a down direction', () => {
expect(user.stats.mp).to.equal(updatedUser.stats.mp);
});
});
});
test/api/v3/integration/tasks/POST-tasks_move_taskId_to_position.test.js
+84
View File
@@ -0,0 +1,84 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:taskId/move/to/:position', () => {
let user;
beforeEach(async () => {
user = await generateUser();
});
it('requires a valid taskId', async () => {
await expect(user.post('/tasks/123/move/to/1')).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('requires a numeric position parameter', async () => {
await expect(user.post(`/tasks/${generateUUID()}/move/to/notANumber`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidReqParams'),
});
});
it('taskId must match a valid task', async () => {
await expect(user.post(`/tasks/${generateUUID()}/move/to/1`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('can move task to new position', async () => {
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'habit', text: 'habit 2'},
{type: 'daily', text: 'daily 1'},
{type: 'habit', text: 'habit 3'},
{type: 'habit', text: 'habit 4'},
{type: 'todo', text: 'todo 1'},
{type: 'habit', text: 'habit 5'},
]);
let taskToMove = tasks[1];
expect(taskToMove.text).to.equal('habit 2');
let newOrder = await user.post(`/tasks/${tasks[1]._id}/move/to/3`);
expect(newOrder[3]).to.equal(taskToMove._id);
expect(newOrder.length).to.equal(5);
});
it('can\'t move completed todo', async () => {
let task = await user.post('/tasks/user', {type: 'todo', text: 'todo 1'});
await user.post(`/tasks/${task._id}/score/up`);
await expect(user.post(`/tasks/${task._id}/move/to/1`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('cantMoveCompletedTodo'),
});
});
it('can push to bottom', async () => {
let tasks = await user.post('/tasks/user', [
{type: 'habit', text: 'habit 1'},
{type: 'habit', text: 'habit 2'},
{type: 'daily', text: 'daily 1'},
{type: 'habit', text: 'habit 3'},
{type: 'habit', text: 'habit 4'},
{type: 'todo', text: 'todo 1'},
{type: 'habit', text: 'habit 5'},
]);
let taskToMove = tasks[1];
expect(taskToMove.text).to.equal('habit 2');
let newOrder = await user.post(`/tasks/${tasks[1]._id}/move/to/-1`);
expect(newOrder[4]).to.equal(taskToMove._id);
expect(newOrder.length).to.equal(5);
});
});
test/api/v3/integration/tasks/POST-tasks_user.test.js
+593
View File
@@ -0,0 +1,593 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/user', () => {
let user;
before(async () => {
user = await generateUser();
});
context('validates params', async () => {
it('returns an error if req.body.type is absent', async () => {
await expect(user.post('/tasks/user', {
notType: 'habit',
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidTaskType'),
});
});
it('returns an error if req.body.type is not valid', async () => {
await expect(user.post('/tasks/user', {
type: 'habitF',
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidTaskType'),
});
});
it('returns an error if one object inside an array is invalid', async () => {
await expect(user.post('/tasks/user', [
{type: 'habitF'},
{type: 'habit'},
])).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('invalidTaskType'),
});
});
it('returns an error if req.body.text is absent', async () => {
await expect(user.post('/tasks/user', {
type: 'habit',
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
});
});
it('does not update user.tasksOrder.{taskType} when the task is not saved because invalid', async () => {
let originalHabitsOrder = (await user.get('/user')).tasksOrder.habits;
await expect(user.post('/tasks/user', {
type: 'habit',
})).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
});
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
it('does not update user.tasksOrder.{taskType} when a task inside an array is not saved because invalid', async () => {
let originalHabitsOrder = (await user.get('/user')).tasksOrder.habits;
await expect(user.post('/tasks/user', [
{type: 'habit'}, // Missing text
{type: 'habit', text: 'valid'}, // Valid
])).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
});
let updatedHabitsOrder = (await user.get('/user')).tasksOrder.habits;
expect(updatedHabitsOrder).to.eql(originalHabitsOrder);
});
it('does not save any task sent in an array when 1 is invalid', async () => {
let originalTasks = await user.get('/tasks/user');
await expect(user.post('/tasks/user', [
{type: 'habit'}, // Missing text
{type: 'habit', text: 'valid'}, // Valid
])).to.eventually.be.rejected.and.eql({ // this block is necessary
code: 400,
error: 'BadRequest',
message: 'habit validation failed',
}).then(async () => {
let updatedTasks = await user.get('/tasks/user');
expect(updatedTasks).to.eql(originalTasks);
});
});
it('automatically sets "task.userId" to user\'s uuid', async () => {
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
expect(task.userId).to.equal(user._id);
});
it(`ignores setting userId, history, createdAt,
updatedAt, challenge, completed,
dateCompleted fields`, async () => {
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
userId: 123,
history: [123],
createdAt: 'yesterday',
updatedAt: 'tomorrow',
challenge: 'no',
completed: true,
dateCompleted: 'never',
value: 324, // ignored because not a reward
});
expect(task.userId).to.equal(user._id);
expect(task.history).to.eql([]);
expect(task.createdAt).not.to.equal('yesterday');
expect(task.updatedAt).not.to.equal('tomorrow');
expect(task.challenge).not.to.equal('no');
expect(task.completed).to.equal(false);
expect(task.streak).not.to.equal('never');
expect(task.value).not.to.equal(324);
});
it('ignores invalid fields', async () => {
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
notValid: true,
});
expect(task).not.to.have.property('notValid');
});
});
context('all types', () => {
it('can create reminders', async () => {
let id1 = generateUUID();
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
reminders: [
{id: id1, startDate: new Date(), time: new Date()},
],
});
expect(task.reminders).to.be.an('array');
expect(task.reminders.length).to.eql(1);
expect(task.reminders[0]).to.be.an('object');
expect(task.reminders[0].id).to.eql(id1);
expect(task.reminders[0].startDate).to.be.a('string'); // json doesn't have dates
expect(task.reminders[0].time).to.be.a('string');
});
});
context('habits', () => {
it('creates a habit', async () => {
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
});
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test habit');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('habit');
expect(task.up).to.eql(false);
expect(task.down).to.eql(true);
});
it('updates user.tasksOrder.habits when a new habit is created', async () => {
let originalHabitsOrderLen = (await user.get('/user')).tasksOrder.habits.length;
let task = await user.post('/tasks/user', {
type: 'habit',
text: 'an habit',
});
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.habits[0]).to.eql(task._id);
expect(updatedUser.tasksOrder.habits.length).to.eql(originalHabitsOrderLen + 1);
});
it('updates user.tasksOrder.habits when multiple habits are created', async () => {
let originalHabitsOrderLen = (await user.get('/user')).tasksOrder.habits.length;
let [task, task2] = await user.post('/tasks/user', [{
type: 'habit',
text: 'an habit',
}, {
type: 'habit',
text: 'another habit',
}]);
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.habits[0]).to.eql(task2._id);
expect(updatedUser.tasksOrder.habits[1]).to.eql(task._id);
expect(updatedUser.tasksOrder.habits.length).to.eql(originalHabitsOrderLen + 2);
});
it('creates multiple habits', async () => {
let [task, task2] = await user.post('/tasks/user', [{
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
}, {
text: 'test habit 2',
type: 'habit',
up: true,
down: false,
notes: 1977,
}]);
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test habit');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('habit');
expect(task.up).to.eql(false);
expect(task.down).to.eql(true);
expect(task2.userId).to.equal(user._id);
expect(task2.text).to.eql('test habit 2');
expect(task2.notes).to.eql('1977');
expect(task2.type).to.eql('habit');
expect(task2.up).to.eql(true);
expect(task2.down).to.eql(false);
});
it('defaults to setting up and down to true', async () => {
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
notes: 1976,
});
expect(task.up).to.eql(true);
expect(task.down).to.eql(true);
});
it('cannot create checklists', async () => {
let task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
checklist: [
{_id: 123, completed: false, text: 'checklist'},
],
});
expect(task).not.to.have.property('checklist');
});
});
context('todos', () => {
it('creates a todo', async () => {
let task = await user.post('/tasks/user', {
text: 'test todo',
type: 'todo',
notes: 1976,
});
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test todo');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('todo');
});
it('creates multiple todos', async () => {
let [task, task2] = await user.post('/tasks/user', [{
text: 'test todo',
type: 'todo',
notes: 1976,
}, {
text: 'test todo 2',
type: 'todo',
notes: 1977,
}]);
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test todo');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('todo');
expect(task2.userId).to.equal(user._id);
expect(task2.text).to.eql('test todo 2');
expect(task2.notes).to.eql('1977');
expect(task2.type).to.eql('todo');
});
it('updates user.tasksOrder.todos when a new todo is created', async () => {
let originalTodosOrderLen = (await user.get('/user')).tasksOrder.todos.length;
let task = await user.post('/tasks/user', {
type: 'todo',
text: 'a todo',
});
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.todos[0]).to.eql(task._id);
expect(updatedUser.tasksOrder.todos.length).to.eql(originalTodosOrderLen + 1);
});
it('updates user.tasksOrder.todos when multiple todos are created', async () => {
let originalTodosOrderLen = (await user.get('/user')).tasksOrder.todos.length;
let [task, task2] = await user.post('/tasks/user', [{
type: 'todo',
text: 'a todo',
}, {
type: 'todo',
text: 'another todo',
}]);
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.todos[0]).to.eql(task2._id);
expect(updatedUser.tasksOrder.todos[1]).to.eql(task._id);
expect(updatedUser.tasksOrder.todos.length).to.eql(originalTodosOrderLen + 2);
});
it('can create checklists', async () => {
let task = await user.post('/tasks/user', {
text: 'test todo',
type: 'todo',
checklist: [
{completed: false, text: 'checklist'},
],
});
expect(task.checklist).to.be.an('array');
expect(task.checklist.length).to.eql(1);
expect(task.checklist[0]).to.be.an('object');
expect(task.checklist[0].text).to.eql('checklist');
expect(task.checklist[0].completed).to.eql(false);
expect(task.checklist[0].id).to.be.a('string');
});
});
context('dailys', () => {
it('creates a daily', async () => {
let now = new Date();
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
notes: 1976,
frequency: 'daily',
everyX: 5,
startDate: now,
});
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test daily');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('daily');
expect(task.frequency).to.eql('daily');
expect(task.everyX).to.eql(5);
expect(new Date(task.startDate)).to.eql(now);
});
it('creates multiple dailys', async () => {
let [task, task2] = await user.post('/tasks/user', [{
text: 'test daily',
type: 'daily',
notes: 1976,
}, {
text: 'test daily 2',
type: 'daily',
notes: 1977,
}]);
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test daily');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('daily');
expect(task2.userId).to.equal(user._id);
expect(task2.text).to.eql('test daily 2');
expect(task2.notes).to.eql('1977');
expect(task2.type).to.eql('daily');
});
it('updates user.tasksOrder.dailys when a new daily is created', async () => {
let originalDailysOrderLen = (await user.get('/user')).tasksOrder.dailys.length;
let task = await user.post('/tasks/user', {
type: 'daily',
text: 'a daily',
});
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.dailys[0]).to.eql(task._id);
expect(updatedUser.tasksOrder.dailys.length).to.eql(originalDailysOrderLen + 1);
});
it('updates user.tasksOrder.dailys when multiple dailys are created', async () => {
let originalDailysOrderLen = (await user.get('/user')).tasksOrder.dailys.length;
let [task, task2] = await user.post('/tasks/user', [{
type: 'daily',
text: 'a daily',
}, {
type: 'daily',
text: 'another daily',
}]);
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.dailys[0]).to.eql(task2._id);
expect(updatedUser.tasksOrder.dailys[1]).to.eql(task._id);
expect(updatedUser.tasksOrder.dailys.length).to.eql(originalDailysOrderLen + 2);
});
it('defaults to a weekly frequency, with every day set', async () => {
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
});
expect(task.frequency).to.eql('weekly');
expect(task.everyX).to.eql(1);
expect(task.repeat).to.eql({
m: true,
t: true,
w: true,
th: true,
f: true,
s: true,
su: true,
});
});
it('allows repeat field to be configured', async () => {
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
repeat: {
m: false,
w: false,
su: false,
},
});
expect(task.repeat).to.eql({
m: false,
t: true,
w: false,
th: true,
f: true,
s: true,
su: false,
});
});
it('defaults startDate to today', async () => {
let today = (new Date()).getDay();
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
});
expect((new Date(task.startDate)).getDay()).to.eql(today);
});
it('can create checklists', async () => {
let task = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
checklist: [
{completed: false, text: 'checklist'},
],
});
expect(task.checklist).to.be.an('array');
expect(task.checklist.length).to.eql(1);
expect(task.checklist[0]).to.be.an('object');
expect(task.checklist[0].text).to.eql('checklist');
expect(task.checklist[0].completed).to.eql(false);
expect(task.checklist[0].id).to.be.a('string');
});
});
context('rewards', () => {
it('creates a reward', async () => {
let task = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
notes: 1976,
value: 10,
});
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test reward');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('reward');
expect(task.value).to.eql(10);
});
it('creates multiple rewards', async () => {
let [task, task2] = await user.post('/tasks/user', [{
text: 'test reward',
type: 'reward',
notes: 1976,
value: 11,
}, {
text: 'test reward 2',
type: 'reward',
notes: 1977,
value: 12,
}]);
expect(task.userId).to.equal(user._id);
expect(task.text).to.eql('test reward');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('reward');
expect(task.value).to.eql(11);
expect(task2.userId).to.equal(user._id);
expect(task2.text).to.eql('test reward 2');
expect(task2.notes).to.eql('1977');
expect(task2.type).to.eql('reward');
expect(task2.value).to.eql(12);
});
it('updates user.tasksOrder.rewards when a new reward is created', async () => {
let originalRewardsOrderLen = (await user.get('/user')).tasksOrder.rewards.length;
let task = await user.post('/tasks/user', {
type: 'reward',
text: 'a reward',
});
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.rewards[0]).to.eql(task._id);
expect(updatedUser.tasksOrder.rewards.length).to.eql(originalRewardsOrderLen + 1);
});
it('updates user.tasksOrder.dreward when multiple rewards are created', async () => {
let originalRewardsOrderLen = (await user.get('/user')).tasksOrder.rewards.length;
let [task, task2] = await user.post('/tasks/user', [{
type: 'reward',
text: 'a reward',
}, {
type: 'reward',
text: 'another reward',
}]);
let updatedUser = await user.get('/user');
expect(updatedUser.tasksOrder.rewards[0]).to.eql(task2._id);
expect(updatedUser.tasksOrder.rewards[1]).to.eql(task._id);
expect(updatedUser.tasksOrder.rewards.length).to.eql(originalRewardsOrderLen + 2);
});
it('defaults to a 0 value', async () => {
let task = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
});
expect(task.value).to.eql(0);
});
it('requires value to be coerced into a number', async () => {
let task = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
value: '10',
});
expect(task.value).to.eql(10);
});
it('cannot create checklists', async () => {
let task = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
checklist: [
{_id: 123, completed: false, text: 'checklist'},
],
});
expect(task).not.to.have.property('checklist');
});
});
});
test/api/v3/integration/tasks/PUT-tasks_challenge_challengeId.test.js
+323
View File
@@ -0,0 +1,323 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('PUT /tasks/:id', () => {
let user;
let guild;
let challenge;
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
context('errors', () => {
let task;
beforeEach(async () => {
task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
});
it('returns error when incorrect id is passed', async () => {
await expect(user.put(`/tasks/${generateUUID()}`, {
text: 'some new text',
up: false,
down: false,
notes: 'some new notes',
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('returns error when user is not a member of the challenge', async () => {
let anotherUser = await generateUser();
await expect(anotherUser.put(`/tasks/${task._id}`, {
text: 'some new text',
up: false,
down: false,
notes: 'some new notes',
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyChalLeaderEditTasks'),
});
});
});
context('validates params', () => {
let task;
beforeEach(async () => {
task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
});
it(`ignores setting _id, type, userId, history, createdAt,
updatedAt, challenge, completed, streak,
dateCompleted fields`, async () => {
let savedTask = await user.put(`/tasks/${task._id}`, {
_id: 123,
type: 'daily',
userId: 123,
history: [123],
createdAt: 'yesterday',
updatedAt: 'tomorrow',
challenge: 'no',
completed: true,
streak: 25,
dateCompleted: 'never',
value: 324, // ignored because not a reward
});
expect(savedTask._id).to.equal(task._id);
expect(savedTask.type).to.equal(task.type);
expect(savedTask.userId).to.equal(task.userId);
expect(savedTask.history).to.eql(task.history);
expect(savedTask.createdAt).to.equal(task.createdAt);
expect(savedTask.updatedAt).to.be.greaterThan(task.updatedAt);
expect(savedTask.challenge._id).to.equal(task.challenge._id);
expect(savedTask.completed).to.equal(task.completed);
expect(savedTask.streak).to.equal(task.streak);
expect(savedTask.dateCompleted).to.equal(task.dateCompleted);
expect(savedTask.value).to.equal(task.value);
});
it('ignores invalid fields', async () => {
let savedTask = await user.put(`/tasks/${task._id}`, {
notValid: true,
});
expect(savedTask.notValid).to.be.undefined;
});
});
context('habits', () => {
let habit;
beforeEach(async () => {
habit = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
notes: 1976,
});
});
it('updates a habit', async () => {
let savedHabit = await user.put(`/tasks/${habit._id}`, {
text: 'some new text',
up: false,
down: false,
notes: 'some new notes',
});
expect(savedHabit.text).to.eql('some new text');
expect(savedHabit.notes).to.eql('some new notes');
expect(savedHabit.up).to.eql(false);
expect(savedHabit.down).to.eql(false);
});
});
context('todos', () => {
let todo;
beforeEach(async () => {
todo = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test todo',
type: 'todo',
notes: 1976,
});
});
it('updates a todo', async () => {
let savedTodo = await user.put(`/tasks/${todo._id}`, {
text: 'some new text',
notes: 'some new notes',
});
expect(savedTodo.text).to.eql('some new text');
expect(savedTodo.notes).to.eql('some new notes');
});
it('can update checklists (replace it)', async () => {
await user.put(`/tasks/${todo._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
});
let savedTodo = await user.put(`/tasks/${todo._id}`, {
checklist: [
{text: 789, completed: false},
],
});
expect(savedTodo.checklist.length).to.equal(1);
expect(savedTodo.checklist[0].text).to.equal('789');
expect(savedTodo.checklist[0].completed).to.equal(false);
});
it('can update tags (replace them)', async () => {
let finalUUID = generateUUID();
await user.put(`/tasks/${todo._id}`, {
tags: [generateUUID(), generateUUID()],
});
let savedTodo = await user.put(`/tasks/${todo._id}`, {
tags: [finalUUID],
});
expect(savedTodo.tags.length).to.equal(1);
expect(savedTodo.tags[0]).to.equal(finalUUID);
});
});
context('dailys', () => {
let daily;
beforeEach(async () => {
daily = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test daily',
type: 'daily',
notes: 1976,
});
});
it('updates a daily', async () => {
let savedDaily = await user.put(`/tasks/${daily._id}`, {
text: 'some new text',
notes: 'some new notes',
frequency: 'daily',
everyX: 5,
});
expect(savedDaily.text).to.eql('some new text');
expect(savedDaily.notes).to.eql('some new notes');
expect(savedDaily.frequency).to.eql('daily');
expect(savedDaily.everyX).to.eql(5);
});
it('can update checklists (replace it)', async () => {
await user.put(`/tasks/${daily._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
checklist: [
{text: 789, completed: false},
],
});
expect(savedDaily.checklist.length).to.equal(1);
expect(savedDaily.checklist[0].text).to.equal('789');
expect(savedDaily.checklist[0].completed).to.equal(false);
});
it('can update tags (replace them)', async () => {
let finalUUID = generateUUID();
await user.put(`/tasks/${daily._id}`, {
tags: [generateUUID(), generateUUID()],
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
tags: [finalUUID],
});
expect(savedDaily.tags.length).to.equal(1);
expect(savedDaily.tags[0]).to.equal(finalUUID);
});
it('updates repeat, even if frequency is set to daily', async () => {
await user.put(`/tasks/${daily._id}`, {
frequency: 'daily',
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
repeat: {
m: false,
su: false,
},
});
expect(savedDaily.repeat).to.eql({
m: false,
t: true,
w: true,
th: true,
f: true,
s: true,
su: false,
});
});
it('updates everyX, even if frequency is set to weekly', async () => {
await user.put(`/tasks/${daily._id}`, {
frequency: 'weekly',
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
everyX: 5,
});
expect(savedDaily.everyX).to.eql(5);
});
it('defaults startDate to today if none date object is passed in', async () => {
let savedDaily = await user.put(`/tasks/${daily._id}`, {
frequency: 'weekly',
});
expect((new Date(savedDaily.startDate)).getDay()).to.eql((new Date()).getDay());
});
});
context('rewards', () => {
let reward;
beforeEach(async () => {
reward = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test reward',
type: 'reward',
notes: 1976,
value: 10,
});
});
it('updates a reward', async () => {
let savedReward = await user.put(`/tasks/${reward._id}`, {
text: 'some new text',
notes: 'some new notes',
value: 11,
});
expect(savedReward.text).to.eql('some new text');
expect(savedReward.notes).to.eql('some new notes');
expect(savedReward.value).to.eql(11);
});
it('requires value to be coerced into a number', async () => {
let savedReward = await user.put(`/tasks/${reward._id}`, {
value: '100',
});
expect(savedReward.value).to.eql(100);
});
});
});
test/api/v3/integration/tasks/PUT-tasks_id.test.js
+396
View File
@@ -0,0 +1,396 @@
import {
generateUser,
generateGroup,
sleep,
generateChallenge,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('PUT /tasks/:id', () => {
let user;
before(async () => {
user = await generateUser();
});
context('validates params', () => {
let task;
beforeEach(async () => {
task = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
});
});
it(`ignores setting _id, type, userId, history, createdAt,
updatedAt, challenge, completed, streak,
dateCompleted fields`, async () => {
let savedTask = await user.put(`/tasks/${task._id}`, {
_id: 123,
type: 'daily',
userId: 123,
history: [123],
createdAt: 'yesterday',
updatedAt: 'tomorrow',
challenge: 'no',
completed: true,
streak: 25,
dateCompleted: 'never',
});
expect(savedTask._id).to.equal(task._id);
expect(savedTask.type).to.equal(task.type);
expect(savedTask.userId).to.equal(task.userId);
expect(savedTask.history).to.eql(task.history);
expect(savedTask.createdAt).to.equal(task.createdAt);
expect(savedTask.updatedAt).to.be.greaterThan(task.updatedAt);
expect(savedTask.challenge).to.equal(task.challenge);
expect(savedTask.completed).to.eql(task.completed);
expect(savedTask.streak).to.equal(savedTask.streak); // it's an habit, dailies can change it
expect(savedTask.dateCompleted).to.equal(task.dateCompleted);
});
it('ignores invalid fields', async () => {
let savedTask = await user.put(`/tasks/${task._id}`, {
notValid: true,
});
expect(savedTask.notValid).to.be.undefined;
});
it(`only allows setting streak, reminders, checklist, notes, attribute, tags
fields for challenge tasks owned by a user`, async () => {
let guild = await generateGroup(user);
let challenge = await generateChallenge(user, guild);
let challengeTask = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'Daily in challenge',
reminders: [
{time: new Date(), startDate: new Date()},
],
checklist: [
{text: 123, completed: false},
],
});
await sleep(2);
await user.sync();
// Pick challenge task
let challengeUserTaskId = user.tasksOrder.dailys[user.tasksOrder.dailys.length - 1];
let challengeUserTask = await user.get(`/tasks/${challengeUserTaskId}`);
let savedChallengeUserTask = await user.put(`/tasks/${challengeUserTaskId}`, {
_id: 123,
type: 'daily',
userId: 123,
history: [123],
createdAt: 'yesterday',
updatedAt: 'tomorrow',
challenge: 'no',
completed: true,
streak: 25,
priority: 1.5,
repeat: {
m: false,
},
everyX: 15,
frequency: 'weekly',
text: 'new text',
dateCompleted: 'never',
reminders: [
{time: new Date(), startDate: new Date()},
{time: new Date(), startDate: new Date()},
],
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
notes: 'new notes',
attribute: 'per',
tags: [challengeUserTaskId],
});
// original task is not touched
let updatedChallengeTask = await user.get(`/tasks/${challengeTask._id}`);
expect(updatedChallengeTask).to.eql(challengeTask);
// ignored
expect(savedChallengeUserTask._id).to.equal(challengeUserTask._id);
expect(savedChallengeUserTask.type).to.equal(challengeUserTask.type);
expect(savedChallengeUserTask.repeat.m).to.equal(true);
expect(savedChallengeUserTask.priority).to.equal(challengeUserTask.priority);
expect(savedChallengeUserTask.frequency).to.equal(challengeUserTask.frequency);
expect(savedChallengeUserTask.userId).to.equal(challengeUserTask.userId);
expect(savedChallengeUserTask.text).to.equal(challengeUserTask.text);
expect(savedChallengeUserTask.history).to.eql(challengeUserTask.history);
expect(savedChallengeUserTask.createdAt).to.equal(challengeUserTask.createdAt);
expect(savedChallengeUserTask.updatedAt).to.be.greaterThan(challengeUserTask.updatedAt);
expect(savedChallengeUserTask.challenge).to.eql(challengeUserTask.challenge);
expect(savedChallengeUserTask.completed).to.equal(challengeUserTask.completed);
expect(savedChallengeUserTask.dateCompleted).to.equal(challengeUserTask.dateCompleted);
expect(savedChallengeUserTask.priority).to.equal(challengeUserTask.priority);
// changed
expect(savedChallengeUserTask.notes).to.equal('new notes');
expect(savedChallengeUserTask.attribute).to.equal('per');
expect(savedChallengeUserTask.tags).to.eql([challengeUserTaskId]);
expect(savedChallengeUserTask.streak).to.equal(25);
expect(savedChallengeUserTask.reminders.length).to.equal(2);
expect(savedChallengeUserTask.checklist.length).to.equal(2);
});
});
context('all types', () => {
let daily;
beforeEach(async () => {
daily = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
notes: 1976,
});
});
it('can update reminders (replace them)', async () => {
await user.put(`/tasks/${daily._id}`, {
reminders: [
{time: new Date(), startDate: new Date()},
],
});
let id1 = generateUUID();
let id2 = generateUUID();
let savedDaily = await user.put(`/tasks/${daily._id}`, {
reminders: [
{id: id1, time: new Date(), startDate: new Date()},
{id: id2, time: new Date(), startDate: new Date()},
],
});
expect(savedDaily.reminders.length).to.equal(2);
expect(savedDaily.reminders[0].id).to.equal(id1);
expect(savedDaily.reminders[1].id).to.equal(id2);
});
});
context('habits', () => {
let habit;
beforeEach(async () => {
habit = await user.post('/tasks/user', {
text: 'test habit',
type: 'habit',
notes: 1976,
});
});
it('updates a habit', async () => {
let savedHabit = await user.put(`/tasks/${habit._id}`, {
text: 'some new text',
up: false,
down: false,
notes: 'some new notes',
});
expect(savedHabit.text).to.eql('some new text');
expect(savedHabit.notes).to.eql('some new notes');
expect(savedHabit.up).to.eql(false);
expect(savedHabit.down).to.eql(false);
});
});
context('todos', () => {
let todo;
beforeEach(async () => {
todo = await user.post('/tasks/user', {
text: 'test todo',
type: 'todo',
notes: 1976,
});
});
it('updates a todo', async () => {
let savedTodo = await user.put(`/tasks/${todo._id}`, {
text: 'some new text',
notes: 'some new notes',
});
expect(savedTodo.text).to.eql('some new text');
expect(savedTodo.notes).to.eql('some new notes');
});
it('can update checklists (replace it)', async () => {
await user.put(`/tasks/${todo._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
});
let savedTodo = await user.put(`/tasks/${todo._id}`, {
checklist: [
{text: 789, completed: false},
],
});
expect(savedTodo.checklist.length).to.equal(1);
expect(savedTodo.checklist[0].text).to.equal('789');
expect(savedTodo.checklist[0].completed).to.equal(false);
});
it('can update tags (replace them)', async () => {
let finalUUID = generateUUID();
await user.put(`/tasks/${todo._id}`, {
tags: [generateUUID(), generateUUID()],
});
let savedTodo = await user.put(`/tasks/${todo._id}`, {
tags: [finalUUID],
});
expect(savedTodo.tags.length).to.equal(1);
expect(savedTodo.tags[0]).to.equal(finalUUID);
});
});
context('dailys', () => {
let daily;
beforeEach(async () => {
daily = await user.post('/tasks/user', {
text: 'test daily',
type: 'daily',
notes: 1976,
});
});
it('updates a daily', async () => {
let savedDaily = await user.put(`/tasks/${daily._id}`, {
text: 'some new text',
notes: 'some new notes',
frequency: 'daily',
everyX: 5,
});
expect(savedDaily.text).to.eql('some new text');
expect(savedDaily.notes).to.eql('some new notes');
expect(savedDaily.frequency).to.eql('daily');
expect(savedDaily.everyX).to.eql(5);
});
it('can update checklists (replace it)', async () => {
await user.put(`/tasks/${daily._id}`, {
checklist: [
{text: 123, completed: false},
{text: 456, completed: true},
],
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
checklist: [
{text: 789, completed: false},
],
});
expect(savedDaily.checklist.length).to.equal(1);
expect(savedDaily.checklist[0].text).to.equal('789');
expect(savedDaily.checklist[0].completed).to.equal(false);
});
it('can update tags (replace them)', async () => {
let finalUUID = generateUUID();
await user.put(`/tasks/${daily._id}`, {
tags: [generateUUID(), generateUUID()],
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
tags: [finalUUID],
});
expect(savedDaily.tags.length).to.equal(1);
expect(savedDaily.tags[0]).to.equal(finalUUID);
});
it('updates repeat, even if frequency is set to daily', async () => {
await user.put(`/tasks/${daily._id}`, {
frequency: 'daily',
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
repeat: {
m: false,
su: false,
},
});
expect(savedDaily.repeat).to.eql({
m: false,
t: true,
w: true,
th: true,
f: true,
s: true,
su: false,
});
});
it('updates everyX, even if frequency is set to weekly', async () => {
await user.put(`/tasks/${daily._id}`, {
frequency: 'weekly',
});
let savedDaily = await user.put(`/tasks/${daily._id}`, {
everyX: 5,
});
expect(savedDaily.everyX).to.eql(5);
});
it('defaults startDate to today if none date object is passed in', async () => {
let savedDaily = await user.put(`/tasks/${daily._id}`, {
frequency: 'weekly',
});
expect((new Date(savedDaily.startDate)).getDay()).to.eql((new Date()).getDay());
});
});
context('rewards', () => {
let reward;
beforeEach(async () => {
reward = await user.post('/tasks/user', {
text: 'test reward',
type: 'reward',
notes: 1976,
value: 10,
});
});
it('updates a reward', async () => {
let savedReward = await user.put(`/tasks/${reward._id}`, {
text: 'some new text',
notes: 'some new notes',
value: 10,
});
expect(savedReward.text).to.eql('some new text');
expect(savedReward.notes).to.eql('some new notes');
expect(savedReward.value).to.eql(10);
});
it('requires value to be coerced into a number', async () => {
let savedReward = await user.put(`/tasks/${reward._id}`, {
value: '100',
});
expect(savedReward.value).to.eql(100);
});
});
});
test/api/v3/integration/tasks/challenges/DELETE-tasks_challenge_challengeId_checklist_itemId.test.js
+115
View File
@@ -0,0 +1,115 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /tasks/:taskId/checklist/:itemId', () => {
let user;
let guild;
let challenge;
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
it('fails on task not found', async () => {
await expect(user.del(`/tasks/${generateUUID()}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('fails on checklist item not found', async () => {
let createdTask = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'daily with checklist',
});
await expect(user.del(`/tasks/${createdTask._id}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('checklistItemNotFound'),
});
});
it('returns error when user is not a member of the challenge', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'Daily with checklist',
});
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
text: 'Checklist Item 1',
completed: false,
});
let anotherUser = await generateUser();
await expect(anotherUser.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0].id}`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyChalLeaderEditTasks'),
});
});
it('deletes a checklist item from a daily', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'Daily with checklist',
});
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
await user.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0].id}`);
savedTask = await user.get(`/tasks/${task._id}`);
expect(savedTask.checklist.length).to.equal(0);
});
it('deletes a checklist item from a todo', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'todo',
text: 'Todo with checklist',
});
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {text: 'Checklist Item 1', completed: false});
await user.del(`/tasks/${task._id}/checklist/${savedTask.checklist[0].id}`);
savedTask = await user.get(`/tasks/${task._id}`);
expect(savedTask.checklist.length).to.equal(0);
});
it('does not work with habits', async () => {
let habit = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'habit',
text: 'habit with checklist',
});
await expect(user.del(`/tasks/${habit._id}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('checklistOnlyDailyTodo'),
});
});
it('does not work with rewards', async () => {
let reward = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'reward',
text: 'reward with checklist',
});
await expect(user.del(`/tasks/${reward._id}/checklist/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('checklistOnlyDailyTodo'),
});
});
});
test/api/v3/integration/tasks/challenges/DELETE-tasks_id_challenge_challengeId.test.js
+115
View File
@@ -0,0 +1,115 @@
import {
generateUser,
generateGroup,
generateChallenge,
sleep,
translate as t,
} from '../../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /tasks/:id', () => {
let user;
let guild;
let challenge;
let task;
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
beforeEach(async () => {
task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
});
it('cannot delete a non-existant task', async () => {
await expect(user.del(`/tasks/${generateUUID()}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('returns error when user is not leader of the challenge', async () => {
let anotherUser = await generateUser();
await expect(anotherUser.del(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyChalLeaderEditTasks'),
});
});
it('deletes a user\'s task', async () => {
await user.del(`/tasks/${task._id}`);
await expect(user.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
context('challenge member', () => {
let anotherUser;
let anotherUsersNewChallengeTaskID;
let newChallengeTask;
beforeEach(async () => {
anotherUser = await generateUser();
await user.post(`/groups/${guild._id}/invite`, { uuids: [anotherUser._id] });
await anotherUser.post(`/groups/${guild._id}/join`);
await anotherUser.post(`/challenges/${challenge._id}/join`);
newChallengeTask = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
let anotherUserWithNewChallengeTask = await anotherUser.get('/user');
anotherUsersNewChallengeTaskID = anotherUserWithNewChallengeTask.tasksOrder.habits[0];
});
it('returns error when user attempts to delete an active challenge task', async () => {
await expect(anotherUser.del(`/tasks/${anotherUsersNewChallengeTaskID}`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('cantDeleteChallengeTasks'),
});
});
it('allows user to delete challenge task after user leaves challenge', async () => {
await anotherUser.post(`/challenges/${challenge._id}/leave`);
await anotherUser.del(`/tasks/${anotherUsersNewChallengeTaskID}`);
await expect(anotherUser.get(`/tasks/${task._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
// TODO for some reason this test fails on TravisCI, review after mongodb indexes have been added
xit('allows user to delete challenge task after challenge task is broken', async () => {
await expect(user.del(`/tasks/${newChallengeTask._id}`));
await sleep(2);
await expect(anotherUser.del(`/tasks/${anotherUsersNewChallengeTaskID}`));
await sleep(2);
await expect(anotherUser.get(`/tasks/${anotherUsersNewChallengeTaskID}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
});
});
test/api/v3/integration/tasks/challenges/GET_tasks_challenge.id.test.js
+86
View File
@@ -0,0 +1,86 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
import { each } from 'lodash';
describe('GET /tasks/challenge/:challengeId', () => {
let user;
let guild;
let challenge;
let task;
let tasks = [];
let challengeWithTask;
let tasksToTest = {
habit: {
text: 'test habit',
type: 'habit',
up: false,
down: true,
},
todo: {
text: 'test todo',
type: 'todo',
},
daily: {
text: 'test daily',
type: 'daily',
frequency: 'daily',
everyX: 5,
startDate: new Date(),
},
reward: {
text: 'test reward',
type: 'reward',
},
};
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
it('returns error when challenge is not found', async () => {
let dummyId = generateUUID();
await expect(user.get(`/tasks/challenge/${dummyId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
each(tasksToTest, (taskValue, taskType) => {
context(`${taskType}`, () => {
before(async () => {
task = await user.post(`/tasks/challenge/${challenge._id}`, taskValue);
tasks.push(task);
challengeWithTask = await user.get(`/challenges/${challenge._id}`);
});
it('gets challenge tasks', async () => {
let getTask = await user.get(`/tasks/challenge/${challengeWithTask._id}`);
expect(getTask).to.eql(tasks);
});
it('gets challenge tasks filtered by type', async () => {
let challengeTasks = await user.get(`/tasks/challenge/${challengeWithTask._id}?type=${task.type}s`);
expect(challengeTasks).to.eql([task]);
});
it('cannot get a task owned by someone else', async () => {
let anotherUser = await generateUser();
await expect(anotherUser.get(`/tasks/challenge/${challengeWithTask._id}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
});
});
});
test/api/v3/integration/tasks/challenges/POST-tasks_challenge_challengeId_taskId_checklist.test.js
+119
View File
@@ -0,0 +1,119 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/:taskId/checklist/', () => {
let user;
let guild;
let challenge;
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
it('fails on task not found', async () => {
await expect(user.post(`/tasks/${generateUUID()}/checklist`, {
text: 'Checklist Item 1',
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('taskNotFound'),
});
});
it('returns error when user is not a member of the challenge', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'Daily with checklist',
});
let anotherUser = await generateUser();
await expect(anotherUser.post(`/tasks/${task._id}/checklist`, {
text: 'Checklist Item 1',
ignored: false,
_id: 123,
}))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyChalLeaderEditTasks'),
});
});
it('adds a checklist item to a daily', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'daily',
text: 'Daily with checklist',
});
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
text: 'Checklist Item 1',
ignored: false,
_id: 123,
});
expect(savedTask.checklist.length).to.equal(1);
expect(savedTask.checklist[0].text).to.equal('Checklist Item 1');
expect(savedTask.checklist[0].completed).to.equal(false);
expect(savedTask.checklist[0].id).to.be.a('string');
expect(savedTask.checklist[0].id).to.not.equal('123');
expect(savedTask.checklist[0].ignored).to.be.an('undefined');
});
it('adds a checklist item to a todo', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'todo',
text: 'Todo with checklist',
});
let savedTask = await user.post(`/tasks/${task._id}/checklist`, {
text: 'Checklist Item 1',
ignored: false,
_id: 123,
});
expect(savedTask.checklist.length).to.equal(1);
expect(savedTask.checklist[0].text).to.equal('Checklist Item 1');
expect(savedTask.checklist[0].completed).to.equal(false);
expect(savedTask.checklist[0].id).to.be.a('string');
expect(savedTask.checklist[0].id).to.not.equal('123');
expect(savedTask.checklist[0].ignored).to.be.an('undefined');
});
it('does not add a checklist to habits', async () => {
let habit = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'habit',
text: 'habit with checklist',
});
await expect(user.post(`/tasks/${habit._id}/checklist`, {
text: 'Checklist Item 1',
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('checklistOnlyDailyTodo'),
});
});
it('does not add a checklist to rewards', async () => {
let reward = await user.post(`/tasks/challenge/${challenge._id}`, {
type: 'reward',
text: 'reward with checklist',
});
await expect(user.post(`/tasks/${reward._id}/checklist`, {
text: 'Checklist Item 1',
})).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('checklistOnlyDailyTodo'),
});
});
});
test/api/v3/integration/tasks/challenges/POST-tasks_challenge_id.test.js
+125
View File
@@ -0,0 +1,125 @@
import {
generateUser,
generateGroup,
generateChallenge,
translate as t,
} from '../../../../../helpers/api-v3-integration.helper';
import { v4 as generateUUID } from 'uuid';
describe('POST /tasks/challenge/:challengeId', () => {
let user;
let guild;
let challenge;
beforeEach(async () => {
user = await generateUser({balance: 1});
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
it('returns error when challenge is not found', async () => {
let fakeChallengeId = generateUUID();
await expect(user.post(`/tasks/challenge/${fakeChallengeId}`, {
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('returns error when user does not have the challenge', async () => {
let userWithoutChallenge = await generateUser();
await expect(userWithoutChallenge.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
})).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('challengeNotFound'),
});
});
it('returns error when non leader tries to edit challenge', async () => {
let userThatIsNotLeaderOfChallenge = await generateUser({
challenges: [challenge._id],
});
await expect(userThatIsNotLeaderOfChallenge.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
})).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('onlyChalLeaderEditTasks'),
});
});
it('creates a habit', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
up: false,
down: true,
notes: 1976,
});
let challengeWithTask = await user.get(`/challenges/${challenge._id}`);
expect(challengeWithTask.tasksOrder.habits.indexOf(task._id)).to.be.above(-1);
expect(task.challenge.id).to.equal(challenge._id);
expect(task.text).to.eql('test habit');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('habit');
expect(task.up).to.eql(false);
expect(task.down).to.eql(true);
});
it('creates a todo', async () => {
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test todo',
type: 'todo',
notes: 1976,
});
let challengeWithTask = await user.get(`/challenges/${challenge._id}`);
expect(challengeWithTask.tasksOrder.todos.indexOf(task._id)).to.be.above(-1);
expect(task.challenge.id).to.equal(challenge._id);
expect(task.text).to.eql('test todo');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('todo');
});
it('creates a daily', async () => {
let now = new Date();
let task = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test daily',
type: 'daily',
notes: 1976,
frequency: 'daily',
everyX: 5,
startDate: now,
});
let challengeWithTask = await user.get(`/challenges/${challenge._id}`);
expect(challengeWithTask.tasksOrder.dailys.indexOf(task._id)).to.be.above(-1);
expect(task.challenge.id).to.equal(challenge._id);
expect(task.text).to.eql('test daily');
expect(task.notes).to.eql('1976');
expect(task.type).to.eql('daily');
expect(task.frequency).to.eql('daily');
expect(task.everyX).to.eql(5);
expect(new Date(task.startDate)).to.eql(now);
});
});
test/api/v3/integration/tasks/challenges/POST-tasks_challenges_challengeId_tasks_id_score_direction.test.js
+140
View File
@@ -0,0 +1,140 @@
import {
generateUser,
generateGroup,
generateChallenge,
} from '../../../../../helpers/api-integration/v3';
import { find } from 'lodash';
describe('POST /tasks/:id/score/:direction', () => {
let user;
let guild;
let challenge;
before(async () => {
user = await generateUser();
guild = await generateGroup(user);
challenge = await generateChallenge(user, guild);
});
context('habits', () => {
let habit;
let usersChallengeTaskId;
let previousTaskHistory;
before(async () => {
habit = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test habit',
type: 'habit',
});
let updatedUser = await user.get('/user');
usersChallengeTaskId = updatedUser.tasksOrder.habits[0];
});
it('scores and adds history', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: habit._id});
previousTaskHistory = task.history[0];
expect(task.value).to.equal(1);
expect(task.history).to.have.lengthOf(1);
});
it('should update the history', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: habit._id});
expect(task.history).to.have.lengthOf(1);
expect(task.history[0].date).to.not.equal(previousTaskHistory.date);
expect(task.history[0].value).to.not.equal(previousTaskHistory.value);
});
});
context('dailies', () => {
let daily;
let usersChallengeTaskId;
let previousTaskHistory;
before(async () => {
daily = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test daily',
type: 'daily',
});
let updatedUser = await user.get('/user');
usersChallengeTaskId = updatedUser.tasksOrder.dailys[0];
});
it('it scores and adds history', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: daily._id});
previousTaskHistory = task.history[0];
expect(task.history).to.have.lengthOf(1);
expect(task.value).to.equal(1);
});
it('should update the history', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: daily._id});
expect(task.history).to.have.lengthOf(1);
expect(task.history[0].date).to.not.equal(previousTaskHistory.date);
expect(task.history[0].value).to.not.equal(previousTaskHistory.value);
});
});
context('todos', () => {
let todo;
let usersChallengeTaskId;
before(async () => {
todo = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test todo',
type: 'todo',
});
let updatedUser = await user.get('/user');
usersChallengeTaskId = updatedUser.tasksOrder.todos[0];
});
it('scores but does not add history', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: todo._id});
expect(task.history).to.not.exist;
expect(task.value).to.equal(1);
});
});
context('rewards', () => {
let reward;
let usersChallengeTaskId;
before(async () => {
reward = await user.post(`/tasks/challenge/${challenge._id}`, {
text: 'test reward',
type: 'reward',
});
let updatedUser = await user.get('/user');
usersChallengeTaskId = updatedUser.tasksOrder.todos[0];
});
it('does not score', async () => {
await user.post(`/tasks/${usersChallengeTaskId}/score/up`);
let tasks = await user.get(`/tasks/challenge/${challenge._id}`);
let task = find(tasks, {_id: reward._id});
expect(task.history).to.not.exist;
expect(task.value).to.equal(0);
});
});
});

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