rpush 1.0.0-java → 2.0.0-java

data/spec/unit/daemon/batch_spec.rb

@@ -1,23 +1,15 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Batch do
-  let(:notification1) { double(:notification1, :id => 1) }
-  let(:notification2) { double(:notification2, :id => 2) }
+  let(:notification1) { double(:notification1, id: 1) }
+  let(:notification2) { double(:notification2, id: 2) }
   let(:batch) { Rpush::Daemon::Batch.new([notification1, notification2]) }
   let(:store) { double.as_null_object }
   let(:time) { Time.now }
 
   before do
-    Time.stub(:now => time)
-    Rpush::Daemon.stub(:store => store)
-  end
-
-  it 'exposes the notifications' do
-    batch.notifications.should eq [notification1, notification2]
-  end
-
-  it 'exposes the number notifications' do
-    batch.num_notifications.should eq 2
+    Time.stub(now: time)
+    Rpush::Daemon.stub(store: store)
   end
 
   it 'exposes the number notifications processed' do
@@ -25,125 +17,85 @@ describe Rpush::Daemon::Batch do
   end
 
   it 'increments the processed notifications count' do
-    expect { batch.notification_dispatched }.to change(batch, :num_processed).to(1)
+    expect { batch.notification_processed }.to change(batch, :num_processed).to(1)
   end
 
   it 'completes the batch when all notifications have been processed' do
     batch.should_receive(:complete)
-    2.times { batch.notification_dispatched }
-  end
-
-  it 'can be described' do
-    batch.describe.should eq '1, 2'
+    2.times { batch.notification_processed }
   end
 
   describe 'mark_delivered' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as delivered immediately' do
-        store.should_receive(:mark_delivered).with(notification1, time)
-        batch.mark_delivered(notification1)
-      end
-
-      it 'reflects the notification was delivered' do
-        batch.should_receive(:reflect).with(:notification_delivered, notification1)
-        batch.mark_delivered(notification1)
-      end
+    it 'marks the notification as delivered immediately without persisting' do
+      store.should_receive(:mark_delivered).with(notification1, time, persist: false)
+      batch.mark_delivered(notification1)
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
+    it 'defers persisting' do
+      batch.mark_delivered(notification1)
+      batch.delivered.should eq [notification1]
+    end
+  end
 
-      it 'marks the notification as delivered immediately without persisting' do
-        store.should_receive(:mark_delivered).with(notification1, time, :persist => false)
-        batch.mark_delivered(notification1)
-      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)
+      batch.mark_all_delivered
+    end
 
-      it 'defers persisting' do
-        batch.mark_delivered(notification1)
-        batch.delivered.should eq [notification1]
-      end
+    it 'defers persisting' do
+      batch.mark_all_delivered
+      batch.delivered.should eq [notification1, notification2]
     end
   end
 
   describe 'mark_failed' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as failed' do
-        store.should_receive(:mark_failed).with(notification1, 1, 'an error', time)
-        batch.mark_failed(notification1, 1, 'an error')
-      end
-
-      it 'reflects the notification failed' do
-        batch.should_receive(:reflect).with(:notification_delivered, notification1)
-        batch.mark_delivered(notification1)
-      end
+    it 'marks the notification as failed without persisting' do
+      store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)
+      batch.mark_failed(notification1, 1, 'an error')
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
+    it 'defers persisting' do
+      batch.mark_failed(notification1, 1, 'an error')
+      batch.failed.should eq([1, 'an error'] => [notification1])
+    end
+  end
 
-      it 'marks the notification as failed without persisting' do
-        store.should_receive(:mark_failed).with(notification1, 1, 'an error', time, :persist => false)
-        batch.mark_failed(notification1, 1, 'an error')
-      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)
+      batch.mark_all_failed(1, 'an error')
+    end
 
-      it 'defers persisting' do
-        Rpush.config.batch_storage_updates = true
-        batch.mark_failed(notification1, 1, 'an error')
-        batch.failed.should eq({[1, 'an error'] => [notification1]})
-      end
+    it 'defers persisting' do
+      batch.mark_all_failed(1, 'an error')
+      batch.failed.should eq([1, 'an error'] => [notification1, notification2])
     end
   end
 
   describe 'mark_retryable' do
