rapns_rails_2 3.4.3

data/spec/unit/logger_spec.rb

@@ -0,0 +1,180 @@
+require File.expand_path("spec/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
+end
+
+module Airbrake
+  def self.notify_or_ignore(e)
+  end
+end
+
+describe Rapns::Logger do
+  let(:log) { double(:sync= => true) }
+  let(:config) { double(:airbrake_notify => 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.stub(:new).and_return(@logger)
+    Rails.logger = @logger
+    File.stub(:open => log)
+    STDERR.stub(:puts)
+  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/)
+    Rapns::Logger.new(:foreground => true)
+  end
+
+  it "should open the a log file in the Rails log directory" do
+    File.should_receive(:open).with('/rails_root/log/rapns.log', 'a')
+    Rapns::Logger.new(:foreground => true)
+  end
+
+  it 'sets sync mode on the log descriptor' do
+    log.should_receive(:sync=).with(true)
+    Rapns::Logger.new(:foreground => true)
+  end
+
+  it 'uses the user-defined logger' do
+    my_logger = double
+    Rapns.config.logger = my_logger
+    logger = Rapns::Logger.new({})
+    my_logger.should_receive(:info)
+    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)
+      Rapns::Logger.new(:foreground => true)
+    end
+  end
+
+  it 'uses ActiveSupport::Logger if BufferedLogger does not exist' do
+    ActiveSupport.stub_constants(:Logger => double) do
+      ActiveSupport.stub(:const_defined? => false)
+      ActiveSupport::Logger.should_receive(:new).with(log, Rails.logger.level)
+      Rapns::Logger.new(:foreground => true)
+    end
+  end
+
+  it "should print out the msg if running in the foreground" do
+    logger = Rapns::Logger.new(:foreground => true)
+    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 = Rapns::Logger.new(:foreground => false)
+    STDOUT.should_not_receive(:puts).with(/hi mom/)
+    logger.info("hi mom")
+  end
+
+  it "should prefix log lines with the current time" do
+    now = Time.now
+    Time.stub(:now).and_return(now)
+    logger = Rapns::Logger.new(:foreground => false)
+    @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 = Rapns::Logger.new(:foreground => false)
+    @logger.should_receive(:error).with(/#{Regexp.escape("[ERROR]")}/)
+    logger.error("eeek")
+  end
+
+  it "should prefix warn logs with the WARNING label" do
+    logger = Rapns::Logger.new(:foreground => false)
+    @logger.should_receive(:warn).with(/#{Regexp.escape("[WARNING]")}/)
+    logger.warn("eeek")
+  end
+
+  it "should handle an Exception instance" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Logger.new(:foreground => false)
+    @logger.should_receive(:error).with(/RuntimeError, hi mom/)
+    logger.error(e)
+  end
+
+  it "should notify Airbrake of the exception" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Logger.new(:foreground => false, :airbrake_notify => true)
+    Airbrake.should_receive(:notify_or_ignore).with(e)
+    logger.error(e)
+  end
+
+  context "without Airbrake defined" do
+    before do
+      Object.send(:remove_const, :Airbrake)
+    end
+
+    after do
+      module Airbrake
+        def self.notify_or_ignore(e)
+        end
+      end
+    end
+
+    it "should notify using HoptoadNotifier" do
+      e = RuntimeError.new("hi mom")
+      e.stub(:backtrace => [])
+      logger = Rapns::Logger.new(:foreground => false, :airbrake_notify => true)
+      HoptoadNotifier.should_receive(:notify_or_ignore).with(e)
+      logger.error(e)
+    end
+  end
+
+  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::Logger.new(:foreground => false, :airbrake_notify => false)
+    Airbrake.should_not_receive(:notify_or_ignore).with(e)
+    logger.error(e)
+  end
+
+  it "should not notify Airbrake if explicitly disabled in the call to error" do
+    e = RuntimeError.new("hi mom")
+    e.stub(:backtrace => [])
+    logger = Rapns::Logger.new(:foreground => false, :airbrake_notify => true)
+    Airbrake.should_not_receive(:notify_or_ignore).with(e)
+    logger.error(e, :airbrake_notify => false)
+  end
+
+  it "should not attempt to notify Airbrake of the error is not an Exception" do
+    logger = Rapns::Logger.new(:foreground => false)
+    Airbrake.should_not_receive(:notify_or_ignore)
+    logger.error("string error message")
+  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 = rails_logger
+    logger = Rapns::Logger.new({})
+    @logger.auto_flushing.should be_true
+  end
+end

data/spec/unit/notification_shared.rb

@@ -0,0 +1,45 @@
+shared_examples_for "an Notification subclass" do
+  describe "when assigning data for the device" do
+    before { Rapns::Deprecation.stub(:warn) }
+
+    it "calls MultiJson.dump when multi_json responds to :dump" do
+      Object.stub_constants(:MultiJson => mock) do
+        MultiJson.should_receive(:dump).with(any_args())
+        notification = notification_class.new
+        notification.send(data_setter, { :pirates => 1 })
+      end
+    end
+
+    it "calls MultiJson.encode when multi_json does not respond to :dump" do
+      Object.stub_constants(:MultiJson => mock) do
+        notification = notification_class.new
+        MultiJson.should_receive(:encode).with(any_args())
+        notification.send(data_setter, { :ninjas => 1 })
+      end
+    end
+
+    it "raises an ArgumentError if something other than a Hash is assigned" do
+      expect do
+        notification.send(data_setter, 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 == "{\"hi\":\"mom\"}"
+    end
+
+    it "decodes the JSON when using the reader method" do
+      notification.send(data_setter, { :hi => "mom" })
+      notification.send(data_getter).should == {"hi" => "mom"}
+    end
+
+    if Rapns.is_rails2_or_3?
+      it 'warns if attributes_for_device is assigned via mass-assignment' do
+        RAILS_DEFAULT_LOGGER.stub!(:debug)
+        Rapns::Deprecation.should_receive(:warn).with(':attributes_for_device via mass-assignment is deprecated. Use :data or the attributes_for_device= instance method.')
+        notification_class.new(:attributes_for_device => {:hi => 'mom'})
+      end
+    end
+  end
+end

data/spec/unit/notification_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Notification do
+end

data/spec/unit/notifier_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("spec/unit_spec_helper")
+require 'rapns/notifier'
+
+describe Rapns::Notifier do
+
+  before(:each) { @port = 5000 }
+  subject { Rapns::Notifier.new('127.0.0.1', @port) }
+  its(:socket) { should_not be_nil }
+
+  context "when connected" do
+    before :each do
+      @reader = UDPSocket.new
+      @reader.bind('127.0.0.1', 0)
+      @port = @reader.addr[1]
+    end
+
+    describe "notify" do
+      it "calls write on the socket" do
+        sock = UDPSocket.new
+        UDPSocket.should_receive(:new).and_return(sock)
+        sock.should_receive(:write)
+
+        subject.notify
+      end
+
+      it "writes data that can be read from socket" do
+        subject.notify
+        @reader.recvfrom(4096).should be_an(Array)
+      end
+    end
+  end
+end

data/spec/unit/push_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns, 'push' do
+  before do
+    Rapns::Upgraded.stub(:check => nil)
+    Rapns::Daemon::AppRunner.stub(:sync => nil, :wait => nil)
+    Rapns::Daemon::Feeder.stub(:start => nil)
+  end
+
+  it 'sets the push config option to true' do
+    Rapns.push
+    Rapns.config.push.should be_true
+  end
+
+  it 'initializes the store' do
+    Rapns::Daemon.should_receive(:initialize_store)
+    Rapns.push
+  end
+
+  it 'syncs the app runner' do
+    Rapns::Daemon::AppRunner.should_receive(:sync)
+    Rapns.push
+  end
+
+  it 'starts the feeder' do
+    Rapns::Daemon::Feeder.should_receive(:start)
+    Rapns.push
+  end
+
+  it 'waits on the app runner' do
+    Rapns::Daemon::AppRunner.should_receive(:wait)
+    Rapns.push
+  end
+
+  it 'stops on the app runner' do
+    Rapns::Daemon::AppRunner.should_receive(:stop)
+    Rapns.push
+  end
+
+  it 'overrides the default config options with those given as a hash' do
+    Rapns.config.batch_size = 20
+    expect { Rapns.push(:batch_size => 10) }.to change(Rapns.config, :batch_size).to(10)
+  end
+end

data/spec/unit/rapns_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns do
+  it "lazy initializes the logger" do
+    Rapns.config.stub(:airbrake_notify => true, :foreground => true)
+    Rapns::Logger.should_receive(:new).with(:foreground => true, :airbrake_notify => true)
+    Rapns.logger
+  end
+end

data/spec/unit/reflection_spec.rb

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

data/spec/unit/upgraded_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Upgraded do
+  let(:logger) { double(:logger, :warn => nil) }
+  let(:config) { double(:config) }
+
+  before do
+    Rails.stub(:root).and_return('/rails_root')
+    Rapns.stub(:logger => logger, :config => config)
+  end
+
+  it 'prints a warning and exists if rapns has not been upgraded' do
+    Rapns::App.stub(:count).and_raise(ActiveRecord::StatementInvalid)
+    Rapns::Upgraded.stub(:puts)
+    Rapns::Upgraded.should_receive(:exit).with(1)
+    Rapns::Upgraded.check(:exit => true)
+  end
+
+  it 'does not exit if Rapns has not been upgraded and :exit is false' do
+    Rapns.config.stub(:embedded => true)
+    Rapns::App.stub(:count).and_raise(ActiveRecord::StatementInvalid)
+    Rapns::Upgraded.stub(:puts)
+    Rapns::Upgraded.should_not_receive(:exit)
+    Rapns::Upgraded.check(:exit => false)
+  end
+
+  it 'does not exit if Rapns has not been upgraded and is in push mode' do
+    Rapns.config.stub(:push => true)
+    Rapns::App.stub(:count).and_raise(ActiveRecord::StatementInvalid)
+    Rapns::Upgraded.stub(:puts)
+    Rapns::Upgraded.should_not_receive(:exit)
+    Rapns::Upgraded.check(:exit => false)
+  end
+
+  it 'warns if rapns.yml still exists' do
+    File.should_receive(:exists?).with('/rails_root/config/rapns/rapns.yml').and_return(true)
+    Rapns.logger.should_receive(:warn).with("Since 2.0.0 rapns uses command-line options and a Ruby based configuration file.\nPlease run 'rails g rapns' to generate a new configuration file into config/initializers.\nRemove config/rapns/rapns.yml to avoid this warning.\n")
+    Rapns::Upgraded.check(:exit => false)
+  end
+end

data/spec/unit_spec_helper.rb

@@ -0,0 +1,137 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'bundler'
+Bundler.require(:default)
+
+require 'active_record'
+require 'database_cleaner'
+
+unless ENV['TRAVIS'] && ENV['QUALITY'] == 'false'
+  begin
+    require './spec/support/simplecov_helper'
+    include SimpleCovHelper
+    start_simple_cov("unit-#{RUBY_VERSION}")
+  rescue LoadError
+    puts "Coverage disabled."
+  end
+end
+
+jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+$adapter = ENV['ADAPTER'] || 'postgresql'
+$adapter = 'jdbc' + $adapter if jruby
+
+DATABASE_CONFIG = YAML.load_file(File.expand_path("../config/database.yml", File.dirname(__FILE__)))
+
+if DATABASE_CONFIG[$adapter].nil?
+  puts "No such adapter '#{$adapter}'. Valid adapters are #{DATABASE_CONFIG.keys.join(', ')}."
+  exit 1
+end
+
+if ENV['TRAVIS']
+  DATABASE_CONFIG[$adapter]['username'] = 'postgres'
+else
+  require 'etc'
+  username = $adapter =~ /mysql/ ? 'root' : Etc.getlogin
+  DATABASE_CONFIG[$adapter]['username'] = username
+end
+
+puts "Using #{$adapter} adapter."
+
+ActiveRecord::Base.establish_connection(DATABASE_CONFIG[$adapter])
+
+require 'generators/templates/create_rapns_notifications'
+require 'generators/templates/create_rapns_feedback'
+require 'generators/templates/add_alert_is_json_to_rapns_notifications'
+require 'generators/templates/add_app_to_rapns'
+require 'generators/templates/create_rapns_apps'
+require 'generators/templates/add_gcm'
+
+[CreateRapnsNotifications, CreateRapnsFeedback,
+ AddAlertIsJsonToRapnsNotifications, AddAppToRapns, CreateRapnsApps, AddGcm].each do |migration|
+  migration.down rescue ActiveRecord::StatementInvalid
+  migration.up
+end
+
+DatabaseCleaner.strategy = :truncation
+
+require 'rapns_rails_2'
+require 'rapns/daemon'
+
+Rapns::Notification.reset_column_information
+Rapns::App.reset_column_information
+Rapns::Apns::Feedback.reset_column_information
+
+require 'spec'
+require 'spec/mocks'
+
+Spec::Runner.configure do |config|
+  # config.before :suite do
+  #   PerfTools::CpuProfiler.start('/tmp/rapns_profile')
+  # end
+  # config.after :suite do
+  #   PerfTools::CpuProfiler.stop
+  # end
+
+  config.before(:all) do
+    unless defined? RAILS_DEFAULT_LOGGER
+      logger = mock
+      logger.stub(:debug) { |a| puts "DEBUG:" + a }
+      logger.as_null_object
+      RAILS_DEFAULT_LOGGER = logger
+    end
+    ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
+
+    ActiveRecord::Base.default_timezone = :utc
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.after(:each) do
+    Rapns.logger = nil
+    Rapns::Daemon.store = nil
+    Rapns::Deprecation.muted do
+      Rapns.config.set_defaults if Rapns.config.kind_of?(Rapns::Configuration)
+    end
+  end
+end
+
+def stub_constants(constants, &block)
+  defined_constants = {}
+  saved_constants = {}
+
+  constants.each do |constant, val|
+    defined = defined_constants[ constant ] = self.const_defined?(constant)
+    saved_constants[ constant ] = self.const_get( constant ) if defined
+    Kernel::silence_warnings { self.const_set( constant, val ) }
+  end
+
+  begin
+    block.call
+  ensure
+    constants.each do |constant, val|
+      if defined_constants[ constant ]
+        Kernel::silence_warnings { self.const_set( constant, saved_constants[ constant ] ) }
+      else
+        Kernel::silence_warnings { self.send(:remove_const, constant ) }
+      end
+    end
+  end
+end
+public :stub_constants
+
+# a test certificate that contains both an X509 certificate and
+# a private key, similar to those used for connecting to Apple
+# push notification servers.
+#
+# Note that we cannot validate the certificate and private key
+# because we are missing the certificate chain used to validate
+# the certificate, and this is private to Apple. So if the app
+# has a certificate and a private key in it, the only way to find
+# out if it really is valid is to connect to Apple's servers.
+
+path = File.join(File.dirname(__FILE__), 'support')
+TEST_CERT = File.read(File.join(path, 'cert_without_password.pem'))
+TEST_CERT_WITH_PASSWORD = File.read(File.join(path, 'cert_with_password.pem'))