rpush 1.0.0-java → 2.0.0-java

data/spec/unit/daemon_spec.rb

@@ -6,75 +6,67 @@ 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::Synchronizer.stub(sync: nil)
+    Rpush::Daemon::AppRunner.stub(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 +76,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
@@ -96,64 +88,38 @@ describe Rpush::Daemon, "when starting" do
   end
 
   it "syncs apps" do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush::Daemon::Synchronizer.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
 
@@ -34,8 +36,8 @@ end
 describe Rpush, 'sync' do
   before { Rpush.config.embedded = true }
 
-  it 'syncs the AppRunner' do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+  it 'syncs' do
+    Rpush::Daemon::Synchronizer.should_receive(:sync)
     Rpush.sync
   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,58 @@ 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)
-    STDOUT.should_not_receive(:puts).with(/hi mom/)
-    logger.info("hi mom")
+  unless Rpush.jruby? # These tests do not work on JRuby.
+    it "should not print out the msg if not running in the foreground" do
+      Rpush.config.foreground = false
+      logger = Rpush::Logger.new
+      STDOUT.should_not_receive(:puts).with(/hi mom/)
+      logger.info("hi mom")
+    end
   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

data/spec/unit/notification_shared.rb

@@ -5,101 +5,31 @@ shared_examples_for "an Notification subclass" do
     it "calls MultiJson.dump when multi_json responds to :dump" do
       notification = notification_class.new
       MultiJson.stub(:respond_to?).with(:dump).and_return(true)
-      MultiJson.should_receive(:dump).with(any_args())
-      notification.send(data_setter, { :pirates => 1 })
+      MultiJson.should_receive(:dump).with(any_args)
+      notification.data = { pirates: 1 }
     end
 
     it "calls MultiJson.encode when multi_json does not respond to :dump" do
       notification = notification_class.new
       MultiJson.stub(:respond_to?).with(:dump).and_return(false)
-      MultiJson.should_receive(:encode).with(any_args())
-      notification.send(data_setter, { :ninjas => 1 })
+      MultiJson.should_receive(:encode).with(any_args)
+      notification.data = { ninjas: 1 }
     end
 
     it "raises an ArgumentError if something other than a Hash is assigned" do
       expect do
-        notification.send(data_setter, Array.new)
+        notification.data = Array.new
       end.to raise_error(ArgumentError, "must be a Hash")
     end
 
     it "encodes the given Hash as JSON" do
-      notification.send(data_setter, { :hi => "mom" })
-      notification.read_attribute(:data).should eq "{\"hi\":\"mom\"}"
+      notification.data = { hi: "mom" }
+      notification.read_attribute(:data).should eq("{\"hi\":\"mom\"}")
     end
 
     it "decodes the JSON when using the reader method" do
-      notification.send(data_setter, { :hi => "mom" })
-      notification.send(data_getter).should eq ({"hi" => "mom"})
-    end
-
-    describe 'scopes' do
-      before do
-        Timecop.freeze(Time.now)
-
-        (@delivered_notification = notification_class.new(:app => app, :delivered => true, :failed => false)).save!(:validate => false)
-        (@failed_notification = notification_class.new(:app => app, :delivered => false, :failed => true)).save!(:validate => false)
-        (@new_notification = notification_class.new(:app => app, :delivered => false, :failed => false)).save!(:validate => false)
-      end
-
-      after do
-        Timecop.return
-      end
-
-      describe '.completed' do
-        it 'should return notifications that have been delivered or failed' do
-          completed_notification_ids = Rpush::Notification.completed.map(&:id)
-
-          completed_notification_ids.size.should eq 2
-          completed_notification_ids.should include(@delivered_notification.id, @failed_notification.id)
-          completed_notification_ids.should_not include(@new_notification.id)
-        end
-      end
-
-      describe '.created_before' do
-        it 'should return notifications that were created before the specified date' do
-          @delivered_notification.created_at = Time.now - 30.days - 1.second
-          @delivered_notification.save!(:validate => false)
-
-          notification_ids = Rpush::Notification.created_before(Time.now - 30.days).map(&:id)
-
-          notification_ids.size.should eq 1
-          notification_ids.should include(@delivered_notification.id)
-        end
-      end
-
-      describe '.completed_and_older_than' do
-        before do
-          @delivered_notification.created_at = Time.now - 30.days - 1.second
-          @delivered_notification.save!(:validate => false)
-
-          @failed_notification.created_at = Time.now - 20.days - 1.second
-          @failed_notification.save!(:validate => false)
-
-          @new_notification.created_at = Time.now - 30.days - 1.second
-          @new_notification.save!(:validate => false)
-        end
-
-        it 'should only include completed notifications' do
-          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 30.days).map(&:id)
-
-          notification_ids.size.should eq 1
-          notification_ids.should include(@delivered_notification.id)
-        end
-
-        it 'should not include completed notifications if not older than specified date' do
-          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 30.days).map(&:id)
-
-          notification_ids.size.should eq 1
-          notification_ids.should_not include(@failed_notification.id)
-        end
-
-        it 'should return notifications that are completed and created before the specified date' do
-          notification_ids = Rpush::Notification.completed_and_older_than(Time.now - 20.days).map(&:id)
-
-          notification_ids.size.should eq 2
-          notification_ids.should include(@delivered_notification.id, @failed_notification.id)
-        end
-      end
+      notification.data = { hi: "mom" }
+      notification.data.should eq("hi" => "mom")
     end
   end
 end

