rpush 4.2.0 → 7.0.1

data/spec/unit/client/active_record/pushy/notification_spec.rb

@@ -1,59 +1,6 @@
 require 'unit_spec_helper'
-require 'unit/notification_shared.rb'
 
 describe Rpush::Client::ActiveRecord::Pushy::Notification do
-  let(:notification_class) { described_class }
-  subject(:notification) { notification_class.new }
-
-  it_behaves_like 'an Notification subclass'
-
-  describe 'validates' do
-    let(:app) { Rpush::Client::ActiveRecord::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
+  it_behaves_like 'Rpush::Client::Pushy::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
 end if active_record?

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

@@ -0,0 +1,14 @@
+shared_examples_for 'Rpush::Client::ActiveRecord::App' do
+  it 'validates the uniqueness of name within type and environment' do
+    Rpush::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT)
+    app = Rpush::Apns::App.new(name: 'test', environment: 'production', certificate: TEST_CERT)
+    expect(app.valid?).to eq(false)
+    expect(app.errors[:name]).to eq ['has already been taken']
+
+    app = Rpush::Apns::App.new(name: 'test', environment: 'development', certificate: TEST_CERT)
+    expect(app.valid?).to eq(true)
+
+    app = Rpush::Gcm::App.new(name: 'test', environment: 'production', auth_key: TEST_CERT)
+    expect(app.valid?).to eq(true)
+  end
+end

data/spec/unit/{notification_shared.rb → client/active_record/shared/notification.rb}

@@ -1,16 +1,21 @@
-shared_examples_for 'an Notification subclass' do
+shared_examples_for 'Rpush::Client::ActiveRecord::Notification' do
+  let(:notification) { described_class.new }
+
+  it 'allows assignment of a single registration ID' do
+    notification.registration_ids = 'a'
+    expect(notification.registration_ids).to eq ['a']
+  end
+
   describe 'when assigning data for the device' do
     before { allow(Rpush::Deprecation).to receive(:warn) }
 
     it 'calls MultiJson.dump when multi_json responds to :dump' do
-      notification = notification_class.new
       allow(MultiJson).to receive(:respond_to?).with(:dump).and_return(true)
       expect(MultiJson).to receive(:dump).with(any_args)
       notification.data = { pirates: 1 }
     end
 
     it 'calls MultiJson.encode when multi_json does not respond to :dump' do
-      notification = notification_class.new
       allow(MultiJson).to receive(:respond_to?).with(:dump).and_return(false)
       expect(MultiJson).to receive(:encode).with(any_args)
       notification.data = { ninjas: 1 }
@@ -23,12 +28,12 @@ shared_examples_for 'an Notification subclass' do
     end
 
     it 'encodes the given Hash as JSON' do
-      notification.data = { hi: 'mom'}
+      notification.data = { hi: 'mom' }
       expect(notification.read_attribute(:data)).to eq('{"hi":"mom"}')
     end
 
     it 'decodes the JSON when using the reader method' do
-      notification.data = { hi: 'mom'}
+      notification.data = { hi: 'mom' }
       expect(notification.data).to eq('hi' => 'mom')
     end
   end
@@ -41,12 +46,12 @@ shared_examples_for 'an Notification subclass' do
     end
 
     it 'encodes the given Hash as JSON' do
-      notification.notification = { hi: 'dad'}
+      notification.notification = { hi: 'dad' }
       expect(notification.read_attribute(:notification)).to eq('{"hi":"dad"}')
     end
 
     it 'decodes the JSON when using the reader method' do
-      notification.notification = { hi: 'dad'}
+      notification.notification = { hi: 'dad' }
       expect(notification.notification).to eq('hi' => 'dad')
     end
   end

data/spec/unit/client/active_record/webpush/app_spec.rb

@@ -0,0 +1,6 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Webpush::App do
+  it_behaves_like 'Rpush::Client::Webpush::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
+end if active_record?

data/spec/unit/client/active_record/webpush/notification_spec.rb

@@ -0,0 +1,6 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Webpush::Notification do
+  it_behaves_like 'Rpush::Client::Webpush::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
+end if active_record?

data/spec/unit/client/active_record/wns/badge_notification_spec.rb

@@ -1,15 +1,5 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Wns::BadgeNotification do
-  let(:notification) do
-    notif = Rpush::Client::ActiveRecord::Wns::BadgeNotification.new
-    notif.app  = Rpush::Client::ActiveRecord::Wns::App.new(name: "aname")
-    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
+  it_behaves_like 'Rpush::Client::Wns::BadgeNotification'
 end if active_record?

data/spec/unit/client/active_record/wns/raw_notification_spec.rb

