rpush 4.2.0 → 7.0.1

data/spec/unit/daemon/apnsp8/delivery_spec.rb

@@ -0,0 +1,53 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Apnsp8::Delivery do
+  subject(:delivery) { described_class.new(app, http2_client, token_provider, batch) }
+
+  let(:app) { double(bundle_id: 'MY BUNDLE ID') }
+  let(:notification1) { double('Notification 1', data: {}, as_json: {}).as_null_object }
+  let(:notification2) { double('Notification 2', data: {}, as_json: {}).as_null_object }
+
+  let(:token_provider) { double(token: 'MY JWT TOKEN') }
+  let(:max_concurrent_streams) { 100 }
+  let(:remote_settings) { { settings_max_concurrent_streams: max_concurrent_streams } }
+  let(:http_request) { double(on: nil) }
+  let(:http2_client) do
+    double(
+      stream_count: 0,
+      call_async: nil,
+      join: nil,
+      prepare_request: http_request,
+      remote_settings: remote_settings
+    )
+  end
+
+  let(:batch) { double(mark_delivered: nil, all_processed: nil) }
+  let(:logger) { double(info: nil) }
+
+  before do
+    allow(batch).to receive(:each_notification) do |&blk|
+      [notification1, notification2].each(&blk)
+    end
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  describe '#perform' do
+    context 'with an HTTP2 client where max concurrent streams is not set' do
+      let(:max_concurrent_streams) { 0x7fffffff }
+
+      it 'does not fall into an infinite loop on notifications after the first' do
+        start = Time.now
+        thread = Thread.new { delivery.perform }
+
+        loop do
+          break unless thread.alive?
+
+          if Time.now - start > 0.5
+            thread.kill
+            fail 'Stuck in an infinite loop'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/daemon/batch_spec.rb

@@ -1,8 +1,8 @@
 require 'unit_spec_helper'
 
 describe Rpush::Daemon::Batch do
-  let(:notification1) { double(:notification1, id: 1) }
-  let(:notification2) { double(:notification2, id: 2) }
+  let(:notification1) { double(:notification1, id: 1, delivered: false, failed: false) }
+  let(:notification2) { double(:notification2, id: 2, delivered: false, failed: false) }
   let(:batch) { Rpush::Daemon::Batch.new([notification1, notification2]) }
   let(:store) { double.as_null_object }
   let(:time) { Time.now }
@@ -50,6 +50,54 @@ describe Rpush::Daemon::Batch do
     end
   end
 
+  describe 'mark_all_retryable' do
+    let(:error) { StandardError.new('Exception') }
+
+    it 'marks all notifications as retryable without persisting' do
+      expect(store).to receive(:mark_retryable).ordered.with(notification1, time, persist: false)
+      expect(store).to receive(:mark_retryable).ordered.with(notification2, time, persist: false)
+
+      batch.mark_all_retryable(time, error)
+    end
+
+    it 'defers persisting' do
+      batch.mark_all_retryable(time, error)
+      expect(batch.retryable).to eq(time => [notification1, notification2])
+    end
+
+    context 'when one of the notifications delivered' do
+      let(:notification2) { double(:notification2, id: 2, delivered: true, failed: false) }
+
+      it 'marks all only pending notification as retryable without persisting' do
+        expect(store).to receive(:mark_retryable).ordered.with(notification1, time, persist: false)
+        expect(store).not_to receive(:mark_retryable).ordered.with(notification2, time, persist: false)
+
+        batch.mark_all_retryable(time, error)
+      end
+
+      it 'defers persisting' do
+        batch.mark_all_retryable(time, error)
+        expect(batch.retryable).to eq(time => [notification1])
+      end
+    end
+
+    context 'when one of the notifications failed' do
+      let(:notification2) { double(:notification2, id: 2, delivered: false, failed: true) }
+
+      it 'marks all only pending notification as retryable without persisting' do
+        expect(store).to receive(:mark_retryable).ordered.with(notification1, time, persist: false)
+        expect(store).not_to receive(:mark_retryable).ordered.with(notification2, time, persist: false)
+
+        batch.mark_all_retryable(time, error)
+      end
+
+      it 'defers persisting' do
+        batch.mark_all_retryable(time, error)
+        expect(batch.retryable).to eq(time => [notification1])
+      end
+    end
+  end
+
   describe 'mark_failed' do
     it 'marks the notification as failed without persisting' do
       expect(store).to receive(:mark_failed).with(notification1, 1, 'an error', time, persist: false)

