rpush 7.0.1 → 9.0.0

data/spec/functional/{gcm_priority_spec.rb → fcm_priority_spec.rb}

@@ -1,12 +1,13 @@
 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) }
+describe 'FCM priority' do
+  let(:app) { Rpush::Fcm::App.new }
+  let(:notification) { Rpush::Fcm::Notification.new }
+  let(:hydrated_notification) { Rpush::Fcm::Notification.find(notification.id) }
   let(:response) { double(Net::HTTPResponse, code: 200) }
   let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
   let(:priority) { 'normal' }
+  let(:fake_device_token) { 'a' * 108 }
 
   before do
     app.name = 'test'
@@ -14,8 +15,9 @@ describe 'GCM priority' do
     app.save!
 
     notification.app_id = app.id
-    notification.registration_ids = ['foo']
+    notification.device_token = fake_device_token
     notification.data = { message: 'test' }
+    notification.notification = { title: 'title' }
     notification.priority = priority
     notification.save!
 
@@ -23,14 +25,18 @@ describe 'GCM priority' do
   end
 
   it 'supports normal priority' do
-    expect(hydrated_notification.as_json['priority']).to eq('normal')
+    json = hydrated_notification.as_json
+    expect(json["message"]["android"]["notification"]["notification_priority"]).to eq('PRIORITY_DEFAULT')
+    expect(json["message"]["android"]["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')
+      json = hydrated_notification.as_json
+      expect(json["message"]["android"]["notification"]["notification_priority"]).to eq('PRIORITY_MAX')
+      expect(json["message"]["android"]["priority"]).to eq('high')
     end
   end
 

data/spec/functional/fcm_spec.rb

@@ -0,0 +1,77 @@
+require 'functional_spec_helper'
+
+describe 'FCM' do
+  let(:app) { Rpush::Fcm::App.new }
+  let(:notification) { Rpush::Fcm::Notification.new }
+  let(:response) { double(Net::HTTPResponse, code: 200) }
+  let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
+  let(:fake_device_token) { 'a' * 108 }
+  let(:creds) {double(Google::Auth::UserRefreshCredentials)}
+
+  before do
+    app.name = 'test'
+    app.auth_key = 'abc123'
+    app.save!
+
+    notification.app_id = app.id
+    notification.device_token = fake_device_token
+    notification.data = { message: 'test' }
+    notification.save!
+
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
+    allow(creds).to receive(:fetch_access_token).and_return({'access_token': 'face_access_token'})
+
+    allow(::Google::Auth::ServiceAccountCredentials).to receive(:fetch_access_token).and_return({access_token: 'bbbbbb'})
+    allow(::Google::Auth::ServiceAccountCredentials).to receive(:make_creds).and_return(creds)
+    allow_any_instance_of(::Rpush::Daemon::Fcm::Delivery).to receive(:necessary_data_exists?).and_return(true)
+  end
+
+  it 'delivers a notification successfully' do
+    example_success_body = {
+      "multicast_id": 108,
+      "success": 1,
+      "failure": 0,
+      "canonical_ids": 0,
+      "results": [
+        { "message_id": "1:08" }
+      ]
+    }.to_json
+    allow(response).to receive_messages(body: example_success_body)
+
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :delivered).to(true)
+  end
+
+  it 'fails to deliver a notification successfully' do
+    example_error_body = {
+      "error": {
+        "code": 400,
+        "message": "The registration token is not a valid FCM registration token",
+        "errors": [
+          {
+            "message": "The registration token is not a valid FCM registration token",
+            "domain": "global",
+            "reason": "badRequest"
+          }
+        ],
+        "status": "INVALID_ARGUMENT"
+      }
+    }.to_json
+
+    allow(response).to receive_messages(code: 400, body: example_error_body)
+    Rpush.push
+    notification.reload
+    expect(notification.delivered).to eq(false)
+  end
+
+  it 'retries notification that fail due to a SocketError' do
+    expect(http).to receive(:request).and_raise(SocketError.new)
+    expect(notification.deliver_after).to be_nil
+    expect do
+      Rpush.push
+      notification.reload
+    end.to change(notification, :deliver_after).to(kind_of(Time))
+  end
+end

data/spec/functional/retry_spec.rb

@@ -1,10 +1,12 @@
 require 'functional_spec_helper'
 
 describe 'Retries' do
-  let(:app) { Rpush::Gcm::App.new }
-  let(:notification) { Rpush::Gcm::Notification.new }
+  let(:app) { Rpush::Fcm::App.new }
+  let(:notification) { Rpush::Fcm::Notification.new }
   let(:response) { double(Net::HTTPResponse, code: 200) }
   let(:http) { double(Net::HTTP::Persistent, request: response, shutdown: nil) }
+  let(:fake_device_token) { 'a' * 108 }
+  let(:creds) {double(Google::Auth::UserRefreshCredentials)}
 
   before do
     Rpush::Daemon.common_init
@@ -14,7 +16,7 @@ describe 'Retries' do
     app.save!
 
     notification.app_id = app.id
-    notification.registration_ids = ['foo']
+    notification.device_token = 'foo'
     notification.data = { message: 'test' }
     notification.save!
 
@@ -23,7 +25,22 @@ describe 'Retries' do
     end
 
     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 }]))
