rpush 2.3.1-java → 2.3.2-java

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

@@ -17,16 +17,14 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
   before do
     Rpush.config.feedback_poll = poll
-    Rpush::Daemon::InterruptibleSleep.stub(new: sleeper)
-    Rpush.stub(logger: logger)
-    Rpush::Daemon::TcpConnection.stub(new: connection)
+    allow(Rpush::Daemon::InterruptibleSleep).to receive_messages(new: sleeper)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection)
     receiver.instance_variable_set("@stop", false)
-    Rpush::Daemon.stub(store: store)
+    allow(Rpush::Daemon).to receive_messages(store: store)
   end
 
   def double_connection_read_with_tuple
-    connection.unstub(:read)
-
     def connection.read(*)
       unless @called
         @called = true
@@ -36,78 +34,78 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'initializes the sleeper with the feedback polling duration' do
-    Rpush::Daemon::InterruptibleSleep.should_receive(:new).with(poll).and_return(sleeper)
+    expect(Rpush::Daemon::InterruptibleSleep).to receive(:new).with(poll).and_return(sleeper)
     Rpush::Daemon::Apns::FeedbackReceiver.new(app)
   end
 
   it 'instantiates a new connection' do
-    Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port)
+    expect(Rpush::Daemon::TcpConnection).to receive(:new).with(app, host, port)
     receiver.check_for_feedback
   end
 
   it 'connects to the feeback service' do
-    connection.should_receive(:connect)
+    expect(connection).to receive(:connect)
     receiver.check_for_feedback
   end
 
   it 'closes the connection' do
-    connection.should_receive(:close)
+    expect(connection).to receive(:close)
     receiver.check_for_feedback
   end
 
   it 'reads from the connection' do
-    connection.should_receive(:read).with(38)
+    expect(connection).to receive(:read).with(38)
     receiver.check_for_feedback
   end
 
   it 'logs the feedback' do
     double_connection_read_with_tuple
-    Rpush.logger.should_receive(:info).with("[my_app] [FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17.")
+    expect(Rpush.logger).to receive(:info).with("[my_app] [FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17.")
     receiver.check_for_feedback
   end
 
   it 'creates the feedback' do
-    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
+    expect(Rpush::Daemon.store).to receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
     double_connection_read_with_tuple
     receiver.check_for_feedback
   end
 
   it 'logs errors' do
     error = StandardError.new('bork!')
-    connection.stub(:read).and_raise(error)
-    Rpush.logger.should_receive(:error).with(error)
+    allow(connection).to receive(:read).and_raise(error)
+    expect(Rpush.logger).to receive(:error).with(error)
     receiver.check_for_feedback
   end
 
   describe 'start' do
     before do
-      Thread.stub(:new).and_yield
-      receiver.stub(:loop).and_yield
+      allow(Thread).to receive(:new).and_yield
+      allow(receiver).to receive(:loop).and_yield
     end
 
     it 'sleeps' do
-      receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:sleep).at_least(:once)
+      allow(receiver).to receive(:check_for_feedback)
+      expect(sleeper).to receive(:sleep).at_least(:once)
       receiver.start
     end
 
     it 'checks for feedback when started' do
-      receiver.should_receive(:check_for_feedback).at_least(:once)
+      expect(receiver).to receive(:check_for_feedback).at_least(:once)
       receiver.start
     end
   end
 
   describe 'stop' do
     it 'interrupts sleep when stopped' do
-      receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:stop)
+      allow(receiver).to receive(:check_for_feedback)
+      expect(sleeper).to receive(:stop)
       receiver.stop
     end
 
     it 'releases the store connection' do
-      Thread.stub(:new).and_yield
-      receiver.stub(:loop).and_yield
-      Rpush::Daemon.store.should_receive(:release_connection)
+      allow(Thread).to receive(:new).and_yield
+      allow(receiver).to receive(:loop).and_yield
+      expect(Rpush::Daemon.store).to receive(:release_connection)
       receiver.start
       receiver.stop
     end
@@ -115,7 +113,7 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
   it 'reflects feedback was received' do
     double_connection_read_with_tuple
-    receiver.should_receive(:reflect).with(:apns_feedback, feedback)
+    expect(receiver).to receive(:reflect).with(:apns_feedback, feedback)
     receiver.check_for_feedback
   end
 end

data/spec/unit/daemon/app_runner_spec.rb

