rpush_extended 3.2.5

data/spec/unit/logger_spec.rb

@@ -0,0 +1,127 @@
+require "unit_spec_helper"
+
+module Rails
+  attr_accessor :logger
+end
+
+describe Rpush::Logger do
+  let(:log) { double(:sync= => true, :level= => nil) }
+
+  before do
+    @logger_class = defined?(ActiveSupport::BufferedLogger) ? ActiveSupport::BufferedLogger : ActiveSupport::Logger
+    @logger = double(@logger_class.name, info: nil, error: nil, level: 0, :level= => nil, 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
+    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
+    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
+    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
+    expect(log).to receive(:sync=).with(true)
+    Rpush::Logger.new
+  end
+
+  it 'uses the user-defined logger' do
+    my_logger = double(:level= => nil)
+    Rpush.config.logger = my_logger
+    logger = Rpush::Logger.new
+    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')
+      expect(ActiveSupport::BufferedLogger).to receive(:new).with(log)
+      Rpush::Logger.new
+    end
+  end
+
+  it 'uses ActiveSupport::Logger if BufferedLogger does not exist' do
+    stub_const('ActiveSupport::Logger', double)
+    allow(ActiveSupport).to receive_messages(const_defined?: false)
+    expect(ActiveSupport::Logger).to receive(:new).with(log).and_return(log)
+    Rpush::Logger.new
+  end
+
+  it 'sets the log level on the logger' do
+    stub_const('ActiveSupport::Logger', double)
+    allow(ActiveSupport).to receive_messages(const_defined?: false)
+    expect(ActiveSupport::Logger).to receive(:new).with(log).and_return(log)
+    Rpush.config.log_level = ::Logger::Severity::ERROR
+    expect(log).to receive(:level=).with(::Logger::Severity::ERROR)
+    Rpush::Logger.new
+  end
+
+  it "should print out the msg if running in the foreground" do
+    logger = Rpush::Logger.new
+    expect(STDOUT).to receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  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
+      expect(STDOUT).not_to 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
+    allow(Time).to receive(:now).and_return(now)
+    logger = Rpush::Logger.new
+    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
+    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
+    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")
+    allow(e).to receive_messages(backtrace: [])
+    logger = Rpush::Logger.new
+    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
+    allow(Rails).to receive_messages(logger: double(info: nil, error: nil, level: 0))
+    Rpush::Logger.new
+    expect(@logger.auto_flushing).to eq(true)
+  end
+end

data/spec/unit/notification_shared.rb

@@ -0,0 +1,53 @@
+shared_examples_for 'an Notification subclass' do
+  describe 'when assigning data for the device' do
+    before { allow(Rpush::Deprecation).to receive(:warn) }
+
+    it 'calls MultiJson.dump when multi_json responds to :dump' do
+      notification = notification_class.new
+      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
+      allow(MultiJson).to receive(:respond_to?).with(:dump).and_return(false)
+      expect(MultiJson).to 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.data = []
+      end.to raise_error(ArgumentError, 'must be a Hash')
+    end
+
+    it 'encodes the given Hash as JSON' do
+      notification.data = { 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'}
+      expect(notification.data).to eq('hi' => 'mom')
+    end
+  end
+
+  describe 'when assigning the notification payload for the device' do
+    it 'raises an ArgumentError if something other than a Hash is assigned' do
+      expect do
+        notification.notification = []
+      end.to raise_error(ArgumentError, 'must be a Hash')
+    end
+
+    it 'encodes the given Hash as JSON' do
+      notification.notification = { hi: 'dad'}
+      expect(notification.read_attribute(:notification)).to eq('{"hi":"dad"}')
+    end
+
+    it 'decodes the JSON when using the reader method' do
+      notification.notification = { hi: 'dad'}
+      expect(notification.notification).to eq('hi' => 'dad')
+    end
+  end
+end

data/spec/unit/plugin_spec.rb

@@ -0,0 +1,36 @@
+require 'unit_spec_helper'
+
+describe Rpush::Plugin do
+  include Rpush::Reflectable
+
+  it 'can only be initialized once' do
+    plugin = double(Rpush::Plugin, unload: nil)
+    expect(Rpush::Plugin).to receive(:new).once.and_return(plugin)
+    Rpush.plugin(:test)
+    Rpush.plugin(:test)
+  end
+
+  it 'can be referenced' do
+    plugin = Rpush.plugin(:test)
+    expect(Rpush.plugins[:test]).to eq(plugin)
+  end
+
+  it 'can be configured' do
+    plugin = Rpush.plugin(:test)
+    plugin.configure do |config|
+      config.is_configured = true
+    end
+    expect(Rpush.config.plugin.test.is_configured).to eq(true)
+  end
+
+  it 'can hook up reflections' do
+    plugin = Rpush.plugin(:test)
+    reflected_error = nil
+    plugin.reflect do |on|
+      on.error { |error| reflected_error = error }
+    end
+    error = double
+    reflect(:error, error)
+    expect(reflected_error).to eq(error)
+  end
+end

data/spec/unit/push_spec.rb

@@ -0,0 +1,34 @@
+require 'unit_spec_helper'
+
+describe Rpush, 'push' do
+  before do
+    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
+    expect(Rpush.config.push).to eq(true)
+  end
+
+  it 'initializes the daemon' do
+    expect(Rpush::Daemon).to receive(:common_init)
+    Rpush.push
+  end
+
+  it 'syncs' do
+    expect(Rpush::Daemon::Synchronizer).to receive(:sync)
+    Rpush.push
+  end
+
+  it 'starts the feeder' do
+    expect(Rpush::Daemon::Feeder).to receive(:start)
+    Rpush.push
+  end
+
+  it 'stops on the app runner' do
+    expect(Rpush::Daemon::AppRunner).to receive(:stop)
+    Rpush.push
+  end
+end

data/spec/unit/reflectable_spec.rb

@@ -0,0 +1,27 @@
+require 'unit_spec_helper'
+
+describe Rpush::Reflectable do
+  class TestReflectable
+    include Rpush::Reflectable
+  end
+
+  let(:logger) { double(error: nil) }
+  let(:test_reflectable) { TestReflectable.new }
+
+  before do
+    allow(Rpush.reflection_stack[0]).to receive(:__dispatch)
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  it 'dispatches the given reflection' do
+    expect(Rpush.reflection_stack[0]).to receive(:__dispatch).with(:error)
+    test_reflectable.reflect(:error)
+  end
+
+  it 'logs errors raised by the reflection' do
+    error = StandardError.new
+    allow(Rpush.reflection_stack[0]).to receive(:__dispatch).and_raise(error)
+    expect(Rpush.logger).to receive(:error).with(error)
+    test_reflectable.reflect(:error)
+  end
+end

data/spec/unit/reflection_collection_spec.rb

@@ -0,0 +1,26 @@
+ require 'unit_spec_helper'
+
+ describe Rpush do
+   it 'yields reflections for configuration' do
+     did_yield = false
+     Rpush.reflect { did_yield = true }
+     expect(did_yield).to eq(true)
+   end
+ end
+
+ describe Rpush::ReflectionCollection do
+   it 'dispatches the given reflection' do
+     did_yield = false
+     Rpush.reflect do |on|
+       on.error { did_yield = true }
+     end
+     Rpush.reflection_stack[0].__dispatch(:error)
+     expect(did_yield).to eq(true)
+   end
+
+   it 'raises an error when trying to dispatch and unknown reflection' do
+     expect do
+       Rpush.reflection_stack[0].__dispatch(:unknown)
+     end.to raise_error(Rpush::ReflectionCollection::NoSuchReflectionError)
+   end
+ end

data/spec/unit/rpush_spec.rb

@@ -0,0 +1,8 @@
+require 'unit_spec_helper'
+
+describe Rpush do
+  it "lazy initializes the logger" do
+    expect(Rpush::Logger).to receive(:new)
+    Rpush.logger
+  end
+end

data/spec/unit_spec_helper.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'rails'
+
+def unit_example?(metadata)
+  metadata[:file_path] =~ %r{spec/unit}
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Modis.with_connection do |redis|
+      redis.keys('rpush:*').each { |key| redis.del(key) }
+    end if redis?
+
+    if active_record? && unit_example?(self.class.metadata)
+      connection = ActiveRecord::Base.connection
+      connection.begin_transaction joinable: false
+    end
+  end
+
+  config.after(:each) do
+    if active_record? && unit_example?(self.class.metadata)
+      connection = ActiveRecord::Base.connection
+      connection.rollback_transaction if connection.transaction_open?
+    end
+  end
+end