rpush 2.3.1-java → 2.3.2-java

data/spec/unit/daemon/delivery_spec.rb

@@ -12,23 +12,23 @@ describe Rpush::Daemon::Delivery do
   let(:delivery) { DeliverySpecDelivery.new(batch) }
   let(:notification) { Rpush::Apns::Notification.new }
 
-  before { Time.stub(now: now) }
+  before { allow(Time).to receive_messages(now: now) }
 
   describe 'mark_retryable' do
     it 'does not retry a notification with an expired fail_after' do
-      batch.should_receive(:mark_failed).with(notification, nil, "Notification failed to be delivered before 2014-10-13 23:00:00.")
+      expect(batch).to receive(:mark_failed).with(notification, nil, "Notification failed to be delivered before 2014-10-13 23:00:00.")
       notification.fail_after = Time.now - 1.hour
       delivery.mark_retryable(notification, Time.now + 1.hour)
     end
 
     it 'retries the notification if does not have a fail_after time' do
-      batch.should_receive(:mark_retryable)
+      expect(batch).to receive(:mark_retryable)
       notification.fail_after = nil
       delivery.mark_retryable(notification, Time.now + 1.hour)
     end
 
     it 'retries the notification if the fail_after time has not been reached' do
-      batch.should_receive(:mark_retryable)
+      expect(batch).to receive(:mark_retryable)
       notification.fail_after = Time.now + 1.hour
       delivery.mark_retryable(notification, Time.now + 1.hour)
     end
@@ -36,7 +36,7 @@ describe Rpush::Daemon::Delivery do
 
   describe 'mark_batch_delivered' do
     it 'marks all notifications as delivered' do
-      batch.should_receive(:mark_all_delivered)
+      expect(batch).to receive(:mark_all_delivered)
       delivery.mark_batch_delivered
     end
   end
@@ -44,7 +44,7 @@ describe Rpush::Daemon::Delivery do
   describe 'mark_batch_failed' do
     it 'marks all notifications as delivered' do
       error = Rpush::DeliveryError.new(1, 42, 'an error')
-      batch.should_receive(:mark_all_failed).with(1, 'Unable to deliver notification 42, received error 1 (an error)')
+      expect(batch).to receive(:mark_all_failed).with(1, 'Unable to deliver notification 42, received error 1 (an error)')
       delivery.mark_batch_failed(error)
     end
   end

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

