rapns 1.0.7 → 2.0.0rc1

data/spec/rapns/daemon/delivery_handler_spec.rb

@@ -1,178 +1,191 @@
 require "spec_helper"
 
 describe Rapns::Daemon::DeliveryHandler do
-  let(:delivery_handler) { Rapns::Daemon::DeliveryHandler.new(0) }
+  let(:queue) { Rapns::Daemon::DeliveryQueue.new }
+  let(:name) { 'my_app:0' }
+  let(:host) { 'localhost' }
+  let(:port) { 2195 }
+  let(:certificate) { stub }
+  let(:password) { stub }
+  let(:delivery_handler) { Rapns::Daemon::DeliveryHandler.new(queue, name, host, port, certificate, password) }
+  let(:connection) { stub(:select => false, :write => nil, :reconnect => nil, :close => nil, :connect => nil) }
+  let(:logger) { stub(:error => nil, :info => nil) }
+  let(:notification) { stub.as_null_object }
+  let(:config) { stub(:check_for_errors => true) }
+  let(:delivery_queues) { [] }
 
   before do
-    @notification = Rapns::Notification.create!(:device_token => "a" * 64)
-    Rapns::Daemon.stub(:delivery_queue).and_return(Rapns::Daemon::DeliveryQueue.new)
-    Rapns::Daemon.delivery_queue.push(@notification)
-    @connection = mock("Connection", :connect => nil, :write => nil, :close => nil, :select => nil, :read => nil)
-    Rapns::Daemon::Connection.stub(:new).and_return(@connection)
-    configuration = mock("Configuration", :push => stub(:host => "gateway.push.apple.com", :port => 2195))
-    Rapns::Daemon.stub(:configuration).and_return(configuration)
-    @logger = mock("Logger", :error => nil, :info => nil)
-    Rapns::Daemon.stub(:logger).and_return(@logger)
+    Rapns::Daemon::Connection.stub(:new => connection)
+    Rapns::Daemon.stub(:delivery_queues => delivery_queues, :logger => logger, :config => config)
+    queue.push(notification) 
   end
 
   it "instantiates a new connection" do
-    Rapns::Daemon::Connection.should_receive(:new).with('DeliveryHandler 0', 'gateway.push.apple.com', 2195)
+    Rapns::Daemon::Connection.should_receive(:new).with("DeliveryHandler:#{name}", host, port, certificate, password)
     delivery_handler
   end
 
   it "connects the socket when started" do
-    @connection.should_receive(:connect)
+    connection.should_receive(:connect)
     delivery_handler.start
     delivery_handler.stop
   end
 
-  it "pushes a STOP instruction into the queue when told to stop" do
-    Rapns::Daemon.delivery_queue.should_receive(:push).with(Rapns::Daemon::DeliveryHandler::STOP)
+  it "instructs the queue to wakeup the thread when told to stop" do
+    thread = stub
+    Thread.stub(:new => thread)
+    queue.should_receive(:wakeup).with(thread)
+    delivery_handler.start
     delivery_handler.stop
   end
 
-  it "closes the connection when a STOP instruction is received" do
-    Rapns::Daemon.delivery_queue.push(Rapns::Daemon::DeliveryHandler::STOP)
+  it "sends the binary version of the notification" do
+    notification.stub(:to_binary => "hi mom")
+    connection.should_receive(:write).with("hi mom")
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should pop a new notification from the delivery queue" do
-    Rapns::Daemon.delivery_queue.should_receive(:pop)
+  it "logs the notification delivery" do
+    notification.stub(:id => 666, :device_token => 'abc123')
+    logger.should_receive(:info).with("[DeliveryHandler:my_app:0] 666 sent to abc123")
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "does not attempt to deliver a notification when a STOP instruction is received" do
-    Rapns::Daemon.delivery_queue.pop # empty the queue
-    delivery_handler.should_not_receive(:deliver)
-    Rapns::Daemon.delivery_queue.push(Rapns::Daemon::DeliveryHandler::STOP)
+  it "marks the notification as delivered" do
+    notification.should_receive(:delivered=).with(true)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should send the binary version of the notification" do
-    @notification.stub((:to_binary)).and_return("hi mom")
-    @connection.should_receive(:write).with("hi mom")
+  it "sets the time the notification was delivered" do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+    notification.should_receive(:delivered_at=).with(now)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should log the notification delivery" do
-    Rapns::Daemon.logger.should_receive(:info).with("Notification #{@notification.id} delivered to #{@notification.device_token}")
+  it "does not trigger validations when saving the notification" do
+    notification.should_receive(:save!).with(:validate => false)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should mark the notification as delivered" do
-    expect { delivery_handler.send(:handle_next_notification); @notification.reload }.to change(@notification, :delivered).to(true)
-  end
-
-  it "should set the time the notification was delivered" do
-    @notification.delivered_at.should be_nil
+  it "updates notification with the ability to reconnect the database" do
+    delivery_handler.should_receive(:with_database_reconnect_and_retry)
     delivery_handler.send(:handle_next_notification)
