social_networking 0.9.3

data/spec/javascripts/social_networking/goal-controller_spec.js

@@ -0,0 +1,191 @@
+describe('GoalCtrl', function() {
+  var controller,
+      goalService,
+      scope,
+      q,
+      createDeferred,
+      updateDeferred;
+
+  beforeEach(function() {
+    module('socialNetworking.controllers');
+    module('socialNetworking.services');
+
+    goalService = {
+      create: function(attributes) {
+                createDeferred = q.defer();
+
+                return createDeferred.promise;
+              },
+      update: function(attributes) {
+                updateDeferred = q.defer();
+
+                return updateDeferred.promise;
+              }
+    };
+  });
+
+  beforeEach(inject(function($rootScope, $q, $controller, goalTool) {
+    scope = $rootScope;
+    q = $q;
+    controller = $controller('GoalCtrl', {
+      Goals: goalService,
+      goalTool: goalTool,
+      currentGoals: [],
+      participantStudyEndDate: '2014-01-01',
+      noticesEnabled: false,
+      noticeUtility: Notice
+    });
+  }));
+
+  beforeEach(function() {
+    jasmine.clock().install();
+  });
+
+  afterEach(function() {
+    jasmine.clock().uninstall();
+  });
+
+  it('should initialize the mode', function() {
+    expect(controller.inBrowseMode()).toBeTruthy();
+  });
+
+  describe('#new', function() {
+    it('should put the controller into entry mode', function() {
+      controller.new();
+
+      expect(controller.inEntryMode()).toBeTruthy();
+    });
+  });
+
+  describe('#toggleComplete', function() {
+    describe('when unsuccessful', function() {
+      it('should reset the isCompleted attribute', function() {
+        window.confirm = function(msg){
+          //return true to simulate the OK button having been clicked
+          return true;
+        };
+        var goal = { isCompleted: true };
+        controller.toggleComplete(goal);
+        updateDeferred.reject({ isCompleted: false });
+        scope.$apply();
+
+        expect(goal.isCompleted).toBeFalsy();
+      });
+    });
+  });
+
+  describe('#toggleDeleted', function() {
+    describe('when unsuccessful', function() {
+      it('should reset the isDeleted attribute', function() {
+        var goal = { isDeleted: true };
+        controller.toggleDeleted(goal);
+        updateDeferred.reject({ isDeleted: false });
+        scope.$apply();
+
+        expect(goal.isDeleted).toBeFalsy();
+      });
+    });
+  });
+
+  describe('#save', function() {
+    describe('when successful', function() {
+      it('should reset and add the goal to the collection', function() {
+        controller.new();
+        controller.save();
+        createDeferred.resolve({ description: 'goal1' });
+        scope.$apply();
+
+        expect(controller.inBrowseMode()).toBeTruthy();
+        expect(controller.participantGoals.length).toBe(1);
+        expect(controller.participantGoals[0].description).toBe('goal1');
+      });
+    });
+
+    describe('when unsuccessful', function() {
+      it('should set the error', function() {
+        controller.new();
+        controller.save();
+        createDeferred.reject({ error: 'baz' });
+        scope.$apply();
+
+        expect(controller.inEntryMode()).toBeTruthy();
+        expect(controller.participantGoals.length).toBe(0);
+        expect(controller.error).toBe('baz');
+      });
+    });
+  });
+
+  describe('.dateInNWeeks', function() {
+    describe('when week number is defined', function() {
+      it('returns formatted date of one week in the future', function() {
+        var today = moment('2015-12-22').toDate();
+        jasmine.clock().mockDate(today);
+
+        expect(controller.dateInNWeeks(1)).toBe('Dec 29 2015');
+      });
+    })
+
+    describe('when week number is undefined', function() {
+      it('returns `null`', function() {
+        expect(controller.dateInNWeeks()).toBeNull();
+      });
+    })
+  });
+
+  describe('.dateAtEndOfTrial', function() {
+    describe('when studyEndDate is defined', function() {
+      describe('when study end date is in the past', function() {
+        it('returns `null`', function() {
+          controller.studyEndDate = new Date(1451423241949);
+
+          expect(controller.dateAtEndOfTrial()).toBeNull();
+        });
+      });
+
+      describe('when study end date is in the future', function() {
+        it('returns formatted date of the future date', function() {
+          var today = moment('2015-12-22').toDate();
+          jasmine.clock().mockDate(today);
+          controller.studyEndDate = new Date(1451423241949);
+
+          expect(controller.dateAtEndOfTrial()).toBe('Dec 29 2015');
+        });
+      });
+    });
+
+    describe('when studyEndDate is `null`', function() {
+      it('returns formatted date of the end of trial', function() {
+        controller.studyEndDate = null;
+
+        expect(controller.dateAtEndOfTrial()).toBeNull();
+      });
+    });
+  });
+
+  describe('.atLeastNWeeksLeftInTrial', function() {
+    describe('study end date is 2 weeks in the future', function() {
+      beforeEach(function() {
+        controller.studyEndDate = moment().add(2, 'weeks');
+      });
+
+      describe('when week number is before the end date', function() {
+        it('returns `true`', function() {
+          expect(controller.atLeastNWeeksLeftInTrial(1)).toBe(true);
+        });
+      });
+
+      describe('when week number is after the end date', function() {
+        it('returns `false`', function() {
+          expect(controller.atLeastNWeeksLeftInTrial(3)).toBe(false);
+        });
+      });
+
+      describe('when week number is undefined', function() {
+        it('defaults to 0th week', function() {
+          expect(controller.atLeastNWeeksLeftInTrial())
+            .toBe(controller.atLeastNWeeksLeftInTrial(0));
+        });
+      });
+    });
+  });
+});

