rpush 1.0.0 → 2.0.0.beta1

data/spec/unit/daemon/delivery_spec.rb

@@ -16,7 +16,6 @@ describe Rpush::Daemon::Delivery do
   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
@@ -35,4 +34,19 @@ describe Rpush::Daemon::Delivery do
       delivery.mark_retryable(notification, Time.now + 1.hour)
     end
   end
+
+  describe 'mark_batch_delivered' do
+    it 'marks all notifications as delivered' do
+      batch.should_receive(:mark_all_delivered)
+      delivery.mark_batch_delivered
+    end
+  end
+
+  describe 'mark_batch_failed' do
+    it 'marks all notifications as delivered' do
+      error = Rpush::DeliveryError.new(1, 42, 'an error')
+      batch.should_receive(:mark_all_failed).with(1, 'Unable to deliver notification 42, received error 1 (an error)')
+      delivery.mark_batch_failed(error)
+    end
+  end
 end

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

@@ -6,9 +6,10 @@ describe Rpush::Daemon::Dispatcher::Http do
   let(:notification) { double }
   let(:batch) { double }
   let(:http) { double }
+  let(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
   let(:dispatcher) { Rpush::Daemon::Dispatcher::Http.new(app, delivery_class) }
 
-  before { Net::HTTP::Persistent.stub(:new => http) }
+  before { Net::HTTP::Persistent.stub(new: http) }
 
   it 'constructs a new persistent connection' do
     Net::HTTP::Persistent.should_receive(:new)
@@ -20,7 +21,7 @@ describe Rpush::Daemon::Dispatcher::Http do
       delivery = double
       delivery_class.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
       delivery.should_receive(:perform)
-      dispatcher.dispatch(notification, batch)
+      dispatcher.dispatch(queue_payload)
     end
   end
 

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

@@ -2,35 +2,36 @@ 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(: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(: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) }
+  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 { Rpush::Daemon::TcpConnection.stub(:new => connection) }
+  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)
+      dispatcher.dispatch(queue_payload)
     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)
+      dispatcher.dispatch(queue_payload)
     end
   end
 
   describe 'cleanup' do
     it 'closes the connection' do
-      dispatcher.dispatch(notification, batch) # lazily initialize connection
+      dispatcher.dispatch(queue_payload) # lazily initialize connection
       connection.should_receive(:close)
       dispatcher.cleanup
     end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -9,20 +9,20 @@ describe Rpush::Daemon::DispatcherLoop do
   end
 
   let(:notification) { double }
-  let(:batch) { double(:notification_dispatched => nil) }
+  let(:batch) { double(notification_processed: nil) }
   let(:queue) { Queue.new }
-  let(:dispatcher) { double(:dispatch => nil, :cleanup => nil) }
+  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)}
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
-    Rpush::Daemon.stub(:store => store)
+    Rpush::Daemon.stub(store: store)
     queue.push([notification, batch])
   end
 
   it 'logs errors' do
     logger = double
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
     error = StandardError.new
     dispatcher.stub(:dispatch).and_raise(error)
     Rpush.logger.should_receive(:error).with(error)
@@ -30,19 +30,14 @@ describe Rpush::Daemon::DispatcherLoop do
   end
 
   it 'reflects an exception' do
-    Rpush.stub(:logger => double(:error => nil))
+    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
+  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

data/spec/unit/daemon/feeder_spec.rb

@@ -1,25 +1,25 @@
 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!(: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) }
+  let(:interruptible_sleeper) { double(sleep: nil, stop: nil, start: nil) }
+  let(:store) do double(Rpush::Daemon::Store::ActiveRecord,
+                        deliverable_notifications: [notification], release_connection: nil)
+  end
 
   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)
+    Rpush.configure do |config|
+      config.batch_size = 5000
+      config.push_poll = 0
+      config.push = false
+    end
+
+    Rpush.stub(logger: logger)
+    Rpush::Daemon.stub(store: store)
+    Rpush::Daemon::Feeder.stub(should_stop: true, interruptible_sleeper: interruptible_sleeper)
+    Rpush::Daemon::AppRunner.stub(enqueue: nil, num_queued: 0)
   end
 
   def start_and_stop
@@ -27,26 +27,26 @@ describe Rpush::Daemon::Feeder do
     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)
+  it 'loads deliverable notifications' do
+    Rpush::Daemon.store.should_receive(:deliverable_notifications).with(Rpush.config.batch_size)
     start_and_stop
   end
 
