rpush 2.3.1 → 2.3.2

data/spec/unit/daemon/retryable_error_spec.rb

@@ -5,10 +5,10 @@ describe Rpush::RetryableError do
   let(:error) { Rpush::RetryableError.new(401, 12, "Unauthorized", response) }
 
   it "returns an informative message" do
-    error.to_s.should eq "Retryable error for 12, received error 401 (Unauthorized) - retry after 3600"
+    expect(error.to_s).to eq "Retryable error for 12, received error 401 (Unauthorized) - retry after 3600"
   end
 
   it "returns the error code" do
-    error.code.should eq 401
+    expect(error.code).to eq 401
   end
 end

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -7,24 +7,24 @@ describe Rpush::Daemon::ServiceConfigMethods do
   end
 
   it 'returns the delivery class' do
-    ServiceConfigMethodsSpec.delivery_class.should eq ServiceConfigMethodsSpec::Delivery
+    expect(ServiceConfigMethodsSpec.delivery_class).to eq ServiceConfigMethodsSpec::Delivery
   end
 
   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)
+    expect(loop_class).to receive(:new).with(app).and_return(loop_instance)
     ServiceConfigMethodsSpec.loops loop_class
-    ServiceConfigMethodsSpec.loop_instances(app).should eq [loop_instance]
+    expect(ServiceConfigMethodsSpec.loop_instances(app)).to eq [loop_instance]
   end
 
   it 'returns a new dispatcher' do
     ServiceConfigMethodsSpec.dispatcher :http, an: :option
     app = double
     dispatcher = double
-    Rpush::Daemon::Dispatcher::Http.should_receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, an: :option).and_return(dispatcher)
-    ServiceConfigMethodsSpec.new_dispatcher(app).should eq dispatcher
+    expect(Rpush::Daemon::Dispatcher::Http).to receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, an: :option).and_return(dispatcher)
+    expect(ServiceConfigMethodsSpec.new_dispatcher(app)).to eq dispatcher
   end
 
   it 'raises a NotImplementedError for an unknown dispatcher type' do

data/spec/unit/daemon/signal_handler_spec.rb

@@ -17,14 +17,14 @@ describe Rpush::Daemon::SignalHandler 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)
+          expect(Rpush::Daemon).to 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)
+          expect(Rpush::Daemon).to receive(:shutdown)
           signal_handler('SIGTERM')
         end
       end
@@ -35,28 +35,28 @@ describe Rpush::Daemon::SignalHandler do
     before { Rpush.config.embedded = true }
 
     it 'does not trap signals' do
-      Signal.should_not_receive(:trap)
+      expect(Signal).not_to receive(:trap)
       Rpush::Daemon::SignalHandler.start
     end
   end
 
   describe 'HUP' do
     before do
-      Rpush::Daemon::Synchronizer.stub(:sync)
-      Rpush::Daemon::Feeder.stub(:wakeup)
-      Rpush::Daemon.stub(store: double(reopen_log: nil))
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync)
+      allow(Rpush::Daemon::Feeder).to receive(:wakeup)
+      allow(Rpush::Daemon).to receive_messages(store: double(reopen_log: nil))
     end
 
     it 'syncs' do
       with_handler_start_stop do
-        Rpush::Daemon::Synchronizer.should_receive(:sync)
+        expect(Rpush::Daemon::Synchronizer).to receive(:sync)
         signal_handler('HUP')
       end
     end
 
     it 'wakes up the Feeder' do
       with_handler_start_stop do
-        Rpush::Daemon::Feeder.should_receive(:wakeup)
+        expect(Rpush::Daemon::Feeder).to receive(:wakeup)
         signal_handler('HUP')
       end
     end
@@ -65,7 +65,7 @@ describe Rpush::Daemon::SignalHandler do
   describe 'USR2' do
     it 'instructs the AppRunner to print debug information' do
       with_handler_start_stop do
-        Rpush::Daemon::AppRunner.should_receive(:debug)
+        expect(Rpush::Daemon::AppRunner).to receive(:debug)
         signal_handler('USR2')
       end
     end
@@ -75,12 +75,12 @@ describe Rpush::Daemon::SignalHandler do
     let(:error) { StandardError.new('test') }
 
     before do
-      Rpush.stub(logger: double(error: nil, info: nil, reopen: nil))
-      Rpush::Daemon.stub(store: double(reopen_log: nil))
+      allow(Rpush).to receive_messages(logger: double(error: nil, info: nil, reopen: nil))
+      allow(Rpush::Daemon).to receive_messages(store: double(reopen_log: nil))
     end
 
     it 'logs errors received when handling a signal' do
