social_networking 0.9.3

data/spec/javascripts/social_networking/profile/profile-answer-controller_spec.js

@@ -0,0 +1,174 @@
+describe('ProfileAnswerCtrl', function() {
+  var $q, $rootScope, $window, answerId, answerText, controller,
+      newAnswer, profileId, profileAnswers, questionId, questions;
+
+  beforeEach(module('socialNetworking.controllers'));
+
+  beforeEach(inject(function($controller, _$rootScope_, _$q_, _$window_) {
+    $rootScope = _$rootScope_;
+    $q = _$q_;
+    $window = _$window_;
+    answerId = 'foo';
+    answerText = 'I love it!';
+    controller = $controller;
+    profileId = 'bar';
+    questionId = 'alas';
+    questions = [
+      {
+        id: questionId,
+        question_text: 'What are your hobbies?'
+      }
+    ];
+    savedAnswer = {
+      id: answerId,
+      answer_text: answerText,
+      profile_id: profileId,
+      profile_question_id: questionId
+    };
+  }));
+
+  describe('#ifAnswered', function() {
+    beforeEach(function() {
+      controller = controller('ProfileAnswerCtrl', {
+        ProfileAnswers: function() {}
+      });
+    });
+
+    it('returns `true` if the participant has answered at least one profile question', function() {
+      controller.answerModels = {}
+      controller.answerModels[questionId] = savedAnswer;
+
+      expect(controller.ifAnswered(questions)).toBe(true);
+    });
+
+    it('returns `false` if the participant has not answered at least one profile question', function() {
+      controller.answerModels = {};
+
+      expect(controller.ifAnswered(questions)).toBe(false);
+    });
+  });
+
+  describe('#save', function() {
+    beforeEach(function() {
+      newAnswer = {
+        answer_text: answerText,
+        profile_id: profileId,
+        profile_question_id: questionId
+      };
+
+      profileAnswers = jasmine.createSpyObj('profileAnswers', ['create', 'getOne']);
+
+      profileAnswers.getOne.and.callFake(function() {
+        var deferred, promise;
+
+        deferred = $q.defer();
+        promise = deferred.promise;
+        deferred.resolve(savedAnswer);
+        return promise;
+      });
+
+      profileAnswers.create();
+    });
+
+    describe('when saving succeeds', function() {
+      beforeEach(function() {
+        profileAnswers.create.and.callFake(function() {
+          var deferred, promise;
+
+          deferred = $q.defer();
+          promise = deferred.promise;
+          deferred.resolve();
+          return promise;
+        });
+
+        controller = controller('ProfileAnswerCtrl', {
+          ProfileAnswers: profileAnswers
+        });
+
+        controller.setModel(newAnswer);
+      });
+
+      it('adds the newly created answer to the collection of answers', function() {
+        expect(controller.answerModels[questionId].id).toBe(undefined);
+
+        controller.save(profileId, questionId);
+        $rootScope.$apply();
+
+        expect(controller.answerModels[questionId]).toEqual(savedAnswer);
+      });
+
+      it('updates the collection of answer states', function() {
+        expect(controller._answerStates[questionId]).toBe(undefined);
+
+        controller.save(profileId, questionId);
+        $rootScope.$apply();
+
+        expect(controller._answerStates[questionId].editable).toBe(false);
+      });
+    });
+
+    describe('answer model is a new object', function() {
+      var callProfileAnswersRejectCreate = function(messageObject) {
+        profileAnswers.create.and.callFake(function() {
+          var deferred, promise;
+
+          deferred = $q.defer();
+          promise = deferred.promise;
+          deferred.reject(messageObject);
+          return promise;
+        });
+      };
+
+      describe('when saving fails with an error message', function() {
+        beforeEach(function() {
+          callProfileAnswersRejectCreate({ data: { error: 'Holy guacamole!' } });
+          controller = controller('ProfileAnswerCtrl', {
+            ProfileAnswers: profileAnswers
+          });
+          controller.setModel(newAnswer);
+        });
+
+        it('displays a confirm message to the user', function() {
+          spyOn($window, 'confirm');
+
+          expect($window.confirm).not.toHaveBeenCalled();
+
+          controller.save(profileId, questionId);
+          $rootScope.$apply();
+
+          expect($window.confirm).toHaveBeenCalled();
+        });
+
+        it('does not save the answer to the collection of answers', function() {
+          expect(controller.answerModels[questionId].id).toBe(undefined);
+
+          controller.save(profileId, questionId);
+          $rootScope.$apply();
+
+          expect(controller.answerModels[questionId].id).toBe(undefined);
+        });
+      });
+
+      describe('when saving fails without an error message', function() {
+        beforeEach(function() {
+          callProfileAnswersRejectCreate();
+          controller = controller('ProfileAnswerCtrl', {
+            ProfileAnswers: profileAnswers
+          });
+          controller.setModel(newAnswer);
+        });
+
+        it('displays a confirm dialog to the user', function() {
+          spyOn($window, 'confirm');
+
+          expect($window.confirm).not.toHaveBeenCalled();
+
+          controller.save(profileId, questionId);
+          $rootScope.$apply();
+
+          expect($window.confirm).toHaveBeenCalled();
+        });
+      });
+    });
+  });
+});

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

