rpush_extended 3.2.5

data/spec/unit/daemon/signal_handler_spec.rb

@@ -0,0 +1,99 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::SignalHandler do
+  def signal_handler(sig)
+    Process.kill(sig, Process.pid)
+    sleep 0.1
+  end
+
+  def with_handler_start_stop
+    Rpush::Daemon::SignalHandler.start
+    yield
+  ensure
+    Rpush::Daemon::SignalHandler.stop
+  end
+
+  describe 'shutdown signals' do
+    unless Rpush.jruby? # These tests do not work on JRuby.
+      it "shuts down when signaled signaled SIGINT" do
+        with_handler_start_stop do
+          expect(Rpush::Daemon).to receive(:shutdown)
+          signal_handler('SIGINT')
+        end
+      end
+
+      it "shuts down when signaled signaled SIGTERM" do
+        with_handler_start_stop do
+          expect(Rpush::Daemon).to receive(:shutdown)
+          signal_handler('SIGTERM')
+        end
+      end
+    end
+  end
+
+  describe 'config.embedded = true' do
+    before { Rpush.config.embedded = true }
+
+    it 'does not trap signals' do
+      expect(Signal).not_to receive(:trap)
+      Rpush::Daemon::SignalHandler.start
+    end
+  end
+
+  describe 'HUP' do
+    before do
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync)
+      allow(Rpush::Daemon::Feeder).to receive(:wakeup)
+      allow(Rpush::Daemon).to receive_messages(store: double(reopen_log: nil))
+    end
+
+    it 'syncs' do
+      with_handler_start_stop do
+        expect(Rpush::Daemon::Synchronizer).to receive(:sync)
+        signal_handler('HUP')
+      end
+    end
+
+    it 'wakes up the Feeder' do
+      with_handler_start_stop do
+        expect(Rpush::Daemon::Feeder).to receive(:wakeup)
+        signal_handler('HUP')
+      end
+    end
+  end
+
+  describe 'USR2' do
+    it 'instructs the AppRunner to print debug information' do
+      with_handler_start_stop do
+        expect(Rpush::Daemon::AppRunner).to receive(:debug)
+        signal_handler('USR2')
+      end
+    end
+  end
+
+  describe 'error handing' do
+    let(:error) { StandardError.new('test') }
+
+    before do
+      allow(Rpush).to receive_messages(logger: double(error: nil, info: nil, reopen: nil))
+      allow(Rpush::Daemon).to receive_messages(store: double(reopen_log: nil))
+    end
+
+    it 'logs errors received when handling a signal' do
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync).and_raise(error)
+      expect(Rpush.logger).to receive(:error).with(error)
+      with_handler_start_stop do
+        signal_handler('HUP')
+      end
+    end
+
+    it 'does not interrupt processing of further errors' do
+      allow(Rpush::Daemon::Synchronizer).to receive(:sync).and_raise(error)
+      expect(Rpush::Daemon::AppRunner).to receive(:debug)
+      with_handler_start_stop do
+        signal_handler('HUP')
+        signal_handler('USR2')
+      end
+    end
+  end
+end

data/spec/unit/daemon/store/active_record/reconnectable_spec.rb

