rpush 4.1.0 → 5.2.0

data/spec/functional/apns2_spec.rb

@@ -177,6 +177,13 @@ describe 'APNs http2 adapter' do
     end
 
     context 'when there is SocketError' do
+      let(:fake_http_resp_headers) {
+        {
+          ":status" => "500",
+          "apns-id"=>"C6D65840-5E3F-785A-4D91-B97D305C12F6"
+        }
+      }
+
       before(:each) do
         expect(fake_client).to receive(:call_async) { raise(SocketError) }
       end
@@ -201,6 +208,24 @@ describe 'APNs http2 adapter' do
         notification = create_notification
         Rpush.push
       end
+
+      context 'when specific notification was delivered before request failed' do
+        let(:fake_http_resp_headers) {
+          {
+            ":status" => "200",
+            "apns-id"=>"C6D65840-5E3F-785A-4D91-B97D305C12F6"
+          }
+        }
+
+        it 'fails but will not retry this notification' do
+          notification = create_notification
+          expect do
+            Rpush.push
+            notification.reload
+          end.to change(notification, :retries).by(0)
+             .and change(notification, :delivered).to(true)
+        end
+      end
     end
 
     context 'when any StandardError occurs' do
@@ -228,5 +253,65 @@ describe 'APNs http2 adapter' do
         Rpush.push
       end
     end
+
+    context 'when waiting for requests to complete times out' do
+      let(:on_close) do
+        proc { |&block| @thread = Thread.new { sleep(0.01) } }
+      end
+
+      before(:each) do
+        @thread = nil
+
+        expect(fake_http2_request).
+          to receive(:on).with(:close), &on_close
+
+        expect(fake_client).to receive(:join) { @thread.join; raise(NetHttp2::AsyncRequestTimeout) }
+      end
+
+      it 'closes the client' do
+        create_notification
+        expect(fake_client).to receive(:close)
+        Rpush.push
+      end
+
+      it 'reflects :error' do
+        reflected_error = false
+        Rpush.reflect do |on|
+          on.error do |error|
+            reflected_error = true
+            expect(error).to be_kind_of(StandardError)
+            reflector.accept
+          end
+        end
+
+        notification = create_notification
+        Rpush.push
+
+        expect(reflected_error).to be true
+      end
+
+      it 'fails but retries delivery several times' do
+        notification = create_notification
+        expect do
+          Rpush.push
+          notification.reload
+        end.to change(notification, :retries)
+      end
+
+      context 'when specific notification was delivered before another async call failed' do
+        let(:on_close) do
+          proc { |&block| @thread = Thread.new { sleep(0.01); block.call } }
+        end
+
+        it 'fails but retries delivery several times' do
+          notification = create_notification
+          expect do
+            Rpush.push
+            notification.reload
+          end.to change(notification, :retries).by(0)
+             .and change(notification, :delivered).to(true)
+        end
+      end
+    end
   end
 end

data/spec/functional/gcm_priority_spec.rb

@@ -0,0 +1,40 @@
+require 'functional_spec_helper'
+
+describe 'GCM priority' do
+  let(:app) { Rpush::Gcm::App.new }
+  let(:notification) { Rpush::Gcm::Notification.new }
+  let(:hydrated_notification) { Rpush::Gcm::Notification.find(notification.id) }
+  let(:response) { double(Net::HTTPResponse, code: 200) }
+  let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
+  let(:priority) { 'normal' }
+
+  before do
+    app.name = 'test'
+    app.auth_key = 'abc123'
+    app.save!
+
+    notification.app_id = app.id
+    notification.registration_ids = ['foo']
+    notification.data = { message: 'test' }
+    notification.priority = priority
+    notification.save!
+
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
+  end
+
+  it 'supports normal priority' do
+    expect(hydrated_notification.as_json['priority']).to eq('normal')
+  end
+
+  context 'high priority' do
+    let(:priority) { 'high' }
+
+    it 'supports high priority' do
+      expect(hydrated_notification.as_json['priority']).to eq('high')
+    end
+  end
+
+  it 'does not add an error when receiving expected priority' do
+    expect(hydrated_notification.errors.messages[:priority]).to be_empty
+  end
+end

data/spec/support/active_record_setup.rb

@@ -40,6 +40,8 @@ require 'generators/templates/rpush_3_2_4_updates'
 require 'generators/templates/rpush_3_3_0_updates'
 require 'generators/templates/rpush_3_3_1_updates'
 require 'generators/templates/rpush_4_1_0_updates'
