rpush 4.1.1 → 5.3.0

data/spec/unit/client/shared/webpush/app.rb

@@ -0,0 +1,33 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Webpush::App' do
+  describe 'validates' do
+    subject { described_class.new }
+
+    it 'validates presence of name' do
+      is_expected.not_to be_valid
+      expect(subject.errors[:name]).to eq ["can't be blank"]
+    end
+
+    it 'validates presence of vapid_keypair' do
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair]).to eq ["can't be blank"]
+    end
+
+    it 'should require the vapid keypair to have subject, public and private key' do
+      subject.vapid_keypair = {}.to_json
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair].sort).to eq [
+        'must have a private_key entry',
+        'must have a public_key entry',
+        'must have a subject entry',
+      ]
+    end
+
+    it 'should require valid json for the keypair' do
+      subject.vapid_keypair = 'invalid'
+      is_expected.not_to be_valid
+      expect(subject.errors[:vapid_keypair].sort).to eq [ 'must be valid JSON' ]
+    end
+  end
+end

data/spec/unit/client/shared/webpush/notification.rb

@@ -0,0 +1,83 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Webpush::Notification' do
+  subject(:notification) { described_class.new }
+
+  describe 'notification attributes' do
+    describe 'data' do
+      subject { described_class.new(data: { message: 'test', urgency: 'normal' } ) }
+      it 'has a message' do
+        expect(subject.message).to eq "test"
+      end
+      it 'has an urgency' do
+        expect(subject.urgency).to eq "normal"
+      end
+    end
+
+    describe 'subscription' do
+      let(:subscription){ { endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}} }
+      subject { described_class.new(registration_ids: [subscription]) }
+
+      it "has a subscription" do
+        expect(subject.subscription).to eq({ endpoint: 'https://push.example.org/foo', keys: {foo: 'bar'} })
+      end
+    end
+  end
+
+
+  describe 'validates' do
+    let(:app) { Rpush::Webpush::App.create!(name: 'MyApp', vapid_keypair: VAPID_KEYPAIR) }
+
+    describe 'data' do
+      subject { described_class.new(app: app, registration_ids: [{endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}}]) }
+      it 'validates presence' do
+        is_expected.not_to be_valid
+        expect(subject.errors[:data]).to eq ["can't be blank"]
+      end
+
+      it "has a 'data' payload limit of 4096 bytes" do
+        subject.data = { message: 'a' * 4096 }
+        is_expected.not_to be_valid
+        expected_errors = ["Notification payload data cannot be larger than 4096 bytes."]
+        expect(subject.errors[:base]).to eq expected_errors
+      end
+    end
+
+    describe 'registration_ids' do
+      subject { described_class.new(app: app, data: { message: 'test' }) }
+      it 'validates presence' do
+        is_expected.not_to be_valid
+        expect(subject.errors[:registration_ids]).to eq ["can't be blank"]
+      end
+
+      it 'limits the number of registration ids to exactly 1' do
+        subject.registration_ids = [{endpoint: 'string', keys: { 'a' => 'hash' }}] * 2
+        is_expected.not_to be_valid
+        expected_errors = ["Number of registration_ids cannot be larger than 1."]
+        expect(subject.errors[:base]).to eq expected_errors
+      end
+
+      it 'validates the structure of the registration' do
+        subject.registration_ids = ['a']
+        is_expected.not_to be_valid
+        expect(subject.errors[:base]).to eq [
+          "Registration must have :endpoint (String) and :keys (Hash) keys"
+        ]
+
+        subject.registration_ids = [{endpoint: 'string', keys: { 'a' => 'hash' }}]
+        is_expected.to be_valid
+      end
+    end
+
+    describe 'time_to_live' do
+      subject { described_class.new(app: app, data: { message: 'test' }, registration_ids: [{endpoint: 'https://push.example.org/foo', keys: {'foo' => 'bar'}}]) }
+
+      it 'should be > 0' do
+        subject.time_to_live = -1
+        is_expected.not_to be_valid
+        expect(subject.errors[:time_to_live]).to eq ['must be greater than 0']
+      end
+    end
+
+  end
+end

