rpush 1.0.0 → 2.0.0.beta1

data/spec/unit/daemon/too_many_requests_error_spec.rb

@@ -1,7 +1,7 @@
 require "unit_spec_helper"
 
 describe Rpush::TooManyRequestsError do
-  let(:response) { double(:code => 429, :header => { 'retry-after' => 3600 }) }
+  let(:response) { double(code: 429, header: { 'retry-after' => 3600 }) }
   let(:error) { Rpush::TooManyRequestsError.new(429, 12, "Too Many Requests", response) }
 
   it "returns an informative message" do

data/spec/unit/daemon/wpns/delivery_spec.rb

@@ -1,37 +1,44 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Wpns::Delivery do
-  let(:app) { Rpush::Wpns::App.new(:name => "MyApp") }
-  let(:notification) { Rpush::Wpns::Notification.create!(:app => app,:alert => "test",
-                                                         :uri => "http://some.example/",
-                                                         :deliver_after => Time.now) }
-  let(:logger) { double(:error => nil, :info => nil, :warn => nil) }
-  let(:response) { double(:code => 200, :header => {}) }
-  let(:http) { double(:shutdown => nil, :request => response) }
+  let(:app) { Rpush::Wpns::App.create!(name: "MyApp") }
+  let(:notification) do Rpush::Wpns::Notification.create!(app: app, alert: "test",
+                                                          uri: "http://some.example/",
+                                                          deliver_after: Time.now)
+  end
+  let(:logger) { double(error: nil, info: nil, warn: nil) }
+  let(:response) { double(code: 200, header: {}) }
+  let(:http) { double(shutdown: nil, request: response) }
   let(:now) { Time.parse('2012-10-14 00:00:00') }
-  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil) }
+  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil, notification_processed: nil) }
   let(:delivery) { Rpush::Daemon::Wpns::Delivery.new(app, http, notification, batch) }
-  let(:store) { double(:create_wpns_notification => double(:id => 2)) }
+  let(:store) { double(create_wpns_notification: double(id: 2)) }
 
   def perform
     delivery.perform
   end
 
+  def perform_with_rescue
+    expect { perform }.to raise_error
+  end
+
   before do
-    delivery.stub(:reflect => nil)
-    Rpush::Daemon.stub(:store => store)
-    Time.stub(:now => now)
-    Rpush.stub(:logger => logger)
+    delivery.stub(reflect: nil)
+    Rpush::Daemon.stub(store: store)
+    Time.stub(now: now)
+    Rpush.stub(logger: logger)
   end
 
   shared_examples_for "an notification with some delivery faliures" do
     let(:new_notification) { Rpush::Wpns::Notification.where('id != ?', notification.id).first }
 
-    before { response.stub(:body => JSON.dump(body)) }
+    before { response.stub(body: JSON.dump(body)) }
 
     it "marks the original notification falied" do
-      delivery.should_receive(:mark_failed).with(notification, nil, error_description)
-      perform rescue Rpush::DeliveryError
+      delivery.should_receive(:mark_failed) do |error|
+        error.message.should =~ error_description
+      end
+      perform_with_rescue
     end
 
     it "raises a DeliveryError" do
@@ -41,99 +48,102 @@ describe Rpush::Daemon::Wpns::Delivery do
 
   describe "an 200 response" do
     before do
-      response.stub(:code => 200)
+      response.stub(code: 200)
     end
 
     it "marks the notification as delivered if delivered successfully to all devices" do
-      response.stub(:body => JSON.dump({ "failure" => 0 }))
-      response.stub(:to_hash => {"x-notificationstatus" => ["Received"]})
+      response.stub(body: JSON.dump("failure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["Received"] })
       batch.should_receive(:mark_delivered).with(notification)
       perform
     end
 
     it "retries the notification when the queue is full" do
-      response.stub(:body => JSON.dump({ "failure" => 0 }))
-      response.stub(:to_hash => { "x-notificationstatus" => ["QueueFull"] })
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*10))
+      response.stub(body: JSON.dump("failure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["QueueFull"] })
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 10))
       perform
     end
 
     it "marks the notification as failed if the notification is suppressed" do