@@ -1,9 +1,10 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Wns::RawNotification do
+  it_behaves_like 'Rpush::Client::Wns::RawNotification'
   let(:notification) do
-    notif = Rpush::Client::ActiveRecord::Wns::RawNotification.new
-    notif.app  = Rpush::Client::ActiveRecord::Wns::App.new(name: "aname")
+    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
@@ -13,14 +14,4 @@ describe Rpush::Client::ActiveRecord::Wns::RawNotification do
     allow(notification).to receive(:payload_data_size) { 5121 }
     expect(notification.valid?).to be(false)
   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 if active_record?

data/spec/unit/client/active_record/wpns/app_spec.rb

@@ -1,4 +1,6 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Wpns::App do
-end
+  it_behaves_like 'Rpush::Client::Wpns::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
+end if active_record?

data/spec/unit/client/active_record/wpns/notification_spec.rb

@@ -1,21 +1,6 @@
 require 'unit_spec_helper'
-require 'unit/notification_shared.rb'
 
 describe Rpush::Client::ActiveRecord::Wpns::Notification do
-  it_should_behave_like 'an Notification subclass'
-  let(:app) { Rpush::Client::ActiveRecord::Wpns::App.create!(name: 'test', auth_key: 'abc') }
-  let(:notification_class) { Rpush::Client::ActiveRecord::Wpns::Notification }
-  let(:notification) { notification_class.new }
-
-  it "should have an url in the uri parameter" do
-    notification = Rpush::Client::ActiveRecord::Wpns::Notification.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 = Rpush::Client::ActiveRecord::Wpns::Notification.new(data: {})
-    notification.valid?
-    expect(notification.errors[:data]).to include("can't be blank")
-  end
+  it_behaves_like 'Rpush::Client::Wpns::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
 end if active_record?

data/spec/unit/client/redis/adm/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Adm::App do
+  it_behaves_like 'Rpush::Client::Adm::App'
+end if redis?

data/spec/unit/client/redis/adm/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Adm::Notification do
+  it_behaves_like 'Rpush::Client::Adm::Notification'
+end if redis?

data/spec/unit/client/redis/apns/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Apns::App do
+  it_behaves_like 'Rpush::Client::Apns::App'
+end if redis?

data/spec/unit/client/redis/apns/feedback_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Apns::Feedback do
+  it_behaves_like 'Rpush::Client::Apns::Feedback'
+end if redis?

data/spec/unit/client/redis/apns/notification_spec.rb

@@ -0,0 +1,50 @@
+# encoding: US-ASCII
+
+require "unit_spec_helper"
+
+describe Rpush::Client::Redis::Apns::Notification do
+  it_behaves_like 'Rpush::Client::Apns::Notification'
+
+  it "should validate the length of the binary conversion of the notification" do
+    notification = described_class.new
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
+    notification.device_token = "a" * 108
+    notification.alert = ""
+
+    notification.alert << "a" until notification.payload.bytesize == 2048
+    expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
+
+    notification.alert << "a"
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base].include?("APN notification cannot be larger than 2048 bytes. Try condensing your alert and device attributes.")).to be_truthy
+  end
+
+  it "should default the sound to 'default'" do
+    notification = described_class.new
+    expect(notification.sound).to eq('default')
+  end
+
+  # skipping these tests because data= for redis doesn't merge existing data
+  xit 'does not overwrite the mutable-content flag when setting attributes for the device' do
+    notification.mutable_content = true
+    notification.data = { 'hi' => 'mom' }
+    expect(notification.as_json['aps']['mutable-content']).to eq 1
+    expect(notification.as_json['hi']).to eq 'mom'
+  end
+
+  xit 'does not overwrite the content-available flag when setting attributes for the device' do
+    notification.content_available = true
+    notification.data = { 'hi' => 'mom' }
+    expect(notification.as_json['aps']['content-available']).to eq 1
+    expect(notification.as_json['hi']).to eq 'mom'
+  end
+
+  # redis does not use alert_is_json - unclear if that is a bug or desired behavior
+  xit 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
+    notification = described_class.new
+    allow(notification).to receive_messages(has_attribute?: false)
+    notification.alert = "{\"one\":2}"
+    expect(notification.alert).to eq('one' => 2)
+  end
+end if redis?

data/spec/unit/client/redis/apns2/app_spec.rb

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Apns2::App do
+end if redis?

data/spec/unit/client/redis/apns2/notification_spec.rb