data/spec/unit/push_spec.rb

@@ -2,8 +2,9 @@ require 'unit_spec_helper'
 
 describe Rpush, 'push' do
   before do
-    Rpush::Daemon::AppRunner.stub(:sync => nil, :wait => nil)
-    Rpush::Daemon::Feeder.stub(:start => nil)
+    Rpush::Daemon::Synchronizer.stub(sync: nil)
+    Rpush::Daemon::AppRunner.stub(wait: nil)
+    Rpush::Daemon::Feeder.stub(start: nil)
   end
 
   it 'sets the push config option to true' do
@@ -16,8 +17,8 @@ describe Rpush, 'push' do
     Rpush.push
   end
 
-  it 'syncs the app runner' do
-    Rpush::Daemon::AppRunner.should_receive(:sync)
+  it 'syncs' do
+    Rpush::Daemon::Synchronizer.should_receive(:sync)
     Rpush.push
   end
 
@@ -26,11 +27,6 @@ describe Rpush, 'push' do
     Rpush.push
   end
 
-  it 'waits on the app runner' do
-    Rpush::Daemon::AppRunner.should_receive(:wait)
-    Rpush.push
-  end
-
   it 'stops on the app runner' do
     Rpush::Daemon::AppRunner.should_receive(:stop)
     Rpush.push
@@ -38,6 +34,6 @@ describe Rpush, 'push' do
 
   it 'overrides the default config options with those given as a hash' do
     Rpush.config.batch_size = 20
-    expect { Rpush.push(:batch_size => 10) }.to change(Rpush.config, :batch_size).to(10)
+    expect { Rpush.push(batch_size: 10) }.to change(Rpush.config, :batch_size).to(10)
   end
 end

data/spec/unit/reflection_spec.rb

@@ -1,30 +1,30 @@
  require 'unit_spec_helper'
 
-describe Rpush do
-  it 'yields reflections for configuration' do
-    did_yield = false
-    Rpush.reflect { |on| did_yield = true }
-    did_yield.should be_true
-  end
+ describe Rpush do
+   it 'yields reflections for configuration' do
+     did_yield = false
+     Rpush.reflect { did_yield = true }
+     did_yield.should be_true
+   end
 
-  it 'returns all reflections' do
-    Rpush.reflections.should be_kind_of(Rpush::Reflections)
-  end
-end
+   it 'returns all reflections' do
+     Rpush.reflections.should be_kind_of(Rpush::Reflections)
+   end
+ end
 
-describe Rpush::Reflections do
-  it 'dispatches the given reflection' do
-    did_yield = false
-    Rpush.reflect do |on|
-      on.error { did_yield = true }
-    end
-    Rpush.reflections.__dispatch(:error)
-    did_yield.should be_true
-  end
+ describe Rpush::Reflections do
+   it 'dispatches the given reflection' do
+     did_yield = false
+     Rpush.reflect do |on|
+       on.error { did_yield = true }
+     end
+     Rpush.reflections.__dispatch(:error)
+     did_yield.should be_true
+   end
 
-  it 'raises an error when trying to dispatch and unknown reflection' do
-    expect do
-      Rpush.reflections.__dispatch(:unknown)
-    end.to raise_error(Rpush::Reflections::NoSuchReflectionError)
-  end
-end
+   it 'raises an error when trying to dispatch and unknown reflection' do
+     expect do
+       Rpush.reflections.__dispatch(:unknown)
+     end.to raise_error(Rpush::Reflections::NoSuchReflectionError)
+   end
+ end

data/spec/unit/rpush_spec.rb

@@ -2,8 +2,7 @@ require 'unit_spec_helper'
 
 describe Rpush do
   it "lazy initializes the logger" do
-    Rpush.config.stub(:foreground => true)
-    Rpush::Logger.should_receive(:new).with(:foreground => true)
+    Rpush::Logger.should_receive(:new)
     Rpush.logger
   end
 end