rpush 4.2.0 → 5.4.0

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

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

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

@@ -0,0 +1,65 @@
+require "unit_spec_helper"
+
+describe Rpush::Client::ActiveRecord::Apns2::Notification do
+  subject(:notification) { described_class.new }
+
+  it_behaves_like 'Rpush::Client::Apns::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::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')
+    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
+
+  describe "multi_json usage" do
+    describe "alert" do
+      subject(:notification) { described_class.new(alert: { a: 1 }, alert_is_json: true) }
+
+      it "should call MultiJson.load when multi_json version is 1.3.0" do
+        allow(Gem).to receive(:loaded_specs).and_return('multi_json' => Gem::Specification.new('multi_json', '1.3.0'))
+        expect(MultiJson).to receive(:load).with(any_args)
+        notification.alert
+      end
+
+      it "should call MultiJson.decode when multi_json version is 1.2.9" do
+        allow(Gem).to receive(:loaded_specs).and_return('multi_json' => Gem::Specification.new('multi_json', '1.2.9'))
+        expect(MultiJson).to receive(:decode).with(any_args)
+        notification.alert
+      end
+    end
+  end
+
+  it "should default the sound to nil" do
+    expect(notification.sound).to be_nil
+  end
+
+  it '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
+
+  it '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
+
+  it 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
+    allow(notification).to receive_messages(has_attribute?: false)
+    notification.alert = "{\"one\":2}"
+    expect(notification.alert).to eq('one' => 2)
+  end
+end if active_record?

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

@@ -0,0 +1,28 @@
+require "unit_spec_helper"
+
+describe Rpush::Client::ActiveRecord::Apnsp8::Notification do
+  subject(:notification) { described_class.new }
+
+  it_behaves_like 'Rpush::Client::Apns::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::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 active_record?

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

@@ -1,30 +1,5 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::App do
-  it 'validates the uniqueness of name within type and environment' do
-    Rpush::Client::ActiveRecord::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT)
-    app = Rpush::Client::ActiveRecord::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::Client::ActiveRecord::Apns::App.new(name: 'test', environment: 'development', certificate: TEST_CERT)
-    expect(app.valid?).to eq(true)
-
-    app = Rpush::Client::ActiveRecord::Gcm::App.new(name: 'test', environment: 'production', auth_key: TEST_CERT)
-    expect(app.valid?).to eq(true)
-  end
-
-  context 'validating certificates' do
-    it 'rescues from certificate error' do
-      app = Rpush::Client::ActiveRecord::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::Client::ActiveRecord::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
+  it_behaves_like 'Rpush::Client::App'
 end if active_record?

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

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

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

@@ -1,96 +1,14 @@
 require 'unit_spec_helper'
-require 'unit/notification_shared.rb'
 
 describe Rpush::Client::ActiveRecord::Gcm::Notification do
-  it_should_behave_like 'an Notification subclass'
+  it_behaves_like 'Rpush::Client::Gcm::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
 
-  let(:app) { Rpush::Client::ActiveRecord::Gcm::App.create!(name: 'test', auth_key: 'abc') }
-  let(:notification_class) { Rpush::Client::ActiveRecord::Gcm::Notification }
-  let(:notification) { notification_class.new }
+  subject(:notification) { described_class.new }
+  let(:app) { Rpush::Gcm::App.create!(name: 'test', auth_key: 'abc') }
 
-  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
+  it 'accepts non-booleans as a truthy value' do
+    notification.dry_run = 'Not a boolean'
     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
-
-  # In Rails 4.2 this value casts to `false` and thus will not be included in
-  # the payload. This changed to match Ruby's semantics, and will casts to
-  # `true` in Rails 5 and above.
-  if ActiveRecord.version <= Gem::Version.new('5')
-    it 'accepts non-booleans as a falsey value' do
-      notification.dry_run = 'Not a boolean'
-      expect(notification.as_json).not_to have_key 'dry_run'
-    end
-  else
-    it 'accepts non-booleans as a truthy value' do
-      notification.dry_run = 'Not a boolean'
-      expect(notification.as_json['dry_run']).to eq true
-    end
-  end
 end if active_record?

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

@@ -1,20 +1,12 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Notification do
-  let(:notification) { Rpush::Client::ActiveRecord::Notification.new }
+  it_behaves_like 'Rpush::Client::Notification'
 
-  it 'allows assignment of many registration IDs' do
-    notification.registration_ids = %w(a b)
-    expect(notification.registration_ids).to eq %w(a b)
-  end
-
-  it 'allows assignment of a single registration ID' do
-    notification.registration_ids = 'a'
-    expect(notification.registration_ids).to eq ['a']
-  end
+  subject(:notification) { described_class.new }
 
   it 'saves its parent App if required' do
-    notification.app = Rpush::Client::ActiveRecord::App.new(name: "aname")
+    notification.app = Rpush::App.new(name: "aname")
     expect(notification.app).to be_valid
     expect(notification).to be_valid
   end

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

@@ -1,17 +1,6 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::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
+  it_behaves_like 'Rpush::Client::Pushy::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
 end if active_record?

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?