rpush 8.0.0 → 9.0.0

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

@@ -1,108 +0,0 @@
-require 'unit_spec_helper'
-
-describe Rpush::Daemon::Apns::Delivery do
-  let(:app) { double(name: 'MyApp') }
-  let(:notification1) { double.as_null_object }
-  let(:notification2) { double.as_null_object }
-  let(:batch) { double(mark_all_failed: nil, mark_all_delivered: nil, all_processed: nil) }
-  let(:logger) { double(error: nil, info: nil) }
-  let(:connection) { double(select: false, write: nil, reconnect: nil, close: nil, connect: nil) }
-  let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, batch) }
-
-  before do
-    allow(batch).to receive(:each_notification) do |&blk|
-      [notification1, notification2].each(&blk)
-    end
-    allow(Rpush).to receive_messages(logger: logger)
-  end
-
-  it 'writes the binary batch' do
-    allow(notification1).to receive_messages(to_binary: 'binary1')
-    allow(notification2).to receive_messages(to_binary: 'binary2')
-    expect(connection).to receive(:write).with('binary1binary2')
-    delivery.perform
-  end
-
-  it 'logs the notification deliveries' do
-    allow(notification1).to receive_messages(id: 666, device_token: 'abc123')
-    allow(notification2).to receive_messages(id: 42, device_token: 'abc456')
-    expect(logger).to receive(:info).with('[MyApp] 666 sent to abc123')
-    expect(logger).to receive(:info).with('[MyApp] 42 sent to abc456')
-    delivery.perform
-  end
-
-  it 'marks all notifications as delivered' do
-    expect(delivery).to receive(:mark_batch_delivered)
-    delivery.perform
-  end
-
-  it 'notifies the batch all notifications have been processed' do
-    expect(batch).to receive(:all_processed)
-    delivery.perform
-  end
-
-  describe 'when an error is raised' do
-    it 'marks all notifications as failed' do
-      error = StandardError.new
-      allow(connection).to receive(:write).and_raise(error)
-      expect(delivery).to receive(:mark_batch_failed).with(error)
-      expect { delivery.perform }.to raise_error(error)
-    end
-  end
-
-  # describe "when delivery fails" do
-  #   before { connection.stub(select: true, read: [8, 4, 69].pack("ccN")) }
-  #
-  #   it "marks the notification as failed" do
-  #     delivery.should_receive(:mark_failed).with(4, "Unable to deliver notification 69, received error 4 (Missing payload)")
-  #     perform
-  #   end
-  #
-  #   it "logs the delivery error" do
-  #     # checking for the doublebed error doesn't work in jruby, but checking
-  #     # for the exception by class does.
-  #
-  #     # error = Rpush::DeliveryError.new(4, 12, "Missing payload")
-  #     # Rpush::DeliveryError.stub(new: error)
-  #     # expect { delivery.perform }.to raise_error(error)
-  #
-  #     expect { delivery.perform }.to raise_error(Rpush::DeliveryError)
-  #   end
-  #
-  #   it "reads 6 bytes from the socket" do
-  #     connection.should_receive(:read).with(6).and_return(nil)
-  #     perform
-  #   end
-  #
-  #   it "does not attempt to read from the socket if the socket was not selected for reading after the timeout" do
-  #     connection.stub(select: nil)
-  #     connection.should_not_receive(:read)
-  #     perform
-  #   end
-  #
-  #   it "reconnects the socket" do
-  #     connection.should_receive(:reconnect)
-  #     perform
-  #   end
-  #
-  #   it "logs that the connection is being reconnected" do
-  #     Rpush.logger.should_receive(:error).with("[MyApp] Error received, reconnecting...")
-  #     perform
-  #   end
-  #
-  #   context "when the APNs disconnects without returning an error" do
-  #     before do
-  #       connection.stub(read: nil)
-  #     end
-  #
-  #     it 'raises a DisconnectError error if the connection is closed without an error being returned' do
-  #       expect { delivery.perform }.to raise_error(Rpush::DisconnectionError)
-  #     end
-  #
-  #     it 'marks the notification as failed' do
-  #       delivery.should_receive(:mark_failed).with(nil, "The APNs disconnected without returning an error. This may indicate you are using an invalid certificate for the host.")
-  #       perform
-  #     end
-  #   end
-  # end
-end

data/spec/unit/daemon/apns/feedback_receiver_spec.rb

