rpush_extended 3.2.5

data/spec/unit/daemon/app_runner_spec.rb

@@ -0,0 +1,188 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+module Rpush
+  module AppRunnerSpecService
+    class App < Rpush::App
+    end
+  end
+
+  module Daemon
+    module AppRunnerSpecService
+      extend ServiceConfigMethods
+
+      class ServiceLoop
+        def initialize(*)
+        end
+
+        def start
+        end
+
+        def stop
+        end
+      end
+
+      dispatcher :http
+      loops ServiceLoop
+
+      class Delivery
+      end
+    end
+  end
+end
+
+describe Rpush::Daemon::AppRunner, 'enqueue' do
+  let(:app) { double(id: 1, name: 'Test', connections: 1) }
+  let(:notification) { double(app_id: 1) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start_dispatchers: nil, start_loops: nil, stop: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
+
+  before do
+    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
+    expect(runner).to receive(:enqueue).with([notification])
+    Rpush::Daemon::AppRunner.enqueue([notification])
+  end
+
+  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])
+    expect(Rpush::Daemon::AppRunner.app_running?(new_app)).to eq(true)
+  end
+end
+
+describe Rpush::Daemon::AppRunner, 'start_app' do
+  let(:app) { double(id: 1, name: 'test', connections: 1) }
+  let(:runner) { double(Rpush::Daemon::AppRunner, enqueue: nil, start_dispatchers: nil, stop: nil) }
+  let(:logger) { double(Rpush::Logger, error: nil, info: nil) }
+
+  before do
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  it 'logs an error if the runner could not be started' do
+    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
+
+describe Rpush::Daemon::AppRunner, 'debug' do
+  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
+    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 'returns the app runner status' do
+    expect(Rpush::Daemon::AppRunner.status.key?(:app_runners)).to eq(true)
+  end
+end
+
+describe Rpush::Daemon::AppRunner do
+  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(:queue) { Queue.new }
+  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
+    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
+      allow(app).to receive_messages(connections: 2)
+      runner.start_dispatchers
+      expect(runner.num_dispatcher_loops).to eq 2
+    end
+
+    it 'starts the dispatcher loop' do
+      expect(dispatcher_loop).to receive(:start)
+      runner.start_dispatchers
+    end
+
+    it 'starts the loops' do
+      expect(service_loop).to receive(:start)
+      runner.start_loops
+    end
+  end
+
+  describe 'enqueue' do
+    let(:notification) { double }
+
+    it 'enqueues the batch' do
+      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
+      expect(runner).to receive(:reflect).with(:notification_enqueued, notification)
+      runner.enqueue([notification])
+    end
+
+    describe 'a service that batches deliveries' do
+      before do
+        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
+          allow(runner).to receive(:num_dispatcher_loops).and_return(2)
+          runner.enqueue([notification])
+        end
+      end
+    end
+  end
+
+  describe 'stop' do
+    before do
+      runner.start_dispatchers
+      runner.start_loops
+    end
+
+    it 'stops the delivery dispatchers' do
+      expect(dispatcher_loop).to receive(:stop)
+      runner.stop
+    end
+
+    it 'stop the loops' do
+      expect(service_loop).to receive(:stop)
+      runner.stop
+    end
+  end
+end

data/spec/unit/daemon/batch_spec.rb

