rapns_rails_2 3.4.3

data/spec/unit/daemon/app_runner_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Daemon::AppRunner, 'stop' do
+  let(:runner) { double }
+  before { Rapns::Daemon::AppRunner.runners['app'] = runner }
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'stops all runners' do
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.stop
+  end
+end
+
+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)
+    Rapns::Daemon::AppRunner.runners[1] = runner
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'batches notifications by app' do
+    batch = double
+    batch.stub!(:describe)
+    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
+    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) { 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)
+    Queue.stub(:new => queue)
+    Rapns::Daemon::AppRunner.runners[app.id] = runner
+    Rapns::App.stub(:all => [app])
+    Rapns.stub(:logger => logger)
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'loads all apps' do
+    Rapns::App.should_receive(:all)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'instructs existing runners to sync' do
+    runner.should_receive(:sync).with(app)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'starts a runner for a new app' 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)
+    new_runner.should_receive(:start)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'deletes old apps' do
+    Rapns::App.stub(:all => [])
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'logs an error 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)
+    new_runner.stub(:start).and_raise(StandardError)
+    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
+
+describe Rapns::Daemon::AppRunner, 'debug' do
+  let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
+    :environment => 'development', :certificate => TEST_CERT) }
+  let(:logger) { double(:info => nil) }
+
+  before do
+    Rapns::Daemon.stub(:config => {})
+    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
+
+  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  batch size: 0\n  batch processed: 0\n  idle: true\n")
+    Rapns::Daemon::AppRunner.debug
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'idle' do
+  let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
+    :environment => 'development', :certificate => TEST_CERT) }
+  let(:logger) { double(:info => nil) }
+
+  before do
+    Rapns.stub(:logger => logger)
+    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
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'returns idle runners' do
+    runner = Rapns::Daemon::AppRunner.runners[app.id]
+    Rapns::Daemon::AppRunner.idle.should == [runner]
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'wait' do
+  let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
+    :environment => 'development', :certificate => TEST_CERT) }
+  let(:logger) { double(:info => nil) }
+
+  before do
+    Rapns.stub(:logger => logger)
+    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
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'waits until all runners are idle' do
+    Rapns::Daemon::AppRunner.runners.count.should == 1
+    Timeout.timeout(5) { Rapns::Daemon::AppRunner.wait }
+  end
+end

data/spec/unit/daemon/batch_spec.rb