-    @notification.reload
-    @notification.delivered_at.should be_kind_of(Time)
   end
 
-  it "should not trigger validations when saving the notification" do
-    @notification.should_receive(:save!).with(:validate => false)
+  it "logs if an error is raised when updating the notification" do
+    e = StandardError.new("bork!")
+    notification.stub(:save!).and_raise(e)
+    Rapns::Daemon.logger.should_receive(:error).with(e)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should update notification with the ability to reconnect the database" do
-    delivery_handler.should_receive(:with_database_reconnect_and_retry)
+  it "notifies the delivery queue the notification has been processed" do
+    queue.should_receive(:notification_processed)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should log if an error is raised when updating the notification" do
-    e = StandardError.new("bork!")
-    @notification.stub(:save!).and_raise(e)
-    Rapns::Daemon.logger.should_receive(:error).with(e)
+  it 'does not check for errors if check_for_errors config option is false' do
+    config.stub(:check_for_errors => false)
+    delivery_handler.should_not_receive(:check_for_error)
     delivery_handler.send(:handle_next_notification)
   end
 
-  it "should notify the delivery queue the notification has been processed" do
-    Rapns::Daemon.delivery_queue.should_receive(:notification_processed)
-    delivery_handler.send(:handle_next_notification)
+  describe "when being stopped" do
+    before { queue.pop }
+
+    it "closes the connection when a DeliveryQueue::WakeupError is raised" do
+      connection.should_receive(:close)
+      queue.stub(:pop).and_raise(Rapns::Daemon::DeliveryQueue::WakeupError)
+      delivery_handler.send(:handle_next_notification)
+    end
+
+    it "does not attempt to deliver a notification when a DeliveryQueue::::WakeupError is raised" do
+      queue.stub(:pop).and_raise(Rapns::Daemon::DeliveryQueue::WakeupError)
+      delivery_handler.should_not_receive(:deliver)
+      delivery_handler.send(:handle_next_notification)
+    end
   end
 
   describe "when delivery fails" do
-    before do
-      @connection.stub(:select => true, :read => [8, 4, 69].pack("ccN"), :reconnect => nil)
-    end
+    before { connection.stub(:select => true, :read => [8, 4, 69].pack("ccN")) }
 
-    it "should update notification with the ability to reconnect the database" do
+    it "updates notification with the ability to reconnect the database" do
       delivery_handler.should_receive(:with_database_reconnect_and_retry)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification as not delivered" do
-      @notification.should_receive(:delivered=).with(false)
+    it "sets the notification as not delivered" do
+      notification.should_receive(:delivered=).with(false)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification delivered_at timestamp to nil" do
-      @notification.should_receive(:delivered_at=).with(nil)
+    it "sets the notification delivered_at timestamp to nil" do
+      notification.should_receive(:delivered_at=).with(nil)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification as failed" do
-      @notification.should_receive(:failed=).with(true)
+    it "sets the notification as failed" do
+      notification.should_receive(:failed=).with(true)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification failed_at timestamp" do
+    it "sets the notification failed_at timestamp" do
       now = Time.now
       Time.stub(:now).and_return(now)
-      @notification.should_receive(:failed_at=).with(now)
+      notification.should_receive(:failed_at=).with(now)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification error code" do
-      @notification.should_receive(:error_code=).with(4)
+    it "sets the notification error code" do
+      notification.should_receive(:error_code=).with(4)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should log the delivery error" do
+    it "logs the delivery error" do
       error = Rapns::DeliveryError.new(4, 12, "Missing payload")
       Rapns::DeliveryError.stub(:new => error)
