rpush 1.0.0

data/spec/unit/daemon/delivery_error_spec.rb

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

data/spec/unit/daemon/delivery_spec.rb

@@ -0,0 +1,38 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Delivery do
+
+  class DeliverySpecDelivery < Rpush::Daemon::Delivery
+    def initialize(batch)
+      @batch = batch
+    end
+  end
+
+  let(:now) { Time.parse("2014-10-14 00:00:00") }
+  let(:batch) { double(Rpush::Daemon::Batch) }
+  let(:delivery) { DeliverySpecDelivery.new(batch) }
+  let(:notification) { Rpush::Apns::Notification.new }
+
+  before { Time.stub(now: now) }
+
+  describe 'mark_retryable' do
+
+    it 'does not retry a notification with an expired fail_after' do
+      batch.should_receive(:mark_failed).with(notification, nil, "Notification failed to be delivered before 2014-10-13 23:00:00.")
+      notification.fail_after = Time.now - 1.hour
+      delivery.mark_retryable(notification, Time.now + 1.hour)
+    end
+
+    it 'retries the notification if does not have a fail_after time' do
+      batch.should_receive(:mark_retryable)
+      notification.fail_after = nil
+      delivery.mark_retryable(notification, Time.now + 1.hour)
+    end
+
+    it 'retries the notification if the fail_after time has not been reached' do
+      batch.should_receive(:mark_retryable)
+      notification.fail_after = Time.now + 1.hour
+      delivery.mark_retryable(notification, Time.now + 1.hour)
+    end
+  end
+end

data/spec/unit/daemon/dispatcher/http_spec.rb

@@ -0,0 +1,33 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Dispatcher::Http do
+  let(:app) { double }
+  let(:delivery_class) { double }
+  let(:notification) { double }
+  let(:batch) { double }
+  let(:http) { double }
+  let(:dispatcher) { Rpush::Daemon::Dispatcher::Http.new(app, delivery_class) }
+
+  before { Net::HTTP::Persistent.stub(:new => http) }
+
+  it 'constructs a new persistent connection' do
+    Net::HTTP::Persistent.should_receive(:new)
+    Rpush::Daemon::Dispatcher::Http.new(app, delivery_class)
+  end
+
+  describe 'dispatch' do
+    it 'delivers the notification' do
+      delivery = double
+      delivery_class.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
+      delivery.should_receive(:perform)
+      dispatcher.dispatch(notification, batch)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      http.should_receive(:shutdown)
+      dispatcher.cleanup
+    end
+  end
+end

data/spec/unit/daemon/dispatcher/tcp_spec.rb

@@ -0,0 +1,38 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Dispatcher::Tcp do
+  let(:app) { double }
+  let(:delivery) { double(:perform => nil) }
+  let(:delivery_class) { double(:new => delivery) }
+  let(:notification) { double }
+  let(:batch) { double }
+  let(:connection) { double(Rpush::Daemon::TcpConnection, :connect => nil) }
+  let(:host) { 'localhost' }
+  let(:port) { 1234 }
+  let(:host_proc) { Proc.new { |app| [host, port] } }
+  let(:dispatcher) { Rpush::Daemon::Dispatcher::Tcp.new(app, delivery_class, :host => host_proc) }
+
+  before { Rpush::Daemon::TcpConnection.stub(:new => connection) }
+
+  describe 'dispatch' do
+    it 'lazily connects the socket' do
+      Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port).and_return(connection)
+      connection.should_receive(:connect)
+      dispatcher.dispatch(notification, batch)
+    end
+
+    it 'delivers the notification' do
+      delivery_class.should_receive(:new).with(app, connection, notification, batch).and_return(delivery)
+      delivery.should_receive(:perform)
+      dispatcher.dispatch(notification, batch)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      dispatcher.dispatch(notification, batch) # lazily initialize connection
+      connection.should_receive(:close)
+      dispatcher.cleanup
+    end
+  end
+end

data/spec/unit/daemon/dispatcher_loop_collection_spec.rb

