rpush 1.0.0-java → 2.0.0-java

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,38 @@ describe Rpush::Daemon::Gcm::Delivery do
     end
 
     describe 'all deliveries failed with some as Unavailable or InternalServerError' do
-      let(:body) {{
-        'failure' => 3,
-        'success' => 0,
-        'results' => [
-          { 'error' => 'Unavailable' },
-          { 'error' => 'InvalidDataKey' },
-          { 'error' => 'Unavailable' }
-        ]}}
+      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) {{
-        'failure' => 2,
-        'success' => 1,
-        'results' => [
-          { 'error' => 'Unavailable' },
-          { 'message_id' => '1:000' },
-          { 'error' => 'InternalServerError' }
-        ]}}
+      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 +265,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 +285,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 +310,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

data/spec/unit/daemon/reflectable_spec.rb

@@ -5,12 +5,12 @@ describe Rpush::Daemon::Reflectable do
     include Rpush::Daemon::Reflectable
   end
 
-  let(:logger) { double(:error => nil) }
+  let(:logger) { double(error: nil) }
   let(:test_reflectable) { TestReflectable.new }
 
   before do
     Rpush.reflections.stub(:__dispatch)
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
   end
 
   it 'dispatches the given reflection' do

data/spec/unit/daemon/retryable_error_spec.rb

@@ -1,7 +1,7 @@
 require "unit_spec_helper"
 
 describe Rpush::RetryableError do
-  let(:response) { double(:code => 401, :header => { 'retry-after' => 3600 }) }
+  let(:response) { double(code: 401, header: { 'retry-after' => 3600 }) }
   let(:error) { Rpush::RetryableError.new(401, 12, "Unauthorized", response) }
 
   it "returns an informative message" do

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -10,10 +10,13 @@ describe Rpush::Daemon::ServiceConfigMethods do
     ServiceConfigMethodsSpec.delivery_class.should eq ServiceConfigMethodsSpec::Delivery
   end
 
-  it 'gets & sets loops' do
-    loop_class = double
+  it 'instantiates loops' do
+    loop_class = Class.new
+    app = double
+    loop_instance = loop_class.new
+    loop_class.should_receive(:new).with(app).and_return(loop_instance)
     ServiceConfigMethodsSpec.loops loop_class
-    ServiceConfigMethodsSpec.loops.should eq [loop_class]
+    ServiceConfigMethodsSpec.loop_instances(app).should eq [loop_instance]
   end
 
   it 'returns a new dispatcher' do

data/spec/unit/daemon/signal_handler_spec.rb

@@ -0,0 +1,95 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::SignalHandler do
+  def signal_handler(sig)
+    Process.kill(sig, Process.pid)
+    sleep 0.1
+  end
+
+  def with_handler_start_stop
+    Rpush::Daemon::SignalHandler.start
+    yield
+  ensure
+    Rpush::Daemon::SignalHandler.stop
+  end
+
+  describe 'shutdown signals' do
+    unless Rpush.jruby? # These tests do not work on JRuby.
+      it "shuts down when signaled signaled SIGINT" do
+        with_handler_start_stop do
+          Rpush::Daemon.should_receive(:shutdown)
+          signal_handler('SIGINT')
+        end
+      end
+
+      it "shuts down when signaled signaled SIGTERM" do
+        with_handler_start_stop do
+          Rpush::Daemon.should_receive(:shutdown)
+          signal_handler('SIGTERM')
+        end
+      end
+    end
+  end
+
+  describe 'config.embedded = true' do
+    before { Rpush.config.embedded = true }
+
+    it 'does not trap signals' do
+      Signal.should_not_receive(:trap)
+      Rpush::Daemon::SignalHandler.start
+    end
+  end
+
+  describe 'HUP' do
+    before do
+      Rpush::Daemon::Synchronizer.stub(:sync)
+      Rpush::Daemon::Feeder.stub(:wakeup)
+    end
+
+    it 'syncs' do
+      with_handler_start_stop do
+        Rpush::Daemon::Synchronizer.should_receive(:sync)
+        signal_handler('HUP')
+      end
+    end
+
+    it 'wakes up the Feeder' do
+      with_handler_start_stop do
+        Rpush::Daemon::Feeder.should_receive(:wakeup)
+        signal_handler('HUP')
+      end
+    end
+  end
+
+  describe 'USR2' do
+    it 'instructs the AppRunner to print debug information' do
+      with_handler_start_stop do
+        Rpush::Daemon::AppRunner.should_receive(:debug)
+        signal_handler('USR2')
+      end
+    end
+  end
+
+  describe 'error handing' do
+    let(:error) { StandardError.new('test') }
+
+    before { Rpush.stub(logger: double(error: nil)) }
+
+    it 'logs errors received when handling a signal' do
+      Rpush::Daemon::Synchronizer.stub(:sync).and_raise(error)
+      expect(Rpush.logger).to receive(:error).with(error)
+      with_handler_start_stop do
+        signal_handler('HUP')
+      end
+    end
+
+    it 'does not interrupt processing of further errors' do
+      Rpush::Daemon::Synchronizer.stub(:sync).and_raise(error)
+      expect(Rpush::Daemon::AppRunner).to receive(:debug)
+      with_handler_start_stop do
+        signal_handler('HUP')
+        signal_handler('USR2')
+      end
+    end
+  end
+end