@@ -0,0 +1,169 @@
+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
+    allow(Time).to receive_messages(now: time)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+  end
+
+  it 'exposes the number notifications processed' do
+    expect(batch.num_processed).to eq 0
+  end
+
+  it 'increments the processed notifications count' do
+    expect { batch.notification_processed }.to change(batch, :num_processed).to(1)
+  end
+
+  it 'completes the batch when all notifications have been processed' do
+    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
+      expect(store).to receive(:mark_delivered).with(notification1, time, persist: false)
+      batch.mark_delivered(notification1)
+    end
+
+    it 'defers persisting' do
+      batch.mark_delivered(notification1)
+      expect(batch.delivered).to eq [notification1]
+    end
+  end
+
+  describe 'mark_all_delivered' do
+    it 'marks the notifications as delivered immediately without persisting' do
+      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
+      expect(batch.delivered).to eq [notification1, notification2]
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as failed without persisting' do
+      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')
+      expect(batch.failed).to eq([1, 'an error'] => [notification1])
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as failed without persisting' do
+      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')
+      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
+      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)
+      expect(batch.retryable).to eq(time => [notification1])
+    end
+  end
+
+  describe 'complete' do
+    before do
+      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(true)
+    end
+
+    it 'reflects errors raised during completion' do
+      e = StandardError.new
+      allow(batch).to receive(:complete_delivered).and_raise(e)
+      expect(batch).to receive(:reflect).with(:error, e)
+      2.times { batch.notification_processed }
+    end
+
+    describe 'delivered' do
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_delivered(n)
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as delivered' do
+        expect(store).to receive(:mark_batch_delivered).with([notification1, notification2])
+        complete
+      end
+
+      it 'reflects the notifications were delivered' do
+        expect(batch).to receive(:reflect).with(:notification_delivered, notification1)
+        expect(batch).to receive(:reflect).with(:notification_delivered, notification2)
+        complete
+      end
+    end
+
+    describe 'failed' do
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_failed(n, 1, 'an error')
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as failed' do
+        expect(store).to receive(:mark_batch_failed).with([notification1, notification2], 1, 'an error')
+        complete
+      end
+
+      it 'reflects the notifications failed' do
+        expect(batch).to receive(:reflect).with(:notification_failed, notification1)
+        expect(batch).to receive(:reflect).with(:notification_failed, notification2)
+        complete
+      end
+    end
+
+    describe 'retryable' do
+      def complete
+        [notification1, notification2].each do |n|
+          batch.mark_retryable(n, time)
+          batch.notification_processed
+        end
+      end
+
+      it 'marks the batch as retryable' do
+        expect(store).to receive(:mark_batch_retryable).with([notification1, notification2], time)
+        complete
+      end
+
+      it 'reflects the notifications will be retried' do
+        expect(batch).to receive(:reflect).with(:notification_will_retry, notification1)
+        expect(batch).to receive(:reflect).with(:notification_will_retry, notification2)
+        complete
+      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
+    expect(error.to_s).to eq "Unable to deliver notification 12, received error 4 (Missing payload)"
+  end
+
+  it "returns the error code" do
+    expect(error.code).to eq 4
+  end
+end

data/spec/unit/daemon/delivery_spec.rb

@@ -0,0 +1,51 @@
+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 { allow(Time).to receive_messages(now: now) }
+
+  describe 'mark_retryable' do
+    it 'does not retry a notification with an expired fail_after' do
+      expect(batch).to 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
+      expect(batch).to 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
+      expect(batch).to receive(:mark_retryable)
+      notification.fail_after = Time.now + 1.hour
+      delivery.mark_retryable(notification, Time.now + 1.hour)
+    end
+  end
+
+  describe 'mark_batch_delivered' do
+    it 'marks all notifications as delivered' do
+      expect(batch).to 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')
+      expect(batch).to 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

@@ -0,0 +1,34 @@
+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(:queue_payload) { Rpush::Daemon::QueuePayload.new(batch, notification) }
+  let(:dispatcher) { Rpush::Daemon::Dispatcher::Http.new(app, delivery_class) }
+
+  before { allow(Net::HTTP::Persistent).to receive_messages(new: http) }
+
+  it 'constructs a new persistent connection' do
+    expect(Net::HTTP::Persistent).to receive(:new)
+    Rpush::Daemon::Dispatcher::Http.new(app, delivery_class)
+  end
+
+  describe 'dispatch' do
+    it 'delivers the notification' do
+      delivery = double
+      expect(delivery_class).to receive(:new).with(app, http, notification, batch).and_return(delivery)
+      expect(delivery).to receive(:perform)
+      dispatcher.dispatch(queue_payload)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      expect(http).to receive(:shutdown)
+      dispatcher.cleanup
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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 { [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 { allow(Rpush::Daemon::TcpConnection).to receive_messages(new: connection) }
+
+  describe 'dispatch' do
+    it 'delivers the notification' do
+      expect(delivery_class).to receive(:new).with(app, connection, notification, batch).and_return(delivery)
+      expect(delivery).to receive(:perform)
+      dispatcher.dispatch(queue_payload)
+    end
+  end
+
+  describe 'cleanup' do
+    it 'closes the connection' do
+      expect(connection).to receive(:close)
+      dispatcher.cleanup
+    end
+  end
+end

data/spec/unit/daemon/dispatcher_loop_spec.rb

@@ -0,0 +1,53 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::DispatcherLoop do
+  def run_dispatcher_loop
+    dispatcher_loop.start
+    dispatcher_loop.stop
+  end
+
+  let(:notification) { double }
+  let(:batch) { double(notification_processed: nil) }
+  let(:queue) { Queue.new }
+  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) }
+
+  before do
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    queue.push([notification, batch])
+  end
+
+  it 'logs errors' do
+    logger = double
+    allow(Rpush).to receive_messages(logger: logger)
+    error = StandardError.new
+    allow(dispatcher).to receive(:dispatch).and_raise(error)
+    expect(Rpush.logger).to receive(:error).with(error)
+    run_dispatcher_loop
+  end
+
+  it 'reflects an exception' do
+    allow(Rpush).to receive_messages(logger: double(error: nil))
+    error = StandardError.new
+    allow(dispatcher).to receive(:dispatch).and_raise(error)
+    expect(dispatcher_loop).to receive(:reflect).with(:error, error)
+    run_dispatcher_loop
+  end
+
+  describe 'stop' do
+    before do
+      queue.clear
+    end
+
+    it 'instructs the dispatcher to cleanup' do
+      expect(dispatcher).to receive(:cleanup)
+      run_dispatcher_loop
+    end
+
+    it 'releases the store connection' do
+      expect(Rpush::Daemon.store).to receive(:release_connection)
+      run_dispatcher_loop
+    end
+  end
+end