-    describe 'batching is disabled' do
-      before { Rpush.config.batch_storage_updates = false }
-
-      it 'marks the notification as retryable' do
-        store.should_receive(:mark_retryable).with(notification1, time)
-        batch.mark_retryable(notification1, time)
-      end
-
-      it 'reflects the notification will be retried' do
-        batch.should_receive(:reflect).with(:notification_will_retry, notification1)
-        batch.mark_retryable(notification1, time)
-      end
+    it 'marks the notification as retryable without persisting' do
+      store.should_receive(:mark_retryable).with(notification1, time, persist: false)
+      batch.mark_retryable(notification1, time)
     end
 
-    describe 'batching is enabled' do
-      before { Rpush.config.batch_storage_updates = true }
-
-      it 'marks the notification as retryable without persisting' do
-        store.should_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]})
-      end
+    it 'defers persisting' do
+      batch.mark_retryable(notification1, time)
+      batch.retryable.should eq(time => [notification1])
     end
   end
 
   describe 'complete' do
     before do
-      Rpush.config.batch_storage_updates = true
-      Rpush.stub(:logger => double.as_null_object)
+      Rpush.stub(logger: double.as_null_object)
       batch.stub(:reflect)
     end
 
-    it 'clears the notifications' do
-      expect do
-        2.times { batch.notification_dispatched }
-      end.to change(batch, :notifications).to([])
-    end
-
     it 'identifies as complete' do
       expect do
-        2.times { batch.notification_dispatched }
+        2.times { batch.notification_processed }
       end.to change(batch, :complete?).to(be_true)
     end
 
@@ -151,14 +103,14 @@ describe Rpush::Daemon::Batch do
       e = StandardError.new
       batch.stub(:complete_delivered).and_raise(e)
       batch.should_receive(:reflect).with(:error, e)
-      2.times { batch.notification_dispatched }
+      2.times { batch.notification_processed }
     end
 
     describe 'delivered' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_delivered(n)
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -172,18 +124,13 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_delivered, notification2)
         complete
       end
-
-      it 'clears the delivered notifications' do
-        complete
-        batch.delivered.should eq([])
-      end
     end
 
     describe 'failed' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_failed(n, 1, 'an error')
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -197,18 +144,13 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_failed, notification2)
         complete
       end
-
-      it 'clears the failed notifications' do
-        complete
-        batch.failed.should eq({})
-      end
     end
 
     describe 'retryable' do
       def complete
         [notification1, notification2].each do |n|
           batch.mark_retryable(n, time)
-          batch.notification_dispatched
+          batch.notification_processed
         end
       end
 
@@ -222,11 +164,6 @@ describe Rpush::Daemon::Batch do
         batch.should_receive(:reflect).with(:notification_will_retry, notification2)
         complete
       end
-
-      it 'clears the retryable notifications' do
-        complete
-        batch.retryable.should eq({})
-      end
     end
   end
 end

data/spec/unit/daemon/delivery_spec.rb

@@ -16,7 +16,6 @@ describe Rpush::Daemon::Delivery do
   before { Time.stub(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.")
       notification.fail_after = Time.now - 1.hour
@@ -35,4 +34,19 @@ describe Rpush::Daemon::Delivery do
       delivery.mark_retryable(notification, Time.now + 1.hour)
     end
   end
+
+  describe 'mark_batch_delivered' do
+    it 'marks all notifications as delivered' do
+      batch.should_receive(:mark_all_delivered)
+      delivery.mark_batch_delivered
+    end
+  end
+
+  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)')
+      delivery.mark_batch_failed(error)
+    end
+  end
 end

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

@@ -6,9 +6,10 @@ describe Rpush::Daemon::Dispatcher::Http do
   let(:notification) { double }
   let(:batch) { double }
   let(:http) { double }
+  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 { Net::HTTP::Persistent.stub(new: http) }
 
   it 'constructs a new persistent connection' do
     Net::HTTP::Persistent.should_receive(:new)
@@ -20,7 +21,7 @@ describe Rpush::Daemon::Dispatcher::Http do
       delivery = double
       delivery_class.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
       delivery.should_receive(:perform)
-      dispatcher.dispatch(notification, batch)
+      dispatcher.dispatch(queue_payload)
     end
   end
 

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

@@ -2,35 +2,36 @@ require 'unit_spec_helper'
 
 describe Rpush::Daemon::Dispatcher::Tcp do
   let(:app) { double }
-  let(:delivery) { double(:perform => nil) }
-  let(:delivery_class) { double(:new => delivery) }
+  let(:delivery) { double(perform: nil) }
+  let(:delivery_class) { double(new: delivery) }
   let(:notification) { double }
   let(:batch) { double }
-  let(:connection) { double(Rpush::Daemon::TcpConnection, :connect => nil) }
+  let(:connection) { double(Rpush::Daemon::TcpConnection, connect: nil) }
   let(:host) { 'localhost' }
   let(:port) { 1234 }
-  let(:host_proc) { Proc.new { |app| [host, port] } }
-  let(:dispatcher) { Rpush::Daemon::Dispatcher::Tcp.new(app, delivery_class, :host => host_proc) }
+  let(:host_proc) { proc { [host, port] } }
+  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 { Rpush::Daemon::TcpConnection.stub(new: connection) }
 
   describe 'dispatch' do
     it 'lazily connects the socket' do
       Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port).and_return(connection)
       connection.should_receive(:connect)
