rapns 3.3.2-java → 3.4.0-java

data/spec/unit/daemon/app_runner_spec.rb

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Rapns::Daemon::AppRunner, 'stop' do
-  let(:runner) { stub }
+  let(:runner) { double }
   before { Rapns::Daemon::AppRunner.runners['app'] = runner }
   after { Rapns::Daemon::AppRunner.runners.clear }
 
@@ -11,10 +11,11 @@ describe Rapns::Daemon::AppRunner, 'stop' do
   end
 end
 
-describe Rapns::Daemon::AppRunner, 'deliver' do
-  let(:runner) { stub }
-  let(:notification) { stub(:app_id => 1) }
-  let(:logger) { stub(:error => nil) }
+describe Rapns::Daemon::AppRunner, 'enqueue' do
+  let(:runner) { double(:enqueue => nil) }
+  let(:notification1) { double(:app_id => 1) }
+  let(:notification2) { double(:app_id => 2) }
+  let(:logger) { double(:error => nil) }
 
   before do
     Rapns.stub(:logger => logger)
@@ -23,29 +24,38 @@ describe Rapns::Daemon::AppRunner, 'deliver' do
 
   after { Rapns::Daemon::AppRunner.runners.clear }
 
-  it 'enqueues the notification' do
-    runner.should_receive(:enqueue).with(notification)
-    Rapns::Daemon::AppRunner.enqueue(notification)
+  it 'batches notifications by app' do
+    batch = double.as_null_object
+    Rapns::Daemon::Batch.stub(:new => batch)
+    Rapns::Daemon::Batch.should_receive(:new).with([notification1])
+    Rapns::Daemon::Batch.should_receive(:new).with([notification2])
+    Rapns::Daemon::AppRunner.enqueue([notification1, notification2])
+  end
+
+  it 'enqueues each batch' do
+    runner.should_receive(:enqueue).with(kind_of(Rapns::Daemon::Batch))
+    Rapns::Daemon::AppRunner.enqueue([notification1])
   end
 
   it 'logs an error if there is no runner to deliver the notification' do
-    notification.stub(:app_id => 2, :id => 123)
-    logger.should_receive(:error).with("No such app '#{notification.app_id}' for notification #{notification.id}.")
-    Rapns::Daemon::AppRunner.enqueue(notification)
+    notification1.stub(:app_id => 2, :id => 123)
+    notification2.stub(:app_id => 2, :id => 456)
+    logger.should_receive(:error).with("No such app '#{notification1.app_id}' for notifications 123, 456.")
+    Rapns::Daemon::AppRunner.enqueue([notification1, notification2])
   end
 end
 
 describe Rapns::Daemon::AppRunner, 'sync' do
   let(:app) { Rapns::Apns::App.new }
   let(:new_app) { Rapns::Apns::App.new }
-  let(:runner) { stub(:sync => nil, :stop => nil, :start => nil) }
-  let(:logger) { stub(:error => nil) }
-  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+  let(:runner) { double(:sync => nil, :stop => nil, :start => nil) }
+  let(:logger) { double(:error => nil, :warn => nil) }
+  let(:queue) { Queue.new }
 
   before do
     app.stub(:id => 1)
     new_app.stub(:id => 2)
-    Rapns::Daemon::DeliveryQueue.stub(:new => queue)
+    Queue.stub(:new => queue)
     Rapns::Daemon::AppRunner.runners[app.id] = runner
     Rapns::App.stub(:all => [app])
     Rapns.stub(:logger => logger)
@@ -65,7 +75,7 @@ describe Rapns::Daemon::AppRunner, 'sync' do
 
   it 'starts a runner for a new app' do
     Rapns::App.stub(:all => [app, new_app])
-    new_runner = stub
+    new_runner = double
     Rapns::Daemon::Apns::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
     new_runner.should_receive(:start)
     Rapns::Daemon::AppRunner.sync
@@ -79,10 +89,20 @@ describe Rapns::Daemon::AppRunner, 'sync' do
 
   it 'logs an error if the app could not be started' do
     Rapns::App.stub(:all => [app, new_app])
-    new_runner = stub
+    new_runner = double
     Rapns::Daemon::Apns::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
     new_runner.stub(:start).and_raise(StandardError)
-    Rapns.logger.should_receive(:error).any_number_of_times
+    Rapns.logger.should_receive(:error)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'reflects errors if the app could not be started' do
+    Rapns::App.stub(:all => [app, new_app])
+    new_runner = double
+    Rapns::Daemon::Apns::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
+    e = StandardError.new
+    new_runner.stub(:start).and_raise(e)
+    Rapns::Daemon::AppRunner.should_receive(:reflect).with(:error, e)
     Rapns::Daemon::AppRunner.sync
   end
 end
