rpush 1.0.0 → 2.0.0.beta1

data/spec/unit/client/active_record/app_spec.rb

@@ -0,0 +1,30 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::App do
+  it 'validates the uniqueness of name within type and environment' do
+    Rpush::Client::ActiveRecord::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT)
+    app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'production', certificate: TEST_CERT)
+    app.valid?.should be_false
+    app.errors[:name].should eq ['has already been taken']
+
+    app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: TEST_CERT)
+    app.valid?.should be_true
+
+    app = Rpush::Client::ActiveRecord::Gcm::App.new(name: 'test', environment: 'production', auth_key: TEST_CERT)
+    app.valid?.should be_true
+  end
+
+  context 'validating certificates' do
+    it 'rescues from certificate error' do
+      app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      expect { app.valid? }.not_to raise_error
+      expect(app.valid?).to be_false
+    end
+
+    it 'raises other errors' do
+      app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      OpenSSL::X509::Certificate.stub(:new).and_raise(NameError, 'simulating no openssl')
+      expect { app.valid? }.to raise_error(NameError)
+    end
+  end
+end

data/spec/unit/client/active_record/gcm/app_spec.rb

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Gcm::App do
+end

data/spec/unit/{gcm → client/active_record/gcm}/notification_spec.rb

@@ -1,23 +1,21 @@
 require 'unit_spec_helper'
 require 'unit/notification_shared.rb'
 
-describe Rpush::Gcm::Notification do
+describe Rpush::Client::ActiveRecord::Gcm::Notification do
   it_should_behave_like 'an Notification subclass'
 
-  let(:app) { Rpush::Gcm::App.create!(:name => 'test', :auth_key => 'abc') }
-  let(:notification_class) { Rpush::Gcm::Notification }
+  let(:app) { Rpush::Client::ActiveRecord::Gcm::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification_class) { Rpush::Client::ActiveRecord::Gcm::Notification }
   let(:notification) { notification_class.new }
-  let(:data_setter) { 'data=' }
-  let(:data_getter) { 'data' }
 
   it "has a 'data' payload limit of 4096 bytes" do
-    notification.data = { :key => "a" * 4096 }
+    notification.data = { key: "a" * 4096 }
     notification.valid?.should be_false
     notification.errors[:base].should eq ["Notification payload data cannot be larger than 4096 bytes."]
   end
 
   it 'limits the number of registration ids to 1000' do
-    notification.registration_ids = ['a']*(1000+1)
+    notification.registration_ids = ['a'] * (1000 + 1)
     notification.valid?.should be_false
     notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 1000."]
   end

data/spec/unit/client/active_record/notification_spec.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Notification do
+  let(:notification) { Rpush::Client::ActiveRecord::Notification.new }
+
+  it 'allows assignment of many registration IDs' do
+    notification.registration_ids = %w(a b)
+    notification.registration_ids.should eq %w(a b)
+  end
+
+  it 'allows assignment of a single registration ID' do
+    notification.registration_ids = 'a'
+    notification.registration_ids.should eq ['a']
+  end
+end

data/spec/unit/client/active_record/wpns/app_spec.rb

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Wpns::App do
+end

data/spec/unit/client/active_record/wpns/notification_spec.rb

@@ -0,0 +1,21 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rpush::Client::ActiveRecord::Wpns::Notification do
+  it_should_behave_like 'an Notification subclass'
+  let(:app) { Rpush::Client::ActiveRecord::Wpns::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification_class) { Rpush::Client::ActiveRecord::Wpns::Notification }
+  let(:notification) { notification_class.new }
+
+  it "should have an url in the uri parameter" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(uri: "somthing")
+    notification.valid?
+    notification.errors[:uri].include?("is invalid").should be_true
+  end
+
+  it "should be invalid if there's no message" do
+    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(alert: "")
+    notification.valid?
+    notification.errors[:alert].include?("can't be blank").should be_true
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -1,11 +1,14 @@
 require 'unit_spec_helper'
 
 describe Rpush do
-  let(:config) { double }
+  let(:config) { Rpush.config }
 
-  before { Rpush.stub(:config => config) }
+  before do
+    Rpush.stub(require: nil)
+    Rpush.stub(config: config)
+  end
 
-  it 'can yields a config block' do
+  it 'yields a configure block' do
     expect { |b| Rpush.configure(&b) }.to yield_with_args(config)
   end
 end
@@ -26,9 +29,8 @@ describe Rpush::Configuration do
   end
 
   it 'sets the pid_file relative if not absolute' do
-    Rails.stub(:root => '/rails')
     config.pid_file = 'tmp/rpush.pid'
