rpush 2.3.1 → 2.3.2

data/spec/unit/daemon_spec.rb

@@ -9,58 +9,61 @@ describe Rpush::Daemon, "when starting" do
   let(:logger) { double(:logger, info: nil, error: nil, warn: nil, internal_logger: nil) }
 
   before do
-    Rpush.stub(logger: logger)
-    Rpush::Daemon::Feeder.stub(:start)
-    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)
+    allow(Rpush).to receive(:logger) { logger }
+    allow(Rpush::Daemon::Feeder).to receive(:start)
+    allow(Rpush::Daemon::Synchronizer).to receive(:sync)
+    allow(Rpush::Daemon::AppRunner).to receive(:stop)
+    allow(Rpush::Daemon).to receive(:exit)
+    allow(Rpush::Daemon).to receive(:puts)
+    allow(Rpush::Daemon::SignalHandler).to receive(:start)
+    allow(Rpush::Daemon::SignalHandler).to receive(:stop)
+    allow(Rpush::Daemon::SignalHandler).to receive(:handle_shutdown_signal)
+    allow(Process).to receive(:daemon)
+    allow(File).to receive(:open)
   end
 
   unless Rpush.jruby?
     it "forks into a daemon if the foreground option is false" do
       Rpush.config.foreground = false
       Rpush::Daemon.common_init
-      Process.should_receive(:daemon)
+      expect(Process).to receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the foreground option is true" do
       Rpush.config.foreground = true
-      Process.should_not_receive(:daemon)
+      expect(Process).to_not receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the push option is true" do
       Rpush.config.push = true
-      Process.should_not_receive(:daemon)
+      expect(Process).to_not receive(:daemon)
       Rpush::Daemon.start
     end
 
     it "does not fork into a daemon if the embedded option is true" do
       Rpush.config.embedded = true
-      Process.should_not_receive(:daemon)
+      expect(Process).to_not receive(:daemon)
       Rpush::Daemon.start
     end
   end
 
   it 'releases the store connection' do
     Rpush::Daemon.store = double
-    Rpush::Daemon.store.should_receive(:release_connection)
+    expect(Rpush::Daemon.store).to receive(:release_connection)
     Rpush::Daemon.start
   end
 
   it 'sets up setup signal traps' do
-    Rpush::Daemon::SignalHandler.should_receive(:start)
+    expect(Rpush::Daemon::SignalHandler).to receive(:start)
     Rpush::Daemon.start
   end
 
   it 'instantiates the store' do
     Rpush.config.client = :active_record
     Rpush::Daemon.start
-    Rpush::Daemon.store.should be_kind_of(Rpush::Daemon::Store::ActiveRecord)
+    expect(Rpush::Daemon.store).to be_kind_of(Rpush::Daemon::Store::ActiveRecord)
   end
 
   it 'initializes plugins' do
@@ -68,65 +71,65 @@ describe Rpush::Daemon, "when starting" do
     did_init = false
     plugin.init { did_init = true }
     Rpush::Daemon.common_init
-    expect(did_init).to be_true
+    expect(did_init).to eq(true)
   end
 
   it 'logs an error if the store cannot be loaded' do
     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 }
+    expect(Rpush.logger).to receive(:error).with(kind_of(LoadError))
+    allow(Rpush::Daemon).to receive(:exit) { Rpush::Daemon.store = double.as_null_object }
     Rpush::Daemon.start
   end
 
   it "writes the process ID to the PID file" do
-    Rpush::Daemon.should_receive(:write_pid_file)
+    expect(Rpush::Daemon).to receive(:write_pid_file)
     Rpush::Daemon.start
   end
 
   it "logs an error if the PID file could not be written" do
     Rpush.config.pid_file = '/rails_root/rpush.pid'
-    File.stub(:open).and_raise(Errno::ENOENT)
-    logger.should_receive(:error).with(%r{Failed to write PID to '/rails_root/rpush\.pid'})
+    allow(File).to receive(:open).and_raise(Errno::ENOENT)
+    expect(logger).to receive(:error).with(%r{Failed to write PID to '/rails_root/rpush\.pid'})
     Rpush::Daemon.start
   end
 
   it "starts the feeder" do
