rpush_extended 3.2.5

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

@@ -0,0 +1,387 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Gcm::Delivery do
+  let(:app) { Rpush::Gcm::App.create!(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, notification_processed: 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
+
+  def perform_with_rescue
+    expect { perform }.to raise_error(StandardError)
+  end
+
+  before do
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(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 { allow(response).to receive_messages(body: JSON.dump(body)) }
+
+    it 'marks the original notification as failed' do
+      # error = Rpush::DeliveryError.new(nil, notification.id, error_description)
+      expect(delivery).to receive(:mark_failed) do |error|
+        expect(error.to_s).to match(error_description)
+      end
+      perform_with_rescue
+    end
+
+    it 'creates a new notification for the unavailable devices' do
+      notification.update_attributes(registration_ids: %w(id_0 id_1 id_2), data: { 'one' => 1 }, collapse_key: 'thing', delay_while_idle: true)
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
+      expect(store).to receive(:create_gcm_notification).with(attrs, notification.data,
+                                                              %w(id_0 id_2), now + 10.seconds, notification.app)
+      perform_with_rescue
+    end
+
+    it 'raises a DeliveryError' do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 200 response' do
+    before do
+      allow(response).to receive_messages(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' }
+        ]
+      }
+
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2))
+      expect(delivery).to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '1')
+      expect(delivery).not_to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '2')
+      perform_with_rescue
+    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' }
+        ]
+      }
+
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2))
+      expect(delivery).to receive(:reflect).with(:gcm_failed_to_recipient, notification, 'Err', '1')
+      expect(delivery).not_to receive(:reflect).with(:gcm_failed_to_recipient, notification, anything, '2')
+      perform_with_rescue
+    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' }
+        ] }
+
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
+      expect(delivery).to 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' }
+        ]
+      }
+
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
+      expect(delivery).to receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
+      perform_with_rescue
+    end
+
+    describe 'when delivered successfully to all devices' do
+      let(:body) do
+        {
+          'failure' => 0,
+          'success' => 1,
+          'results' => [{ 'message_id' => '1:000' }]
+        }
+      end
+
+      before { allow(response).to receive_messages(body: JSON.dump(body)) }
+
+      it 'marks the notification as delivered' do
+        expect(delivery).to receive(:mark_delivered)
+        perform
+      end
+
+      it 'logs that the notification was delivered' do
+        expect(logger).to 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' }
+        ]
+      }
+
+      allow(response).to receive_messages(body: JSON.dump(body))
+      expect(delivery).to receive(:mark_failed)
+      expect(delivery).not_to receive(:mark_retryable)
+      expect(store).not_to receive(:create_gcm_notification)
+      perform_with_rescue
+    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' }
+        ] }
+      allow(response).to receive_messages(body: JSON.dump(body))
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients. Errors: InvalidDataKey.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+
+    describe 'all deliveries failed with Unavailable or InternalServerError' do
+      let(:body) do
+        {
+          'failure' => 2,
+          'success' => 0,
+          'results' => [
+            { 'error' => 'Unavailable' },
+            { 'error' => 'Unavailable' }
+          ]
+        }
+      end
+
+      before do
+        allow(response).to receive_messages(body: JSON.dump(body))
+        allow(notification).to receive_messages(registration_ids: %w(1 2))
+      end
+
+      it 'retries the notification respecting the Retry-After header' do
+        allow(response).to receive_messages(header: { 'retry-after' => 10 })
+        expect(delivery).to 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
+        expect(delivery).to receive(:mark_retryable).with(notification, now + 2)
+        perform
+      end
+
+      it 'does not mark the notification as failed' do
+        expect(delivery).not_to receive(:mark_failed)
+        perform
+      end
+
+      it 'logs that the notification will be retried' do
+        notification.retries = 1
+        notification.deliver_after = now + 2
+        expect(Rpush.logger).to 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) do
+        { 'failure' => 3,
+          'success' => 0,
+          'results' => [
+            { 'error' => 'Unavailable' },
+            { 'error' => 'InvalidDataKey' },
+            { 'error' => 'Unavailable' }
+          ]
+        }
+      end
+      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) do
+        { 'failure' => 2,
+          'success' => 1,
+          'results' => [
+            { 'error' => 'Unavailable' },
+            { 'message_id' => '1:000' },
+            { 'error' => 'InternalServerError' }
+          ]
+        }
+      end
+      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 { allow(response).to receive_messages(code: 503) }
+
+    it 'logs a warning that the notification will be retried.' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
+      expect(logger).to 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
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+
+    it 'respects a HTTP-date Retry-After header' do
+      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      expect(delivery).to 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
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
+      perform
+    end
+  end
+
+  describe 'a 502 response' do
+    before { allow(response).to receive_messages(code: 502) }
+
+    it 'logs a warning that the notification will be retried.' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
+      expect(logger).to receive(:warn).with("[MyApp] GCM responded with a Bad Gateway 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
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+
+    it 'respects a HTTP-date Retry-After header' do
+      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      expect(delivery).to 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
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
+      perform
+    end
+  end
+
+  describe 'a 500 response' do
+    before do
+      notification.update_attribute(:retries, 2)
+      allow(response).to receive_messages(code: 500)
+    end
+
+    it 'logs a warning that the notification has been re-queued.' do
+      notification.retries = 3
+      notification.deliver_after = now + 2**3
+      expect(Rpush.logger).to 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
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**3)
+      perform
+    end
+  end
+
+  describe 'a 5xx response' do
+    before { allow(response).to receive_messages(code: 555) }
+
+    it 'logs a warning that the notification will be retried.' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
+      expect(logger).to receive(:warn).with("[MyApp] GCM responded with a 5xx 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
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+
+    it 'respects a HTTP-date Retry-After header' do
+      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      expect(delivery).to 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
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
+      perform
+    end
+  end
+
+  describe 'a 401 response' do
+    before { allow(response).to receive_messages(code: 401) }
+
+    it 'raises an error' do
+      expect { perform }.to raise_error(Rpush::DeliveryError)
+    end
+  end
+
+  describe 'a 400 response' do
+    before { allow(response).to receive_messages(code: 400) }
+
+    it 'marks the notification as failed' do
+      error = Rpush::DeliveryError.new(400, notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+
+  describe 'an un-handled response' do
+    before { allow(response).to receive_messages(code: 418) }
+
+    it 'marks the notification as failed' do
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      expect(delivery).to receive(:mark_failed).with(error)
+      perform_with_rescue
+    end
+  end
+end

data/spec/unit/daemon/proc_title_spec.rb

@@ -0,0 +1,11 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::ProcTitle do
+  it 'sets the process title' do
+    Rpush.config.embedded = false
+    Rpush.config.push = false
+    allow(Rpush::Daemon::AppRunner).to receive_messages(total_dispatchers: 2, total_queued: 10)
+    expect(Process).to receive(:setproctitle).with('rpush | 10 queued | 2 dispatchers')
+    Rpush::Daemon::ProcTitle.update
+  end
+end

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

@@ -0,0 +1,159 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Pushy::Delivery do
+  let(:app) { Rpush::Pushy::App.create!(name: 'MyApp', api_key: 'my_api_key') }
+  let(:token) { 'device token' }
+  let(:data) { { message: 'some message' } }
+  let(:notification) { Rpush::Pushy::Notification.create!(app: app, registration_ids: [token], data: data) }
+  let(:batch) { instance_double('Rpush::Daemon::Batch', notification_processed: nil) }
+  let(:response) { instance_double('Net::HTTPResponse', code: response_code, header: response_header) }
+  let(:response_code) { 200 }
+  let(:response_header) { {} }
+  let(:http) { instance_double('Net::HTTP::Persistent', request: response) }
+  let(:logger) { instance_double('Rpush::Logger', error: nil, info: nil, warn: nil, internal_logger: nil) }
+  let(:now) { Time.parse('2018-01-19 00:00:00 UTC') }
+
+  before do
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Time).to receive_messages(now: now)
+  end
+
+  subject(:delivery) { described_class.new(app, http, notification, batch) }
+
+  describe '#pushy_uri' do
+    it { expect(subject.pushy_uri).to eq URI.parse('https://api.pushy.me/push?api_key=my_api_key') }
+  end
+
+  describe '#perform' do
+    shared_examples 'process notification' do
+      it 'invoke batch.notification_processed' do
+        subject.perform rescue nil
+        expect(batch).to have_received(:notification_processed)
+      end
+    end
+
+    context 'when response code is 200' do
+      let(:external_device_id) { '5a60ca7f6ad08477b5070dd3' }
+
+      before do
+        allow(batch).to receive(:mark_delivered)
+        response_body = {
+          success: true,
+          id: external_device_id
+        }
+        allow(response).to receive(:body) { response_body.to_json }
+        Rpush::Daemon.store = Rpush::Daemon::Store.const_get(Rpush.config.client.to_s.camelcase).new
+      end
+
+      it 'marks the notification as delivered' do
+        delivery.perform
+        expect(batch).to have_received(:mark_delivered).with(notification)
+      end
+
+      it { expect { delivery.perform }.to change { notification.external_device_id }.to(external_device_id) }
+
+      it 'logs than notification received an external id' do
+        delivery.perform
+        expected = "#{notification.id} received an external id=5a60ca7f6ad08477b5070dd3"
+        expect(logger).to have_received(:info).with(expected)
+      end
+
+      it_behaves_like 'process notification'
+    end
+
+    shared_examples 'retry delivery' do |response_code:|
+      let(:response_code) { response_code }
+
+      shared_examples 'logs' do |deliver_after:|
+        let(:expected_log_message) do
+          "Pushy responded with a #{response_code} error. Notification #{notification.id} " \
+          "will be retried after #{deliver_after} (retry 1)."
+        end
+
+        it 'logs that the notification will be retried' do
+          delivery.perform
+          expect(logger).to have_received(:warn).with(expected_log_message)
+        end
+      end
+
+      context 'when Retry-After header is present' do
+        let(:response_header) { { 'retry-after' => 10 } }
+
+        before do
+          allow(delivery).to receive(:mark_retryable) do
+            notification.deliver_after = now + 10.seconds
+            notification.retries += 1
+          end
+        end
+
+        it 'retry the notification' do
+          delivery.perform
+          expect(delivery).to have_received(:mark_retryable).with(notification, now + 10.seconds)
+        end
+
+        it_behaves_like 'logs', deliver_after: '2018-01-19 00:00:10'
+        it_behaves_like 'process notification'
+      end
+
+      context 'when Retry-After header is not present' do
+        before do
+          allow(delivery).to receive(:mark_retryable_exponential) do
+            notification.deliver_after = now + 2.seconds
+            notification.retries = 1
+          end
+        end
+
+        it 'retry the notification' do
+          delivery.perform
+          expect(delivery).to have_received(:mark_retryable_exponential).with(notification)
+        end
+
+        it_behaves_like 'logs', deliver_after: '2018-01-19 00:00:02'
+        it_behaves_like 'process notification'
+      end
+    end
+
+    it_behaves_like 'retry delivery', response_code: 429
+    it_behaves_like 'retry delivery', response_code: 500
+    it_behaves_like 'retry delivery', response_code: 502
+    it_behaves_like 'retry delivery', response_code: 503
+    it_behaves_like 'retry delivery', response_code: 504
+
+    context 'when delivery failed' do
+      let(:response_code) { 400 }
+      let(:fail_message) { 'No devices matched the specified condition.' }
+      before do
+        allow(response).to receive(:body) { { error: fail_message }.to_json }
+        allow(batch).to receive(:mark_failed)
+      end
+
+      it 'logs that the notifications failed' do
+        expect { delivery.perform }.to raise_error(Rpush::DeliveryError)
+        expect(logger).to have_received(:error).with("#{notification.id} failed: #{fail_message}")
+      end
+
+      it 'marks the notification as failed' do
+        expect { delivery.perform }.to raise_error(Rpush::DeliveryError)
+        expected_message = "Unable to deliver notification #{notification.id}, " \
+                           "received error 400 (#{fail_message})"
+        expect(batch).to have_received(:mark_failed).with(notification, 400, expected_message)
+      end
+
+      it_behaves_like 'process notification'
+    end
+
+    context 'when SocketError raised' do
+      before do
+        allow(http).to receive(:request) { raise SocketError }
+        allow(delivery).to receive(:mark_retryable)
+      end
+
+      it 'retry delivery after 10 seconds' do
+        expect { delivery.perform }.to raise_error(SocketError)
+        expect(delivery).to have_received(:mark_retryable).with(notification, now + 10.seconds, SocketError)
+      end
+
+      it_behaves_like 'process notification'
+    end
+  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
+    expect(error.to_s).to eq "Retryable error for 12, received error 401 (Unauthorized) - retry after 3600"
+  end
+
+  it "returns the error code" do
+    expect(error.code).to eq 401
+  end
+end

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -0,0 +1,36 @@
+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
+    expect(ServiceConfigMethodsSpec.delivery_class).to eq ServiceConfigMethodsSpec::Delivery
+  end
+
+  it 'instantiates loops' do
+    loop_class = Class.new
+    app = double
+    loop_instance = loop_class.new
+    expect(loop_class).to receive(:new).with(app).and_return(loop_instance)
+    ServiceConfigMethodsSpec.loops loop_class
+    expect(ServiceConfigMethodsSpec.loop_instances(app)).to eq [loop_instance]
+  end
+
+  it 'returns a new dispatcher' do
+    ServiceConfigMethodsSpec.dispatcher :http, an: :option
+    app = double
+    dispatcher = double
+    expect(Rpush::Daemon::Dispatcher::Http).to receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, an: :option).and_return(dispatcher)
+    expect(ServiceConfigMethodsSpec.new_dispatcher(app)).to 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