rpush 5.0.0 → 5.1.0

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

@@ -0,0 +1,17 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::App' do
+  context 'validating certificates' do
+    it 'rescues from certificate error' do
+      app = Rpush::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      expect { app.valid? }.not_to raise_error
+      expect(app.valid?).to eq(false)
+    end
+
+    it 'raises other errors' do
+      app = Rpush::Apns::App.new(name: 'test', environment: 'development', certificate: 'bad')
+      allow(OpenSSL::X509::Certificate).to receive(:new).and_raise(NameError, 'simulating no openssl')
+      expect { app.valid? }.to raise_error(NameError)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,77 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Gcm::Notification' do
+  let(:app) { Rpush::Gcm::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification) { described_class.new }
+
+  it "has a 'data' payload limit of 4096 bytes" do
+    notification.data = { key: "a" * 4096 }
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base]).to eq ["Notification payload data cannot be larger than 4096 bytes."]
+  end
+
+  it 'limits the number of registration ids to 1000' do
+    notification.registration_ids = ['a'] * (1000 + 1)
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base]).to eq ["Number of registration_ids cannot be larger than 1000."]
+  end
+
+  it 'validates expiry is present if collapse_key is set' do
+    notification.collapse_key = 'test'
+    notification.expiry = nil
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:expiry]).to eq ['must be set when using a collapse_key']
+  end
+
+  it 'includes time_to_live in the payload' do
+    notification.expiry = 100
+    expect(notification.as_json['time_to_live']).to eq 100
+  end
+
+  it 'includes content_available in the payload' do
+    notification.content_available = true
+    expect(notification.as_json['content_available']).to eq true
+  end
+
+  it 'includes mutable_content in the payload' do
+    notification.mutable_content = true
+    expect(notification.as_json['mutable_content']).to eq true
+  end
+
+  it 'sets the priority to high when set to high' do
+    notification.priority = 'high'
+    expect(notification.as_json['priority']).to eq 'high'
+  end
+
+  it 'sets the priority to normal when set to normal' do
+    notification.priority = 'normal'
+    expect(notification.as_json['priority']).to eq 'normal'
+  end
+
+  it 'validates the priority is either "normal" or "high"' do
+    notification.priority = 'invalid'
+    expect(notification.errors[:priority]).to eq ['must be one of either "normal" or "high"']
+  end
+
+  it 'excludes the priority if it is not defined' do
+    expect(notification.as_json).not_to have_key 'priority'
+  end
+
+  it 'includes the notification payload if defined' do
+    notification.notification = { key: 'any key is allowed' }
+    expect(notification.as_json).to have_key 'notification'
+  end
+
+  it 'excludes the notification payload if undefined' do
+    expect(notification.as_json).not_to have_key 'notification'
+  end
+
+  it 'includes the dry_run payload if defined' do
+    notification.dry_run = true
+    expect(notification.as_json['dry_run']).to eq true
+  end
+
+  it 'excludes the dry_run payload if undefined' do
+    expect(notification.as_json).not_to have_key 'dry_run'
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Notification' do
+  let(:notification) { described_class.new }
+
+  it 'allows assignment of many registration IDs' do
+    notification.registration_ids = %w[a b]
+    expect(notification.registration_ids).to eq %w[a b]
+  end
+end

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

@@ -0,0 +1,17 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Pushy::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 api_key' do
+      is_expected.not_to be_valid
+      expect(subject.errors[:api_key]).to eq ["can't be blank"]
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Pushy::Notification' do
+  subject(:notification) { described_class.new }
+
+  describe 'validates' do
+    let(:app) { Rpush::Pushy::App.create!(name: 'MyApp', api_key: 'my_api_key') }
+
+    describe 'data' do
+      subject { described_class.new(app: app, registration_ids: ['id']) }
+      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 1000' do
+        subject.registration_ids = ['a'] * (1000 + 1)
+        is_expected.not_to be_valid
+        expected_errors = ["Number of registration_ids cannot be larger than 1000."]
+        expect(subject.errors[:base]).to eq expected_errors
+      end
+    end
+
+    describe 'time_to_live' do
+      subject { described_class.new(app: app, data: { message: 'test' }, registration_ids: ['id']) }
+
+      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
+
+      it 'should be <= 1.year.seconds' do
+        subject.time_to_live = 2.years.seconds.to_i
+        is_expected.not_to be_valid
+        expect(subject.errors[:time_to_live]).to eq ['The maximum value is 1 year']
+      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/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