fcm 1.0.0 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dea7a47eae801d77518e6a53fee8740b99e0ba0ab62eb35d3bc56545ac44ceab
-  data.tar.gz: 8cac898bef85b9243f03573da25334298a206c6ed2492b3d18a20eb7d614e556
+  metadata.gz: a3378dc24fca1ced3cbda70c31a427261044eaa4b9d0580884e73981a04b1ce3
+  data.tar.gz: 6801d93f67ace2faeda17ad8ccf99b363cc6526a99573d8e5938eca7563e78c5
 SHA512:
-  metadata.gz: ac7d34e4ebaf6c18dc60e915f7d915575b1e77401458163bd9eb3147277fc15ba42685939cf9d05b22ee585f9025f2dd3b4c40d4116f99778a8c8dbbd3b44b2f
-  data.tar.gz: 385fd1829ae861daac05bac042c52f141a23f6bed289311723d9f5c07ffbbe2130e1c18da55ad9b59fc8ee1c991d1e0472d8732a9d6392939327f605e4ee25a6
+  metadata.gz: 657dd3db45b913993cbd876a918ed69affaefe076ca649722c0c6c61937978b20337f8677398f735e7ff40ea983193d58c420811a2ed90778bbe8efc00f4f033
+  data.tar.gz: 662b4fc1b8b04962f957518ebaf86d68ca92d905a989e6baed51d4705af55b83f30388030da66237fec93b7fe2d66c0fdd3b14132915e75d0dcccccf312eb58d

data/.gitignore

@@ -48,4 +48,4 @@ specifications
 Gemfile.lock
 .rvmrc
 spec/reports
-*.gem
+*.gem

data/Gemfile

@@ -5,3 +5,4 @@ gem 'rake'
 gem 'rspec'
 gem 'webmock'
 gem 'ci_reporter_rspec'
+gem 'googleauth'

data/README.md

@@ -1,6 +1,6 @@
 # Firebase Cloud Messaging (FCM) for Android and iOS
 