@@ -90,12 +110,12 @@ end
 describe Rapns::Daemon::AppRunner, 'debug' do
   let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
     :environment => 'development', :certificate => TEST_CERT) }
-  let(:logger) { stub(:info => nil) }
+  let(:logger) { double(:info => nil) }
 
   before do
     Rapns::Daemon.stub(:config => {})
-    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => stub.as_null_object)
-    Rapns::Daemon::Apns::Connection.stub(:new => stub.as_null_object)
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => double.as_null_object)
+    Rapns::Daemon::Apns::Connection.stub(:new => double.as_null_object)
     Rapns.stub(:logger => logger)
     Rapns::Daemon::AppRunner.sync
   end
@@ -103,7 +123,7 @@ describe Rapns::Daemon::AppRunner, 'debug' do
   after { Rapns::Daemon::AppRunner.runners.clear }
 
   it 'prints debug app states to the log' do
-    Rapns.logger.should_receive(:info).with("\ntest:\n  handlers: 1\n  queued: 0\n  idle: true\n")
+    Rapns.logger.should_receive(:info).with("\ntest:\n  handlers: 1\n  queued: 0\n  batch size: 0\n  batch processed: 0\n  idle: true\n")
     Rapns::Daemon::AppRunner.debug
   end
 end
@@ -111,12 +131,12 @@ end
 describe Rapns::Daemon::AppRunner, 'idle' do
   let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
     :environment => 'development', :certificate => TEST_CERT) }
-  let(:logger) { stub(:info => nil) }
+  let(:logger) { double(:info => nil) }
 
   before do
     Rapns.stub(:logger => logger)
-    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => stub.as_null_object)
-    Rapns::Daemon::Apns::Connection.stub(:new => stub.as_null_object)
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => double.as_null_object)
+    Rapns::Daemon::Apns::Connection.stub(:new => double.as_null_object)
     Rapns::Daemon::AppRunner.sync
   end
 
@@ -131,12 +151,12 @@ end
 describe Rapns::Daemon::AppRunner, 'wait' do
   let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
     :environment => 'development', :certificate => TEST_CERT) }
-  let(:logger) { stub(:info => nil) }
+  let(:logger) { double(:info => nil) }
 
   before do
     Rapns.stub(:logger => logger)
-    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => stub.as_null_object)
-    Rapns::Daemon::Apns::Connection.stub(:new => stub.as_null_object)
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => double.as_null_object)
+    Rapns::Daemon::Apns::Connection.stub(:new => double.as_null_object)
     Rapns::Daemon::AppRunner.sync
   end
 

data/spec/unit/daemon/batch_spec.rb

