rapns_rails_2 3.5.1 → 3.6.1

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

@@ -1,281 +0,0 @@
-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" * 256, :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

@@ -1,157 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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