POST-groups_id_invite.test.js

import {
  createAndPopulateGroup,
  generateUser,
} from '../../../helpers/api-integration/v2';
import { each } from 'lodash';

describe('POST /groups/:id/invite', () => {
  context('user is a member of the group', () => {
    each({
      'public guild': {type: 'guild', privacy: 'public'},
      'private guild': {type: 'guild', privacy: 'private'},
      party: {type: 'party', privacy: 'private'},
    }, (groupDetails, groupType) => {
      let group, invitee, inviter;

      beforeEach(async () => {
        invitee = await generateUser();
        let groupData = await createAndPopulateGroup({
          groupDetails,
          members: 1,
        });
        group = groupData.group;
        inviter = groupData.members[0];
      });

      it(`allows user to send an invitation for a ${groupType}`, async () => {
        await inviter.post(`/groups/${group._id}/invite`, {
          uuids: [invitee._id],
        });
        await group.sync();
        expect(group.invites).to.include(invitee._id);
      });
    });

    context('members and invites is at the cap', () => {
      let group, invitee, inviter, partyCap, members, invites;

      before(async () => {
        let g = await createAndPopulateGroup();
        partyCap = g.group.partyCap;
        members = Math.floor(partyCap / 2);
        invites = partyCap - members;
        members--;
      });

      it('allows user to send an invitation for a guild', async () => {
        invitee = await generateUser();
        let groupData = await createAndPopulateGroup({
          groupDetails: {type: 'guild', privacy: 'public'},
          members,
          invites,
        });
        group = groupData.group;
        inviter = groupData.members[0];

        await inviter.post(`/groups/${group._id}/invite`, {
          uuids: [invitee._id],
        });
        await group.sync();
        expect(group.invites).to.include(invitee._id);
      });

      it('does not allow user to send an invitation for a party', async () => {
        invitee = await generateUser();
        let groupData = await createAndPopulateGroup({
          groupDetails: {type: 'party', privacy: 'private'},
          members,
          invites,
        });
        group = groupData.group;
        inviter = groupData.members[0];

        return expect(inviter.post(`/groups/${group._id}/invite`, {
          uuids: [invitee._id],
        })).to.eventually.be.rejected.and.eql({
          code: 400,
          text: `Over ${partyCap} member party cap!`,
        });
      });
    });

    context('members and invites is just under the cap', () => {
      let group, invitee, inviter, partyCap, members, invites;

      before(async () => {
        let g = await createAndPopulateGroup();
        partyCap = g.group.partyCap;
        members = Math.floor(partyCap / 2);
        invites = partyCap - members - 1;
        members--;
      });

      it('allows user to send an invitation for a party', async () => {
        invitee = await generateUser();
        let groupData = await createAndPopulateGroup({
          groupDetails: {type: 'party', privacy: 'private'},
          members,
          invites,
        });
        group = groupData.group;
        inviter = groupData.members[0];

        await inviter.post(`/groups/${group._id}/invite`, {
          uuids: [invitee._id],
        });
        await group.sync();
        expect(group.invites).to.include(invitee._id);
      });
    });
  });

  context('user is a not member of the group', () => {
    each({
      'public guild': {type: 'guild', privacy: 'public'},
    }, (groupDetails, groupType) => {
      context(`the group is a ${groupType}`, () => {
        let group, invitee, inviter;

        beforeEach(async () => {
          invitee = await generateUser();
          inviter = await generateUser();
          let groupData = await createAndPopulateGroup({
            groupDetails,
          });
          group = groupData.group;
        });

        it(`allows user to send an invitation for a ${groupType}`, async () => {
          await inviter.post(`/groups/${group._id}/invite`, {
            uuids: [invitee._id],
          });
          await group.sync();
          expect(group.invites).to.include(invitee._id);
        });
      });
    });

    each({
      'private guild': {type: 'guild', privacy: 'private'},
      party: {type: 'party', privacy: 'private'},
    }, (groupDetails, groupType) => {
      context(`the group is a ${groupType}`, () => {
        let group, invitee, inviter;

        beforeEach(async () => {
          invitee = await generateUser();
          inviter = await generateUser();
          let groupData = await createAndPopulateGroup({
            groupDetails,
          });
          group = groupData.group;
        });

        it(`does not allows user to send an invitation for a ${groupType}`, async () => {
          return expect(inviter.post(`/groups/${group._id}/invite`, {
            uuids: [invitee._id],
          })).to.eventually.be.rejected.and.eql({
            code: 401,
            text: 'Only a member can invite new members!',
          });
        });
      });
    });
  });
});