-    Rpush::Daemon::Feeder.should_receive(:start)
+    expect(Rpush::Daemon::Feeder).to receive(:start)
     Rpush::Daemon.start
   end
 
   it "syncs apps" do
-    Rpush::Daemon::Synchronizer.should_receive(:sync)
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
     Rpush::Daemon.start
   end
 
   describe "shutdown" do
     it "stops the feeder" do
-      Rpush::Daemon::Feeder.should_receive(:stop)
+      expect(Rpush::Daemon::Feeder).to receive(:stop)
       Rpush::Daemon.shutdown
     end
 
     it "stops the app runners" do
-      Rpush::Daemon::AppRunner.should_receive(:stop)
+      expect(Rpush::Daemon::AppRunner).to receive(:stop)
       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")
+      allow(File).to receive(:exist?) { true }
+      expect(File).to 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)
+      allow(File).to receive(:exist?) { false }
+      expect(File).to_not receive(:delete)
       Rpush::Daemon.shutdown
     end
 
     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)
+      expect(File).to_not receive(:delete)
       Rpush::Daemon.shutdown
     end
   end

data/spec/unit/deprecatable_spec.rb

@@ -17,16 +17,16 @@ describe Rpush::Deprecatable do
   let(:klass) { HasDeprecatedMethod.new }
 
   before do
-    Rpush::Deprecation.stub(:warn)
+    allow(Rpush::Deprecation).to receive(:warn)
   end
 
   it 'warns the method is deprecated when called' do
-    Rpush::Deprecation.should_receive(:warn).with(/deprecated_method is deprecated and will be removed from Rpush 4\.0\./)
+    expect(Rpush::Deprecation).to receive(:warn).with(/deprecated_method is deprecated and will be removed from Rpush 4\.0\./)
     klass.deprecated_method
   end
 
   it 'calls the original method' do
     klass.deprecated_method
-    klass.original_called?.should be_true
+    expect(klass.original_called?).to eq(true)
   end
 end

data/spec/unit/deprecation_spec.rb

@@ -2,12 +2,12 @@ require 'unit_spec_helper'
 
 describe Rpush::Deprecation do
   it 'prints a warning' do
-    STDERR.should_receive(:puts).with("DEPRECATION WARNING: msg")
+    expect(STDERR).to receive(:puts).with("DEPRECATION WARNING: msg")
     Rpush::Deprecation.warn("msg")
   end
 
   it 'does not print a warning when muted' do
-    STDERR.should_not_receive(:puts)
+    expect(STDERR).not_to receive(:puts)
     Rpush::Deprecation.muted do
       Rpush::Deprecation.warn("msg")
     end

data/spec/unit/embed_spec.rb

@@ -2,19 +2,19 @@ require 'unit_spec_helper'
 
 describe Rpush, 'embed' do
   before do
-    Rpush::Daemon.stub(start: nil, shutdown: nil)
-    Kernel.stub(:at_exit)
+    allow(Rpush::Daemon).to receive_messages(start: nil, shutdown: nil)
+    allow(Kernel).to receive(:at_exit)
   end
 
   after { Rpush.shutdown }
 
   it 'sets the embedded config option to true' do
     Rpush.embed
-    Rpush.config.embedded.should be_true
+    expect(Rpush.config.embedded).to eq(true)
   end
 
   it 'starts the daemon' do
-    Rpush::Daemon.should_receive(:start)
+    expect(Rpush::Daemon).to receive(:start)
     Rpush.embed
   end
 
@@ -28,7 +28,7 @@ describe Rpush, 'shutdown' do
   before { Rpush.config.embedded = true }
 
   it 'shuts down the daemon' do
-    Rpush::Daemon.should_receive(:shutdown)
+    expect(Rpush::Daemon).to receive(:shutdown)
     Rpush.shutdown
   end
 end