@@ -0,0 +1,165 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record/reconnectable'
+
+describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
+  class TestDouble
+    include Rpush::Daemon::Store::ActiveRecord::Reconnectable
+
+    attr_reader :name
+
+    def initialize(error, max_calls)
+      @error = error
+      @max_calls = max_calls
+      @calls = 0
+    end
+
+    def perform
+      with_database_reconnect_and_retry do
+        @calls += 1
+        fail @error if @calls <= @max_calls
+      end
+    end
+  end
+
+  let(:adapter_error_class) do
+    case SPEC_ADAPTER
+    when 'postgresql'
+      PGError
+    when 'mysql'
+      Mysql::Error
+    when 'mysql2'
+      Mysql2::Error
+    when 'jdbcpostgresql'
+      ActiveRecord::JDBCError
+    when 'jdbcmysql'
+      ActiveRecord::JDBCError
+    when 'jdbch2'
+      ActiveRecord::JDBCError
+    when 'sqlite3'
+      SQLite3::Exception
+    else
+      fail "Please update #{__FILE__} for adapter #{SPEC_ADAPTER}"
+    end
+  end
+
+  let(:error) { adapter_error_class.new("db down!") }
+  let(:timeout) { ActiveRecord::ConnectionTimeoutError.new("db lazy!") }
+  let(:test_doubles) { [TestDouble.new(error, 1), TestDouble.new(timeout, 1)]  }
+
+  before do
+    @logger = double("Logger", info: nil, error: nil, warn: nil)
+    allow(Rpush).to receive(:logger).and_return(@logger)
+
+    allow(ActiveRecord::Base).to receive(:clear_all_connections!)
+    allow(ActiveRecord::Base).to receive(:establish_connection)
+    test_doubles.each { |td| allow(td).to receive(:sleep) }
+  end
+
+  it "should log the error raised" do
+    expect(Rpush.logger).to receive(:error).with(error)
+    test_doubles.each(&:perform)
+  end
+
+  it "should log that the database is being reconnected" do
+    expect(Rpush.logger).to receive(:warn).with("Lost connection to database, reconnecting...")
+    test_doubles.each(&:perform)
+  end
+
+  it "should log the reconnection attempt" do
+    expect(Rpush.logger).to receive(:warn).with("Attempt 1")
+    test_doubles.each(&:perform)
+  end
+
+  it "should clear all connections" do
+    expect(ActiveRecord::Base).to receive(:clear_all_connections!)
+    test_doubles.each(&:perform)
+  end
+
+  it "should establish a new connection" do
+    expect(ActiveRecord::Base).to receive(:establish_connection)
+    test_doubles.each(&:perform)
+  end
+
+  it "should test out the new connection by performing a count" do
+    expect(Rpush::Client::ActiveRecord::Notification).to receive(:count).twice
+    test_doubles.each(&:perform)
+  end
+
+  context "should reconnect on" do
+    [
+        ::ActiveRecord::ConnectionNotEstablished,
+        ::ActiveRecord::ConnectionTimeoutError,
+        ::ActiveRecord::JDBCError,
+        ::ActiveRecord::StatementInvalid,
+        Mysql::Error,
+        Mysql2::Error,
+        PG::Error,
+        PGError,
+        SQLite3::Exception
+    ].each do |error_class|
+      let(:error) { error_class.new }
+
+      it error_class.name do
+        expect(ActiveRecord::Base).to receive(:establish_connection)
+        test_doubles.each(&:perform)
+      end
+    end
+  end
+
+  context "should not reconnect on" do
+    let(:error) { ActiveRecord::ActiveRecordError.new }
+
+    it "ActiveRecord::ActiveRecordError" do
+      expect(ActiveRecord::Base).not_to receive(:establish_connection)
+      expect { test_doubles.each(&:perform) }.to raise_error(ActiveRecord::ActiveRecordError)
+    end
+  end
+
+  context "when the reconnection attempt is not successful" do
+    before do
+      class << Rpush::Client::ActiveRecord::Notification
+        def count
+          @count_calls += 1
+          return if @count_calls == 2
+          fail @error
+        end
+      end
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@count_calls", 0)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@error", error)
+    end
+
+    describe "error behaviour" do
+      it "should log the 2nd attempt" do
+        expect(Rpush.logger).to receive(:warn).with("Attempt 2")
+        test_doubles[0].perform
+      end
+
+      it "should log errors raised when the reconnection is not successful" do
+        expect(Rpush.logger).to receive(:error).with(error)
+        test_doubles[0].perform
+      end
+
+      it "should sleep to avoid thrashing when the database is down" do
+        expect(test_doubles[0]).to receive(:sleep).with(2)
+        test_doubles[0].perform
+      end
+    end
+
+    describe "timeout behaviour" do
+      it "should log the 2nd attempt" do
+        expect(Rpush.logger).to receive(:warn).with("Attempt 2")
+        test_doubles[1].perform
+      end
+
+      it "should log errors raised when the reconnection is not successful" do
+        expect(Rpush.logger).to receive(:error).with(error)
+        test_doubles[1].perform
+      end
+
+      it "should sleep to avoid thrashing when the database is down" do
+        expect(test_doubles[1]).to receive(:sleep).with(2)
+        test_doubles[1].perform
+      end
+    end
+  end
+end if active_record?

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

