rpush 7.0.1 → 8.0.0

data/lib/rpush/daemon/fcm.rb

@@ -0,0 +1,9 @@
+module Rpush
+  module Daemon
+    module Fcm
+      extend ServiceConfigMethods
+
+      dispatcher :http
+    end
+  end
+end

data/lib/rpush/daemon/gcm/delivery.rb

@@ -238,4 +238,4 @@ module Rpush
       end
     end
   end
-end
+end

data/lib/rpush/daemon/google_credential_cache.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+module Rpush
+  module Daemon
+    class GoogleCredentialCache
+      include Singleton
+      include Loggable
+
+      # Assuming tokens are valid for 1 hour
+      TOKEN_VALID_FOR_SEC = 60 * 59
+
+      def initialize
+        @credentials_cache = {}
+      end
+
+      def access_token(scope, json_key)
+        key = hash_key(scope, json_key)
+
+        if @credentials_cache[key].nil? || Time.now > @credentials_cache[key][:expires_at]
+          token = fetch_fresh_token(scope, json_key)
+          expires_at = Time.now + TOKEN_VALID_FOR_SEC
+          @credentials_cache[key] = { token: token, expires_at: expires_at }
+        end
+
+        @credentials_cache[key][:token]
+      end
+
+      private
+
+      def fetch_fresh_token(scope, json_key)
+        json_key_io = json_key ? StringIO.new(json_key) : nil
+        log_debug("FCM - Obtaining access token.")
+        authorizer = Google::Auth::ServiceAccountCredentials.make_creds(scope: scope, json_key_io: json_key_io)
+        authorizer.fetch_access_token
+      end
+
+      def hash_key(scope, json_key)
+        scope.hash ^ json_key.hash
+      end
+    end
+  end
+end

data/lib/rpush/daemon/store/active_record.rb

@@ -145,6 +145,11 @@ module Rpush
           end
         end
 
+        def create_fcm_notification(attrs, data, app)
+          notification = Rpush::Client::ActiveRecord::Fcm::Notification.new
+          create_fcm_like_notification(notification, attrs, data, app)
+        end
+
         def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::ActiveRecord::Gcm::Notification.new
           create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
@@ -194,6 +199,16 @@ module Rpush
 
         private
 
+        def create_fcm_like_notification(notification, attrs, data, app) # rubocop:disable Metrics/ParameterLists
+          with_database_reconnect_and_retry do
+            notification.assign_attributes(attrs)
+            notification.data = data
+            notification.app = app
+            notification.save!
+            notification
+          end
+        end
+
         def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
           with_database_reconnect_and_retry do
             notification.assign_attributes(attrs)

data/lib/rpush/daemon/store/interface.rb

@@ -5,8 +5,8 @@ module Rpush
         PUBLIC_METHODS = [:deliverable_notifications, :mark_retryable,
                           :mark_batch_retryable, :mark_delivered, :mark_batch_delivered,
                           :mark_failed, :mark_batch_failed, :create_apns_feedback,
-                          :create_gcm_notification, :create_adm_notification, :update_app,
-                          :update_notification, :release_connection,
+                          :create_fcm_notification, :create_gcm_notification, :create_adm_notification,
+                          :update_app, :update_notification, :release_connection,
                           :all_apps, :app, :mark_ids_failed, :mark_ids_retryable,
                           :reopen_log, :pending_delivery_count, :translate_integer_notification_id]
 

data/lib/rpush/daemon/store/redis.rb

@@ -92,6 +92,11 @@ module Rpush
           Rpush::Client::Redis::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app_id: app.id)
         end
 
+        def create_fcm_notification(attrs, data, app)
+          notification = Rpush::Client::Redis::Fcm::Notification.new
+          create_fcm_like_notification(notification, attrs, data, app)
+        end
+
         def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
           notification = Rpush::Client::Redis::Gcm::Notification.new
           create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
@@ -138,6 +143,14 @@ module Rpush
           nil
         end
 
+        def create_fcm_like_notification(notification, attrs, data, app) # rubocop:disable Metrics/ParameterLists
+          notification.assign_attributes(attrs)
+          notification.data = data
+          notification.app = app
+          notification.save!
+          notification
+        end
+
         def create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app) # rubocop:disable Metrics/ParameterLists
           notification.assign_attributes(attrs)
           notification.data = data