-      Rpush::Daemon::Synchronizer.stub(:sync).and_raise(error)
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync).and_raise(error)
       expect(Rpush.logger).to receive(:error).with(error)
       with_handler_start_stop do
         signal_handler('HUP')
@@ -88,7 +88,7 @@ describe Rpush::Daemon::SignalHandler do
     end
 
     it 'does not interrupt processing of further errors' do
-      Rpush::Daemon::Synchronizer.stub(:sync).and_raise(error)
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync).and_raise(error)
       expect(Rpush::Daemon::AppRunner).to receive(:debug)
       with_handler_start_stop do
         signal_handler('HUP')

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

@@ -48,40 +48,40 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
 
   before do
     @logger = double("Logger", info: nil, error: nil, warn: nil)
-    Rpush.stub(:logger).and_return(@logger)
+    allow(Rpush).to receive(:logger).and_return(@logger)
 
-    ActiveRecord::Base.stub(:clear_all_connections!)
-    ActiveRecord::Base.stub(:establish_connection)
+    allow(ActiveRecord::Base).to receive(:clear_all_connections!)
+    allow(ActiveRecord::Base).to receive(:establish_connection)
     test_doubles.each { |td| allow(td).to receive(:sleep) }
   end
 
   it "should log the error raised" do
-    Rpush.logger.should_receive(:error).with(error)
+    expect(Rpush.logger).to receive(:error).with(error)
     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...")
+    expect(Rpush.logger).to receive(:warn).with("Lost connection to database, reconnecting...")
     test_doubles.each(&:perform)
   end
 
   it "should log the reconnection attempt" do
-    Rpush.logger.should_receive(:warn).with("Attempt 1")
+    expect(Rpush.logger).to receive(:warn).with("Attempt 1")
     test_doubles.each(&:perform)
   end
 
   it "should clear all connections" do
-    ActiveRecord::Base.should_receive(:clear_all_connections!)
+    expect(ActiveRecord::Base).to receive(:clear_all_connections!)
     test_doubles.each(&:perform)
   end
 
   it "should establish a new connection" do
-    ActiveRecord::Base.should_receive(:establish_connection)
+    expect(ActiveRecord::Base).to receive(:establish_connection)
     test_doubles.each(&:perform)
   end
 
   it "should test out the new connection by performing a count" do
-    Rpush::Client::ActiveRecord::Notification.should_receive(:count).twice
+    expect(Rpush::Client::ActiveRecord::Notification).to receive(:count).twice
     test_doubles.each(&:perform)
   end
 
@@ -100,12 +100,12 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
 
     describe "error behaviour" do
       it "should log the 2nd attempt" do
-        Rpush.logger.should_receive(:warn).with("Attempt 2")
+        expect(Rpush.logger).to 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)
+        expect(Rpush.logger).to receive(:error).with(error)
         test_doubles[0].perform
       end
 
@@ -117,12 +117,12 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
 
     describe "timeout behaviour" do
       it "should log the 2nd attempt" do
-        Rpush.logger.should_receive(:warn).with("Attempt 2")
+        expect(Rpush.logger).to 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)
+        expect(Rpush.logger).to receive(:error).with(error)
         test_doubles[1].perform
       end
 

data/spec/unit/daemon/store/active_record_spec.rb

@@ -9,35 +9,35 @@ describe Rpush::Daemon::Store::ActiveRecord do
   let(:logger) { double(Rpush::Logger, error: nil, internal_logger: nil) }
 
   before do
-    Rpush.stub(logger: logger)
-    Time.stub(now: time)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Time).to receive_messages(now: time)
   end
 
   it 'can update a notification' do
-    notification.should_receive(:save!)
+    expect(notification).to receive(:save!)
     store.update_notification(notification)
   end
 
   it 'can update a app' do
-    app.should_receive(:save!)
+    expect(app).to receive(:save!)
     store.update_app(app)
   end
 
   it 'can release a connection' do
-    ActiveRecord::Base.connection.should_receive(:close)
+    expect(ActiveRecord::Base.connection).to receive(:close)
     store.release_connection
   end
 
   it 'logs errors raised when trying to release the connection' do
     e = StandardError.new