@@ -38,16 +38,16 @@ describe Rpush::Daemon::AppRunner, 'enqueue' do
   let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    Rpush.stub(logger: logger)
-    Rpush::Daemon::ProcTitle.stub(:update)
-    Rpush::Daemon::AppRunner.stub(new: runner)
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Rpush::Daemon::ProcTitle).to receive(:update)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(new: runner)
     Rpush::Daemon::AppRunner.start_app(app)
   end
 
   after { Rpush::Daemon::AppRunner.stop }
 
   it 'enqueues notifications on the runner' do
-    runner.should_receive(:enqueue).with([notification])
+    expect(runner).to receive(:enqueue).with([notification])
     Rpush::Daemon::AppRunner.enqueue([notification])
   end
 
@@ -56,7 +56,7 @@ describe Rpush::Daemon::AppRunner, 'enqueue' do
     new_app = double(Rpush::App, id: 3, name: 'NewApp', connections: 1)
     Rpush::Daemon.store = double(app: new_app)
     Rpush::Daemon::AppRunner.enqueue([notification])
-    Rpush::Daemon::AppRunner.app_running?(new_app).should be_true
+    expect(Rpush::Daemon::AppRunner.app_running?(new_app)).to eq(true)
   end
 end
 
@@ -66,13 +66,13 @@ describe Rpush::Daemon::AppRunner, 'start_app' do
   let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    Rpush.stub(logger: logger)
+    allow(Rpush).to receive_messages(logger: logger)
   end
 
   it 'logs an error if the runner could not be started' do
-    Rpush::Daemon::AppRunner.should_receive(:new).with(app).and_return(runner)
-    runner.stub(:start_dispatchers).and_raise(StandardError)
-    Rpush.logger.should_receive(:error)
+    expect(Rpush::Daemon::AppRunner).to receive(:new).with(app).and_return(runner)
+    allow(runner).to receive(:start_dispatchers).and_raise(StandardError)
+    expect(Rpush.logger).to receive(:error)
     Rpush::Daemon::AppRunner.start_app(app)
   end
 end
@@ -87,15 +87,15 @@ describe Rpush::Daemon::AppRunner, 'debug' do
   let(:store) { double(all_apps: [app], release_connection: nil) }
 
   before do
-    Rpush::Daemon.stub(config: {}, store: store)
-    Rpush.stub(logger: logger)
+    allow(Rpush::Daemon).to receive_messages(config: {}, store: store)
+    allow(Rpush).to receive_messages(logger: logger)
     Rpush::Daemon::AppRunner.start_app(app)
   end
 
   after { Rpush::Daemon::AppRunner.stop_app(app.id) }
 
   it 'prints debug app states to the log' do
-    Rpush.logger.should_receive(:info).with(kind_of(String))
+    expect(Rpush.logger).to receive(:info).with(kind_of(String))
     Rpush::Daemon::AppRunner.debug
   end
 end
@@ -114,27 +114,27 @@ describe Rpush::Daemon::AppRunner do
   let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
-    Rpush::Daemon::DispatcherLoop.stub(new: dispatcher_loop)
-    Rpush::Daemon.stub(store: store)
-    Rpush::Daemon::AppRunnerSpecService::ServiceLoop.stub(new: service_loop)
-    Queue.stub(new: queue)
-    Rpush.stub(logger: logger)
+    allow(Rpush::Daemon::DispatcherLoop).to receive_messages(new: dispatcher_loop)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Rpush::Daemon::AppRunnerSpecService::ServiceLoop).to receive_messages(new: service_loop)
+    allow(Queue).to receive_messages(new: queue)
+    allow(Rpush).to receive_messages(logger: logger)
   end
 
   describe 'start' do
     it 'starts a delivery dispatcher for each connection' do
-      app.stub(connections: 2)
+      allow(app).to receive_messages(connections: 2)
       runner.start_dispatchers
-      runner.num_dispatcher_loops.should eq 2
+      expect(runner.num_dispatcher_loops).to eq 2
     end
 
     it 'starts the dispatcher loop' do
-      dispatcher_loop.should_receive(:start)
+      expect(dispatcher_loop).to receive(:start)
       runner.start_dispatchers
     end
 
     it 'starts the loops' do
-      service_loop.should_receive(:start)
+      expect(service_loop).to receive(:start)
       runner.start_loops
     end
   end
@@ -143,27 +143,27 @@ describe Rpush::Daemon::AppRunner do
     let(:notification) { double }
 
     it 'enqueues the batch' do