data/spec/unit/daemon/store/active_record/reconnectable_spec.rb

@@ -16,13 +16,13 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
     def perform
       with_database_reconnect_and_retry do
         @calls += 1
-        raise @error if @calls <= @max_calls
+        fail @error if @calls <= @max_calls
       end
     end
   end
 
   let(:adapter_error_class) do
-    case $adapter
+    case SPEC_ADAPTER
     when 'postgresql'
       PGError
     when 'mysql'
@@ -38,77 +38,98 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
     when 'sqlite3'
       SQLite3::Exception
     else
-      raise "Please update #{__FILE__} for adapter #{$adapter}"
+      fail "Please update #{__FILE__} for adapter #{SPEC_ADAPTER}"
     end
   end
+
   let(:error) { adapter_error_class.new("db down!") }
-  let(:test_double) { TestDouble.new(error, 1) }
+  let(:timeout) { ActiveRecord::ConnectionTimeoutError.new("db lazy!") }
+  let(:test_doubles) { [TestDouble.new(error, 1), TestDouble.new(timeout, 1)]  }
 
   before do
-    @logger = double("Logger", :info => nil, :error => nil, :warn => nil)
+    @logger = double("Logger", info: nil, error: nil, warn: nil)
     Rpush.stub(:logger).and_return(@logger)
 
     ActiveRecord::Base.stub(:clear_all_connections!)
     ActiveRecord::Base.stub(:establish_connection)
-    test_double.stub(:sleep)
+    test_doubles.each { |td| allow(td).to receive(:sleep) }
   end
 
   it "should log the error raised" do
     Rpush.logger.should_receive(:error).with(error)
-    test_double.perform
+    test_doubles.each(&:perform)
   end
 
   it "should log that the database is being reconnected" do
     Rpush.logger.should_receive(:warn).with("Lost connection to database, reconnecting...")
-    test_double.perform
+    test_doubles.each(&:perform)
   end
 
   it "should log the reconnection attempt" do
     Rpush.logger.should_receive(:warn).with("Attempt 1")
-    test_double.perform
+    test_doubles.each(&:perform)
   end
 
   it "should clear all connections" do
     ActiveRecord::Base.should_receive(:clear_all_connections!)
-    test_double.perform
+    test_doubles.each(&:perform)
   end
 
   it "should establish a new connection" do
     ActiveRecord::Base.should_receive(:establish_connection)
-    test_double.perform
+    test_doubles.each(&:perform)
   end
 
   it "should test out the new connection by performing a count" do
-    Rpush::Notification.should_receive(:count)
-    test_double.perform
+    Rpush::Client::ActiveRecord::Notification.should_receive(:count).twice
+    test_doubles.each(&:perform)
   end
 
   context "when the reconnection attempt is not successful" do
     before do
-      class << Rpush::Notification
+      class << Rpush::Client::ActiveRecord::Notification
         def count
           @count_calls += 1
           return if @count_calls == 2
-          raise @error
+          fail @error
         end
       end
-      Rpush::Notification.instance_variable_set("@count_calls", 0)
-      Rpush::Notification.instance_variable_set("@error", error)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@count_calls", 0)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@error", error)
     end
 
-    it "should log the 2nd attempt" do
-      Rpush.logger.should_receive(:warn).with("Attempt 2")
-      test_double.perform
-    end
+    describe "error behaviour" do
+      it "should log the 2nd attempt" do
+        Rpush.logger.should_receive(:warn).with("Attempt 2")
+        test_doubles[0].perform
+      end
 
-    it "should log errors raised when the reconnection is not successful" do
-      Rpush.logger.should_receive(:error).with(error)
-      test_double.perform
+      it "should log errors raised when the reconnection is not successful" do
+        Rpush.logger.should_receive(:error).with(error)
+        test_doubles[0].perform
+      end
+
+      it "should sleep to avoid thrashing when the database is down" do
+        expect(test_doubles[0]).to receive(:sleep).with(2)
+        test_doubles[0].perform
+      end
     end
 
-    it "should sleep to avoid thrashing when the database is down" do
-      test_double.should_receive(:sleep).with(2)
-      test_double.perform
+    describe "timeout behaviour" do
+      it "should log the 2nd attempt" do
+        Rpush.logger.should_receive(:warn).with("Attempt 2")
+        test_doubles[1].perform
+      end
+
+      it "should log errors raised when the reconnection is not successful" do
+        Rpush.logger.should_receive(:error).with(error)
+        test_doubles[1].perform
+      end
+
+      it "should sleep to avoid thrashing when the database is down" do
+        expect(test_doubles[1]).to receive(:sleep).with(2)
+        test_doubles[1].perform
+      end
     end
   end
 end