-      response.stub(:body => JSON.dump({ "faliure" => 0 }))
-      response.stub(:to_hash => { "x-notificationstatus" => ["Suppressed"] })
-      delivery.should_receive(:mark_failed).with(200, "Notification was received but suppressed by the service.")
-      perform rescue Rpush::DeliveryError
+      response.stub(body: JSON.dump("faliure" => 0))
+      response.stub(to_hash: { "x-notificationstatus" => ["Suppressed"] })
+      error = Rpush::DeliveryError.new(200, notification.id, 'Notification was received but suppressed by the service.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 400 response" do
-    before { response.stub(:code => 400) }
+    before { response.stub(code: 400) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(400,
-        "Bad XML or malformed notification URI.")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(400, notification.id, 'Bad XML or malformed notification URI.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 401 response" do
-    before { response.stub(:code => 401) }
+    before { response.stub(code: 401) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(401,
-        "Unauthorized to send a notification to this app.")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(401, notification.id, 'Unauthorized to send a notification to this app.')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 404 response" do
-    before { response.stub(:code => 404) }
+    before { response.stub(code: 404) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(404, "Not Found")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(404, notification.id, 'Not Found')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 405 response" do
-    before { response.stub(:code => 405) }
+    before { response.stub(code: 405) }
     it "marks notifications as failed" do
-      delivery.should_receive(:mark_failed).with(405, "Method Not Allowed")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(405, notification.id, 'Method Not Allowed')
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 
   describe "an 406 response" do
-    before { response.stub(:code => 406) }
+    before { response.stub(code: 406) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*60))
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
       perform
     end
 
     it "logs a warning that the notification will be retried" do
       notification.retries = 1
       notification.deliver_after = now + 2
-      logger.should_receive(:warn).with("[MyApp] Per-day throttling limit reached. Notification 1 will be retried after 2012-10-14 00:00:02 (retry 1).")
+      logger.should_receive(:warn).with("[MyApp] Per-day throttling limit reached. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
       perform
     end
   end
 
   describe "an 412 response" do
-    before { response.stub(:code => 412) }
+    before { response.stub(code: 412) }
 
     it "retries the notification" do
-      batch.should_receive(:mark_retryable).with(notification, Time.now + (60*60))
+      batch.should_receive(:mark_retryable).with(notification, Time.now + (60 * 60))
       perform
     end
 
     it "logs a warning that the notification will be retried" do
       notification.retries = 1
       notification.deliver_after = now + 2
-      logger.should_receive(:warn).with("[MyApp] Device unreachable. Notification 1 will be retried after 2012-10-14 00:00:02 (retry 1).")
+      logger.should_receive(:warn).with("[MyApp] Device unreachable. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
       perform
     end
   end
 
   describe "an 503 response" do
-    before { response.stub(:code => 503) }
+    before { response.stub(code: 503) }
 
     it "retries the notification exponentially" do
       delivery.should_receive(:mark_retryable_exponential).with(notification)
@@ -149,11 +159,12 @@ describe Rpush::Daemon::Wpns::Delivery do
   end
 
   describe 'an un-handled response' do
-    before { response.stub(:code => 418) }
+    before { response.stub(code: 418) }
 
     it 'marks the notification as failed' do
-      delivery.should_receive(:mark_failed).with(418, "I'm a Teapot")
-      perform rescue Rpush::DeliveryError
+      error = Rpush::DeliveryError.new(418, notification.id, "I'm a Teapot")
+      delivery.should_receive(:mark_failed).with(error)
+      perform_with_rescue
     end
   end
 end

data/spec/unit/daemon_spec.rb

@@ -6,75 +6,66 @@ describe Rpush::Daemon, "when starting" do
 
   let(:certificate) { double }
   let(:password) { double }
-  let(:config) { double(:pid_file => nil, :foreground => true,
-    :embedded => false, :push => false, :store => :active_record,
-    :logger => nil) }
-  let(:logger) { double(:logger, :info => nil, :error => nil, :warn => nil) }
+  let(:logger) { double(:logger, info: nil, error: nil, warn: nil) }
 
   before do
-    Rpush.stub(:config => config, :logger => logger)
+    Rpush.stub(logger: logger)
     Rpush::Daemon::Feeder.stub(:start)
-    Rpush::Daemon::AppRunner.stub(:sync => nil, :stop => nil)
-    Rpush::Daemon.stub(:daemonize => nil, :exit => nil, :puts => nil)
+    Rpush::Daemon::AppRunner.stub(sync: nil, stop: nil)
+    Rpush::Daemon.stub(exit: nil, puts: nil)
+    Rpush::Daemon::SignalHandler.stub(start: nil, stop: nil, handle_shutdown_signal: nil)
+    Process.stub(:daemon)
     File.stub(:open)
-    Rails.stub(:root).and_return("/rails_root")
   end
 
   unless Rpush.jruby?
     it "forks into a daemon if the foreground option is false" do
-      config.stub(:foreground => false)
+      Rpush.config.foreground = false
       Rpush::Daemon.initialize_store
-      Rpush::Daemon.store.stub(:after_daemonize => nil)
-      Rpush::Daemon.should_receive(:daemonize)
-      Rpush::Daemon.start
-    end
-
-    it 'notifies the store after forking' do
-      config.stub(:foreground => false)
-      Rpush::Daemon.initialize_store
-      Rpush::Daemon.store.should_receive(:after_daemonize)
+      Process.should_receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the foreground option is true" do
-      config.stub(:foreground => true)
-      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush.config.foreground = true
+      Process.should_not_receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the push option is true" do
-      config.stub(:push => true)
-      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush.config.push = true
+      Process.should_not_receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the embedded option is true" do
-      config.stub(:embedded => true)
-      Rpush::Daemon.should_not_receive(:daemonize)
+      Rpush.config.embedded = true
+      Process.should_not_receive(:daemon)
       Rpush::Daemon.start
     end
   end
 
-  it 'sets up setup signal traps' do
-    Rpush::Daemon.should_receive(:setup_signal_traps)
+  it 'releases the store connection' do
+    Rpush::Daemon.store = double
+    Rpush::Daemon.store.should_receive(:release_connection)
     Rpush::Daemon.start
   end
 
-  it 'does not setup signal traps when embedded' do
-    config.stub(:embedded => true)
-    Rpush::Daemon.should_not_receive(:setup_signal_traps)
+  it 'sets up setup signal traps' do
+    Rpush::Daemon::SignalHandler.should_receive(:start)
     Rpush::Daemon.start
   end
 
   it 'instantiates the store' do
-    config.stub(:store => :active_record)
+    Rpush.config.client = :active_record
     Rpush::Daemon.start
     Rpush::Daemon.store.should be_kind_of(Rpush::Daemon::Store::ActiveRecord)
   end
 
   it 'logs an error if the store cannot be loaded' do
-    config.stub(:store => :foo_bar)
+    Rpush.config.client = :foo_bar
     Rpush.logger.should_receive(:error).with(kind_of(LoadError))
+    Rpush::Daemon.stub(:exit) { Rpush::Daemon.store = double.as_null_object }
     Rpush::Daemon.start
   end
 
@@ -84,7 +75,7 @@ describe Rpush::Daemon, "when starting" do
   end
 
   it "logs an error if the PID file could not be written" do
-    config.stub(:pid_file => '/rails_root/rpush.pid')
+    Rpush.config.pid_file = '/rails_root/rpush.pid'
     File.stub(:open).and_raise(Errno::ENOENT)
     logger.should_receive(:error).with("Failed to write PID to '/rails_root/rpush.pid': #<Errno::ENOENT: No such file or directory>")
     Rpush::Daemon.start
@@ -99,61 +90,35 @@ describe Rpush::Daemon, "when starting" do
     Rpush::Daemon::AppRunner.should_receive(:sync)
     Rpush::Daemon.start
   end
-end
-
-describe Rpush::Daemon, "when being shutdown" do
-  let(:config) { double(:pid_file => '/rails_root/rpush.pid') }
-  let(:logger) { double(:info => nil, :error => nil, :warn => nil) }
-
-  before do
-    Rpush.stub(:config => config)
-    Rpush::Daemon.stub(:puts => nil)
-    Rpush::Daemon::Feeder.stub(:stop)
-    Rpush::Daemon::AppRunner.stub(:stop)
-  end
 
-  # These tests do not work on JRuby.
-  unless Rpush.jruby?
-    it "shuts down when signaled signaled SIGINT" do
-      Rpush::Daemon.setup_signal_traps
-      Rpush::Daemon.should_receive(:shutdown)
-      Process.kill("SIGINT", Process.pid)
-      sleep 0.01
+  describe "shutdown" do
+    it "stops the feeder" do
+      Rpush::Daemon::Feeder.should_receive(:stop)
+      Rpush::Daemon.shutdown
     end
 
-    it "shuts down when signaled signaled SIGTERM" do
-      Rpush::Daemon.setup_signal_traps
-      Rpush::Daemon.should_receive(:shutdown)
-      Process.kill("SIGTERM", Process.pid)
-      sleep 0.01
+    it "stops the app runners" do
+      Rpush::Daemon::AppRunner.should_receive(:stop)
+      Rpush::Daemon.shutdown
     end
-  end
-
-  it "stops the feeder" do
-    Rpush::Daemon::Feeder.should_receive(:stop)
-    Rpush::Daemon.shutdown
-  end
-
-  it "stops the app runners" do
-    Rpush::Daemon::AppRunner.should_receive(:stop)
-    Rpush::Daemon.shutdown
-  end
 
-  it "removes the PID file if one was written" do
-    File.stub(:exists?).and_return(true)
-    File.should_receive(:delete).with("/rails_root/rpush.pid")
-    Rpush::Daemon.shutdown
-  end
+    it "removes the PID file if one was written" do
+      Rpush.config.pid_file = "/rails_root/rpush.pid"
+      File.stub(:exist?).and_return(true)
+      File.should_receive(:delete).with("/rails_root/rpush.pid")
+      Rpush::Daemon.shutdown
+    end
 
-  it "does not attempt to remove the PID file if it does not exist" do
-    File.stub(:exists?).and_return(false)
-    File.should_not_receive(:delete)
-    Rpush::Daemon.shutdown
-  end
+    it "does not attempt to remove the PID file if it does not exist" do
+      File.stub(:exists?).and_return(false)
+      File.should_not_receive(:delete)
+      Rpush::Daemon.shutdown
+    end
 
-  it "does not attempt to remove the PID file if one was not written" do
-    config.stub(:pid_file).and_return(nil)
-    File.should_not_receive(:delete)
-    Rpush::Daemon.shutdown
+    it "does not attempt to remove the PID file if one was not written" do
+      Rpush.config.pid_file = nil
+      File.should_not_receive(:delete)
+      Rpush::Daemon.shutdown
+    end
   end
 end

data/spec/unit/embed_spec.rb

@@ -2,10 +2,12 @@ require 'unit_spec_helper'
 
 describe Rpush, 'embed' do
   before do
-    Rpush::Daemon.stub(:start)
+    Rpush::Daemon.stub(start: nil, shutdown: nil)
     Kernel.stub(:at_exit)
   end
 
+  after { Rpush.shutdown }
+
   it 'sets the embedded config option to true' do
     Rpush.embed
     Rpush.config.embedded.should be_true
@@ -18,7 +20,7 @@ describe Rpush, 'embed' do
 
   it 'overrides the default config options with those given as a hash' do
     Rpush.config.push_poll = 4
-    expect { Rpush.embed(:push_poll => 2) }.to change(Rpush.config, :push_poll).to(2)
+    expect { Rpush.embed(push_poll: 2) }.to change(Rpush.config, :push_poll).to(2)
   end
 end
 

data/spec/unit/logger_spec.rb

@@ -1,74 +1,59 @@
 require "unit_spec_helper"
 
 module Rails
-  def self.logger
-    @logger
-  end
-
-  def self.logger=(logger)
-    @logger = logger
-  end
-end
-
-module HoptoadNotifier
-  def self.notify(e)
-  end
+  attr_accessor :logger
 end
 
 describe Rpush::Logger do
   let(:log) { double(:sync= => true) }
 
   before do
-    Rails.stub(:root).and_return("/rails_root")
-
-    @logger_class = if defined?(ActiveSupport::BufferedLogger)
-      ActiveSupport::BufferedLogger
-    else
-      ActiveSupport::Logger
-    end
-
-    @logger = double(@logger_class.name, :info => nil, :error => nil, :level => 0, :auto_flushing => 1, :auto_flushing= => nil)
+    @logger_class = defined?(ActiveSupport::BufferedLogger) ? ActiveSupport::BufferedLogger : ActiveSupport::Logger
+    @logger = double(@logger_class.name, info: nil, error: nil, level: 0, auto_flushing: 1, :auto_flushing= => nil)
     @logger_class.stub(:new).and_return(@logger)
     Rails.logger = @logger
-    File.stub(:open => log)
-    FileUtils.stub(:mkdir_p => nil)
+    File.stub(open: log)
+    FileUtils.stub(mkdir_p: nil)
     STDERR.stub(:puts)
+    Rpush.config.foreground = true
+    Rpush.config.log_dir = Rails.root
   end
 
   it "disables logging if the log file cannot be opened" do
     File.stub(:open).and_raise(Errno::ENOENT)
     STDERR.should_receive(:puts).with(/No such file or directory/)
     STDERR.should_receive(:puts).with(/Logging disabled/)
-    Rpush::Logger.new(:foreground => true)
+    Rpush::Logger.new
   end
 
   it 'creates the log directory' do
-    FileUtils.should_receive(:mkdir_p).with('/rails_root/log')
-    Rpush::Logger.new(:foreground => true)
+    FileUtils.should_receive(:mkdir_p).with('/tmp/rails_root/log')
+    Rpush::Logger.new
   end
 
   it "should open the a log file in the Rails log directory" do
-    File.should_receive(:open).with('/rails_root/log/rpush.log', 'a')
-    Rpush::Logger.new(:foreground => true)
+    File.should_receive(:open).with('/tmp/rails_root/log/rpush.log', 'a')
+    Rpush::Logger.new
   end
 
   it 'sets sync mode on the log descriptor' do
     log.should_receive(:sync=).with(true)
-    Rpush::Logger.new(:foreground => true)
+    Rpush::Logger.new
   end
 
   it 'uses the user-defined logger' do
     my_logger = double
     Rpush.config.logger = my_logger
-    logger = Rpush::Logger.new({})
+    logger = Rpush::Logger.new
     my_logger.should_receive(:info)
+    Rpush.config.foreground = false
     logger.info('test')
   end
 
   it 'uses ActiveSupport::BufferedLogger if a user-defined logger is not set' do
     if ActiveSupport.const_defined?('BufferedLogger')
       ActiveSupport::BufferedLogger.should_receive(:new).with(log, Rails.logger.level)
-      Rpush::Logger.new(:foreground => true)
+      Rpush::Logger.new
     end
   end
 
@@ -76,51 +61,56 @@ describe Rpush::Logger do
     stub_const('ActiveSupport::Logger', double)
     ActiveSupport.stub(:const_defined? => false)
     ActiveSupport::Logger.should_receive(:new).with(log, Rails.logger.level)
-    Rpush::Logger.new(:foreground => true)
+    Rpush::Logger.new
   end
 
   it "should print out the msg if running in the foreground" do
-    logger = Rpush::Logger.new(:foreground => true)
+    logger = Rpush::Logger.new
     STDOUT.should_receive(:puts).with(/hi mom/)
     logger.info("hi mom")
   end
 
   it "should not print out the msg if not running in the foreground" do
-    logger = Rpush::Logger.new(:foreground => false)
+    Rpush.config.foreground = false
+    logger = Rpush::Logger.new
     STDOUT.should_not_receive(:puts).with(/hi mom/)
     logger.info("hi mom")
   end
 
   it "should prefix log lines with the current time" do
+    Rpush.config.foreground = false
     now = Time.now
     Time.stub(:now).and_return(now)
-    logger = Rpush::Logger.new(:foreground => false)
+    logger = Rpush::Logger.new
     @logger.should_receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
     logger.info("blah")
   end
 
   it "should prefix error logs with the ERROR label" do
-    logger = Rpush::Logger.new(:foreground => false)
+    Rpush.config.foreground = false
+    logger = Rpush::Logger.new
     @logger.should_receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
     logger.error("eeek")
   end
 
   it "should prefix warn logs with the WARNING label" do
-    logger = Rpush::Logger.new(:foreground => false)
+    Rpush.config.foreground = false
+    logger = Rpush::Logger.new
     @logger.should_receive(:warn).with(/#{Regexp.escape("[WARNING]")}/)
     logger.warn("eeek")
   end
 
   it "should handle an Exception instance" do
+    Rpush.config.foreground = false
     e = RuntimeError.new("hi mom")
-    e.stub(:backtrace => [])
-    logger = Rpush::Logger.new(:foreground => false)
+    e.stub(backtrace: [])
+    logger = Rpush::Logger.new
     @logger.should_receive(:error).with(/RuntimeError, hi mom/)
     logger.error(e)
   end
 
   it 'defaults auto_flushing to true if the Rails logger does not respond to auto_flushing' do
-    rails_logger = double(:info => nil, :error => nil, :level => 0)
+    rails_logger = double(info: nil, error: nil, level: 0)
     Rails.logger = rails_logger
     @logger.auto_flushing.should be_true
   end