@@ -9,25 +9,25 @@ describe Rpush::Daemon::Dispatcher::Http do
   let(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
   let(:dispatcher) { Rpush::Daemon::Dispatcher::Http.new(app, delivery_class) }
 
-  before { Net::HTTP::Persistent.stub(new: http) }
+  before { allow(Net::HTTP::Persistent).to receive_messages(new: http) }
 
   it 'constructs a new persistent connection' do
-    Net::HTTP::Persistent.should_receive(:new)
+    expect(Net::HTTP::Persistent).to receive(:new)
     Rpush::Daemon::Dispatcher::Http.new(app, delivery_class)
   end
 
   describe 'dispatch' do
     it 'delivers the notification' do
       delivery = double
-      delivery_class.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
-      delivery.should_receive(:perform)
+      expect(delivery_class).to receive(:new).with(app, http, notification, batch).and_return(delivery)
+      expect(delivery).to receive(:perform)
       dispatcher.dispatch(queue_payload)
     end
   end
 
   describe 'cleanup' do
     it 'closes the connection' do
-      http.should_receive(:shutdown)
+      expect(http).to receive(:shutdown)
       dispatcher.cleanup
     end
   end

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

@@ -13,19 +13,19 @@ describe Rpush::Daemon::Dispatcher::Tcp do
   let(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
   let(:dispatcher) { Rpush::Daemon::Dispatcher::Tcp.new(app, delivery_class, host: host_proc) }
 
-  before { Rpush::Daemon::TcpConnection.stub(new: connection) }
+  before { allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection) }
 
   describe 'dispatch' do
     it 'delivers the notification' do
-      delivery_class.should_receive(:new).with(app, connection, notification, batch).and_return(delivery)
-      delivery.should_receive(:perform)
+      expect(delivery_class).to receive(:new).with(app, connection, notification, batch).and_return(delivery)
+      expect(delivery).to receive(:perform)
       dispatcher.dispatch(queue_payload)
     end
   end
 
   describe 'cleanup' do
     it 'closes the connection' do
-      connection.should_receive(:close)
+      expect(connection).to receive(:close)
       dispatcher.cleanup
     end
   end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -14,24 +14,24 @@ describe Rpush::Daemon::DispatcherLoop do
   let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
-    Rpush::Daemon.stub(store: store)
+    allow(Rpush::Daemon).to receive_messages(store: store)
     queue.push([notification, batch])
   end
 
   it 'logs errors' do
     logger = double
-    Rpush.stub(logger: logger)
+    allow(Rpush).to receive_messages(logger: logger)
     error = StandardError.new
-    dispatcher.stub(:dispatch).and_raise(error)
-    Rpush.logger.should_receive(:error).with(error)
+    allow(dispatcher).to receive(:dispatch).and_raise(error)
+    expect(Rpush.logger).to receive(:error).with(error)
     run_dispatcher_loop
   end
 
   it 'reflects an exception' do
-    Rpush.stub(logger: double(error: nil))
+    allow(Rpush).to receive_messages(logger: double(error: nil))
     error = StandardError.new
-    dispatcher.stub(:dispatch).and_raise(error)
-    dispatcher_loop.should_receive(:reflect).with(:error, error)
+    allow(dispatcher).to receive(:dispatch).and_raise(error)
+    expect(dispatcher_loop).to receive(:reflect).with(:error, error)
     run_dispatcher_loop
   end
 
@@ -41,12 +41,12 @@ describe Rpush::Daemon::DispatcherLoop do
     end
 
     it 'instructs the dispatcher to cleanup' do
-      dispatcher.should_receive(:cleanup)
+      expect(dispatcher).to receive(:cleanup)
       run_dispatcher_loop
     end
 
     it 'releases the store connection' do
-      Rpush::Daemon.store.should_receive(:release_connection)
+      expect(Rpush::Daemon.store).to receive(:release_connection)
       run_dispatcher_loop
     end
   end

data/spec/unit/daemon/feeder_spec.rb

@@ -14,10 +14,10 @@ describe Rpush::Daemon::Feeder do
       config.push = false
     end
 
-    Rpush.stub(logger: logger)
-    Rpush::Daemon.stub(store: store)
-    Rpush::Daemon::Feeder.stub(should_stop: true, interruptible_sleeper: interruptible_sleeper)
-    Rpush::Daemon::AppRunner.stub(enqueue: nil, num_queued: 0)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Rpush::Daemon::Feeder).to receive_messages(should_stop: true, interruptible_sleeper: interruptible_sleeper)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(enqueue: nil, num_queued: 0)
   end
 
   def start_and_stop
@@ -26,68 +26,67 @@ describe Rpush::Daemon::Feeder do
   end
 
   it 'loads deliverable notifications' do
-    Rpush::Daemon.store.should_receive(:deliverable_notifications).with(Rpush.config.batch_size)
+    expect(Rpush::Daemon.store).to receive(:deliverable_notifications).with(Rpush.config.batch_size)
     start_and_stop
   end
 
   it 'does not load more notifications if the total queue size is equal to the batch size' do
-    Rpush::Daemon::AppRunner.stub(total_queued: Rpush.config.batch_size)
-    Rpush::Daemon.store.should_not_receive(:deliverable_notifications)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(total_queued: Rpush.config.batch_size)
+    expect(Rpush::Daemon.store).not_to receive(:deliverable_notifications)
     start_and_stop
   end
 
   it 'limits the batch size if some runners are still processing notifications' do
-    Rpush.config.stub(batch_size: 10)
-    Rpush::Daemon::AppRunner.stub(total_queued: 6)
-    Rpush::Daemon.store.should_receive(:deliverable_notifications).with(4)
+    allow(Rpush.config).to receive_messages(batch_size: 10)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(total_queued: 6)
+    expect(Rpush::Daemon.store).to receive(:deliverable_notifications).with(4)
     start_and_stop
   end
 
   it 'enqueues notifications without looping if in push mode' do
-    Rpush.config.push = true
-    Rpush::Daemon::Feeder.should_not_receive(:feed_forever)
-    Rpush::Daemon::Feeder.should_receive(:enqueue_notifications)
-    start_and_stop
+    expect(Rpush::Daemon::Feeder).not_to receive(:feed_forever)
+    expect(Rpush::Daemon::Feeder).to receive(:feed_all)
+    Rpush::Daemon::Feeder.start(true)
   end
 
   it "enqueues the notifications" do
-    Rpush::Daemon::AppRunner.should_receive(:enqueue).with([notification])
+    expect(Rpush::Daemon::AppRunner).to receive(:enqueue).with([notification])
     start_and_stop
   end
 
   it "logs errors" do
     e = StandardError.new("bork")