-      Rapns::Daemon.logger.should_receive(:error).with(error)
+      logger.should_receive(:error).with(error)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should set the notification error description" do
-      @notification.should_receive(:error_description=).with("Missing payload")
+    it "sets the notification error description" do
+      notification.should_receive(:error_description=).with("Missing payload")
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should skip validation when saving the notification" do
-      @notification.should_receive(:save!).with(:validate => false)
+    it "skips validation when saving the notification" do
+      notification.should_receive(:save!).with(:validate => false)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should read 6 bytes from the socket" do
-      @connection.should_receive(:read).with(6).and_return(nil)
+    it "reads 6 bytes from the socket" do
+      connection.should_receive(:read).with(6).and_return(nil)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should not attempt to read from the socket if the socket was not selected for reading after the timeout" do
-      @connection.stub(:select => nil)
-      @connection.should_not_receive(:read)
+    it "does not attempt to read from the socket if the socket was not selected for reading after the timeout" do
+      connection.stub(:select => nil)
+      connection.should_not_receive(:read)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should reconnect the socket" do
-      @connection.should_receive(:reconnect)
+    it "reconnects the socket" do
+      connection.should_receive(:reconnect)
       delivery_handler.send(:handle_next_notification)
     end
 
-    it "should log that the connection is being reconnected" do
-      Rapns::Daemon.logger.should_receive(:error).with("[DeliveryHandler 0] Error received, reconnecting...")
+    it "logs that the connection is being reconnected" do
+      Rapns::Daemon.logger.should_receive(:error).with("[DeliveryHandler:my_app:0] Error received, reconnecting...")
       delivery_handler.send(:handle_next_notification)
     end
 
     context "when the APNs disconnects without returning an error" do
       before do
-        @connection.stub(:read => nil)
+        connection.stub(:read => nil)
       end
 
-      it 'should raise a DisconnectError error if the connection is closed without an error being returned' do
+      it 'raises a DisconnectError error if the connection is closed without an error being returned' do
         error = Rapns::DisconnectionError.new
         Rapns::DisconnectionError.should_receive(:new).and_return(error)
         Rapns::Daemon.logger.should_receive(:error).with(error)
@@ -180,12 +193,12 @@ describe Rapns::Daemon::DeliveryHandler do
       end
 
       it 'does not set the error code on the notification' do
-        @notification.should_receive(:error_code=).with(nil)
+        notification.should_receive(:error_code=).with(nil)
         delivery_handler.send(:handle_next_notification)
       end
 
       it 'sets the error descriptipon on the notification' do
-        @notification.should_receive(:error_description=).with("APNs disconnected without returning an error.")
+        notification.should_receive(:error_description=).with("APNs disconnected without returning an error.")
         delivery_handler.send(:handle_next_notification)
       end
     end

data/spec/rapns/daemon/feedback_receiver_spec.rb

@@ -1,16 +1,22 @@
 require "spec_helper"
 
 describe Rapns::Daemon::FeedbackReceiver, 'check_for_feedback' do
+  let(:host) { 'feedback.push.apple.com' }
+  let(:port) { 2196 }
+  let(:poll) { 60 }
+  let(:certificate) { stub }
+  let(:password) { stub }
+  let(:app) { 'my_app' }
   let(:connection) { stub(:connect => nil, :read => nil, :close => nil) }
   let(:logger) { stub(:error => nil, :info => nil) }
+  let(:receiever) { Rapns::Daemon::FeedbackReceiver.new(app, host, port, poll, certificate, password) }
 
   before do
-    Rapns::Daemon::FeedbackReceiver.stub(:interruptible_sleep)
+    receiever.stub(:interruptible_sleep)
     Rapns::Daemon.logger = logger
     Rapns::Daemon::Connection.stub(:new => connection)
     Rapns::Feedback.stub(:create!)
-    Rapns::Daemon.configuration = stub(:feedback => stub(:host => 'feedback.push.apple.com', :port => 2196, :poll => 60))
-    Rapns::Daemon::FeedbackReceiver.instance_variable_set("@stop", false)
+    receiever.instance_variable_set("@stop", false)
   end
 
   def stub_connection_read_with_tuple
