rpush 1.0.0

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,159 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+describe Rpush::Daemon, "when starting" do
+  module Rails; end
+
+  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) }
+
+  before do
+    Rpush.stub(:config => config, :logger => logger)
+    Rpush::Daemon::Feeder.stub(:start)
+    Rpush::Daemon::AppRunner.stub(:sync => nil, :stop => nil)
+    Rpush::Daemon.stub(:daemonize => nil, :exit => nil, :puts => nil)
+    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::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)
+      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::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::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::Daemon.start
+    end
+  end
+
+  it 'sets up setup signal traps' do
+    Rpush::Daemon.should_receive(:setup_signal_traps)
+    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)
+    Rpush::Daemon.start
+  end
+
+  it 'instantiates the store' do
+    config.stub(:store => :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.logger.should_receive(:error).with(kind_of(LoadError))
+    Rpush::Daemon.start
+  end
+
+  it "writes the process ID to the PID file" do
+    Rpush::Daemon.should_receive(:write_pid_file)
+    Rpush::Daemon.start
+  end
+
+  it "logs an error if the PID file could not be written" do
+    config.stub(: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
+  end
+
+  it "starts the feeder" do
+    Rpush::Daemon::Feeder.should_receive(:start)
+    Rpush::Daemon.start
+  end
+
+  it "syncs apps" 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
+    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
+    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 "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
+  end
+end

data/spec/unit/deprecatable_spec.rb

@@ -0,0 +1,32 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecatable do
+  class HasDeprecatedMethod
+    include Rpush::Deprecatable
+
+    def original_called?
+      @called == true
+    end
+
+    def deprecated_method
+      @called = true
+    end
+    deprecated(:deprecated_method, '4.0')
+  end
+
+  let(:klass) { HasDeprecatedMethod.new }
+
+  before do
+    Rpush::Deprecation.stub(: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.")
+    klass.deprecated_method
+  end
+
+  it 'calls the original method' do
+    klass.deprecated_method
+    klass.original_called?.should be_true
+  end
+end

data/spec/unit/deprecation_spec.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+describe Rpush::Deprecation do
+  it 'prints a warning' do
+    STDERR.should_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)
+    Rpush::Deprecation.muted do
+      Rpush::Deprecation.warn("msg")
+    end
+  end
+end

data/spec/unit/embed_spec.rb

@@ -0,0 +1,50 @@
+require 'unit_spec_helper'
+
+describe Rpush, 'embed' do
+  before do
+    Rpush::Daemon.stub(:start)
+    Kernel.stub(:at_exit)
+  end
+
+  it 'sets the embedded config option to true' do
+    Rpush.embed
+    Rpush.config.embedded.should be_true
+  end
+
+  it 'starts the daemon' do
+    Rpush::Daemon.should_receive(:start)
+    Rpush.embed
+  end
+
+  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)
+  end
+end
+
+describe Rpush, 'shutdown' do
+  before { Rpush.config.embedded = true }
+
+  it 'shuts down the daemon' do
+    Rpush::Daemon.should_receive(:shutdown)
+    Rpush.shutdown
+  end
+end
+
+describe Rpush, 'sync' do
+  before { Rpush.config.embedded = true }
+
+  it 'syncs the AppRunner' do
+    Rpush::Daemon::AppRunner.should_receive(:sync)
+    Rpush.sync
+  end
+end
+
+describe Rpush, 'debug' do
+  before { Rpush.config.embedded = true }
+
+  it 'debugs the AppRunner' do
+    Rpush::Daemon::AppRunner.should_receive(:debug)
+    Rpush.debug
+  end
+end

data/spec/unit/gcm/app_spec.rb

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+describe Rpush::Gcm::App do
+end

data/spec/unit/gcm/notification_spec.rb

@@ -0,0 +1,36 @@
+require 'unit_spec_helper'
+require 'unit/notification_shared.rb'
+
+describe Rpush::Gcm::Notification do
+  it_should_behave_like 'an Notification subclass'
+
+  let(:app) { Rpush::Gcm::App.create!(:name => 'test', :auth_key => 'abc') }
+  let(:notification_class) { Rpush::Gcm::Notification }
+  let(:notification) { notification_class.new }
+  let(:data_setter) { 'data=' }
+  let(:data_getter) { 'data' }
+
+  it "has a 'data' payload limit of 4096 bytes" do
+    notification.data = { :key => "a" * 4096 }
+    notification.valid?.should be_false
+    notification.errors[:base].should eq ["Notification payload data cannot be larger than 4096 bytes."]
+  end
+
+  it 'limits the number of registration ids to 1000' do
+    notification.registration_ids = ['a']*(1000+1)
+    notification.valid?.should be_false
+    notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 1000."]
+  end
+
+  it 'validates expiry is present if collapse_key is set' do
+    notification.collapse_key = 'test'
+    notification.expiry = nil
+    notification.valid?.should be_false
+    notification.errors[:expiry].should eq ['must be set when using a collapse_key']
+  end
+
+  it 'includes time_to_live in the payload' do
+    notification.expiry = 100
+    notification.as_json['time_to_live'].should eq 100
+  end
+end

data/spec/unit/logger_spec.rb

@@ -0,0 +1,127 @@
+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
+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.stub(:new).and_return(@logger)
+    Rails.logger = @logger
+    File.stub(:open => log)
+    FileUtils.stub(:mkdir_p => nil)
+    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/)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'creates the log directory' do
+    FileUtils.should_receive(:mkdir_p).with('/rails_root/log')
+    Rpush::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/rpush.log', 'a')
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'sets sync mode on the log descriptor' do
+    log.should_receive(:sync=).with(true)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it 'uses the user-defined logger' do
+    my_logger = double
+    Rpush.config.logger = my_logger
+    logger = Rpush::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)
+      Rpush::Logger.new(:foreground => true)
+    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)
+    Rpush::Logger.new(:foreground => true)
+  end
+
+  it "should print out the msg if running in the foreground" do
+    logger = Rpush::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 = Rpush::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 = Rpush::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 = Rpush::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 = Rpush::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 = Rpush::Logger.new(:foreground => false)
+    @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 = rails_logger
+    @logger.auto_flushing.should be_true
+  end
+end

data/spec/unit/notification_shared.rb

@@ -0,0 +1,105 @@
+shared_examples_for "an Notification subclass" do
+  describe "when assigning data for the device" do
+    before { Rpush::Deprecation.stub(: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())
+      notification.send(data_setter, { :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 })
+    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 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
+    end
+  end
+end