-    ActiveRecord::Base.connection.stub(:close).and_raise(e)
-    Rpush.logger.should_receive(:error).with(e)
+    allow(ActiveRecord::Base.connection).to receive(:close).and_raise(e)
+    expect(Rpush.logger).to receive(:error).with(e)
     store.release_connection
   end
 
   describe 'deliverable_notifications' do
     it 'checks for new notifications with the ability to reconnect the database' do
-      store.should_receive(:with_database_reconnect_and_retry)
+      expect(store).to receive(:with_database_reconnect_and_retry)
       store.deliverable_notifications(Rpush.config.batch_size)
     end
 
@@ -45,43 +45,43 @@ describe Rpush::Daemon::Store::ActiveRecord do
       Rpush.config.batch_size = 5000
       Rpush.config.push = false
       relation = double.as_null_object
-      relation.should_receive(:limit).with(5000)
-      relation.stub(to_a: [])
-      store.stub(ready_for_delivery: relation)
+      expect(relation).to receive(:limit).with(5000)
+      allow(relation).to receive_messages(to_a: [])
+      allow(store).to receive_messages(ready_for_delivery: relation)
       store.deliverable_notifications(Rpush.config.batch_size)
     end
 
     it 'does not load notification in batches if in push mode' do
       Rpush.config.push = true
       relation = double.as_null_object
-      relation.should_not_receive(:limit)
-      Rpush::Notification.stub(ready_for_delivery: relation)
+      expect(relation).not_to receive(:limit)
+      allow(Rpush::Notification).to receive_messages(ready_for_delivery: relation)
       store.deliverable_notifications(Rpush.config.batch_size)
     end
 
     it 'loads an undelivered notification without deliver_after set' do
       notification.update_attributes!(delivered: false, deliver_after: nil)
-      store.deliverable_notifications(Rpush.config.batch_size).should eq [notification]
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to eq [notification]
     end
 
     it 'loads an notification with a deliver_after time in the past' do
       notification.update_attributes!(delivered: false, deliver_after: 1.hour.ago)
-      store.deliverable_notifications(Rpush.config.batch_size).should eq [notification]
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to eq [notification]
     end
 
     it 'does not load an notification with a deliver_after time in the future' do
       notification.update_attributes!(delivered: false, deliver_after: 1.hour.from_now)
-      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
     end
 
     it 'does not load a previously delivered notification' do
       notification.update_attributes!(delivered: true, delivered_at: time)
-      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
     end
 
     it "does not enqueue a notification that has previously failed delivery" do
       notification.update_attributes!(delivered: false, failed: true)
-      store.deliverable_notifications(Rpush.config.batch_size).should be_empty
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
     end
   end
 
@@ -100,12 +100,12 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(validate: false)
+      expect(notification).to receive(:save!).with(validate: false)
       store.mark_retryable(notification, time)
     end
 
     it 'does not save the notification if persist: false' do
-      notification.should_not_receive(:save!)
+      expect(notification).not_to receive(:save!)
       store.mark_retryable(notification, time, persist: false)
     end
   end
@@ -115,8 +115,8 @@ describe Rpush::Daemon::Store::ActiveRecord do
 
     it 'sets the attributes on the object for use in reflections' do
       store.mark_batch_retryable([notification], deliver_after)
-      notification.deliver_after.should eq deliver_after
-      notification.retries.should eq 1
+      expect(notification.deliver_after).to eq deliver_after
+      expect(notification.retries).to eq 1
     end
 
     it 'increments the retired count' do
@@ -149,12 +149,12 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(validate: false)
+      expect(notification).to receive(:save!).with(validate: false)
       store.mark_delivered(notification, time)
     end
 
     it 'does not save the notification if persist: false' do
-      notification.should_not_receive(:save!)
+      expect(notification).not_to receive(:save!)
       store.mark_delivered(notification, time, persist: false)
     end
   end
@@ -162,8 +162,8 @@ describe Rpush::Daemon::Store::ActiveRecord do
   describe 'mark_batch_delivered' do
     it 'sets the attributes on the object for use in reflections' do
       store.mark_batch_delivered([notification])
-      notification.delivered_at.should eq time
-      notification.delivered.should be_true
+      expect(notification.delivered_at).to eq time
+      expect(notification.delivered).to be_truthy
     end
 
     it 'marks the notifications as delivered' do
@@ -184,7 +184,7 @@ describe Rpush::Daemon::Store::ActiveRecord do
   describe 'mark_failed' do
     it 'marks the notification as not delivered' do
       store.mark_failed(notification, nil, '', time)
-      notification.delivered.should be_false
+      expect(notification.delivered).to eq(false)
     end
 
     it 'marks the notification as failed' do