@@ -0,0 +1,37 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::DispatcherLoopCollection do
+  let(:dispatcher_loop) { double.as_null_object }
+  let(:collection) { Rpush::Daemon::DispatcherLoopCollection.new }
+
+  it 'returns the size of the collection' do
+    collection.push(dispatcher_loop)
+    collection.size.should eq 1
+  end
+
+  it 'pops a dispatcher loop from the collection' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop.should_receive(:stop)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop.should_receive(:wait)
+    collection.pop
+    collection.size.should eq 0
+  end
+
+  it 'wakes up all dispatcher loops when popping a single dispatcher_loop' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop2 = double.as_null_object
+    collection.push(dispatcher_loop2)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop2.should_receive(:wakeup)
+    collection.pop
+  end
+
+  it 'stops all dispatcher  detetcloops' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop.should_receive(:stop)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop.should_receive(:wait)
+    collection.stop
+  end
+end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -0,0 +1,71 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::DispatcherLoop do
+  def run_dispatcher_loop
+    dispatcher_loop.start
+    dispatcher_loop.stop
+    dispatcher_loop.wakeup
+    dispatcher_loop.wait
+  end
+
+  let(:notification) { double }
+  let(:batch) { double(:notification_dispatched => nil) }
+  let(:queue) { Queue.new }
+  let(:dispatcher) { double(:dispatch => nil, :cleanup => nil) }
+  let(:dispatcher_loop) { Rpush::Daemon::DispatcherLoop.new(queue, dispatcher) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil)}
+
+  before do
+    Rpush::Daemon.stub(:store => store)
+    queue.push([notification, batch])
+  end
+
+  it 'logs errors' do
+    logger = double
+    Rpush.stub(:logger => logger)
+    error = StandardError.new
+    dispatcher.stub(:dispatch).and_raise(error)
+    Rpush.logger.should_receive(:error).with(error)
+    run_dispatcher_loop
+  end
+
+  it 'reflects an exception' do
+    Rpush.stub(:logger => double(:error => nil))
+    error = StandardError.new
+    dispatcher.stub(:dispatch).and_raise(error)
+    dispatcher_loop.should_receive(:reflect).with(:error, error)
+    run_dispatcher_loop
+  end
+
+  it 'instructs the batch that the notification has been processed' do
+    batch.should_receive(:notification_dispatched)
+    run_dispatcher_loop
+  end
+
+  it "instructs the queue to wakeup the thread when told to stop" do
+    queue.should_receive(:push).with(Rpush::Daemon::DispatcherLoop::WAKEUP).and_call_original
+    run_dispatcher_loop
+  end
+
+  describe 'stop' do
+    before do
+      queue.clear
+      queue.push(Rpush::Daemon::DispatcherLoop::WAKEUP)
+    end
+
+    it 'does not attempt to dispatch when a WAKEUP is dequeued' do
+      dispatcher.should_not_receive(:dispatch)
+      run_dispatcher_loop
+    end
+
+    it 'instructs the dispatcher to cleanup' do
+      dispatcher.should_receive(:cleanup)
+      run_dispatcher_loop
+    end
+
+    it 'releases the store connection' do
+      Rpush::Daemon.store.should_receive(:release_connection)
+      run_dispatcher_loop
+    end
+  end
+end

data/spec/unit/daemon/feeder_spec.rb

