Merge pull request #6600 from KristianTashkov/challenge-winner-tests

Challenge select winner route tests

test/api/v3/integration/challenges/POST-challenges_challengeId_winner_winnerId.test.js

@@ -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);
+    });
+  });
+});

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

@@ -438,9 +438,9 @@ api.deleteChallenge = {
 };
 
 /**
- * @api {delete} /challenges/:challengeId Delete a challenge
+ * @api {post} /challenges/:challengeId/selectWinner/:winnerId Select winner for challenge
  * @apiVersion 3.0.0
- * @apiName DeleteChallenge
+ * @apiName SelectChallengeWinner
  * @apiGroup Challenge
  *
  * @apiSuccess {object} empty An empty object
@@ -452,7 +452,7 @@ api.selectChallengeWinner = {
   async handler (req, res) {
     let user = res.locals.user;
 
-    req.checkParams('challenge', res.t('challengeIdRequired')).notEmpty().isUUID();
+    req.checkParams('challengeId', res.t('challengeIdRequired')).notEmpty().isUUID();
     req.checkParams('winnerId', res.t('winnerIdRequired')).notEmpty().isUUID();
 
     let validationErrors = req.validationErrors();
@@ -463,11 +463,11 @@ api.selectChallengeWinner = {
     if (!challenge.canModify(user)) throw new NotAuthorized(res.t('onlyLeaderDeleteChal'));
 
     let winner = await User.findOne({_id: req.params.winnerId}).exec();
-    if (!winner || winner.challenges.indexOf(challenge._id) === -1) throw new NotFound(res.t('winnerNotFound', {userId: req.parama.winnerId}));
+    if (!winner || winner.challenges.indexOf(challenge._id) === -1) throw new NotFound(res.t('winnerNotFound', {userId: req.params.winnerId}));
 
     res.respond(200, {});
     // Close channel in background
-    _closeChal(challenge, {broken: 'CHALLENGE_DELETED', winner});
+    _closeChal(challenge, {broken: 'CHALLENGE_CLOSED', winner});
   },
 };