-    config.pid_file.should eq '/rails/tmp/rpush.pid'
+    config.pid_file.should eq '/tmp/rails_root/tmp/rpush.pid'
   end
 
   it 'does not alter an absolute pid_file path' do
@@ -42,4 +44,9 @@ describe Rpush::Configuration do
     config.foreground = false
     config.foreground.should be_true
   end
+
+  it 'delegate redis_options to Modis' do
+    Rpush.config.redis_options = { hi: :mom }
+    Modis.redis_options.should eq(hi: :mom)
+  end
 end

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

@@ -1,15 +1,15 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Adm::Delivery do
-  let(:app) { Rpush::Adm::App.new(:name => 'MyApp', :client_id => 'CLIENT_ID', :client_secret => 'CLIENT_SECRET') }
-  let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['xyz'], :deliver_after => Time.now, :data => {'message' => 'test'}) }
-  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::Adm::App.create!(name: 'MyApp', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
+  let(:notification) { Rpush::Adm::Notification.create!(app: app, registration_ids: ['xyz'], deliver_after: Time.now, data: { 'message' => 'test' }) }
+  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::Adm::Delivery.new(app, http, notification, batch) }
-  let(:store) { double(:create_adm_notification => double(:id => 2)) }
+  let(:store) { double(create_adm_notification: double(id: 2)) }
 
   def perform
     delivery.perform
@@ -19,44 +19,45 @@ describe Rpush::Daemon::Adm::Delivery do
     app.access_token = 'ACCESS_TOKEN'
     app.access_token_expiration = Time.now + 1.month
 
-    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
 
   describe 'unknown error response' do
     before do
-      response.stub(:code => 408)
+      response.stub(code: 408)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
-      response.stub(:body => JSON.dump({ 'reason' => 'InvalidData' }))
-      delivery.should_receive(:mark_failed).with(408, 'Request Timeout')
+      response.stub(body: JSON.dump('reason' => 'InvalidData'))
+      error = Rpush::DeliveryError.new(408, notification.id, 'Request Timeout')
+      delivery.should_receive(:mark_failed).with(error)
       expect { perform }.to raise_error(Rpush::DeliveryError)
     end
   end
 
   describe 'a 200 (Ok) response' do
     before do
-      response.stub(:code => 200)
+      response.stub(code: 200)
     end
 
     it 'marks the notification as delivered if delivered successfully to all devices' do
-      response.stub(:body => JSON.dump({ 'registrationID' => 'xyz' }))
+      response.stub(body: JSON.dump('registrationID' => 'xyz'))
       delivery.should_receive(:mark_delivered)
       perform
     end
 
     it 'logs that the notification was delivered' do
-      response.stub(:body => JSON.dump({ 'registrationID' => 'xyz' }))
+      response.stub(body: JSON.dump('registrationID' => 'xyz'))
       logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
       perform
     end
 
     it 'reflects on canonical IDs' do
-      response.stub(:body => JSON.dump({'registrationID' => 'canonical123' }))
-      notification.stub(:registration_ids => ['1'])
+      response.stub(body: JSON.dump('registrationID' => 'canonical123'))
+      notification.stub(registration_ids: ['1'])
       delivery.should_receive(:reflect).with(:adm_canonical_id, '1', 'canonical123')
       perform
     end
@@ -64,31 +65,32 @@ describe Rpush::Daemon::Adm::Delivery do
 
   describe 'a 400 (Bad Request) response' do
     before do
-      response.stub(:code => 400)
+      response.stub(code: 400)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
-      response.stub(:body => JSON.dump({ 'reason' => 'InvalidData' }))
-      delivery.should_receive(:mark_failed).with(nil, 'Failed to deliver to all recipients.')
-      expect { perform }.to raise_error(Rpush::DeliveryError)
+      response.stub(body: JSON.dump('reason' => 'InvalidData'))
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
+      delivery.should_receive(:mark_failed).with(error)
+      expect { perform }.to raise_error(error)
     end
 
     it 'logs that the notification was not delivered' do
-      response.stub(:body => JSON.dump({ 'reason' => 'InvalidRegistrationId' }))
+      response.stub(body: JSON.dump('reason' => 'InvalidRegistrationId'))
       logger.should_receive(:warn).with("[MyApp] bad_request: xyz (InvalidRegistrationId)")
-      expect { perform }.to raise_error(Rpush::DeliveryError)
+      expect { perform }.to raise_error
     end
   end
 
   describe 'a 401 (Unauthorized) response' do
