Refactor quest functions and add tests

test/spec/groupCtrlSpec.js

@@ -310,3 +310,132 @@ describe("CopyMessageModal controller", function() {
     });
   });
 });
+
+describe("Party Controller", function() {
+  var scope, ctrl, user, User, groups, $rootScope, $controller;
+
+  beforeEach(function() {
+    user = specHelper.newUser(),
+    user._id = "unique-user-id";
+    User = {
+      user: user,
+      sync: sinon.spy
+    }
+
+    module(function($provide) {
+      $provide.value('User', User);
+    });
+
+    inject(function(_$rootScope_, _$controller_, Groups){
+
+      $rootScope = _$rootScope_;
+
+      scope = _$rootScope_.$new();
+
+      $controller = _$controller_;
+
+      groups = Groups;
+
+      // Load RootCtrl to ensure shared behaviors are loaded
+      $controller('RootCtrl',  {$scope: scope, User: User});
+
+      ctrl = $controller('PartyCtrl', {$scope: scope, User: User});
+    });
+  });
+
+  describe('questAccept', function() {
+    it('calls Groups.questAccept', function() {
+      var party = {};
+      var groupSpy = sinon.stub(groups, "questAccept", function(){return true;});
+      scope.questAccept(party);
+      groupSpy.should.have.been.calledOnce;
+    });
+  });
+
+  describe('questReject', function() {
+    it('calls Groups.questReject', function() {
+      var party = {};
+      var groupSpy = sinon.stub(groups, "questReject", function(){return true;});
+      scope.questReject(party);
+      groupSpy.should.have.been.calledOnce;
+    });
+  });
+
+  describe('questCancel', function() {
+    var party, cancelSpy, windowSpy;
+    beforeEach(function() {
+      party = {};
+      cancelSpy = sinon.stub(groups, "questCancel", function(){return true;});
+    });
+
+    afterEach(function() {
+      windowSpy.restore();
+      cancelSpy.restore();
+    });
+
+    it('calls Groups.questCancel when alert box is confirmed', function() {
+      windowSpy = sinon.stub(window, "confirm", function(){return true});
+
+      scope.questCancel(party);
+      windowSpy.should.have.been.calledOnce;
+      windowSpy.should.have.been.calledWith(window.env.t('sureCancel'));
+      cancelSpy.should.have.been.calledOnce;
+    });
+
+    it('does not call Groups.questCancel when alert box is confirmed', function() {
+      windowSpy = sinon.stub(window, "confirm", function(){return false});
+
+      scope.questCancel(party);
+      windowSpy.should.have.been.calledOnce;
+      cancelSpy.should.not.have.been.calledOnce;
+    });
+  });
+
+  describe('questAbort', function() {
+    var party, abortSpy, windowSpy;
+    beforeEach(function() {
+      party = {};
+      abortSpy = sinon.stub(groups, "questAbort", function(){return true;});
+    });
+
+    afterEach(function() {
+      windowSpy.restore();
+      abortSpy.restore();
+    });
+
+    it('calls Groups.questAbort when two alert boxes are confirmed', function() {
+      windowSpy = sinon.stub(window, "confirm", function(){return true});
+
+      scope.questAbort(party);
+      windowSpy.should.have.been.calledTwice;
+      windowSpy.should.have.been.calledWith(window.env.t('sureAbort'));
+      windowSpy.should.have.been.calledWith(window.env.t('doubleSureAbort'));
+      abortSpy.should.have.been.calledOnce;
+    });
+
+    it('does not call Groups.questAbort when first alert box is not confirmed', function() {
+      windowSpy = sinon.stub(window, "confirm", function(){return false});
+
+      scope.questAbort(party);
+      windowSpy.should.have.been.calledOnce;
+      windowSpy.should.have.been.calledWith(window.env.t('sureAbort'));
+      windowSpy.should.not.have.been.calledWith(window.env.t('doubleSureAbort'));
+      abortSpy.should.not.have.been.calledOnce;
+    });
+
+    it('does not call Groups.questAbort when first alert box is confirmed but second one is not', function() {
+      // Hack to confirm first window, but not second
+      var shouldReturn = false;
+      windowSpy = sinon.stub(window, "confirm", function(){
+        shouldReturn = !shouldReturn;
+        return shouldReturn;
+      });
+
+      scope.questAbort(party);
+      windowSpy.should.have.been.calledTwice;
+      windowSpy.should.have.been.calledWith(window.env.t('sureAbort'));
+      windowSpy.should.have.been.calledWith(window.env.t('doubleSureAbort'));
+      abortSpy.should.not.have.been.calledOnce;
+    });
+  });
+});