-      queue.should_receive(:push) do |queue_payload|
-        queue_payload.notification.should eq notification
-        queue_payload.batch.should_not be_nil
+      expect(queue).to receive(:push) do |queue_payload|
+        expect(queue_payload.notification).to eq notification
+        expect(queue_payload.batch).not_to be_nil
       end
       runner.enqueue([notification])
     end
 
     it 'reflects the notification has been enqueued' do
-      runner.should_receive(:reflect).with(:notification_enqueued, notification)
+      expect(runner).to receive(:reflect).with(:notification_enqueued, notification)
       runner.enqueue([notification])
     end
 
     describe 'a service that batches deliveries' do
       before do
-        runner.send(:service).stub(batch_deliveries?: true)
+        allow(runner.send(:service)).to receive_messages(batch_deliveries?: true)
       end
 
       describe '1 notification with more than one dispatcher loop' do
         it 'does not raise ArgumentError: invalid slice size' do
           # https://github.com/rpush/rpush/issues/57
-          runner.stub(:num_dispatcher_loops).and_return(2)
+          allow(runner).to receive(:num_dispatcher_loops).and_return(2)
           runner.enqueue([notification])
         end
       end
@@ -177,12 +177,12 @@ describe Rpush::Daemon::AppRunner do
     end
 
     it 'stops the delivery dispatchers' do
-      dispatcher_loop.should_receive(:stop)
+      expect(dispatcher_loop).to receive(:stop)
       runner.stop
     end
 
     it 'stop the loops' do
-      service_loop.should_receive(:stop)
+      expect(service_loop).to receive(:stop)
       runner.stop
     end
   end

data/spec/unit/daemon/batch_spec.rb

@@ -8,12 +8,12 @@ describe Rpush::Daemon::Batch do
   let(:time) { Time.now }
 
   before do
-    Time.stub(now: time)
-    Rpush::Daemon.stub(store: store)
+    allow(Time).to receive_messages(now: time)
+    allow(Rpush::Daemon).to receive_messages(store: store)
   end
 
   it 'exposes the number notifications processed' do
-    batch.num_processed.should eq 0
+    expect(batch.num_processed).to eq 0
   end
 
   it 'increments the processed notifications count' do
@@ -21,88 +21,88 @@ describe Rpush::Daemon::Batch do
   end
 
   it 'completes the batch when all notifications have been processed' do
-    batch.should_receive(:complete)
+    expect(batch).to receive(:complete)
     2.times { batch.notification_processed }
   end
 
   describe 'mark_delivered' do
     it 'marks the notification as delivered immediately without persisting' do
-      store.should_receive(:mark_delivered).with(notification1, time, persist: false)
+      expect(store).to receive(:mark_delivered).with(notification1, time, persist: false)
       batch.mark_delivered(notification1)
     end
 
     it 'defers persisting' do
       batch.mark_delivered(notification1)
-      batch.delivered.should eq [notification1]
+      expect(batch.delivered).to eq [notification1]
     end
   end
 
   describe 'mark_all_delivered' do
     it 'marks the notifications as delivered immediately without persisting' do
-      store.should_receive(:mark_delivered).with(notification1, time, persist: false)
-      store.should_receive(:mark_delivered).with(notification2, time, persist: false)
+      expect(store).to receive(:mark_delivered).with(notification1, time, persist: false)
+      expect(store).to receive(:mark_delivered).with(notification2, time, persist: false)
       batch.mark_all_delivered
     end
 
     it 'defers persisting' do
       batch.mark_all_delivered
-      batch.delivered.should eq [notification1, notification2]
+      expect(batch.delivered).to eq [notification1, notification2]
     end
   end
 
   describe 'mark_failed' do
     it 'marks the notification as failed without persisting' do
-      store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
+      expect(store).to receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
       batch.mark_failed(notification1, 1, 'an error')
     end
 
     it 'defers persisting' do
       batch.mark_failed(notification1, 1, 'an error')
-      batch.failed.should eq([1, 'an error'] => [notification1])
+      expect(batch.failed).to eq([1, 'an error'] => [notification1])
     end
   end
 
   describe 'mark_failed' do
     it 'marks the notification as failed without persisting' do
-      store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
-      store.should_receive(:mark_failed).with(notification2, 1, 'an error', time, persist: false)
+      expect(store).to receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
+      expect(store).to receive(:mark_failed).with(notification2, 1, 'an error', time, persist: false)
       batch.mark_all_failed(1, 'an error')
     end
 
     it 'defers persisting' do
       batch.mark_all_failed(1, 'an error')