@@ -0,0 +1,160 @@
+require 'unit_spec_helper'
+
+describe Rapns::Daemon::Batch do
+  let(:notification1) { double(:id => 1) }
+  let(:notification2) { double(:id => 2) }
+  let(:batch) { Rapns::Daemon::Batch.new([notification1, notification2]) }
+  let(:store) { double.as_null_object }
+
+  before do
+    Rapns::Daemon.stub(:store => store)
+  end
+
+  it 'exposes the notifications' do
+    batch.notifications.should eq [notification1, notification2]
+  end
+
+  it 'exposes the number notifications' do
+    batch.num_notifications.should eq 2
+  end
+
+  it 'exposes the number notifications processed' do
+    batch.num_processed.should eq 0
+  end
+
+  it 'increments the processed notifications count' do
+    expect { batch.notification_processed }.to change(batch, :num_processed).to(1)
+  end
+
+  it 'completes the batch when all notifications have been processed' do
+    batch.should_receive(:complete)
+    2.times { batch.notification_processed }
+  end
+
+  it 'can be described' do
+    batch.describe.should eq '1, 2'
+  end
+
+  describe 'mark_delivered' do
+    it 'marks the notification as delivered immediately if batching is disabled' do
+      Rapns.config.batch_storage_updates = false
+      store.should_receive(:mark_delivered).with(notification1)
+      batch.mark_delivered(notification1)
+    end
+
+    it 'defers marking the notification as delivered until the batch is complete' do
+      Rapns.config.batch_storage_updates = true
+      batch.mark_delivered(notification1)
+      batch.delivered.should eq [notification1]
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as failed immediately if batching is disabled' do
+      Rapns.config.batch_storage_updates = false
+      store.should_receive(:mark_failed).with(notification1, 1, 'an error')
+      batch.mark_failed(notification1, 1, 'an error')
+    end
+
+    it 'defers marking the notification as failed until the batch is complete' do
+      Rapns.config.batch_storage_updates = true
+      batch.mark_failed(notification1, 1, 'an error')
+      batch.failed.should eq({[1, 'an error'] => [notification1]})
+    end
+  end
+
+  describe 'mark_retryable' do
+    let(:time) { Time.now }
+
+    it 'marks the notification as retryable immediately if batching is disabled' do
+      Rapns.config.batch_storage_updates = false
+      store.should_receive(:mark_retryable).with(notification1, time)
+      batch.mark_retryable(notification1, time)
+    end
+
+    it 'defers marking the notification as retryable until the batch is complete' do
+      Rapns.config.batch_storage_updates = true
+      batch.mark_retryable(notification1, time)
+      batch.retryable.should eq({time => [notification1]})
+    end
+  end
+
+  describe 'complete' do
+    before do
+      Rapns.config.batch_storage_updates = true
+      Rapns.stub(:logger => double.as_null_object)
+    end
+
+    it 'clears the notifications' do
+      expect do
+        2.times { batch.notification_processed }
+      end.to change(batch, :notifications).to([])
+    end
+
+    it 'identifies as complete' do
+      expect do
+        2.times { batch.notification_processed }
+      end.to change(batch, :complete?).to(be_true)
+    end
+
+    it 'reflects errors raised during completion' do
+      e = StandardError.new
+      batch.stub(:complete_delivered).and_raise(e)
+      batch.should_receive(:reflect).with(:error, e)
+      2.times { batch.notification_processed }
+    end
+
+    describe 'delivered' do
+      it 'marks the batch as delivered' do
+        store.should_receive(:mark_batch_delivered).with([notification1, notification2])
+        [notification1, notification2].each do |n|
+          batch.mark_delivered(n)
+          batch.notification_processed
+        end
+      end
+
+      it 'clears the delivered notifications' do
+        [notification1, notification2].each { |n| batch.mark_delivered(n) }
+        expect do
+          2.times { batch.notification_processed }
+        end.to change(batch, :delivered).to([])
+      end
+    end
+
+    describe 'failed' do
+      it 'marks the batch as failed' do
+        store.should_receive(:mark_batch_failed).with([notification1, notification2], 1, 'an error')
+        [notification1, notification2].each do |n|
+          batch.mark_failed(n, 1, 'an error')
+          batch.notification_processed
+        end
+      end
+
+      it 'clears the failed notifications' do
+        [notification1, notification2].each { |n| batch.mark_failed(n, 1, 'an error') }
+        expect do
+          2.times { batch.notification_processed }
+        end.to change(batch, :failed).to({})
+      end
+    end
+
+    describe 'retryable' do
+      let(:time) { Time.now }
+
+      it 'marks the batch as retryable' do
+        store.should_receive(:mark_batch_retryable).with([notification1, notification2], time)
+        [notification1, notification2].each do |n|
+          batch.mark_retryable(n, time)
+          batch.notification_processed
+        end
+      end
+
+      it 'clears the retyable notifications' do
+        [notification1, notification2].each { |n| batch.mark_retryable(n, time) }
+        expect do
+          2.times { batch.notification_processed }
+        end.to change(batch, :retryable).to({})
+      end
+    end
+  end
+end

data/spec/unit/daemon/delivery_handler_collection_spec.rb

@@ -0,0 +1,37 @@
+require 'unit_spec_helper'
+
+describe Rapns::Daemon::DeliveryHandlerCollection do
+  let(:handler) { double.as_null_object }
+  let(:collection) { Rapns::Daemon::DeliveryHandlerCollection.new }
+
+  it 'returns the size of the collection' do
+    collection.push(handler)
+    collection.size.should eq 1
+  end
+
+  it 'pops a handler from the collection' do
+    collection.push(handler)
+    handler.should_receive(:stop)
+    handler.should_receive(:wakeup)
+    handler.should_receive(:wait)
+    collection.pop
+    collection.size.should eq 0
+  end
+
+  it 'wakes up all handlers when popping a single handler' do
+    collection.push(handler)
+    handler2 = double.as_null_object
+    collection.push(handler2)
+    handler.should_receive(:wakeup)
+    handler2.should_receive(:wakeup)
+    collection.pop
+  end
+
+  it 'stops all handlers' do
+    collection.push(handler)
+    handler.should_receive(:stop)
+    handler.should_receive(:wakeup)
+    handler.should_receive(:wait)
+    collection.stop
+  end
+end