-  it 'loads deliverable notifications' do
-    Rpush::Daemon.store.should_receive(:deliverable_notifications).with([app])
+  it 'does not load more notifications if the total queue size is equal to the batch size' do
+    Rpush::Daemon::AppRunner.stub(num_queued: Rpush.config.batch_size)
+    Rpush::Daemon.store.should_not_receive(:deliverable_notifications)
     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)
+  it 'limits the batch size if some runners are still processing notifications' do
+    Rpush.config.stub(batch_size: 10)
+    Rpush::Daemon::AppRunner.stub(num_queued: 6)
+    Rpush::Daemon.store.should_receive(:deliverable_notifications).with(4)
     start_and_stop
   end
 
   it 'enqueues notifications without looping if in push mode' do
-    config.stub(:push => true)
+    Rpush.config.push = true
     Rpush::Daemon::Feeder.should_not_receive(:feed_forever)
     Rpush::Daemon::Feeder.should_receive(:enqueue_notifications)
     start_and_stop
@@ -65,34 +65,35 @@ describe Rpush::Daemon::Feeder do
   end
 
   describe 'stop' do
-    it 'interrupts sleep when stopped' do
-      Rpush::Daemon::Feeder.should_receive(:interrupt_sleep)
+    it 'interrupts sleep' do
+      interruptible_sleeper.should_receive(:stop)
       start_and_stop
     end
 
-    it 'releases the store connection when stopped' do
+    it 'releases the store connection' do
       Rpush::Daemon.store.should_receive(:release_connection)
       start_and_stop
     end
   end
 
-  it "enqueues notifications when started" do
+  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)
+  it 'sleeps' do
+    interruptible_sleeper.should_receive(:sleep)
     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
+  describe 'wakeup' do
+    it 'interrupts sleep' do
+      interruptible_sleeper.should_receive(:wakeup)
+      Rpush::Daemon::Feeder.start
+      Rpush::Daemon::Feeder.wakeup
+    end
+
+    after { Rpush::Daemon::Feeder.stop }
   end
 end

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

@@ -1,44 +1,51 @@
 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(: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) }
+  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)) }
+  let(:store) { double(create_gcm_notification: double(id: 2)) }
 
   def perform
     delivery.perform
   end
 
+  def perform_with_rescue
+    expect { perform }.to raise_error
+  end
+
   before do
-    delivery.stub(:reflect => nil)
-    Rpush::Daemon.stub(:store => store)
-    Time.stub(:now => now)
-    Rpush.stub(:logger => logger)
+    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)) }
+    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
+      # error = Rpush::DeliveryError.new(nil, notification.id, error_description)
+      delivery.should_receive(:mark_failed) do |error|
+        error.to_s.should =~ error_description
+      end
+      perform_with_rescue
     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 })
+      notification.update_attributes(registration_ids: %w(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
+                                                          %w(id_0 id_2), now + 10.seconds, notification.app)
+      perform_with_rescue
     end
 
     it 'raises a DeliveryError' do
@@ -48,7 +55,7 @@ describe Rpush::Daemon::Gcm::Delivery do
 
   describe 'a 200 response' do
     before do
-      response.stub(:code => 200)
+      response.stub(code: 200)
     end
 
     it 'reflects on any IDs which successfully received the notification' do
@@ -61,11 +68,11 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      response.stub(:body => JSON.dump(body))
-      notification.stub(:registration_ids => ['1', '2'])
+      response.stub(body: JSON.dump(body))
+      notification.stub(registration_ids: %w(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
+      perform_with_rescue
     end
 
     it 'reflects on any IDs which failed to receive the notification' do
@@ -78,11 +85,11 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      response.stub(:body => JSON.dump(body))
-      notification.stub(:registration_ids => ['1', '2'])
+      response.stub(body: JSON.dump(body))
+      notification.stub(registration_ids: %w(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
+      perform_with_rescue
     end
 
     it 'reflects on canonical IDs' do
@@ -93,40 +100,43 @@ describe Rpush::Daemon::Gcm::Delivery do
         'results' => [
           { 'message_id' => '1:000' },
           { 'message_id' => '1:000', 'registration_id' => 'canonical123' },
-          { 'message_id' => '1:000' },
-        ]}
+          { 'message_id' => '1:000' }
+        ] }
 
-      response.stub(:body => JSON.dump(body))
-      notification.stub(:registration_ids => ['1', '2', '3'])
+      response.stub(body: JSON.dump(body))
+      notification.stub(registration_ids: %w(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' },
-          ]}
+        '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'])
+      response.stub(body: JSON.dump(body))
+      notification.stub(registration_ids: %w(1 2 3))
       delivery.should_receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
