rpush 1.0.0-java → 2.0.0-java

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

@@ -1,4 +1,5 @@
-require "unit_spec_helper"
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
 
 describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
 
@@ -7,35 +8,39 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   let(:poll) { 60 }
   let(:certificate) { double }
   let(:password) { double }
-  let(:app) { double(:name => 'my_app', :password => password, :certificate => certificate, :environment => 'production') }
-  let(:connection) { double(:connect => nil, :read => nil, :close => nil) }
-  let(:logger) { double(:error => nil, :info => nil) }
+  let(:app) { double(name: 'my_app', password: password, certificate: certificate, environment: 'production') }
+  let(:connection) { double(connect: nil, read: nil, close: nil) }
+  let(:logger) { double(error: nil, info: nil) }
   let(:receiver) { Rpush::Daemon::Apns::FeedbackReceiver.new(app) }
   let(:feedback) { double }
-  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, :sleep => nil, :interrupt_sleep => nil) }
-  let(:store) { double(Rpush::Daemon::Store::ActiveRecord,
-    create_apns_feedback: feedback, release_connection: nil) }
+  let(:sleeper) { double(Rpush::Daemon::InterruptibleSleep, sleep: nil, start: nil, stop: nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, create_apns_feedback: feedback, release_connection: nil) }
 
   before do
     Rpush.config.feedback_poll = poll
-    Rpush::Daemon::InterruptibleSleep.stub(:new => sleeper)
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::TcpConnection.stub(:new => connection)
+    Rpush::Daemon::InterruptibleSleep.stub(new: sleeper)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::TcpConnection.stub(new: connection)
     receiver.instance_variable_set("@stop", false)
-    Rpush::Daemon.stub(:store => store)
+    Rpush::Daemon.stub(store: store)
   end
 
   def double_connection_read_with_tuple
     connection.unstub(:read)
 
-    def connection.read(bytes)
-      if !@called
+    def connection.read(*)
+      unless @called
         @called = true
         "N\xE3\x84\r\x00 \x83OxfU\xEB\x9F\x84aJ\x05\xAD}\x00\xAF1\xE5\xCF\xE9:\xC3\xEA\a\x8F\x1D\xA4M*N\xB0\xCE\x17"
       end
     end
   end
 
+  it 'initializes the sleeper with the feedback polling duration' do
+    Rpush::Daemon::InterruptibleSleep.should_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)
     receiver.check_for_feedback
@@ -63,7 +68,7 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'creates the feedback' do
-    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
+    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1_323_533_325), '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', app)
     double_connection_read_with_tuple
     receiver.check_for_feedback
   end
@@ -81,9 +86,9 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
       receiver.stub(:loop).and_yield
     end
 
-    it 'sleeps for the feedback poll period' do
+    it 'sleeps' do
       receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:sleep).with(60).at_least(:once)
+      sleeper.should_receive(:sleep).at_least(:once)
       receiver.start
     end
 
@@ -96,7 +101,7 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   describe 'stop' do
     it 'interrupts sleep when stopped' do
       receiver.stub(:check_for_feedback)
-      sleeper.should_receive(:interrupt_sleep)
+      sleeper.should_receive(:stop)
       receiver.stop
     end
 

data/spec/unit/daemon/app_runner_spec.rb

@@ -1,4 +1,5 @@
 require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
 
 module Rpush
   module AppRunnerSpecService
@@ -11,7 +12,7 @@ module Rpush
       extend ServiceConfigMethods
 
       class ServiceLoop
-        def initialize(app)
+        def initialize(*)
         end
 
         def start
@@ -30,198 +31,104 @@ module Rpush
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'stop' do
-  let(:runner) { double }
-  before { Rpush::Daemon::AppRunner.runners['app'] = runner }
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'stops all runners' do
-    runner.should_receive(:stop)
-    Rpush::Daemon::AppRunner.stop
-  end
-end
-
 describe Rpush::Daemon::AppRunner, 'enqueue' do