data/spec/unit/daemon/feeder_spec.rb

@@ -0,0 +1,96 @@
+require "unit_spec_helper"
+
+describe Rpush::Daemon::Feeder do
+  let!(:app) { Rpush::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Apns::Notification.create!(device_token: "a" * 108, app: app) }
+  let(:logger) { double }
+  let(:interruptible_sleeper) { double(sleep: nil, stop: nil) }
+  let(:store) { double(Rpush::Daemon::Store::ActiveRecord, deliverable_notifications: [notification], release_connection: nil) }
+
+  before do
+    Rpush.configure do |config|
+      config.batch_size = 5000
+      config.push_poll = 0
+      config.push = false
+    end
+
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Rpush::Daemon::Feeder).to receive_messages(should_stop: true, interruptible_sleeper: interruptible_sleeper)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(enqueue: nil, num_queued: 0)
+  end
+
+  def start_and_stop
+    Rpush::Daemon::Feeder.start
+    Rpush::Daemon::Feeder.stop
+  end
+
+  it 'loads deliverable notifications' do
+    expect(Rpush::Daemon.store).to receive(:deliverable_notifications).with(Rpush.config.batch_size)
+    start_and_stop
+  end
+
+  it 'does not load more notifications if the total queue size is equal to the batch size' do
+    allow(Rpush::Daemon::AppRunner).to receive_messages(total_queued: Rpush.config.batch_size)
+    expect(Rpush::Daemon.store).not_to receive(:deliverable_notifications)
+    start_and_stop
+  end
+
+  it 'limits the batch size if some runners are still processing notifications' do
+    allow(Rpush.config).to receive_messages(batch_size: 10)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(total_queued: 6)
+    expect(Rpush::Daemon.store).to receive(:deliverable_notifications).with(4)
+    start_and_stop
+  end
+
+  it 'enqueues notifications without looping if in push mode' do
+    expect(Rpush::Daemon::Feeder).not_to receive(:feed_forever)
+    expect(Rpush::Daemon::Feeder).to receive(:feed_all)
+    Rpush::Daemon::Feeder.start(true)
+  end
+
+  it "enqueues the notifications" do
+    expect(Rpush::Daemon::AppRunner).to receive(:enqueue).with([notification])
+    start_and_stop
+  end
+
+  it "logs errors" do
+    e = StandardError.new("bork")
+    allow(Rpush::Daemon.store).to receive(:deliverable_notifications).and_raise(e)
+    expect(Rpush.logger).to receive(:error).with(e)
+    start_and_stop
+  end
+
+  describe 'stop' do
+    it 'interrupts sleep' do
+      expect(interruptible_sleeper).to receive(:stop)
+      start_and_stop
+    end
+
+    it 'releases the store connection' do
+      expect(Rpush::Daemon.store).to receive(:release_connection)
+      start_and_stop
+    end
+  end
+
+  it 'enqueues notifications when started' do
+    expect(Rpush::Daemon::Feeder).to receive(:enqueue_notifications).at_least(:once)
+    allow(Rpush::Daemon::Feeder).to receive(:loop).and_yield
+    start_and_stop
+  end
+
+  it 'sleeps' do
+    expect(interruptible_sleeper).to receive(:sleep)
+    start_and_stop
+  end
+
+  describe 'wakeup' do
+    it 'interrupts sleep' do
+      expect(interruptible_sleeper).to receive(:stop)
+      Rpush::Daemon::Feeder.start
+      Rpush::Daemon::Feeder.wakeup
+    end
+
+    after { Rpush::Daemon::Feeder.stop }
+  end
+end