modules/invites/test/invites-service-test.js

   1 'use strict';
   2
   3 var invitesService = require('../lib/invites-service');
   4 var ObjectID = require('mongodb').ObjectID;
   5 var assert = require('assert');
   6 var StatusError = require('statuserror');
   7 var TroupeInvite = require('gitter-web-persistence').TroupeInvite;
   8 var fixtureLoader = require('gitter-web-test-utils/lib/test-fixtures');
   9
  10 describe('invite-service', function() {
  11   const fixture = fixtureLoader.setupEach({
  12     userInvitedBy1: {},
  13     userHellbanned1: {
  14       hellbanned: true
  15     }
  16   });
  17
  18   describe('integration tests #slow', function() {
  19     describe('createInvite', function() {
  20       it('should create an invite', function() {
  21         var roomId = new ObjectID();
  22
  23         return invitesService
  24           .createInvite(roomId, {
  25             type: 'github',
  26             externalId: 'gitterawesome',
  27             invitedByUserId: fixture.userInvitedBy1.id,
  28             emailAddress: 'test@gitter.im'
  29           })
  30           .then(function(invite) {
  31             assert.strictEqual(invite.state, 'PENDING');
  32             assert.strictEqual(String(invite.invitedByUserId), String(fixture.userInvitedBy1.id));
  33             assert.strictEqual(String(invite.troupeId), String(roomId));
  34             assert.strictEqual(invite.userId, null);
  35             assert.strictEqual(invite.emailAddress, 'test@gitter.im');
  36             assert.strictEqual(invite.externalId, 'gitterawesome');
  37             assert.strictEqual(invite.type, 'github');
  38           });
  39       });
  40
  41       it('should not allow duplicate invites', function() {
  42         var roomId = new ObjectID();
  43
  44         return invitesService
  45           .createInvite(roomId, {
  46             type: 'github',
  47             externalId: 'gitterawesome',
  48             invitedByUserId: fixture.userInvitedBy1.id,
  49             emailAddress: 'test@gitter.im'
  50           })
  51           .then(function() {
  52             return invitesService.createInvite(roomId, {
  53               type: 'github',
  54               externalId: 'gitterawesome',
  55               invitedByUserId: fixture.userInvitedBy1.id,
  56               emailAddress: 'test@gitter.im'
  57             });
  58           })
  59           .then(function() {
  60             assert.ok(false, 'Expected exception');
  61           })
  62           .catch(StatusError, function(err) {
  63             assert.strictEqual(err.status, 409);
  64           });
  65       });
  66
  67       it('should not allow invites from hellbaned users', async () => {
  68         var roomId = new ObjectID();
  69
  70         await invitesService.createInvite(roomId, {
  71           type: 'github',
  72           externalId: 'gitterawesome',
  73           invitedByUserId: fixture.userHellbanned1.id,
  74           emailAddress: 'test@gitter.im'
  75         });
  76
  77         const invitesInRoom = await TroupeInvite.find({
  78           troupeId: roomId
  79         })
  80           .lean()
  81           .exec();
  82
  83         assert.strictEqual(
  84           invitesInRoom.length,
  85           0,
  86           `Expected no invites in room but found ${
  87             invitesInRoom.length
  88           }\ninvitesInRoom=${JSON.stringify(invitesInRoom, null, 2)}`
  89         );
  90       });
  91     });
  92
  93     describe('create-accept-complete flow', function() {
  94       it('should accept an invite', function() {
  95         var roomId = new ObjectID();
  96         var userId = new ObjectID();
  97         var userId2 = new ObjectID();
  98
  99         return invitesService
 100           .createInvite(roomId, {
 101             type: 'github',
 102             externalId: 'gitterawesome',
 103             invitedByUserId: fixture.userInvitedBy1.id,
 104             emailAddress: 'test@gitter.im'
 105           })
 106           .bind({
 107             invite: null
 108           })
 109           .then(function(invite) {
 110             this.invite = invite;
 111             return invitesService.accept(userId, invite.secret);
 112           })
 113           .then(function(invite) {
 114             assert.strictEqual(String(invite._id), String(this.invite._id));
 115             return invitesService.markInviteAccepted(invite._id, userId);
 116           })
 117           .then(function() {
 118             // Attempt to reuse the invite, same user
 119             return invitesService.accept(userId, this.invite.secret);
 120           })
 121           .then(function(invite) {
 122             assert.strictEqual(String(invite._id), String(this.invite._id));
 123             return invitesService
 124               .accept(userId2, this.invite.secret)
 125               .then(function() {
 126                 assert.ok(false, 'Expected exception');
 127               })
 128               .catch(StatusError, function(err) {
 129                 assert.strictEqual(err.status, 404);
 130               });
 131           })
 132           .then(function() {
 133             return TroupeInvite.findById(this.invite._id);
 134           })
 135           .then(function(invite) {
 136             assert.strictEqual(invite.state, 'ACCEPTED');
 137             assert.strictEqual(String(invite.userId), String(userId));
 138           });
 139       });
 140     });
 141   });
 142
 143   describe('findInvitesForReminder #slow', function() {
 144     var fixture = fixtureLoader.setup({
 145       troupe1: {},
 146       user1: {}
 147     });
 148
 149     it('should return invites', function() {
 150       return invitesService
 151         .createInvite(fixture.troupe1._id, {
 152           type: 'email',
 153           emailAddress: fixtureLoader.generateEmail(),
 154           invitedByUserId: fixture.user1._id
 155         })
 156         .bind({
 157           inviteId: null
 158         })
 159         .then(function(invite) {
 160           this.inviteId = invite._id;
 161           return invitesService.findInvitesForReminder(-1);
 162         })
 163         .then(function(invites) {
 164           assert(invites.length > 1);
 165           var inviteId = this.inviteId;
 166           var originalInvite = invites.filter(function(f) {
 167             return String(inviteId) === String(f.invite._id);
 168           })[0];
 169
 170           assert(originalInvite);
 171           assert(originalInvite.invite);
 172           assert(originalInvite.invitedByUser);
 173           assert(originalInvite.troupe);
 174
 175           assert.strictEqual(String(originalInvite.invite._id), String(inviteId));
 176           assert.strictEqual(String(originalInvite.invitedByUser._id), String(fixture.user1._id));
 177           assert.strictEqual(String(originalInvite.troupe._id), String(fixture.troupe1._id));
 178         });
 179     });
 180   });
 181 });