rpush 2.3.1 → 2.3.2

data/spec/functional/new_app_spec.rb

@@ -30,30 +30,15 @@ describe 'New app loading' do
   end
 
   def stub_tcp_connection
-    Rpush::Daemon::TcpConnection.any_instance.stub(connect_socket: [tcp_socket, ssl_socket])
-    Rpush::Daemon::TcpConnection.any_instance.stub(setup_ssl_context: double.as_null_object)
+    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(connect_socket: [tcp_socket, ssl_socket])
+    allow_any_instance_of(Rpush::Daemon::TcpConnection).to receive_messages(setup_ssl_context: double.as_null_object)
     stub_const('Rpush::Daemon::TcpConnection::IO', io_double)
   end
 
-  def wait_for_notification_to_deliver(notification)
-    Timeout.timeout(timeout) do
-      until notification.delivered
-        sleep 0.1
-        notification.reload
-      end
-    end
-  end
-
-  before do
-    Rpush.config.push_poll = 0
-    Rpush.embed
-  end
-
   it 'delivers a notification successfully' do
-    sleep 1 # TODO: Need a better way to detect when the Feeder is running.
     notification = create_notification
-    wait_for_notification_to_deliver(notification)
+    Rpush.push
+    notification.reload
+    expect(notification.delivered).to eq(true)
   end
-
-  after { Timeout.timeout(timeout) { Rpush.shutdown } }
 end

data/spec/functional/retry_spec.rb

@@ -22,25 +22,21 @@ describe 'Retries' do
       redis.del(Rpush::Client::Redis::Notification.absolute_pending_namespace)
     end
 
