Filter challenge by owned (#12527)

* when filtering by owned challenges, challenges that a user owns but has not joined will be included

* add tests for filtering challenges by owned

* fix lint

test/api/v3/integration/challenges/GET-challenges_user.test.js

@@ -6,8 +6,8 @@ import {
 
 describe('GET challenges/user', () => {
   context('no official challenges', () => {
-    let user; let member; let nonMember; let challenge; let challenge2; let
+    let user; let member; let nonMember; let challenge; let challenge2;
-      publicGuild;
+    let publicGuild; let userData; let groupData;
 
     before(async () => {
       const { group, groupLeader, members } = await createAndPopulateGroup({
@@ -19,25 +19,20 @@ describe('GET challenges/user', () => {
         members: 1,
       });
 
-      user = groupLeader;
       publicGuild = group;
-      member = members[0]; // eslint-disable-line prefer-destructuring
+      groupData = {
-      nonMember = await generateUser();
+        _id: publicGuild._id,
+        categories: [],
+        id: publicGuild._id,
+        type: publicGuild.type,
+        privacy: publicGuild.privacy,
+        name: publicGuild.name,
+        summary: publicGuild.name,
+        leader: publicGuild.leader._id,
+      };
 
-      challenge = await generateChallenge(user, group);
+      user = groupLeader;
-      await user.post(`/challenges/${challenge._id}/join`);
+      userData = {
-      challenge2 = await generateChallenge(user, group);
-      await user.post(`/challenges/${challenge2._id}/join`);
-    });
-
-    it('should return challenges user has joined', async () => {
-      await nonMember.post(`/challenges/${challenge._id}/join`);
-
-      const challenges = await nonMember.get('/challenges/user');
-
-      const 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 },
@@ -49,17 +44,31 @@ describe('GET challenges/user', () => {
         flags: {
           verifiedUsername: true,
         },
+      };
+
+      member = members[0]; // eslint-disable-line prefer-destructuring
+      nonMember = await generateUser();
+
+      challenge = await generateChallenge(user, group);
+      challenge2 = await generateChallenge(user, group);
+
+      await nonMember.post(`/challenges/${challenge._id}/join`);
     });
-      expect(foundChallenge.group).to.eql({
+    context('all challenges', () => {
-        _id: publicGuild._id,
+      it('should return challenges user has joined', async () => {
-        categories: [],
+        const challenges = await nonMember.get('/challenges/user');
-        id: publicGuild._id,
+
-        type: publicGuild.type,
+        const foundChallenge = _.find(challenges, { _id: challenge._id });
-        privacy: publicGuild.privacy,
+        expect(foundChallenge).to.exist;
-        name: publicGuild.name,
+        expect(foundChallenge.leader).to.eql(userData);
-        summary: publicGuild.name,
+        expect(foundChallenge.group).to.eql(groupData);
-        leader: publicGuild.leader._id,
       });
+
+      it('should not return challenges a non-member has not joined', async () => {
+        const challenges = await nonMember.get('/challenges/user');
+
+        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+        expect(foundChallenge2).to.not.exist;
       });
 
       it('should return challenges user has created', async () => {
@@ -67,54 +76,12 @@ describe('GET challenges/user', () => {
 
         const foundChallenge1 = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
+        expect(foundChallenge1.leader).to.eql(userData);
-        _id: publicGuild.leader._id,
+        expect(foundChallenge1.group).to.eql(groupData);
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      expect(foundChallenge1.group).to.eql({
-        _id: publicGuild._id,
-        categories: [],
-        id: publicGuild._id,
-        type: publicGuild.type,
-        privacy: publicGuild.privacy,
-        name: publicGuild.name,
-        summary: publicGuild.name,
-        leader: publicGuild.leader._id,
-      });
         const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
         expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
+        expect(foundChallenge2.leader).to.eql(userData);
-        _id: publicGuild.leader._id,
+        expect(foundChallenge2.group).to.eql(groupData);
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      expect(foundChallenge2.group).to.eql({
-        _id: publicGuild._id,
-        categories: [],
-        id: publicGuild._id,
-        type: publicGuild.type,
-        privacy: publicGuild.privacy,
-        name: publicGuild.name,
-        summary: publicGuild.name,
-        leader: publicGuild.leader._id,
-      });
       });
 
       it('should return challenges in user\'s group', async () => {
@@ -122,64 +89,12 @@ describe('GET challenges/user', () => {
 
         const foundChallenge1 = _.find(challenges, { _id: challenge._id });
         expect(foundChallenge1).to.exist;
-      expect(foundChallenge1.leader).to.eql({
+        expect(foundChallenge1.leader).to.eql(userData);
-        _id: publicGuild.leader._id,
+        expect(foundChallenge1.group).to.eql(groupData);
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      expect(foundChallenge1.group).to.eql({
-        _id: publicGuild._id,
-        categories: [],
-        id: publicGuild._id,
-        type: publicGuild.type,
-        privacy: publicGuild.privacy,
-        name: publicGuild.name,
-        summary: publicGuild.name,
-        leader: publicGuild.leader._id,
-      });
         const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
         expect(foundChallenge2).to.exist;
-      expect(foundChallenge2.leader).to.eql({
+        expect(foundChallenge2.leader).to.eql(userData);
-        _id: publicGuild.leader._id,
+        expect(foundChallenge2.group).to.eql(groupData);
-        id: publicGuild.leader._id,
-        profile: { name: user.profile.name },
-        auth: {
-          local: {
-            username: user.auth.local.username,
-          },
-        },
-        flags: {
-          verifiedUsername: true,
-        },
-      });
-      expect(foundChallenge2.group).to.eql({
-        _id: publicGuild._id,
-        categories: [],
-        id: publicGuild._id,
-        type: publicGuild.type,
-        privacy: publicGuild.privacy,
-        name: publicGuild.name,
-        summary: publicGuild.name,
-        leader: publicGuild.leader._id,
-      });
-    });
-
-    it('should not return challenges in user groups if we send member true param', async () => {
-      const challenges = await member.get(`/challenges/user?member=${true}`);
-
-      const foundChallenge1 = _.find(challenges, { _id: challenge._id });
-      expect(foundChallenge1).to.not.exist;
-
-      const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
-      expect(foundChallenge2).to.not.exist;
       });
 
       it('should return newest challenges first', async () => {
@@ -241,6 +156,63 @@ describe('GET challenges/user', () => {
       });
     });
 
+    context('my challenges', () => {
+      it('should return challenges user has joined', async () => {
+        const challenges = await nonMember.get(`/challenges/user?member=${true}`);
+
+        const foundChallenge = _.find(challenges, { _id: challenge._id });
+        expect(foundChallenge).to.exist;
+        expect(foundChallenge.leader).to.eql(userData);
+        expect(foundChallenge.group).to.eql(groupData);
+      });
+
+      it('should return challenges user has created', async () => {
+        const challenges = await user.get(`/challenges/user?member=${true}`);
+
+        const foundChallenge1 = _.find(challenges, { _id: challenge._id });
+        expect(foundChallenge1).to.exist;
+        expect(foundChallenge1.leader).to.eql(userData);
+        expect(foundChallenge1.group).to.eql(groupData);
+        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+        expect(foundChallenge2).to.exist;
+        expect(foundChallenge2.leader).to.eql(userData);
+        expect(foundChallenge2.group).to.eql(groupData);
+      });
+
+      it('should return challenges user has created if filter by owned', async () => {
+        const challenges = await user.get(`/challenges/user?member=${true}&owned=owned`);
+
+        const foundChallenge1 = _.find(challenges, { _id: challenge._id });
+        expect(foundChallenge1).to.exist;
+        expect(foundChallenge1.leader).to.eql(userData);
+        expect(foundChallenge1.group).to.eql(groupData);
+        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+        expect(foundChallenge2).to.exist;
+        expect(foundChallenge2.leader).to.eql(userData);
+        expect(foundChallenge2.group).to.eql(groupData);
+      });
+
+      it('should not return challenges user has created if filter by not owned', async () => {
+        const challenges = await user.get(`/challenges/user?owned=not_owned&member=${true}`);
+
+        const foundChallenge1 = _.find(challenges, { _id: challenge._id });
+        expect(foundChallenge1).to.not.exist;
+        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+        expect(foundChallenge2).to.not.exist;
+      });
+
+      it('should not return challenges in user groups', async () => {
+        const challenges = await member.get(`/challenges/user?member=${true}`);
+
+        const foundChallenge1 = _.find(challenges, { _id: challenge._id });
+        expect(foundChallenge1).to.not.exist;
+
+        const foundChallenge2 = _.find(challenges, { _id: challenge2._id });
+        expect(foundChallenge2).to.not.exist;
+      });
+    });
+  });
+
   context('official challenge is present', () => {
     let user; let officialChallenge; let unofficialChallenges; let
       publicGuild;

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

@@ -371,10 +371,7 @@ api.getUserChallenges = {
       { _id: { $in: user.challenges } }, // Challenges where the user is participating
     ];
 
-    const { owned } = req.query;
-    if (!owned) {
     orOptions.push({ leader: user._id });
-    }
 
     if (!req.query.member) {
       orOptions.push({
@@ -386,6 +383,7 @@ api.getUserChallenges = {
       $and: [{ $or: orOptions }],
     };
 
+    const { owned } = req.query;
     if (owned) {
       if (owned === 'not_owned') {
         query.$and.push({ leader: { $ne: user._id } });