gcm 0.1.0 → 0.1.1
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/.travis.yml +3 -3
- data/LICENSE.txt +1 -1
- data/README.md +45 -21
- data/gcm.gemspec +1 -1
- data/lib/gcm.rb +53 -50
- data/spec/gcm_spec.rb +98 -112
- metadata +3 -3
checksums.yaml
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
---
|
|
2
2
|
SHA1:
|
|
3
|
-
metadata.gz:
|
|
4
|
-
data.tar.gz:
|
|
3
|
+
metadata.gz: 4a6bbfaf64cd67f8f2008a650c0321ca5667717d
|
|
4
|
+
data.tar.gz: 4ba52e54a1239330ee62cc69acebca3efad1ff03
|
|
5
5
|
SHA512:
|
|
6
|
-
metadata.gz:
|
|
7
|
-
data.tar.gz:
|
|
6
|
+
metadata.gz: 0d2418f9c98cb8f43194dddaba988cb61761d2142f19c05e8718780628ef07df519f3d19523212e987b7ce2ee86ff1b63fbeede50c364379b2c7090d75ce74d9
|
|
7
|
+
data.tar.gz: 5b2e606c93a2f79dc8c11fa4e0d442399ad23d6616740ef862ca8ad8840e04dc248f55fc0812558301ffd2ce7ac1f1d25b667e46e57a53d6417fe2caccf32d4c
|
data/.travis.yml
CHANGED
data/LICENSE.txt
CHANGED
data/README.md
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
# Google Cloud Messaging for Android (GCM)
|
|
2
|
-
[](http://travis-ci.org/spacialdb/gcm)
|
|
2
|
+
[](http://badge.fury.io/rb/gcm) [](http://travis-ci.org/spacialdb/gcm)
|
|
3
3
|
|
|
4
|
-
GCM sends notifications to Android devices via [GCM](
|
|
4
|
+
GCM sends notifications to Android devices via [GCM](https://developers.google.com/cloud-messaging/gcm).
|
|
5
5
|
|
|
6
6
|
##Installation
|
|
7
7
|
|
|
@@ -15,18 +15,18 @@ gem 'gcm'
|
|
|
15
15
|
|
|
16
16
|
##Requirements
|
|
17
17
|
|
|
18
|
-
An Android device running 2.3 or newer and an API key as per [GCM getting started guide](
|
|
18
|
+
An Android device running 2.3 (or newer) or an iOS device and an API key as per [GCM getting started guide](https://developers.google.com/cloud-messaging/android/start).
|
|
19
19
|
|
|
20
20
|
One of the following, tested Ruby versions:
|
|
21
21
|
|
|
22
|
-
* `1.9.3`
|
|
23
22
|
* `2.0.0`
|
|
24
|
-
* `2.1.
|
|
25
|
-
* `2.2.
|
|
23
|
+
* `2.1.8`
|
|
24
|
+
* `2.2.4`
|
|
25
|
+
* `2.3.0`
|
|
26
26
|
|
|
27
27
|
##Usage
|
|
28
28
|
|
|
29
|
-
For your server to send a message to one or more devices, you must first initialise a new `GCM` class with your
|
|
29
|
+
For your server to send a message to one or more devices, you must first initialise a new `GCM` class with your Api 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://developers.google.com/cloud-messaging/http-server-ref) like `data` or `time_to_live` etc. as a hash via the second optional argument to `send`.
|
|
30
30
|
|
|
31
31
|
Example sending notifications:
|
|
32
32
|
|
|
@@ -36,31 +36,31 @@ require 'gcm'
|
|
|
36
36
|
gcm = GCM.new("my_api_key")
|
|
37
37
|
# you can set option parameters in here
|
|
38
38
|
# - all options are pass to HTTParty method arguments
|
|
39
|
-
# - ref: https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb#
|
|
39
|
+
# - ref: https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb#L29-L60
|
|
40
40
|
# gcm = GCM.new("my_api_key", timeout: 3)
|
|
41
41
|
|
|
42
|
-
registration_ids= ["12", "13"] # an array of one or more client registration
|
|
42
|
+
registration_ids= ["12", "13"] # an array of one or more client registration tokens
|
|
43
43
|
options = {data: {score: "123"}, collapse_key: "updated_score"}
|
|
44
44
|
response = gcm.send(registration_ids, options)
|
|
45
45
|
```
|
|
46
46
|
|
|
47
|
-
Currently `response` is just a hash containing the response `body`, `headers` and `status`. Check [here](
|
|
47
|
+
Currently `response` is just a hash containing the response `body`, `headers` and `status`. Check [here](https://developers.google.com/cloud-messaging/http#response) to see how to interpret the responses.
|
|
48
48
|
|
|
49
|
-
##
|
|
49
|
+
## Device Group Messaging
|
|
50
50
|
|
|
51
|
-
With [
|
|
51
|
+
With [device group messaging](https://developers.google.com/cloud-messaging/notifications), you can send a single message to multiple instance of an app running on devices belonging to a group. Typically, "group" refers a set of different devices that belong to a single user. However, a group could also represent a set of devices where the app instance functions in a highly correlated manner. To use this feature, you will first need an initialised `GCM` class.
|
|
52
52
|
|
|
53
|
-
### Generate a Notification Key
|
|
54
|
-
Then you will need a notification key which you can create for a particular `key_name` which needs to be uniquely named per app in case you have multiple apps for the same `project_id`. This ensures that notifications only go to the intended target app. The `create` method will do this and return the token `notification_key
|
|
53
|
+
### Generate a Notification Key for device group
|
|
54
|
+
Then you will need a notification key which you can create for a particular `key_name` which needs to be uniquely named per app in case you have multiple apps for the same `project_id`. This ensures that notifications only go to the intended target app. The `create` method will do this and return the token `notification_key`, that represents the device group, in the response:
|
|
55
55
|
|
|
56
56
|
```ruby
|
|
57
57
|
response = gcm.create(key_name: "appUser-Chris",
|
|
58
|
-
project_id: "my_project_id",
|
|
58
|
+
project_id: "my_project_id", # https://developers.google.com/cloud-messaging/gcm#senderid
|
|
59
59
|
registration_ids:["4", "8", "15", "16", "23", "42"])
|
|
60
60
|
```
|
|
61
61
|
|
|
62
62
|
### Send to Notification Key
|
|
63
|
-
Now you can send a message to a particular `notification_key` via the `send_with_notification_key` method. This allows the server to send a single data to multiple app instances (typically on multiple devices) owned by a single user (instead of sending to registration
|
|
63
|
+
Now you can send a message to a particular `notification_key` via the `send_with_notification_key` method. This allows the server to send a single data to multiple app instances (typically on multiple devices) owned by a single user (instead of sending to some registration tokens). Note: the maximum number of members allowed for a `notification_key` is 20.
|
|
64
64
|
|
|
65
65
|
```ruby
|
|
66
66
|
response = gcm.send_with_notification_key("notification_key", {
|
|
@@ -68,9 +68,9 @@ response = gcm.send_with_notification_key("notification_key", {
|
|
|
68
68
|
collapse_key: "updated_score"})
|
|
69
69
|
```
|
|
70
70
|
|
|
71
|
-
### Add/Remove Registration
|
|
71
|
+
### Add/Remove Registration Tokens
|
|
72
72
|
|
|
73
|
-
You can also add/remove registration
|
|
73
|
+
You can also add/remove registration Tokens to/from a particular `notification_key` of some `project_id`. For example:
|
|
74
74
|
|
|
75
75
|
```ruby
|
|
76
76
|
response = gcm.add(key_name: "appUser-Chris",
|
|
@@ -84,6 +84,22 @@ response = gcm.remove(key_name: "appUser-Chris",
|
|
|
84
84
|
registration_ids:["8", "15"])
|
|
85
85
|
```
|
|
86
86
|
|
|
87
|
+
## Send Messages to Topics
|
|
88
|
+
|
|
89
|
+
GCM topic messaging allows your app server to send a message to multiple devices that have opted in to a particular topic. Based on the publish/subscribe model, topic messaging supports unlimited subscriptions per app. Sending to a topic is very similar to sending to an individual device or to a user group, in the sense that you can use the `gcm.send_with_notification_key()` method where the `noticiation_key` matches the regular expression `"/topics/[a-zA-Z0-9-_.~%]+"`:
|
|
90
|
+
|
|
91
|
+
```ruby
|
|
92
|
+
response = gcm.send_with_notification_key("/topics/yourTopic", {
|
|
93
|
+
data: {message: "This is a GCM Topic Message!"})
|
|
94
|
+
```
|
|
95
|
+
|
|
96
|
+
Or you can use the helper:
|
|
97
|
+
|
|
98
|
+
```ruby
|
|
99
|
+
response = gcm.send_to_topic("yourTopic", {
|
|
100
|
+
data: {message: "This is a GCM Topic Message!"})
|
|
101
|
+
```
|
|
102
|
+
|
|
87
103
|
## Blog Posts
|
|
88
104
|
|
|
89
105
|
* [How to send iOS and Android notifications from your Rails backend](http://juretriglav.si/how-to-send-ios-and-android-notifications-from-your-rails-backend/)
|
|
@@ -91,13 +107,21 @@ response = gcm.remove(key_name: "appUser-Chris",
|
|
|
91
107
|
* [GCM – 서버 만들기](http://susemi99.kr/1023)
|
|
92
108
|
* [ruby から gcm を使って android 端末へメッセージを送信する](http://qiita.com/ma2saka/items/5852308b7c2855eef552)
|
|
93
109
|
* [titanium alloy android push通知 by ruby](http://shoprev.hatenablog.com/entry/2014/08/30/202531)
|
|
110
|
+
* [Android Push Notifications via Rails](http://azukiweb.com/blog/2015/android-push-nots/)
|
|
94
111
|
|
|
95
|
-
##
|
|
112
|
+
## Mobile Clients
|
|
96
113
|
|
|
97
|
-
You can find a guide to implement an Android Client app to receive notifications here: [
|
|
114
|
+
You can find a guide to implement an Android Client app to receive notifications here: [Set up a GCM Client App on Android](https://developers.google.com/cloud-messaging/android/client).
|
|
115
|
+
|
|
116
|
+
The guide to set up an iOS app to get notifications is here: [Setting up a GCM Client App on iOS](https://developers.google.com/cloud-messaging/ios/client).
|
|
98
117
|
|
|
99
118
|
## ChangeLog
|
|
100
119
|
|
|
120
|
+
### 0.1.1
|
|
121
|
+
|
|
122
|
+
* Added helper `send_to_topic` to send messages to [topics](https://developers.google.com/cloud-messaging/topic-messaging).
|
|
123
|
+
* Fixed documentation and updated base uri to `https://gcm-http.googleapis.com/gcm`
|
|
124
|
+
|
|
101
125
|
### 0.1.0
|
|
102
126
|
* Added `send_with_notification_key` to send message to a notification key since the documented API for it is [wrong]( http://stackoverflow.com/questions/19720767/gcm-user-notifications-missing-registration-ids-field/25183892#25183892).
|
|
103
127
|
|
|
@@ -121,7 +145,7 @@ You can find a guide to implement an Android Client app to receive notifications
|
|
|
121
145
|
|
|
122
146
|
##MIT License
|
|
123
147
|
|
|
124
|
-
* Copyright (c)
|
|
148
|
+
* Copyright (c) 2016 Kashif Rasul and Shoaib Burq. See LICENSE.txt for details.
|
|
125
149
|
|
|
126
150
|
##Many thanks to all the contributors
|
|
127
151
|
|
data/gcm.gemspec
CHANGED
|
@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
|
|
|
3
3
|
|
|
4
4
|
Gem::Specification.new do |s|
|
|
5
5
|
s.name = "gcm"
|
|
6
|
-
s.version = "0.1.
|
|
6
|
+
s.version = "0.1.1"
|
|
7
7
|
s.platform = Gem::Platform::RUBY
|
|
8
8
|
s.authors = ["Kashif Rasul", "Shoaib Burq"]
|
|
9
9
|
s.email = ["kashif@spacialdb.com", "shoaib@spacialdb.com"]
|
data/lib/gcm.rb
CHANGED
|
@@ -4,7 +4,7 @@ require 'json'
|
|
|
4
4
|
|
|
5
5
|
class GCM
|
|
6
6
|
include HTTParty
|
|
7
|
-
base_uri 'https://
|
|
7
|
+
base_uri 'https://gcm-http.googleapis.com/gcm'
|
|
8
8
|
default_timeout 30
|
|
9
9
|
format :json
|
|
10
10
|
|
|
@@ -31,25 +31,24 @@ class GCM
|
|
|
31
31
|
post_body = build_post_body(registration_ids, options)
|
|
32
32
|
|
|
33
33
|
params = {
|
|
34
|
-
:
|
|
35
|
-
:
|
|
34
|
+
body: post_body.to_json,
|
|
35
|
+
headers: {
|
|
36
36
|
'Authorization' => "key=#{@api_key}",
|
|
37
|
-
'Content-Type' => 'application/json'
|
|
37
|
+
'Content-Type' => 'application/json'
|
|
38
38
|
}
|
|
39
39
|
}
|
|
40
40
|
response = self.class.post('/send', params.merge(@client_options))
|
|
41
41
|
build_response(response, registration_ids)
|
|
42
42
|
end
|
|
43
|
-
|
|
43
|
+
alias send send_notification
|
|
44
44
|
|
|
45
|
-
def create_notification_key(key_name, project_id, registration_ids=[])
|
|
46
|
-
post_body = build_post_body(registration_ids,
|
|
47
|
-
|
|
48
|
-
:notification_key_name => key_name})
|
|
45
|
+
def create_notification_key(key_name, project_id, registration_ids = [])
|
|
46
|
+
post_body = build_post_body(registration_ids, operation: 'create',
|
|
47
|
+
notification_key_name: key_name)
|
|
49
48
|
|
|
50
49
|
params = {
|
|
51
|
-
:
|
|
52
|
-
:
|
|
50
|
+
body: post_body.to_json,
|
|
51
|
+
headers: {
|
|
53
52
|
'Content-Type' => 'application/json',
|
|
54
53
|
'project_id' => project_id,
|
|
55
54
|
'Authorization' => "key=#{@api_key}"
|
|
@@ -59,17 +58,16 @@ class GCM
|
|
|
59
58
|
response = self.class.post('/notification', params.merge(@client_options))
|
|
60
59
|
build_response(response)
|
|
61
60
|
end
|
|
62
|
-
|
|
61
|
+
alias create create_notification_key
|
|
63
62
|
|
|
64
63
|
def add_registration_ids(key_name, project_id, notification_key, registration_ids)
|
|
65
|
-
post_body = build_post_body(registration_ids,
|
|
66
|
-
|
|
67
|
-
|
|
68
|
-
:notification_key => notification_key})
|
|
64
|
+
post_body = build_post_body(registration_ids, operation: 'add',
|
|
65
|
+
notification_key_name: key_name,
|
|
66
|
+
notification_key: notification_key)
|
|
69
67
|
|
|
70
68
|
params = {
|
|
71
|
-
:
|
|
72
|
-
:
|
|
69
|
+
body: post_body.to_json,
|
|
70
|
+
headers: {
|
|
73
71
|
'Content-Type' => 'application/json',
|
|
74
72
|
'project_id' => project_id,
|
|
75
73
|
'Authorization' => "key=#{@api_key}"
|
|
@@ -79,17 +77,16 @@ class GCM
|
|
|
79
77
|
response = self.class.post('/notification', params.merge(@client_options))
|
|
80
78
|
build_response(response)
|
|
81
79
|
end
|
|
82
|
-
|
|
80
|
+
alias add add_registration_ids
|
|
83
81
|
|
|
84
82
|
def remove_registration_ids(key_name, project_id, notification_key, registration_ids)
|
|
85
|
-
post_body = build_post_body(registration_ids,
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
:notification_key => notification_key})
|
|
83
|
+
post_body = build_post_body(registration_ids, operation: 'remove',
|
|
84
|
+
notification_key_name: key_name,
|
|
85
|
+
notification_key: notification_key)
|
|
89
86
|
|
|
90
87
|
params = {
|
|
91
|
-
:
|
|
92
|
-
:
|
|
88
|
+
body: post_body.to_json,
|
|
89
|
+
headers: {
|
|
93
90
|
'Content-Type' => 'application/json',
|
|
94
91
|
'project_id' => project_id,
|
|
95
92
|
'Authorization' => "key=#{@api_key}"
|
|
@@ -99,45 +96,51 @@ class GCM
|
|
|
99
96
|
response = self.class.post('/notification', params.merge(@client_options))
|
|
100
97
|
build_response(response)
|
|
101
98
|
end
|
|
102
|
-
|
|
99
|
+
alias remove remove_registration_ids
|
|
103
100
|
|
|
104
|
-
def send_with_notification_key(notification_key, options)
|
|
105
|
-
body = { :
|
|
101
|
+
def send_with_notification_key(notification_key, options = {})
|
|
102
|
+
body = { to: notification_key }.merge(options)
|
|
106
103
|
|
|
107
104
|
params = {
|
|
108
|
-
:
|
|
109
|
-
:
|
|
105
|
+
body: body.to_json,
|
|
106
|
+
headers: {
|
|
110
107
|
'Authorization' => "key=#{@api_key}",
|
|
111
|
-
'Content-Type' => 'application/json'
|
|
108
|
+
'Content-Type' => 'application/json'
|
|
112
109
|
}
|
|
113
110
|
}
|
|
114
111
|
response = self.class.post('/send', params.merge(@client_options))
|
|
115
112
|
build_response(response)
|
|
116
113
|
end
|
|
117
114
|
|
|
115
|
+
def send_to_topic(topic, options = {})
|
|
116
|
+
if topic =~ /[a-zA-Z0-9\-_.~%]+/
|
|
117
|
+
send_with_notification_key('/topics/' + topic, options)
|
|
118
|
+
end
|
|
119
|
+
end
|
|
120
|
+
|
|
118
121
|
private
|
|
119
122
|
|
|
120
|
-
def build_post_body(registration_ids, options={})
|
|
121
|
-
{ :
|
|
123
|
+
def build_post_body(registration_ids, options = {})
|
|
124
|
+
{ registration_ids: registration_ids }.merge(options)
|
|
122
125
|
end
|
|
123
126
|
|
|
124
|
-
def build_response(response, registration_ids=[])
|
|
127
|
+
def build_response(response, registration_ids = [])
|
|
125
128
|
body = response.body || {}
|
|
126
|
-
response_hash = {:
|
|
129
|
+
response_hash = { body: body, headers: response.headers, status_code: response.code }
|
|
127
130
|
case response.code
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
131
|
+
when 200
|
|
132
|
+
response_hash[:response] = 'success'
|
|
133
|
+
body = JSON.parse(body) unless body.empty?
|
|
134
|
+
response_hash[:canonical_ids] = build_canonical_ids(body, registration_ids) unless registration_ids.empty?
|
|
135
|
+
response_hash[:not_registered_ids] = build_not_registered_ids(body, registration_ids) unless registration_ids.empty?
|
|
136
|
+
when 400
|
|
137
|
+
response_hash[:response] = 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.'
|
|
138
|
+
when 401
|
|
139
|
+
response_hash[:response] = 'There was an error authenticating the sender account.'
|
|
140
|
+
when 503
|
|
141
|
+
response_hash[:response] = 'Server is temporarily unavailable.'
|
|
142
|
+
when 500..599
|
|
143
|
+
response_hash[:response] = 'There was an internal error in the GCM server while trying to process the request.'
|
|
141
144
|
end
|
|
142
145
|
response_hash
|
|
143
146
|
end
|
|
@@ -147,7 +150,7 @@ class GCM
|
|
|
147
150
|
unless body.empty?
|
|
148
151
|
if body['canonical_ids'] > 0
|
|
149
152
|
body['results'].each_with_index do |result, index|
|
|
150
|
-
canonical_ids << { :
|
|
153
|
+
canonical_ids << { old: registration_ids[index], new: result['registration_id'] } if has_canonical_id?(result)
|
|
151
154
|
end
|
|
152
155
|
end
|
|
153
156
|
end
|
|
@@ -158,7 +161,7 @@ class GCM
|
|
|
158
161
|
not_registered_ids = []
|
|
159
162
|
unless body.empty?
|
|
160
163
|
if body['failure'] > 0
|
|
161
|
-
body['results'].each_with_index do |result,index|
|
|
164
|
+
body['results'].each_with_index do |result, index|
|
|
162
165
|
not_registered_ids << registration_id[index] if is_not_registered?(result)
|
|
163
166
|
end
|
|
164
167
|
end
|
data/spec/gcm_spec.rb
CHANGED
|
@@ -1,38 +1,38 @@
|
|
|
1
1
|
require 'spec_helper'
|
|
2
2
|
|
|
3
3
|
describe GCM do
|
|
4
|
-
let(:send_url) { "#{GCM
|
|
4
|
+
let(:send_url) { "#{GCM.base_uri}/send" }
|
|
5
5
|
|
|
6
|
-
it
|
|
7
|
-
expect {GCM.new}.to raise_error
|
|
6
|
+
it 'should raise an error if the api key is not provided' do
|
|
7
|
+
expect { GCM.new }.to raise_error
|
|
8
8
|
end
|
|
9
9
|
|
|
10
|
-
it
|
|
10
|
+
it 'should raise error if time_to_live is given' do
|
|
11
11
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#send-msg
|
|
12
12
|
end
|
|
13
13
|
|
|
14
|
-
describe
|
|
14
|
+
describe 'sending notification' do
|
|
15
15
|
let(:api_key) { 'AIzaSyB-1uEai2WiUapxCs2Q0GZYzPu7Udno5aA' }
|
|
16
|
-
let(:registration_ids) { [
|
|
16
|
+
let(:registration_ids) { ['42'] }
|
|
17
17
|
let(:valid_request_body) do
|
|
18
|
-
{ :
|
|
18
|
+
{ registration_ids: registration_ids }
|
|
19
19
|
end
|
|
20
20
|
let(:valid_request_headers) do
|
|
21
21
|
{
|
|
22
|
-
|
|
23
|
-
|
|
22
|
+
'Content-Type' => 'application/json',
|
|
23
|
+
'Authorization' => "key=#{api_key}"
|
|
24
24
|
}
|
|
25
25
|
end
|
|
26
26
|
|
|
27
27
|
let(:stub_gcm_send_request) do
|
|
28
28
|
stub_request(:post, send_url).with(
|
|
29
|
-
:
|
|
30
|
-
:
|
|
29
|
+
body: valid_request_body.to_json,
|
|
30
|
+
headers: valid_request_headers
|
|
31
31
|
).to_return(
|
|
32
32
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
33
|
-
:
|
|
34
|
-
:
|
|
35
|
-
:
|
|
33
|
+
body: '{}',
|
|
34
|
+
headers: {},
|
|
35
|
+
status: 200
|
|
36
36
|
)
|
|
37
37
|
end
|
|
38
38
|
|
|
@@ -40,7 +40,7 @@ describe GCM do
|
|
|
40
40
|
uri = URI.parse(send_url)
|
|
41
41
|
uri.user = 'a'
|
|
42
42
|
uri.password = 'b'
|
|
43
|
-
stub_request(:post, uri.to_s).to_return(:
|
|
43
|
+
stub_request(:post, uri.to_s).to_return(body: '{}', headers: {}, status: 200)
|
|
44
44
|
end
|
|
45
45
|
|
|
46
46
|
before(:each) do
|
|
@@ -48,212 +48,198 @@ describe GCM do
|
|
|
48
48
|
stub_gcm_send_request_with_basic_auth
|
|
49
49
|
end
|
|
50
50
|
|
|
51
|
-
it
|
|
51
|
+
it 'should send notification using POST to GCM server' do
|
|
52
52
|
gcm = GCM.new(api_key)
|
|
53
|
-
gcm.send(registration_ids).should eq(
|
|
53
|
+
gcm.send(registration_ids).should eq(response: 'success', body: '{}', headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
|
|
54
54
|
stub_gcm_send_request.should have_been_made.times(1)
|
|
55
55
|
end
|
|
56
56
|
|
|
57
|
-
it
|
|
58
|
-
gcm = GCM.new(api_key, basic_auth: {username: 'a', password: 'b'})
|
|
59
|
-
gcm.send(registration_ids).should eq(
|
|
57
|
+
it 'should use basic authentication provided by options' do
|
|
58
|
+
gcm = GCM.new(api_key, basic_auth: { username: 'a', password: 'b' })
|
|
59
|
+
gcm.send(registration_ids).should eq(response: 'success', body: '{}', headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
|
|
60
60
|
stub_gcm_send_request_with_basic_auth.should have_been_made.times(1)
|
|
61
61
|
end
|
|
62
62
|
|
|
63
|
-
context
|
|
64
|
-
let!(:stub_with_data)
|
|
65
|
-
stub_request(:post, send_url)
|
|
66
|
-
with(:
|
|
67
|
-
|
|
68
|
-
to_return(:
|
|
69
|
-
|
|
63
|
+
context 'send notification with data' do
|
|
64
|
+
let!(:stub_with_data) do
|
|
65
|
+
stub_request(:post, send_url)
|
|
66
|
+
.with(body: '{"registration_ids":["42"],"data":{"score":"5x1","time":"15:10"}}',
|
|
67
|
+
headers: valid_request_headers)
|
|
68
|
+
.to_return(status: 200, body: '', headers: {})
|
|
69
|
+
end
|
|
70
70
|
before do
|
|
71
71
|
end
|
|
72
|
-
it
|
|
72
|
+
it 'should send the data in a post request to gcm' do
|
|
73
73
|
gcm = GCM.new(api_key)
|
|
74
|
-
gcm.send(registration_ids,
|
|
74
|
+
gcm.send(registration_ids, data: { score: '5x1', time: '15:10' })
|
|
75
75
|
stub_with_data.should have_been_requested
|
|
76
76
|
end
|
|
77
77
|
end
|
|
78
78
|
|
|
79
|
-
context
|
|
80
|
-
|
|
79
|
+
context 'when send_notification responds with failure' do
|
|
81
80
|
let(:mock_request_attributes) do
|
|
82
81
|
{
|
|
83
|
-
:
|
|
84
|
-
:
|
|
82
|
+
body: valid_request_body.to_json,
|
|
83
|
+
headers: valid_request_headers
|
|
85
84
|
}
|
|
86
85
|
end
|
|
87
86
|
|
|
88
87
|
subject { GCM.new(api_key) }
|
|
89
88
|
|
|
90
|
-
context
|
|
89
|
+
context 'on failure code 400' do
|
|
91
90
|
before do
|
|
92
91
|
stub_request(:post, send_url).with(
|
|
93
92
|
mock_request_attributes
|
|
94
93
|
).to_return(
|
|
95
94
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
96
|
-
:
|
|
97
|
-
:
|
|
98
|
-
:
|
|
95
|
+
body: '{}',
|
|
96
|
+
headers: {},
|
|
97
|
+
status: 400
|
|
99
98
|
)
|
|
100
99
|
end
|
|
101
|
-
it
|
|
102
|
-
subject.send(registration_ids).should eq({
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
:status_code => 400
|
|
107
|
-
})
|
|
100
|
+
it 'should not send notification due to 400' do
|
|
101
|
+
subject.send(registration_ids).should eq(body: '{}',
|
|
102
|
+
headers: {},
|
|
103
|
+
response: 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.',
|
|
104
|
+
status_code: 400)
|
|
108
105
|
end
|
|
109
106
|
end
|
|
110
107
|
|
|
111
|
-
context
|
|
108
|
+
context 'on failure code 401' do
|
|
112
109
|
before do
|
|
113
110
|
stub_request(:post, send_url).with(
|
|
114
111
|
mock_request_attributes
|
|
115
112
|
).to_return(
|
|
116
113
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
117
|
-
:
|
|
118
|
-
:
|
|
119
|
-
:
|
|
114
|
+
body: '{}',
|
|
115
|
+
headers: {},
|
|
116
|
+
status: 401
|
|
120
117
|
)
|
|
121
118
|
end
|
|
122
119
|
|
|
123
|
-
it
|
|
124
|
-
subject.send(registration_ids).should eq({
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
:status_code => 401
|
|
129
|
-
})
|
|
120
|
+
it 'should not send notification due to 401' do
|
|
121
|
+
subject.send(registration_ids).should eq(body: '{}',
|
|
122
|
+
headers: {},
|
|
123
|
+
response: 'There was an error authenticating the sender account.',
|
|
124
|
+
status_code: 401)
|
|
130
125
|
end
|
|
131
126
|
end
|
|
132
127
|
|
|
133
|
-
context
|
|
128
|
+
context 'on failure code 503' do
|
|
134
129
|
before do
|
|
135
130
|
stub_request(:post, send_url).with(
|
|
136
131
|
mock_request_attributes
|
|
137
132
|
).to_return(
|
|
138
133
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
139
|
-
:
|
|
140
|
-
:
|
|
141
|
-
:
|
|
134
|
+
body: '{}',
|
|
135
|
+
headers: {},
|
|
136
|
+
status: 503
|
|
142
137
|
)
|
|
143
138
|
end
|
|
144
139
|
|
|
145
|
-
it
|
|
146
|
-
subject.send(registration_ids).should eq({
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
:status_code => 503
|
|
151
|
-
})
|
|
140
|
+
it 'should not send notification due to 503' do
|
|
141
|
+
subject.send(registration_ids).should eq(body: '{}',
|
|
142
|
+
headers: {},
|
|
143
|
+
response: 'Server is temporarily unavailable.',
|
|
144
|
+
status_code: 503)
|
|
152
145
|
end
|
|
153
146
|
end
|
|
154
147
|
|
|
155
|
-
context
|
|
148
|
+
context 'on failure code 5xx' do
|
|
156
149
|
before do
|
|
157
150
|
stub_request(:post, send_url).with(
|
|
158
151
|
mock_request_attributes
|
|
159
152
|
).to_return(
|
|
160
153
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
161
|
-
:
|
|
162
|
-
:
|
|
163
|
-
:
|
|
154
|
+
body: '{"body-key" => "Body value"}',
|
|
155
|
+
headers: { 'header-key' => 'Header value' },
|
|
156
|
+
status: 599
|
|
164
157
|
)
|
|
165
158
|
end
|
|
166
159
|
|
|
167
|
-
it
|
|
168
|
-
subject.send(registration_ids).should eq({
|
|
169
|
-
|
|
170
|
-
|
|
171
|
-
|
|
172
|
-
:status_code => 599
|
|
173
|
-
})
|
|
160
|
+
it 'should not send notification due to 599' do
|
|
161
|
+
subject.send(registration_ids).should eq(body: '{"body-key" => "Body value"}',
|
|
162
|
+
headers: { 'header-key' => ['Header value'] },
|
|
163
|
+
response: 'There was an internal error in the GCM server while trying to process the request.',
|
|
164
|
+
status_code: 599)
|
|
174
165
|
end
|
|
175
166
|
end
|
|
176
167
|
end
|
|
177
168
|
|
|
178
|
-
context
|
|
179
|
-
|
|
169
|
+
context 'when send_notification responds canonical_ids' do
|
|
180
170
|
let(:mock_request_attributes) do
|
|
181
171
|
{
|
|
182
|
-
|
|
183
|
-
|
|
172
|
+
body: valid_request_body.to_json,
|
|
173
|
+
headers: valid_request_headers
|
|
184
174
|
}
|
|
185
175
|
end
|
|
186
176
|
|
|
187
177
|
let(:valid_response_body_with_canonical_ids) do
|
|
188
178
|
{
|
|
189
|
-
:
|
|
179
|
+
failure: 0, canonical_ids: 1, results: [{ registration_id: '43', message_id: '0:1385025861956342%572c22801bb3' }]
|
|
190
180
|
}
|
|
191
181
|
end
|
|
192
182
|
|
|
193
183
|
subject { GCM.new(api_key) }
|
|
194
184
|
|
|
195
|
-
|
|
196
185
|
before do
|
|
197
186
|
stub_request(:post, send_url).with(
|
|
198
|
-
|
|
187
|
+
mock_request_attributes
|
|
199
188
|
).to_return(
|
|
200
189
|
# ref: http://developer.android.com/guide/google/gcm/gcm.html#success
|
|
201
|
-
:
|
|
202
|
-
:
|
|
203
|
-
:
|
|
190
|
+
body: valid_response_body_with_canonical_ids.to_json,
|
|
191
|
+
headers: {},
|
|
192
|
+
status: 200
|
|
204
193
|
)
|
|
205
194
|
end
|
|
206
195
|
|
|
207
|
-
it
|
|
196
|
+
it 'should contain canonical_ids' do
|
|
208
197
|
response = subject.send(registration_ids)
|
|
209
198
|
|
|
210
|
-
response.should eq({
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
:body => "{\"failure\":0,\"canonical_ids\":1,\"results\":[{\"registration_id\":\"43\",\"message_id\":\"0:1385025861956342%572c22801bb3\"}]}"
|
|
217
|
-
})
|
|
199
|
+
response.should eq(headers: {},
|
|
200
|
+
canonical_ids: [{ old: '42', new: '43' }],
|
|
201
|
+
not_registered_ids: [],
|
|
202
|
+
status_code: 200,
|
|
203
|
+
response: 'success',
|
|
204
|
+
body: '{"failure":0,"canonical_ids":1,"results":[{"registration_id":"43","message_id":"0:1385025861956342%572c22801bb3"}]}')
|
|
218
205
|
end
|
|
219
206
|
end
|
|
220
207
|
|
|
221
|
-
context
|
|
222
|
-
|
|
208
|
+
context 'when send_notification responds with NotRegistered' do
|
|
223
209
|
subject { GCM.new(api_key) }
|
|
224
210
|
|
|
225
211
|
let(:mock_request_attributes) do
|
|
226
212
|
{
|
|
227
|
-
|
|
228
|
-
|
|
213
|
+
body: valid_request_body.to_json,
|
|
214
|
+
headers: valid_request_headers
|
|
229
215
|
}
|
|
230
216
|
end
|
|
231
217
|
|
|
232
218
|
let(:valid_response_body_with_not_registered_ids) do
|
|
233
219
|
{
|
|
234
|
-
:
|
|
220
|
+
canonical_ids: 0, failure: 1, results: [{ error: 'NotRegistered' }]
|
|
235
221
|
}
|
|
236
222
|
end
|
|
237
223
|
|
|
238
224
|
before do
|
|
239
|
-
stub_request(:post,send_url).with(
|
|
225
|
+
stub_request(:post, send_url).with(
|
|
240
226
|
mock_request_attributes
|
|
241
227
|
).to_return(
|
|
242
|
-
:
|
|
243
|
-
:
|
|
244
|
-
:
|
|
228
|
+
body: valid_response_body_with_not_registered_ids.to_json,
|
|
229
|
+
headers: {},
|
|
230
|
+
status: 200
|
|
245
231
|
)
|
|
246
232
|
end
|
|
247
233
|
|
|
248
|
-
it
|
|
234
|
+
it 'should contain not_registered_ids' do
|
|
249
235
|
response = subject.send(registration_ids)
|
|
250
236
|
response.should eq(
|
|
251
|
-
:
|
|
252
|
-
:
|
|
253
|
-
:
|
|
254
|
-
:
|
|
255
|
-
:
|
|
256
|
-
:
|
|
237
|
+
headers: {},
|
|
238
|
+
canonical_ids: [],
|
|
239
|
+
not_registered_ids: registration_ids,
|
|
240
|
+
status_code: 200,
|
|
241
|
+
response: 'success',
|
|
242
|
+
body: '{"canonical_ids":0,"failure":1,"results":[{"error":"NotRegistered"}]}'
|
|
257
243
|
)
|
|
258
244
|
end
|
|
259
245
|
end
|
metadata
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: gcm
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.1.
|
|
4
|
+
version: 0.1.1
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- Kashif Rasul
|
|
@@ -9,7 +9,7 @@ authors:
|
|
|
9
9
|
autorequire:
|
|
10
10
|
bindir: bin
|
|
11
11
|
cert_chain: []
|
|
12
|
-
date:
|
|
12
|
+
date: 2016-02-04 00:00:00.000000000 Z
|
|
13
13
|
dependencies:
|
|
14
14
|
- !ruby/object:Gem::Dependency
|
|
15
15
|
name: httparty
|
|
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
|
|
|
79
79
|
version: '0'
|
|
80
80
|
requirements: []
|
|
81
81
|
rubyforge_project: gcm
|
|
82
|
-
rubygems_version: 2.
|
|
82
|
+
rubygems_version: 2.5.2
|
|
83
83
|
signing_key:
|
|
84
84
|
specification_version: 4
|
|
85
85
|
summary: send data to Android applications on Android devices
|