Move group tests to new test structure

test/api/groups/GET-groups_id.test.js

@@ -1,49 +1,68 @@
 import {
-  generateGroup,
+  createAndPopulateGroup,
   generateUser,
   requester,
 } from '../../helpers/api.helper';
-import {each} from 'lodash';
+import {
+  find,
+  each
+} from 'lodash';
 
 describe('GET /groups/:id', () => {
 
-  let typesOfGroups = {
-    publicGuilds: { type: 'guild', privacy: 'public' },
-    privateGuilds: { type: 'guild', privacy: 'private' },
-    party: { type: 'party', privacy: 'private' },
-  }
+  let typesOfGroups = {};
+  typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
+  typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
+  typesOfGroups['party'] = { type: 'party', privacy: 'private' };
 
   each(typesOfGroups, (groupData, groupType) => {
-    context(`Group Type: ${groupType}`, () => {
-      let api, leader, createdGroup;
+    context(`Member of a ${groupType}`, () => {
+      let leader, member, createdGroup;
 
-      beforeEach((done) => {
-        generateUser({
-          balance: 1,
-        }).then((user) => {
-          leader = user;
-          api = requester(user);
-          return generateGroup(leader, groupData);
-        }).then((group) => {
-          createdGroup = group;
+      before((done) => {
+        createAndPopulateGroup({
+          members: 30,
+          groupDetails: {
+            name: 'test guild',
+            type: 'guild',
+            privacy: 'public',
+          },
+        }).then((res) => {
+          leader = res.leader;
+          member = res.members[0];
+          createdGroup = res.group;
           done();
         }).catch(done);
       });
 
+      it('returns the group object', (done) => {
+        let api = requester(member);
+        api.get(`/groups/${createdGroup._id}`)
+          .then((group) => {
+            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);
+            done();
+          }).catch(done);
+      });
+
       it('transforms members array to an array of user objects', (done) => {
+        let api = requester(member);
         api.get(`/groups/${createdGroup._id}`).then((group) => {
-          let member = group.members[0];
-          expect(member._id).to.eql(leader._id);
-          expect(member.profile.name).to.eql(leader.profile.name);
-          expect(member.items).to.exist;
-          expect(member.stats).to.exist;
-          expect(member.achievements).to.exist;
-          expect(member.contributor).to.exist;
+          let foundMember = group.members[0];
+          expect(foundMember._id).to.exist;
+          expect(foundMember.profile.name).to.exist;
+          expect(foundMember.items).to.exist;
+          expect(foundMember.stats).to.exist;
+          expect(foundMember.achievements).to.exist;
+          expect(foundMember.contributor).to.exist;
           done();
         }).catch(done);
       });
 
       it('transforms leader id to leader object', (done) => {
+        let api = requester(member);
         api.get(`/groups/${createdGroup._id}`).then((group) => {
           expect(group.leader._id).to.eql(leader._id);
           expect(group.leader.profile.name).to.eql(leader.profile.name);
@@ -55,40 +74,43 @@ describe('GET /groups/:id', () => {
         }).catch(done);
       });
 
-      it('returns error if group does not exist', (done) => {
-        generateUser().then((user) => {
-          api = requester(user);
-          return api.get('/groups/group-that-does-not-exist');
-        }).then((done)).catch((err) => {
-          expect(err.code).to.eql(404);
-          expect(err.text).to.eql('Group not found or you don\'t have access.');
-          done()
-        });
+      it('includes the user in the members list', (done) => {
+        let api = requester(member);
+        api.get(`/groups/${createdGroup._id}`).then((group) => {
+          let members = group.members;
+          let userInGroup = find(members, (user) => {
+            return member._id === user._id;
+          });
+          expect(userInGroup).to.be.ok;
+          done();
+        }).catch(done);
       });
     });
   });
 
-  context('Public Guilds', () => {
-    let api, leader, createdGroup;
+  context('Non-member of a public guild', () => {
+    let leader, nonMember, createdGroup;
 
-    beforeEach((done) => {
-      generateUser({
-        balance: 1,
-      }).then((user) => {
-        leader = user;
-        api = requester(user);
-        return generateGroup(leader, {
-          name: 'group name',
+    before((done) => {
+      createAndPopulateGroup({
+        members: 1,
+        groupDetails: {
+          name: 'test guild',
           type: 'guild',
           privacy: 'public',
-        });
-      }).then((group) => {
-        createdGroup = group;
+        },
+      }).then((res) => {
+        leader = res.leader;
+        createdGroup = res.group;
+        return generateUser();
+      }).then((user) => {
+        nonMember = user;
         done();
       }).catch(done);
     });
 
-    it('returns the group object', (done) => {
+    it('returns the group object for a non-member', (done) => {
+      let api = requester(nonMember);
       api.get(`/groups/${createdGroup._id}`)
         .then((group) => {
           expect(group._id).to.eql(createdGroup._id);
@@ -99,105 +121,104 @@ describe('GET /groups/:id', () => {
         }).catch(done);
     });
 
-    it('returns the group object for a non-member', (done) => {
-      generateUser().then((user) => {
-        api = requester(user);
-        return api.get(`/groups/${createdGroup._id}`);
-      }).then((group) => {
-        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);
-        done();
-      }).catch(done);
+    it('does not include user in members list', (done) => {
+      let api = requester(nonMember);
+      api.get(`/groups/${createdGroup._id}`)
+        .then((group) => {
+          let userInGroup = find(group.members, (user) => {
+            return nonMember._id === user._id;
+          });
+          expect(userInGroup).to.not.be.ok;
+          done();
+        }).catch(done);
     });
   });
 
   context('Private Guilds', () => {
-    let api, leader, createdGroup;
+    let leader, nonMember, createdGroup;
 
-    beforeEach((done) => {
-      generateUser({
-        balance: 1,
-      }).then((user) => {
-        leader = user;
-        api = requester(user);
-        return generateGroup(leader, {
-          name: 'group name',
+    before((done) => {
+      createAndPopulateGroup({
+        members: 1,
+        groupDetails: {
+          name: 'test guild',
           type: 'guild',
           privacy: 'private',
-        });
-      }).then((group) => {
-        createdGroup = group;
+        },
+      }).then((res) => {
+        leader = res.leader;
+        createdGroup = res.group;
+        return generateUser();
+      }).then((user) => {
+        nonMember = user;
         done();
       }).catch(done);
     });
 
-    it('returns the group object', (done) => {
-      api.get(`/groups/${createdGroup._id}`)
-        .then((group) => {
-          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);
-          done();
-        }).catch(done);
-    });
-
     it('does not return the group object for a non-member', (done) => {
-      generateUser().then((user) => {
-        api = requester(user);
-        return api.get(`/groups/${createdGroup._id}`);
-      }).then((done)).catch((err) => {
-        expect(err.code).to.eql(404);
-        expect(err.text).to.eql('Group not found or you don\'t have access.');
-        done()
+      let api = requester(nonMember);
+      api.get(`/groups/${createdGroup._id}`)
+        .then((done)).catch((err) => {
+          expect(err.code).to.eql(404);
+          expect(err.text).to.eql('Group not found or you don\'t have access.');
+          done()
       });
     });
   });
 
-  context('Parties', () => {
-    let api, leader, createdGroup;
+  context('Non-member of a party', () => {
+    let leader, nonMember, createdGroup;
 
-    beforeEach((done) => {
-      generateUser({
-        balance: 1,
-      }).then((user) => {
-        leader = user;
-        api = requester(user);
-        return generateGroup(leader, {
-          name: 'group name',
+    before((done) => {
+      createAndPopulateGroup({
+        members: 1,
+        groupDetails: {
+          name: 'test party',
           type: 'party',
-        });
-      }).then((group) => {
-        createdGroup = group;
+          privacy: 'private',
+        },
+      }).then((res) => {
+        leader = res.leader;
+        createdGroup = res.group;
+        return generateUser();
+      }).then((user) => {
+        nonMember = user;
         done();
       }).catch(done);
     });
 
-    it('returns the group object', (done) => {
-      api.get(`/groups/${createdGroup._id}`)
-        .then((group) => {
-          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);
-          done();
-        }).catch(done);
-    });
-
     it('does not return the group object for a non-member', (done) => {
-      generateUser().then((user) => {
-        api = requester(user);
-        return api.get(`/groups/${createdGroup._id}`);
-      }).then((done)).catch((err) => {
-        expect(err.code).to.eql(404);
-        expect(err.text).to.eql('Group not found or you don\'t have access.');
-        done()
-      });
+      let api = requester(nonMember);
+      api.get(`/groups/${createdGroup._id}`)
+        .then((done)).catch((err) => {
+          expect(err.code).to.eql(404);
+          expect(err.text).to.eql('Group not found or you don\'t have access.');
+          done()
+        });
+    });
+  });
+
+  context('Member of a party', () => {
+    let leader, member, createdGroup;
+
+    before((done) => {
+      createAndPopulateGroup({
+        members: 1,
+        groupDetails: {
+          name: 'test party',
+          type: 'party',
+          privacy: 'private',
+        },
+      }).then((res) => {
+        leader = res.leader;
+        createdGroup = res.group;
+        member = res.members[0];
+        done();
+      }).catch(done);
     });
 
     it('returns the user\'s party if an id of "party" is passed in', (done) => {
+      let api = requester(member);
       api.get('/groups/party')
         .then((group) => {
           expect(group._id).to.eql(createdGroup._id);
@@ -208,4 +229,25 @@ describe('GET /groups/:id', () => {
         }).catch(done);
     });
   });
+
+  context('Non-existent group', () => {
+    let user;
+
+    beforeEach((done) => {
+      generateUser().then((_user) => {
+        user = _user;
+        done();
+      }).catch(done);
+    });
+
+    it('returns error if group does not exist', (done) => {
+      let api = requester(user);
+      api.get('/groups/group-that-does-not-exist')
+        .then((done)).catch((err) => {
+          expect(err.code).to.eql(404);
+          expect(err.text).to.eql('Group not found or you don\'t have access.');
+          done()
+        });
+    });
+  });
 });