-      dispatcher.dispatch(notification, batch)
+      dispatcher.dispatch(queue_payload)
     end
 
     it 'delivers the notification' do
       delivery_class.should_receive(:new).with(app, connection, notification, batch).and_return(delivery)
       delivery.should_receive(:perform)
-      dispatcher.dispatch(notification, batch)
+      dispatcher.dispatch(queue_payload)
     end
   end
 
   describe 'cleanup' do
     it 'closes the connection' do
-      dispatcher.dispatch(notification, batch) # lazily initialize connection
+      dispatcher.dispatch(queue_payload) # lazily initialize connection
       connection.should_receive(:close)
       dispatcher.cleanup
     end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -4,25 +4,23 @@ describe Rpush::Daemon::DispatcherLoop do
   def run_dispatcher_loop
     dispatcher_loop.start
     dispatcher_loop.stop
-    dispatcher_loop.wakeup
-    dispatcher_loop.wait
   end
 
   let(:notification) { double }
-  let(:batch) { double(:notification_dispatched => nil) }
+  let(:batch) { double(notification_processed: nil) }
   let(:queue) { Queue.new }
-  let(:dispatcher) { double(:dispatch => nil, :cleanup => nil) }
+  let(:dispatcher) { double(dispatch: nil, cleanup: nil) }
   let(:dispatcher_loop) { Rpush::Daemon::DispatcherLoop.new(queue, dispatcher) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil)}
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
 
   before do
-    Rpush::Daemon.stub(:store => store)
+    Rpush::Daemon.stub(store: store)
     queue.push([notification, batch])
   end
 
   it 'logs errors' do
     logger = double
-    Rpush.stub(:logger => logger)
+    Rpush.stub(logger: logger)
     error = StandardError.new
     dispatcher.stub(:dispatch).and_raise(error)
     Rpush.logger.should_receive(:error).with(error)
@@ -30,32 +28,16 @@ describe Rpush::Daemon::DispatcherLoop do
   end
 
   it 'reflects an exception' do
-    Rpush.stub(:logger => double(:error => nil))
+    Rpush.stub(logger: double(error: nil))
     error = StandardError.new
     dispatcher.stub(:dispatch).and_raise(error)
     dispatcher_loop.should_receive(:reflect).with(:error, error)
     run_dispatcher_loop
   end
 
-  it 'instructs the batch that the notification has been processed' do
-    batch.should_receive(:notification_dispatched)
-    run_dispatcher_loop
-  end
-
-  it "instructs the queue to wakeup the thread when told to stop" do
-    queue.should_receive(:push).with(Rpush::Daemon::DispatcherLoop::WAKEUP).and_call_original
-    run_dispatcher_loop
-  end
-
   describe 'stop' do
     before do
       queue.clear
-      queue.push(Rpush::Daemon::DispatcherLoop::WAKEUP)
-    end
-
-    it 'does not attempt to dispatch when a WAKEUP is dequeued' do
-      dispatcher.should_not_receive(:dispatch)
-      run_dispatcher_loop
     end
 
     it 'instructs the dispatcher to cleanup' do

data/spec/unit/daemon/feeder_spec.rb

@@ -1,25 +1,23 @@
 require "unit_spec_helper"
 
 describe Rpush::Daemon::Feeder do