-  let(:runner) { double(:enqueue => nil) }
-  let(:notification1) { double(:app_id => 1) }
-  let(:notification2) { double(:app_id => 2) }
-  let(:logger) { double(Rpush::Logger, :error => nil) }
+  let(:app) { double(id: 1, name: 'Test', connections: 1) }
+  let(:notification) { double(app_id: 1) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.runners[1] = runner
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::ProcTitle.stub(:update)
+    Rpush::Daemon::AppRunner.stub(new: runner)
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 
-  after { Rpush::Daemon::AppRunner.runners.clear }
+  after { Rpush::Daemon::AppRunner.stop }
 
-  it 'batches notifications by app' do
-    batch = double.as_null_object
-    Rpush::Daemon::Batch.stub(:new => batch)
-    Rpush::Daemon::Batch.should_receive(:new).with([notification1])
-    Rpush::Daemon::Batch.should_receive(:new).with([notification2])
-    Rpush::Daemon::AppRunner.enqueue([notification1, notification2])
+  it 'enqueues notifications on the runner' do
+    runner.should_receive(:enqueue).with([notification])
+    Rpush::Daemon::AppRunner.enqueue([notification])
   end
 
-  it 'enqueues each batch' do
-    runner.should_receive(:enqueue).with(kind_of(Rpush::Daemon::Batch))
-    Rpush::Daemon::AppRunner.enqueue([notification1])
-  end
-
-  it 'logs an error if there is no runner to deliver the notification' do
-    notification1.stub(:app_id => 2, :id => 123)
-    notification2.stub(:app_id => 2, :id => 456)
-    logger.should_receive(:error).with("No such app '#{notification1.app_id}' for notifications 123, 456.")
-    Rpush::Daemon::AppRunner.enqueue([notification1, notification2])
+  it 'starts the app if a runner does not exist' do
+    notification = double(app_id: 3)
+    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
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'sync' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :name => 'test') }
-  let(:new_app) { double(Rpush::AppRunnerSpecService::App, :name => 'new_test') }
-  let(:runner) { double(:sync => nil, :stop => nil, :start => nil) }
-  let(:logger) { double(Rpush::Logger, :error => nil, :warn => nil) }
-  let(:queue) { Queue.new }
+describe Rpush::Daemon::AppRunner, 'start_app' do
+  let(:app) { double(id: 1, name: 'test') }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start: nil, stop: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
 
   before do
-    app.stub(:id => 1)
-    new_app.stub(:id => 2)
-    Queue.stub(:new => queue)
-    Rpush::Daemon::AppRunner.runners[app.id] = runner
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'loads all apps' do
-    Rpush::App.should_receive(:all)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'instructs existing runners to sync' do
-    runner.should_receive(:sync).with(app)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'starts a runner for a new app' do
-    Rpush::App.stub(:all => [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    new_runner.should_receive(:start)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'deletes old runners' do
-    Rpush::App.stub(:all => [])
-    runner.should_receive(:stop)
-    Rpush::Daemon::AppRunner.sync
+    Rpush.stub(logger: logger)
   end
 
   it 'logs an error if the runner could not be started' do
-    Rpush::App.stub(:all => [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    new_runner.stub(:start).and_raise(StandardError)
+    Rpush::Daemon::AppRunner.should_receive(:new).with(app).and_return(runner)
+    runner.stub(:start).and_raise(StandardError)
     Rpush.logger.should_receive(:error)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  it 'reflects errors if the runner could not be started' do
-    Rpush::App.stub(:all => [app, new_app])
-    new_runner = double
-    Rpush::Daemon::AppRunner.should_receive(:new).with(new_app).and_return(new_runner)
-    e = StandardError.new
-    new_runner.stub(:start).and_raise(e)
-    Rpush::Daemon::AppRunner.should_receive(:reflect).with(:error, e)
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 end
 
 describe Rpush::Daemon::AppRunner, 'debug' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :id => 1, :name => 'test', :connections => 1,
-    :environment => 'development', :certificate => TEST_CERT, :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
+  let(:app) do
+    double(Rpush::AppRunnerSpecService::App, id: 1, name: 'test', connections: 1,
+      environment: 'development', certificate: TEST_CERT, service_name: 'app_runner_spec_service')
+  end
+  let(:logger) { double(Rpush::Logger, info: nil) }
+  let(:store) { double(all_apps: [app], release_connection: nil) }
 
   before do
-    Rpush::App.stub(:all => [app])
-    Rpush::Daemon.stub(:config => {})
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.sync
+    Rpush::Daemon.stub(config: {}, store: store)
+    Rpush.stub(logger: logger)
+    Rpush::Daemon::AppRunner.start_app(app)
   end
 
-  after { Rpush::Daemon::AppRunner.runners.clear }
+  after { Rpush::Daemon::AppRunner.stop_app(app.id) }
 
   it 'prints debug app states to the log' do
-    Rpush.logger.should_receive(:info).with("\ntest:\n  dispatchers: 1\n  queued: 0\n  batch size: 0\n  batch processed: 0\n  idle: true\n")
+    Rpush.logger.should_receive(:info).with(kind_of(String))
     Rpush::Daemon::AppRunner.debug
   end
 end
 
-describe Rpush::Daemon::AppRunner, 'idle' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :name => 'test', :connections => 1,
-    :environment => 'development', :certificate => TEST_CERT, :id => 1,
-    :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
-
-  before do
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'returns idle runners' do
-    runner = Rpush::Daemon::AppRunner.runners[app.id]
-    Rpush::Daemon::AppRunner.idle.should eq [runner]
-  end
-end
-
-describe Rpush::Daemon::AppRunner, 'wait' do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :id => 1, :name => 'test',
-    :connections => 1, :environment => 'development', :certificate => TEST_CERT,
-    :service_name => 'app_runner_spec_service') }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
-
-  before do
-    Rpush::App.stub(:all => [app])
-    Rpush.stub(:logger => logger)
-    Rpush::Daemon::AppRunner.sync
-  end
-
-  after { Rpush::Daemon::AppRunner.runners.clear }
-
-  it 'waits until all runners are idle' do
-    Rpush::Daemon::AppRunner.runners.count.should eq 1
-    Timeout.timeout(5) { Rpush::Daemon::AppRunner.wait }
-  end
-end
-
 describe Rpush::Daemon::AppRunner do
-  let(:app) { double(Rpush::AppRunnerSpecService::App, :environment => :sandbox,
-    :connections => 1, :service_name => 'app_runner_spec_service',
-    :name => 'test') }
+  let(:app) do
+    double(Rpush::AppRunnerSpecService::App, environment: :sandbox,
+      connections: 1, service_name: 'app_runner_spec_service', name: 'test')
+  end
   let(:runner) { Rpush::Daemon::AppRunner.new(app) }
-  let(:logger) { double(Rpush::Logger, :info => nil) }
+  let(:logger) { double(Rpush::Logger, info: nil) }
   let(:queue) { Queue.new }
-  let(:dispatcher_loop_collection) { Rpush::Daemon::DispatcherLoopCollection.new }
-  let(:service_loop) { double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop,
-    :start => nil, :stop => nil) }
+  let(:service_loop) { double(Rpush::Daemon::AppRunnerSpecService::ServiceLoop, start: nil, stop: nil) }
+  let(:dispatcher_loop) { double(Rpush::Daemon::DispatcherLoop, stop: nil, start: nil) }
   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)