data/spec/javascripts/social_networking/home-controller_spec.js

@@ -0,0 +1,351 @@
+;(function() {
+  'use strict';
+
+describe('HomeCtrl', function() {
+  var controller,
+      onYourMindResource,
+      commentResource,
+      homeTool,
+      likeResource,
+      scope,
+      q,
+      deferred,
+      sharedResource;
+
+  beforeEach(function() {
+    module('socialNetworking.controllers');
+    module('socialNetworking.services');
+
+    onYourMindResource = {
+      create: function(attributes) {
+                deferred = q.defer();
+
+                return deferred.promise;
+              }
+    };
+    commentResource = {
+      create: function() {
+                deferred = q.defer();
+
+                return deferred.promise;
+              }
+    };
+    likeResource = {
+      create: function() {
+                deferred = q.defer();
+
+                return deferred.promise;
+              }
+    };
+    sharedResource = {
+      create: function() {
+        deferred = q.defer();
+
+        return deferred.promise;
+      },
+      get: function() {
+        deferred = q.defer();
+
+        return deferred.promise;
+      }
+    }
+  });
+
+  beforeEach(inject(function($rootScope, $q, $controller, $filter, _homeTool_) {
+    homeTool = _homeTool_;
+    scope = $rootScope;
+    q = $q;
+    controller = $controller('HomeCtrl', {
+      OnYourMindResource: onYourMindResource,
+      CommentResource: commentResource,
+      LikeResource: likeResource,
+      homeTool: _homeTool_,
+      participantId: 123,
+      actionItems: [],
+      feedItems: [],
+      memberProfiles: [],
+      $filter: $filter,
+      $http: sharedResource,
+      $location: {},
+      $scope: scope,
+      noticesEnabled: false,
+      noticeUtility: Notice,
+      resource: 'someResource'
+    });
+  }));
+
+  it('should initialize the mode', function() {
+    expect(controller.inFeedBrowseMode()).toBeTruthy();
+  });
+
+  describe('#timeAgoInWords', function() {
+    var foo;
+
+    beforeEach(function() {
+      foo = {
+        calendar: function() {
+          return 'foo';
+        }
+      };
+      window.moment = function() {
+        return foo;
+      };
+
+      spyOn(foo, 'calendar');
+    });
+
+    it('runs .calendar to display the time in words of an event', function() {
+      controller.timeAgoInWords();
+
+      expect(foo.calendar).toHaveBeenCalled();
+    });
+  });
+
+  describe('Commenting', function() {
+    describe('#commentOn', function() {
+      beforeEach(function() {
+        spyOn(controller, 'setSelectedItem');
+        spyOn(homeTool, 'newCommentOn');
+      });
+
+      it('builds and sets the item', function() {
+        controller.commentOn();
+
+        expect(controller.setSelectedItem).toHaveBeenCalled();
+        expect(homeTool.newCommentOn).toHaveBeenCalled();
+      });
+    });
+
+    describe('#closeCommentForm', function() {
+      it('removes the selected item from being commented on', function() {
+        var item = {};
+        controller.setSelectedItem(item);
+
+        expect(controller.isCommentingOn(item)).toEqual(true);
+
+        controller.closeCommentForm();
+
+        expect(controller.isCommentingOn(item)).toEqual(false);
+      });
+    });
+
+    describe('#isCommentingOn', function() {
+      it('returns whether the selected item is currently selected for commenting', function() {
+        var item = {};
+
+        expect(controller.isCommentingOn(item)).toEqual(false);
+
+        controller.setSelectedItem(item);
+
+        expect(controller.isCommentingOn(item)).toEqual(true);
+      });
+    });
+
+    describe('#saveComment', function() {
+      beforeEach(function() {
+        spyOn(controller, 'closeCommentForm');
+      });
+
+      describe('when the input field is empty', function() {
+        beforeEach(function() {
+          spyOn(homeTool, 'getCommentModel').and.callFake(function() {
+            return { text: '' };
+          });
+        });
+
+        it('closes the commenting form', function() {
+          controller.saveComment();
+
+          expect(controller.closeCommentForm).toHaveBeenCalled();
+        });
+      });
+
+      describe('when the input field is populated', function() {
+        beforeEach(function() {
+          spyOn(homeTool, 'getCommentModel').and.callFake(function() {
+            return { text: 'Great thought!' };
+          });
+        });
+
+        it('closes the commenting form', function() {
+          controller.saveComment();
+          deferred.resolve({});
+          scope.$apply();
+
+          expect(controller.closeCommentForm).toHaveBeenCalled();
+        });
+      });
+    });
+  });
+
+  describe('#show', function() {
+    it('should set the appropriate mode', function() {
+      controller.show('profiles');
+      expect(controller.inFeedBrowseMode()).toBeFalsy();
+      controller.show('feed');
+      expect(controller.inFeedBrowseMode()).toBeTruthy();
+    });
+  });
+
+  describe('#saveOnYourMind', function() {
+    describe('when successful', function() {
+      it('should return to feed mode and add the statement to the feed', function() {
+        controller.saveOnYourMind();
+        deferred.resolve({ feedItems: 'feed item' });
+        controller.resetFeed = function() { return true; }
+        scope.$apply();
+
+        expect(controller.inFeedBrowseMode()).toBeTruthy();
+        expect(controller.feedItems.length).toBe(1);
+      });
+    });
+
+    describe('when unsuccessful', function() {
+      it('should set the error', function() {
+        controller.newOnYourMindStatement();
+        controller.saveOnYourMind();
+        deferred.reject({ error: 'baz' });
+        scope.$apply();
+
+        expect(controller.inOnYourMindEntryMode()).toBeTruthy();
+        expect(controller.feedItems.length).toBe(0);
+        expect(controller.error).toBe('baz');
+      });
+    });
+  });
+
+  describe('#getMore', function() {
+    describe('when feed is disabled', function() {
+      it('remains disabled', function() {
+        controller.feedDisabled = true;
+        controller.getMore();
+
+        expect(controller.feedDisabled).toBe(true);
+      });
+    });
+
+    describe('when feed is enabled', function() {
+      it('is set to disabled', function() {
+        controller.feedDisabled = false;
+        controller.getMore();
+
+        expect(controller.feedDisabled).toBe(true);
+      });
+
+      describe('when promise resolves', function() {
+        function getMore(items) {
+          items = items || [];
+          controller.getMore();
+          deferred.resolve({data: {feedItems: items}});
+          scope.$digest();
+        }
+
+        describe('when feed items exist', function() {
+          var items = ['foo'];
+
+          it('sets concatenated feed items', function() {
+            controller.feedItems = ['bar']
+            getMore(items);
+
+            expect(controller.feedItems).toEqual(['bar', 'foo']);
+          });
+
+          it('disables feed', function() {
+            controller.feedDisabled = false;
+            getMore(items);
+
+            expect(controller.feedDisabled).toBe(false);
+          });
+
+          it('increments the page number', function() {
+            controller.page = 1;
+            getMore(items);
+
+            expect(controller.page).toBe(2);
+          });
+        });
+
+        describe('when no feed items exist', function() {
+          function getFixture() {
+            return $('#jasmine_content');
+          }
+
+          function getFeed() {
+            return getFixture()
+                   .append('<div id="infinite-feed" infinite-scroll-disabled="false" />')
+                   .find('#infinite-feed');
+          }
+
+          it('disables infinite scroll', function() {
+            var feed = getFeed();
+            
+            expect(feed.attr('infinite-scroll-disabled')).toBe('false');
+
+            getMore();
+
+            expect(feed.attr('infinite-scroll-disabled')).toBe('true');
+          });
+        });
+      });
+    });
+  });
+
+  describe('#associationCount', function() {
+    it('returns the number of associations', function() {
+      var item = {};
+      item.likes = [{ participantId: 1 }];
+
+      expect(controller.associationCount(item.likes))
+        .toEqual(1);
+    });
+
+    it('returns the count of 0 if no associations exist', function() {
+      var item = {};
+
+      expect(controller.associationCount(item.likes))
+        .toEqual(0);
+    });
+  });
+
+  describe('#hasLikeableContent', function() {
+    it('returns true if the item is not a nudge', function() {
+      expect(controller.hasLikeableContent({ description: 'foo' }))
+        .toEqual(true);
+    });
+
+    it('returns false if the item is not a nudge', function() {
+      expect(controller.hasLikeableContent({ description: 'nudge' }))
+        .toEqual(false);
+    });
+  });
+
+  describe('#isLikeable', function() {
+    it('returns false if the item is a nudge', function() {
+      expect(controller.isLikeable({ description: 'nudge' }))
+        .toEqual(false);
+    });
+
+    it('returns false if the item has already been liked by the participant', function() {
+      var item = {};
+      item.likes = [{ participantId: 123 }];
+
+      expect(controller._participantId)
+        .toEqual(123);
+      expect(controller.isLikeable(item))
+        .toEqual(false);
+    });
+
+    it('returns true if the item has not been liked by the current participant and the item is not a nudge', function() {
+      var item = {};
+      item.description = 'foo';
+      item.likes = [{ participantId: 1 }];
+
+      expect(controller._participantId)
+        .toEqual(123);
+      expect(controller.isLikeable(item))
+        .toEqual(true);
+    });
+  });
+});
+})();
+