-    let(:http) { double(:shutdown => nil)}
-    let(:token_response) { double(:code => 200, :header => {}, :body => JSON.dump({'access_token' => 'ACCESS_TOKEN', 'expires_in' => 60})) }
+    let(:http) { double(shutdown: nil) }
+    let(:token_response) { double(code: 200, header: {}, body: JSON.dump('access_token' => 'ACCESS_TOKEN', 'expires_in' => 60)) }
 
     before do
-      response.stub(:code => 401, :header => { 'retry-after' => 10 })
+      response.stub(code: 401, header: { 'retry-after' => 10 })
 
       # first request to deliver message that returns unauthorized response
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
     end
 
@@ -116,7 +118,7 @@ describe Rpush::Daemon::Adm::Delivery do
     end
 
     it 'should log the error and stop retrying if new access token can\'t be retrieved' do
-      token_response.stub(:code => 404, :body => "test")
+      token_response.stub(code: 404, body: "test")
       # request for access token
       http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
 
@@ -130,15 +132,15 @@ describe Rpush::Daemon::Adm::Delivery do
   end
 
   describe 'a 429 (Too Many Request) response' do
-    let(:http) { double(:shutdown => nil) }
-    let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['abc','xyz'], :deliver_after => Time.now, :collapse_key => 'sync', :data => {'message' => 'test'}) }
-    let(:too_many_request_response) { double(:code => 429, :header => { 'retry-after' => 3600 }) }
+    let(:http) { double(shutdown: nil) }
+    let(:notification) { Rpush::Adm::Notification.create!(app: app, registration_ids: %w(abc xyz), deliver_after: Time.now, collapse_key: 'sync', data: { 'message' => 'test' }) }
+    let(:too_many_request_response) { double(code: 429, header: { 'retry-after' => 3600 }) }
 
     it 'should retry the entire notification respecting the Retry-After header if none sent out yet' do
-      response.stub(:code => 429, :header => { 'retry-after' => 3600 })
+      response.stub(code: 429, header: { 'retry-after' => 3600 })
 
       # first request to deliver message that returns too many request response
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
       delivery.should_receive(:mark_retryable).with(notification, now + 1.hour)
@@ -146,25 +148,25 @@ describe Rpush::Daemon::Adm::Delivery do
     end
 
     it 'should retry the entire notification using exponential backoff' do
-      response.stub(:code => 429, :header => {})
+      response.stub(code: 429, header: {})
 
       # first request to deliver message that returns too many request response
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % [notification.registration_ids.first])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
-      delivery.should_receive(:mark_retryable).with(notification, Time.now + 2 ** (notification.retries + 1))
+      delivery.should_receive(:mark_retryable).with(notification, Time.now + 2**(notification.retries + 1))
       perform
     end
 
     it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
-      response.stub(:code => 200, :body => JSON.dump({ 'registrationID' => 'abc' }))
+      response.stub(code: 200, body: JSON.dump('registrationID' => 'abc'))
 
       # first request to deliver message succeeds
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['abc'])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
       # first request to deliver message that returns too many request response
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['xyz'])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(too_many_request_response)
 
       store.should_receive(:update_notification).with do |notif|
@@ -172,10 +174,10 @@ describe Rpush::Daemon::Adm::Delivery do
         notif.registration_ids.include?('xyz').should be_false
       end
 
-      store.should_receive(:create_adm_notification).with do |attrs, notification_data, reg_ids, deliver_after, notification_app|
-        attrs.has_key?('collapse_key').should be_true
-        attrs.has_key?('delay_while_idle').should be_true
-        attrs.has_key?('app_id').should be_true
+      store.should_receive(:create_adm_notification).with do |attrs, _notification_data, reg_ids, deliver_after, notification_app|
+        attrs.key?('collapse_key').should be_true
+        attrs.key?('delay_while_idle').should be_true
+        attrs.key?('app_id').should be_true
 
         reg_ids.should eq ['xyz']
         deliver_after.should eq now + 1.hour
@@ -190,11 +192,12 @@ describe Rpush::Daemon::Adm::Delivery do
 
   describe 'a 500 (Internal Server Error) response' do
     before do
-      response.stub(:code => 500)
+      response.stub(code: 500)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
-      delivery.should_receive(:mark_failed).with(nil, 'Failed to deliver to all recipients.')
+      error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
+      delivery.should_receive(:mark_failed).with(error)
       expect { perform }.to raise_error(Rpush::DeliveryError)
     end
 
@@ -206,7 +209,7 @@ describe Rpush::Daemon::Adm::Delivery do
 
   describe 'a 503 (Service Unavailable) response' do
     before do
-      response.stub(:code => 503, :header => { 'retry-after' => 10 })
+      response.stub(code: 503, header: { 'retry-after' => 10 })
     end
 
     it 'should retry the notification respecting the Retry-After header' do
