rpush 1.0.0-java

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

data/spec/unit/daemon/interruptible_sleep_spec.rb

@@ -0,0 +1,68 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::InterruptibleSleep do
+
+  let(:rd) { double(:close => nil) }
+  let(:wr) { double(:close => nil) }
+
+  subject { Rpush::Daemon::InterruptibleSleep.new }
+
+  it 'creates a new pipe' do
+    IO.should_receive(:pipe)
+    subject
+  end
+
+  it 'selects on the reader' do
+    IO.stub(:pipe => [rd, wr])
+    IO.should_receive(:select).with([rd], nil, nil, 1)
+    subject.sleep(1)
+  end
+
+  it 'closes the writer' do
+    IO.stub(:pipe => [rd, wr])
+    rd.should_receive(:close)
+    wr.should_receive(:close)
+    subject.close
+  end
+
+  it 'returns false when timeout occurs' do
+    expect(subject.sleep(0.01)).to be_false
+  end
+
+  it 'returns true when sleep does not timeout' do
+    subject.interrupt_sleep
+    expect(subject.sleep(0.01)).to be_true
+  end
+
+  context 'with UDP socket connected' do
+    before :each do
+      @host, @port = subject.enable_wake_on_udp('127.0.0.1', 0)
+    end
+
+    it 'times out with no udp activity' do
+      expect(subject.sleep(0.01)).to be_false
+    end
+
+    unless defined? JRUBY_VERSION
+      it 'wakes on UDPSocket' do
+        waker = UDPSocket.new
+        waker.connect(@host, @port)
+        waker.write('x')
+        expect(subject.sleep(0.01)).to be_true
+      end
+
+      it 'consumes all data on udp socket' do
+        waker = UDPSocket.new
+        waker.connect(@host, @port)
+        waker.send('x', 0)
+        waker.send('x', 0)
+        waker.send('x', 0)
+        # true since there is data to be read => no timeout
+        expect(subject.sleep(0.01)).to be_true
+        # false since data is consumed => wait for full timeout
+        expect(subject.sleep(0.01)).to be_false
+      end
+    end
+  end
+
+end

data/spec/unit/daemon/reflectable_spec.rb

@@ -0,0 +1,27 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Reflectable do
+  class TestReflectable
+    include Rpush::Daemon::Reflectable
+  end
+
+  let(:logger) { double(:error => nil) }
+  let(:test_reflectable) { TestReflectable.new }
+
+  before do
+    Rpush.reflections.stub(:__dispatch)
+    Rpush.stub(:logger => logger)
+  end
+
+  it 'dispatches the given reflection' do
+    Rpush.reflections.should_receive(:__dispatch).with(:error)
+    test_reflectable.reflect(:error)
+  end
+
+  it 'logs errors raise by the reflection' do
+    error = StandardError.new
+    Rpush.reflections.stub(:__dispatch).and_raise(error)
+    Rpush.logger.should_receive(:error).with(error)
+    test_reflectable.reflect(:error)
+  end
+end

data/spec/unit/daemon/retryable_error_spec.rb

@@ -0,0 +1,14 @@
+require "unit_spec_helper"
+
+describe Rpush::RetryableError do
+  let(:response) { double(:code => 401, :header => { 'retry-after' => 3600 }) }
+  let(:error) { Rpush::RetryableError.new(401, 12, "Unauthorized", response) }
+
+  it "returns an informative message" do
+    error.to_s.should eq "Retryable error for 12, received error 401 (Unauthorized) - retry after 3600"
+  end
+
+  it "returns the error code" do
+    error.code.should eq 401
+  end
+end

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -0,0 +1,33 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::ServiceConfigMethods do
+  module ServiceConfigMethodsSpec
+    extend Rpush::Daemon::ServiceConfigMethods
+    class Delivery; end
+  end
+
+  it 'returns the delivery class' do
+    ServiceConfigMethodsSpec.delivery_class.should eq ServiceConfigMethodsSpec::Delivery
+  end
+
+  it 'gets & sets loops' do
+    loop_class = double
+    ServiceConfigMethodsSpec.loops loop_class
+    ServiceConfigMethodsSpec.loops.should eq [loop_class]
+  end
+
+  it 'returns a new dispatcher' do
+    ServiceConfigMethodsSpec.dispatcher :http, an: :option
+    app = double
+    dispatcher = double
+    Rpush::Daemon::Dispatcher::Http.should_receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, an: :option).and_return(dispatcher)
+    ServiceConfigMethodsSpec.new_dispatcher(app).should eq dispatcher
+  end
+
+  it 'raises a NotImplementedError for an unknown dispatcher type' do
+    expect do
+      ServiceConfigMethodsSpec.dispatcher :unknown
+      ServiceConfigMethodsSpec.dispatcher_class
+    end.to raise_error(NotImplementedError)
+  end
+end