-    Rpush::Daemon.store.stub(:deliverable_notifications).and_raise(e)
-    Rpush.logger.should_receive(:error).with(e)
+    allow(Rpush::Daemon.store).to receive(:deliverable_notifications).and_raise(e)
+    expect(Rpush.logger).to receive(:error).with(e)
     start_and_stop
   end
 
   describe 'stop' do
     it 'interrupts sleep' do
-      interruptible_sleeper.should_receive(:stop)
+      expect(interruptible_sleeper).to receive(:stop)
       start_and_stop
     end
 
     it 'releases the store connection' do
-      Rpush::Daemon.store.should_receive(:release_connection)
+      expect(Rpush::Daemon.store).to receive(:release_connection)
       start_and_stop
     end
   end
 
   it 'enqueues notifications when started' do
-    Rpush::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
-    Rpush::Daemon::Feeder.stub(:loop).and_yield
+    expect(Rpush::Daemon::Feeder).to receive(:enqueue_notifications).at_least(:once)
+    allow(Rpush::Daemon::Feeder).to receive(:loop).and_yield
     start_and_stop
   end
 
   it 'sleeps' do
-    interruptible_sleeper.should_receive(:sleep)
+    expect(interruptible_sleeper).to receive(:sleep)
     start_and_stop
   end
 
   describe 'wakeup' do
     it 'interrupts sleep' do
-      interruptible_sleeper.should_receive(:wakeup)
+      expect(interruptible_sleeper).to receive(:wakeup)
       Rpush::Daemon::Feeder.start
       Rpush::Daemon::Feeder.wakeup
     end

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

@@ -20,31 +20,31 @@ describe Rpush::Daemon::Gcm::Delivery do
   end
 
   before do
-    delivery.stub(reflect: nil)
-    Rpush::Daemon.stub(store: store)
-    Time.stub(now: now)
-    Rpush.stub(logger: logger)
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(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 { allow(response).to receive_messages(body: JSON.dump(body)) }
 
     it 'marks the original notification as failed' do
       # error = Rpush::DeliveryError.new(nil, notification.id, error_description)
-      delivery.should_receive(:mark_failed) do |error|
-        error.to_s.should =~ error_description
+      expect(delivery).to receive(:mark_failed) do |error|
+        expect(error.to_s).to match(error_description)
       end
       perform_with_rescue
     end
 
     it 'creates a new notification for the unavailable devices' do
       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 })
+      allow(response).to receive_messages(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,
-                                                          %w(id_0 id_2), now + 10.seconds, notification.app)
+      expect(store).to receive(:create_gcm_notification).with(attrs, notification.data,
+                                                              %w(id_0 id_2), now + 10.seconds, notification.app)
       perform_with_rescue
     end
 
@@ -55,7 +55,7 @@ describe Rpush::Daemon::Gcm::Delivery do
 
   describe 'a 200 response' do
     before do
-      response.stub(code: 200)
+      allow(response).to receive_messages(code: 200)
     end
 
     it 'reflects on any IDs which successfully received the notification' do
@@ -68,10 +68,10 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      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')
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2))
+      expect(delivery).to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '1')
+      expect(delivery).not_to receive(:reflect).with(:gcm_delivered_to_recipient, notification, '2')
       perform_with_rescue
     end
 
@@ -85,10 +85,10 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      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')
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2))
+      expect(delivery).to receive(:reflect).with(:gcm_failed_to_recipient, notification, 'Err', '1')
+      expect(delivery).not_to receive(:reflect).with(:gcm_failed_to_recipient, notification, anything, '2')
       perform_with_rescue
     end
 
@@ -103,9 +103,9 @@ describe Rpush::Daemon::Gcm::Delivery do
           { 'message_id' => '1:000' }
         ] }
 
-      response.stub(body: JSON.dump(body))
-      notification.stub(registration_ids: %w(1 2 3))
-      delivery.should_receive(:reflect).with(:gcm_canonical_id, '2', 'canonical123')
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
+      expect(delivery).to receive(:reflect).with(:gcm_canonical_id, '2', 'canonical123')
       perform
     end
 
@@ -121,9 +121,9 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      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')
+      allow(response).to receive_messages(body: JSON.dump(body))
+      allow(notification).to receive_messages(registration_ids: %w(1 2 3))
+      expect(delivery).to receive(:reflect).with(:gcm_invalid_registration_id, app, 'NotRegistered', '2')
       perform_with_rescue
     end
 
@@ -136,15 +136,15 @@ describe Rpush::Daemon::Gcm::Delivery do
         }
       end
 