@@ -0,0 +1,98 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::Feeder do
+  let(:config) { double(:batch_size => 5000,
+                        :push_poll => 0,
+                        :embedded => false,
+                        :push => false,
+                        :wakeup => nil) }
+  let!(:app) { Rpush::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
+  let(:notification) { Rpush::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
+  let(:logger) { double }
+  let(:interruptible_sleep) { double(:sleep => nil, :interrupt_sleep => nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord,
+      deliverable_notifications: [notification], release_connection: nil) }
+
+  before do
+    Rpush.stub(:config => config,:logger => logger)
+    Rpush::Daemon.stub(:store => store)
+    Rpush::Daemon::Feeder.stub(:stop? => true)
+    Rpush::Daemon::AppRunner.stub(:enqueue => nil, :idle => [double(:app => app)])
+    Rpush::Daemon::InterruptibleSleep.stub(:new => interruptible_sleep)
+    Rpush::Daemon::Feeder.instance_variable_set('@interruptible_sleeper', nil)
+  end
+
+  def start_and_stop
+    Rpush::Daemon::Feeder.start
+    Rpush::Daemon::Feeder.stop
+  end
+
+  it 'starts the loop in a new thread if embedded' do
+    config.stub(:embedded => true)
+    Thread.should_receive(:new).and_yield
+    Rpush::Daemon::Feeder.should_receive(:feed_forever)
+    start_and_stop
+  end
+
+  it 'loads deliverable notifications' do
+    Rpush::Daemon.store.should_receive(:deliverable_notifications).with([app])
+    start_and_stop
+  end
+
+  it 'does not attempt to load deliverable notifications if there are no idle runners' do
+    Rpush::Daemon::AppRunner.stub(:idle => [])
+    Rpush::Daemon.store.should_not_receive(:deliverable_notifications)
+    start_and_stop
+  end
+
+  it 'enqueues notifications without looping if in push mode' do
+    config.stub(:push => true)
+    Rpush::Daemon::Feeder.should_not_receive(:feed_forever)
+    Rpush::Daemon::Feeder.should_receive(:enqueue_notifications)
+    start_and_stop
+  end
+
+  it "enqueues the notifications" do
+    Rpush::Daemon::AppRunner.should_receive(:enqueue).with([notification])
+    start_and_stop
+  end
+
+  it "logs errors" do
+    e = StandardError.new("bork")
+    Rpush::Daemon.store.stub(:deliverable_notifications).and_raise(e)
+    Rpush.logger.should_receive(:error).with(e)
+    start_and_stop
+  end
+
+  describe 'stop' do
+    it 'interrupts sleep when stopped' do
+      Rpush::Daemon::Feeder.should_receive(:interrupt_sleep)
+      start_and_stop
+    end
+
+    it 'releases the store connection when stopped' do
+      Rpush::Daemon.store.should_receive(:release_connection)
+      start_and_stop
+    end
+  end
+
+  it "enqueues notifications when started" do
+    Rpush::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
+    Rpush::Daemon::Feeder.stub(:loop).and_yield
+    start_and_stop
+  end
+
+  it "sleeps for the given period" do
+    config.stub(:push_poll => 2)
+    interruptible_sleep.should_receive(:sleep).with(2)
+    start_and_stop
+  end
+
+  it "creates the wakeup socket" do
+    bind = '127.0.0.1'
+    port = 12345
+    config.stub(:wakeup => { :bind => bind, :port => port})
+    interruptible_sleep.should_receive(:enable_wake_on_udp).with(bind, port)
+    start_and_stop
+  end
+end

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

@@ -0,0 +1,310 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Gcm::Delivery do
+  let(:app) { Rpush::Gcm::App.new(:name => 'MyApp', :auth_key => 'abc123') }
+  let(:notification) { Rpush::Gcm::Notification.create!(:app => app, :registration_ids => ['xyz'], :deliver_after => Time.now) }
+  let(:logger) { double(:error => nil, :info => nil, :warn => nil) }
+  let(:response) { double(:code => 200, :header => {}) }
+  let(:http) { double(:shutdown => nil, :request => response)}
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(:mark_failed => nil, :mark_delivered => nil, :mark_retryable => nil) }
+  let(:delivery) { Rpush::Daemon::Gcm::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(:create_gcm_notification => double(:id => 2)) }
+
+  def perform
+    delivery.perform
+  end
+
+  before do
+    delivery.stub(:reflect => nil)
+    Rpush::Daemon.stub(:store => store)
+    Time.stub(:now => now)
+    Rpush.stub(:logger => logger)
+  end
+
+  shared_examples_for 'a notification with some delivery failures' do
+    let(:new_notification) { Rpush::Gcm::Notification.where('id != ?', notification.id).first }
+
+    before { response.stub(:body => JSON.dump(body)) }
+
+    it 'marks the original notification as failed' do
+      delivery.should_receive(:mark_failed).with(nil, error_description)
+      perform rescue Rpush::DeliveryError
+    end
+
+    it 'creates a new notification for the unavailable devices' do
+      notification.update_attributes(:registration_ids => ['id_0', 'id_1', 'id_2'], :data => {'one' => 1}, :collapse_key => 'thing', :delay_while_idle => true)
+      response.stub(:header => { 'retry-after' => 10 })
+      attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
+      store.should_receive(:create_gcm_notification).with(attrs, notification.data,
+          ['id_0', 'id_2'], now + 10.seconds, notification.app)
+      perform rescue Rpush::DeliveryError
+    end
+
+    it 'raises a DeliveryError' do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 200 response' do
+    before do
+      response.stub(:code => 200)
+    end
+
+    it 'reflects on any IDs which successfully received the notification' do
+      body = {
+        'failure' => 1,
+        'success' => 1,
+        'results' => [
+          { 'message_id' => '1:000' },
+          { 'error' => 'Err' }
+        ]
+      }
+
+      response.stub(:body => JSON.dump(body))
+      notification.stub(:registration_ids => ['1', '2'])
+      delivery.should_receive(:reflect).with(:gcm_delivered_to_recipient, notification, '1')
+      delivery.should_not_receive(:reflect).with(:gcm_delivered_to_recipient, notification, '2')
+      perform rescue Rpush::DeliveryError
+    end
+
+    it 'reflects on any IDs which failed to receive the notification' do
+      body = {
+        'failure' => 1,
+        'success' => 1,
+        'results' => [
+          { 'error' => 'Err' },
+          { 'message_id' => '1:000' }
+        ]
+      }
+
+      response.stub(:body => JSON.dump(body))
+      notification.stub(:registration_ids => ['1', '2'])
+      delivery.should_receive(:reflect).with(:gcm_failed_to_recipient, notification, 'Err', '1')
+      delivery.should_not_receive(:reflect).with(:gcm_failed_to_recipient, notification, anything, '2')
+      perform rescue Rpush::DeliveryError
+    end
+
+    it 'reflects on canonical IDs' do
+      body = {
+        'failure' => 0,
+        'success' => 3,
+        'canonical_ids' => 1,
+        'results' => [
+          { 'message_id' => '1:000' },
+          { 'message_id' => '1:000', 'registration_id' => 'canonical123' },
+          { 'message_id' => '1:000' },
+        ]}
+
+      response.stub(:body => JSON.dump(body))
+      notification.stub(:registration_ids => ['1', '2', '3'])
+      delivery.should_receive(:reflect).with(:gcm_canonical_id, '2', 'canonical123')
+      perform
+    end
+
+    it 'reflects on invalid IDs' do
+      body = {
+          'failure' => 1,
+          'success' => 2,
+          'canonical_ids' => 0,
+          'results' => [
+              { 'message_id' => '1:000' },
+              { 'error' => 'NotRegistered' },
+              { 'message_id' => '1:000' },
+          ]}
+
+      response.stub(:body => JSON.dump(body))
+      notification.stub(:registration_ids => ['1', '2', '3'])
+      delivery.should_receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
+      perform rescue Rpush::DeliveryError
+    end
+
+    describe 'when delivered successfully to all devices' do
+      let(:body) {{
+        'failure' => 0,
+        'success' => 1,
+        'results' => [{ 'message_id' => '1:000'}]
+      }}
+
+      before { response.stub(:body => JSON.dump(body)) }
+
+      it 'marks the notification as delivered' do
+        delivery.should_receive(:mark_delivered)
+        perform
+      end
+
+      it 'logs that the notification was delivered' do
+        logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+        perform
+      end
+    end
+
+    it 'marks a notification as failed if any ids are invalid' do
+      body = {
+          'failure' => 1,
+          'success' => 2,
+          'canonical_ids' => 0,
+          'results' => [
+              { 'message_id' => '1:000' },
+              { 'error' => 'NotRegistered' },
+              { 'message_id' => '1:000' },
+          ]}
+
+      response.stub(:body => JSON.dump(body))
+      delivery.should_receive(:mark_failed)
+      delivery.should_not_receive(:mark_retryable)
+      store.should_not_receive(:create_gcm_notification)
+      perform rescue Rpush::DeliveryError
+    end
+
+    it 'marks a notification as failed if any deliveries failed that cannot be retried' do
+      body = {
+        'failure' => 1,
+        'success' => 1,
+        'results' => [
+          { 'message_id' => '1:000' },
+          { 'error' => 'InvalidDataKey' }
+        ]}
+      response.stub(:body => JSON.dump(body))
+      delivery.should_receive(:mark_failed).with(nil, "Failed to deliver to all recipients. Errors: InvalidDataKey.")
+      perform rescue Rpush::DeliveryError
+    end
+
+    describe 'all deliveries failed with Unavailable or InternalServerError' do
+      let(:body) {{
+        'failure' => 2,
+        'success' => 0,
+        'results' => [
+          { 'error' => 'Unavailable' },
+          { 'error' => 'Unavailable' }
+        ]}}
+
+      before do
+        response.stub(:body => JSON.dump(body))
+        notification.stub(:registration_ids => ['1', '2'])
+      end
+
+      it 'retries the notification respecting the Retry-After header' do
+        response.stub(:header => { 'retry-after' => 10 })
+        delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+        perform
+      end
+
+      it 'retries the notification using exponential back-off if the Retry-After header is not present' do
+        delivery.should_receive(:mark_retryable).with(notification, now + 2)
+        perform
+      end
+
+      it 'does not mark the notification as failed' do
+        delivery.should_not_receive(:mark_failed)
+        perform
+      end
+
+      it 'logs that the notification will be retried' do
+        notification.retries = 1
+        notification.deliver_after = now + 2
+        Rpush.logger.should_receive(:warn).with("[MyApp] All recipients unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+        perform
+      end
+    end
+
+    describe 'all deliveries failed with some as Unavailable or InternalServerError' do
+      let(:body) {{
+        'failure' => 3,
+        'success' => 0,
+        'results' => [
+          { 'error' => 'Unavailable' },
+          { 'error' => 'InvalidDataKey' },
+          { 'error' => 'Unavailable' }
+        ]}}
+      let(:error_description) { /#{Regexp.escape("Failed to deliver to recipients 0, 1, 2. Errors: Unavailable, InvalidDataKey, Unavailable. 0, 2 will be retried as notification")} [\d]+\./ }
+      it_should_behave_like 'a notification with some delivery failures'
+    end
+
+    describe 'some deliveries failed with Unavailable or InternalServerError' do
+      let(:body) {{
+        'failure' => 2,
+        'success' => 1,
+        'results' => [
+          { 'error' => 'Unavailable' },
+          { 'message_id' => '1:000' },
+          { 'error' => 'InternalServerError' }
+        ]}}
+      let(:error_description) { /#{Regexp.escape("Failed to deliver to recipients 0, 2. Errors: Unavailable, InternalServerError. 0, 2 will be retried as notification")} [\d]+\./ }
+      it_should_behave_like 'a notification with some delivery failures'
+    end
+  end
+
+  describe 'a 503 response' do
+    before { response.stub(:code => 503) }
+
+    it 'logs a warning that the notification will be retried.' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
+      logger.should_receive(:warn).with("[MyApp] GCM responded with an Service Unavailable Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      perform
+    end
+
+    it 'respects an integer Retry-After header' do
+      response.stub(:header => { 'retry-after' => 10 })
+      delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+
+    it 'respects a HTTP-date Retry-After header' do
+      response.stub(:header => { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      delivery.should_receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+      perform
+    end
+
+    it 'defaults to exponential back-off if the Retry-After header is not present' do
+      delivery.should_receive(:mark_retryable).with(notification, now + 2 ** 1)
+      perform
+    end
+  end
+
+  describe 'a 500 response' do
+    before do
+      notification.update_attribute(:retries, 2)
+      response.stub(:code => 500)
+    end
+
+    it 'logs a warning that the notification has been re-queued.' do
+      notification.retries = 3
+      notification.deliver_after = now + 2 ** 3
+      Rpush.logger.should_receive(:warn).with("[MyApp] GCM responded with an Internal Error. Notification #{notification.id} will be retried after #{(now + 2 ** 3).strftime("%Y-%m-%d %H:%M:%S")} (retry 3).")
+      perform
+    end
+
+    it 'retries the notification in accordance with the exponential back-off strategy.' do
+      delivery.should_receive(:mark_retryable).with(notification, now + 2 ** 3)
+      perform
+    end
+  end
+
+  describe 'a 401 response' do
+    before { response.stub(:code => 401) }
+
+    it 'raises an error' do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 400 response' do
+    before { response.stub(:code => 400) }
+
+    it 'marks the notification as failed' do
+      delivery.should_receive(:mark_failed).with(400, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
+      perform rescue Rpush::DeliveryError
+    end
+  end
+
+  describe 'an un-handled response' do
+    before { response.stub(:code => 418) }
+
+    it 'marks the notification as failed' do
+      delivery.should_receive(:mark_failed).with(418, "I'm a Teapot")
+      perform rescue Rpush::DeliveryError
+    end
+  end
+end