+require 'generators/templates/rpush_4_1_1_updates'
+require 'generators/templates/rpush_4_2_0_updates'
 
 migrations = [
   AddRpush,
@@ -55,7 +57,9 @@ migrations = [
   Rpush324Updates,
   Rpush330Updates,
   Rpush331Updates,
-  Rpush410Updates
+  Rpush410Updates,
+  Rpush411Updates,
+  Rpush420Updates
 ]
 
 unless ENV['TRAVIS']

data/spec/support/simplecov_helper.rb

@@ -18,7 +18,7 @@ module SimpleCovHelper
         end
       end
 
-      formatter SimpleCov::Formatter::MultiFormatter[*formatters]
+      formatter SimpleCov::Formatter::MultiFormatter.new(formatters)
     end
   end
 end

data/spec/unit/apns_feedback_spec.rb

@@ -1,13 +1,15 @@
 require 'unit_spec_helper'
 
 describe Rpush, 'apns_feedback' do
-  let!(:apns_app) do
-    Rpush::Apns::App.create!(name: 'test', environment: 'production', certificate: TEST_CERT)
-  end
-
-  let!(:gcm_app) do
-    Rpush::Gcm::App.create!(name: 'MyApp', auth_key: 'abc123')
+  let!(:apns_app) { Rpush::Apns::App.create!(apns_app_params) }
+  let(:apns_app_params) do
+    {
+      name: 'test',
+      environment: 'production',
+      certificate: TEST_CERT
+    }
   end
+  let!(:gcm_app) { Rpush::Gcm::App.create!(name: 'MyApp', auth_key: 'abc123') }
 
   let(:receiver) { double(check_for_feedback: nil) }
 
@@ -25,4 +27,13 @@ describe Rpush, 'apns_feedback' do
     expect(receiver).to receive(:check_for_feedback)
     Rpush.apns_feedback
   end
+
+  context 'feedback disabled' do
+    let(:apns_app_params) { super().merge(feedback_enabled: false) }
+
+    it 'does not initialize feedback receiver' do
+      expect(Rpush::Daemon::Apns::FeedbackReceiver).not_to receive(:new)
+      Rpush.apns_feedback
+    end
+  end
 end

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

@@ -1,58 +1,6 @@
 require 'unit_spec_helper'
 
 describe Rpush::Client::ActiveRecord::Adm::App do
-  subject { Rpush::Client::ActiveRecord::Adm::App.new(name: 'test', environment: 'development', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
-  let(:existing_app) { Rpush::Client::ActiveRecord::Adm::App.create!(name: 'existing', 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 name is not unique within scope' do
-    subject.name = existing_app.name
-    expect(subject).not_to be_valid
-    expect(subject.errors[:name]).to eq ["has already been taken"]
-  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
+  it_behaves_like 'Rpush::Client::Adm::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
 end if active_record?

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

@@ -1,43 +1,6 @@
 require 'unit_spec_helper'
-require 'unit/notification_shared.rb'
 
 describe Rpush::Client::ActiveRecord::Adm::Notification do
-  it_should_behave_like 'an Notification subclass'
-
-  let(:app) { Rpush::Client::ActiveRecord::Adm::App.create!(name: 'test', client_id: 'CLIENT_ID', client_secret: 'CLIENT_SECRET') }
-  let(:notification_class) { Rpush::Client::ActiveRecord::Adm::Notification }
-  let(:notification) { notification_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
+  it_behaves_like 'Rpush::Client::Adm::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
 end if active_record?

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

@@ -1,29 +1,6 @@
 require 'unit_spec_helper'
 
-describe Rpush::Client::ActiveRecord::App do
-  it 'does not validate an app with an invalid certificate' do
-    app = Rpush::Client::ActiveRecord::Apns::App.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 = Rpush::Client::ActiveRecord::Apns::App.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 = Rpush::Client::ActiveRecord::Apns::App.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 = Rpush::Client::ActiveRecord::Apns::App.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
+describe Rpush::Client::ActiveRecord::Apns::App do
+  it_behaves_like 'Rpush::Client::Apns::App'
+  it_behaves_like 'Rpush::Client::ActiveRecord::App'
 end if active_record?

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

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

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

@@ -1,324 +1,65 @@
-# encoding: US-ASCII
-
 require "unit_spec_helper"
-require 'unit/notification_shared.rb'
 
 describe Rpush::Client::ActiveRecord::Apns::Notification do
-  it_should_behave_like 'an Notification subclass'
-
-  let(:app) { Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT) }
-  let(:notification_class) { Rpush::Client::ActiveRecord::Apns::Notification }
-  let(:notification) { notification_class.new }
+  subject(:notification) { described_class.new }
 
-  it "should validate the format of the device_token" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "{$%^&*()}")
-    expect(notification.valid?).to be_falsey
-    expect(notification.errors[:device_token].include?("is invalid")).to be_truthy
-  end
+  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 = "way too long!" * 200
-    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
+    notification.alert = ""
 
-  it "should store long alerts" do
-    notification.app = app
-    notification.device_token = "a" * 108
-    notification.alert = "*" * 300
+    notification.alert << "a" until notification.payload.bytesize == 2048
     expect(notification.valid?).to be_truthy
+    expect(notification.errors[:base]).to be_empty
 
-    notification.save!
-    notification.reload
-    expect(notification.alert).to eq("*" * 300)
-  end
-
-  it "should default the sound to nil" do
-    expect(notification.sound).to be_nil
-  end
-
-  it "should default the expiry to 1 day" do
-    expect(notification.expiry).to eq 1.day.to_i
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, "when assigning the device token" do
-  it "should strip spaces from the given string" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "o m g")
-    expect(notification.device_token).to eq "omg"
-  end
-
-  it "should strip chevrons from the given string" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "<omg>")
-    expect(notification.device_token).to eq "omg"
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, "as_json" do
-  it "should include the alert if present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: "hi mom")
-    expect(notification.as_json["aps"]["alert"]).to eq "hi mom"
-  end
-
-  it "should not include the alert key if the alert is not present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: nil)
-    expect(notification.as_json["aps"].key?("alert")).to be_falsey
-  end
-
-  it "should encode the alert as JSON if it is a Hash" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: { 'body' => "hi mom", 'alert-loc-key' => "View" })
-    expect(notification.as_json["aps"]["alert"]).to eq('body' => "hi mom", 'alert-loc-key' => "View")
-  end
-
-  it "should include the badge if present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(badge: 6)
-    expect(notification.as_json["aps"]["badge"]).to eq 6
-  end
-
-  it "should not include the badge key if the badge is not present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(badge: nil)
-    expect(notification.as_json["aps"].key?("badge")).to be_falsey
-  end
-
-  it "should include the sound if present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: "my_sound.aiff")
-    expect(notification.as_json["aps"]["alert"]).to eq "my_sound.aiff"
-  end
-
-  it "should not include the sound key if the sound is not present" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new(sound: nil)
-    expect(notification.as_json["aps"].key?("sound")).to be_falsey
-  end
-
-  it "should include attributes for the device" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
-    notification.data = { omg: :lol, wtf: :dunno }
-    expect(notification.as_json["omg"]).to eq "lol"
-    expect(notification.as_json["wtf"]).to eq "dunno"
-  end
-
-  it "should allow attributes to include a hash" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
-    notification.data = { omg: { ilike: :hashes } }
-    expect(notification.as_json["omg"]["ilike"]).to eq "hashes"
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'MDM' do
-  let(:magic) { 'abc123' }
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  before do
-    notification.device_token = "a" * 108
-    notification.id = 1234
-  end
-
-  it 'includes the mdm magic in the payload' do
-    notification.mdm = magic
-    expect(notification.as_json).to eq('mdm' => magic)
-  end
-
-  it 'does not include aps attribute' do
-    notification.alert = "i'm doomed"
-    notification.mdm = magic
-    expect(notification.as_json.key?('aps')).to be_falsey
-  end
-
-  it 'can be converted to binary' do
-    notification.mdm = magic
-    expect(notification.to_binary).to be_present
+    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
-end if active_record?
 
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'mutable-content' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
+  describe "multi_json usage" do
+    describe "alert" do
+      subject(:notification) { described_class.new(alert: { a: 1 }, alert_is_json: true) }
 
-  it 'includes mutable-content in the payload' do
-    notification.mutable_content = true
-    expect(notification.as_json['aps']['mutable-content']).to eq 1
-  end
+      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 'does not include content-available in the payload if not set' do
-    expect(notification.as_json['aps'].key?('mutable-content')).to be_falsey
-  end
-
-  it 'does not include mutable-content as a non-aps attribute' do
-    notification.mutable_content = true
-    expect(notification.as_json.key?('mutable-content')).to be_falsey
+      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 'does not overwrite existing attributes for the device' do
-    notification.data = { hi: :mom }
-    notification.mutable_content = true
-    expect(notification.as_json['aps']['mutable-content']).to eq 1
-    expect(notification.as_json['hi']).to eq 'mom'
+  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 }
+    notification.data = { 'hi' => 'mom' }
     expect(notification.as_json['aps']['mutable-content']).to eq 1
     expect(notification.as_json['hi']).to eq 'mom'
   end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'content-available' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  it 'includes content-available in the payload' do
