rapns 3.0.0-java

data/spec/unit/daemon/app_runner_spec.rb

@@ -0,0 +1,129 @@
+require 'unit_spec_helper'
+
+describe Rapns::Daemon::AppRunner, 'stop' do
+  let(:runner) { stub }
+  before { Rapns::Daemon::AppRunner.runners['app'] = runner }
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'stops all runners' do
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.stop
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'deliver' do
+  let(:runner) { stub }
+  let(:notification) { stub(:app_id => 1) }
+  let(:logger) { stub(:error => nil) }
+
+  before do
+    Rapns::Daemon.stub(:logger => logger)
+    Rapns::Daemon::AppRunner.runners[1] = runner
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'enqueues the notification' do
+    runner.should_receive(:enqueue).with(notification)
+    Rapns::Daemon::AppRunner.enqueue(notification)
+  end
+
+  it 'logs an error if there is no runner to deliver the notification' do
+    notification.stub(:app_id => 2, :id => 123)
+    logger.should_receive(:error).with("No such app '#{notification.app_id}' for notification #{notification.id}.")
+    Rapns::Daemon::AppRunner.enqueue(notification)
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'sync' do
+  let(:app) { Rapns::Apns::App.new }
+  let(:new_app) { Rapns::Apns::App.new }
+  let(:runner) { stub(:sync => nil, :stop => nil, :start => nil) }
+  let(:logger) { stub(:error => nil) }
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+
+  before do
+    app.stub(:id => 1)
+    new_app.stub(:id => 2)
+    Rapns::Daemon::DeliveryQueue.stub(:new => queue)
+    Rapns::Daemon::AppRunner.runners[app.id] = runner
+    Rapns::App.stub(:all => [app])
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'loads all apps' do
+    Rapns::App.should_receive(:all)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'instructs existing runners to sync' do
+    runner.should_receive(:sync).with(app)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'starts a runner for a new app' do
+    Rapns::App.stub(:all => [app, new_app])
+    new_runner = stub
+    Rapns::Daemon::Apns::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
+    new_runner.should_receive(:start)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'deletes old apps' do
+    Rapns::App.stub(:all => [])
+    runner.should_receive(:stop)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  it 'logs an error if the app could not be started' do
+    Rapns::App.stub(:all => [app, new_app])
+    new_runner = stub
+    Rapns::Daemon::Apns::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
+    new_runner.stub(:start).and_raise(StandardError)
+    Rapns::Daemon.logger.should_receive(:error).any_number_of_times
+    Rapns::Daemon::AppRunner.sync
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'debug' do
+  let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
+    :environment => 'development', :certificate => TEST_CERT) }
+  let(:logger) { stub(:info => nil) }
+
+  before do
+    Rapns::Daemon.stub(:config => {})
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => stub.as_null_object)
+    Rapns::Daemon::Apns::Connection.stub(:new => stub.as_null_object)
+    Rapns::Daemon.stub(:logger => logger)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'prints debug app states to the log' do
+    Rapns::Daemon.logger.should_receive(:info).with("\ntest:\n  handlers: 1\n  queued: 0\n  idle: true\n")
+    Rapns::Daemon::AppRunner.debug
+  end
+end
+
+describe Rapns::Daemon::AppRunner, 'idle' do
+  let!(:app) { Rapns::Apns::App.create!(:name => 'test', :connections => 1,
+    :environment => 'development', :certificate => TEST_CERT) }
+  let(:logger) { stub(:info => nil) }
+
+  before do
+    Rapns::Daemon.stub(:config => {})
+    Rapns::Daemon::Apns::FeedbackReceiver.stub(:new => stub.as_null_object)
+    Rapns::Daemon::Apns::Connection.stub(:new => stub.as_null_object)
+    Rapns::Daemon.stub(:logger => logger)
+    Rapns::Daemon::AppRunner.sync
+  end
+
+  after { Rapns::Daemon::AppRunner.runners.clear }
+
+  it 'returns idle runners' do
+    runner = Rapns::Daemon::AppRunner.runners[app.id]
+    Rapns::Daemon::AppRunner.idle.should == [runner]
+  end
+end

data/spec/unit/daemon/database_reconnectable_spec.rb