+    allow(creds).to receive(:fetch_access_token).and_return({'access_token': 'face_access_token'})
+
+    allow(::Google::Auth::ServiceAccountCredentials).to receive(:fetch_access_token).and_return({access_token: 'bbbbbb'})
+    allow(::Google::Auth::ServiceAccountCredentials).to receive(:make_creds).and_return(creds)
+    allow_any_instance_of(::Rpush::Daemon::Fcm::Delivery).to receive(:necessary_data_exists?).and_return(true)
+
+    example_success_body = {
+      "multicast_id": 108,
+      "success": 1,
+      "failure": 0,
+      "canonical_ids": 0,
+      "results": [
+        { "message_id": "1:08" }
+      ]
+    }.to_json
+    allow(response).to receive_messages(body: example_success_body)
   end
 
   it 'delivers a notification due to be retried' do

data/spec/functional/synchronization_spec.rb

@@ -2,7 +2,7 @@ require 'functional_spec_helper'
 
 describe 'Synchronization' do
   let(:timeout) { 10 }
-  let(:app) { Rpush::Gcm::App.new }
+  let(:app) { Rpush::Fcm::App.new }
 
   def wait_for_num_dispatchers(num)
     Timeout.timeout(timeout) do

data/spec/functional_spec_helper.rb

@@ -11,17 +11,11 @@ def timeout(&blk)
   Timeout.timeout(10, &blk)
 end
 
-def stub_tcp_connection(tcp_socket, ssl_socket, io_double)
-  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
-
 RSpec.configure do |config|
   config.before(:each) do
     Modis.with_connection do |redis|
       redis.keys('rpush:*').each { |key| redis.del(key) }
-    end if redis?
+    end if redis? && functional_example?(self.class.metadata)
 
     Rpush.config.logger = ::Logger.new(STDOUT) if functional_example?(self.class.metadata)
   end

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ if !ENV['CI'] || (ENV['CI'] && ENV['QUALITY'] == 'true')
   end
 end
 
+require 'debug'
 require 'timecop'
 require 'activerecord-jdbc-adapter' if defined? JRUBY_VERSION
 
@@ -46,7 +47,7 @@ path = File.join(File.dirname(__FILE__), 'support')
 TEST_CERT = File.read(File.join(path, 'cert_without_password.pem'))
 TEST_CERT_WITH_PASSWORD = File.read(File.join(path, 'cert_with_password.pem'))
 
-VAPID_KEYPAIR = Webpush.generate_key.to_hash.merge(subject: 'rpush-test@example.org').to_json
+VAPID_KEYPAIR = WebPush.generate_key.to_hash.merge(subject: 'rpush-test@example.org').to_json
 
 def after_example_cleanup
   Rpush.logger = nil
@@ -57,6 +58,8 @@ def after_example_cleanup
   end
   Rpush.plugins.values.each(&:unload)
   Rpush.instance_variable_set('@plugins', {})
+  Rpush.reflection_stack.clear
+  Rpush.reflection_stack.push(Rpush::ReflectionCollection.new)
 end
 
 RSpec.configure do |config|

data/spec/support/active_record_setup.rb

@@ -43,6 +43,7 @@ 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'
+require 'generators/templates/rpush_7_1_0_updates'
 
 migrations = [
   AddRpush,
@@ -60,7 +61,8 @@ migrations = [
   Rpush331Updates,
   Rpush410Updates,
   Rpush411Updates,
-  Rpush420Updates
+  Rpush420Updates,
+  Rpush710Updates
 ]
 
 unless ENV['CI']

data/spec/unit/client/active_record/{gcm → fcm}/app_spec.rb

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

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

@@ -0,0 +1,10 @@
+require 'unit_spec_helper'
+
+describe Rpush::Client::ActiveRecord::Fcm::Notification do
+  it_behaves_like 'Rpush::Client::Fcm::Notification'
+  it_behaves_like 'Rpush::Client::ActiveRecord::Notification'
+
+  subject(:notification) { described_class.new }
+  let(:app) { Rpush::Fcm::App.create!(name: 'test', auth_key: 'abc') }
+
+end if active_record?

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

@@ -8,7 +8,7 @@ shared_examples_for 'Rpush::Client::ActiveRecord::App' do
     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)