-    notification.content_available = true
-    expect(notification.as_json['aps']['content-available']).to eq 1
-  end
-
-  it 'does not include content-available in the payload if not set' do
-    expect(notification.as_json['aps'].key?('content-available')).to be_falsey
-  end
-
-  it 'does not include content-available as a non-aps attribute' do
-    notification.content_available = true
-    expect(notification.as_json.key?('content-available')).to be_falsey
-  end
-
-  it 'does not overwrite existing attributes for the device' do
-    notification.data = { hi: :mom }
-    notification.content_available = true
-    expect(notification.as_json['aps']['content-available']).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 }
+    notification.data = { 'hi' => 'mom' }
     expect(notification.as_json['aps']['content-available']).to eq 1
     expect(notification.as_json['hi']).to eq 'mom'
   end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'url-args' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  it 'includes url-args in the payload' do
-    notification.url_args = ['url-arg-1']
-    expect(notification.as_json['aps']['url-args']).to eq ['url-arg-1']
-  end
-
-  it 'does not include url-args in the payload if not set' do
-    expect(notification.as_json['aps'].key?('url-args')).to be_falsey
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'category' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  it 'includes category in the payload' do
-    notification.category = 'INVITE_CATEGORY'
-    expect(notification.as_json['aps']['category']).to eq 'INVITE_CATEGORY'
-  end
-
-  it 'does not include category in the payload if not set' do
-    expect(notification.as_json['aps'].key?('category')).to be_falsey
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  before do
-    notification.device_token = "a" * 108
-    notification.id = 1234
-  end
-
-  it 'uses APNS_PRIORITY_CONSERVE_POWER if content-available is the only key' do
-    notification.alert = nil
-    notification.badge = nil
-    notification.sound = nil
-    notification.content_available = true
-    bytes = notification.to_binary.bytes.to_a[-4..-1]
-    expect(bytes.first).to eq 5 # priority item ID
-    expect(bytes.last).to eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_CONSERVE_POWER
-  end
-
-  it 'uses APNS_PRIORITY_IMMEDIATE if content-available is not the only key' do
-    notification.alert = "New stuff!"
-    notification.badge = nil
-    notification.sound = nil
-    notification.content_available = true
-    bytes = notification.to_binary.bytes.to_a[-4..-1]
-    expect(bytes.first).to eq 5 # priority item ID
-    expect(bytes.last).to eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
-  end
-
-  it "should correctly convert the notification to binary" do
-    notification.sound = "1.aiff"
-    notification.badge = 3
-    notification.alert = "Don't panic Mr Mainwaring, don't panic!"
-    notification.data = { hi: :mom }
-    notification.expiry = 86_400 # 1 day
-    notification.priority = Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
-    notification.app = Rpush::Client::ActiveRecord::Apns::App.new(name: 'my_app', environment: 'development', certificate: TEST_CERT)
-    now = Time.now
-    allow(Time).to receive_messages(now: now)
-    expect(notification.to_binary).to eq "\x02\x00\x00\x00\xAF\x01\x00 \xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\x02\x00a{\"aps\":{\"alert\":\"Don't panic Mr Mainwaring, don't panic!\",\"badge\":3,\"sound\":\"1.aiff\"},\"hi\":\"mom\"}\x03\x00\x04\x00\x00\x04\xD2\x04\x00\x04#{[now.to_i + 86_400].pack('N')}\x05\x00\x01\n"
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, "bug #31" do
-  it 'does not confuse a JSON looking string as JSON' do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
-    notification.alert = "{\"one\":2}"
-    expect(notification.alert).to eq "{\"one\":2}"
-  end
 
   it 'does confuse a JSON looking string as JSON if the alert_is_json attribute is not present' do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new
     allow(notification).to receive_messages(has_attribute?: false)
     notification.alert = "{\"one\":2}"
     expect(notification.alert).to eq('one' => 2)
   end
 end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, "bug #35" do