@@ -25,62 +31,62 @@ describe Rapns::Daemon::FeedbackReceiver, 'check_for_feedback' do
   end
 
   it 'instantiates a new connection' do  
-    Rapns::Daemon::Connection.should_receive(:new).with("FeedbackReceiver", 'feedback.push.apple.com', 2196)
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    Rapns::Daemon::Connection.should_receive(:new).with("FeedbackReceiver:#{app}", host, port, certificate, password)
+    receiever.check_for_feedback
   end
 
   it 'connects to the feeback service' do
     connection.should_receive(:connect)
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    receiever.check_for_feedback
   end
 
   it 'closes the connection' do
     connection.should_receive(:close)
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    receiever.check_for_feedback
   end
 
   it 'reads from the connection' do
     connection.should_receive(:read).with(38)
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    receiever.check_for_feedback
   end
 
   it 'logs the feedback' do
     stub_connection_read_with_tuple
-    Rapns::Daemon.logger.should_receive(:info).with("[FeedbackReceiver] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17")
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    Rapns::Daemon.logger.should_receive(:info).with("[FeedbackReceiver:my_app] Delivery failed at 2011-12-10 16:08:45 UTC for 834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17")
+    receiever.check_for_feedback
   end
 
   it 'creates the feedback' do
     stub_connection_read_with_tuple
-    Rapns::Feedback.should_receive(:create!).with(:failed_at => Time.at(1323533325), :device_token => '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17')
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    Rapns::Feedback.should_receive(:create!).with(:failed_at => Time.at(1323533325), :device_token => '834f786655eb9f84614a05ad7d00af31e5cfe93ac3ea078f1da44d2a4eb0ce17', :app => 'my_app')
+    receiever.check_for_feedback
   end
 
   it 'logs errors' do
     error = StandardError.new('bork!')
     connection.stub(:read).and_raise(error)
     Rapns::Daemon.logger.should_receive(:error).with(error)
-    Rapns::Daemon::FeedbackReceiver.check_for_feedback
+    receiever.check_for_feedback
   end
 
   it 'sleeps for the feedback poll period' do
-    Rapns::Daemon::FeedbackReceiver.stub(:check_for_feedback)
-    Rapns::Daemon::FeedbackReceiver.should_receive(:interruptible_sleep).with(60).at_least(:once)
+    receiever.stub(:check_for_feedback)
+    receiever.should_receive(:interruptible_sleep).with(60).at_least(:once)
     Thread.stub(:new).and_yield
-    Rapns::Daemon::FeedbackReceiver.stub(:loop).and_yield
-    Rapns::Daemon::FeedbackReceiver.start
+    receiever.stub(:loop).and_yield
+    receiever.start
   end
 
   it 'checks for feedback when started' do
-    Rapns::Daemon::FeedbackReceiver.should_receive(:check_for_feedback).at_least(:once)
+    receiever.should_receive(:check_for_feedback).at_least(:once)
     Thread.stub(:new).and_yield
-    Rapns::Daemon::FeedbackReceiver.stub(:loop).and_yield
-    Rapns::Daemon::FeedbackReceiver.start
+    receiever.stub(:loop).and_yield
+    receiever.start
   end
 
   it 'interrupts sleep when stopped' do
-    Rapns::Daemon::FeedbackReceiver.stub(:check_for_feedback)
-    Rapns::Daemon::FeedbackReceiver.should_receive(:interrupt_sleep)
-    Rapns::Daemon::FeedbackReceiver.stop
+    receiever.stub(:check_for_feedback)
+    receiever.should_receive(:interrupt_sleep)
+    receiever.stop
   end
 end

data/spec/rapns/daemon/feeder_spec.rb

@@ -1,79 +1,75 @@
 require "spec_helper"
 
 describe Rapns::Daemon::Feeder do
+  let(:poll) { 2 }
+  let(:config) { stub(:batch_size => 5000) }
+  let(:notification) { Rapns::Notification.create!(:device_token => "a" * 64, :app => 'my_app') }
+  let(:logger) { stub }
+
   before do
     Rapns::Daemon::Feeder.stub(:sleep)
     Rapns::Daemon::Feeder.stub(:interruptible_sleep)
