rpush 1.0.0

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

@@ -0,0 +1,18 @@
+require 'unit_spec_helper'
+
+describe Rpush::Apns::DisconnectionError do
+  let(:error) { Rpush::Apns::DisconnectionError.new }
+
+  it 'returns a nil error code' do
+    error.code.should be_nil
+  end
+
+  it 'contains an error description' do
+    error.description
+  end
+
+  it 'returns a message' do
+    error.message
+    error.to_s
+  end
+end

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

@@ -0,0 +1,117 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
+
+  let(:host) { 'feedback.push.apple.com' }
+  let(:port) { 2196 }
+  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(: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) }
+
+  before do
+    Rpush.config.feedback_poll = poll
+    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)
+  end
+
+  def double_connection_read_with_tuple
+    connection.unstub(:read)
+
+    def connection.read(bytes)
+      if !@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 'instantiates a new connection' do
+    Rpush::Daemon::TcpConnection.should_receive(:new).with(app, host, port)
+    receiver.check_for_feedback
+  end
+
+  it 'connects to the feeback service' do
+    connection.should_receive(:connect)
+    receiver.check_for_feedback
+  end
+
+  it 'closes the connection' do
+    connection.should_receive(:close)
+    receiver.check_for_feedback
+  end
+
+  it 'reads from the connection' do
+    connection.should_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.")
+    receiver.check_for_feedback
+  end
+
+  it 'creates the feedback' do
+    Rpush::Daemon.store.should_receive(:create_apns_feedback).with(Time.at(1323533325), '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)
+    receiver.check_for_feedback
+  end
+
+  describe 'start' do
+    before do
+      Thread.stub(:new).and_yield
+      receiver.stub(:loop).and_yield
+    end
+
+    it 'sleeps for the feedback poll period' do
+      receiver.stub(:check_for_feedback)
+      sleeper.should_receive(:sleep).with(60).at_least(:once)
+      receiver.start
+    end
+
+    it 'checks for feedback when started' do
+      receiver.should_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(:interrupt_sleep)
+      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)
+      receiver.start
+      receiver.stop
+    end
+  end
+
+  it 'reflects feedback was received' do
+    double_connection_read_with_tuple
+    receiver.should_receive(:reflect).with(:apns_feedback, feedback)
+    receiver.check_for_feedback
+  end
+end

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