@@ -0,0 +1,109 @@
+require "unit_spec_helper"
+
+describe Rapns::Daemon::DatabaseReconnectable do
+  class TestDouble
+    include Rapns::Daemon::DatabaseReconnectable
+
+    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
+    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 = mock("Logger", :info => nil, :error => nil, :warn => nil)
+    Rapns::Daemon.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::Daemon.logger.should_receive(:error).with(error)
+    test_double.perform
+  end
+
+  it "should log that the database is being reconnected" do
+    Rapns::Daemon.logger.should_receive(:warn).with("Lost connection to database, reconnecting...")
+    test_double.perform
+  end
+
+  it "should log the reconnection attempt" do
+    Rapns::Daemon.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::Daemon.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::Daemon.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

data/spec/unit/daemon/delivery_error_spec.rb

@@ -0,0 +1,13 @@
+require "unit_spec_helper"
+
+describe Rapns::DeliveryError do
+  let(:error) { Rapns::DeliveryError.new(4, 12, "Missing payload") }
+
+  it "returns an informative message" do
+    error.to_s.should == "Unable to deliver notification 12, received error 4 (Missing payload)"
+  end
+
+  it "returns the error code" do
+    error.code.should == 4
+  end
+end

data/spec/unit/daemon/delivery_handler_shared.rb

@@ -0,0 +1,28 @@
+shared_examples_for 'an DeliveryHandler subclass' do
+  it 'logs all delivery errors' do
+    logger = stub
+    Rapns::Daemon.stub(:logger => logger)
+    error = StandardError.new
+    delivery_handler.stub(:deliver).and_raise(error)
+    Rapns::Daemon.logger.should_receive(:error).with(error)
+    delivery_handler.send(:handle_next_notification)
+  end
+
+  it "instructs the queue to wakeup the thread when told to stop" do
+    thread = stub(:join => nil)
+    Thread.stub(:new => thread)
+    queue.should_receive(:wakeup).with(thread)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+
+  describe "when being stopped" do
+    before { queue.pop }
+
+    it "does not attempt to deliver a notification when a DeliveryQueue::::WakeupError is raised" do
+      queue.stub(:pop).and_raise(Rapns::Daemon::DeliveryQueue::WakeupError)
+      delivery_handler.should_not_receive(:deliver)
+      delivery_handler.send(:handle_next_notification)
+    end
+  end
+end

data/spec/unit/daemon/delivery_queue_spec.rb

@@ -0,0 +1,29 @@
+require "unit_spec_helper"
+
+describe Rapns::Daemon::DeliveryQueue do
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+
+  it 'behaves likes a normal qeue' do
+    obj = stub
+    queue.push obj
+    queue.pop.should == obj
+  end
+
+  it 'returns false if notifications have not all been processed' do
+    queue.push stub
+    queue.notifications_processed?.should be_false
+  end
+
+  it 'returns false if the queue is empty but notifications have not all been processed' do
+    queue.push stub
+    queue.pop
+    queue.notifications_processed?.should be_false
+  end
+
+  it 'returns true if all notifications have been processed' do
+    queue.push stub
+    queue.pop
+    queue.notification_processed
+    queue.notifications_processed?.should be_true
+  end
+end

data/spec/unit/daemon/feeder_spec.rb