-    @notification = Rapns::Notification.create!(:device_token => "a" * 64)
-    @logger = mock("Logger", :info => nil, :error => nil, :warn => nil)
-    Rapns::Daemon.stub(:logger).and_return(@logger)
-    @queue = mock(:push => nil, :notifications_processed? => true)
-    Rapns::Daemon.stub(:delivery_queue).and_return(@queue)
-    Rapns::Daemon.stub(:configuration => mock("Configuration", :push => stub(:poll => 2)))
+    Rapns::Daemon.stub(:logger => logger, :config => config)
     Rapns::Daemon::Feeder.instance_variable_set("@stop", false)
+    Rapns::Daemon::AppRunner.stub(:ready => ['my_app'])
+    Rapns::Daemon::AppRunner.stub(:ready => ['my_app'])
   end
 
-  it "should reconnect to the database when daemonized" do
-    Rapns::Daemon::Feeder.stub(:loop)
-    Rapns::Daemon::Feeder.should_receive(:reconnect_database)
-    Rapns::Daemon::Feeder.start(false)
-  end
-
-  it "should check for new notifications with the ability to reconnect the database" do
+  it "checks for new notifications with the ability to reconnect the database" do
     Rapns::Daemon::Feeder.should_receive(:with_database_reconnect_and_retry)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should not reconnect to the database when running in the foreground" do
-    Rapns::Daemon::Feeder.stub(:loop)
-    Rapns::Daemon::Feeder.should_not_receive(:reconnect_database)
-    Rapns::Daemon::Feeder.start(true)
+  it 'loads notifications in batches' do
+    relation = stub
+    relation.should_receive(:find_each).with(:batch_size => 5000)
+    Rapns::Notification.stub(:ready_for_delivery => relation)
+    Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should enqueue an undelivered notification" do
-    @notification.update_attributes!(:delivered => false)
-    Rapns::Daemon.delivery_queue.should_receive(:push)
+  it "delivers the notification" do
+    notification.update_attributes!(:delivered => false)
+    Rapns::Daemon::AppRunner.should_receive(:deliver).with(notification)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should enqueue an undelivered notification without deliver_after set" do
-    @notification.update_attributes!(:delivered => false, :deliver_after => nil)
-    Rapns::Daemon.delivery_queue.should_receive(:push)
+  it 'does not enqueue the notification if the app runner is still processing the previous batch' do
+    Rapns::Daemon::AppRunner.stub(:ready => [])
+    Rapns::Daemon::AppRunner.should_not_receive(:deliver)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should enqueue a notification with a deliver_after time in the past" do
-    @notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
-    Rapns::Daemon.delivery_queue.should_receive(:push)
+  it "enqueues an undelivered notification without deliver_after set" do
+    notification.update_attributes!(:delivered => false, :deliver_after => nil)
+    Rapns::Daemon::AppRunner.should_receive(:deliver).with(notification)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should not enqueue a notification with a deliver_after time in the future" do
-    @notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
-    Rapns::Daemon.delivery_queue.should_not_receive(:push)
+  it "enqueues a notification with a deliver_after time in the past" do
+    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
+    Rapns::Daemon::AppRunner.should_receive(:deliver).with(notification)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should not enqueue a previously delivered notification" do
-    @notification.update_attributes!(:delivered => true, :delivered_at => Time.now)
-    Rapns::Daemon.delivery_queue.should_not_receive(:push)
+  it "does not enqueue a notification with a deliver_after time in the future" do
+    notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
+    Rapns::Daemon::AppRunner.should_not_receive(:deliver)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should not enqueue a notification that has previously failed delivery" do
-    @notification.update_attributes!(:delivered => false, :failed => true)
-    Rapns::Daemon.delivery_queue.should_not_receive(:push)
+  it "does not enqueue a previously delivered notification" do
+    notification.update_attributes!(:delivered => true, :delivered_at => Time.now)
+    Rapns::Daemon::AppRunner.should_not_receive(:deliver)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should not enqueue more notifications if other are still being processed" do
-    Rapns::Daemon.delivery_queue.stub(:notifications_processed? => false)
-    Rapns::Notification.should_not_receive(:ready_for_delivery)
-    Rapns::Daemon.delivery_queue.should_not_receive(:push)
+  it "does not enqueue a notification that has previously failed delivery" do
+    notification.update_attributes!(:delivered => false, :failed => true)
+    Rapns::Daemon::AppRunner.should_not_receive(:deliver)
     Rapns::Daemon::Feeder.enqueue_notifications
   end
 