@@ -0,0 +1,80 @@
+describe('ProfileCtrl', function() {
+  var controller,
+      mockAlertService,
+      profileService,
+      nudgeService,
+      scope,
+      q,
+      deferred,
+      deferredNudgeCreate,
+      deferredProfileUpdate;
+  
+  beforeEach(function() {
+    // load the module with the controller to test
+    module('socialNetworking.controllers');
+
+    mockAlertService = {
+      addError: function() {}
+    };
+    profileService = {
+      getOne: function(profileId) {
+        deferred = q.defer();
+        return deferred.promise;
+      },
+      update: function() {
+        deferredProfileUpdate = q.defer();
+        return deferredProfileUpdate.promise;
+      }
+    };
+    nudgeService = {
+      create: function() {
+        deferredNudgeCreate = q.defer();
+        return deferredNudgeCreate.promise;
+      }
+    };
+  });
+
+  beforeEach(inject(function($rootScope, $q, $controller) {
+    scope = $rootScope;
+    q = $q;
+    controller = $controller('ProfileCtrl', {
+      alertService: mockAlertService,
+      profileId: 1,
+      Profiles: profileService,
+      Nudges: nudgeService
+    });
+  }));
+
+  it('should set the id', function() {
+    deferred.resolve({ id: '1' });
+    scope.$digest();
+
+    expect(controller.id).toBe('1');
+  });
+
+  it('displays alert message when nudge fails', function() {
+    spyOn(mockAlertService, 'addError');
+    controller.nudge();
+    deferredNudgeCreate.reject({ data: { error: '' } });
+    scope.$digest();
+
+    expect(mockAlertService.addError).toHaveBeenCalled();
+  });
+
+  it('displays alert message when profile icon is not found', function() {
+    spyOn(mockAlertService, 'addError');
+    deferred.reject({ data: { error: '' } });
+    scope.$digest();
+
+    expect(mockAlertService.addError).toHaveBeenCalled();
+  });
+
+  it('displays alert message when profile updating fails', function() {
+    spyOn(mockAlertService, 'addError');
+    controller.updateProfileIcon('');
+    deferredProfileUpdate.reject({ data: { error: '' } });
+    scope.$digest();
+
+    expect(mockAlertService.addError).toHaveBeenCalled();
+  });
+});

data/spec/javascripts/social_networking/services/AlertSpec.js