-      batch.failed.should eq([1, 'an error'] => [notification1, notification2])
+      expect(batch.failed).to eq([1, 'an error'] => [notification1, notification2])
     end
   end
 
   describe 'mark_retryable' do
     it 'marks the notification as retryable without persisting' do
-      store.should_receive(:mark_retryable).with(notification1, time, persist: false)
+      expect(store).to receive(:mark_retryable).with(notification1, time, persist: false)
       batch.mark_retryable(notification1, time)
     end
 
     it 'defers persisting' do
       batch.mark_retryable(notification1, time)
-      batch.retryable.should eq(time => [notification1])
+      expect(batch.retryable).to eq(time => [notification1])
     end
   end
 
   describe 'complete' do
     before do
-      Rpush.stub(logger: double.as_null_object)
-      batch.stub(:reflect)
+      allow(Rpush).to receive_messages(logger: double.as_null_object)
+      allow(batch).to receive(:reflect)
     end
 
     it 'identifies as complete' do
       expect do
         2.times { batch.notification_processed }
-      end.to change(batch, :complete?).to(be_true)
+      end.to change(batch, :complete?).to(true)
     end
 
     it 'reflects errors raised during completion' do
       e = StandardError.new
-      batch.stub(:complete_delivered).and_raise(e)
-      batch.should_receive(:reflect).with(:error, e)
+      allow(batch).to receive(:complete_delivered).and_raise(e)
+      expect(batch).to receive(:reflect).with(:error, e)
       2.times { batch.notification_processed }
     end
 
@@ -115,13 +115,13 @@ describe Rpush::Daemon::Batch do
       end
 
       it 'marks the batch as delivered' do
-        store.should_receive(:mark_batch_delivered).with([notification1, notification2])
+        expect(store).to receive(:mark_batch_delivered).with([notification1, notification2])
         complete
       end
 
       it 'reflects the notifications were delivered' do
-        batch.should_receive(:reflect).with(:notification_delivered, notification1)
-        batch.should_receive(:reflect).with(:notification_delivered, notification2)
+        expect(batch).to receive(:reflect).with(:notification_delivered, notification1)
+        expect(batch).to receive(:reflect).with(:notification_delivered, notification2)
         complete
       end
     end
@@ -135,13 +135,13 @@ describe Rpush::Daemon::Batch do
       end
 
       it 'marks the batch as failed' do
-        store.should_receive(:mark_batch_failed).with([notification1, notification2], 1, 'an error')
+        expect(store).to receive(:mark_batch_failed).with([notification1, notification2], 1, 'an error')
         complete
       end
 
       it 'reflects the notifications failed' do
-        batch.should_receive(:reflect).with(:notification_failed, notification1)
-        batch.should_receive(:reflect).with(:notification_failed, notification2)
+        expect(batch).to receive(:reflect).with(:notification_failed, notification1)
+        expect(batch).to receive(:reflect).with(:notification_failed, notification2)
         complete
       end
     end
@@ -155,13 +155,13 @@ describe Rpush::Daemon::Batch do
       end
 
       it 'marks the batch as retryable' do
-        store.should_receive(:mark_batch_retryable).with([notification1, notification2], time)
+        expect(store).to receive(:mark_batch_retryable).with([notification1, notification2], time)
         complete
       end
 
       it 'reflects the notifications will be retried' do
-        batch.should_receive(:reflect).with(:notification_will_retry, notification1)
-        batch.should_receive(:reflect).with(:notification_will_retry, notification2)
+        expect(batch).to receive(:reflect).with(:notification_will_retry, notification1)
+        expect(batch).to receive(:reflect).with(:notification_will_retry, notification2)
         complete
       end
     end

data/spec/unit/daemon/delivery_error_spec.rb

@@ -4,10 +4,10 @@ describe Rpush::DeliveryError do
   let(:error) { Rpush::DeliveryError.new(4, 12, "Missing payload") }
 
   it "returns an informative message" do
-    error.to_s.should eq "Unable to deliver notification 12, received error 4 (Missing payload)"
+    expect(error.to_s).to eq "Unable to deliver notification 12, received error 4 (Missing payload)"
   end
 
   it "returns the error code" do
-    error.code.should eq 4
+    expect(error.code).to eq 4
   end
 end