@@ -37,7 +37,7 @@ describe Rpush, 'sync' do
   before { Rpush.config.embedded = true }
 
   it 'syncs' do
-    Rpush::Daemon::Synchronizer.should_receive(:sync)
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
     Rpush.sync
   end
 end
@@ -46,7 +46,7 @@ describe Rpush, 'debug' do
   before { Rpush.config.embedded = true }
 
   it 'debugs the AppRunner' do
-    Rpush::Daemon::AppRunner.should_receive(:debug)
+    expect(Rpush::Daemon::AppRunner).to receive(:debug)
     Rpush.debug
   end
 end

data/spec/unit/logger_spec.rb

@@ -9,34 +9,34 @@ describe Rpush::Logger do
 
   before do
     @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.stub(logger: @logger)
-    File.stub(open: log)
-    FileUtils.stub(mkdir_p: nil)
-    STDERR.stub(:puts)
+    @logger = double(@logger_class.name, info: nil, error: nil, level: 0, auto_flushing: true, :auto_flushing= => nil)
+    allow(@logger_class).to receive(:new).and_return(@logger)
+    allow(Rails).to receive_messages(logger: @logger)
+    allow(File).to receive_messages(open: log)
+    allow(FileUtils).to receive_messages(mkdir_p: nil)
+    allow(STDERR).to receive(:puts)
     Rpush.config.foreground = true
     Rpush.config.log_file = 'log/rpush.log'
   end
 
   it "disables logging if the log file cannot be opened" do
-    File.stub(:open).and_raise(Errno::ENOENT)
-    STDERR.should_receive(:puts).with(/Logging disabled/)
+    allow(File).to receive(:open).and_raise(Errno::ENOENT)
+    expect(STDERR).to receive(:puts).with(/Logging disabled/)
     Rpush::Logger.new
   end
 
   it 'creates the log directory' do
-    FileUtils.should_receive(:mkdir_p).with('/tmp/rails_root/log')
+    expect(FileUtils).to 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('/tmp/rails_root/log/rpush.log', 'a')
+    expect(File).to 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)
+    expect(log).to receive(:sync=).with(true)
     Rpush::Logger.new
   end
 
@@ -44,28 +44,28 @@ describe Rpush::Logger do
     my_logger = double
     Rpush.config.logger = my_logger
     logger = Rpush::Logger.new
-    my_logger.should_receive(:info)
+    expect(my_logger).to 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)
+      expect(ActiveSupport::BufferedLogger).to receive(:new).with(log, Rails.logger.level)
       Rpush::Logger.new
     end
   end
 
   it 'uses ActiveSupport::Logger if BufferedLogger does not exist' do
     stub_const('ActiveSupport::Logger', double)
-    ActiveSupport.stub(:const_defined? => false)
-    ActiveSupport::Logger.should_receive(:new).with(log, Rails.logger.level)
+    allow(ActiveSupport).to receive_messages(:const_defined? => false)
+    expect(ActiveSupport::Logger).to receive(:new).with(log, Rails.logger.level)
     Rpush::Logger.new
   end
 
   it "should print out the msg if running in the foreground" do
     logger = Rpush::Logger.new
-    STDOUT.should_receive(:puts).with(/hi mom/)
+    expect(STDOUT).to receive(:puts).with(/hi mom/)
     logger.info("hi mom")
   end
 
@@ -73,7 +73,7 @@ describe Rpush::Logger do
     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/)
+      expect(STDOUT).not_to receive(:puts).with(/hi mom/)
       logger.info("hi mom")
     end
   end
@@ -81,38 +81,38 @@ describe Rpush::Logger do
   it "should prefix log lines with the current time" do
     Rpush.config.foreground = false
     now = Time.now
-    Time.stub(:now).and_return(now)
+    allow(Time).to receive(:now).and_return(now)
     logger = Rpush::Logger.new
-    @logger.should_receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
+    expect(@logger).to receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
     logger.info("blah")
   end
 
   it "should prefix error logs with the ERROR label" do
     Rpush.config.foreground = false
     logger = Rpush::Logger.new