@@ -216,19 +219,19 @@ describe Rpush::Daemon::Adm::Delivery do
   end
 
   describe 'some registration ids succeeding and some failing' do
-    let(:http) { double(:shutdown => nil) }
-    let(:notification) { Rpush::Adm::Notification.create!(:app => app, :registration_ids => ['abc','xyz'], :deliver_after => Time.now, :collapse_key => 'sync', :data => {'message' => 'test'}) }
-    let(:bad_request_response) { double(:code => 400, :body => JSON.dump({ 'reason' => 'InvalidData' })) }
+    let(:http) { double(shutdown: nil) }
+    let(:notification) { Rpush::Adm::Notification.create!(app: app, registration_ids: %w(abc xyz), deliver_after: Time.now, collapse_key: 'sync', data: { 'message' => 'test' }) }
+    let(:bad_request_response) { double(code: 400, body: JSON.dump('reason' => 'InvalidData')) }
 
     it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
-      response.stub(:code => 200, :body => JSON.dump({ 'registrationID' => 'abc' }))
+      response.stub(code: 200, body: JSON.dump('registrationID' => 'abc'))
 
       # first request to deliver message succeeds
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['abc'])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
       # first request to deliver message that returns too many request response
-      adm_uri = URI.parse(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL % ['xyz'])
+      adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
       http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(bad_request_response)
 
       store.should_receive(:update_notification).with do |notif|

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

@@ -1,8 +1,8 @@
 require 'unit_spec_helper'
 
-describe Rpush::Apns::CertificateExpiredError do
-  let(:app) { double(:name => 'test') }
-  let(:error) { Rpush::Apns::CertificateExpiredError.new(app, Time.now) }
+describe Rpush::CertificateExpiredError do
+  let(:app) { double(name: 'test') }
+  let(:error) { Rpush::CertificateExpiredError.new(app, Time.now) }
 
   it 'returns a message' do
     error.message

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

@@ -1,101 +1,108 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Apns::Delivery do
-  let(:app) { double(:name => 'MyApp') }
-  let(:notification) { double.as_null_object }
-  let(:batch) { double(:mark_failed => nil, :mark_delivered => nil) }
-  let(:logger) { double(:error => nil, :info => nil) }
-  let(:config) { double(:check_for_errors => true) }
-  let(:connection) { double(:select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
-  let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, notification, batch) }
-
-  def perform
-    begin
-      delivery.perform
-    rescue Rpush::DeliveryError, Rpush::Apns::DisconnectionError
-    end
-  end
+  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
-    Rpush.stub(:config => config, :logger => logger)
+    batch.stub(:each_notification) do |&blk|
+      [notification1, notification2].each(&blk)
+    end
+    Rpush.stub(logger: logger)
   end
 
-  it "sends the binary version of the notification" do
-    notification.stub(:to_binary => "hi mom")
-    connection.should_receive(:write).with("hi mom")
-    perform
+  it 'writes the binary batch' do
+    notification1.stub(to_binary: 'binary1')
+    notification2.stub(to_binary: 'binary2')
+    connection.should_receive(:write).with('binary1binary2')
+    delivery.perform
   end
 
-  it "logs the notification delivery" do
-    notification.stub(:id => 666, :device_token => 'abc123')
-    logger.should_receive(:info).with("[MyApp] 666 sent to abc123")
-    perform
+  it 'logs the notification deliveries' do
+    notification1.stub(id: 666, device_token: 'abc123')
+    notification2.stub(id: 42, device_token: 'abc456')
+    logger.should_receive(:info).with('[MyApp] 666 sent to abc123')
+    logger.should_receive(:info).with('[MyApp] 42 sent to abc456')
+    delivery.perform
   end
 
-  it "marks the notification as delivered" do
-    delivery.should_receive(:mark_delivered)
-    perform
+  it 'marks all notifications as delivered' do
+    delivery.should_receive(:mark_batch_delivered)
+    delivery.perform
   end
 
-  it 'does not check for errors if check_for_errors config option is false' do
-    config.stub(:check_for_errors => false)
-    delivery.should_not_receive(:check_for_error)
-    perform
+  it 'notifies the batch all notifications have been processed' do
+    batch.should_receive(:all_processed)
+    delivery.perform
   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, "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::Apns::DisconnectionError)
-      end
-
-      it 'marks the notification as failed' do
-        delivery.should_receive(:mark_failed).with(nil, "APNs disconnected without returning an error.")
-        perform
-      end
+  describe 'when an error is raised' do
+    it 'marks all notifications as failed' do
+      error = StandardError.new
+      connection.stub(:write).and_raise(error)
+      delivery.should_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