rapns_rails_2 3.4.3

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

@@ -0,0 +1,289 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Daemon::Gcm::Delivery do
+  let(:app) { Rapns::Gcm::App.new(:name => 'MyApp', :auth_key => 'abc123') }
+  let(:notification) { Rapns::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) { Rapns::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)
+    Rapns::Daemon.stub(:store => store)
+    Time.stub(:now => now)
+    Rapns.stub(:logger => logger)
+  end
+
+  shared_examples_for 'an notification with some delivery failures' do
+    let(:new_notification) { Rapns::Gcm::Notification.where('id != ?', notification.id).first }
+
+    before { response.stub(:body => MultiJson.dump(body) ) }
+
+    it 'marks the original notification as failed' do
+      batch.should_receive(:mark_failed).with(notification, nil, error_description)
+      perform rescue Rapns::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 Rapns::DeliveryError
+    end
+
+    it 'raises a DeliveryError' do
+      expect { perform }.to raise_error(Rapns::DeliveryError)
+    end
+  end
+
+  describe 'an 200 response' do
+    before do
+      response.stub(:code => 200)
+    end
+
+    it 'marks the notification as delivered if delivered successfully to all devices' do
+      response.stub(:body => MultiJson.dump({ 'failure' => 0 }))
+      batch.should_receive(:mark_delivered).with(notification)
+      perform
+    end
+
+    it 'logs that the notification was delivered' do
+      response.stub(:body => MultiJson.dump({ 'failure' => 0 }))
+      logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+      perform
+    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 => MultiJson.dump(body))
+      batch.should_receive(:mark_failed).with(notification, nil, "Failed to deliver to all recipients. Errors: InvalidDataKey.")
+      perform rescue Rapns::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 => MultiJson.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 => MultiJson.dump(body))
+      notification.stub(:registration_ids => ['1', '2', '3'])
+      delivery.should_receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
+      perform
+    end
+
+    it 'does not retry, raise or marks a notification as failed for 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 => MultiJson.dump(body))
+      batch.should_not_receive(:mark_failed)
+      batch.should_not_receive(:mark_retryable)
+      store.should_not_receive(:create_gcm_notification)
+      perform
+    end
+
+    describe 'all deliveries returned Unavailable or InternalServerError' do
+      let(:body) {{
+        'failure' => 2,
+        'success' => 0,
+        'results' => [
+          { 'error' => 'Unavailable' },
+          { 'error' => 'Unavailable' }
+        ]}}
+
+      before { response.stub(:body => MultiJson.dump(body)) }
+
+      it 'retries the notification respecting the Retry-After header' do
+        response.stub(:header => { 'retry-after' => 10 })
+        batch.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
+        batch.should_receive(:mark_retryable).with(notification, now + 2)
+        perform
+      end
+
+      it 'does not mark the notification as failed' do
+        batch.should_not_receive(:mark_failed)
+        perform
+      end
+
+      it 'logs that the notification will be retried' do
+        notification.retries = 1
+        notification.deliver_after = now + 2
+        Rapns.logger.should_receive(:warn).with("All recipients unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+        perform
+      end
+    end
+
+    shared_examples_for 'an notification with some delivery failures (200)' do
+      let(:new_notification) { Rapns::Gcm::Notification.where('id != ?', notification.id).first }
+
+      before { response.stub(:body => MultiJson.dump(body)) }
+
+      it 'marks the original notification as failed' do
+        batch.should_receive(:mark_failed).with(notification, nil, error_description)
+        perform rescue Rapns::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 Rapns::DeliveryError
+      end
+
+      it 'raises a DeliveryError' do
+        expect { perform }.to raise_error(Rapns::DeliveryError)
+      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 'an notification with some delivery failures (200)'
+    end
+  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 'an notification with some delivery failures'
+  end
+
+  describe 'an 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("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 })
+      batch.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' })
+      batch.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
+      batch.should_receive(:mark_retryable).with(notification, now + 2 ** 1)
+      perform
+    end
+  end
+
+  describe 'an 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
+      Rapns.logger.should_receive(:warn).with("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
+      batch.should_receive(:mark_retryable).with(notification, now + 2 ** 3)
+      perform
+    end
+  end
+
+  describe 'an 401 response' do
+    before { response.stub(:code => 401) }
+
+    it 'raises an error' do
+      expect { perform }.to raise_error(Rapns::DeliveryError)
+    end
+  end
+
+  describe 'an 400 response' do
+    before { response.stub(:code => 400) }
+
+    it 'marks the notification as failed' do
+      batch.should_receive(:mark_failed).with(notification, 400, 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.')
+      perform rescue Rapns::DeliveryError
+    end
+  end
+
+  describe 'an un-handled response' do
+    before { response.stub(:code => 418) }
+
+    it 'marks the notification as failed' do
+      batch.should_receive(:mark_failed).with(notification, 418, "I'm a Teapot")
+      perform rescue Rapns::DeliveryError
+    end
+  end
+end

data/spec/unit/daemon/interruptible_sleep_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Daemon::InterruptibleSleep do
+
+  let(:rd) { double(:close => nil) }
+  let(:wr) { double(:close => nil) }
+
+  subject { Rapns::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
+    subject.sleep(0.01).should be_false
+  end
+
+  it 'returns true when sleep does not timeout' do
+    subject.interrupt_sleep
+    subject.sleep(0.01).should 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
+      subject.sleep(0.01).should be_false
+    end
+
+    it 'wakes on UDPSocket' do
+      waker = UDPSocket.new
+      waker.connect(@host, @port)
+      waker.write('x')
+      subject.sleep(0.01).should be_true
+      waker.close
+    end
+
+    it 'consumes all data on udp socket' do
+      waker = UDPSocket.new
+      # waker.connect(@host, @port)
+      waker.send('x', 0, @host, @port)
+      waker.send('x', 0, @host, @port)
+      waker.send('x', 0, @host, @port)
+      # true since there is data to be read => no timeout
+      subject.sleep(0.01).should be_true
+      # false since data is consumed => wait for full timeout
+      subject.sleep(0.01).should be_false
+      waker.close
+    end
+  end
+
+end

data/spec/unit/daemon/reflectable_spec.rb

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

data/spec/unit/daemon/store/active_record/reconnectable_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("spec/unit_spec_helper")
+require 'rapns/daemon/store/active_record/reconnectable'
+
+describe Rapns::Daemon::Store::ActiveRecord::Reconnectable do
+  class TestDouble
+    include Rapns::Daemon::Store::ActiveRecord::Reconnectable
+
+    attr_reader :name
+
+    def initialize(error, max_calls)
+      @error = error
+      @max_calls = max_calls
+      @calls = 0
+    end
+
+    def perform
+      with_database_reconnect_and_retry do
+        @calls += 1
+        raise @error if @calls <= @max_calls
+      end
+    end
+  end
+
+  let(:adapter_error_class) do
+    case $adapter
+    when 'postgresql'
+      PGError
+    when 'mysql'
+      Mysql::Error
+    when 'mysql2'
+      Mysql2::Error
+    when 'jdbcpostgresql'
+      ActiveRecord::JDBCError
+    when 'jdbcmysql'
+      ActiveRecord::JDBCError
+    when 'jdbch2'
+      ActiveRecord::JDBCError
+    when 'sqlite3'
+      SQLite3::Exception
+    else
+      raise "Please update #{__FILE__} for adapter #{$adapter}"
+    end
+  end
+  let(:error) { adapter_error_class.new("db down!") }
+  let(:test_double) { TestDouble.new(error, 1) }
+
+  before do
+    @logger = double("Logger", :info => nil, :error => nil, :warn => nil)
+    Rapns.stub(:logger).and_return(@logger)
+
+    ActiveRecord::Base.stub(:clear_all_connections!)
+    ActiveRecord::Base.stub(:establish_connection)
+    test_double.stub(:sleep)
+  end
+
+  it "should log the error raised" do
+    Rapns.logger.should_receive(:error).with(error)
+    test_double.perform
+  end
+
+  it "should log that the database is being reconnected" do
+    Rapns.logger.should_receive(:warn).with("Lost connection to database, reconnecting...")
+    test_double.perform
+  end
+
+  it "should log the reconnection attempt" do
+    Rapns.logger.should_receive(:warn).with("Attempt 1")
+    test_double.perform
+  end
+
+  it "should clear all connections" do
+    ActiveRecord::Base.should_receive(:clear_all_connections!)
+    test_double.perform
+  end
+
+  it "should establish a new connection" do
+    ActiveRecord::Base.should_receive(:establish_connection)
+    test_double.perform
+  end
+
+  it "should test out the new connection by performing a count" do
+    Rapns::Notification.should_receive(:count)
+    test_double.perform
+  end
+
+  context "when the reconnection attempt is not successful" do
+    before do
+      class << Rapns::Notification
+        def count
+          @count_calls += 1
+          return if @count_calls == 2
+          raise @error
+        end
+      end
+      Rapns::Notification.instance_variable_set("@count_calls", 0)
+      Rapns::Notification.instance_variable_set("@error", error)
+    end
+
+    it "should log the 2nd attempt" do
+      Rapns.logger.should_receive(:warn).with("Attempt 2")
+      test_double.perform
+    end
+
+    it "should log errors raised when the reconnection is not successful without notifying airbrake" do
+      Rapns.logger.should_receive(:error).with(error, :airbrake_notify => false)
+      test_double.perform
+    end
+
+    it "should sleep to avoid thrashing when the database is down" do
+      test_double.should_receive(:sleep).with(2)
+      test_double.perform
+    end
+  end
+end