-  it "should limit payload size to 256 bytes but not the entire packet" do
-    notification = Rpush::Client::ActiveRecord::Apns::Notification.new do |n|
-      n.device_token = "a" * 108
-      n.alert = "a" * 210
-      n.app = Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT)
-    end
-
-    expect(notification.to_binary(for_validation: true).bytesize).to be > 256
-    expect(notification.payload.bytesize).to be < 256
-    expect(notification).to be_valid
-  end
-end if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, "multi_json usage" do
-  describe Rpush::Client::ActiveRecord::Apns::Notification, "alert" do
-    it "should call MultiJson.load when multi_json version is 1.3.0" do
-      notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: { a: 1 }, alert_is_json: true)
-      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
-      notification = Rpush::Client::ActiveRecord::Apns::Notification.new(alert: { a: 1 }, alert_is_json: true)
-      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 if active_record?
-
-describe Rpush::Client::ActiveRecord::Apns::Notification, 'thread-id' do
-  let(:notification) { Rpush::Client::ActiveRecord::Apns::Notification.new }
-
-  it 'includes thread-id in the payload' do
-    notification.thread_id = 'THREAD-ID'
-    expect(notification.as_json['aps']['thread-id']).to eq 'THREAD-ID'
-  end
-
-  it 'does not include thread-id in the payload if not set' do
-    expect(notification.as_json['aps']).to_not have_key('thread-id')
-  end
-end if active_record?