-    Rpush::Daemon::DispatcherLoopCollection.stub(:new => dispatcher_loop_collection)
+    Rpush::Daemon::AppRunnerSpecService::ServiceLoop.stub(new: service_loop)
+    Queue.stub(new: queue)
+    Rpush.stub(logger: logger)
   end
 
   describe 'start' do
     it 'starts a delivery dispatcher for each connection' do
-      app.stub(:connections => 2)
+      app.stub(connections: 2)
+      runner.start
+      runner.num_dispatcher_loops.should eq 2
+    end
+
+    it 'starts the dispatcher loop' do
+      dispatcher_loop.should_receive(:start)
       runner.start
-      runner.num_dispatchers.should eq 2
     end
 
     it 'starts the loops' do
@@ -232,16 +139,32 @@ describe Rpush::Daemon::AppRunner do
 
   describe 'enqueue' do
     let(:notification) { double }
-    let(:batch) { double(:notifications => [notification]) }
 
     it 'enqueues the batch' do
-      queue.should_receive(:push).with([notification, batch])
-      runner.enqueue(batch)
+      queue.should_receive(:push) do |queue_payload|
+        queue_payload.notification.should eq notification
+        queue_payload.batch.should_not be_nil
+      end
+      runner.enqueue([notification])
     end
 
     it 'reflects the notification has been enqueued' do
       runner.should_receive(:reflect).with(:notification_enqueued, notification)
-      runner.enqueue(batch)
+      runner.enqueue([notification])
+    end
+
+    describe 'a service that batches deliveries' do
+      before do
+        runner.send(:service).stub(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)
+          runner.enqueue([notification])
+        end
+      end
     end
   end
 
@@ -249,7 +172,7 @@ describe Rpush::Daemon::AppRunner do
     before { runner.start }
 
     it 'stops the delivery dispatchers' do
-      dispatcher_loop_collection.should_receive(:stop)
+      dispatcher_loop.should_receive(:stop)
       runner.stop
     end
 
@@ -258,35 +181,4 @@ describe Rpush::Daemon::AppRunner do
       runner.stop
     end
   end
-
-  describe 'idle?' do
-    it 'is idle if all notifications have been processed' do
-      runner.batch = double(:complete? => true)
-      runner.idle?.should be_true
-    end
-
-    it 'is idle if the runner has no associated batch' do
-      runner.batch = nil
-      runner.idle?.should be_true
-    end
-
-    it 'is not idle if not all notifications have been processed' do
-      runner.batch = double(:complete? => false)
-      runner.idle?.should be_false
-    end
-  end
-
-  describe 'sync' do
-    before { runner.start }
-
-    it 'reduces the number of dispatchers if needed' do
-      app.stub(:connections => 0)
-      expect { runner.sync(app) }.to change(runner, :num_dispatchers).to(0)
-    end
-
-    it 'increases the number of dispatchers if needed' do
-      app.stub(:connections => 2)
-      expect { runner.sync(app) }.to change(runner, :num_dispatchers).to(2)
-    end
-  end
 end