@@ -0,0 +1,219 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Daemon::Batch do
+  let(:notification1) { double(:notification1, :id => 1) }
+  let(:notification2) { double(:notification2, :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 == [notification1, notification2]
+  end
+
+  it 'exposes the number notifications' do
+    batch.num_notifications.should == 2
+  end
+
+  it 'exposes the number notifications processed' do
+    batch.num_processed.should == 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 == '1, 2'
+  end
+
+  describe 'mark_delivered' do
+    describe 'batching is disabled' do
+      before { Rapns.config.batch_storage_updates = false }
+
+      it 'marks the notification as delivered immediately' do
+        store.should_receive(:mark_delivered).with(notification1)
+        batch.mark_delivered(notification1)
+      end
+
+      it 'reflects the notification was delivered' do
+        batch.should_receive(:reflect).with(:notification_delivered, notification1)
+        batch.mark_delivered(notification1)
+      end
+    end
+
+    describe 'batching is enabled' do
+      before { Rapns.config.batch_storage_updates = true }
+
+      it 'defers marking the notification as delivered until the batch is complete' do
+        batch.mark_delivered(notification1)
+        batch.delivered.should == [notification1]
+      end
+    end
+  end
+
+  describe 'mark_failed' do
+    describe 'batching is disabled' do
+      before { Rapns.config.batch_storage_updates = false }
+
+      it 'marks the notification as failed' do
+        store.should_receive(:mark_failed).with(notification1, 1, 'an error')
+        batch.mark_failed(notification1, 1, 'an error')
+      end
+
+      it 'reflects the notification failed' do
+        batch.should_receive(:reflect).with(:notification_delivered, notification1)
+        batch.mark_delivered(notification1)
+      end
+    end
+
+    describe 'batching is enabled' do
+      before { Rapns.config.batch_storage_updates = true }
+
+      it 'defers marking the notification as failed' do
+        Rapns.config.batch_storage_updates = true
+        batch.mark_failed(notification1, 1, 'an error')
+        batch.failed.should == {[1, 'an error'] => [notification1]}
+      end
+    end
+  end
+
+  describe 'mark_retryable' do
+    let(:time) { Time.now }
+
+    describe 'batching is disabled' do
+      before { Rapns.config.batch_storage_updates = false }
+
+      it 'marks the notification as retryable' do
+        store.should_receive(:mark_retryable).with(notification1, time)
+        batch.mark_retryable(notification1, time)
+      end
+
+      it 'reflects the notification will be retried' do
+        batch.should_receive(:reflect).with(:notification_will_retry, notification1)
+        batch.mark_retryable(notification1, time)
+      end
+    end
+
+    describe 'batching is enabled' do
+      before { Rapns.config.batch_storage_updates = true }
+
+      it 'defers marking the notification as retryable' do
+        batch.mark_retryable(notification1, time)
+        batch.retryable.should == {time => [notification1]}
+      end
+    end
+  end
+
+  describe 'complete' do
+    before do
+      Rapns.config.batch_storage_updates = true
+      Rapns.stub(:logger => double.as_null_object)
+      batch.stub(:reflect)
+    end
+
+    it 'clears the notifications' do
+      expect do
+        2.times { batch.notification_processed }
+      end.to change(batch.notifications, :length).to(0)
+    end
+
+    it 'identifies as complete' do
+      expect do
+        2.times { batch.notification_processed }
+      end.to change(batch, :complete?).to(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
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_delivered(n)
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as delivered' do
+        store.should_receive(:mark_batch_delivered).with([notification1, notification2])
+        complete
+      end
+
+      it 'reflects the notifications were delivered' do
+        batch.should_receive(:reflect).with(:notification_delivered, notification1)
+        batch.should_receive(:reflect).with(:notification_delivered, notification2)
+        complete
+      end
+
+      it 'clears the delivered notifications' do
+        complete
+        batch.delivered.should == []
+      end
+    end
+
+    describe 'failed' do
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_failed(n, 1, 'an error')
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as failed' do
+        store.should_receive(:mark_batch_failed).with([notification1, notification2], 1, 'an error')
+        complete
+      end
+
+      it 'reflects the notifications failed' do
+        batch.should_receive(:reflect).with(:notification_failed, notification1)
+        batch.should_receive(:reflect).with(:notification_failed, notification2)
+        complete
+      end
+
+      it 'clears the failed notifications' do
+        complete
+        batch.failed.should == {}
+      end
+    end
+
+    describe 'retryable' do
+      let(:time) { Time.now }
+
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_retryable(n, time)
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as retryable' do
+        store.should_receive(:mark_batch_retryable).with([notification1, notification2], time)
+        complete
+      end
+
+      it 'reflects the notifications will be retried' do
+        batch.should_receive(:reflect).with(:notification_will_retry, notification1)
+        batch.should_receive(:reflect).with(:notification_will_retry, notification2)
+        complete
+      end
+
+      it 'clears the retryable notifications' do
+        complete
+        batch.retryable.should == {}
+      end
+    end
+  end
+end

data/spec/unit/daemon/delivery_error_spec.rb

@@ -0,0 +1,13 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::DeliveryError do
+  let(:error) { Rapns::DeliveryError.new(4, 12, "Missing payload") }
+
+  it "returns an informative message" do
+    error.to_s.should == "Unable to deliver notification 12, received error 4 (Missing payload)"
+  end
+
+  it "returns the error code" do
+    error.code.should == 4
+  end
+end

data/spec/unit/daemon/delivery_handler_collection_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path("spec/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 == 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 == 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

@@ -0,0 +1,45 @@
+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 = double
+    Rapns.stub(:logger => logger)
+    error = StandardError.new
+    delivery_handler.stub(:deliver).and_raise(error)
+    Rapns.logger.should_receive(:error).with(error)
+    run_delivery_handler
+  end
+
+  it 'reflects an exception' do
+    Rapns.stub(:logger => double(:error => nil))
+    error = StandardError.new
+    delivery_handler.stub(:deliver).and_raise(error)
+    delivery_handler.should_receive(:reflect).with(:error, error)
+    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
+    queue.should_receive(:push).with(Rapns::Daemon::DeliveryHandler::WAKEUP) { |*a| queue.proxied_by_rspec__push(*a) }
+    run_delivery_handler
+  end
+
+  describe "when being stopped" do
+    before { queue.pop }
+
+    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
+  end
+end

data/spec/unit/daemon/feeder_spec.rb

@@ -0,0 +1,81 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Daemon::Feeder do
+  let(:config) { double(:batch_size => 5000,
+                        :push_poll => 0,
+                        :embedded => false,
+                        :push => false,
+                        :udp_wake_host => nil,
+                        :udp_wake_port => nil) }
+  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) { double }
+
+  before do
+    Rapns.stub(:config => config,:logger => logger)
+    Rapns::Daemon.stub(:store => double(:deliverable_notifications => [notification]))
+    Rapns::Daemon::Feeder.stub(:stop? => true)
+    Rapns::Daemon::AppRunner.stub(:enqueue => nil, :idle => [double(:app => app)])
+  end
+
+  def start
+    Rapns::Daemon::Feeder.start
+  end
+
+  it "starts the loop in a new thread if embedded" do
+    config.stub(:embedded => true)
+    Thread.should_receive(:new).and_yield
+    Rapns::Daemon::Feeder.should_receive(:feed_forever)
+    start
+  end
+
+  it 'loads deliverable notifications' do
+    Rapns::Daemon.store.should_receive(:deliverable_notifications).with([app])
+    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)
+    Rapns::Daemon::Feeder.should_receive(:enqueue_notifications)
+    start
+  end
+
+  it "enqueues the notifications" do
+    Rapns::Daemon::AppRunner.should_receive(:enqueue).with([notification])
+    start
+  end
+
+  it "logs errors" do
+    e = StandardError.new("bork")
+    Rapns::Daemon.store.stub(:deliverable_notifications).and_raise(e)
+    Rapns.logger.should_receive(:error).with(e)
+    start
+  end
+
+  it "interrupts sleep when stopped" do
+    Rapns::Daemon::Feeder.should_receive(:interrupt_sleep)
+    Rapns::Daemon::Feeder.stop
+  end
+
+  it "enqueues notifications when started" do
+    Rapns::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
+    Rapns::Daemon::Feeder.stub(:loop).and_yield
+    start
+  end
+
+  it "sleeps for the given period" do
+    config.stub(:push_poll => 2)
+    sleeper = double(:sleep => true)
+    sleeper.should_receive(:sleep).with(2)
+    Rapns::Daemon::Feeder.stub(:interruptible_sleeper => sleeper)
+    Rapns::Daemon::Feeder.stub(:loop).and_yield
+    Rapns::Daemon::Feeder.start
+  end
+end

data/spec/unit/daemon/gcm/app_runner_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path("spec/unit_spec_helper")
+require File.dirname(__FILE__) + '/../app_runner_shared.rb'
+
+describe Rapns::Daemon::Gcm::AppRunner do
+  it_should_behave_like 'an AppRunner subclass'
+
+  let(:app_class) { Rapns::Gcm::App }
+  let(:app) { app_class.new }
+  let(:runner) { Rapns::Daemon::Gcm::AppRunner.new(app) }
+  let(:handler) { double(:start => nil, :queue= => nil, :wakeup => nil, :wait => nil) }
+  let(:handler_collection) { double(:handler_collection, :push => nil, :size => 1, :stop => nil) }
+  let(:logger) { double(:info => nil) }
+
+  before do
+    Rapns.stub(:logger => logger)
+    Rapns::Daemon::Gcm::DeliveryHandler.stub(:new => handler)
+    Rapns::Daemon::DeliveryHandlerCollection.stub(:new => handler_collection)
+  end
+end

data/spec/unit/daemon/gcm/delivery_handler_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("spec/unit_spec_helper")
+require File.dirname(__FILE__) + '/../delivery_handler_shared.rb'
+
+describe Rapns::Daemon::Gcm::DeliveryHandler do
+  it_should_behave_like 'an DeliveryHandler subclass'
+
+  let(:notification) { double }
+  let(:batch) { double(:notification_processed => nil) }
+  let(:queue) { Queue.new }
+  let(:app) { double }
+  let(:delivery_handler) { Rapns::Daemon::Gcm::DeliveryHandler.new(app) }
+  let(:http) { double(:shutdown => nil) }
+  let(:delivery) { double(:perform => nil) }
+
+  before do
+    Net::HTTP::Persistent.stub(:new => http)
+    Rapns::Daemon::Gcm::Delivery.stub(:new => delivery)
+    delivery_handler.queue = queue
+    queue.push([notification, batch])
+  end
+
+  def run_delivery_handler
+    delivery_handler.start
+    delivery_handler.stop
+    delivery_handler.wakeup
+    delivery_handler.wait
+  end
+
+  it 'performs delivery of an notification' do
+    Rapns::Daemon::Gcm::Delivery.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
+    delivery.should_receive(:perform)
+    run_delivery_handler
+  end
+
+  it 'initiates a persistent connection object' do
+    Net::HTTP::Persistent.should_receive(:new).with('rapns')
+    Rapns::Daemon::Gcm::DeliveryHandler.new(app)
+  end
+
+  it 'shuts down the http connection stopped' do
+    http.should_receive(:shutdown)
+    run_delivery_handler
+  end
+end