@@ -0,0 +1,43 @@
+describe('Alert', function() {
+  var alertService;
+
+  beforeEach(module('socialNetworking.services'));
+
+  beforeEach(function() {
+    inject(function($injector) {
+      alertService = $injector.get('alertService');
+    });
+  });
+
+  describe('#addError', function() {
+    it('adds an error alert to the alerts array', function() {
+      expect(alertService.alerts).toEqual([]);
+
+      alertService.addError("Big Peanut");
+
+      expect(alertService.alerts).toEqual([{
+        cssClass: "alert-danger",
+        message: "Big Peanut"
+      }])
+    });
+  });
+
+  describe('#getAlerts', function() {
+    it('returns all alerts', function() {
+      expect(alertService.getAlerts()).toEqual([]);
+
+      alertService.alerts = ['foo']
+
+      expect(alertService.getAlerts()).toEqual(['foo']);
+    });
+  });
+
+  describe('#removeAlert', function() {
+    it('removes alert from array of alerts', function() {
+      alertService.alerts = ['alert']
+      alertService.removeAlert('alert');
+
+      expect(alertService.alerts).toEqual([]);
+    });
+  });
+});

data/spec/mailers/social_networking/mailer_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+module SocialNetworking
+  describe Mailer do
+    describe ".notify" do
+      let(:recipient) { instance_double(Participant, email: "obama@ex.co") }
+
+      it "delivers an email" do
+        expect do
+          Mailer
+            .notify(
+              recipient: recipient,
+              body: "foo",
+              subject: "bar")
+            .deliver_now
+        end.to change { ActionMailer::Base.deliveries.count }.by(1)
+      end
+    end
+  end
+end

data/spec/models/social_networking/comment_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+module SocialNetworking
+  describe Comment, type: :model do
+    fixtures(:participants, :"social_networking/goals")
+    let(:participant1) { participants(:participant1) }
+    let(:goal) { social_networking_goals(:participant2_goal_alpha) }
+
+    it "should return the number of comments made today" do
+      expect do
+        Comment.create(
+          participant_id: participant1.id,
+          item: goal,
+          text: "love this test",
+          created_at: Date.today
+        )
+      end.to change { Comment.for_today.count }.by(1)
+    end
+
+    it "should return the number of comments made in the past seven days" do
+      expect do
+        Comment.create(
+          participant_id: participant1.id,
+          item: goal,
+          text: "love this test",
+          created_at: Date.today - 1.days
+        )
+
+        Comment.create(
+          participant_id: participant1.id,
+          item: goal,
+          text: "love this test",
+          created_at: Date.today - 8.days
+        )
+      end.to change { Comment.for_week.count }.by(1)
+    end
+  end
+end