data/spec/unit/daemon/delivery_spec.rb

@@ -41,6 +41,16 @@ describe Rpush::Daemon::Delivery do
     end
   end
 
+  describe 'mark_batch_retryable' do
+    let(:batch) { double(Rpush::Daemon::Batch) }
+    let(:error) { StandardError.new('Exception') }
+
+    it 'marks all notifications as retryable' do
+      expect(batch).to receive(:mark_all_retryable)
+      delivery.mark_batch_retryable(Time.now + 1.hour, error)
+    end
+  end
+
   describe 'mark_batch_failed' do
     it 'marks all notifications as delivered' do
       error = Rpush::DeliveryError.new(1, 42, 'an error')

data/spec/unit/daemon/pushy/delivery_spec.rb

@@ -61,10 +61,12 @@ describe Rpush::Daemon::Pushy::Delivery do
       it_behaves_like 'process notification'
     end
 
-    shared_examples 'retry delivery' do |response_code:|
-      let(:response_code) { response_code }
+    shared_examples 'retry delivery' do |options|
+      let(:response_code) { options[:response_code] }
+
+      shared_examples 'logs' do |log_options|
+        let(:deliver_after) { log_options[:deliver_after] }
 
-      shared_examples 'logs' do |deliver_after:|
         let(:expected_log_message) do
           "Pushy responded with a #{response_code} error. Notification #{notification.id} " \
           "will be retried after #{deliver_after} (retry 1)."

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

@@ -0,0 +1,312 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Daemon::Store' do
+  subject(:store) { described_class.new }
+
+  let(:app) { Rpush::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
+  let(:notification) { Rpush::Apns::Notification.create!(device_token: "a" * 64, app: app) }
+  let(:time) { Time.parse('2019/06/06 02:45').utc }
+  let(:logger) { double(Rpush::Logger, error: nil, internal_logger: nil) }
+
+  before do
+    allow(Rpush).to receive_messages(logger: logger)
+  end
+
+  before(:each) do
+    Timecop.freeze(time)
+  end
+
+  after do
+    Timecop.return
+  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
+
+  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_s).to eq deliver_after.to_s
+      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_s).to eq time.to_s
+      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_s).to eq time.to_s
+      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(time)
+    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::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 eq deliver_after
+    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

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

@@ -80,8 +80,8 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
     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
+  it "should test out the new connection by performing an exists" do
+    expect(Rpush::Client::ActiveRecord::Notification).to receive(:exists?).twice
     test_doubles.each(&:perform)
   end
 
@@ -118,13 +118,13 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
   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
+        def exists?
+          @exists_calls += 1
+          return if @exists_calls == 2
           fail @error
         end
       end
-      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@count_calls", 0)
+      Rpush::Client::ActiveRecord::Notification.instance_variable_set("@exists_calls", 0)
       Rpush::Client::ActiveRecord::Notification.instance_variable_set("@error", error)
     end
 
@@ -152,7 +152,7 @@ describe Rpush::Daemon::Store::ActiveRecord::Reconnectable do
       end
 
       it "should log errors raised when the reconnection is not successful" do
-        expect(Rpush.logger).to receive(:error).with(error)
+        expect(Rpush.logger).to receive(:error).with(timeout)
         test_doubles[1].perform
       end