+    app = Rpush::Fcm::App.new(name: 'test', environment: 'production', json_key: TEST_CERT)
     expect(app.valid?).to eq(true)
   end
 end

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

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

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

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

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

@@ -165,21 +165,6 @@ shared_examples 'Rpush::Client::Apns::Notification' do
     end
   end
 
-  describe 'content_available?' do
-    context 'if not set' do
-      it 'should be false' do
-        expect(notification.content_available?).to be_falsey
-      end
-    end
-
-    context 'if set' do
-      it 'should be true' do
-        notification.content_available = true
-        expect(notification.content_available?).to be_truthy
-      end
-    end
-  end
-
   describe 'url-args' do
     it 'includes url-args in the payload' do
       notification.url_args = ['url-arg-1']

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

@@ -0,0 +1,4 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Fcm::App' do
+end

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

@@ -0,0 +1,92 @@
+require 'unit_spec_helper'
+
+shared_examples 'Rpush::Client::Fcm::Notification' do
+  let(:app) { Rpush::Fcm::App.create!(name: 'test', auth_key: 'abc') }
+  let(:notification) { described_class.new }
+
+  it "has a 'data' payload limit of 4096 bytes" do
+    notification.app = app
+    notification.device_token = "valid"
+    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 "validates notification keys" do
+    notification.app = app
+    notification.device_token = "valid"
+    notification.notification = { "title" => "valid", "body" => "valid", "color" => "valid for android", "garbage" => "invalid" }
+    expect(notification.valid?).to be_falsey
+    expect(notification.errors[:notification]).to eq ["contains invalid keys: garbage"]
+  end
+
+  it "allows notifications with either symbol keys or string keys" do
+    notification.app = app
+    notification.notification = { "title" => "title", body: "body" }
+    expect(notification.as_json['message']['notification']).to eq({"title"=>"title", "body"=>"body"})
+  end
+
+  it "moves notification keys to the correcdt location" do
+    notification.app = app
+    notification.device_token = "valid"
+    notification.notification = { "title" => "valid", "body" => "valid", "color" => "valid for android" }
+    expect(notification.valid?).to be_truthy
+    expect(notification.as_json['message']['notification']).to eq("title"=>"valid", "body"=>"valid")
+    expect(notification.as_json['message']['android']['notification']['color']).to eq('valid for android')
+  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['message']['android']['ttl']).to eq '100s'
+  end
+
+  it 'includes content_available in the payload' do
+    notification.content_available = true
+    expect(notification.as_json["message"]["apns"]["payload"]["aps"]["content-available"]).to eq 1
+  end
+
+  it 'sets the priority to high when set to high' do
+    notification.notification = { title: "Title" }
+    notification.priority = 'high'
+    expect(notification.as_json['message']['android']['priority']).to eq 'high'
+    expect(notification.as_json['message']['android']['notification']['notification_priority']).to eq 'PRIORITY_MAX'
+    # TODO Add notification_priority
+  end
+
+  it 'sets the priority to normal when set to normal' do
+    notification.notification = { title: "Title" }
+    notification.priority = 'normal'
+    expect(notification.as_json['message']['android']['priority']).to eq 'normal'
+    expect(notification.as_json['message']['android']['notification']['notification_priority']).to eq 'PRIORITY_DEFAULT'
+    # TODO Add notification_priority
+  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['message']['android']).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['message']).to have_key 'notification'
+  end
+
+  it 'excludes the notification payload if undefined' do
+    expect(notification.as_json['message']).not_to have_key 'notification'
+  end
+
+  it 'fails when trying to set the dry_run option' do
+    expect { notification.dry_run = true }.to raise_error(ArgumentError)
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -41,6 +41,6 @@ describe Rpush::Configuration do
   it 'delegate redis_options to Modis' do
     Rpush.config.client = :redis
     Rpush.config.redis_options = { hi: :mom }
-    expect(Modis.redis_options).to eq(hi: :mom)
+    expect(Modis.redis_options[:default]).to eq(hi: :mom)
   end
 end

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

@@ -42,7 +42,7 @@ describe Rpush::Daemon::Apnsp8::Delivery do
         loop do
           break unless thread.alive?
 
