notify_user 0.1.4 → 0.3.1

data/spec/dummy/rails-4.1.0/test/test_helper.rb

@@ -4,9 +4,6 @@ require 'rails/test_help'
 
 class ActiveSupport::TestCase
   # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
-  #
-  # Note: You'll currently still have to declare fixtures explicitly in integration tests
-  # -- they do not yet inherit this setting
   fixtures :all
 
   # Add more helper methods to be used by all tests here...

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/2iFf6DF21eHswaXamThRpysQhZa4HHhfXSwW0I26I_Q.cache

@@ -0,0 +1,3 @@
+[o:Set:
+@hash{
+I"environment-version:ETTI"environment-paths;TTI"0processors:type=text/css&file_type=text/css;TTI"hfile-digest:///Users/anton/workspace/notify_user/app/assets/stylesheets/notify_user/notify_user.css;TTI">processors:type=text/css&file_type=text/css&pipeline=self;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/8DepzOh5SIwaxC825zft8xeBhAi84AFjIkQLBafpfcI.cache

@@ -0,0 +1 @@
+I"
�/Users/anton/workspace/notify_user/app/assets/javascripts/notify_user/notification.js?type=application/javascript&id=61149a8231535cdb0802ac42bc4d3dd4fdf7bbf78e0982d49b32ebd61f1b476a:ET

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/DFBSCnNmEyoM8roYdJ4CwzgAxnyRtTG3S2qD1ryqXxw.cache

@@ -0,0 +1 @@
+"%cK��P�A��G��D�,_���|�aLa�

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/DcdyyraxoBKSYh1m6Spmfn5Qtn0V2X2t8aO3dmAi0Po.cache

@@ -0,0 +1,3 @@
+[o:Set:
+@hash{
+I"environment-version:ETTI"environment-paths;TTI"Lprocessors:type=application/javascript&file_type=application/javascript;TTI"hfile-digest:///Users/anton/workspace/notify_user/app/assets/javascripts/notify_user/notification.js;TTI"Zprocessors:type=application/javascript&file_type=application/javascript&pipeline=self;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/IO46kchRzb_wUQ8H3D25_DHv7lZK4CxthkOj6ZKp8mQ.cache

@@ -0,0 +1 @@
+I"
�app/assets/stylesheets/application.css?type=text/css&pipeline=self&id=672f11df0f160c5378abcd1e434ad390158f0454aa8d02baf25e6ecd3efb74aa:ET

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/JTg9Khb4iQ4MkGt2OoYdfz6rYD9ccxMNxCOnVK92fJA.cache

@@ -0,0 +1 @@
+I"}app/assets/stylesheets/application.css?type=text/css&id=76743947a4cb49f7dd528768c04b9a6e6672cc40163dcbbc5ed210817e510c9a:ET

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/O8akbUwAbmIKY-AhITimq-JDQ6IgsO3Hvq2v5etufFw.cache

@@ -0,0 +1,2 @@
+[o:Set:
+@hash{I"environment-version:ETTI"environment-paths;TTI"0processors:type=text/css&file_type=text/css;TTI"9file-digest://app/assets/stylesheets/application.css;TTI">processors:type=text/css&file_type=text/css&pipeline=self;TTI")file-digest://app/assets/stylesheets;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/TWJMA4bg5d25falxiw_TLK0GtSXWpfl0vFaFLRpkYKI.cache

@@ -0,0 +1 @@
+I"
�/Users/anton/workspace/notify_user/app/assets/stylesheets/notify_user/notify_user.css?type=text/css&id=d4136d011f761b73a3eda9c8d266e35003ee1ed5ea674226210259697dc0392f:ET

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/Y829B5qbE0t7idbBscHZCJxlb-D9S6G_8P6HwwMe7J4.cache

@@ -0,0 +1,2 @@
+[o:Set:
+@hash{	I"environment-version:ETTI"environment-paths;TTI">processors:type=text/css&file_type=text/css&pipeline=self;TTI"hfile-digest:///Users/anton/workspace/notify_user/app/assets/stylesheets/notify_user/notify_user.css;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/cjXxcrFHyMpHUOqA38Yaft85pmxR7gZ4__TFcgJQyKA.cache

@@ -0,0 +1 @@
+"%��Rm�v�S3.��O�L���ڹc�ƕq�=_j�

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/j52KuMJNJLJcKPVLf8rk8USLswZAmy6Hi1OW35JjVTo.cache

@@ -0,0 +1 @@
+"%]!�K��X�K�֓�ޖ���';�����4x��

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/mwsAf4xggfO0hGKNns79uKcXG7B5rk8a4Zav3vXyr6M.cache

@@ -0,0 +1,2 @@
+[o:Set:
+@hash{	I"environment-version:ETTI"environment-paths;TTI"Zprocessors:type=application/javascript&file_type=application/javascript&pipeline=self;TTI"hfile-digest:///Users/anton/workspace/notify_user/app/assets/javascripts/notify_user/notification.js;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/tPF6H9NRpGO3whu2y5_e_R_1EACKdCwu5437D83qJT0.cache

@@ -0,0 +1,3 @@
+[o:Set:
+@hash{
+I"environment-version:ETTI"environment-paths;TTI">processors:type=text/css&file_type=text/css&pipeline=self;TTI"9file-digest://app/assets/stylesheets/application.css;TTI")file-digest://app/assets/stylesheets;TT

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/x5V5ICXz753PW9A8l6gpNAh_utfwyXyixuUxtMgJ2Pg.cache

@@ -0,0 +1 @@
+I"
�/Users/anton/workspace/notify_user/app/assets/stylesheets/notify_user/notify_user.css?type=text/css&pipeline=self&id=7b0fca9fe7e02f6095e89c0640e6b1fc71949c6242d7ffbc37bd1e22a2b02f33:ET

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/y8AwtETeMIB25XCoxQDwn3DmMpUFLblIFK4yb18zN4c.cache

@@ -0,0 +1 @@
+"%�p���X|���Q&�L;&�t]��
ZP}O

data/spec/dummy/rails-4.1.0/tmp/cache/assets/test/sprockets/v3.0/yWa5z3IIFR71QlDOGDwO5IpC9vsVUGFNfficVy0q3zo.cache

@@ -0,0 +1 @@
+I"
�/Users/anton/workspace/notify_user/app/assets/javascripts/notify_user/notification.js?type=application/javascript&pipeline=self&id=62e64bb794f52761bc30a0a0d7f32de7347579aff22beb3d7483bfea4c2da37b:ET

data/spec/factories/notify_user_notifications.rb

@@ -1,10 +1,7 @@
-# Read about factories at https://github.com/thoughtbot/factory_girl
-
 FactoryGirl.define do
-  factory :notify_user_notification, :class => 'Notification' do
-    type ""
-    target_id 1
-    target_type "MyString"
-    params "MyText"
+  factory :notify_user_notification, class: 'NewPostNotification' do
+    params {{ data: 'My Data' }}
+
+    association :target, factory: :user
   end
 end

data/spec/factories/users.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :user do
+    sequence :email do |n|
+      "#{n}@notifyuser.com"
+    end
+  end
+end

data/spec/lib/notify_user/channels/apns_channel_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ApnsChannel do
+  let(:user) { User.create({email: 'user@example.com' })}
+  let(:notification) { NewPostNotification.create({target: user}) }
+
+  before do
+    @android = instance_double('Device', token: 'android_token')
+    @ios = instance_double('Device', token: 'ios_token')
+
+    allow(notification).to receive(:mobile_message) { 'Message' }
+
+    allow_any_instance_of(NotifyUser::Apns).to receive(:push)
+    allow_any_instance_of(NotifyUser::Gcm).to receive(:push)
+  end
+
+  describe 'device spliting' do
+    context 'all devices' do
+      before do
+        devices = double('Device', ios: [@ios], android: [@android])
+        allow_any_instance_of(User).to receive(:devices) { devices }
+      end
+
+      it 'routes the notifications via apns' do
+        @apns = NotifyUser::Apns.new([notification], [@ios], {})
+        expect(NotifyUser::Apns).to receive(:new) { @apns }
+
+        described_class.deliver(notification)
+      end
+
+      it 'routes the notifications via gcm' do
+        @gcm = NotifyUser::Gcm.new([notification], [@android], {})
+        expect(NotifyUser::Gcm).to receive(:new) { @gcm }
+
+        described_class.deliver(notification)
+      end
+    end
+
+    context 'only ios' do
+      before do
+        devices = double('Device', ios: [@ios], android: [])
+        allow_any_instance_of(User).to receive(:devices) { devices }
+      end
+
+      it 'doesnt make use of the gcm route' do
+        expect(NotifyUser::Gcm).not_to receive(:new)
+
+        described_class.deliver(notification)
+      end
+    end
+
+    context 'only android' do
+      before do
+        devices = double('Device', ios: [], android: [@android])
+        allow_any_instance_of(User).to receive(:devices) { devices }
+      end
+
+      it 'doesnt make use of the gcm route' do
+        expect(NotifyUser::Apns).not_to receive(:new)
+
+        described_class.deliver(notification)
+      end
+    end
+  end
+end

data/spec/mailers/notify_user/notification_mailer_spec.rb

@@ -1,32 +1,32 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe NotifyUser::NotificationMailer do
-  describe "notification_email" do
+module NotifyUser
+  describe NotificationMailer do
+    describe 'notification_email' do
+      let(:user) { build(:user) }
+      let(:notification) { NewPostNotification.new(target: user) }
+      let(:mailer) { NotificationMailer.send(:new, 'notification_email', notification, ActionMailerChannel.default_options) }
+      let(:mail) { mailer.notification_email(notification, ActionMailerChannel.default_options) }
 
-    let(:user) { User.new({email: "user@example.com" })}
-    let(:notification) { NewPostNotification.new({target: user}) }
-    let(:mailer) { NotifyUser::NotificationMailer.send(:new, 'notification_email', notification, ActionMailerChannel.default_options) }
-    let(:mail) { mailer.notification_email(notification, ActionMailerChannel.default_options) }
+      before :each do
+        allow(BaseNotification).to receive(:find).and_return(notification)
+      end
 
-    before :each do
-      NotifyUser::BaseNotification.stub(:find).and_return(notification)
-    end
+      it 'renders the headers' do
+        expect(mail.subject).to eq(ActionMailerChannel.default_options[:subject])
+        expect(mail.to).to eq([user.email])
+        expect(mail.from).to eq([NotifyUser.mailer_sender])
+      end
 
-    it "renders the headers" do
-      mail.subject.should eq(ActionMailerChannel.default_options[:subject])
-      mail.to.should eq([user.email])
-      mail.from.should eq([NotifyUser.mailer_sender])
-    end
+      it "renders a template to render the notification's template as a partial" do
+        mailer_should_render_template(mailer, 'notify_user/action_mailer/notification')
+        mail
+      end
 
-    it "renders a template to render the notification's template as a partial" do
-      mailer_should_render_template(mailer, "notify_user/action_mailer/notification")
-      mail
+      it 'renders with a layout' do
+        allow_any_instance_of(NotificationMailer).to receive(:notification).and_return(notification)
+        expect(mail.body.raw_source).to include 'This is the default generated layout'
+      end
     end
-
-    it "renders with a layout" do
-      NotifyUser::NotificationMailer.any_instance.stub(:notification).and_return(notification)
-      mail.body.raw_source.should include "This is the default generated layout"
-    end
-
   end
 end

data/spec/models/notify_user/apn_connection_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module NotifyUser
+  describe APNConnection do
+    describe 'pem file paths' do
+      before :each do
+        @connection = described_class.new
+      end
+
+      it 'has the correct default development path' do
+        expect(@connection.send(:development_certificate)).to eq "#{Rails.root}/config/keys/development_push.pem"
+      end
+
+      it 'has the correct default production path' do
+        expect(@connection.send(:production_certificate)).to eq "#{Rails.root}/config/keys/production_push.pem"
+      end
+
+      it 'can set a custom path for development' do
+        ENV['APN_DEVELOPMENT_PATH'] = 'path/to/key.pem'
+        expect(@connection.send(:development_certificate)).to eq "#{Rails.root}/path/to/key.pem"
+      end
+
+      it 'can set a custom path for production' do
+        ENV['APN_PRODUCTION_PATH'] = 'path/to/key.pem'
+        expect(@connection.send(:production_certificate)).to eq "#{Rails.root}/path/to/key.pem"
+      end
+    end
+  end
+end

data/spec/models/notify_user/apns_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+require 'support/test_apn_connection'
+
+module NotifyUser
+  describe Apns do
+    let(:user) { create(:user, email: 'user@example.com') }
+    let(:notification) { create(:notify_user_notification, target: user) }
+
+    describe 'initialisation' do
+      before :each do
+        @apns = Apns.new([notification], [], {})
+      end
+
+      describe 'push options' do
+        it 'sets the mobile message' do
+          expect(@apns.push_options[:alert]).to eq notification.mobile_message
+        end
+
+        it 'sets the badge to 1' do
+          expect(@apns.push_options[:badge]).to eq 1
+        end
+
+        it 'sets the notification category' do
+          expect(@apns.push_options[:category]).to eq notification.class.name
+        end
+
+        it 'sets the custom data with params' do
+          expect(@apns.push_options[:custom_data]).to eq notification.params
+        end
+
+        it 'has a default sound' do
+          expect(@apns.push_options[:sound]).to eq 'default'
+        end
+
+        it 'can use custom sounds' do
+          apns = Apns.new([notification], [], sound: 'special.wav')
+
+          expect(apns.push_options[:sound]).to eq 'special.wav'
+        end
+
+        it 'removes the badge key for silent notifications' do
+          apns = Apns.new([notification], [], silent: true)
+
+          expect(apns.push_options).not_to have_key(:badge)
+        end
+      end
+    end
+
+    describe 'push' do
+      before :each do
+        @apns = Apns.new([notification], [], {})
+
+        @connection = TestAPNConnection.new
+
+        allow(@apns).to receive(:connection)   { @connection }
+      end
+
+      context 'with no errors' do
+        before :each do
+          allow(IO).to receive(:select) { [nil, nil] }
+        end
+
+        it 'succeeds if no error' do
+          expect(@apns.push).to eq true
+        end
+
+        it 'writes to the connection for each device' do
+          devices = []
+          3.times do
+            devices << create_device_double
+          end
+          allow(@apns).to receive(:devices) { devices }
+          expect(@connection).to receive(:write).exactly(3).times
+          @apns.push
+        end
+      end
+
+      context 'with an error' do
+        before :each do
+          # Return errors first time, no errors on recursion
+          allow(IO).to receive(:select).and_return([[true], nil], [nil, nil])
+          error_string = "nil, #{status}, #{error_index}"
+          allow(@connection).to receive(:read) { error_string }
+        end
+
+        let(:status) { 8 }
+        let(:error_index) { 0 }
+
+        it 'tries again if an error occurs' do
+          expect(@apns).to receive(:send_notifications).twice.and_call_original
+          @apns.push
+        end
+      end
+    end
+  end
+end

data/spec/models/notify_user/gcm_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'support/test_gcm_connection'
+
+module NotifyUser
+  describe Gcm, type: :model do
+    let(:user) { create(:user) }
+    let(:notification) { create(:notify_user_notification, target: user) }
+    let(:user_tokens) { ['a_token'] }
+
+    before :each do
+      allow_any_instance_of(Gcm).to receive(:device_tokens) { user_tokens }
+      @client = TestGCMConnection.new
+      allow_any_instance_of(Gcm).to receive(:client).and_return(@client)
+    end
+
+    describe 'initialisation' do
+      it 'initialises the correct push options' do
+        @gcm = Gcm.new([notification], [], {})
+
+        expect(@gcm.push_options).to include(
+          data: {
+            notification_id: notification.id,
+            message: notification.mobile_message,
+            type: notification.class.name,
+            unread_count: 1,
+            custom_data: notification.params
+          }
+        )
+      end
+    end
+
+    describe 'push' do
+      before :each do
+        @gcm = Gcm.new([notification], [], {})
+      end
+
+      context 'without errors' do
+        before :each do
+          # Stub out send method with a successful response object, or maybe,
+          # initialize TestGCMConnection with new(:success)
+          # This would keep the spec file clean...
+        end
+
+        it 'returns true if no error' do
+          expect(@gcm.push).to eq true
+        end
+
+        it 'sends to the device token of the notification target' do
+          expect(@client).to receive(:send).with(user_tokens, kind_of(Hash))
+          @gcm.push
+        end
+
+        it 'does not try to send to an empty token' do
+          user_tokens = []
+          allow_any_instance_of(Gcm).to receive(:device_tokens) { user_tokens }
+          expect_any_instance_of(GCM).not_to receive(:send)
+          @gcm.push
+        end
+
+        it 'sends multiple notifications' do
+          multiple_tokens = %w(token_1 token_2 token_3)
+          allow(@gcm).to receive(:device_tokens) { multiple_tokens }
+          expect(@client).to receive(:send).once
+            .with(multiple_tokens, kind_of(Hash))
+          @gcm.push
+        end
+      end
+    end
+  end
+end

data/spec/models/notify_user/notification_spec.rb

@@ -5,172 +5,565 @@ module NotifyUser
 
     let(:user) { User.create({email: "user@example.com" })}
     let(:notification) { NewPostNotification.create({target: user}) }
-    Rails.application.routes.default_url_options[:host]= 'localhost:5000' 
+    Rails.application.routes.default_url_options[:host]= 'localhost:5000'
 
     before :each do
-      BaseNotification.any_instance.stub(:mobile_message).and_return("New Notification")
-      # BaseNotification.channel(:apns, {aggregate_per: false})
+      NewPostNotification.class_eval do
+        channel :action_mailer
+        self.aggregate_grouping = false
+      end
+
+      allow_any_instance_of(BaseNotification).to receive(:mobile_message) { 'New Notification' }
     end
 
     describe "notification count" do
       it "returns the sent count for a user" do
-        notification.count_for_target.should eq 1
+        expect(notification.count_for_target).to eq 1
       end
     end
 
     describe "params" do
-
       it "doesn't fail if searching for param variable that doesn't exist" do
-        notification.params[:unknown].should eq nil
+        expect(notification.params[:unknown]).to eq nil
       end
 
       it "doesn't fail if searching for a param that doesn't exist if other params are present" do
         notification.params = {name: "hello_world"}
-        notification.params[:unknown].should eq nil
+        expect(notification.params[:unknown]).to eq nil
       end
 
       it "can reference params using string when submitted as json" do
         notification.params = {"listing_id" => 1}
         notification.save
 
-        NewPostNotification.last.params["listing_id"].should eq 1
+        expect(NewPostNotification.last.params["listing_id"]).to eq 1
       end
 
       it "can reference params using symbol when submitted as json" do
         notification.params = {"listing_id" => 1}
         notification.save
 
-        NewPostNotification.last.params[:listing_id].should eq 1
+        expect(NewPostNotification.last.params[:listing_id]).to eq 1
       end
 
       it "can reference params using symbol when submitted as hash" do
         notification.params = {:listing_id => 1}
         notification.save
 
-        NewPostNotification.last.params[:listing_id].should eq 1
+        expect(NewPostNotification.last.params[:listing_id]).to eq 1
       end
 
       it "can reference params using string when subbmited as hash" do
         notification.params = {:listing_id => 1}
         notification.save
 
-        NewPostNotification.last.params["listing_id"].should eq 1
+        expect(NewPostNotification.last.params["listing_id"]).to eq 1
       end
     end
 
     describe "#notify" do
+      before do
+        @notification = NewPostNotification.create(target: user)
+      end
 
       it "sets the state to pending" do
-        notification = NewPostNotification.create({target: user})
-        notification.notify
-        notification.state.should eq "pending"
+        @notification.notify
+        expect(@notification.reload.state).to eq 'pending'
       end
 
-      describe "#deliver" do
+      it "passing false marks the notification as sent" do
+        @notification.notify(false)
+        expect(@notification.reload.state).to eq 'sent'
+      end
 
-        describe "with aggregation enabled" do
-          it "schedules a job to wait for more notifications to aggregate if there is not one already" do
-            NewPostNotification.should_receive(:delay_for)
-                            .with(notification.class.aggregate_per).and_call_original
+      context 'using aggregation' do
+        before do
+          allow(NewPostNotification).to receive(:aggregate_grouping) { true }
+        end
 
-            notification.deliver
-          end
+        it 'doesnt assign a parent if there arent any' do
+          @notification.notify
+          expect(@notification.reload.parent_id).to be_nil
+        end
 
-          it "doesn't schedule a job if a pending notification awaiting aggregation already exists" do
-            another_notification = NewPostNotification.create({target: user})
-            NewPostNotification.should_not_receive(:delay_for)
-                            .with(notification.class.aggregate_per).and_call_original
+        it 'doesnt assign a parent if one hasnt been created within 24 hours' do
+          @t = 25.hours.ago
+          @parent = NewPostNotification.create(target: user, created_at: @t)
 
-            notification.deliver
-          end
+          @notification.notify
+          expect(@notification.reload.parent_id).to be_nil
         end
 
-        describe "with aggregation disabled" do
-          before :each do
-            NewPostNotification.channel(:action_mailer, {aggregate_per: false})
-          end
+        it 'assigns a parent if one has been created within 24 hours' do
+          @t = 23.hours.ago
+          @parent = NewPostNotification.create(target: user, created_at: @t)
 
-          it "schedules notification to be sent through channels" do
-            NewPostNotification.should_receive(:delay).and_call_original
-            notification.deliver        
-          end
+          @notification.notify
+          expect(@notification.reload.parent_id).to eq @parent.id
         end
       end
     end
 
-    describe "notify!" do
+    describe "#deliver" do
+      context "with aggregation enabled" do
+        it "schedules a job to wait for more notifications to aggregate if there is not one already" do
+          expect(NewPostNotification).to(
+            receive(:delay_for).with(notification.class.aggregate_per)
+          ).and_call_original
+
+          notification.deliver
+        end
+
+        it "doesn't schedule a job if a pending notification awaiting aggregation already exists" do
+          another_notification = NewPostNotification.create({target: user, state: "pending_as_aggregation_parent"})
+
+          expect(NewPostNotification).not_to(
+            receive(:delay_for).with(notification.class.aggregate_per)
+          )
+
+          notification.deliver
+        end
+      end
+
+      context "with aggregation disabled" do
+        before :each do
+          NewPostNotification.channel(:action_mailer, {aggregate_per: false})
+        end
+
+        it "schedules notification to be sent through channels" do
+          expect(NewPostNotification).to receive(:delay).and_call_original
+          notification.deliver
+        end
+      end
+    end
 
+    describe "notify!" do
       it "sets the state to pending_no_aggregation" do
         notification = NewPostNotification.create({target: user})
         notification.notify!
-        notification.state.should eq "pending_no_aggregation"
+
+        expect(notification.state).to eq "pending_no_aggregation"
       end
 
-      describe ".deliver_notification_channel" do 
+      describe ".deliver_notification_channel" do
+        before :each do
+          @notification = NewPostNotification.create({target: user})
+        end
 
-          before :each do
-            @notification = NewPostNotification.create({target: user})
-          end
+        it "doesn't send if unsubscribed from channel" do
+          unsubscribe = NotifyUser::Unsubscribe.create({target: user, type: "action_mailer"})
 
-          it "doesn't send if unsubscribed from channel" do
-            unsubscribe = NotifyUser::Unsubscribe.create({target: user, type: "action_mailer"}) 
-            ActionMailerChannel.should_not_receive(:deliver)
-            BaseNotification.deliver_notification_channel(@notification.id, "action_mailer")
-          end
+          expect(ActionMailerChannel).not_to receive(:deliver)
+          BaseNotification.deliver_notification_channel(@notification.id, "action_mailer")
+        end
 
-          it "does send if subscribed to channel" do
-            ActionMailerChannel.should_receive(:deliver)
-            BaseNotification.deliver_notification_channel(@notification.id, "action_mailer")
-          end
+        it "does send if subscribed to channel" do
+          expect(ActionMailerChannel).to receive(:deliver)
+          BaseNotification.deliver_notification_channel(@notification.id, "action_mailer")
+        end
       end
 
       describe "#deliver!" do
         it "schedules to be delivered to channels" do
           notification.dont_aggregate
-          NewPostNotification.should_receive(:deliver_channels)
-                              .with(notification.id)
-                              .and_call_original
-          notification.deliver!            
+
+          expect(NewPostNotification).to(
+            receive(:deliver_channels).with(notification.id)
+          ).and_call_original
+
+          notification.deliver!
         end
       end
 
       describe "#deliver_channels" do
-        
         it "delivers notification to channels" do
-          ActionMailerChannel.should_receive(:deliver).once
+          expect(ActionMailerChannel).to receive(:deliver).once
           NewPostNotification.deliver_channels(notification.id)
         end
-
       end
     end
 
     describe "#notify_aggregated_channel"  do
-
       it "if only one notification to aggregate hit deliver_notification_channel" do
-        NewPostNotification.should_receive(:deliver_notification_channel).with(notification.id, :action_mailer).once
+        expect(NewPostNotification).to receive(:deliver_notification_channel).with(notification.id, :action_mailer).once
         NewPostNotification.notify_aggregated_channel(notification.id, :action_mailer)
       end
 
       it "if many notifications to aggregate hit deliver_notifications_channel" do
         another_notification = NewPostNotification.create({target: user})
 
-        NewPostNotification.should_receive(:deliver_notifications_channel).once
+        expect(NewPostNotification).to receive(:deliver_notifications_channel).once
+        NewPostNotification.notify_aggregated_channel(notification.id, :action_mailer)
+      end
+
+      it "if notification is marked_as_read don't deliver" do
+        notification = NewPostNotification.create({target: user, state: "read"})
+
+        expect(NewPostNotification).not_to receive(:deliver_notification_channel)
+        expect(NewPostNotification).not_to receive(:deliver_notifications_channel)
+
         NewPostNotification.notify_aggregated_channel(notification.id, :action_mailer)
       end
 
+      context "with aggregate grouping enabled" do
+        before do
+          allow(NewPostNotification).to receive(:aggregate_grouping) { true }
+        end
+
+        it "should receive pending_aggregation_by_group_with" do
+          notification = NewPostNotification.create({target: user, group_id: 2})
+
+          expect(NewPostNotification).to receive(:pending_aggregation_by_group_with).and_call_original
+          NewPostNotification.notify_aggregated_channel(notification.id, :action_mailer)
+        end
+      end
+    end
+
+    describe "interval aggregation" do
+      before :each do
+        Sidekiq::Testing.fake!
+        @aggregate_per = [0, 1, 4, 5]
+        NewPostNotification.class_eval do
+          channel :action_mailer, aggrregate_per: @aggregate_per
+
+          self.aggregate_grouping = true
+        end
+      end
+
+      it "marking a pending_as_aggregation_parent as sent sets it to sent_as_aggregation_parent" do
+        notification = NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"})
+        notification.mark_as_sent!
+        expect(notification.reload.state).to eq "sent_as_aggregation_parent"
+      end
+
+      describe "aggregate interval" do
+        describe "first notification to be received after a notification was sent" do
+          it "includes notifications within 24hours from first notification" do
+          end
+
+          it "first notification returns interval 0" do
+            notification = NewPostNotification.create({target: user, group_id: 1})
+            expect(notification.aggregation_interval).to eq 0
+          end
+
+          it "second notification returns internal 1" do
+            NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+            notification = NewPostNotification.create({target: user, group_id: 1})
+            expect(notification.aggregation_interval).to eq 1
+          end
+
+          it "third notification returns interval 2" do
+            NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+            NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+
+            notification = NewPostNotification.create({target: user, group_id: 1})
+            expect(notification.aggregation_interval).to eq 2
+          end
+
+          it "doesn't include sent notifications from another target_id" do
+            NewPostNotification.create({target: user, group_id: 3, state: "sent_as_aggregation_parent"})
+            NewPostNotification.create({target: user, group_id: 0, state: "sent_as_aggregation_parent"})
+
+            notification = NewPostNotification.create({target: user, group_id: 1})
+            expect(notification.aggregation_interval).to eq 0
+          end
+
+          it "agregation interval should include pending as parent states as well" do
+            NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+            NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"})
+
+            notification = NewPostNotification.create({target: user, group_id: 1})
+            expect(notification.aggregation_interval).to eq 2
+          end
+        end
+      end
+
+      describe "parent_id" do
+        it "sets parent_id if the time between the previous parent_id is less than 24 hours ago" do
+          n = NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent", parent_id: nil})
+
+          Timecop.travel(10.hours.from_now) do
+            notification = NewPostNotification.new({target: user, group_id: 1})
+            notification.notify
+
+            expect(notification.parent_id).to eq n.id
+          end
+        end
+
+        it "does not set parent_id if time between previous parent_id is more than 24 hours ago" do
+          n = NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent", parent_id: nil})
+
+          Timecop.travel(25.hours.from_now) do
+            notification = NewPostNotification.new({target: user, group_id: 1})
+            notification.notify
+
+            expect(notification.reload.parent_id).to eq nil
+          end
+        end
+
+        it "parent_id gets set to the latest id of the latest parents" do
+          NewPostNotification.create({target: user, group_id: 1, parent_id: nil})
+
+          Timecop.travel(10.hours.from_now) do
+            n = NewPostNotification.new({target: user, group_id: 1, parent_id: nil, created_at: 10.hours.ago})
+
+            Timecop.travel(15.hours.from_now) do
+              notification = NewPostNotification.new({target: user, group_id: 1})
+              notification.notify
+
+              expect(notification.reload.parent_id).to eq n.id
+            end
+          end
+        end
+      end
+
+      describe "delay_time" do
+
+        it "first notification will return Time.now" do
+          notification = NewPostNotification.create({target: user, group_id: 1})
+          expect(notification.delay_time({aggregate_per: @aggregate_per}).to_s).to eq notification.created_at.to_s
+        end
+
+        it "notification received during first interval returns last time + x.minutes " do
+          n = NewPostNotification.create!({target: user, group_id: 1, state: "pending_as_aggregation_parent"})
+          n.mark_as_sent!
+
+          notification = NewPostNotification.create!({target: user, group_id: 1})
+          expect(notification.delay_time({aggregate_per: @aggregate_per}).to_s).to eq (n.sent_time + 1.minute).to_s
+        end
+
+        it "notification returned during third interval returns last time + x.minutes" do
+          NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"}).mark_as_sent!
+          n = NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"})
+          n.mark_as_sent!
+
+          notification = NewPostNotification.create({target: user, group_id: 1})
+          expect(notification.delay_time({aggregate_per: @aggregate_per}).to_s).to eq (n.sent_time + 4.minute).to_s
+        end
+
+        it "notification received after all intervals have ended just uses the last interval" do
+          10.times do
+            NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"}).mark_as_sent!
+          end
+          last_n = NewPostNotification.create({target: user, group_id: 1, state: "pending_as_aggregation_parent"})
+          last_n.mark_as_sent!
+
+          notification = NewPostNotification.create({target: user, group_id: 1})
+          expect(notification.delay_time({aggregate_per: @aggregate_per}).to_s).to eq (last_n.sent_time + 5.minute).to_s
+        end
+      end
+
+      describe "the first notification" do
+        before :each do
+          @notification = NewPostNotification.create({target: user, group_id: 1})
+        end
+
+        it "should send immediately" do
+          expect{
+            @notification.deliver
+          }.to change(Sidekiq::Extensions::DelayedClass.jobs, :size).by(1)
+        end
+
+        it "should change state to pending_as_aggregation_parent" do
+          expect{
+            @notification.deliver
+          }.to change(@notification, :state).to "pending_as_aggregation_parent"
+        end
+
+        it "parent_id should be nil" do
+          @notification.deliver
+          expect(@notification.reload.parent_id).to eq nil
+        end
+      end
+
+      describe "receive subsequent notifications" do
+
+        describe "with no pending notifications" do
+          before :each do
+            @n = NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+          end
+
+          it "delays notification" do
+            notification = NewPostNotification.create({target: user, group_id: 1, created_at: @n.created_at + 2.minutes})
+
+            expect{
+              notification.deliver
+            }.to change(Sidekiq::Extensions::DelayedClass.jobs, :size).by(1)
+          end
+
+          it "parent_id gets set to notification at interval 0" do
+            notification = NewPostNotification.new({target: user, group_id: 1, created_at: @n.created_at + 2.minutes})
+            notification.notify
+            expect(notification.reload.parent_id).to eq @n.id
+          end
+
+        end
+
+        describe "with pending notifications" do
+          before :each do
+            @n = NewPostNotification.create({target: user, group_id: 1, state: "sent_as_aggregation_parent"})
+            @other_notification = NewPostNotification.create({target: user, state: "pending_as_aggregation_parent", group_id: 1})
+            @notification = NewPostNotification.create({target: user, group_id: 1})
+          end
+
+          it "dont delay anything" do
+            expect{
+              @notification.deliver
+            }.to change(Sidekiq::Extensions::DelayedClass.jobs, :size).by(0)
+          end
+
+          it "state remains as pending" do
+            @notification.deliver
+            expect(@notification.reload.pending?).to eq true
+          end
+
+        end
+      end
+      #we need a way to identify which notification was the one that was delayed conceptually labeled "head" or a special state
+      #search how many unread/sent "head" notifications exist and use that as the interval
+    end
+
+    describe "validations" do
+      describe "aggregate_grouping false" do
+        before :each do
+          NewPostNotification.class_eval do
+            channel :action_mailer, aggrregate_per: [1, 4, 5]
+          end
+        end
+
+        it "doesn't require a group_id" do
+          notification = NewPostNotification.new({target: user})
+          expect(notification).to be_valid
+        end
+      end
+
+      describe "aggregate_grouping true" do
+        before :each do
+          NewPostNotification.class_eval do
+            channel :action_mailer, aggrregate_per: [1, 4, 5]
+            self.aggregate_grouping = true
+          end
+        end
+
+        it "if group_id present be valid" do
+          notification = NewPostNotification.new({target: user, group_id: 1})
+          expect(notification).to be_valid
+        end
+        it "if aggregate_grouping is true require a group_id" do
+          notification = NewPostNotification.new({target: user})
+          expect(notification).to_not be_valid
+        end
+      end
+    end
+
+    describe "user_has_unsubscribed?" do
+      it "true if unsubscribed from type" do
+        notification = NewPostNotification.create({target: user})
+        Unsubscribe.create({target: notification.target, type: "NewPostNotification"})
+
+        expect(notification.user_has_unsubscribed?).to eq true
+      end
+
+      it "false if haven't unsubscribed from type" do
+        notification = NewPostNotification.create({target: user})
+        expect(notification.user_has_unsubscribed?).to eq false
+      end
+
+      it "true if unsubscribed from channel" do
+        notification = NewPostNotification.create({target: user})
+        Unsubscribe.create({target: notification.target, type: "action_mailer"})
+
+        expect(notification.user_has_unsubscribed?(:action_mailer)).to eq true
+      end
+
+      it "false if haven't unsubscribed from channel" do
+        notification = NewPostNotification.create({target: user})
+
+        expect(notification.user_has_unsubscribed?(:action_mailer)).to eq false
+      end
+
+      it "true if unsubscribed from type and group_id" do
+        Unsubscribe.create({target: notification.target, type: "NewPostNotification", group_id: 1})
+        notification.update_attributes(group_id: 1)
+
+        expect(notification.user_has_unsubscribed?).to eq true
+      end
+
+      it "true if unsubcribed from type but pass in group_id" do
+        Unsubscribe.create({target: notification.target, type: "NewPostNotification"})
+        notification.update_attributes(group_id: 1)
+
+        expect(notification.user_has_unsubscribed?).to eq true
+      end
+
+      it "false if havent unsubscribed from type and group_id" do
+        notification.update_attributes(group_id: 1)
+        expect(notification.user_has_unsubscribed?).to eq false
+      end
+    end
+
+    describe "unsubscribing" do
+
+      describe "deliver_notification_channel" do
+        it "subscribed to type receives deliver" do
+          expect(ActionMailerChannel).to receive(:deliver)
+          NewPostNotification.deliver_notification_channel(notification.id, :action_mailer)
+        end
+
+        it "unsubscribed from type doesn't receive deliver" do
+          expect(ActionMailerChannel).to_not receive(:deliver)
+
+          Unsubscribe.create({target: notification.target, type: "action_mailer"})
+          NewPostNotification.deliver_notification_channel(notification.id, :action_mailer)
+        end
+
+        it "unsubscribed from type and group_id doesn't receive deliver " do
+          expect(ActionMailerChannel).to_not receive(:deliver)
+          Unsubscribe.create({target: notification.target, type: "NewPostNotification", group_id: 1})
+
+          notification.update_attributes(group_id: 1)
+
+          NewPostNotification.deliver_notification_channel(notification.id, :action_mailer)
+        end
+
+      end
+
+      describe "deliver_notifications_channel" do
+
+        it "subscribed to type receives deliver_aggregated" do
+          expect(ActionMailerChannel).to receive(:deliver_aggregated)
+          NewPostNotification.deliver_notifications_channel([notification], :action_mailer)
+        end
+
+        it "unsubscribed from type doesn't receive deliver_aggregated" do
+          expect(ActionMailerChannel).to_not receive(:deliver_aggregated)
+
+          Unsubscribe.create({target: notification.target, type: "action_mailer"})
+          NewPostNotification.deliver_notifications_channel([notification], :action_mailer)
+        end
+
+        it "unsubscribed from type and group_id doesn't receive deliver_aggregated " do
+          expect(ActionMailerChannel).to_not receive(:deliver_aggregated)
+
+          Unsubscribe.create({target: notification.target, type: "NewPostNotification", group_id: 1})
+          notification.update_attributes(group_id: 1)
+
+          NewPostNotification.deliver_notifications_channel([notification], :action_mailer)
+        end
+      end
     end
 
     describe "generate hash" do
       it "creates a new hash if an active hash doesn't already exist" do
         user_hash = notification.generate_unsubscribe_hash
-        user_hash.should_not eq nil
+        expect(user_hash).not_to eq nil
       end
 
       it "uses the old hash if an active hash already exists" do
         user_hash = notification.generate_unsubscribe_hash
 
         another_hash = notification.generate_unsubscribe_hash
-        another_hash.token.should eq user_hash.token
+        expect(another_hash.token).to eq user_hash.token
       end
 
       it "creates a new hash if no active hash exists" do
@@ -178,8 +571,7 @@ module NotifyUser
         user_hash.deactivate
 
         another_hash = notification.generate_unsubscribe_hash
-        another_hash.token.should_not eq user_hash.token
-
+        expect(another_hash.token).not_to eq user_hash.token
       end
     end
   end