data/spec/javascripts/social_networking/new_shareable_form_spec.js

@@ -0,0 +1,91 @@
+//= require jquery
+//= require shared/new_shareable_form
+
+'use strict';
+
+describe('addSharingToNewShareableForm', function() {
+  var ACTION_TYPE,
+      ITEM_TYPE;
+
+  ITEM_TYPE = 'activity';
+  ACTION_TYPE = 'planned';
+
+  function getFixture() {
+    return $('#jasmine_content');
+  };
+
+  function getPage() {
+    return getFixture()
+           .find('.new-shareable-form-after-form-groups');
+  };
+
+  function initListener(listener) {
+    $(document).trigger(listener);
+  };
+
+  function setPage() {
+    return getFixture()
+           .append('<span class="new-shareable-form-after-form-groups" data-item-type="' + ITEM_TYPE + '" data-action-type="' + ACTION_TYPE + '"></span>');
+  };
+
+  function setOtherPage() {
+    return getFixture();
+  };
+
+  afterEach(function() {
+    $('#jasmine_content').empty();
+  });
+
+  describe('when page does not have shareable field', function() {
+    describe('addSharingToNewShareableForm', function() {
+      describe('on page change', function() {
+        it('doesn\'t throw an error', function() {
+          setOtherPage();
+
+          expect(function() {
+            initListener('page:change')
+          }).not.toThrowError(TypeError);
+        });
+      });
+    });
+  });
+
+  describe('when page has shareable field', function() {
+    beforeEach(function() {
+      setPage();
+    });
+
+    describe('addSharingToNewShareableForm', function() {
+      describe('on page change', function() {
+        beforeEach(function() {
+          initListener('page:change');
+        });
+
+        it('formats label for attribute', function() {
+          expect(getPage().find('label[for=' + ITEM_TYPE + '_shared_item]').length)
+            .toEqual(1);
+        });
+
+        it('formats label content', function() {
+          expect(getPage().find('label[for=' + ITEM_TYPE + '_shared_item]').text())
+            .toMatch('Share the content of this ' + ITEM_TYPE);
+        });
+
+        it('formats "yes" radio input', function() {
+          expect(getPage().find('input#' + ITEM_TYPE + '_shared_item_1[value=1]').length)
+            .toEqual(1);
+        });
+
+        it('formats "no" radio input', function() {
+          expect(getPage().find('input#' + ITEM_TYPE + '_shared_item_2[value=0]').length)
+            .toEqual(1);
+        });
+
+        it('formats hidden inputs', function() {
+          expect(getPage().find('[type="hidden"][value=' + ACTION_TYPE + ']').length)
+            .toEqual(1);
+        });
+      });
+    });
+  });
+});