-          if Time.now - start > 0.5
+          if Time.now - start > 1
             thread.kill
             fail 'Stuck in an infinite loop'
           end

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

@@ -0,0 +1,127 @@
+require 'unit_spec_helper'
+
+describe Rpush::Daemon::Fcm::Delivery do
+  let(:app) { Rpush::Fcm::App.create!(name: 'MyApp', firebase_project_id: 'abc123', json_key:'{}') }
+  let(:notification) { Rpush::Fcm::Notification.create!(app: app, device_token: 'xyz', deliver_after: Time.now) }
+  let(:logger) { double(error: nil, info: nil, warn: nil) }
+  let(:response) { double(code: 200, header: {}) }
+  let(:http) { double(shutdown: nil, request: response) }
+  let(:now) { Time.parse('2012-10-14 00:00:00') }
+  let(:batch) { double(mark_failed: nil, mark_delivered: nil, mark_retryable: nil, notification_processed: nil) }
+  let(:delivery) { Rpush::Daemon::Fcm::Delivery.new(app, http, notification, batch) }
+  let(:store) { double(create_fcm_notification: double(id: 2)) }
+
+  def perform
+    delivery.perform
+  end
+
+  def perform_with_rescue
+    expect { perform }.to raise_error(StandardError)
+  end
+
+  before do
+    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)
+    allow_any_instance_of(Rpush::Daemon::Fcm::Delivery).to receive_messages(obtain_access_token: "access_token")
+  end
+
+  describe 'a 200 response' do
+    before do
+      allow(response).to receive_messages(code: 200)
+      allow(response).to receive_messages(body: nil)
+      allow(notification).to receive_messages(device_token: '1')
+    end
+
+    it 'reflects on ID which successfully received the notification' do
+      expect(delivery).to receive(:reflect).with(:fcm_delivered_to_recipient, notification)
+      perform
+    end
+
+    it 'marks the notification as delivered' do
+      expect(delivery).to receive(:mark_delivered)
+      perform
+    end
+
+    it 'logs that the notification was delivered' do
+      expect(logger).to receive(:info).with("[MyApp] #{notification.id} sent to 1")
+      perform
+    end
+  end
+
+  describe 'all deliveries failed with Unavailable or InternalServerError 503' do
+    before do
+      allow(notification).to receive_messages(device_token: '1')
+      allow(response).to receive_messages(code: 503, body: nil)
+    end
+
+    it 'reflects on any IDs which failed to receive the notification' do
+      pending("Determine the correct cases where FCM should send fcm_failed_to_recipient")
+      expect(delivery).to receive(:reflect).with(:fcm_failed_to_recipient, notification)
+      perform
+    end
+
+    it 'retries the notification respecting the Retry-After header' do
+      allow(response).to receive_messages(header: { 'retry-after' => 10 })
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 10.seconds)
+      perform
+    end
+
+    it 'retries the notification using exponential back-off if the Retry-After header is not present' do
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2)
+      perform
+    end
+
+    it 'does not mark the notification as failed' do
+      expect(delivery).not_to receive(:mark_failed)
+      perform
+    end
+
+    it 'logs that the notification will be retried' do
+      notification.retries = 1
+      notification.deliver_after = now + 2
+      expect(Rpush.logger).to receive(:warn).with("[MyApp] FCM responded with an Service Unavailable Error. Notification #{notification.id} will be retried after 2012-10-14 00:00:02 (retry 1).")
+      perform
+    end
+  end
+
+  describe 'all deliveries failed with Unavailable or InternalServerError 500' do
+    before do
+      allow(notification).to receive_messages(device_token: '1')
+      allow(response).to receive_messages(code: 500, body: nil)
+    end
+
+    it 'logs a warning that the notification has been re-queued.' do
+      notification.retries = 3
+      notification.deliver_after = now + 2**3
+      expect(Rpush.logger).to receive(:warn).with("[MyApp] FCM responded with an Internal Error. Notification #{notification.id} will be retried after #{(now + 2**3).strftime('%Y-%m-%d %H:%M:%S')} (retry 3).")
+      perform
+    end
+
+    it 'retries the notification in accordance with the exponential back-off strategy.' do
+      notification.update_attribute(:retries, 2)
+      expect(delivery).to receive(:mark_retryable).with(notification, now + 2**3)
+      perform
+    end
+  end
+
+  describe 'all deliveries failed with invalid token' do
+    before do
+      allow(notification).to receive_messages(device_token: '1')
+      allow(response).to receive_messages(code: 404, body: { error: { status: 'NOT_FOUND', message: 'Requested entity was not found.' } }.to_json)
+    end
+
+    it 'reflects on invalid IDs' do
+      expect(delivery).to receive(:reflect).with(:fcm_invalid_device_token, app, "NOT_FOUND: Requested entity was not found.", '1')
+      perform_with_rescue
+    end
+
+    it 'marks a notification as failed if any ids are invalid' do
+      expect(delivery).to receive(:mark_failed)
+      expect(delivery).not_to receive(:mark_retryable)
+      expect(store).not_to receive(:create_fcm_notification)
+      perform_with_rescue
+    end
+  end
+end

