rpush 2.3.1 → 2.3.2

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

@@ -4,26 +4,26 @@ 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)
-    app.valid?.should be_false
-    app.errors[:name].should eq ['has already been taken']
+    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)
-    app.valid?.should be_true
+    expect(app.valid?).to eq(true)
 
     app = Rpush::Client::ActiveRecord::Gcm::App.new(name: 'test', environment: 'production', auth_key: TEST_CERT)
-    app.valid?.should be_true
+    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 be_false
+      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')
-      OpenSSL::X509::Certificate.stub(:new).and_raise(NameError, 'simulating no openssl')
+      allow(OpenSSL::X509::Certificate).to receive(:new).and_raise(NameError, 'simulating no openssl')
       expect { app.valid? }.to raise_error(NameError)
     end
   end

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

@@ -10,25 +10,25 @@ describe Rpush::Client::ActiveRecord::Gcm::Notification do
 
   it "has a 'data' payload limit of 4096 bytes" do
     notification.data = { key: "a" * 4096 }
-    notification.valid?.should be_false
-    notification.errors[:base].should eq ["Notification payload data cannot be larger than 4096 bytes."]
+    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)
-    notification.valid?.should be_false
-    notification.errors[:base].should eq ["Number of registration_ids cannot be larger than 1000."]
+    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
-    notification.valid?.should be_false
-    notification.errors[:expiry].should eq ['must be set when using a collapse_key']
+    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
-    notification.as_json['time_to_live'].should eq 100
+    expect(notification.as_json['time_to_live']).to eq 100
   end
 end

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

@@ -5,12 +5,12 @@ describe Rpush::Client::ActiveRecord::Notification do
 
   it 'allows assignment of many registration IDs' do
     notification.registration_ids = %w(a b)
-    notification.registration_ids.should eq %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'
-    notification.registration_ids.should eq ['a']
+    expect(notification.registration_ids).to eq ['a']
   end
 
   it 'saves its parent App if required' do

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

@@ -10,18 +10,12 @@ describe Rpush::Client::ActiveRecord::Wpns::Notification do
   it "should have an url in the uri parameter" do
     notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(uri: "somthing")
     notification.valid?
-    notification.errors[:uri].include?("is invalid").should be_true
+    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?
-    notification.errors[:data].include?("can't be blank").should be_true
-  end
-
-  it "should be invalid if there's no alert" do
-    notification = Rpush::Client::ActiveRecord::Wpns::Notification.new(alert: nil)
-    notification.valid?
-    notification.errors[:data].include?("can't be blank").should be_true
+    expect(notification.errors[:data]).to include("can't be blank")
   end
 end

data/spec/unit/configuration_spec.rb

@@ -4,8 +4,8 @@ describe Rpush do
   let(:config) { Rpush.config }
 
   before do
-    Rpush.stub(require: nil)
-    Rpush.stub(config: config)
+    allow(Rpush).to receive_messages(require: nil)
+    allow(Rpush).to receive_messages(config: config)
   end
 
   it 'yields a configure block' do
@@ -30,17 +30,17 @@ describe Rpush::Configuration do
 
   it 'sets the pid_file relative if not absolute' do
     config.pid_file = 'tmp/rpush.pid'
-    config.pid_file.should eq '/tmp/rails_root/tmp/rpush.pid'
+    expect(config.pid_file).to eq '/tmp/rails_root/tmp/rpush.pid'
   end
 
   it 'does not alter an absolute pid_file path' do
     config.pid_file = '/tmp/rpush.pid'
-    config.pid_file.should eq '/tmp/rpush.pid'
+    expect(config.pid_file).to eq '/tmp/rpush.pid'
   end
 
   it 'delegate redis_options to Modis' do
     Rpush.config.client = :redis
     Rpush.config.redis_options = { hi: :mom }
-    Modis.redis_options.should eq(hi: :mom)
+    expect(Modis.redis_options).to eq(hi: :mom)
   end
 end

data/spec/unit/daemon/adm/delivery_spec.rb

@@ -19,72 +19,72 @@ describe Rpush::Daemon::Adm::Delivery do
     app.access_token = 'ACCESS_TOKEN'
     app.access_token_expiration = Time.now + 1.month
 
-    delivery.stub(reflect: nil)
-    Rpush::Daemon.stub(store: store)
-    Time.stub(now: now)
-    Rpush.stub(logger: logger)
+    allow(delivery).to receive_messages(reflect: nil)
+    allow(Rpush::Daemon).to receive_messages(store: store)
+    allow(Time).to receive_messages(now: now)
+    allow(Rpush).to receive_messages(logger: logger)
   end
 
   describe 'unknown error response' do
     before do