-    Net::HTTP::Persistent.stub(new: http)
-    response.stub(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
+    allow(response).to receive_messages(body: JSON.dump(results: [{ message_id: notification.registration_ids.first.to_s }]))
   end
 
   it 'delivers a notification due to be retried' do
     Rpush::Daemon.store.mark_retryable(notification, Time.now - 1.minute)
-
-    expect do
-      Rpush.push
-      notification.reload
-    end.to change(notification, :delivered).to(true)
+    Rpush.push
+    notification.reload
+    expect(notification.delivered).to eq(true)
   end
 
   it 'does not deliver a notification not due to be retried' do
     Rpush::Daemon.store.mark_retryable(notification, Time.now + 1.minute)
-
-    expect do
-      Rpush.push
-      notification.reload
-    end.to_not change(notification, :delivered).to(true)
+    Rpush.push
+    notification.reload
+    expect(notification.delivered).to eq(false)
   end
 end

data/spec/functional/synchronization_spec.rb

@@ -44,7 +44,7 @@ describe 'Synchronization' do
   it 'stops a deleted app' do
     app.destroy
     Rpush.sync
-    Rpush::Daemon::AppRunner.app_running?(app).should be_false
+    expect(Rpush::Daemon::AppRunner.app_running?(app)).to eq(false)
   end
 
   it 'restarts an app when the certificate is changed' do

data/spec/functional/wpns_spec.rb

@@ -21,11 +21,11 @@ describe 'WPNs' do
     notification_with_alert.alert = "Hello world!"
     notification_with_alert.save!
 
-    Net::HTTP::Persistent.stub(new: http)
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
   end
 
   it 'delivers a notification with data successfully' do
-    response.stub(to_hash: { 'x-notificationstatus' => ['Received'] })
+    allow(response).to receive_messages(to_hash: { 'x-notificationstatus' => ['Received'] })
 
     expect do
       Rpush.push
@@ -34,16 +34,16 @@ describe 'WPNs' do
   end
 
   it 'fails to deliver a notification with data successfully' do
-    response.stub(code: 400)
+    allow(response).to receive_messages(code: 400)
 
     expect do
       Rpush.push
       notification_with_data.reload
-    end.to_not change(notification_with_data, :delivered).to(true)
+    end.to change(notification_with_data, :failed_at)
   end
 
   it 'delivers a notification with an alert successfully' do
-    response.stub(to_hash: { 'x-notificationstatus' => ['Received'] })
+    allow(response).to receive_messages(to_hash: { 'x-notificationstatus' => ['Received'] })
 
     expect do
       Rpush.push
@@ -52,12 +52,12 @@ describe 'WPNs' do
   end
 
   it 'fails to deliver a notification with an alert successfully' do
-    response.stub(code: 400)
+    allow(response).to receive_messages(code: 400)
 
     expect do
       Rpush.push
       notification_with_alert.reload
-    end.to_not change(notification_with_alert, :delivered).to(true)
+    end.to change(notification_with_alert, :failed_at)
   end
 
   it 'retries notification that fail due to a SocketError' do

data/spec/functional_spec_helper.rb

@@ -3,9 +3,8 @@ require 'spec_helper'
 require 'database_cleaner'
 DatabaseCleaner.strategy = :truncation
 
-def functional_example?(example)
-  path = example.metadata[:example_group][:file_path]
-  path =~ /spec\/functional/
+def functional_example?(metadata)
+  metadata[:file_path] =~ /spec\/functional/
 end
 
 RSpec.configure do |config|
@@ -14,10 +13,10 @@ RSpec.configure do |config|
       redis.keys('rpush:*').each { |key| redis.del(key) }
     end
 
-    Rpush.config.logger = ::Logger.new(STDOUT) if functional_example?(example)
+    Rpush.config.logger = ::Logger.new(STDOUT) if functional_example?(self.class.metadata)
   end
 
   config.after(:each) do
-    DatabaseCleaner.clean if functional_example?(example)
+    DatabaseCleaner.clean if functional_example?(self.class.metadata)
   end
 end

data/spec/spec_helper.rb

@@ -53,7 +53,7 @@ end
 RSpec.configure do |config|
   config.before(:each) do
     Rpush.config.log_file = File.join(RPUSH_ROOT, 'rpush.log')
-    Rpush.stub(root: RPUSH_ROOT)
+    allow(Rpush).to receive(:root) { RPUSH_ROOT }
   end
 
   config.after(:each) do

data/spec/unit/apns_feedback_spec.rb

@@ -5,17 +5,17 @@ describe Rpush, 'apns_feedback' do
   let(:receiver) { double(check_for_feedback: nil) }
 
   before do
-    Rpush::Daemon::Apns::FeedbackReceiver.stub(new: receiver)
+    allow(Rpush::Daemon::Apns::FeedbackReceiver).to receive(:new) { receiver }
   end
 
   it 'initializes the daemon' do
-    Rpush::Daemon.should_receive(:common_init)
+    expect(Rpush::Daemon).to receive(:common_init)
     Rpush.apns_feedback
   end
 
   it 'checks feedback for each app' do
-    Rpush::Daemon::Apns::FeedbackReceiver.should_receive(:new).with(app).and_return(receiver)
-    receiver.should_receive(:check_for_feedback)
+    expect(Rpush::Daemon::Apns::FeedbackReceiver).to receive(:new).with(app).and_return(receiver)
+    expect(receiver).to receive(:check_for_feedback)
     Rpush.apns_feedback
   end
 end

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

@@ -5,31 +5,31 @@ describe Rpush::Client::ActiveRecord::Adm::App do
   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
-    subject.should be_valid
+    expect(subject).to be_valid
   end
 
   it 'should be invalid if name' do
     subject.name = nil
-    subject.should_not be_valid
-    subject.errors[:name].should eq ["can't be blank"]
+    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
-    subject.should_not be_valid
-    subject.errors[:name].should eq ["has already been taken"]
+    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
-    subject.should_not be_valid
-    subject.errors[:client_id].should eq ["can't be blank"]
+    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
-    subject.should_not be_valid
-    subject.errors[:client_secret].should eq ["can't be blank"]
+    expect(subject).not_to be_valid
+    expect(subject.errors[:client_secret]).to eq ["can't be blank"]
   end
 
   describe '#access_token_expired?' do
@@ -42,17 +42,17 @@ describe Rpush::Client::ActiveRecord::Adm::App do
     end
 
     it 'should return true if access_token_expiration is nil' do
-      subject.access_token_expired?.should be_true
+      expect(subject.access_token_expired?).to eq(true)
     end
 
     it 'should return true if expired' do
       subject.access_token_expiration = Time.now - 5.minutes
-      subject.access_token_expired?.should be_true
+      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
-      subject.access_token_expired?.should be_false
+      expect(subject.access_token_expired?).to eq(false)
     end
   end
 end

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

@@ -10,14 +10,14 @@ describe Rpush::Client::ActiveRecord::Adm::Notification do
 
   it "has a 'data' payload limit of 6144 bytes" do
     notification.data = { key: "a" * 6144 }
-    notification.valid?.should be_false
-    notification.errors[:base].should eq ["Notification payload data cannot be larger than 6144 bytes."]
+    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)
-    notification.valid?.should be_false
-    notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 100."]
+    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
@@ -25,19 +25,19 @@ describe Rpush::Client::ActiveRecord::Adm::Notification do
     notification.registration_ids = 'a'
     notification.collapse_key = 'test'
     notification.data = nil