-    @logger.should_receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
+    expect(@logger).to receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
     logger.error("eeek")
   end
 
   it "should prefix warn logs with the WARNING label" do
     Rpush.config.foreground = false
     logger = Rpush::Logger.new
-    @logger.should_receive(:warn).with(/#{Regexp.escape("[WARNING]")}/)
+    expect(@logger).to 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: [])
+    allow(e).to receive_messages(backtrace: [])
     logger = Rpush::Logger.new
-    @logger.should_receive(:error).with(/RuntimeError, hi mom/)
+    expect(@logger).to 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.stub(logger: double(info: nil, error: nil, level: 0))
+    allow(Rails).to receive_messages(logger: double(info: nil, error: nil, level: 0))
     Rpush::Logger.new
-    @logger.auto_flushing.should be_true
+    expect(@logger.auto_flushing).to eq(true)
   end
 end

data/spec/unit/notification_shared.rb

@@ -1,18 +1,18 @@
 shared_examples_for "an Notification subclass" do
   describe "when assigning data for the device" do
-    before { Rpush::Deprecation.stub(:warn) }
+    before { allow(Rpush::Deprecation).to receive(:warn) }
 
     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)
+      allow(MultiJson).to receive(:respond_to?).with(:dump).and_return(true)
+      expect(MultiJson).to 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)
+      allow(MultiJson).to receive(:respond_to?).with(:dump).and_return(false)
+      expect(MultiJson).to receive(:encode).with(any_args)
       notification.data = { ninjas: 1 }
     end
 
@@ -24,12 +24,12 @@ shared_examples_for "an Notification subclass" do
 
     it "encodes the given Hash as JSON" do
       notification.data = { hi: "mom" }
-      notification.read_attribute(:data).should eq("{\"hi\":\"mom\"}")
+      expect(notification.read_attribute(:data)).to eq("{\"hi\":\"mom\"}")
     end
 
     it "decodes the JSON when using the reader method" do
       notification.data = { hi: "mom" }
-      notification.data.should eq("hi" => "mom")
+      expect(notification.data).to eq("hi" => "mom")
     end
   end
 end

data/spec/unit/plugin_spec.rb

@@ -20,7 +20,7 @@ describe Rpush::Plugin do
     plugin.configure do |config|
       config.is_configured = true
     end
-    expect(Rpush.config.plugin.test.is_configured).to be_true
+    expect(Rpush.config.plugin.test.is_configured).to eq(true)
   end
 
   it 'can hook up reflections' do

data/spec/unit/push_spec.rb

@@ -2,33 +2,33 @@ require 'unit_spec_helper'
 
 describe Rpush, 'push' do
   before do
-    Rpush::Daemon::Synchronizer.stub(sync: nil)
-    Rpush::Daemon::AppRunner.stub(wait: nil)
-    Rpush::Daemon::Feeder.stub(start: nil)
+    allow(Rpush::Daemon::Synchronizer).to receive_messages(sync: nil)
+    allow(Rpush::Daemon::AppRunner).to receive_messages(wait: nil)
+    allow(Rpush::Daemon::Feeder).to receive_messages(start: nil)
   end
 
   it 'sets the push config option to true' do
     Rpush.push
-    Rpush.config.push.should be_true
+    expect(Rpush.config.push).to eq(true)
   end
 
   it 'initializes the daemon' do
-    Rpush::Daemon.should_receive(:common_init)
+    expect(Rpush::Daemon).to receive(:common_init)
     Rpush.push
   end
 
   it 'syncs' do
-    Rpush::Daemon::Synchronizer.should_receive(:sync)
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
     Rpush.push
   end
 
   it 'starts the feeder' do
-    Rpush::Daemon::Feeder.should_receive(:start)
+    expect(Rpush::Daemon::Feeder).to receive(:start)
     Rpush.push
   end
 
   it 'stops on the app runner' do
-    Rpush::Daemon::AppRunner.should_receive(:stop)
+    expect(Rpush::Daemon::AppRunner).to receive(:stop)
     Rpush.push
   end