-      response.stub(code: 408)
+      allow(response).to receive_messages(code: 408)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
-      response.stub(body: JSON.dump('reason' => 'InvalidData'))
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidData'))
       error = Rpush::DeliveryError.new(408, notification.id, 'Request Timeout')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       expect { perform }.to raise_error(Rpush::DeliveryError)
     end
   end
 
   describe 'a 200 (Ok) response' do
     before do
-      response.stub(code: 200)
+      allow(response).to receive_messages(code: 200)
     end
 
     it 'marks the notification as delivered if delivered successfully to all devices' do
-      response.stub(body: JSON.dump('registrationID' => 'xyz'))
-      delivery.should_receive(:mark_delivered)
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'xyz'))
+      expect(delivery).to receive(:mark_delivered)
       perform
     end
 
     it 'logs that the notification was delivered' do
-      response.stub(body: JSON.dump('registrationID' => 'xyz'))
-      logger.should_receive(:info).with("[MyApp] #{notification.id} sent to xyz")
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'xyz'))
+      expect(logger).to receive(:info).with("[MyApp] #{notification.id} sent to xyz")
       perform
     end
 
     it 'reflects on canonical IDs' do
-      response.stub(body: JSON.dump('registrationID' => 'canonical123'))
-      notification.stub(registration_ids: ['1'])
-      delivery.should_receive(:reflect).with(:adm_canonical_id, '1', 'canonical123')
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'canonical123'))
+      allow(notification).to receive_messages(registration_ids: ['1'])
+      expect(delivery).to receive(:reflect).with(:adm_canonical_id, '1', 'canonical123')
       perform
     end
   end
 
   describe 'a 400 (Bad Request) response' do
     before do
-      response.stub(code: 400)
+      allow(response).to receive_messages(code: 400)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
-      response.stub(body: JSON.dump('reason' => 'InvalidData'))
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidData'))
       error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       expect { perform }.to raise_error(error)
     end
 
     it 'logs that the notification was not delivered' do
-      response.stub(body: JSON.dump('reason' => 'InvalidRegistrationId'))
-      logger.should_receive(:warn).with("[MyApp] bad_request: xyz (InvalidRegistrationId)")
+      allow(response).to receive_messages(body: JSON.dump('reason' => 'InvalidRegistrationId'))
+      expect(logger).to receive(:warn).with("[MyApp] bad_request: xyz (InvalidRegistrationId)")
       expect { perform }.to raise_error
     end
 
     it 'reflects' do
-      response.stub(body: JSON.dump('registrationID' => 'canonical123', 'reason' => 'Unregistered'))
-      notification.stub(registration_ids: ['1'])
-      delivery.should_receive(:reflect).with(:adm_failed_to_recipient, notification, '1', 'Unregistered')
+      allow(response).to receive_messages(body: JSON.dump('registrationID' => 'canonical123', 'reason' => 'Unregistered'))
+      allow(notification).to receive_messages(registration_ids: ['1'])
+      expect(delivery).to receive(:reflect).with(:adm_failed_to_recipient, notification, '1', 'Unregistered')
       expect { perform }.to raise_error
     end
   end
@@ -94,45 +94,45 @@ describe Rpush::Daemon::Adm::Delivery do
     let(:token_response) { double(code: 200, header: {}, body: JSON.dump('access_token' => 'ACCESS_TOKEN', 'expires_in' => 60)) }
 
     before do
-      response.stub(code: 401, header: { 'retry-after' => 10 })
+      allow(response).to receive_messages(code: 401, header: { 'retry-after' => 10 })
 
       # first request to deliver message that returns unauthorized response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
     end
 
     it 'should retrieve a new access token and mark the notification for retry' do
       # request for access token
-      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
 
-      store.should_receive(:update_app).with(notification.app)
-      delivery.should_receive(:mark_retryable).with(notification, now)
+      expect(store).to receive(:update_app).with(notification.app)
+      expect(delivery).to receive(:mark_retryable).with(notification, now)
 
       perform
     end
 
     it 'should update the app with the new access token' do
       # request for access token
-      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
 
-      store.should_receive(:update_app).with do |app|
-        app.access_token.should eq 'ACCESS_TOKEN'
-        app.access_token_expiration.should eq now + 60.seconds
+      expect(store).to receive(:update_app) do |app|
+        expect(app.access_token).to eq 'ACCESS_TOKEN'
+        expect(app.access_token_expiration).to eq now + 60.seconds
       end
