update quest leave route

test/api/v3/integration/quests/POST-groups_groupid_quests_leave.test.js

@@ -1,85 +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, member, leader;
+  let questingGroup;
-  const PET_QUEST = 'whale';
+  let partyMembers;
-  let userQuestUpdate = {
+  let user;
-    items: {
+  let leader;
-      quests: {},
-    },
-    'party.quest.RSVPNeeded': true,
-    'party.quest.key': PET_QUEST,
-  };
 
-  before(async () => {
+  const PET_QUEST = 'whale';
+
+  beforeEach(async () => {
     let { group, groupLeader, members } = await createAndPopulateGroup({
       groupDetails: { type: 'party', privacy: 'private' },
-      members: 1,
+      members: 2,
     });
 
-    leader = groupLeader;
     questingGroup = group;
-    member = members[0];
+    leader = groupLeader;
+    partyMembers = members;
 
-    userQuestUpdate.items.quests[PET_QUEST] = 1;
+    await leader.update({
+      [`items.quests.${PET_QUEST}`]: 1,
+    });
+    user = await generateUser();
   });
 
-  it('returns an error when group is not found', async () => {
+  context('failure conditions', () => {
-    await expect(member.post(`/groups/${generateUUID()}/quests/leave`))
+    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 quest is  not active', async () => {
+    it('returns an error when group is a guild', async () => {
-    await expect(member.post(`/groups/${questingGroup._id}/quests/leave`))
+      let { group: guild, groupLeader: guildLeader } = await createAndPopulateGroup({
-      .to.eventually.be.rejected.and.eql({
+        groupDetails: { type: 'guild', privacy: 'private' },
-        code: 404,
-        error: 'NotFound',
-        message: t('noActiveQuestToLeave'),
       });
-  });
 
-  it('returns an error when quest leader attempts to leave', async () => {
+      await expect(guildLeader.post(`/groups/${guild._id}/quests/leave`))
-    await questingGroup.update({quest: {key: PET_QUEST, active: true, leader: leader._id}});
-
-    await expect(leader.post(`/groups/${questingGroup._id}/quests/leave`))
       .to.eventually.be.rejected.and.eql({
         code: 401,
         error: 'NotAuthorized',
-        message: t('questLeaderCannotLeaveQuest'),
+        message: t('guildQuestsNotSupported'),
       });
-  });
+    });
 
-  it('returns an error when non quest member attempts to leave', async () => {
+    it('returns an error when quest is not active', async () => {
-    await expect(member.post(`/groups/${questingGroup._id}/quests/leave`))
+      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[0].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 member.update(userQuestUpdate);
+    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 questMembers = {};
+    let leaveResult = await partyMembers[0].post(`/groups/${questingGroup._id}/quests/leave`);
-    questMembers[member._id] = true;
+    await Promise.all([
-    await questingGroup.update({'quest.members': questMembers});
+      partyMembers[0].sync(),
+      questingGroup.sync(),
+    ]);
 
-    let leaveResult = await member.post(`/groups/${questingGroup._id}/quests/leave`);
+    expect(partyMembers[0].party.quest).to.eql({
-    let userThatLeft = await member.get('/user');
+      key: null,
-    let updatedGroup = await member.get(`/groups/${questingGroup._id}`);
+      progress: {
-
+        up: 0,
-    expect(userThatLeft.party.quest.key).to.be.null;
+        down: 0,
-    expect(userThatLeft.party.quest.RSVPNeeded).to.be.false;
+        collect: {},
-    expect(updatedGroup.quest.members[member._id]).to.be.false;
+      },
-    expect(updatedGroup.quest).to.deep.equal(leaveResult);
+      completed: null,
+      RSVPNeeded: false,
+    });
+    expect(questingGroup.quest).to.deep.equal(leaveResult);
+    expect(questingGroup.quest.members[partyMembers[0]._id]).to.be.false;
   });
 });

website/src/controllers/api-v3/quests.js

@@ -19,7 +19,6 @@ import {
   sendTxn as sendTxnEmail,
 } from '../../libs/api-v3/email';
 import { quests as questScrolls } from '../../../../common/script/content';
-import Q from 'q';
 
 function canStartQuestAutomatically (group)  {
   // If all members are either true (accepted) or false (rejected) return true
@@ -184,14 +183,14 @@ api.acceptQuest = {
 };
 
 /**
- * @api {post} /groups/:groupId/quests/leave Leaves a quest
+ * @api {post} /groups/:groupId/quests/leave Leaves the active quest
  * @apiVersion 3.0.0
  * @apiName LeaveQuest
  * @apiGroup Group
  *
  * @apiParam {string} groupId The group _id (or 'party')
  *
- * @apiSuccess {Object} Empty Object
+ * @apiSuccess {Object} quest Quest Object
  */
 api.leaveQuest = {
   method: 'POST',
@@ -207,19 +206,12 @@ api.leaveQuest = {
     if (validationErrors) throw validationErrors;
 
     let group = await Group.getGroup({user, groupId, fields: 'type quest'});
+
     if (!group) throw new NotFound(res.t('groupNotFound'));
-
+    if (group.type !== 'party') throw new NotAuthorized(res.t('guildQuestsNotSupported'));
-    if (!(group.quest && group.quest.active)) {
+    if (!group.quest.active) throw new NotFound(res.t('noActiveQuestToLeave'));
-      throw new NotFound(res.t('noActiveQuestToLeave'));
+    if (group.quest.leader === user._id) throw new NotAuthorized(res.t('questLeaderCannotLeaveQuest'));
-    }
+    if (!group.quest.members[user._id]) throw new NotAuthorized(res.t('notPartOfQuest'));
-
-    if (group.quest.leader === user._id) {
-      throw new NotAuthorized(res.t('questLeaderCannotLeaveQuest'));
-    }
-
-    if (!(group.quest.members && group.quest.members[user._id])) {
-      throw new NotAuthorized(res.t('notPartOfQuest'));
-    }
 
     group.quest.members[user._id] = false;
     group.markModified('quest.members');