data/spec/models/social_networking/concerns/participant_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+module SocialNetworking
+  module Concerns
+    RSpec.describe Participant do
+      describe "validations" do
+        context "contact preference is selected" do
+          it "is invalid if email is not provided" do
+            expect(::Participant
+              .new(contact_preference: "email")
+              .tap(&:valid?)
+              .errors[:email]).to include "can't be blank"
+          end
+
+          it "is invalid if phone number is not provided" do
+            expect(::Participant
+              .new(contact_preference: "sms")
+              .tap(&:valid?)
+              .errors[:phone_number]).to include "can't be blank"
+          end
+
+          it "is invalid if phone number is not provided" do
+            expect(::Participant
+              .new(contact_preference: "phone")
+              .tap(&:valid?)
+              .errors[:phone_number]).to include "can't be blank"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/social_networking/goal_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+module SocialNetworking
+  describe Goal, type: :model do
+    fixtures(:participants)
+    let(:participant) { participants(:participant1) }
+
+    it "should prevent due dates in the past" do
+      goal = Goal.create(due_on: Date.today.advance(days: -1))
+
+      expect(goal.errors[:due_on].length).to eq(1)
+    end
+
+    it "should prevent dates past the end of the study membership" do
+      allow(participant).to receive(:active_membership_end_date) { Date.today }
+      goal = Goal.create(participant: participant,
+                         due_on: Date.today.advance(days: 1))
+
+      expect(goal.errors[:due_on].length).to eq(1)
+    end
+
+    it "should return the number of goals made today" do
+      count = Goal.for_today.count
+
+      Goal.create(
+        participant_id: participant.id,
+        description: "Write a test that passes.",
+        created_at: Date.today
+      )
+
+      expect(Goal.for_today.count).to eq(count + 1)
+    end
+
+    it "should return the number of goals made in the past seven days" do
+      count = Goal.for_week.count
+
+      Goal.create(
+        participant_id: participant.id,
+        description: "Write a test that passes.",
+        created_at: Date.today - 1.day
+      )
+
+      Goal.create(
+        participant_id: participant.id,
+        description: "Write a test that passes.",
+        created_at: Date.today - 8.days
+      )
+
+      expect(Goal.for_week.count).to eq(count + 1)
+    end
+
+    describe ".to_serialized" do
+      def goal(attributes = {})
+        Goal.create({
+          participant: participant,
+          description: "foo",
+          due_on: Date.today
+        }.merge(attributes))
+      end
+
+      it "sets `dueOn` property with correct format" do
+        expect(goal.to_serialized[:dueOn])
+          .to eq Date.today.to_s(:participant_date)
+      end
+
+      it "returns an empty hash if `due_on` is nil" do
+        expect(goal(due_on: nil).to_serialized)
+          .to eq({})
+      end
+    end
+
+    context "with goal sample data" do
+      fixtures(:all)
+
+      it "should return an incomplete goal" do
+        expect(Goal.did_not_complete.count).to be > 0
+      end
+
+      it "should return no incomplete goals" do
+        expect { Goal.find_by(description: "p1 omega").delete }
+          .to change { Goal.did_not_complete.count }.by(-1)
+      end
+    end
+
+    context ".action" do
+      def goal(attributes = {})
+        Goal.create({
+          participant: participant,
+          description: "DESCription",
+          due_on: Date.today
+        }.merge(attributes))
+      end
+
+      it "is 'Completed' if the goal was completed" do
+        expect(goal(
+          completed_at: Date.today.advance(days: -2)
+        ).action).to eq "Completed"
+      end
+
+      it "is 'Did Not Complete' if in the past and goal not completed" do
+        expect(goal(
+          due_on: Date.today.advance(days: -1)
+        ).action).to eq "Did Not Complete"
+      end
+
+      it "is 'Created' if due on is nil" do
+        expect(goal(
+          due_on: nil
+        ).action).to eq "Created"
+      end
+
+      it "is 'Created' when due in the future and goal is not completed" do
+        puts "mock #{ Time.zone.today + 1.day }"
+        expect(goal(
+          due_on: Time.zone.today + 1.day
+        ).action).to eq "Created"
+      end
+    end
+  end
+end