data/spec/unit/daemon/delivery_handler_shared.rb

@@ -1,34 +1,43 @@
 shared_examples_for 'an DeliveryHandler subclass' do
+  def run_delivery_handler
+    delivery_handler.start
+    delivery_handler.stop
+    delivery_handler.wakeup
+    delivery_handler.wait
+  end
+
   it 'logs all delivery errors' do
-    logger = stub
+    logger = double
     Rapns.stub(:logger => logger)
     error = StandardError.new
     delivery_handler.stub(:deliver).and_raise(error)
     Rapns.logger.should_receive(:error).with(error)
-    delivery_handler.send(:handle_next_notification)
+    run_delivery_handler
   end
 
   it 'reflects an exception' do
-    Rapns.stub(:logger => stub(:error => nil))
+    Rapns.stub(:logger => double(:error => nil))
     error = StandardError.new
     delivery_handler.stub(:deliver).and_raise(error)
     delivery_handler.should_receive(:reflect).with(:error, error)
-    delivery_handler.send(:handle_next_notification)
+    run_delivery_handler
+  end
+
+  it 'instructs the batch that the notification has been processed' do
+    batch.should_receive(:notification_processed)
+    run_delivery_handler
   end
 
   it "instructs the queue to wakeup the thread when told to stop" do
-    thread = stub(:join => nil)
-    Thread.stub(:new => thread)
-    queue.should_receive(:wakeup).with(thread)
-    delivery_handler.start
-    delivery_handler.stop
+    queue.should_receive(:push).with(Rapns::Daemon::DeliveryHandler::WAKEUP).and_call_original
+    run_delivery_handler
   end
 
   describe "when being stopped" do
     before { queue.pop }
 
-    it "does not attempt to deliver a notification when a DeliveryQueue::::WakeupError is raised" do
-      queue.stub(:pop).and_raise(Rapns::Daemon::DeliveryQueue::WakeupError)
+    it "does not attempt to deliver a notification when a WAKEUP is dequeued" do
+      queue.stub(:pop).and_return(Rapns::Daemon::DeliveryHandler::WAKEUP)
       delivery_handler.should_not_receive(:deliver)
       delivery_handler.send(:handle_next_notification)
     end

data/spec/unit/daemon/feeder_spec.rb

@@ -1,17 +1,17 @@
 require "unit_spec_helper"
 
 describe Rapns::Daemon::Feeder do
-  let(:config) { stub(:batch_size => 5000, :push_poll => 0, :embedded => false,
+  let(:config) { double(:batch_size => 5000, :push_poll => 0, :embedded => false,
     :push => false) }
   let!(:app) { Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
   let(:notification) { Rapns::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
-  let(:logger) { stub }
+  let(:logger) { double }
 
   before do
     Rapns.stub(:config => config,:logger => logger)
-    Rapns::Daemon.stub(:store => stub(:deliverable_notifications => [notification]))
+    Rapns::Daemon.stub(:store => double(:deliverable_notifications => [notification]))
     Rapns::Daemon::Feeder.stub(:stop? => true)
-    Rapns::Daemon::AppRunner.stub(:enqueue => nil, :idle => [stub(:app => app)])
+    Rapns::Daemon::AppRunner.stub(:enqueue => nil, :idle => [double(:app => app)])
   end
 
   def start
@@ -30,6 +30,12 @@ describe Rapns::Daemon::Feeder do
     start
   end
 
+  it 'does not attempt to load deliverable notifications if there are no idle runners' do
+    Rapns::Daemon::AppRunner.stub(:idle => [])
+    Rapns::Daemon.store.should_not_receive(:deliverable_notifications)
+    start
+  end
+
   it 'enqueues notifications without looping if in push mode' do
     config.stub(:push => true)
     Rapns::Daemon::Feeder.should_not_receive(:feed_forever)
@@ -37,14 +43,8 @@ describe Rapns::Daemon::Feeder do
     start
   end
 
-  it "enqueues the notification" do
-    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
-    start
-  end
-
-  it 'reflects the notification has been enqueued' do
-    Rapns::Daemon::AppRunner.stub(:enqueue)
-    Rapns::Daemon::Feeder.should_receive(:reflect).with(:notification_enqueued, notification)
+  it "enqueues the notifications" do
+    Rapns::Daemon::AppRunner.should_receive(:enqueue).with([notification])
     start
   end