@@ -214,12 +214,12 @@ describe Rpush::Daemon::Store::ActiveRecord do
     end
 
     it 'saves the notification without validation' do
-      notification.should_receive(:save!).with(validate: false)
+      expect(notification).to receive(:save!).with(validate: false)
       store.mark_failed(notification, nil, '', time)
     end
 
     it 'does not save the notification if persist: false' do
-      notification.should_not_receive(:save!)
+      expect(notification).not_to receive(:save!)
       store.mark_failed(notification, nil, '', time, persist: false)
     end
   end
@@ -227,18 +227,18 @@ describe Rpush::Daemon::Store::ActiveRecord do
   describe 'mark_batch_failed' do
     it 'sets the attributes on the object for use in reflections' do
       store.mark_batch_failed([notification], 123, 'an error')
-      notification.failed_at.should eq time
-      notification.delivered_at.should be_nil
-      notification.delivered.should be_false
-      notification.failed.should be_true
-      notification.error_code.should eq 123
-      notification.error_description.should eq 'an error'
+      expect(notification.failed_at).to eq time
+      expect(notification.delivered_at).to be_nil
+      expect(notification.delivered).to eq(false)
+      expect(notification.failed).to be_truthy
+      expect(notification.error_code).to eq 123
+      expect(notification.error_description).to eq 'an error'
     end
 
     it 'marks the notification as not delivered' do
       store.mark_batch_failed([notification], nil, '')
       notification.reload
-      notification.delivered.should be_false
+      expect(notification.delivered).to be_falsey
     end
 
     it 'marks the notification as failed' do
@@ -272,7 +272,7 @@ describe Rpush::Daemon::Store::ActiveRecord do
 
   describe 'create_apns_feedback' do
     it 'creates the Feedback record' do
-      Rpush::Client::ActiveRecord::Apns::Feedback.should_receive(:create!).with(
+      expect(Rpush::Client::ActiveRecord::Apns::Feedback).to receive(:create!).with(
         failed_at: time, device_token: 'ab' * 32, app_id: app.id)
       store.create_apns_feedback(time, 'ab' * 32, app)
     end
@@ -287,27 +287,27 @@ describe Rpush::Daemon::Store::ActiveRecord do
 
     it 'sets the given attributes' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.device_token.should eq 'ab' * 32
+      expect(new_notification.device_token).to eq 'ab' * 32
     end
 
     it 'sets the given data' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.data['data'].should be_true
+      expect(new_notification.data['data']).to be_truthy
     end
 
     it 'sets the given registration IDs' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.registration_ids.should eq registration_ids
+      expect(new_notification.registration_ids).to eq registration_ids
     end
 
     it 'sets the deliver_after timestamp' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.deliver_after.to_s.should eq deliver_after.to_s
+      expect(new_notification.deliver_after.to_s).to eq deliver_after.to_s
     end
 
     it 'saves the new notification' do
       new_notification = store.create_gcm_notification(*args)
-      new_notification.new_record?.should be_false
+      expect(new_notification.new_record?).to be_falsey
     end
   end
 
@@ -320,29 +320,29 @@ describe Rpush::Daemon::Store::ActiveRecord do
 
     it 'sets the given attributes' do
       new_notification = store.create_adm_notification(*args)
-      new_notification.app_id.should eq app.id
-      new_notification.collapse_key.should eq 'ckey'
-      new_notification.delay_while_idle.should be_true
+      expect(new_notification.app_id).to eq app.id
+      expect(new_notification.collapse_key).to eq 'ckey'
+      expect(new_notification.delay_while_idle).to be_truthy
     end
 
     it 'sets the given data' do
       new_notification = store.create_adm_notification(*args)
-      new_notification.data['data'].should be_true
+      expect(new_notification.data['data']).to be_truthy
     end
 
     it 'sets the given registration IDs' do
       new_notification = store.create_adm_notification(*args)
-      new_notification.registration_ids.should eq registration_ids
+      expect(new_notification.registration_ids).to eq registration_ids
     end
 
     it 'sets the deliver_after timestamp' do
       new_notification = store.create_adm_notification(*args)
-      new_notification.deliver_after.to_s.should eq deliver_after.to_s
+      expect(new_notification.deliver_after.to_s).to eq deliver_after.to_s
     end
 
     it 'saves the new notification' do
       new_notification = store.create_adm_notification(*args)
-      new_notification.new_record?.should be_false
+      expect(new_notification.new_record?).to be_falsey
     end
   end
 end