data/spec/unit/client/shared/wns/badge_notification.rb

@@ -0,0 +1,15 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Wns::BadgeNotification' do
+  let(:notification) do
+    notif = described_class.new
+    notif.app  = Rpush::Wns::App.create!(name: "MyApp", client_id: "someclient", client_secret: "somesecret")
+    notif.uri  = 'https://db5.notify.windows.com/?token=TOKEN'
+    notif.badge = 42
+    notif
+  end
+
+  it 'should allow a notification without data' do
+    expect(notification.valid?).to be(true)
+  end
+end

data/spec/unit/client/shared/wns/raw_notification.rb

@@ -0,0 +1,21 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Wns::RawNotification' do
+  let(:notification) do
+    notif = described_class.new
+    notif.app  = Rpush::Wns::App.create!(name: "MyApp", client_id: "someclient", client_secret: "somesecret")
+    notif.uri  = 'https://db5.notify.windows.com/?token=TOKEN'
+    notif.data = { foo: 'foo', bar: 'bar' }
+    notif
+  end
+
+  it 'allows exact payload of 5 KB' do
+    allow(notification).to receive(:payload_data_size) { 5120 }
+    expect(notification.valid?).to be(true)
+  end
+
+  it 'allows the size of payload under 5 KB' do
+    allow(notification).to receive(:payload_data_size) { 5119 }
+    expect(notification.valid?).to be(true)
+  end
+end

data/spec/unit/client/shared/wpns/app.rb

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Wpns::App' do
+end

data/spec/unit/client/shared/wpns/notification.rb

@@ -0,0 +1,18 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Wpns::Notification' do
+  let(:app) { Rpush::Wpns::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification) { described_class.new }
+
+  it "should have an url in the uri parameter" do
+    notification = described_class.new(uri: "somthing")
+    notification.valid?
+    expect(notification.errors[:uri]).to include('is invalid')
+  end
+
+  it "should be invalid if there's no data" do
+    notification = described_class.new(data: {})
+    notification.valid?
+    expect(notification.errors[:data]).to include("can't be blank")
+  end
+end

data/spec/unit/daemon/apns/feedback_receiver_spec.rb

@@ -7,7 +7,16 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
   let(:frequency) { 60 }
   let(:certificate) { double }
   let(:password) { double }
-  let(:app) { double(name: 'my_app', password: password, certificate: certificate, environment: 'production') }
+  let(:feedback_enabled) { true }
+  let(:app) do
+    double(
+      name: 'my_app',
+      password: password,
+      certificate: certificate,
+      feedback_enabled: feedback_enabled,
+      environment: 'production'
+    )
+  end
   let(:connection) { double(connect: nil, read: nil, close: nil) }
   let(:logger) { double(error: nil, info: nil) }
   let(:receiver) { Rpush::Daemon::Apns::FeedbackReceiver.new(app) }
@@ -93,6 +102,15 @@ describe Rpush::Daemon::Apns::FeedbackReceiver, 'check_for_feedback' do
       expect(receiver).to receive(:check_for_feedback).at_least(:once)
       receiver.start
     end
+
+    context 'with feedback_enabled false' do
+      let(:feedback_enabled) { false }
+
+      it 'does not check for feedback when started' do
+        expect(receiver).not_to receive(:check_for_feedback)
+        receiver.start
+      end
+    end
   end
 
   describe 'stop' do

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/gcm/delivery_spec.rb

@@ -40,7 +40,7 @@ describe Rpush::Daemon::Gcm::Delivery do
     end
 
     it 'creates a new notification for the unavailable devices' do
-      notification.update_attributes(registration_ids: %w(id_0 id_1 id_2), data: { 'one' => 1 }, collapse_key: 'thing', delay_while_idle: true)
+      notification.update(registration_ids: %w(id_0 id_1 id_2), data: { 'one' => 1 }, collapse_key: 'thing', delay_while_idle: true)
       allow(response).to receive_messages(header: { 'retry-after' => 10 })
       attrs = { 'collapse_key' => 'thing', 'delay_while_idle' => true, 'app_id' => app.id }
       expect(store).to receive(:create_gcm_notification).with(attrs, notification.data,

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