@@ -0,0 +1,50 @@
+# encoding: US-ASCII
+
+require "unit_spec_helper"
+
+describe Rpush::Client::Redis::Apns2::Notification do
+  it_behaves_like 'Rpush::Client::Apns::Notification'
+
+  it "should validate the length of the binary conversion of the notification" do
+    notification = described_class.new
+    notification.app = Rpush::Apns2::App.create(name: 'test', environment: 'development', certificate: TEST_CERT)
+    notification.device_token = "a" * 108
+    notification.alert = ""
+
+    notification.alert << "a" until notification.payload.bytesize == 4096
+    expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
+
+    notification.alert << "a"
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base].include?("APN notification cannot be larger than 4096 bytes. Try condensing your alert and device attributes.")).to be_truthy
+  end
+
+  it "should default the sound to 'default'" do
+    notification = described_class.new
+    expect(notification.sound).to eq('default')
+  end
+
+  # skipping these tests because data= for redis doesn't merge existing data
+  xit 'does not overwrite the mutable-content flag when setting attributes for the device' do
+    notification.mutable_content = true
+    notification.data = { 'hi' => 'mom' }
+    expect(notification.as_json['aps']['mutable-content']).to eq 1
+    expect(notification.as_json['hi']).to eq 'mom'
+  end
+
+  xit 'does not overwrite the content-available flag when setting attributes for the device' do
+    notification.content_available = true
+    notification.data = { 'hi' => 'mom' }
+    expect(notification.as_json['aps']['content-available']).to eq 1
+    expect(notification.as_json['hi']).to eq 'mom'
+  end
+
+  # redis does not use alert_is_json - unclear if that is a bug or desired behavior
+  xit 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
+    notification = described_class.new
+    allow(notification).to receive_messages(has_attribute?: false)
+    notification.alert = "{\"one\":2}"
+    expect(notification.alert).to eq('one' => 2)
+  end
+end if redis?

data/spec/unit/client/redis/apnsp8/notification_spec.rb

@@ -0,0 +1,29 @@
+require "unit_spec_helper"
+
+describe Rpush::Client::Redis::Apnsp8::Notification do
+  after do
+    Rpush::Apnsp8::App.all.select { |a| a.environment == "development" && a.apn_key == "1" }.each(&:destroy)
+  end
+
+  it_behaves_like "Rpush::Client::Apns::Notification"
+
+  it "should validate the length of the binary conversion of the notification", :aggregate_failures do
+    notification = described_class.new
+    notification.app = Rpush::Apnsp8::App.create(apn_key: "1",
+                                                 apn_key_id: "2",
+                                                 name: 'test',
+                                                 environment: 'development',
+                                                 team_id: "3",
+                                                 bundle_id: "4")
+    notification.device_token = "a" * 108
+    notification.alert = ""
+
+    notification.alert << "a" until notification.payload.bytesize == 4096
+    expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
+
+    notification.alert << "a"
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:base].include?("APN notification cannot be larger than 4096 bytes. Try condensing your alert and device attributes.")).to be_truthy
+  end
+end if redis?

data/spec/unit/client/redis/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::App do
+  it_behaves_like 'Rpush::Client::App'
+end if redis?

data/spec/unit/client/redis/gcm/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Gcm::App do
+  it_behaves_like 'Rpush::Client::Gcm::App'
+end if redis?

data/spec/unit/client/redis/gcm/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Gcm::Notification do
+  it_behaves_like 'Rpush::Client::Gcm::Notification'
+end if redis?

data/spec/unit/client/redis/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Notification do
+  it_behaves_like 'Rpush::Client::Notification'
+end if redis?

data/spec/unit/client/redis/pushy/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Pushy::App do
+  it_behaves_like 'Rpush::Client::Pushy::App'
+end if redis?

data/spec/unit/client/redis/pushy/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Pushy::Notification do
+  it_behaves_like 'Rpush::Client::Pushy::Notification'
+end if redis?

data/spec/unit/client/redis/webpush/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Webpush::App do
+  it_behaves_like 'Rpush::Client::Webpush::App'
+end if redis?

data/spec/unit/client/redis/webpush/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Webpush::Notification do
+  it_behaves_like 'Rpush::Client::Webpush::Notification'
+end if redis?

data/spec/unit/client/redis/wns/badge_notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Wns::BadgeNotification do
+  it_behaves_like 'Rpush::Client::Wns::BadgeNotification'
+end if redis?

data/spec/unit/client/redis/wns/raw_notification_spec.rb

