rapns_rails_2 3.5.1 → 3.6.1

data/spec/unit/daemon/batch_spec.rb

@@ -1,219 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-
-describe Rapns::Daemon::Batch do
-  let(:notification1) { double(:notification1, :id => 1) }
-  let(:notification2) { double(:notification2, :id => 2) }
-  let(:batch) { Rapns::Daemon::Batch.new([notification1, notification2]) }
-  let(:store) { double.as_null_object }
-
-  before do
-    Rapns::Daemon.stub(:store => store)
-  end
-
-  it 'exposes the notifications' do
-    batch.notifications.should == [notification1, notification2]
-  end
-
-  it 'exposes the number notifications' do
-    batch.num_notifications.should == 2
-  end
-
-  it 'exposes the number notifications processed' do
-    batch.num_processed.should == 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
-    batch.should_receive(:complete)
-    2.times { batch.notification_processed }
-  end
-
-  it 'can be described' do
-    batch.describe.should == '1, 2'
-  end
-
-  describe 'mark_delivered' do
-    describe 'batching is disabled' do
-      before { Rapns.config.batch_storage_updates = false }
-
-      it 'marks the notification as delivered immediately' do
-        store.should_receive(:mark_delivered).with(notification1)
-        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 { Rapns.config.batch_storage_updates = true }
-
-      it 'defers marking the notification as delivered until the batch is complete' do
-        batch.mark_delivered(notification1)
-        batch.delivered.should == [notification1]
-      end
-    end
-  end
-
-  describe 'mark_failed' do
-    describe 'batching is disabled' do
-      before { Rapns.config.batch_storage_updates = false }
-
-      it 'marks the notification as failed' do
-        store.should_receive(:mark_failed).with(notification1, 1, 'an error')
-        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 { Rapns.config.batch_storage_updates = true }
-
-      it 'defers marking the notification as failed' do
-        Rapns.config.batch_storage_updates = true
-        batch.mark_failed(notification1, 1, 'an error')
-        batch.failed.should == {[1, 'an error'] => [notification1]}
-      end
-    end
-  end
-
-  describe 'mark_retryable' do
-    let(:time) { Time.now }
-
-    describe 'batching is disabled' do
-      before { Rapns.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 { Rapns.config.batch_storage_updates = true }
-
-      it 'defers marking the notification as retryable' do
-        batch.mark_retryable(notification1, time)
-        batch.retryable.should == {time => [notification1]}
-      end
-    end
-  end
-
-  describe 'complete' do
-    before do
-      Rapns.config.batch_storage_updates = true
-      Rapns.stub(:logger => double.as_null_object)
-      batch.stub(:reflect)
-    end
-
-    it 'clears the notifications' do
-      expect do
-        2.times { batch.notification_processed }
-      end.to change(batch.notifications, :length).to(0)
-    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
-      batch.stub(:complete_delivered).and_raise(e)
-      batch.should_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
-        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 == []
-      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
-        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 == {}
-      end
-    end
-
-    describe 'retryable' do
-      let(:time) { Time.now }
-
-      def complete
-        [notification1, notification2].each do |n|
-          batch.mark_retryable(n, time)
-          batch.notification_processed
-        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 == {}
-      end
-    end
-  end
-end

data/spec/unit/daemon/delivery_error_spec.rb

@@ -1,13 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-
-describe Rapns::DeliveryError do
-  let(:error) { Rapns::DeliveryError.new(4, 12, "Missing payload") }
-
-  it "returns an informative message" do
-    error.to_s.should == "Unable to deliver notification 12, received error 4 (Missing payload)"
-  end
-
-  it "returns the error code" do
-    error.code.should == 4
-  end
-end

data/spec/unit/daemon/delivery_handler_collection_spec.rb

@@ -1,37 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-
-describe Rapns::Daemon::DeliveryHandlerCollection do
-  let(:handler) { double.as_null_object }
-  let(:collection) { Rapns::Daemon::DeliveryHandlerCollection.new }
-
-  it 'returns the size of the collection' do
-    collection.push(handler)
-    collection.size.should == 1
-  end
-
-  it 'pops a handler from the collection' do
-    collection.push(handler)
-    handler.should_receive(:stop)
-    handler.should_receive(:wakeup)
-    handler.should_receive(:wait)
-    collection.pop
-    collection.size.should == 0
-  end
-
-  it 'wakes up all handlers when popping a single handler' do
-    collection.push(handler)
-    handler2 = double.as_null_object
-    collection.push(handler2)
-    handler.should_receive(:wakeup)
-    handler2.should_receive(:wakeup)
-    collection.pop
-  end
-
-  it 'stops all handlers' do
-    collection.push(handler)
-    handler.should_receive(:stop)
-    handler.should_receive(:wakeup)
-    handler.should_receive(:wait)
-    collection.stop
-  end
-end

data/spec/unit/daemon/delivery_handler_shared.rb

@@ -1,45 +0,0 @@
-shared_examples_for 'an DeliveryHandler subclass' do
-  def run_delivery_handler
-    delivery_handler.start
-    delivery_handler.stop
-    delivery_handler.wakeup
-    delivery_handler.wait
-  end
-
-  it 'logs all delivery errors' do
-    logger = double
-    Rapns.stub(:logger => logger)
-    error = StandardError.new
-    delivery_handler.stub(:deliver).and_raise(error)
-    Rapns.logger.should_receive(:error).with(error)
-    run_delivery_handler
-  end
-
-  it 'reflects an exception' do
-    Rapns.stub(:logger => double(:error => nil))
-    error = StandardError.new
-    delivery_handler.stub(:deliver).and_raise(error)
-    delivery_handler.should_receive(:reflect).with(:error, error)
-    run_delivery_handler
-  end
-
-  it 'instructs the batch that the notification has been processed' do
-    batch.should_receive(:notification_processed)
-    run_delivery_handler
-  end
-
-  it "instructs the queue to wakeup the thread when told to stop" do
-    queue.should_receive(:push).with(Rapns::Daemon::DeliveryHandler::WAKEUP) { |*a| queue.proxied_by_rspec__push(*a) }
-    run_delivery_handler
-  end
-
-  describe "when being stopped" do
-    before { queue.pop }
-
-    it "does not attempt to deliver a notification when a WAKEUP is dequeued" do
-      queue.stub(:pop).and_return(Rapns::Daemon::DeliveryHandler::WAKEUP)
-      delivery_handler.should_not_receive(:deliver)
-      delivery_handler.send(:handle_next_notification)
-    end
-  end
-end

data/spec/unit/daemon/feeder_spec.rb

@@ -1,89 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-
-describe Rapns::Daemon::Feeder do
-  let(:config) { double(:batch_size => 5000,
-                        :push_poll => 0,
-                        :embedded => false,
-                        :push => false,
-                        :wakeup => nil) }
-  let!(:app) { Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
-  let(:notification) { Rapns::Apns::Notification.create!(:device_token => "a" * 256, :app => app) }
-  let(:logger) { double }
-  let(:interruptible_sleep) { double(:sleep => nil, :interrupt_sleep => nil) }
-
-  before do
-    Rapns.stub(:config => config,:logger => logger)
-    Rapns::Daemon.stub(:store => double(:deliverable_notifications => [notification]))
-    Rapns::Daemon::Feeder.stub(:stop? => true)
-    Rapns::Daemon::AppRunner.stub(:enqueue => nil, :idle => [double(:app => app)])
-    Rapns::Daemon::InterruptibleSleep.stub(:new => interruptible_sleep)
-    Rapns::Daemon::Feeder.instance_variable_set('@interruptible_sleeper', nil)
-  end
-
-  def start_and_stop
-    Rapns::Daemon::Feeder.start
-    Rapns::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
-    Rapns::Daemon::Feeder.should_receive(:feed_forever)
-    start_and_stop
-  end
-
-  it 'loads deliverable notifications' do
-    Rapns::Daemon.store.should_receive(:deliverable_notifications).with([app])
-    start_and_stop
-  end
-
-  it 'does not attempt to load deliverable notifications if there are no idle runners' do
-    Rapns::Daemon::AppRunner.stub(:idle => [])
-    Rapns::Daemon.store.should_not_receive(:deliverable_notifications)
-    start_and_stop
-  end
-
-  it 'enqueues notifications without looping if in push mode' do
-    config.stub(:push => true)
-    Rapns::Daemon::Feeder.should_not_receive(:feed_forever)
-    Rapns::Daemon::Feeder.should_receive(:enqueue_notifications)
-    start_and_stop
-  end
-
-  it "enqueues the notifications" do
-    Rapns::Daemon::AppRunner.should_receive(:enqueue).with([notification])
-    start_and_stop
-  end
-
-  it "logs errors" do
-    e = StandardError.new("bork")
-    Rapns::Daemon.store.stub(:deliverable_notifications).and_raise(e)
-    Rapns.logger.should_receive(:error).with(e)
-    start_and_stop
-  end
-
-  it "interrupts sleep when stopped" do
-    Rapns::Daemon::Feeder.should_receive(:interrupt_sleep)
-    start_and_stop
-  end
-
-  it "enqueues notifications when started" do
-    Rapns::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
-    Rapns::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)
-    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
-  end
-end

data/spec/unit/daemon/gcm/app_runner_spec.rb

@@ -1,19 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-require File.dirname(__FILE__) + '/../app_runner_shared.rb'
-
-describe Rapns::Daemon::Gcm::AppRunner do
-  it_should_behave_like 'an AppRunner subclass'
-
-  let(:app_class) { Rapns::Gcm::App }
-  let(:app) { app_class.new }
-  let(:runner) { Rapns::Daemon::Gcm::AppRunner.new(app) }
-  let(:handler) { double(:start => nil, :queue= => nil, :wakeup => nil, :wait => nil) }
-  let(:handler_collection) { double(:handler_collection, :push => nil, :size => 1, :stop => nil) }
-  let(:logger) { double(:info => nil) }
-
-  before do
-    Rapns.stub(:logger => logger)
-    Rapns::Daemon::Gcm::DeliveryHandler.stub(:new => handler)
-    Rapns::Daemon::DeliveryHandlerCollection.stub(:new => handler_collection)
-  end
-end

data/spec/unit/daemon/gcm/delivery_handler_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path("spec/unit_spec_helper")
-require File.dirname(__FILE__) + '/../delivery_handler_shared.rb'
-
-describe Rapns::Daemon::Gcm::DeliveryHandler do
-  it_should_behave_like 'an DeliveryHandler subclass'
-
-  let(:notification) { double }
-  let(:batch) { double(:notification_processed => nil) }
-  let(:queue) { Queue.new }
-  let(:app) { double }
-  let(:delivery_handler) { Rapns::Daemon::Gcm::DeliveryHandler.new(app) }
-  let(:http) { double(:shutdown => nil) }
-  let(:delivery) { double(:perform => nil) }
-
-  before do
-    Net::HTTP::Persistent.stub(:new => http)
-    Rapns::Daemon::Gcm::Delivery.stub(:new => delivery)
-    delivery_handler.queue = queue
-    queue.push([notification, batch])
-  end
-
-  def run_delivery_handler
-    delivery_handler.start
-    delivery_handler.stop
-    delivery_handler.wakeup
-    delivery_handler.wait
-  end
-
-  it 'performs delivery of an notification' do
-    Rapns::Daemon::Gcm::Delivery.should_receive(:new).with(app, http, notification, batch).and_return(delivery)
-    delivery.should_receive(:perform)
-    run_delivery_handler
-  end
-
-  it 'initiates a persistent connection object' do
-    Net::HTTP::Persistent.should_receive(:new).with('rapns')
-    Rapns::Daemon::Gcm::DeliveryHandler.new(app)
-  end
-
-  it 'shuts down the http connection stopped' do
-    http.should_receive(:shutdown)
-    run_delivery_handler
-  end
-end