test/spec/groupServicesSpec.js

@@ -1,7 +1,7 @@
 'use strict';
 
 describe('groupServices', function() {
-  var $httpBackend, $http, groups;
+  var $httpBackend, $http, groups, user;
 
   beforeEach(function() {
     module(function($provide) {
@@ -11,6 +11,8 @@ describe('groupServices', function() {
     inject(function(_$httpBackend_, Groups, User) {
       $httpBackend = _$httpBackend_;
       groups = Groups;
+      user = User;
+      user.sync = function(){};
     });
   });
 
@@ -38,4 +40,100 @@ describe('groupServices', function() {
     $httpBackend.flush();
   });
 
+  context('quest function wrappers', function() {
+    var successPromise = function() {
+      return {
+        then: function(success, failure) {
+          success();
+        }
+      }
+    }
+
+    var successParty = {
+      $questAccept: successPromise,
+      $questReject: successPromise,
+      $questCancel: successPromise,
+      $questAbort:  successPromise
+    }
+
+    var failPromise = function() {
+      return {
+        then: function(success, failure) {
+          failure('fail');
+        }
+      }
+    }
+
+    var failParty = {
+      $questAccept: failPromise,
+      $questReject: failPromise,
+      $questCancel: failPromise,
+      $questAbort:  failPromise
+    }
+
+    beforeEach(function() {
+      sinon.spy(user, 'sync');
+      sinon.stub(console, 'log', function(arg) { return true; });
+    });
+
+    afterEach(function() {
+      user.sync.restore();
+      console.log.restore();
+    });
+
+    describe('questAccept', function() {
+      it('syncs user if $questAccept succeeds', function() {
+        groups.questAccept(successParty);
+        user.sync.should.have.been.calledOnce;
+      });
+
+      it('does not sync user if $questAccept fails', function() {
+        groups.questAccept(failParty);
+        user.sync.should.not.have.been.calledOnce;
+        console.log.should.have.been.calledWith('fail');
+      });
+    });
+
+    describe('questReject', function() {
+      it('syncs user if $questReject succeeds', function() {
+        groups.questReject(successParty);
+        user.sync.should.have.been.calledOnce;
+        console.log.should.not.have.been.called;
+      });
+
+      it('does not sync user if $questReject fails', function() {
+        groups.questReject(failParty);
+        user.sync.should.not.have.been.calledOnce;
+        console.log.should.have.been.calledWith('fail');
+      });
+    });
+
+    describe('questCancel', function() {
+      it('syncs user if $questCancel succeeds', function() {
+        groups.questCancel(successParty);
+        user.sync.should.have.been.calledOnce;
+        console.log.should.not.have.been.called;
+      });
+
+      it('does not sync user if $questCancel fails', function() {
+        groups.questCancel(failParty);
+        user.sync.should.not.have.been.calledOnce;
+        console.log.should.have.been.calledWith('fail');
+      });
+    });
+
+    describe('questAbort', function() {
+      it('syncs user if $questAbort succeeds', function() {
+        groups.questAbort(successParty);
+        user.sync.should.have.been.calledOnce;
+        console.log.should.not.have.been.called;
+      });
+
+      it('does not sync user if $questAbort fails', function() {
+        groups.questAbort(failParty);
+        user.sync.should.not.have.been.calledOnce;
+        console.log.should.have.been.calledWith('fail');
+      });
+    });
+  });
 });