data/spec/unit/daemon/service_config_methods_spec.rb

@@ -23,7 +23,7 @@ describe Rpush::Daemon::ServiceConfigMethods do
     ServiceConfigMethodsSpec.dispatcher :http, an: :option
     app = double
     dispatcher = double
-    expect(Rpush::Daemon::Dispatcher::Http).to receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, an: :option).and_return(dispatcher)
+    expect(Rpush::Daemon::Dispatcher::Http).to receive(:new).with(app, ServiceConfigMethodsSpec::Delivery, {an: :option}).and_return(dispatcher)
     expect(ServiceConfigMethodsSpec.new_dispatcher(app)).to eq dispatcher
   end
 

data/spec/unit/daemon/shared/store.rb

@@ -233,48 +233,6 @@ shared_examples 'Rpush::Daemon::Store' do
     end
   end
 
-  describe 'create_apns_feedback' do
-    it 'creates the Feedback record' do
-      expect(Rpush::Apns::Feedback).to receive(:create!).with(
-        failed_at: time, device_token: 'ab' * 32, app_id: app.id
-      )
-      store.create_apns_feedback(time, 'ab' * 32, app)
-    end
-  end
-
-  describe 'create_gcm_notification' do
-    let(:data) { { 'data' => true } }
-    let(:attributes) { { device_token: 'ab' * 32 } }
-    let(:registration_ids) { %w[123 456] }
-    let(:deliver_after) { time + 10.seconds }
-    let(:args) { [attributes, data, registration_ids, deliver_after, app] }
-
-    it 'sets the given attributes' do
-      new_notification = store.create_gcm_notification(*args)
-      expect(new_notification.device_token).to eq 'ab' * 32
-    end
-
-    it 'sets the given data' do
-      new_notification = store.create_gcm_notification(*args)
-      expect(new_notification.data['data']).to be_truthy
-    end
-
-    it 'sets the given registration IDs' do
-      new_notification = store.create_gcm_notification(*args)
-      expect(new_notification.registration_ids).to eq registration_ids
-    end
-
-    it 'sets the deliver_after timestamp' do
-      new_notification = store.create_gcm_notification(*args)
-      expect(new_notification.deliver_after).to eq deliver_after
-    end
-
-    it 'saves the new notification' do
-      new_notification = store.create_gcm_notification(*args)
-      expect(new_notification.new_record?).to be_falsey
-    end
-  end
-
   describe 'create_adm_notification' do
     let(:data) { { 'data' => true } }
     let(:attributes) { { app_id: app.id, collapse_key: 'ckey', delay_while_idle: true } }

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

@@ -50,7 +50,7 @@ describe Rpush::Daemon::Wns::Delivery do
     end
 
     it 'set the access token for the app' do
-      expect(delivery).to receive(:update_access_token).with("access_token" => "dummy_access_token", "expires_in" => 60)
+      expect(delivery).to receive(:update_access_token).with({"access_token" => "dummy_access_token", "expires_in" => 60})
       expect(store).to receive(:update_app).with app
       perform
     end

data/spec/unit/logger_spec.rb

@@ -92,7 +92,7 @@ describe Rpush::Logger do
     now = Time.now
     allow(Time).to receive(:now).and_return(now)
     logger = Rpush::Logger.new
-    expect(@logger).to receive(:info).with(/#{Regexp.escape("[#{now.to_s(:db)}]")}/)
+    expect(@logger).to receive(:info).with(/#{Regexp.escape("[#{now.to_formatted_s(:db)}]")}/)
     logger.info("blah")
   end
 

data/spec/unit_spec_helper.rb

@@ -12,7 +12,7 @@ RSpec.configure do |config|
   config.before(:each) do
     Modis.with_connection do |redis|
       redis.keys('rpush:*').each { |key| redis.del(key) }
-    end if redis?
+    end if redis? && unit_example?(self.class.metadata)
 
     if active_record? && unit_example?(self.class.metadata)
       connection = ActiveRecord::Base.connection