-    notification.valid?.should be_true
-    notification.errors[:data].should be_empty
+    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
-    notification.valid?.should be_false
-    notification.errors[:data].should eq ['must be set unless collapse_key is specified']
+    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
-    notification.as_json['expiresAfter'].should eq 100
+    expect(notification.as_json['expiresAfter']).to eq 100
   end
 end

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

@@ -4,26 +4,26 @@ 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?
-    app.errors[:certificate].should eq ['value must contain a certificate and a private key.']
+    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?
-    app.errors[:certificate].should eq []
+    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?
-    app.errors[:certificate].should eq []
+    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?
-    app.errors[:certificate].should eq ['value must contain a certificate and a private key.']
+    expect(app.errors[:certificate]).to eq ['value must contain a certificate and a private key.']
   end
 end

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

@@ -3,7 +3,7 @@ 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: "{$%^&*()}")
-    notification.valid?.should be_false
-    notification.errors[:device_token].include?("is invalid").should be_true
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:device_token]).to include('is invalid')
   end
 end

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

@@ -12,85 +12,85 @@ describe Rpush::Client::ActiveRecord::Apns::Notification do
 
   it "should validate the format of the device_token" do
     notification = Rpush::Client::ActiveRecord::Apns::Notification.new(device_token: "{$%^&*()}")
-    notification.valid?.should be_false
-    notification.errors[:device_token].include?("is invalid").should be_true
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:device_token].include?("is invalid")).to be_truthy
   end
 
   it "should validate the length of the binary conversion of the notification" do
     notification.device_token = "a" * 64
     notification.alert = "way too long!" * 200
-    notification.valid?.should be_false
-    notification.errors[:base].include?("APN notification cannot be larger than 2048 bytes. Try condensing your alert and device attributes.").should be_true
+    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.sound.should eq('default')
+    expect(notification.sound).to eq('default')
   end
 
   it "should default the expiry to 1 day" do
-    notification.expiry.should eq 1.day.to_i
+    expect(notification.expiry).to eq 1.day.to_i
   end
 end
 
 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")
-    notification.device_token.should eq "omg"
+    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>")
-    notification.device_token.should eq "omg"
+    expect(notification.device_token).to eq "omg"
   end
 end
 
 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")
-    notification.as_json["aps"]["alert"].should eq "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)
-    notification.as_json["aps"].key?("alert").should be_false
+    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" })
-    notification.as_json["aps"]["alert"].should eq('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)
-    notification.as_json["aps"]["badge"].should eq 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)
-    notification.as_json["aps"].key?("badge").should be_false
+    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")
-    notification.as_json["aps"]["alert"].should eq "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)
-    notification.as_json["aps"].key?("sound").should be_false
+    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 }
-    notification.as_json["omg"].should eq "lol"
-    notification.as_json["wtf"].should eq "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 } }
-    notification.as_json["omg"]["ilike"].should eq "hashes"
+    expect(notification.as_json["omg"]["ilike"]).to eq "hashes"
   end
 end
 
@@ -100,13 +100,13 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'MDM' do
 
   it 'includes the mdm magic in the payload' do
     notification.mdm = magic