@@ -0,0 +1,22 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Wns::RawNotification do
+  it_behaves_like 'Rpush::Client::Wns::RawNotification'
+
+  subject(: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
+
+  # This fails because the length validation is only on active record
+  # Attempting to move to active model in rails 6 fails
+  # because wns_notification#as_json is not defined
+  # and the active_model#as_json version results in a stack level too deep error
+  xit 'does not allow the size of payload over 5 KB' do
+    allow(notification).to receive(:payload_data_size) { 5121 }
+    expect(notification.valid?).to be(false)
+  end
+end if redis?

data/spec/unit/client/redis/wpns/app_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Wpns::App do
+  it_behaves_like 'Rpush::Client::Wpns::App'
+end if redis?

data/spec/unit/client/redis/wpns/notification_spec.rb

@@ -0,0 +1,5 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::Redis::Wpns::Notification do
+  it_behaves_like 'Rpush::Client::Wpns::Notification'
+end if redis?

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

@@ -0,0 +1,51 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Adm::App' do
+  subject { described_class.new(name: 'test', environment: 'development', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
+
+  it 'should be valid if properly instantiated' do
+    expect(subject).to be_valid
+  end
+
+  it 'should be invalid if name' do
+    subject.name = nil
+    expect(subject).not_to be_valid
+    expect(subject.errors[:name]).to eq ["can't be blank"]
+  end
+
+  it 'should be invalid if missing client_id' do
+    subject.client_id = nil
+    expect(subject).not_to be_valid
+    expect(subject.errors[:client_id]).to eq ["can't be blank"]
+  end
+
+  it 'should be invalid if missing client_secret' do
+    subject.client_secret = nil
+    expect(subject).not_to be_valid
+    expect(subject.errors[:client_secret]).to eq ["can't be blank"]
+  end
+
+  describe '#access_token_expired?' do
+    before(:each) do
+      Timecop.freeze(Time.now)
+    end
+
+    after do
+      Timecop.return
+    end
+
+    it 'should return true if access_token_expiration is nil' do
+      expect(subject.access_token_expired?).to eq(true)
+    end
+
+    it 'should return true if expired' do
+      subject.access_token_expiration = Time.now - 5.minutes
+      expect(subject.access_token_expired?).to eq(true)
+    end
+
+    it 'should return false if not expired' do
+      subject.access_token_expiration = Time.now + 5.minutes
+      expect(subject.access_token_expired?).to eq(false)
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Adm::Notification' do
+  let(:app) { Rpush::Adm::App.create!(name: 'test', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
+  let(:notification) { described_class.new }
+
+  it "has a 'data' payload limit of 6144 bytes" do
+    notification.data = { key: "a" * 6144 }
+    expect(notification.valid?).to eq(false)
+    expect(notification.errors[:base]).to eq ["Notification payload data cannot be larger than 6144 bytes."]
+  end
+
+  it 'limits the number of registration ids to 100' do
+    notification.registration_ids = ['a'] * (100 + 1)
+    expect(notification.valid?).to eq(false)
+    expect(notification.errors[:base]).to eq ["Number of registration_ids cannot be larger than 100."]
+  end
+
+  it 'validates data can be blank if collapse_key is set' do
+    notification.app = app
+    notification.registration_ids = ['a']
+    notification.collapse_key = 'test'
+    notification.data = nil
+    expect(notification.valid?).to eq(true)
+    expect(notification.errors[:data]).to be_empty
+  end
+
+  it 'validates data is present if collapse_key is not set' do
+    notification.collapse_key = nil
+    notification.data = nil
+    expect(notification.valid?).to eq(false)
+    expect(notification.errors[:data]).to eq ['must be set unless collapse_key is specified']
+  end
+
+  it 'includes expiresAfter in the payload' do
+    notification.expiry = 100
+    expect(notification.as_json['expiresAfter']).to eq 100
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Apns::App' do
+  it 'does not validate an app with an invalid certificate' do
+    app = described_class.new(name: 'test', environment: 'development', certificate: 'foo')
+    app.valid?
+    expect(app.errors[:certificate]).to eq ['value must contain a certificate and a private key.']
+  end
+
+  it 'validates a certificate without a password' do
+    app = described_class.new name: 'test', environment: 'development', certificate: TEST_CERT
+    app.valid?
+    expect(app.errors[:certificate]).to eq []
+  end
+
+  it 'validates a certificate with a password' do
+    app = described_class.new name: 'test', environment: 'development',
+                              certificate: TEST_CERT_WITH_PASSWORD, password: 'fubar'
+    app.valid?
+    expect(app.errors[:certificate]).to eq []
+  end
+
+  it 'validates a certificate with an incorrect password' do
+    app = described_class.new name: 'test', environment: 'development',
+                              certificate: TEST_CERT_WITH_PASSWORD, password: 'incorrect'
+    app.valid?
+    expect(app.errors[:certificate]).to eq ['value must contain a certificate and a private key.']
+  end
+end

data/spec/unit/client/shared/apns/feedback.rb

@@ -0,0 +1,9 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Apns::Feedback' do
+  it 'validates the format of the device_token' do
+    notification = described_class.new(device_token: "{$%^&*()}")
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:device_token]).to include('is invalid')
+  end
+end