data/spec/javascripts/social_networking/notices_spec.js

@@ -0,0 +1,44 @@
+describe('Notice', function() {
+  var server, noticeUtility, callback;
+  var actionType, description, participantId;
+
+  beforeEach(function() {
+    actionType = "SocialNetworking::Goal";
+    description = "Completed a goal."
+    participantId = 1;
+
+    server = sinon.fakeServer.create();
+    callback = sinon.spy();
+    noticeUtility = window.Notice
+  });
+
+  afterEach(function() {
+    server.restore();
+  });
+
+  describe('#behaviorPostNotice', function() {
+    it('should trigger #behaviorRealTimeToast upon success', function() {
+      expect(noticeUtility.behaviorPostNotice).toBeTruthy();
+      noticeUtility.behaviorRealTimeToast = callback;
+      noticeUtility.behaviorPostNotice(actionType, description, participantId);
+
+      expect(server.requests.length).toBe(1);
+      expect(server.requests[0].url).toBe("/participant_behaviors/complete");
+    });
+  });
+
+  describe('#incentivePostNotice', function() {
+    it('should trigger #incentivRealTimeToast upon success', function() {
+      expect(noticeUtility.incentivePostNotice).toBeTruthy();
+      noticeUtility.incentivRealTimeToast = callback;
+      noticeUtility.incentivePostNotice(actionType, description, participantId);
+
+      expect(server.requests.length).toBe(1);
+      expect(server.requests[0].url).toBe("/participant_incentives/complete");
+    });
+  });
+
+  it('should offer a public incentive specific notification function (behaviorPostNotice)', function() {
+    expect(noticeUtility.behaviorPostNotice).toBeTruthy();
+  });
+});