data/spec/models/social_networking/like_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+module SocialNetworking
+  describe Like, type: :model do
+    fixtures(:participants, :"social_networking/goals")
+    let(:participant1) { participants(:participant1) }
+    let(:goal) { social_networking_goals(:participant2_goal_alpha) }
+
+    it "should return the number of likes given today" do
+      count = Like.for_today.count
+
+      Like.create(
+        participant_id: participant1.id,
+        item_id: goal.id,
+        item_type: "SocialNetworking::Goal",
+        created_at: Date.today
+      )
+
+      expect(Like.for_today.count).to eq(count + 1)
+    end
+
+    it "should return the number of likes given in the past seven days" do
+      count = Like.for_week.count
+
+      Like.create(
+        participant_id: participant1.id,
+        item_id: goal.id,
+        item_type: "SocialNetworking::Goal",
+        created_at: Date.today - 1.day
+      )
+
+      Like.create(
+        participant_id: participant1.id,
+        item_id: goal.id,
+        item_type: "SocialNetworking::Goal",
+        created_at: Date.today - 8.days
+      )
+
+      expect(Like.for_week.count).to eq(count + 1)
+    end
+
+    context "#item_description is called" do
+      it "should return an description for SharedItem type" do
+        shareable = double("shareable", description: "goal description")
+        goal = double("goal", description: "goal description", id: 1)
+        shared_item = double("shared_item",
+                             item_type: "SocialNetworking::Goal",
+                             item: goal)
+        goal_like = create_generic_like(participant1.id,
+                                        goal.id,
+                                        "SocialNetworking::SharedItem")
+        expect(goal_like).to receive(:item).exactly(2).times { shared_item }
+        expect(Shareable).to receive(:new) { shareable }
+        expect(goal_like.item_description)
+          .to eq("goal description")
+      end
+
+      it "should return a description for onTheMindStatement likes" do
+        shareable = double("shareable", description: "otms description")
+        otms_like = create_generic_like(participant1.id,
+                                        goal.id,
+                                        "SocialNetworking::OnTheMindStatement")
+        expect(Shareable).to receive(:new) { shareable }
+        expect(otms_like.item_description).to eq("otms description")
+      end
+
+      it "should return a generic description for a nil item" do
+        unknown_like = create_generic_like(participant1.id,
+                                           goal.id,
+                                           "SocialNetworking::SharedItem")
+        shareable =
+          double("shareable",
+                 description: "Description not available for this item.")
+        expect(unknown_like).to receive(:item) { nil }
+        expect(Shareable).to receive(:new) { shareable }
+        expect(unknown_like.item_description)
+          .to eq("Description not available for this item.")
+      end
+
+      def create_generic_like(participant_id, item_id, item_type)
+        Like.create(
+          participant_id: participant_id,
+          item_id: item_id,
+          item_type: item_type,
+          created_at: Date.today - 1.day
+        )
+      end
+    end
+  end
+end

data/spec/models/social_networking/notification_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+module SocialNetworking
+  RSpec.describe Notification do
+    let(:participant) { instance_double(Participant) }
+    let(:recipient) { instance_double(Participant) }
+    let(:mailer) { double("mailer") }
+
+    def notification(attributes = {})
+      Notification.new({
+        current_participant: participant,
+        mailer: mailer,
+        recipient: recipient,
+        message_body: "foo",
+        subject: "bar"
+      }.merge(attributes))
+    end
+
+    describe ".notify" do
+      describe "when recipient is the current_participant" do
+        it "returns nil" do
+          new_notification = notification(recipient: participant)
+
+          expect(new_notification.notify).to be_nil
+        end
+      end
+
+      describe "when recipient is not the current_participant" do
+        describe "when recipient would prefer to receive emails" do
+          it "sends an email" do
+            allow(recipient)
+              .to receive(:contact_preference) { "email" }
+
+            expect_any_instance_of(Notification)
+              .to receive(:send_email)
+
+            notification.notify
+          end
+        end
+
+        describe "when recipient would prefer to receive sms" do
+          it "sends an sms" do
+            allow(recipient)
+              .to receive(:contact_preference) { "sms" }
+
+            expect_any_instance_of(Notification)
+              .to receive(:send_sms)
+
+            notification.notify
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/social_networking/nudge_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+module SocialNetworking
+  describe Nudge, type: :model do
+    fixtures(:participants, :"social_networking/goals")
+    let(:participant1) { participants(:participant1) }
+    let(:participant2) { participants(:participant2) }
+    let(:goal) { social_networking_goals(:participant2_goal_alpha) }
+
+    it "should return the nudges given today" do
+      count = Nudge.for_today.count
+
+      Nudge.create(
+        initiator_id: participant1.id,
+        recipient_id: participant2.id,
+        created_at: Date.today
+      )
+
+      expect(Nudge.for_today.count).to eq(count + 1)
+    end
+
+    it "should return the number of nudges given in the past seven days" do
+      count = Nudge.for_week.count
+
+      Nudge.create(
+        initiator_id: participant1.id,
+        recipient_id: participant2.id,
+        created_at: Date.today - 1.day
+      )
+
+      Nudge.create(
+        initiator_id: participant1.id,
+        recipient_id: participant2.id,
+        created_at: Date.today - 8.days
+      )
+
+      expect(Nudge.for_week.count).to eq(count + 1)
+    end
+  end
+end