@@ -0,0 +1,357 @@
+require 'unit_spec_helper'
+require 'rpush/daemon/store/active_record'
+
+describe Rpush::Daemon::Store::ActiveRecord do
+  let(:app) { Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.create!(device_token: "a" * 64, app: app) }
+  let(:store) { Rpush::Daemon::Store::ActiveRecord.new }
+  let(:time) { Time.now.utc }
+  let(:logger) { double(Rpush::Logger, error: nil, internal_logger: nil) }
+
+  before do
+    allow(Rpush).to receive_messages(logger: logger)
+    allow(Time).to receive_messages(now: time)
+  end
+
+  it 'updates an notification' do
+    expect(notification).to receive(:save!)
+    store.update_notification(notification)
+  end
+
+  it 'updates an app' do
+    expect(app).to receive(:save!)
+    store.update_app(app)
+  end
+
+  it 'finds an app by ID' do
+    expect(store.app(app.id)).to eq(app)
+  end
+
+  it 'finds all apps' do
+    app
+    expect(store.all_apps).to eq([app])
+  end
+
+  it 'translates an Integer notification ID' do
+    expect(store.translate_integer_notification_id(notification.id)).to eq(notification.id)
+  end
+
+  it 'returns the pending notification count' do
+    notification
+    expect(store.pending_delivery_count).to eq(1)
+  end
+
+  it 'can release a connection' do
+    expect(ActiveRecord::Base.connection).to receive(:close)
+    store.release_connection
+  end
+
+  it 'logs errors raised when trying to release the connection' do
+    e = StandardError.new
+    allow(ActiveRecord::Base.connection).to receive(:close).and_raise(e)
+    expect(Rpush.logger).to receive(:error).with(e)
+    store.release_connection
+  end
+
+  describe 'deliverable_notifications' do
+    it 'checks for new notifications with the ability to reconnect the database' do
+      expect(store).to receive(:with_database_reconnect_and_retry)
+      store.deliverable_notifications(Rpush.config.batch_size)
+    end
+
+    it 'loads notifications in batches' do
+      Rpush.config.batch_size = 5000
+      relation = double.as_null_object
+      expect(relation).to receive(:limit).with(5000)
+      allow(relation).to receive_messages(pluck: [])
+      allow(store).to receive_messages(ready_for_delivery: relation)
+      store.deliverable_notifications(Rpush.config.batch_size)
+    end
+
+    it 'loads an undelivered notification without deliver_after set' do
+      notification.update_attributes!(delivered: false, deliver_after: nil)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to eq [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)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to eq [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)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+
+    it 'does not load a previously delivered notification' do
+      notification.update_attributes!(delivered: true, delivered_at: time)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+
+    it "does not enqueue a notification that has previously failed delivery" do
+      notification.update_attributes!(delivered: false, failed: true)
+      expect(store.deliverable_notifications(Rpush.config.batch_size)).to be_empty
+    end
+  end
+
+  describe 'mark_retryable' do
+    it 'increments the retry count' do
+      expect do
+        store.mark_retryable(notification, time)
+      end.to change(notification, :retries).by(1)
+    end
+
+    it 'sets the deliver after timestamp' do
+      deliver_after = time + 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
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_retryable(notification, time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_retryable(notification, time, persist: false)
+    end
+  end
+
+  describe 'mark_batch_retryable' do
+    let(:deliver_after) { time + 10.seconds }
+
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_retryable([notification], deliver_after)
+      expect(notification.deliver_after).to eq deliver_after
+      expect(notification.retries).to eq 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, time)
+      end.to change(notification, :delivered).to(true)
+    end
+
+    it 'sets the time the notification was delivered' do
+      expect do
+        store.mark_delivered(notification, time)
+        notification.reload
+      end.to change { notification.delivered_at.try(:utc).to_s }.to(time.to_s)
+    end
+
+    it 'saves the notification without validation' do
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_delivered(notification, time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_delivered(notification, time, persist: false)
+    end
+  end
+
+  describe 'mark_batch_delivered' do
+    it 'sets the attributes on the object for use in reflections' do
+      store.mark_batch_delivered([notification])
+      expect(notification.delivered_at).to eq time
+      expect(notification.delivered).to be_truthy
+    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(time.to_s)
+    end
+  end
+
+  describe 'mark_failed' do
+    it 'marks the notification as not delivered' do
+      store.mark_failed(notification, nil, '', time)
+      expect(notification.delivered).to eq(false)
+    end
+
+    it 'marks the notification as failed' do
+      expect do
+        store.mark_failed(notification, nil, '', time)
+        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, '', time)
+        notification.reload
+      end.to change { notification.failed_at.try(:utc).to_s }.to(time.to_s)
+    end
+
+    it 'sets the error code' do
+      expect do
+        store.mark_failed(notification, 42, '', time)
+      end.to change(notification, :error_code).to(42)
+    end
+
+    it 'sets the error description' do
+      expect do
+        store.mark_failed(notification, 42, 'Weeee', time)
+      end.to change(notification, :error_description).to('Weeee')
+    end
+
+    it 'saves the notification without validation' do
+      expect(notification).to receive(:save!).with(validate: false)
+      store.mark_failed(notification, nil, '', time)
+    end
+
+    it 'does not save the notification if persist: false' do
+      expect(notification).not_to receive(:save!)
+      store.mark_failed(notification, nil, '', time, persist: false)
+    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')
+      expect(notification.failed_at).to eq time
+      expect(notification.delivered_at).to be_nil
+      expect(notification.delivered).to eq(false)
+      expect(notification.failed).to be_truthy
+      expect(notification.error_code).to eq 123
+      expect(notification.error_description).to eq 'an error'
+    end
+
+    it 'marks the notification as not delivered' do
+      store.mark_batch_failed([notification], nil, '')
+      notification.reload
+      expect(notification.delivered).to be_falsey
+    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(time.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
+      expect(Rpush::Client::ActiveRecord::Apns::Feedback).to receive(:create!).with(
+        failed_at: time, device_token: 'ab' * 32, app_id: app.id)
+      store.create_apns_feedback(time, 'ab' * 32, app)
+    end
+  end
+
+  describe 'create_gcm_notification' do
+    let(:data) { { data: true } }
+    let(:attributes) { { device_token: 'ab' * 32 } }
+    let(:registration_ids) { %w(123 456) }
+    let(:deliver_after) { time + 10.seconds }
+    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
+
+    it 'sets the given attributes' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.device_token).to eq 'ab' * 32
+    end
+
+    it 'sets the given data' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.data['data']).to be_truthy
+    end
+
+    it 'sets the given registration IDs' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.registration_ids).to eq registration_ids
+    end
+
+    it 'sets the deliver_after timestamp' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.deliver_after.to_s).to eq deliver_after.to_s
+    end
+
+    it 'saves the new notification' do
+      new_notification = store.create_gcm_notification(*args)
+      expect(new_notification.new_record?).to be_falsey
+    end
+  end
+
+  describe 'create_adm_notification' do
+    let(:data) { { data: true } }
+    let(:attributes) { { app_id: app.id, collapse_key: 'ckey', delay_while_idle: true } }
+    let(:registration_ids) { %w(123 456) }
+    let(:deliver_after) { time + 10.seconds }
+    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
+
+    it 'sets the given attributes' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.app_id).to eq app.id
+      expect(new_notification.collapse_key).to eq 'ckey'
+      expect(new_notification.delay_while_idle).to be_truthy
+    end
+
+    it 'sets the given data' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.data['data']).to be_truthy
+    end
+
+    it 'sets the given registration IDs' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.registration_ids).to eq registration_ids
+    end
+
+    it 'sets the deliver_after timestamp' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.deliver_after.to_s).to eq deliver_after.to_s
+    end
+
+    it 'saves the new notification' do
+      new_notification = store.create_adm_notification(*args)
+      expect(new_notification.new_record?).to be_falsey
+    end
+  end
+end if active_record?