-[![Gem Version](https://badge.fury.io/rb/fcm.svg)](http://badge.fury.io/rb/fcm) [![Build Status](https://secure.travis-ci.org/spacialdb/fcm.png?branch=master)](http://travis-ci.org/spacialdb/fcm)
+[![Gem Version](https://badge.fury.io/rb/fcm.svg)](http://badge.fury.io/rb/fcm) [![Build Status](https://secure.travis-ci.org/decision-labs/fcm.svg?branch=master)](http://travis-ci.org/decision-labs/fcm)
 
 The FCM gem lets your ruby backend send notifications to Android and iOS devices via [
 Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/).
@@ -19,13 +19,56 @@ gem 'fcm'
 
 For Android you will need a device running 2.3 (or newer) that also have the Google Play Store app installed, or an emulator running Android 2.3 with Google APIs. iOS devices are also supported.
 
-
-A version of supported Ruby, currently:  
+A version of supported Ruby, currently:
 `ruby >= 2.4`
 
-
 ## Usage
 
+## HTTP v1 API
+
+To migrate to HTTP v1 see: https://firebase.google.com/docs/cloud-messaging/migrate-v1
+
+```ruby
+fcm = FCM.new(
+  API_TOKEN,
+  GOOGLE_APPLICATION_CREDENTIALS_PATH,
+  FIREBASE_PROJECT_ID
+)
+message = {
+  'topic': "89023", # OR token if you want to send to a specific device
+  # 'token': "000iddqd",
+  'data': {
+    payload: {
+      data: {
+        id: 1
+      }
+    }.to_json
+  },
+  'notification': {
+    title: notification.title_th,
+    body: notification.body_th,
+  },
+  'android': {},
+  'apns': {
+    payload: {
+      aps: {
+        sound: "default",
+        category: "#{Time.zone.now.to_i}"
+      }
+    }
+  },
+  'fcm_options': {
+    analytics_label: 'Label'
+  }
+}
+
+fcm.send_v1(message)
+```
+
+## HTTP Legacy Version
+
+To migrate to HTTP v1 see: https://firebase.google.com/docs/cloud-messaging/migrate-v1
+
 For your server to send a message to one or more devices, you must first initialise a new `FCM` class with your Firebase Cloud Messaging server key, and then call the `send` method on this and give it 1 or more (up to 1000) registration tokens as an array of strings. You can also optionally send further [HTTP message parameters](https://firebase.google.com/docs/cloud-messaging/http-server-ref) like `data` or `time_to_live` etc. as a hash via the second optional argument to `send`.
 
 Example sending notifications:
@@ -34,14 +77,10 @@ Example sending notifications:
 require 'fcm'
 
 fcm = FCM.new("my_server_key")
-# you can set option parameters in here
-#  - all options are pass to HTTParty method arguments
-#  - ref: https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb#L29-L60
-#  fcm = FCM.new("my_server_key", timeout: 3)
 
 registration_ids= ["12", "13"] # an array of one or more client registration tokens
 
-# See https://firebase.google.com/docs/reference/fcm/rest/v1/projects.messages for all available options.
+# See https://firebase.google.com/docs/cloud-messaging/http-server-ref for all available options.
 options = { "notification": {
               "title": "Portugal vs. Denmark",
               "body": "5 to 1"
@@ -101,14 +140,14 @@ FCM [topic messaging](https://firebase.google.com/docs/cloud-messaging/topic-mes
 
 ```ruby
 response = fcm.send_with_notification_key("/topics/yourTopic",
-            data: {message: "This is a FCM Topic Message!"})
+            notification: {body: "This is a FCM Topic Message!"})
 ```
 
 Or you can use the helper:
 
 ```ruby
 response = fcm.send_to_topic("yourTopic",
-            data: {message: "This is a FCM Topic Message!"})
+            notification: {body: "This is a FCM Topic Message!"})
 ```
 
 ### Sending to Multiple Topics
@@ -137,8 +176,8 @@ The `send_to_topic_condition` method within this library allows you to specicy a
 ```ruby
 response = fcm.send_to_topic_condition(
   "'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)",
-  data: {
-    message: "This is an FCM Topic Message sent to a condition!"
+  notification: {
+    body: "This is an FCM Topic Message sent to a condition!"
   }
 )
 ```
@@ -171,6 +210,14 @@ The guide to set up an iOS app to get notifications is here: [Setting up a FCM C
 
 ## ChangeLog
 
+### 1.0.3
+
+- Fix overly strict faraday depenecy
+
+### 1.0.2
+
+- Bug fix: retrieve notification key" params: https://github.com/spacialdb/fcm/commit/b328a75c11d779a06d0ceda83527e26aa0495774
+
 ### 1.0.0
 
 - Bumped supported ruby to `>= 2.4`
@@ -197,8 +244,15 @@ The guide to set up an iOS app to get notifications is here: [Setting up a FCM C
 
 - [Contributors](https://github.com/spacialdb/fcm/contributors)
 
-## Donations
+## Cutting a release
 
-We accept tips through [Gratipay](https://gratipay.com/spacialdb/).
+Update version in `fcm.gemspec` with `VERSION` and update `README.md` `## ChangeLog` section.
 
-[![Gratipay](https://img.shields.io/gratipay/spacialdb.svg)](https://www.gittip.com/spacialdb/)
+```bash
+# set the version
+# VERSION="1.0.4"
+gem build fcm.gemspec
+git tag -a v${VERSION} -m "Releasing version v${VERSION}"
+git push origin --tags
+gem push fcm-${VERSION}.gem
+```

data/fcm.gemspec

@@ -3,10 +3,10 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "fcm"
-  s.version     = "1.0.0"
+  s.version     = "1.0.5"
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Kashif Rasul", "Shoaib Burq"]
-  s.email       = ["kashif@spacialdb.com", "shoaib@spacialdb.com"]
+  s.email       = ["kashif@decision-labs.com", "shoaib@decision-labs.com"]
   s.homepage    = "https://github.com/spacialdb/fcm"
   s.summary     = %q{Reliably deliver messages and notifications via FCM}
   s.description = %q{fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform messaging solution that lets you reliably deliver messages and notifications at no cost to Android, iOS or Web browsers.}
@@ -19,5 +19,5 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency('faraday','1.0.0')
+  s.add_runtime_dependency('faraday', '~> 1')
 end

data/lib/fcm.rb

@@ -1,24 +1,71 @@
-require 'faraday'
-require 'cgi'
-require 'json'
+require "faraday"
+require "cgi"
+require "json"
+require "googleauth"
 
 class FCM
-  BASE_URI = 'https://fcm.googleapis.com'
+  BASE_URI = "https://fcm.googleapis.com"
+  BASE_URI_V1 = "https://fcm.googleapis.com/v1/projects/"
   DEFAULT_TIMEOUT = 30
   FORMAT = :json
 
   # constants
-  GROUP_NOTIFICATION_BASE_URI = 'https://android.googleapis.com'
-  INSTANCE_ID_API = 'https://iid.googleapis.com'
+  GROUP_NOTIFICATION_BASE_URI = "https://android.googleapis.com"
+  INSTANCE_ID_API = "https://iid.googleapis.com"
   TOPIC_REGEX = /[a-zA-Z0-9\-_.~%]+/
 
-  attr_accessor :timeout, :api_key
+  attr_accessor :timeout, :api_key, :json_key_path, :project_base_uri
 
-  def initialize(api_key, client_options = {})
+  def initialize(api_key, json_key_path = "", project_name = "", client_options = {})
     @api_key = api_key
     @client_options = client_options
+    @json_key_path = json_key_path
+    @project_base_uri = BASE_URI_V1 + project_name.to_s
   end
 
+  # See https://firebase.google.com/docs/cloud-messaging/send-message
+  # {
+  #   "token": "4sdsx",
+  #   "notification": {
+  #     "title": "Breaking News",
+  #     "body": "New news story available."
+  #   },
+  #   "data": {
+  #     "story_id": "story_12345"
+  #   },
+  #   "android": {
+  #     "notification": {
+  #       "click_action": "TOP_STORY_ACTIVITY",
+  #       "body": "Check out the Top Story"
+  #     }
+  #   },
+  #   "apns": {
+  #     "payload": {
+  #       "aps": {
+  #         "category" : "NEW_MESSAGE_CATEGORY"
+  #       }
+  #     }
+  #   }
+  # }
+  # fcm = FCM.new(api_key, json_key_path, project_name)
+  # fcm.send(
+  #    { "token": "4sdsx",, "to" : "notification": {}.. }
+  # )
+  def send_notification_v1(message)
+    return if @project_base_uri.empty?
+
+    post_body = { 'message': message }
+
+    response = Faraday.post("#{@project_base_uri}/messages:send") do |req|
+      req.headers["Content-Type"] = "application/json"
+      req.headers["Authorization"] = "Bearer #{jwt_token}"
+      req.body = post_body.to_json
+    end
+    build_response(response)
+  end
+
+  alias send_v1 send_notification_v1
+
   # See https://developers.google.com/cloud-messaging/http for more details.
   # { "notification": {
   #  "title": "Portugal vs. Denmark",
@@ -35,72 +82,72 @@ class FCM
     post_body = build_post_body(registration_ids, options)
 
     for_uri(BASE_URI) do |connection|
-      response = connection.post('/fcm/send', post_body.to_json)
+      response = connection.post("/fcm/send", post_body.to_json)
       build_response(response, registration_ids)
     end
   end
+
   alias send send_notification
 
   def create_notification_key(key_name, project_id, registration_ids = [])
-    post_body = build_post_body(registration_ids, operation: 'create',
-                                notification_key_name: key_name)
+    post_body = build_post_body(registration_ids, operation: "create",
+                                                  notification_key_name: key_name)
 
     extra_headers = {
-      'project_id' => project_id
+      "project_id" => project_id,
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
-      response = connection.post('/gcm/notification', post_body.to_json)
+      response = connection.post("/gcm/notification", post_body.to_json)
       build_response(response)
     end
   end
+
   alias create create_notification_key
 
   def add_registration_ids(key_name, project_id, notification_key, registration_ids)
-    post_body = build_post_body(registration_ids, operation: 'add',
-                                notification_key_name: key_name,
-                                notification_key: notification_key)
+    post_body = build_post_body(registration_ids, operation: "add",
+                                                  notification_key_name: key_name,
+                                                  notification_key: notification_key)
 
     extra_headers = {
-      'project_id' => project_id
+      "project_id" => project_id,
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
-      response = connection.post('/gcm/notification', post_body.to_json)
+      response = connection.post("/gcm/notification", post_body.to_json)
       build_response(response)
     end
   end
+
   alias add add_registration_ids
 
   def remove_registration_ids(key_name, project_id, notification_key, registration_ids)
-    post_body = build_post_body(registration_ids, operation: 'remove',
-                                notification_key_name: key_name,
-                                notification_key: notification_key)
+    post_body = build_post_body(registration_ids, operation: "remove",
+                                                  notification_key_name: key_name,
+                                                  notification_key: notification_key)
 
     extra_headers = {
-      'project_id' => project_id
+      "project_id" => project_id,
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
-      response = connection.post('/gcm/notification', post_body.to_json)
+      response = connection.post("/gcm/notification", post_body.to_json)
       build_response(response)
     end
   end
+
   alias remove remove_registration_ids
 
   def recover_notification_key(key_name, project_id)
-    params = {
-      query: {
-        notification_key_name: key_name
-      }
-    }
-      
+    params = { notification_key_name: key_name }
+
     extra_headers = {
-      'project_id' => project_id
+      "project_id" => project_id,
     }
 
     for_uri(GROUP_NOTIFICATION_BASE_URI, extra_headers) do |connection|
-      response = connection.get('/gcm/notification', params)
+      response = connection.get("/gcm/notification", params)
       build_response(response)
     end
   end
@@ -118,11 +165,11 @@ class FCM
   end
 
   def batch_topic_subscription(topic, registration_ids)
-    manage_topics_relationship(topic, registration_ids, 'Add')
+    manage_topics_relationship(topic, registration_ids, "Add")
   end
 
   def batch_topic_unsubscription(topic, registration_ids)
-    manage_topics_relationship(topic, registration_ids, 'Remove')
+    manage_topics_relationship(topic, registration_ids, "Remove")
   end
 
   def manage_topics_relationship(topic, registration_ids, action)
@@ -136,35 +183,35 @@ class FCM
 
   def send_to_topic(topic, options = {})
     if topic.gsub(TOPIC_REGEX, "").length == 0
-      send_with_notification_key('/topics/' + topic, options)
+      send_with_notification_key("/topics/" + topic, options)
     end
   end
 
-  def get_instance_id_info iid_token, options={}
+  def get_instance_id_info(iid_token, options = {})
     params = {
-      query: options
+      query: options,
     }
-    
+
     for_uri(INSTANCE_ID_API) do |connection|
-      response = connection.get('/iid/info/'+iid_token, params)
+      response = connection.get("/iid/info/" + iid_token, params)
       build_response(response)
     end
   end
 
-  def subscribe_instance_id_to_topic iid_token, topic_name
+  def subscribe_instance_id_to_topic(iid_token, topic_name)
     batch_subscribe_instance_ids_to_topic([iid_token], topic_name)
   end
 
-  def unsubscribe_instance_id_from_topic iid_token, topic_name
+  def unsubscribe_instance_id_from_topic(iid_token, topic_name)
     batch_unsubscribe_instance_ids_from_topic([iid_token], topic_name)
   end
 
-  def batch_subscribe_instance_ids_to_topic instance_ids, topic_name
-    manage_topics_relationship(topic_name, instance_ids, 'Add')
+  def batch_subscribe_instance_ids_to_topic(instance_ids, topic_name)
+    manage_topics_relationship(topic_name, instance_ids, "Add")
   end
 
-  def batch_unsubscribe_instance_ids_from_topic instance_ids, topic_name
-    manage_topics_relationship(topic_name, instance_ids, 'Remove')
+  def batch_unsubscribe_instance_ids_from_topic(instance_ids, topic_name)
+    manage_topics_relationship(topic_name, instance_ids, "Remove")
   end
 
   def send_to_topic_condition(condition, options = {})
@@ -178,7 +225,7 @@ class FCM
 
   def for_uri(uri, extra_headers = {})
     connection = ::Faraday.new(:url => uri) do |faraday|
-      faraday.adapter  Faraday.default_adapter
+      faraday.adapter Faraday.default_adapter
       faraday.headers["Content-Type"] = "application/json"
       faraday.headers["Authorization"] = "key=#{api_key}"
       extra_headers.each do |key, value|
@@ -198,18 +245,18 @@ class FCM
     response_hash = { body: body, headers: response.headers, status_code: response.status }
     case response.status
     when 200
-      response_hash[:response] = 'success'
+      response_hash[:response] = "success"
       body = JSON.parse(body) unless body.empty?
       response_hash[:canonical_ids] = build_canonical_ids(body, registration_ids) unless registration_ids.empty?
       response_hash[:not_registered_ids] = build_not_registered_ids(body, registration_ids) unless registration_ids.empty?
     when 400
-      response_hash[:response] = 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.'
+      response_hash[:response] = "Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields."
     when 401
-      response_hash[:response] = 'There was an error authenticating the sender account.'
+      response_hash[:response] = "There was an error authenticating the sender account."
     when 503
-      response_hash[:response] = 'Server is temporarily unavailable.'
+      response_hash[:response] = "Server is temporarily unavailable."
     when 500..599
-      response_hash[:response] = 'There was an internal error in the FCM server while trying to process the request.'
+      response_hash[:response] = "There was an internal error in the FCM server while trying to process the request."
     end
     response_hash
   end
@@ -217,9 +264,9 @@ class FCM
   def build_canonical_ids(body, registration_ids)
     canonical_ids = []
     unless body.empty?
-      if body['canonical_ids'] > 0
-        body['results'].each_with_index do |result, index|
-          canonical_ids << { old: registration_ids[index], new: result['registration_id'] } if has_canonical_id?(result)
+      if body["canonical_ids"] > 0
+        body["results"].each_with_index do |result, index|
+          canonical_ids << { old: registration_ids[index], new: result["registration_id"] } if has_canonical_id?(result)
         end
       end
     end
@@ -229,8 +276,8 @@ class FCM
   def build_not_registered_ids(body, registration_id)
     not_registered_ids = []
     unless body.empty?
-      if body['failure'] > 0
-        body['results'].each_with_index do |result, index|
+      if body["failure"] > 0
+        body["results"].each_with_index do |result, index|
           not_registered_ids << registration_id[index] if is_not_registered?(result)
         end
       end
@@ -240,17 +287,17 @@ class FCM
 
   def execute_notification(body)
     for_uri(BASE_URI) do |connection|
-      response = connection.post('/fcm/send', body.to_json)
+      response = connection.post("/fcm/send", body.to_json)
       build_response(response)
     end
   end
 
   def has_canonical_id?(result)
-    !result['registration_id'].nil?
+    !result["registration_id"].nil?
   end
 
   def is_not_registered?(result)
-    result['error'] == 'NotRegistered'
+    result["error"] == "NotRegistered"
   end
 
   def validate_condition?(condition)
@@ -269,4 +316,14 @@ class FCM
     topics = condition.scan(/(?:^|\S|\s)'([^']*?)'(?:$|\S|\s)/).flatten
     topics.all? { |topic| topic.gsub(TOPIC_REGEX, "").length == 0 }
   end
+
+  def jwt_token
+    scope = "https://www.googleapis.com/auth/firebase.messaging"
+    authorizer = Google::Auth::ServiceAccountCredentials.make_creds(
+      json_key_io: File.open(@json_key_path),
+      scope: scope,
+    )
+    token = authorizer.fetch_access_token!
+    token["access_token"]
+  end
 end

data/spec/fcm_spec.rb

@@ -1,12 +1,12 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe FCM do
   let(:send_url) { "#{FCM::BASE_URI}/fcm/send" }
   let(:group_notification_base_uri) { "#{FCM::GROUP_NOTIFICATION_BASE_URI}/gcm/notification" }
-  let(:api_key) { 'AIzaSyB-1uEai2WiUapxCs2Q0GZYzPu7Udno5aA' }
-  let(:registration_id) { '42' }
-  let(:registration_ids) { ['42'] }
-  let(:key_name) { 'appUser-Chris' }
+  let(:api_key) { "AIzaSyB-1uEai2WiUapxCs2Q0GZYzPu7Udno5aA" }
+  let(:registration_id) { "42" }
+  let(:registration_ids) { ["42"] }
+  let(:key_name) { "appUser-Chris" }
   let(:project_id) { "123456789" } # https://developers.google.com/cloud-messaging/gcm#senderid
   let(:notification_key) { "APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ" }
   let(:valid_topic) { "TopicA" }
@@ -15,15 +15,19 @@ describe FCM do
   let(:invalid_condition) { "'TopicA' in topics and some other text ('TopicB' in topics || 'TopicC' in topics)" }
   let(:invalid_condition_topic) { "'TopicA$' in topics" }
 
-  it 'should raise an error if the api key is not provided' do
+  it "should raise an error if the api key is not provided" do
     expect { FCM.new }.to raise_error(ArgumentError)
   end
 
-  it 'should raise error if time_to_live is given' do
+  it "should raise error if time_to_live is given" do
     # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#ttl
   end
 
-  describe 'sending notification' do
+  describe "#send_v1" do
+    pending "should send message"
+  end
+
+  describe "sending notification" do
     let(:valid_request_body) do
       { registration_ids: registration_ids }
     end
@@ -32,39 +36,39 @@ describe FCM do
     end
     let(:valid_request_headers) do
       {
-        'Content-Type' => 'application/json',
-        'Authorization' => "key=#{api_key}"
+        "Content-Type" => "application/json",
+        "Authorization" => "key=#{api_key}",
       }
     end
 
     let(:stub_fcm_send_request) do
       stub_request(:post, send_url).with(
         body: valid_request_body.to_json,
-        headers: valid_request_headers
+        headers: valid_request_headers,
       ).to_return(
         # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
-        body: '{}',
+        body: "{}",
         headers: {},
-        status: 200
+        status: 200,
       )
     end
 
     let(:stub_fcm_send_request_with_string) do
       stub_request(:post, send_url).with(
         body: valid_request_body_with_string.to_json,
-        headers: valid_request_headers
+        headers: valid_request_headers,
       ).to_return(
-        body: '{}',
+        body: "{}",
         headers: {},
-        status: 200
+        status: 200,
       )
     end
 
     let(:stub_fcm_send_request_with_basic_auth) do
       uri = URI.parse(send_url)
-      uri.user = 'a'
-      uri.password = 'b'
-      stub_request(:post, uri.to_s).to_return(body: '{}', headers: {}, status: 200)
+      uri.user = "a"
+      uri.password = "b"
+      stub_request(:post, uri.to_s).to_return(body: "{}", headers: {}, status: 200)
     end
 
     before(:each) do
@@ -73,30 +77,30 @@ describe FCM do
       stub_fcm_send_request_with_basic_auth
     end
 
-    it 'should send notification using POST to FCM server' do
+    it "should send notification using POST to FCM server" do
       fcm = FCM.new(api_key)
-      fcm.send(registration_ids).should eq(response: 'success', body: '{}', headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
+      fcm.send(registration_ids).should eq(response: "success", body: "{}", headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
       stub_fcm_send_request.should have_been_made.times(1)
     end
 
-    it 'should send notification using POST to FCM if id provided as string' do
+    it "should send notification using POST to FCM if id provided as string" do
       fcm = FCM.new(api_key)
-      fcm.send(registration_id).should eq(response: 'success', body: '{}', headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
+      fcm.send(registration_id).should eq(response: "success", body: "{}", headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
       stub_fcm_send_request.should have_been_made.times(1)
     end
 
-    context 'send notification with data' do
+    context "send notification with data" do
       let!(:stub_with_data) do
         stub_request(:post, send_url)
           .with(body: '{"registration_ids":["42"],"data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
       before do
       end
-      it 'should send the data in a post request to fcm' do
+      it "should send the data in a post request to fcm" do
         fcm = FCM.new(api_key)
-        fcm.send(registration_ids, data: { score: '5x1', time: '15:10' })
+        fcm.send(registration_ids, data: { score: "5x1", time: "15:10" })
         stub_with_data.should have_been_requested
       end
     end
@@ -106,25 +110,25 @@ describe FCM do
         stub_request(:post, send_url)
           .with(body: '{"to":"/topics/TopicA","data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
       let!(:stub_with_invalid_topic) do
         stub_request(:post, send_url)
           .with(body: '{"condition":"/topics/TopicA$","data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
 
       describe "#send_to_topic" do
-        it 'should send the data in a post request to fcm' do
+        it "should send the data in a post request to fcm" do
           fcm = FCM.new(api_key)
-          fcm.send_to_topic(valid_topic, data: { score: '5x1', time: '15:10' })
+          fcm.send_to_topic(valid_topic, data: { score: "5x1", time: "15:10" })
           stub_with_valid_topic.should have_been_requested
         end
 
-        it 'should not send to invalid topics' do
+        it "should not send to invalid topics" do
           fcm = FCM.new(api_key)
-          fcm.send_to_topic(invalid_topic, data: { score: '5x1', time: '15:10' })
+          fcm.send_to_topic(invalid_topic, data: { score: "5x1", time: "15:10" })
           stub_with_invalid_topic.should_not have_been_requested
         end
       end
@@ -135,143 +139,143 @@ describe FCM do
         stub_request(:post, send_url)
           .with(body: '{"condition":"\'TopicA\' in topics && (\'TopicB\' in topics || \'TopicC\' in topics)","data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
       let!(:stub_with_invalid_condition) do
         stub_request(:post, send_url)
           .with(body: '{"condition":"\'TopicA\' in topics and some other text (\'TopicB\' in topics || \'TopicC\' in topics)","data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
       let!(:stub_with_invalid_condition_topic) do
         stub_request(:post, send_url)
           .with(body: '{"condition":"\'TopicA$\' in topics","data":{"score":"5x1","time":"15:10"}}',
                 headers: valid_request_headers)
-          .to_return(status: 200, body: '', headers: {})
+          .to_return(status: 200, body: "", headers: {})
       end
 
       describe "#send_to_topic_condition" do
-        it 'should send the data in a post request to fcm' do
+        it "should send the data in a post request to fcm" do
           fcm = FCM.new(api_key)
-          fcm.send_to_topic_condition(valid_condition, data: { score: '5x1', time: '15:10' })
+          fcm.send_to_topic_condition(valid_condition, data: { score: "5x1", time: "15:10" })
           stub_with_valid_condition.should have_been_requested
         end
 
-        it 'should not send to invalid conditions' do
+        it "should not send to invalid conditions" do
           fcm = FCM.new(api_key)
-          fcm.send_to_topic_condition(invalid_condition, data: { score: '5x1', time: '15:10' })
+          fcm.send_to_topic_condition(invalid_condition, data: { score: "5x1", time: "15:10" })
           stub_with_invalid_condition.should_not have_been_requested
         end
 
-        it 'should not send to invalid topics in a condition' do
+        it "should not send to invalid topics in a condition" do
           fcm = FCM.new(api_key)
-          fcm.send_to_topic_condition(invalid_condition_topic, data: { score: '5x1', time: '15:10' })
+          fcm.send_to_topic_condition(invalid_condition_topic, data: { score: "5x1", time: "15:10" })
           stub_with_invalid_condition_topic.should_not have_been_requested
         end
       end
     end
 
-    context 'when send_notification responds with failure' do
+    context "when send_notification responds with failure" do
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
       subject { FCM.new(api_key) }
 
-      context 'on failure code 400' do
+      context "on failure code 400" do
         before do
           stub_request(:post, send_url).with(
             mock_request_attributes
           ).to_return(
             # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
-            body: '{}',
+            body: "{}",
             headers: {},
-            status: 400
+            status: 400,
           )
         end
-        it 'should not send notification due to 400' do
-          subject.send(registration_ids).should eq(body: '{}',
+        it "should not send notification due to 400" do
+          subject.send(registration_ids).should eq(body: "{}",
                                                    headers: {},
-                                                   response: 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.',
+                                                   response: "Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.",
                                                    status_code: 400)
         end
       end
 
-      context 'on failure code 401' do
+      context "on failure code 401" do
         before do
           stub_request(:post, send_url).with(
             mock_request_attributes
           ).to_return(
             # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
-            body: '{}',
+            body: "{}",
             headers: {},
-            status: 401
+            status: 401,
           )
         end
 
-        it 'should not send notification due to 401' do
-          subject.send(registration_ids).should eq(body: '{}',
+        it "should not send notification due to 401" do
+          subject.send(registration_ids).should eq(body: "{}",
                                                    headers: {},
-                                                   response: 'There was an error authenticating the sender account.',
+                                                   response: "There was an error authenticating the sender account.",
                                                    status_code: 401)
         end
       end
 
-      context 'on failure code 503' do
+      context "on failure code 503" do
         before do
           stub_request(:post, send_url).with(
             mock_request_attributes
           ).to_return(
             # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
-            body: '{}',
+            body: "{}",
             headers: {},
-            status: 503
+            status: 503,
           )
         end
 
-        it 'should not send notification due to 503' do
-          subject.send(registration_ids).should eq(body: '{}',
+        it "should not send notification due to 503" do
+          subject.send(registration_ids).should eq(body: "{}",
                                                    headers: {},
-                                                   response: 'Server is temporarily unavailable.',
+                                                   response: "Server is temporarily unavailable.",
                                                    status_code: 503)
         end
       end
 
-      context 'on failure code 5xx' do
+      context "on failure code 5xx" do
         before do
           stub_request(:post, send_url).with(
             mock_request_attributes
           ).to_return(
             # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
             body: '{"body-key" => "Body value"}',
-            headers: { 'header-key' => 'Header value' },
-            status: 599
+            headers: { "header-key" => "Header value" },
+            status: 599,
           )
         end
 
-        it 'should not send notification due to 599' do
+        it "should not send notification due to 599" do
           subject.send(registration_ids).should eq(body: '{"body-key" => "Body value"}',
-                                                   headers: { 'header-key' => 'Header value' },
-                                                   response: 'There was an internal error in the FCM server while trying to process the request.',
+                                                   headers: { "header-key" => "Header value" },
+                                                   response: "There was an internal error in the FCM server while trying to process the request.",
                                                    status_code: 599)
         end
       end
     end
 
-    context 'when send_notification responds canonical_ids' do
+    context "when send_notification responds canonical_ids" do
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
       let(:valid_response_body_with_canonical_ids) do
         {
-          failure: 0, canonical_ids: 1, results: [{ registration_id: '43', message_id: '0:1385025861956342%572c22801bb3' }]
+          failure: 0, canonical_ids: 1, results: [{ registration_id: "43", message_id: "0:1385025861956342%572c22801bb3" }],
         }
       end
 
@@ -284,35 +288,35 @@ describe FCM do
           # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
           body: valid_response_body_with_canonical_ids.to_json,
           headers: {},
-          status: 200
+          status: 200,
         )
       end
 
-      it 'should contain canonical_ids' do
+      it "should contain canonical_ids" do
         response = subject.send(registration_ids)
 
         response.should eq(headers: {},
-                           canonical_ids: [{ old: '42', new: '43' }],
+                           canonical_ids: [{ old: "42", new: "43" }],
                            not_registered_ids: [],
                            status_code: 200,
-                           response: 'success',
+                           response: "success",
                            body: '{"failure":0,"canonical_ids":1,"results":[{"registration_id":"43","message_id":"0:1385025861956342%572c22801bb3"}]}')
       end
     end
 
-    context 'when send_notification responds with NotRegistered' do
+    context "when send_notification responds with NotRegistered" do
       subject { FCM.new(api_key) }
 
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
       let(:valid_response_body_with_not_registered_ids) do
         {
-          canonical_ids: 0, failure: 1, results: [{ error: 'NotRegistered' }]
+          canonical_ids: 0, failure: 1, results: [{ error: "NotRegistered" }],
         }
       end
 
@@ -322,31 +326,31 @@ describe FCM do
         ).to_return(
           body: valid_response_body_with_not_registered_ids.to_json,
           headers: {},
-          status: 200
+          status: 200,
         )
       end
 
-      it 'should contain not_registered_ids' do
+      it "should contain not_registered_ids" do
         response = subject.send(registration_ids)
         response.should eq(
           headers: {},
           canonical_ids: [],
           not_registered_ids: registration_ids,
           status_code: 200,
-          response: 'success',
-          body: '{"canonical_ids":0,"failure":1,"results":[{"error":"NotRegistered"}]}'
+          response: "success",
+          body: '{"canonical_ids":0,"failure":1,"results":[{"error":"NotRegistered"}]}',
         )
       end
     end
   end
 
-  describe 'sending group notifications' do
+  describe "sending group notifications" do
     # TODO: refactor to should_behave_like
     let(:valid_request_headers) do
       {
         "Authorization" => "key=#{api_key}",
-        "Content-Type" => 'application/json',
-        "Project-Id" => project_id
+        "Content-Type" => "application/json",
+        "Project-Id" => project_id,
       }
     end
     let(:valid_response_body) do
@@ -357,24 +361,24 @@ describe FCM do
       {
         registration_ids: registration_ids,
         operation: "create",
-        notification_key_name: key_name
+        notification_key_name: key_name,
       }
     end
 
     subject { FCM.new(api_key) }
 
     # ref: https://firebase.google.com/docs/cloud-messaging/notifications#managing-device-groups-on-the-app-server
-    context 'create' do
+    context "create" do
       let(:valid_request_body) do
         default_valid_request_body.merge({
-          operation: "create"
+          operation: "create",
         })
       end
 
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
@@ -384,33 +388,33 @@ describe FCM do
         ).to_return(
           body: valid_response_body.to_json,
           headers: {},
-          status: 200
+          status: 200,
         )
       end
 
-      it 'should send a post request' do
+      it "should send a post request" do
         response = subject.create(key_name, project_id, registration_ids)
         response.should eq(
           headers: {},
           status_code: 200,
-          response: 'success',
-          body: valid_response_body.to_json
+          response: "success",
+          body: valid_response_body.to_json,
         )
       end
     end # create context
 
-    context 'add' do
+    context "add" do
       let(:valid_request_body) do
         default_valid_request_body.merge({
           operation: "add",
-          notification_key: notification_key
+          notification_key: notification_key,
         })
       end
 
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
@@ -420,33 +424,33 @@ describe FCM do
         ).to_return(
           body: valid_response_body.to_json,
           headers: {},
-          status: 200
+          status: 200,
         )
       end
 
-      it 'should send a post request' do
+      it "should send a post request" do
         response = subject.add(key_name, project_id, notification_key, registration_ids)
         response.should eq(
           headers: {},
           status_code: 200,
-          response: 'success',
-          body: valid_response_body.to_json
+          response: "success",
+          body: valid_response_body.to_json,
         )
       end
     end # add context
 
-    context 'remove' do
+    context "remove" do
       let(:valid_request_body) do
         default_valid_request_body.merge({
           operation: "remove",
-          notification_key: notification_key
+          notification_key: notification_key,
         })
       end
 
       let(:mock_request_attributes) do
         {
           body: valid_request_body.to_json,
-          headers: valid_request_headers
+          headers: valid_request_headers,
         }
       end
 
@@ -456,23 +460,42 @@ describe FCM do
         ).to_return(
           body: valid_response_body.to_json,
           headers: {},
-          status: 200
+          status: 200,
         )
       end
 
-      it 'should send a post request' do
+      it "should send a post request" do
         response = subject.remove(key_name, project_id, notification_key, registration_ids)
         response.should eq(
           headers: {},
           status_code: 200,
-          response: 'success',
-          body: valid_response_body.to_json
+          response: "success",
+          body: valid_response_body.to_json,
         )
       end
     end # remove context
   end
 
-  describe 'subscribing to a topic' do
+  describe "#recover_notification_key" do
+    it "sends a 'retrieve notification key' request" do
+      uri = "#{FCM::GROUP_NOTIFICATION_BASE_URI}/gcm/notification"
+      endpoint = stub_request(:get, uri).with(
+        headers: {
+          "Content-Type" => "application/json",
+          "Authorization" => "key=TEST_SERVER_KEY",
+          "project_id" => "TEST_PROJECT_ID",
+        },
+        query: { notification_key_name: "TEST_KEY_NAME" },
+      )
+      client = FCM.new("TEST_SERVER_KEY")
+
+      client.recover_notification_key("TEST_KEY_NAME", "TEST_PROJECT_ID")
+
+      expect(endpoint).to have_been_requested
+    end
+  end
+
+  describe "subscribing to a topic" do
     # TODO
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fcm
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.5
 platform: ruby
 authors:
 - Kashif Rasul
@@ -9,28 +9,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-16 00:00:00.000000000 Z
+date: 2021-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1'
 description: fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform
   messaging solution that lets you reliably deliver messages and notifications at
   no cost to Android, iOS or Web browsers.
 email:
-- kashif@spacialdb.com
-- shoaib@spacialdb.com
+- kashif@decision-labs.com
+- shoaib@decision-labs.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -65,7 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Reliably deliver messages and notifications via FCM