data/lib/rpush/daemon/webpush/delivery.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "webpush"
+require "web-push"
 
 module Rpush
   module Daemon
@@ -10,7 +10,7 @@ module Rpush
       # We just override #perform to inject the http instance that is managed
       # by Rpush.
       #
-      class Request < ::Webpush::Request
+      class Request < ::WebPush::Request
         def perform(http)
           req = Net::HTTP::Post.new(uri.request_uri, headers)
           req.body = body

data/lib/rpush/daemon.rb

@@ -49,6 +49,10 @@ require 'rpush/daemon/apnsp8/delivery'
 require 'rpush/daemon/apnsp8/token'
 require 'rpush/daemon/apnsp8'
 
+require 'rpush/daemon/fcm/delivery'
+require 'rpush/daemon/fcm'
+require 'rpush/daemon/google_credential_cache'
+
 require 'rpush/daemon/gcm/delivery'
 require 'rpush/daemon/gcm'
 

data/lib/rpush/reflection_collection.rb

@@ -4,8 +4,9 @@ module Rpush
 
     REFLECTIONS = [
       :apns_feedback, :notification_enqueued, :notification_delivered,
-      :notification_failed, :notification_will_retry, :gcm_delivered_to_recipient,
-      :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
+      :notification_failed, :notification_will_retry,
+      :gcm_delivered_to_recipient, :gcm_failed_to_recipient, :gcm_canonical_id, :gcm_invalid_registration_id,
+      :fcm_delivered_to_recipient, :fcm_failed_to_recipient, :fcm_canonical_id, :fcm_invalid_device_token,
       :error, :adm_canonical_id, :adm_failed_to_recipient, :wns_invalid_channel,
       :tcp_connection_lost, :ssl_certificate_will_expire, :ssl_certificate_revoked,
       :notification_id_will_retry, :notification_id_failed

data/lib/rpush/version.rb

@@ -1,8 +1,8 @@
 module Rpush
   module VERSION
-    MAJOR = 7
+    MAJOR = 8
     MINOR = 0
-    TINY = 1
+    TINY = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".").freeze

data/lib/rpush.rb

@@ -3,6 +3,7 @@ require 'multi_json'
 require 'active_support/all'
 require 'net-http2'
 require 'jwt'
+require 'googleauth'
 
 require 'rails'
 

data/spec/functional/apns2_spec.rb

@@ -79,8 +79,7 @@ describe 'APNs http2 adapter' do
           headers: {
             'apns-expiration' => '0',
             'apns-priority' => '10',
-            'apns-topic' => 'com.example.app',
-            'apns-push-type' => 'background'
+            'apns-topic' => 'com.example.app'
           }
         }
       )
@@ -114,8 +113,7 @@ describe 'APNs http2 adapter' do
             headers: {
               'apns-topic' => bundle_id,
               'apns-expiration' => '0',
-              'apns-priority' => '10',
-              'apns-push-type' => 'background'
+              'apns-priority' => '10'
             }
           }
         ).and_return(fake_http2_request)
@@ -257,7 +255,6 @@ describe 'APNs http2 adapter' do
         Rpush.reflect do |on|
           on.error do |error|
             expect(error).to be_kind_of(StandardError)
-           reflector.accept
           end
         end
 
@@ -292,7 +289,6 @@ describe 'APNs http2 adapter' do
           on.error do |error|
             reflected_error = true
             expect(error).to be_kind_of(StandardError)
-            reflector.accept
           end
         end
 

data/spec/functional/fcm_priority_spec.rb

@@ -0,0 +1,46 @@
+require 'functional_spec_helper'
+
+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'
+    app.auth_key = 'abc123'
+    app.save!
+
+    notification.app_id = app.id
+    notification.device_token = fake_device_token
+    notification.data = { message: 'test' }
+    notification.notification = { title: 'title' }
+    notification.priority = priority
+    notification.save!
+
+    allow(Net::HTTP::Persistent).to receive_messages(new: http)
+  end
+
+  it 'supports normal priority' do
+    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
+      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
+
+  it 'does not add an error when receiving expected priority' do
+    expect(hydrated_notification.errors.messages[:priority]).to be_empty
+  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_spec_helper.rb

@@ -21,7 +21,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? && 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

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/fcm/app_spec.rb

@@ -0,0 +1,6 @@
+require 'unit_spec_helper'
+
+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/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