-      before { response.stub(body: JSON.dump(body)) }
+      before { allow(response).to receive_messages(body: JSON.dump(body)) }
 
       it 'marks the notification as delivered' do
-        delivery.should_receive(:mark_delivered)
+        expect(delivery).to receive(:mark_delivered)
         perform
       end
 
       it 'logs that the notification was delivered' do
-        logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+        expect(logger).to receive(:info).with("[MyApp] #{notification.id} sent to xyz")
         perform
       end
     end
@@ -161,10 +161,10 @@ describe Rpush::Daemon::Gcm::Delivery do
         ]
       }
 
-      response.stub(body: JSON.dump(body))
-      delivery.should_receive(:mark_failed)
-      delivery.should_not_receive(:mark_retryable)
-      store.should_not_receive(:create_gcm_notification)
+      allow(response).to receive_messages(body: JSON.dump(body))
+      expect(delivery).to receive(:mark_failed)
+      expect(delivery).not_to receive(:mark_retryable)
+      expect(store).not_to receive(:create_gcm_notification)
       perform_with_rescue
     end
 
@@ -176,9 +176,9 @@ describe Rpush::Daemon::Gcm::Delivery do
           { 'message_id' => '1:000' },
           { 'error' => 'InvalidDataKey' }
         ] }
-      response.stub(body: JSON.dump(body))
+      allow(response).to receive_messages(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)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
 
@@ -195,30 +195,30 @@ describe Rpush::Daemon::Gcm::Delivery do
       end
 
       before do
-        response.stub(body: JSON.dump(body))
-        notification.stub(registration_ids: %w(1 2))
+        allow(response).to receive_messages(body: JSON.dump(body))
+        allow(notification).to receive_messages(registration_ids: %w(1 2))
       end
 
       it 'retries the notification respecting the Retry-After header' do
-        response.stub(header: { 'retry-after' => 10 })
-        delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+        allow(response).to receive_messages(header: { 'retry-after' => 10 })
+        expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
         perform
       end
 
       it 'retries the notification using exponential back-off if the Retry-After header is not present' do
-        delivery.should_receive(:mark_retryable).with(notification, now + 2)
+        expect(delivery).to receive(:mark_retryable).with(notification, now + 2)
         perform
       end
 
       it 'does not mark the notification as failed' do
-        delivery.should_not_receive(:mark_failed)
+        expect(delivery).not_to receive(:mark_failed)
         perform
       end
 
       it 'logs that the notification will be retried' do
         notification.retries = 1
         notification.deliver_after = now + 2
-        Rpush.logger.should_receive(:warn).with("[MyApp] All recipients unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+        expect(Rpush.logger).to receive(:warn).with("[MyApp] All recipients unavailable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
         perform
       end
     end
@@ -255,29 +255,29 @@ describe Rpush::Daemon::Gcm::Delivery do
   end
 
   describe 'a 503 response' do
-    before { response.stub(code: 503) }
+    before { allow(response).to receive_messages(code: 503) }
 
     it 'logs a warning that the notification will be retried.' do
       notification.retries = 1
       notification.deliver_after = now + 2
-      logger.should_receive(:warn).with("[MyApp] GCM responded with an Service Unavailable Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      expect(logger).to receive(:warn).with("[MyApp] GCM responded with an Service Unavailable Error. Notification #{notification.id} will be retried 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 })
-      delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      expect(delivery).to 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' })
-      delivery.should_receive(:mark_retryable).with(notification, Time.parse('Wed, 03 Oct 2012 20:55:11 GMT'))
+      allow(response).to receive_messages(header: { 'retry-after' => 'Wed, 03 Oct 2012 20:55:11 GMT' })
+      expect(delivery).to 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)
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**1)
       perform
     end
   end
@@ -285,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)
+      allow(response).to receive_messages(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).")
+      expect(Rpush.logger).to 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)
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**3)
       perform
     end
   end
 
   describe 'a 401 response' do
-    before { response.stub(code: 401) }
+    before { allow(response).to receive_messages(code: 401) }
 
     it 'raises an error' do
       expect { perform }.to raise_error(Rpush::DeliveryError)
@@ -310,21 +310,21 @@ describe Rpush::Daemon::Gcm::Delivery do
   end
 
   describe 'a 400 response' do
-    before { response.stub(code: 400) }
+    before { allow(response).to receive_messages(code: 400) }
 
     it 'marks the notification as failed' do
       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)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end
 
   describe 'an un-handled response' do
-    before { response.stub(code: 418) }
+    before { allow(response).to receive_messages(code: 418) }
 
     it 'marks the notification as failed' do
       error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       perform_with_rescue
     end
   end