-    notification.as_json.should eq('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
-    notification.as_json.key?('aps').should be_false
+    expect(notification.as_json.key?('aps')).to be_falsey
   end
 end
 
@@ -115,30 +115,30 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'content-available' do
 
   it 'includes content-available in the payload' do
     notification.content_available = true
-    notification.as_json['aps']['content-available'].should eq 1
+    expect(notification.as_json['aps']['content-available']).to eq 1
   end
 
   it 'does not include content-available in the payload if not set' do
-    notification.as_json['aps'].key?('content-available').should be_false
+    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
-    notification.as_json.key?('content-available').should be_false
+    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
-    notification.as_json['aps']['content-available'].should eq 1
-    notification.as_json['hi'].should eq 'mom'
+    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.as_json['aps']['content-available'].should eq 1
-    notification.as_json['hi'].should eq 'mom'
+    expect(notification.as_json['aps']['content-available']).to eq 1
+    expect(notification.as_json['hi']).to eq 'mom'
   end
 end
 
@@ -147,11 +147,11 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'url-args' do
 
   it 'includes url-args in the payload' do
     notification.url_args = ['url-arg-1']
-    notification.as_json['aps']['url-args'].should eq ['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
-    notification.as_json['aps'].key?('url-args').should be_false
+    expect(notification.as_json['aps'].key?('url-args')).to be_falsey
   end
 end
 
@@ -160,11 +160,11 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'category' do
 
   it 'includes category in the payload' do
     notification.category = 'INVITE_CATEGORY'
-    notification.as_json['aps']['category'].should eq '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
-    notification.as_json['aps'].key?('category').should be_false
+    expect(notification.as_json['aps'].key?('category')).to be_falsey
   end
 end
 
@@ -182,8 +182,8 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
     notification.sound = nil
     notification.content_available = true
     bytes = notification.to_binary.bytes.to_a[-4..-1]
-    bytes.first.should eq 5 # priority item ID
-    bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_CONSERVE_POWER
+    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
@@ -192,8 +192,8 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
     notification.sound = nil
     notification.content_available = true
     bytes = notification.to_binary.bytes.to_a[-4..-1]
-    bytes.first.should eq 5 # priority item ID
-    bytes.last.should eq Rpush::Client::ActiveRecord::Apns::Notification::APNS_PRIORITY_IMMEDIATE
+    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
@@ -204,7 +204,7 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, 'to_binary' do
     notification.expiry = 86_400 # 1 day, \x00\x01Q\x80
     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)
-    notification.to_binary.should eq "\x02\x00\x00\x00\x99\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\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\x00\x01Q\x80\x05\x00\x01\n"
+    expect(notification.to_binary).to eq "\x02\x00\x00\x00\x99\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\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\x00\x01Q\x80\x05\x00\x01\n"
   end
 end
 
@@ -212,14 +212,14 @@ 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}"
-    notification.alert.should eq "{\"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
-    notification.stub(:has_attribute? => false)
+    allow(notification).to receive_messages(:has_attribute? => false)
     notification.alert = "{\"one\":2}"
-    notification.alert.should eq('one' => 2)
+    expect(notification.alert).to eq('one' => 2)
   end
 end
 
@@ -231,9 +231,9 @@ describe Rpush::Client::ActiveRecord::Apns::Notification, "bug #35" do
       n.app = Rpush::Client::ActiveRecord::Apns::App.create!(name: 'my_app', environment: 'development', certificate: TEST_CERT)
     end
 
-    notification.to_binary(for_validation: true).bytesize.should be > 256
-    notification.payload.bytesize.should be < 256
-    notification.should be_valid
+    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
 
@@ -241,15 +241,15 @@ 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)
-      Gem.stub(:loaded_specs).and_return('multi_json' => Gem::Specification.new('multi_json', '1.3.0'))
-      MultiJson.should_receive(:load).with(any_args)
+      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)
-      Gem.stub(:loaded_specs).and_return('multi_json' => Gem::Specification.new('multi_json', '1.2.9'))
-      MultiJson.should_receive(:decode).with(any_args)
+      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