@@ -0,0 +1,95 @@
+require "unit_spec_helper"
+
+describe Rapns::Daemon::Feeder do
+  let(:config) { stub(:batch_size => 5000) }
+  let!(:app) { Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
+  let(:notification) { Rapns::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
+  let(:logger) { stub }
+
+  before do
+    Rapns::Daemon.stub(:logger => logger, :config => config)
+    Rapns::Daemon::Feeder.instance_variable_set("@stop", true)
+    Rapns::Daemon::AppRunner.stub(:idle => [stub(:app => app)])
+  end
+
+  def start
+    Rapns::Daemon::Feeder.start(0)
+  end
+
+  it "checks for new notifications with the ability to reconnect the database" do
+    Rapns::Daemon::Feeder.should_receive(:with_database_reconnect_and_retry)
+    start
+  end
+
+  it 'loads notifications in batches' do
+    relation = stub.as_null_object
+    relation.should_receive(:limit).with(5000)
+    Rapns::Notification.stub(:ready_for_delivery => relation)
+    start
+  end
+
+  it "enqueue the notification" do
+    notification.update_attributes!(:delivered => false)
+    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
+    start
+  end
+
+  it 'does not enqueue the notification if the app runner is still processing the previous batch' do
+    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
+    start
+  end
+
+  it "enqueues an undelivered notification without deliver_after set" do
+    notification.update_attributes!(:delivered => false, :deliver_after => nil)
+    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
+    start
+  end
+
+  it "enqueues a notification with a deliver_after time in the past" do
+    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
+    Rapns::Daemon::AppRunner.should_receive(:enqueue).with(notification)
+    start
+  end
+
+  it "does not enqueue a notification with a deliver_after time in the future" do
+    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
+    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
+    start
+  end
+
+  it "does not enqueue a previously delivered notification" do
+    notification.update_attributes!(:delivered => true, :delivered_at => Time.now)
+    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
+    start
+  end
+
+  it "does not enqueue a notification that has previously failed delivery" do
+    notification.update_attributes!(:delivered => false, :failed => true)
+    Rapns::Daemon::AppRunner.should_not_receive(:enqueue)
+    start
+  end
+
+  it "logs errors" do
+    e = StandardError.new("bork")
+    Rapns::Notification.stub(:ready_for_delivery).and_raise(e)
+    Rapns::Daemon.logger.should_receive(:error).with(e)
+    start
+  end
+
+  it "interrupts sleep when stopped" do
+    Rapns::Daemon::Feeder.should_receive(:interrupt_sleep)
+    Rapns::Daemon::Feeder.stop
+  end
+
+  it "enqueues notifications when started" do
+    Rapns::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
+    Rapns::Daemon::Feeder.stub(:loop).and_yield
+    start
+  end
+
+  it "sleeps for the given period" do
+    Rapns::Daemon::Feeder.should_receive(:interruptible_sleep).with(2)
+    Rapns::Daemon::Feeder.stub(:loop).and_yield
+    Rapns::Daemon::Feeder.start(2)
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'unit_spec_helper'
+require File.dirname(__FILE__) + '/../app_runner_shared.rb'
+
+describe Rapns::Daemon::Gcm::AppRunner do
+  it_behaves_like 'an AppRunner subclass'
+
+  let(:app_class) { Rapns::Gcm::App }
+  let(:app) { app_class.new }
+  let(:runner) { Rapns::Daemon::Gcm::AppRunner.new(app) }
+  let(:handler) { stub(:start => nil, :stop => nil, :queue= => nil) }
+  let(:logger) { stub(:info => nil) }
+
+  before do
+    Rapns::Daemon.stub(:logger => logger)
+    Rapns::Daemon::Gcm::DeliveryHandler.stub(:new => handler)
+  end
+end

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

@@ -0,0 +1,36 @@
+require "unit_spec_helper"
+require File.dirname(__FILE__) + '/../delivery_handler_shared.rb'
+
+describe Rapns::Daemon::Gcm::DeliveryHandler do
+  it_should_behave_like 'an DeliveryHandler subclass'
+
+  let(:app) { stub }
+  let(:delivery_handler) { Rapns::Daemon::Gcm::DeliveryHandler.new(app) }
+  let(:notification) { stub }
+  let(:http) { stub(:shutdown => nil)}
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+
+  before do
+    Net::HTTP::Persistent.stub(:new => http)
+    Rapns::Daemon::Gcm::Delivery.stub(:perform)
+    delivery_handler.queue = queue
+    queue.push(notification)
+  end
+
+  it 'performs delivery of an notification' do
+    Rapns::Daemon::Gcm::Delivery.should_receive(:perform).with(app, http, notification)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+
+  it 'initiates a persistent connection object' do
+    Net::HTTP::Persistent.should_receive(:new).with('rapns')
+    Rapns::Daemon::Gcm::DeliveryHandler.new(app)
+  end
+
+  it 'shuts down the http connection stopped' do
+    http.should_receive(:shutdown)
+    delivery_handler.start
+    delivery_handler.stop
+  end
+end

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

@@ -0,0 +1,236 @@
+require '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']) }
+  let(:logger) { stub(:error => nil, :info => nil, :warn => nil) }
+  let(:response) { stub(:code => 200, :header => {}) }
+  let(:http) { stub(:shutdown => nil, :request => response)}
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+
+  def perform
+    Rapns::Daemon::Gcm::Delivery.perform(app, http, notification)
+  end
+
+  before do
+    Time.stub(:now => now)
+    Rapns::Daemon.stub(:logger => logger)
+  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 => JSON.dump({ 'failure' => 0 }))
+      expect do
+        perform
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'logs that the notification was delivered' do
+      response.stub(:body => JSON.dump({ 'failure' => 0 }))
+      logger.should_receive(:info).with("[MyApp] 1 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' => 'NotRegistered' }
+      ]}
+      response.stub(:body => JSON.dump(body))
+      perform rescue Rapns::DeliveryError
+      notification.reload
+      notification.failed.should be_true
+      notification.error_code = nil
+      notification.error_description = "Weee"
+    end
+
+    describe 'all deliveries returned Unavailable or InternalServerError' do
+      let(:body) {{
+        'failure' => 2,
+        'success' => 0,
+        'results' => [
+          { 'error' => 'Unavailable' },
+          { 'error' => 'Unavailable' }
+        ]}}
+
+      before { response.stub(:body => JSON.dump(body)) }
+
+      it 'retries the notification respecting the Retry-After header' do
+        response.stub(:header => { 'retry-after' => 10 })
+        perform
+        notification.reload
+        notification.retries.should == 1
+        notification.deliver_after.should == now + 10.seconds
+      end
+
+      it 'retries the notification using exponential back-off if the Retry-After header is not present' do
+        notification.update_attribute(:retries, 8)
+        perform
+        notification.reload
+        notification.retries.should == 9
+        notification.deliver_after.should == now + 2 ** 9
+      end
+
+      it 'does not mark the notification as failed' do
+        expect do
+          perform
+          notification.reload
+        end.to_not change(notification, :failed).to(true)
+      end
+
+      it 'logs that the notification will be retried' do
+        Rapns::Daemon.logger.should_receive(:warn).with("All recipients unavailable. Notification #{notification.id} will be retired after 2012-10-14 00:00:02 (retry 1).")
+        perform
+      end
+    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 => JSON.dump(body)) }
+
+      it 'marks the original notification as failed' do
+        perform rescue Rapns::DeliveryError
+        notification.reload
+        notification.failed.should be_true
+        notification.failed_at = now
+        notification.error_code.should be_nil
+        notification.error_description.should == error_description
+      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)
+        perform rescue Rapns::DeliveryError
+        new_notification.registration_ids.should == ['id_0', 'id_2']
+        new_notification.data.should == {'one' => 1}
+        new_notification.collapse_key.should == 'thing'
+        new_notification.delay_while_idle.should be_true
+      end
+
+      it 'sets the delivery time on the new notification to respect the Retry-After header' do
+        response.stub(:header => { 'retry-after' => 10 })
+        perform rescue Rapns::DeliveryError
+        new_notification.deliver_after.should == now + 10.seconds
+      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' => 'NotRegistered' },
+          { 'error' => 'Unavailable' }
+        ]}}
+      let(:error_description) { "Failed to deliver to recipients 0, 1, 2. Errors: Unavailable, NotRegistered, Unavailable. 0, 2 will be retried as notification 2." }
+      it_should_behave_like 'an notification with some delivery failures'
+    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) { "Failed to deliver to recipients 0, 2. Errors: Unavailable, InternalServerError. 0, 2 will be retried as notification 2." }
+    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
+      logger.should_receive(:warn).with("GCM responded with an Service Unavailable Error. Notification 1 will be retired 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 })
+      expect do
+        perform
+      end.to change(notification, :deliver_after).to(now + 10)
+    end
+
+    it 'respects a HTTP-date Retry-After header' do
+      response.stub(:header => { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      expect do
+        perform
+      end.to change(notification, :deliver_after).to(Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+    end
+
+    it 'defaults to exponential back-off if the Retry-After header is not present' do
+      expect do
+        perform
+      end.to change(notification, :deliver_after).to(now + 2 ** 1)
+    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
+      Rapns::Daemon.logger.should_receive(:warn).with("GCM responded with an Internal Error. Notification #{notification.id} will be retired after #{(now + 2 ** 3).strftime("%Y-%m-%d %H:%M:%S")} (retry 3).")
+      perform
+    end
+
+    it 'sets deliver_after on the notification in accordance with the exponential back-off strategy.' do
+      expect do
+        perform
+        notification.reload
+      end.to change(notification, :deliver_after).to(now + 2 ** 3)
+    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
+      perform rescue Rapns::DeliveryError
+      notification.reload
+      notification.failed.should be_true
+      notification.failed_at.should == now
+      notification.error_code.should == 400
+      notification.error_description.should == 'GCM failed to parse the JSON request. Possibly an rapns bug, please open an issue.'
+    end
+  end
+
+  describe 'an un-handled response' do
+    before { response.stub(:code => 418) }
+
+    it 'marks the notification as failed' do
+      perform rescue Rapns::DeliveryError
+      notification.reload
+      notification.failed.should be_true
+      notification.failed_at.should == now
+      notification.error_code.should == 418
+      notification.error_description.should == "I'm a Teapot"
+    end
+  end
+end