-      delivery.should_receive(:mark_retryable).with(notification, now)
+      expect(delivery).to receive(:mark_retryable).with(notification, now)
 
       perform
     end
 
     it 'should log the error and stop retrying if new access token can\'t be retrieved' do
-      token_response.stub(code: 404, body: "test")
+      allow(token_response).to receive_messages(code: 404, body: "test")
       # request for access token
-      http.should_receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
+      expect(http).to receive(:request).with(Rpush::Daemon::Adm::Delivery::AMAZON_TOKEN_URI, instance_of(Net::HTTP::Post)).and_return(token_response)
 
-      store.should_not_receive(:update_app).with(notification.app)
-      delivery.should_not_receive(:mark_retryable)
+      expect(store).not_to receive(:update_app).with(notification.app)
+      expect(delivery).not_to receive(:mark_retryable)
 
-      logger.should_receive(:warn).with("[MyApp] Could not retrieve access token from ADM: test")
+      expect(logger).to receive(:warn).with("[MyApp] Could not retrieve access token from ADM: test")
 
       perform
     end
@@ -144,54 +144,54 @@ describe Rpush::Daemon::Adm::Delivery do
     let(:rate_limited_response) { double(code: 429, header: { 'retry-after' => 3600 }) }
 
     it 'should retry the entire notification respecting the Retry-After header if none sent out yet' do
-      response.stub(code: 429, header: { 'retry-after' => 3600 })
+      allow(response).to receive_messages(code: 429, header: { 'retry-after' => 3600 })
 
       # first request to deliver message that returns too many request response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
-      delivery.should_receive(:mark_retryable).with(notification, now + 1.hour)
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 1.hour)
       perform
     end
 
     it 'should retry the entire notification using exponential backoff' do
-      response.stub(code: 429, header: {})
+      allow(response).to receive_messages(code: 429, header: {})
 
       # first request to deliver message that returns too many request response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, notification.registration_ids.first))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
-      delivery.should_receive(:mark_retryable).with(notification, Time.now + 2**(notification.retries + 1))
+      expect(delivery).to receive(:mark_retryable).with(notification, Time.now + 2**(notification.retries + 1))
       perform
     end
 
     it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
-      response.stub(code: 200, body: JSON.dump('registrationID' => 'abc'))
+      allow(response).to receive_messages(code: 200, body: JSON.dump('registrationID' => 'abc'))
 
       # first request to deliver message succeeds
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
       # first request to deliver message that returns too many request response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(rate_limited_response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(rate_limited_response)
 
-      store.should_receive(:update_notification).with do |notif|
-        notif.registration_ids.include?('abc').should be_true
-        notif.registration_ids.include?('xyz').should be_false
+      expect(store).to receive(:update_notification) do |notif|
+        expect(notif.registration_ids).to include('abc')
+        expect(notif.registration_ids).to_not include('xyz')
       end
 
-      store.should_receive(:create_adm_notification).with do |attrs, _notification_data, reg_ids, deliver_after, notification_app|
-        attrs.key?('collapse_key').should be_true
-        attrs.key?('delay_while_idle').should be_true
-        attrs.key?('app_id').should be_true
+      expect(store).to receive(:create_adm_notification) do |attrs, _notification_data, reg_ids, deliver_after, notification_app|
+        expect(attrs.keys).to include('collapse_key')
+        expect(attrs.keys).to include('delay_while_idle')
+        expect(attrs.keys).to include('app_id')
 
-        reg_ids.should eq ['xyz']
-        deliver_after.should eq now + 1.hour
-        notification_app.should eq notification.app
+        expect(reg_ids).to eq ['xyz']
+        expect(deliver_after).to eq now + 1.hour
+        expect(notification_app).to eq notification.app
       end
 
-      delivery.should_receive(:mark_delivered)
+      expect(delivery).to receive(:mark_delivered)
 
       perform
     end
@@ -199,28 +199,28 @@ describe Rpush::Daemon::Adm::Delivery do
 
   describe 'a 500 (Internal Server Error) response' do
     before do
-      response.stub(code: 500)
+      allow(response).to receive_messages(code: 500)
     end
 
     it 'marks the notification as failed because no successful delivery was made' do
       error = Rpush::DeliveryError.new(nil, notification.id, 'Failed to deliver to all recipients.')
-      delivery.should_receive(:mark_failed).with(error)
+      expect(delivery).to receive(:mark_failed).with(error)
       expect { perform }.to raise_error(Rpush::DeliveryError)
     end
 
     it 'logs that the notification was not delivered' do
