reorganize old client tests

test/client-old/spec/controllers/inviteToGroupCtrlSpec.js

@@ -0,0 +1,257 @@
+'use strict';
+
+describe('Invite to Group Controller', function() {
+  var scope, ctrl, groups, user, guild, rootScope, $controller;
+
+  beforeEach(function() {
+    user = specHelper.newUser({
+      profile: { name: 'Mario' }
+    });
+
+    module(function($provide) {
+      $provide.value('User', {});
+      $provide.value('injectedGroup', { user: user });
+    });
+
+    inject(function(_$rootScope_, _$controller_, Groups) {
+      rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: {user: user}});
+
+      ctrl = $controller('InviteToGroupCtrl', {$scope: scope, User: {user: user}});
+
+      groups = Groups;
+    });
+  });
+
+  describe('addEmail', function() {
+    it('adds blank email to email list', function() {
+      scope.emails = [{name: 'Mario', email: 'mario@mushroomkingdom.com'}];
+      scope.addEmail();
+
+      expect(scope.emails).to.eql([{name: 'Mario', email: 'mario@mushroomkingdom.com'}, {name: '', email: ''}]);
+    });
+  });
+
+  describe('addUuid', function() {
+    it('adds blank uuid to invitees list', function() {
+      scope.invitees = [{uuid: 'user1'}];
+      scope.addUuid();
+
+      expect(scope.invitees).to.eql([{uuid: 'user1'}, {uuid: ''}]);
+    });
+  });
+
+  describe('inviteNewUsers', function() {
+    var groupInvite, groupCreate;
+
+    beforeEach(function() {
+      scope.group = specHelper.newGroup({
+        type: 'party',
+      });
+
+      groupCreate = sandbox.stub(groups.Group, 'create');
+      groupInvite = sandbox.stub(groups.Group, 'invite');
+    });
+
+    context('if the party does not already exist', function() {
+      var groupResponse;
+
+      beforeEach(function() {
+        delete scope.group._id;
+        groupResponse = {data: {data: scope.group}}
+      });
+
+      it('saves the group if a new group is being created', function() {
+        groupCreate.returns(Promise.resolve(groupResponse));
+        scope.inviteNewUsers('uuid');
+        expect(groupCreate).to.be.calledOnce;
+      });
+
+      it('uses provided name', function() {
+        scope.group.name = 'test party';
+
+        groupCreate.returns(Promise.resolve(groupResponse));
+
+        scope.inviteNewUsers('uuid');
+
+        expect(groupCreate).to.be.calledWith(scope.group);
+        expect(scope.group.name).to.eql('test party');
+      });
+
+      it('names the group if no name is provided', function() {
+        scope.group.name = '';
+
+        groupCreate.returns(Promise.resolve(groupResponse));
+
+        scope.inviteNewUsers('uuid');
+
+        expect(groupCreate).to.be.calledWith(scope.group);
+        expect(scope.group.name).to.eql(env.t('possessiveParty', {name: user.profile.name}));
+      });
+    });
+
+    context('email', function() {
+      beforeEach(function () {
+        sandbox.stub(rootScope, 'hardRedirect');
+      });
+
+      it('invites user with emails', function(done) {
+        scope.emails = [
+          {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+          {name: 'Mario', email: 'mario@tmk.com'}
+        ];
+
+        var inviteDetails = {
+          inviter: user.profile.name,
+          emails: [
+            {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+            {name: 'Mario', email: 'mario@tmk.com'}
+          ]
+        };
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, inviteDetails);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+
+      it('resets email list after sending', function(done) {
+        scope.emails[0].name = 'Luigi';
+        scope.emails[0].email = 'mario_bro@themushroomkingdom.com';
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              //We use a timeout to test items that happen after the promise is resolved
+              setTimeout(function(){
+                expect(scope.emails).to.eql([{name:'', email: ''},{name:'', email: ''}]);
+                done();
+              }, 1000);
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+
+      it('filters out blank email inputs', function() {
+        scope.emails = [
+          {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+          {name: 'Toad', email: ''},
+          {name: 'Mario', email: 'mario@tmk.com'}
+        ];
+
+        var inviteDetails = {
+          inviter: user.profile.name,
+          emails: [
+            {name: 'Luigi', email: 'mario_bro@themushroomkingdom.com'},
+            {name: 'Mario', email: 'mario@tmk.com'}
+          ]
+        };
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, inviteDetails);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('email');
+      });
+    });
+
+    context('uuid', function() {
+      beforeEach(function () {
+        sandbox.stub(rootScope, 'hardRedirect');
+      });
+
+      it('invites user with uuid', function(done) {
+        scope.invitees = [{uuid: '1234'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['1234'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('invites users with uuids', function(done) {
+        scope.invitees = [{uuid: 'user1'}, {uuid: 'user2'}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['user1', 'user2', 'user3'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('resets invitee list after sending', function(done) {
+        scope.invitees = [{uuid: 'user1'}, {uuid: 'user2'}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              //We use a timeout to test items that happen after the promise is resolved
+              setTimeout(function(){
+                expect(scope.invitees).to.eql([{uuid: ''}]);
+                done();
+              }, 1000);
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+
+      it('removes blank fields from being sent', function() {
+        scope.invitees = [{uuid: 'user1'}, {uuid: ''}, {uuid: 'user3'}];
+
+        groupInvite.returns(
+          Promise.resolve()
+            .then(function () {
+              expect(groupInvite).to.be.calledOnce;
+              expect(groupInvite).to.be.calledWith(scope.group._id, { uuids: ['user1', 'user3'] });
+              done();
+            })
+        );
+
+        scope.inviteNewUsers('uuid');
+      });
+    });
+
+    context('invalid invite method', function() {
+      it('logs error', function() {
+        sandbox.stub(console, 'log');
+
+        scope.inviteNewUsers();
+        expect(groups.Group.invite).to.not.be.called;
+        expect(console.log).to.be.calledOnce;
+        expect(console.log).to.be.calledWith('Invalid invite method.');
+      });
+    });
+
+  });
+});