-      perform rescue Rpush::DeliveryError
+      perform_with_rescue
     end
 
     describe 'when delivered successfully to all devices' do
-      let(:body) {{
-        'failure' => 0,
-        'success' => 1,
-        'results' => [{ 'message_id' => '1:000'}]
-      }}
+      let(:body) do
+        {
+          'failure' => 0,
+          'success' => 1,
+          'results' => [{ 'message_id' => '1:000' }]
+        }
+      end
 
-      before { response.stub(:body => JSON.dump(body)) }
+      before { response.stub(body: JSON.dump(body)) }
 
       it 'marks the notification as delivered' do
         delivery.should_receive(:mark_delivered)
@@ -141,20 +151,21 @@ describe Rpush::Daemon::Gcm::Delivery do
 
     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' },
-          ]}
+        'failure' => 1,
+        'success' => 2,
+        'canonical_ids' => 0,
+        'results' => [
+          { 'message_id' => '1:000' },
+          { 'error' => 'NotRegistered' },
+          { 'message_id' => '1:000' }
+        ]
+      }
 
-      response.stub(:body => JSON.dump(body))
+      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
+      perform_with_rescue
     end
 
     it 'marks a notification as failed if any deliveries failed that cannot be retried' do
@@ -164,28 +175,32 @@ describe Rpush::Daemon::Gcm::Delivery do
         '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
+        ] }
+      response.stub(body: JSON.dump(body))
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients. Errors: InvalidDataKey.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
 
     describe 'all deliveries failed with Unavailable or InternalServerError' do
-      let(:body) {{
-        'failure' => 2,
-        'success' => 0,
-        'results' => [
-          { 'error' => 'Unavailable' },
-          { 'error' => 'Unavailable' }
-        ]}}
+      let(:body) do
+        {
+          'failure' => 2,
+          'success' => 0,
+          'results' => [
+            { 'error' => 'Unavailable' },
+            { 'error' => 'Unavailable' }
+          ]
+        }
+      end
 
       before do
-        response.stub(:body => JSON.dump(body))
-        notification.stub(:registration_ids => ['1', '2'])
+        response.stub(body: JSON.dump(body))
+        notification.stub(registration_ids: %w(1 2))
       end
 
       it 'retries the notification respecting the Retry-After header' do
-        response.stub(:header => { 'retry-after' => 10 })
+        response.stub(header: { 'retry-after' => 10 })
         delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
         perform
       end
@@ -209,34 +224,36 @@ describe Rpush::Daemon::Gcm::Delivery do
     end
 
     describe 'all deliveries failed with some as Unavailable or InternalServerError' do
-      let(:body) {{
+      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) {{
+      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 { response.stub(:code => 503) }
+    before { response.stub(code: 503) }
 
     it 'logs a warning that the notification will be retried.' do
       notification.retries = 1
@@ -246,19 +263,19 @@ describe Rpush::Daemon::Gcm::Delivery do
     end
 
     it 'respects an integer Retry-After header' do
-      response.stub(:header => { 'retry-after' => 10 })
+      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' })
+      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)
+      delivery.should_receive(:mark_retryable).with(notification, now + 2**1)
       perform
     end
   end
@@ -266,24 +283,24 @@ describe Rpush::Daemon::Gcm::Delivery do
   describe 'a 500 response' do
     before do
       notification.update_attribute(:retries, 2)
-      response.stub(:code => 500)
+      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).")
+      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)
+      delivery.should_receive(:mark_retryable).with(notification, now + 2**3)
       perform
     end
   end
 
   describe 'a 401 response' do
-    before { response.stub(:code => 401) }
+    before { response.stub(code: 401) }
 
     it 'raises an error' do
       expect { perform }.to raise_error(Rpush::DeliveryError)
@@ -291,20 +308,22 @@ describe Rpush::Daemon::Gcm::Delivery do
   end
 
   describe 'a 400 response' do
-    before { response.stub(:code => 400) }
+    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
+      error = Rpush::DeliveryError.new(400, notification.id, 'GCM failed to parse the JSON request. Possibly an Rpush bug, please open an issue.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe 'an un-handled response' do
-    before { response.stub(:code => 418) }
+    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
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 end