rapns_rails_2 3.4.3

data/spec/unit/daemon/store/active_record_spec.rb

@@ -0,0 +1,281 @@
+require File.expand_path("spec/unit_spec_helper")
+require 'rapns/daemon/store/active_record'
+
+describe Rapns::Daemon::Store::ActiveRecord do
+  let(:app) { Rapns::Apns::App.create!(:name => 'my_app', :environment => 'development', :certificate => TEST_CERT) }
+  let(:notification) { Rapns::Apns::Notification.create!(:device_token => "a" * 64, :app => app) }
+  let(:store) { Rapns::Daemon::Store::ActiveRecord.new }
+  let(:now) { Time.now.utc }
+
+  before { Time.stub(:now => now) }
+
+  it 'reconnects after daemonize' do
+    store.should_receive(:reconnect_database)
+    store.after_daemonize
+  end
+
+  describe 'deliverable_notifications' do
+    it 'checks for new notifications with the ability to reconnect the database' do
+      store.should_receive(:with_database_reconnect_and_retry)
+      store.deliverable_notifications(app)
+    end
+
+    it 'loads notifications in batches' do
+      Rapns.config.batch_size = 5000
+      Rapns.config.push = false
+      relation = double.as_null_object
+      relation.should_receive(:find).with(:all, :limit => 5000)
+      Rapns::Notification.stub(:ready_for_delivery => relation)
+      store.deliverable_notifications([app])
+    end
+
+    it 'does not load notification in batches if in push mode' do
+      Rapns.config.push = true
+      relation = double.as_null_object
+      relation.should_not_receive(:limit)
+      Rapns::Notification.stub(:ready_for_delivery => relation)
+      store.deliverable_notifications([app])
+    end
+
+    it 'loads an undelivered notification without deliver_after set' do
+      notification.update_attributes!(:delivered => false, :deliver_after => nil)
+      store.deliverable_notifications([app]).should == [notification]
+    end
+
+    it 'loads an notification with a deliver_after time in the past' do
+      notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.ago)
+      store.deliverable_notifications([app]).should == [notification]
+    end
+
+    it 'does not load an notification with a deliver_after time in the future' do
+      notification.update_attributes!(:delivered => false, :deliver_after => 1.hour.from_now)
+      store.deliverable_notifications([app]).should be_empty
+    end
+
+    it 'does not load a previously delivered notification' do
+      notification.update_attributes!(:delivered => true, :delivered_at => Time.now)
+      store.deliverable_notifications([app]).should be_empty
+    end
+
+    it "does not enqueue a notification that has previously failed delivery" do
+      notification.update_attributes!(:delivered => false, :failed => true)
+      store.deliverable_notifications([app]).should be_empty
+    end
+
+    it 'does not load notifications for apps that are still processing the previous batch' do
+      notification
+      store.deliverable_notifications([]).should be_empty
+    end
+  end
+
+  describe 'mark_retryable' do
+    it 'increments the retry count' do
+      expect do
+        store.mark_retryable(notification, now)
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      deliver_after = now + 10.seconds
+      expect do
+        store.mark_retryable(notification, deliver_after)
+      end.to change(notification, :deliver_after).to(deliver_after)
+    end
+
+    it 'saves the notification without validation' do
+      notification.should_receive(:save).with(false)
+      store.mark_retryable(notification, now)
+    end
+  end
+
+  describe 'mark_batch_retryable' do
+    let(:deliver_after) { now + 10.seconds }
+
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_retryable([notification], deliver_after)
+      notification.deliver_after.should == deliver_after
+      notification.retries.should == 1
+    end
+
+    it 'increments the retired count' do
+      expect do
+        store.mark_batch_retryable([notification], deliver_after)
+        notification.reload
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      expect do
+        store.mark_batch_retryable([notification], deliver_after)
+        notification.reload
+      end.to change { notification.deliver_after.try(:utc).to_s }.to(deliver_after.utc.to_s)
+    end
+  end
+
+  describe 'mark_delivered' do
+    it 'marks the notification as delivered' do
+      expect do
+        store.mark_delivered(notification)
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notification was delivered' do
+      expect do
+        store.mark_delivered(notification)
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(now.to_s)
+    end
+
+    it 'saves the notification without validation' do
+      notification.should_receive(:save).with(false)
+      store.mark_delivered(notification)
+    end
+  end
+
+  describe 'mark_batch_delivered' do
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_delivered([notification])
+      notification.delivered_at.should == now
+      notification.delivered.should be_true
+    end
+
+    it 'marks the notifications as delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notifications were delivered' do
+      expect do
+        store.mark_batch_delivered([notification])
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(now.to_s)
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as not delivered' do
+      store.mark_failed(notification, nil, '')
+      notification.delivered.should be_false
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_failed(notification, nil, '')
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+
+    it 'sets the time the notification delivery failed' do
+      expect do
+        store.mark_failed(notification, nil, '')
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(now.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_failed(notification, 42, '')
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_failed(notification, 42, 'Weeee')
+      end.to change(notification, :error_description).to('Weeee')
+    end
+
+    it 'saves the notification without validation' do
+      notification.should_receive(:save).with(false)
+      store.mark_failed(notification, nil, '')
+    end
+  end
+
+  describe 'mark_batch_failed' do
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_failed([notification], 123, 'an error')
+      notification.failed_at.should == now
+      notification.delivered_at.should be_nil
+      notification.delivered.should be_false
+      notification.failed.should be_true
+      notification.error_code.should == 123
+      notification.error_description.should == 'an error'
+    end
+
+    it 'marks the notification as not delivered' do
+      store.mark_batch_failed([notification], nil, '')
+      notification.reload
+      notification.delivered.should be_false
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change(notification, :failed).to(true)
+    end
+
+    it 'sets the time the notification delivery failed' do
+      expect do
+        store.mark_batch_failed([notification], nil, '')
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(now.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_batch_failed([notification], 42, '')
+        notification.reload
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_batch_failed([notification], 42, 'Weeee')
+        notification.reload
+      end.to change(notification, :error_description).to('Weeee')
+    end
+  end
+
+  describe 'create_apns_feedback' do
+    it 'creates the Feedback record' do
+      Rapns::Apns::Feedback.should_receive(:create!).with(
+        :failed_at => now, :device_token => 'ab' * 32, :app => app)
+      store.create_apns_feedback(now, 'ab' * 32, app)
+    end
+  end
+
+  describe 'create_gcm_notification' do
+    let(:data) { { :data => true } }
+    let(:attributes) { { :device_token => 'ab' * 32 } }
+    let(:registration_ids) { ['123', '456'] }
+    let(:deliver_after) { now + 10.seconds }
+    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
+
+    it 'sets the given attributes' do
+      new_notification = store.create_gcm_notification(*args)
+      new_notification.device_token.should == 'ab' * 32
+    end
+
+    it 'sets the given data' do
+      new_notification = store.create_gcm_notification(*args)
+      new_notification.data['data'].should be_true
+    end
+
+    it 'sets the given registration IDs' do
+      new_notification = store.create_gcm_notification(*args)
+      new_notification.registration_ids.should == registration_ids
+    end
+
+    it 'sets the deliver_after timestamp' do
+      new_notification = store.create_gcm_notification(*args)
+      new_notification.deliver_after.to_s.should == deliver_after.to_s
+    end
+
+    it 'saves the new notification' do
+      new_notification = store.create_gcm_notification(*args)
+      new_notification.new_record?.should be_false
+    end
+  end
+end

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,157 @@
+require File.expand_path("spec/unit_spec_helper")
+require 'rapns/daemon/store/active_record'
+
+describe Rapns::Daemon, "when starting" do
+  module Rails; end
+
+  let(:certificate) { double }
+  let(:password) { double }
+  let(:config) { double(:pid_file => nil, :airbrake_notify => false,
+    :foreground => true, :embedded => false, :push => false,
+    :store => :active_record, :logger => nil) }
+  let(:logger) { double(:logger, :info => nil, :error => nil, :warn => nil) }
+
+  before do
+    Rapns.stub(:config => config, :logger => logger)
+    Rapns::Daemon::Feeder.stub(:start)
+    Rapns::Daemon::AppRunner.stub(:sync => nil, :stop => nil)
+    Rapns::Daemon.stub(:daemonize => nil, :exit => nil, :puts => nil)
+    File.stub(:open)
+    Rails.stub(:root).and_return("/rails_root")
+  end
+
+  unless Rapns.jruby?
+    it "forks into a daemon if the foreground option is false" do
+      config.stub(:foreground => false)
+      Rapns::Daemon.initialize_store
+      Rapns::Daemon.store.stub(:after_daemonize => nil)
+      Rapns::Daemon.should_receive(:daemonize)
+      Rapns::Daemon.start
+    end
+
+    it 'notifies the store after forking' do
+      config.stub(:foreground => false)
+      Rapns::Daemon.initialize_store
+      Rapns::Daemon.store.should_receive(:after_daemonize)
+      Rapns::Daemon.start
+    end
+
+    it "does not fork into a daemon if the foreground option is true" do
+      config.stub(:foreground => true)
+      Rapns::Daemon.should_not_receive(:daemonize)
+      Rapns::Daemon.start
+    end
+
+    it "does not fork into a daemon if the push option is true" do
+      config.stub(:push => true)
+      Rapns::Daemon.should_not_receive(:daemonize)
+      Rapns::Daemon.start
+    end
+
+    it "does not fork into a daemon if the embedded option is true" do
+      config.stub(:embedded => true)
+      Rapns::Daemon.should_not_receive(:daemonize)
+      Rapns::Daemon.start
+    end
+  end
+
+  it 'sets up setup signal traps' do
+    Rapns::Daemon.should_receive(:setup_signal_traps)
+    Rapns::Daemon.start
+  end
+
+  it 'does not setup signal traps when embedded' do
+    config.stub(:embedded => true)
+    Rapns::Daemon.should_not_receive(:setup_signal_traps)
+    Rapns::Daemon.start
+  end
+
+  it 'instantiates the store' do
+    config.stub(:store => :active_record)
+    Rapns::Daemon.start
+    Rapns::Daemon.store.should be_kind_of(Rapns::Daemon::Store::ActiveRecord)
+  end
+
+  it 'logs an error if the store cannot be loaded' do
+    config.stub(:store => :foo_bar)
+    Rapns.logger.should_receive(:error).with(kind_of(LoadError))
+    Rapns::Daemon.start
+  end
+
+  it "writes the process ID to the PID file" do
+    Rapns::Daemon.should_receive(:write_pid_file)
+    Rapns::Daemon.start
+  end
+
+  it "logs an error if the PID file could not be written" do
+    config.stub(:pid_file => '/rails_root/rapns.pid')
+    File.stub(:open).and_raise(Errno::ENOENT)
+    logger.should_receive(:error).with("Failed to write PID to '/rails_root/rapns.pid': #<Errno::ENOENT: No such file or directory>")
+    Rapns::Daemon.start
+  end
+
+  it "starts the feeder" do
+    Rapns::Daemon::Feeder.should_receive(:start)
+    Rapns::Daemon.start
+  end
+
+  it "syncs apps" do
+    Rapns::Daemon::AppRunner.should_receive(:sync)
+    Rapns::Daemon.start
+  end
+end
+
+describe Rapns::Daemon, "when being shutdown" do
+  let(:config) { double(:pid_file => '/rails_root/rapns.pid') }
+  let(:logger) { double(:info => nil, :error => nil, :warn => nil) }
+
+  before do
+    Rapns.stub(:config => config)
+    Rapns::Daemon.stub(:puts => nil)
+    Rapns::Daemon::Feeder.stub(:stop)
+    Rapns::Daemon::AppRunner.stub(:stop)
+  end
+
+  # These tests do not work on JRuby.
+  unless Rapns.jruby?
+    it "shuts down when signaled signaled SIGINT" do
+      Rapns::Daemon.setup_signal_traps
+      Rapns::Daemon.should_receive(:shutdown)
+      Process.kill("SIGINT", Process.pid)
+    end
+
+    it "shuts down when signaled signaled SIGTERM" do
+      Rapns::Daemon.setup_signal_traps
+      Rapns::Daemon.should_receive(:shutdown)
+      Process.kill("SIGTERM", Process.pid)
+    end
+  end
+
+  it "stops the feeder" do
+    Rapns::Daemon::Feeder.should_receive(:stop)
+    Rapns::Daemon.shutdown
+  end
+
+  it "stops the app runners" do
+    Rapns::Daemon::AppRunner.should_receive(:stop)
+    Rapns::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/rapns.pid")
+    Rapns::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)
+    Rapns::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)
+    Rapns::Daemon.shutdown
+  end
+end