-  it "should log errors" do
+  it "logs errors" do
     e = StandardError.new("bork")
     Rapns::Notification.stub(:ready_for_delivery).and_raise(e)
     Rapns::Daemon.logger.should_receive(:error).with(e)
@@ -88,12 +84,12 @@ describe Rapns::Daemon::Feeder do
   it "enqueues notifications when started" do
     Rapns::Daemon::Feeder.should_receive(:enqueue_notifications).at_least(:once)
     Rapns::Daemon::Feeder.stub(:loop).and_yield
-    Rapns::Daemon::Feeder.start(true)
+    Rapns::Daemon::Feeder.start(poll)
   end
 
-  it "should sleep for the given period" do
-    Rapns::Daemon::Feeder.should_receive(:interruptible_sleep).with(2)
+  it "sleeps for the given period" do
+    Rapns::Daemon::Feeder.should_receive(:interruptible_sleep).with(poll)
     Rapns::Daemon::Feeder.stub(:loop).and_yield
-    Rapns::Daemon::Feeder.start(true)
+    Rapns::Daemon::Feeder.start(poll)
   end
 end

data/spec/rapns/daemon/logger_spec.rb

@@ -21,17 +21,30 @@ module Airbrake
 end
 
 describe Rapns::Daemon::Logger do
+  let(:log) { stub(:sync= => true) }
+  let(:config) { stub(:airbrake_notify => true) }
+
   before do
     Rails.stub(:root).and_return("/rails_root")
     @buffered_logger = mock("BufferedLogger", :info => nil, :error => nil, :level => 0, :auto_flushing => 1, :auto_flushing= => nil)
     Rails.logger = @buffered_logger
     ActiveSupport::BufferedLogger.stub(:new).and_return(@buffered_logger)
-    configuration = mock("Configuration", :airbrake_notify? => true)
-    Rapns::Daemon.stub(:configuration).and_return(configuration)
+    Rapns::Daemon.stub(:config => config)
+    File.stub(:open => log)
   end
 
   it "should open the a log file in the Rails log directory" do
-    ActiveSupport::BufferedLogger.should_receive(:new).with("/rails_root/log/rapns.log", Rails.logger.level)
+    File.should_receive(:open).with('/rails_root/log/rapns.log', 'w')
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it 'sets sync mode on the log descriptor' do
+    log.should_receive(:sync=).with(true)
+    Rapns::Daemon::Logger.new(:foreground => true)
+  end
+
+  it 'instantiates the BufferedLogger' do
+    ActiveSupport::BufferedLogger.should_receive(:new).with(log, Rails.logger.level)
     Rapns::Daemon::Logger.new(:foreground => true)
   end
 
@@ -69,6 +82,7 @@ describe Rapns::Daemon::Logger do
 
   it "should handle an Exception instance" do
     e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
     logger = Rapns::Daemon::Logger.new(:foreground => false)
     @buffered_logger.should_receive(:error).with(/RuntimeError, hi mom/)
     logger.error(e)
@@ -76,6 +90,7 @@ describe Rapns::Daemon::Logger do
 
   it "should notify Airbrake of the exception" do
     e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
     logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
     Airbrake.should_receive(:notify_or_ignore).with(e)
     logger.error(e)
@@ -95,6 +110,7 @@ describe Rapns::Daemon::Logger do
 
     it "should notify using HoptoadNotifier" do
       e = RuntimeError.new("hi mom")
+      e.stub(:backtrace => [])
       logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
       HoptoadNotifier.should_receive(:notify_or_ignore).with(e)
       logger.error(e)
@@ -103,6 +119,7 @@ describe Rapns::Daemon::Logger do
 
   it "should not notify Airbrake of the exception if the airbrake_notify option is false" do
     e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
     logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => false)
     Airbrake.should_not_receive(:notify_or_ignore).with(e)
     logger.error(e)
@@ -110,6 +127,7 @@ describe Rapns::Daemon::Logger do
 
   it "should not notify Airbrake if explicitly disabled in the call to error" do
     e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
     logger = Rapns::Daemon::Logger.new(:foreground => false, :airbrake_notify => true)
     Airbrake.should_not_receive(:notify_or_ignore).with(e)
     logger.error(e, :airbrake_notify => false)