-      logger.should_receive(:warn).with("[MyApp] internal_server_error: xyz (Internal Server Error)")
+      expect(logger).to receive(:warn).with("[MyApp] internal_server_error: xyz (Internal Server Error)")
       expect { perform }.to raise_error(Rpush::DeliveryError)
     end
   end
 
   describe 'a 503 (Service Unavailable) response' do
     before do
-      response.stub(code: 503, header: { 'retry-after' => 10 })
+      allow(response).to receive_messages(code: 503, header: { 'retry-after' => 10 })
     end
 
     it 'should retry the notification respecting the Retry-After header' do
-      delivery.should_receive(:mark_retryable).with(notification, now + 10.seconds)
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
       perform
     end
   end
@@ -231,21 +231,21 @@ describe Rpush::Daemon::Adm::Delivery do
     let(:bad_request_response) { double(code: 400, body: JSON.dump('reason' => 'InvalidData')) }
 
     it 'should keep sent reg ids in original notification and create new notification with remaining reg ids for retry' do
-      response.stub(code: 200, body: JSON.dump('registrationID' => 'abc'))
+      allow(response).to receive_messages(code: 200, body: JSON.dump('registrationID' => 'abc'))
 
       # first request to deliver message succeeds
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'abc'))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(response)
 
       # first request to deliver message that returns too many request response
       adm_uri = URI.parse(format(Rpush::Daemon::Adm::Delivery::AMAZON_ADM_URL, 'xyz'))
-      http.should_receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(bad_request_response)
+      expect(http).to receive(:request).with(adm_uri, instance_of(Net::HTTP::Post)).and_return(bad_request_response)
 
-      store.should_receive(:update_notification).with do |notif|
-        notif.error_description.should eq "Failed to deliver to recipients: \nxyz: InvalidData"
+      expect(store).to receive(:update_notification) do |notif|
+        expect(notif.error_description).to eq "Failed to deliver to recipients: \nxyz: InvalidData"
       end
 
-      delivery.should_receive(:mark_delivered)
+      expect(delivery).to receive(:mark_delivered)
 
       perform
     end

data/spec/unit/daemon/apns/delivery_spec.rb

@@ -10,42 +10,42 @@ describe Rpush::Daemon::Apns::Delivery do
   let(:delivery) { Rpush::Daemon::Apns::Delivery.new(app, connection, batch) }
 
   before do
-    batch.stub(:each_notification) do |&blk|
+    allow(batch).to receive(:each_notification) do |&blk|
       [notification1, notification2].each(&blk)
     end
-    Rpush.stub(logger: logger)
+    allow(Rpush).to receive_messages(logger: logger)
   end
 
   it 'writes the binary batch' do
-    notification1.stub(to_binary: 'binary1')
-    notification2.stub(to_binary: 'binary2')
-    connection.should_receive(:write).with('binary1binary2')
+    allow(notification1).to receive_messages(to_binary: 'binary1')
+    allow(notification2).to receive_messages(to_binary: 'binary2')
+    expect(connection).to receive(:write).with('binary1binary2')
     delivery.perform
   end
 
   it 'logs the notification deliveries' do
-    notification1.stub(id: 666, device_token: 'abc123')
-    notification2.stub(id: 42, device_token: 'abc456')
-    logger.should_receive(:info).with('[MyApp] 666 sent to abc123')
-    logger.should_receive(:info).with('[MyApp] 42 sent to abc456')
+    allow(notification1).to receive_messages(id: 666, device_token: 'abc123')
+    allow(notification2).to receive_messages(id: 42, device_token: 'abc456')
+    expect(logger).to receive(:info).with('[MyApp] 666 sent to abc123')
+    expect(logger).to receive(:info).with('[MyApp] 42 sent to abc456')
     delivery.perform
   end
 
   it 'marks all notifications as delivered' do
-    delivery.should_receive(:mark_batch_delivered)
+    expect(delivery).to receive(:mark_batch_delivered)
     delivery.perform
   end
 
   it 'notifies the batch all notifications have been processed' do
-    batch.should_receive(:all_processed)
+    expect(batch).to receive(:all_processed)
     delivery.perform
   end
 
   describe 'when an error is raised' do
     it 'marks all notifications as failed' do
       error = StandardError.new
-      connection.stub(:write).and_raise(error)
-      delivery.should_receive(:mark_batch_failed).with(error)
+      allow(connection).to receive(:write).and_raise(error)
+      expect(delivery).to receive(:mark_batch_failed).with(error)
       expect { delivery.perform }.to raise_error(error)
     end
   end