-  let(:config) { double(:batch_size => 5000,
-                        :push_poll => 0,
-                        :embedded => false,
-                        :push => false,
-                        :wakeup => nil) }
-  let!(:app) { Rpush::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
-  let(:notification) { Rpush::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
+  let!(:app) { Rpush::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Apns::Notification.create!(device_token: "a" * 64, app: app) }
   let(:logger) { double }
-  let(:interruptible_sleep) { double(:sleep => nil, :interrupt_sleep => nil) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord,
-      deliverable_notifications: [notification], release_connection: nil) }
+  let(:interruptible_sleeper) { double(sleep: nil, stop: nil, start: nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, deliverable_notifications: [notification], release_connection: nil) }
 
   before do
-    Rpush.stub(:config => config,:logger => logger)
-    Rpush::Daemon.stub(:store => store)
-    Rpush::Daemon::Feeder.stub(:stop? => true)
-    Rpush::Daemon::AppRunner.stub(:enqueue => nil, :idle => [double(:app => app)])
-    Rpush::Daemon::InterruptibleSleep.stub(:new => interruptible_sleep)
-    Rpush::Daemon::Feeder.instance_variable_set('@interruptible_sleeper', nil)
+    Rpush.configure do |config|
+      config.batch_size = 5000
+      config.push_poll = 0
+      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)
   end
 
   def start_and_stop
@@ -27,26 +25,26 @@ describe Rpush::Daemon::Feeder do
     Rpush::Daemon::Feeder.stop
   end
 
-  it 'starts the loop in a new thread if embedded' do
-    config.stub(:embedded => true)
-    Thread.should_receive(:new).and_yield
-    Rpush::Daemon::Feeder.should_receive(:feed_forever)
+  it 'loads deliverable notifications' do
+    Rpush::Daemon.store.should_receive(:deliverable_notifications).with(Rpush.config.batch_size)
     start_and_stop
   end
 
-  it 'loads deliverable notifications' do
-    Rpush::Daemon.store.should_receive(:deliverable_notifications).with([app])
+  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)
     start_and_stop
   end
 
-  it 'does not attempt to load deliverable notifications if there are no idle runners' do
-    Rpush::Daemon::AppRunner.stub(:idle => [])
-    Rpush::Daemon.store.should_not_receive(:deliverable_notifications)
+  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)
     start_and_stop
   end
 
   it 'enqueues notifications without looping if in push mode' do
-    config.stub(:push => true)
+    Rpush.config.push = true
     Rpush::Daemon::Feeder.should_not_receive(:feed_forever)
     Rpush::Daemon::Feeder.should_receive(:enqueue_notifications)
     start_and_stop
@@ -65,34 +63,35 @@ describe Rpush::Daemon::Feeder do
   end
 
   describe 'stop' do
-    it 'interrupts sleep when stopped' do
-      Rpush::Daemon::Feeder.should_receive(:interrupt_sleep)
+    it 'interrupts sleep' do
+      interruptible_sleeper.should_receive(:stop)
       start_and_stop
     end
 
-    it 'releases the store connection when stopped' do
+    it 'releases the store connection' do
       Rpush::Daemon.store.should_receive(:release_connection)
       start_and_stop
     end
   end
 
-  it "enqueues notifications when started" do
+  it 'enqueues notifications when started' do
     Rpush::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
     Rpush::Daemon::Feeder.stub(:loop).and_yield
     start_and_stop
   end
 
-  it "sleeps for the given period" do
-    config.stub(:push_poll => 2)
-    interruptible_sleep.should_receive(:sleep).with(2)
+  it 'sleeps' do
+    interruptible_sleeper.should_receive(:sleep)
     start_and_stop
   end
 
-  it "creates the wakeup socket" do
-    bind = '127.0.0.1'
-    port = 12345
-    config.stub(:wakeup => { :bind => bind, :port => port})
-    interruptible_sleep.should_receive(:enable_wake_on_udp).with(bind, port)
-    start_and_stop
+  describe 'wakeup' do
+    it 'interrupts sleep' do
+      interruptible_sleeper.should_receive(:wakeup)
+      Rpush::Daemon::Feeder.start
+      Rpush::Daemon::Feeder.wakeup
+    end
+
+    after { Rpush::Daemon::Feeder.stop }
   end
 end