data/spec/unit/deprecatable_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Deprecatable do
+  class HasDeprecatedMethod
+    include Rapns::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
+    Rapns::Deprecation.stub(:warn)
+  end
+
+  it 'warns the method is deprecated when called' do
+    Rapns::Deprecation.should_receive(:warn).with("deprecated_method is deprecated and will be removed from Rapns 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 File.expand_path("spec/unit_spec_helper")
+
+describe Rapns::Deprecation do
+  it 'prints a warning' do
+    STDERR.should_receive(:puts).with("DEPRECATION WARNING: msg")
+    Rapns::Deprecation.warn("msg")
+  end
+
+  it 'does not print a warning when muted' do
+    STDERR.should_not_receive(:puts)
+    Rapns::Deprecation.muted do
+      Rapns::Deprecation.warn("msg")
+    end
+  end
+end

data/spec/unit/embed_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path("spec/unit_spec_helper")
+
+describe Rapns, 'embed' do
+  before do
+    Rapns::Daemon.stub(:start)
+    Kernel.stub(:at_exit)
+  end
+
+  it 'sets the embedded config option to true' do
+    Rapns.embed
+    Rapns.config.embedded.should be_true
+  end
+
+  it 'starts the daemon' do
+    Rapns::Daemon.should_receive(:start)
+    Rapns.embed
+  end
+
+  it 'overrides the default config options with those given as a hash' do
+    Rapns.config.push_poll = 4
+    expect { Rapns.embed(:push_poll => 2) }.to change(Rapns.config, :push_poll).to(2)
+  end
+end
+
+describe Rapns, 'shutdown' do
+  before { Rapns.config.embedded = true }
+
+  it 'shuts down the daemon' do
+    Rapns::Daemon.should_receive(:shutdown)
+    Rapns.shutdown
+  end
+end
+
+describe Rapns, 'sync' do
+  before { Rapns.config.embedded = true }
+
+  it 'syncs the AppRunner' do
+    Rapns::Daemon::AppRunner.should_receive(:sync)
+    Rapns.sync
+  end
+end
+
+describe Rapns, 'debug' do
+  before { Rapns.config.embedded = true }
+
+  it 'debugs the AppRunner' do
+    Rapns::Daemon::AppRunner.should_receive(:debug)
+    Rapns.debug
+  end
+end

data/spec/unit/gcm/app_spec.rb

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

data/spec/unit/gcm/notification_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path("spec/unit_spec_helper")
+require 'spec/unit/notification_shared.rb'
+
+describe Rapns::Gcm::Notification do
+  it_should_behave_like 'an Notification subclass'
+
+  let(:app) { Rapns::Gcm::App.create!(:name => 'test', :auth_key => 'abc') }
+  let(:notification_class) { Rapns::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 == "GCM notification payload data cannot be larger than 4096 bytes."
+  end
+
+  it 'allows assignment of many registration IDs' do
+    notification.app = app
+    notification.registration_ids = ['a', 'b']
+    notification.save!
+    reloaded_notification = notification_class.find(notification.id)
+    reloaded_notification.registration_ids.should == ['a', 'b']
+  end
+
+  it 'num of registration Ids limit of 1000' do
+    notification.registration_ids = ['a']*(1000+1)
+    notification.valid?.should be_false
+    notification.errors[:base].should == "GCM notification number of registration_ids cannot be larger than 1000"
+  end
+
+  it 'allows assignment of a single registration ID' do
+    notification.app = app
+    notification.registration_ids = 'a'
+    notification.save!
+    reloaded_notification = notification_class.find(notification.id)
+    reloaded_notification.registration_ids.should == ['a']
+  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 == '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 == 100
+  end
+end