@@ -1,137 +0,0 @@
-require 'unit_spec_helper'
-require 'rpush/daemon/store/active_record'
-
-describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
-  let(:host) { 'feedback.push.apple.com' }
-  let(:port) { 2196 }
-  let(:frequency) { 60 }
-  let(:certificate) { double }
-  let(:password) { double }
-  let(:feedback_enabled) { true }
-  let(:app) do
-    double(
-      name: 'my_app',
-      password: password,
-      certificate: certificate,
-      feedback_enabled: feedback_enabled,
-      environment: 'production'
-    )
-  end
-  let(:connection) { double(connect: nil, read: nil, close: nil) }
-  let(:logger) { double(error: nil, info: nil) }
-  let(:receiver) { Rpush::Daemon::Apns::FeedbackReceiver.new(app) }
-  let(:feedback) { double }
-  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, sleep: nil, stop: nil) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, create_apns_feedback: feedback, release_connection: nil) }
-
-  before do
-    Rpush.config.apns.feedback_receiver.frequency = frequency
-    allow(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
-    allow(Rpush).to receive_messages(logger: logger)
-    allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection)
-    receiver.instance_variable_set("@stop", false)
-    allow(Rpush::Daemon).to receive_messages(store: store)
-  end
-
-  def double_connection_read_with_tuple
-    def connection.read(*)
-      unless @called
-        @called = true
-        "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
-      end
-    end
-  end
-
-  it 'initializes the sleeper with the feedback polling frequency' do
-    expect(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
-    Rpush::Daemon::Apns::FeedbackReceiver.new(app)
-  end
-
-  it 'instantiates a new connection' do
-    expect(Rpush::Daemon::TcpConnection).to receive(:new).with(app, host, port)
-    receiver.check_for_feedback
-  end
-
-  it 'connects to the feeback service' do
-    expect(connection).to receive(:connect)
-    receiver.check_for_feedback
-  end
-
-  it 'closes the connection' do
-    expect(connection).to receive(:close)
-    receiver.check_for_feedback
-  end
-
-  it 'reads from the connection' do
-    expect(connection).to receive(:read).with(38)
-    receiver.check_for_feedback
-  end
-
-  it 'logs the feedback' do
-    double_connection_read_with_tuple
-    expect(Rpush.logger).to receive(:info).with("[my_app] [FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17.")
-    receiver.check_for_feedback
-  end
-
-  it 'creates the feedback' do
-    expect(Rpush::Daemon.store).to receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
-    double_connection_read_with_tuple
-    receiver.check_for_feedback
-  end
-
-  it 'logs errors' do
-    error = StandardError.new('bork!')
-    allow(connection).to receive(:read).and_raise(error)
-    expect(Rpush.logger).to receive(:error).with(error)
-    receiver.check_for_feedback
-  end
-
-  describe 'start' do
-    before do
-      allow(Thread).to receive(:new).and_yield
-      allow(receiver).to receive(:loop).and_yield
-    end
-
-    it 'sleeps' do
-      allow(receiver).to receive(:check_for_feedback)
-      expect(sleeper).to receive(:sleep).at_least(:once)
-      receiver.start
-    end
-
-    it 'checks for feedback when started' do
-      expect(receiver).to receive(:check_for_feedback).at_least(:once)
-      receiver.start
-    end
-
-    context 'with feedback_enabled false' do
-      let(:feedback_enabled) { false }
-
-      it 'does not check for feedback when started' do
-        expect(receiver).not_to receive(:check_for_feedback)
-        receiver.start
-      end
-    end
-  end
-
-  describe 'stop' do
-    it 'interrupts sleep when stopped' do
-      allow(receiver).to receive(:check_for_feedback)
-      expect(sleeper).to receive(:stop)
-      receiver.stop
-    end
-
-    it 'releases the store connection' do
-      allow(Thread).to receive(:new).and_yield
-      allow(receiver).to receive(:loop).and_yield
-      expect(Rpush::Daemon.store).to receive(:release_connection)
-      receiver.start
-      receiver.stop
-    end
-  end
-
-  it 'reflects feedback was received' do
-    double_connection_read_with_tuple
-    expect(receiver).to receive(:reflect).with(:apns_feedback, feedback)
-    receiver.check_for_feedback
-  end
-end

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

@@ -1,32 +0,0 @@
-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 { [host, port] } }
-  let(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
-  let(:dispatcher) { Rpush::Daemon::Dispatcher::Tcp.new(app, delivery_class, host: host_proc) }
-
-  before { allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection) }
-
-  describe 'dispatch' do
-    it 'delivers the notification' do
-      expect(delivery_class).to receive(:new).with(app, connection, notification, batch).and_return(delivery)
-      expect(delivery).to receive(:perform)
-      dispatcher.dispatch(queue_payload)
-    end
-  end
-
-  describe 'cleanup' do
-    it 'closes the connection' do
-      expect(connection).to receive(:close)
-      dispatcher.cleanup
-    end
-  end
-end

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

@@ -1,387 +0,0 @@
-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(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