rpush 1.0.0-java

data/spec/unit/daemon/app_runner_spec.rb

@@ -0,0 +1,292 @@
+require 'unit_spec_helper'
+
+module Rpush
+  module AppRunnerSpecService
+    class App < Rpush::App
+    end
+  end
+
+  module Daemon
+    module AppRunnerSpecService
+      extend ServiceConfigMethods
+
+      class ServiceLoop
+        def initialize(app)
+        end
+
+        def start
+        end
+
+        def stop
+        end
+      end
+
+      dispatcher :http
+      loops ServiceLoop
+
+      class Delivery
+      end
+    end
+  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) }
+
+  before do
+    Rpush.stub(:logger => logger)
+    Rpush::Daemon::AppRunner.runners[1] = runner
+  end
+
+  after { Rpush::Daemon::AppRunner.runners.clear }
+
+  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])
+  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])
+  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 }
+
+  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
+  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.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
+  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) }
+
+  before do
+    Rpush::App.stub(:all => [app])
+    Rpush::Daemon.stub(:config => {})
+    Rpush.stub(:logger => logger)
+    Rpush::Daemon::AppRunner.sync
+  end
+
+  after { Rpush::Daemon::AppRunner.runners.clear }
+
+  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::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(:runner) { Rpush::Daemon::AppRunner.new(app) }
+  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(:store) { double(Rpush::Daemon::Store::ActiveRecord, release_connection: nil) }
+
+  before do
+    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)
+  end
+
+  describe 'start' do
+    it 'starts a delivery dispatcher for each connection' do
+      app.stub(:connections => 2)
+      runner.start
+      runner.num_dispatchers.should eq 2
+    end
+
+    it 'starts the loops' do
+      service_loop.should_receive(:start)
+      runner.start
+    end
+  end
+
+  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)
+    end
+
+    it 'reflects the notification has been enqueued' do
+      runner.should_receive(:reflect).with(:notification_enqueued, notification)
+      runner.enqueue(batch)
+    end
+  end
+
+  describe 'stop' do
+    before { runner.start }
+
+    it 'stops the delivery dispatchers' do
+      dispatcher_loop_collection.should_receive(:stop)
+      runner.stop
+    end
+
+    it 'stop the loops' do
+      service_loop.should_receive(:stop)
+      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

data/spec/unit/daemon/batch_spec.rb

@@ -0,0 +1,232 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Batch do
+  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
+  end
+
+  it 'exposes the number notifications processed' do
+    batch.num_processed.should eq 0
+  end
+
+  it 'increments the processed notifications count' do
+    expect { batch.notification_dispatched }.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'
+  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
+    end
+
+    describe 'batching is enabled' do
+      before { Rpush.config.batch_storage_updates = true }
+
+      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
+
+      it 'defers persisting' do
+        batch.mark_delivered(notification1)
+        batch.delivered.should eq [notification1]
+      end
+    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
+    end
+
+    describe 'batching is enabled' do
+      before { Rpush.config.batch_storage_updates = true }
+
+      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
+
+      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
+    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
+    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
+    end
+  end
+
+  describe 'complete' do
+    before do
+      Rpush.config.batch_storage_updates = true
+      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 }
+      end.to change(batch, :complete?).to(be_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)
+      2.times { batch.notification_dispatched }
+    end
+
+    describe 'delivered' do
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_delivered(n)
+          batch.notification_dispatched
+        end
+      end
+
+      it 'marks the batch as delivered' do
+        store.should_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)
+        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
+        end
+      end
+
+      it 'marks the batch as failed' do
+        store.should_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)
+        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
+        end
+      end
+
+      it 'marks the batch as retryable' do
+        store.should_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)
+        complete
+      end
+
+      it 'clears the retryable notifications' do
+        complete
+        batch.retryable.should eq({})
+      end
+    end
+  end
+end

data/spec/unit/daemon/delivery_error_spec.rb

@@ -0,0 +1,13 @@
+require "unit_spec_helper"
+
+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)"
+  end
+
+  it "returns the error code" do
+    error.code.should eq 4
+  end
+end

data/spec/unit/daemon/delivery_spec.rb

@@ -0,0 +1,38 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Delivery do
+
+  class DeliverySpecDelivery < Rpush::Daemon::Delivery
+    def initialize(batch)
+      @batch = batch
+    end
+  end
+
+  let(:now) { Time.parse("2014-10-14 00:00:00") }
+  let(:batch) { double(Rpush::Daemon::Batch) }
+  let(:delivery) { DeliverySpecDelivery.new(batch) }
+  let(:notification) { Rpush::Apns::Notification.new }
+
+  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
+      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)
+      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)
+      notification.fail_after = Time.now + 1.hour
+      delivery.mark_retryable(notification, Time.now + 1.hour)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Dispatcher::Http do
+  let(:app) { double }
+  let(:delivery_class) { double }
+  let(:notification) { double }
+  let(:batch) { double }
+  let(:http) { double }
+  let(:dispatcher) { Rpush::Daemon::Dispatcher::Http.new(app, delivery_class) }
+
+  before { Net::HTTP::Persistent.stub(:new => http) }
+
+  it 'constructs a new persistent connection' do
+    Net::HTTP::Persistent.should_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)
+      dispatcher.dispatch(notification, batch)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      http.should_receive(:shutdown)
+      dispatcher.cleanup
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+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(:notification) { double }
+  let(:batch) { double }
+  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) }
+
+  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)
+    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)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      dispatcher.dispatch(notification, batch) # lazily initialize connection
+      connection.should_receive(:close)
+      dispatcher.cleanup
+    end
+  end
+end

data/spec/unit/daemon/dispatcher_loop_collection_spec.rb

@@ -0,0 +1,37 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::DispatcherLoopCollection do
+  let(:dispatcher_loop) { double.as_null_object }
+  let(:collection) { Rpush::Daemon::DispatcherLoopCollection.new }
+
+  it 'returns the size of the collection' do
+    collection.push(dispatcher_loop)
+    collection.size.should eq 1
+  end
+
+  it 'pops a dispatcher loop from the collection' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop.should_receive(:stop)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop.should_receive(:wait)
+    collection.pop
+    collection.size.should eq 0
+  end
+
+  it 'wakes up all dispatcher loops when popping a single dispatcher_loop' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop2 = double.as_null_object
+    collection.push(dispatcher_loop2)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop2.should_receive(:wakeup)
+    collection.pop
+  end
+
+  it 'stops all dispatcher  detetcloops' do
+    collection.push(dispatcher_loop)
+    dispatcher_loop.should_receive(:stop)
+    dispatcher_loop.should_receive(:wakeup)
+    dispatcher_loop.should_receive(:wait)
+    collection.stop
+  end
+end