15 | * There are cases when a request is accept and the message successfully 16 | * created, but GCM has a canonical registration id for that device. In this 17 | * case, the server should update the registration id to avoid rejected requests 18 | * in the future. 19 | * 20 | *
21 | * In a nutshell, the workflow to handle a result is: 22 | *
23 | * - Call {@link #getMessageId()}:
24 | * - {@literal null} means error, call {@link #getErrorCodeName()}
25 | * - non-{@literal null} means the message was created:
26 | * - Call {@link #getCanonicalRegistrationId()}
27 | * - if it returns {@literal null}, do nothing.
28 | * - otherwise, update the server datastore with the new id.
29 | *
30 | */
31 | class Result {
32 |
33 | private $messageId;
34 | private $canonicalRegistrationId;
35 | private $errorCode;
36 |
37 | /**
38 | * Sets the message id
39 | *
40 | * @param string $messageId
41 | */
42 | public function setMessageId($messageId) {
43 | $this->messageId = $messageId;
44 | }
45 |
46 | /**
47 | * Gets the message id, if any
48 | *
49 | * @return string
50 | */
51 | public function getMessageId() {
52 | return $this->messageId;
53 | }
54 |
55 | /**
56 | * Sets the canonical registration id
57 | *
58 | * @param string $canonicalRegistrationId
59 | */
60 | public function setCanonicalRegistrationId($canonicalRegistrationId) {
61 | $this->canonicalRegistrationId = $canonicalRegistrationId;
62 | }
63 |
64 | /**
65 | * Gets the canonical registration id, if any
66 | *
67 | * @return string
68 | */
69 | public function getCanonicalRegistrationId() {
70 | return $this->canonicalRegistrationId;
71 | }
72 |
73 | /**
74 | * Sets the error code
75 | *
76 | * @param string $errorCode
77 | */
78 | public function setErrorCode($errorCode) {
79 | $this->errorCode = $errorCode;
80 | }
81 |
82 | /**
83 | * Gets the error code, if any
84 | *
85 | * @return string
86 | */
87 | public function getErrorCode() {
88 | return $this->errorCode;
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/src/PHP_GCM/Sender.php:
--------------------------------------------------------------------------------
1 | key = $key;
40 | $this->retries = 3;
41 | $this->certificatePath = null;
42 | }
43 |
44 | /**
45 | * Allows a non-default certificate chain to be used when communicating
46 | * with Google APIs.
47 | *
48 | * @param string $certificatePath full qualified path to a certificate store.
49 | * @return Sender Returns the instance of this Sender for method chaining.
50 | */
51 | public function certificatePath($certificatePath) {
52 | $this->certificatePath = $certificatePath;
53 | return $this;
54 | }
55 |
56 | /**
57 | * Set the number of retries to attempt in the case of service unavailability. Defaults to 3 retries.
58 | *
59 | * Note: Retries use exponential back-off in the case of service unavailability and
60 | * could block the calling thread for many seconds.
61 | *
62 | * @param int $retries number of retries in case of service unavailability errors.
63 | * @return Sender Returns the instance of this Sender for method chaining.
64 | */
65 | public function retries($retries) {
66 | $this->retries = $retries;
67 | return $this;
68 | }
69 |
70 | /**
71 | * Sends a GCM message to one or more devices, retrying up to the specified
72 | * number of retries in case of unavailability.
73 | *
74 | * Note: Retries use exponential back-off in the case of service unavailability and
75 | * could block the calling thread for many seconds.
76 | *
77 | * @param Message $message to be sent
78 | * @param string|array $registrationIds String registration id or an array of registration ids of the devices where the message will be sent.
79 | * @return AggregateResult combined result of all requests made.
80 | * @throws \InvalidArgumentException If registrationIds is empty
81 | * @throws InvalidRequestException If GCM did not return a 200 after the specified number of retries.
82 | */
83 | public function send(Message $message, $registrationIds) {
84 | if (empty($registrationIds)) {
85 | throw new \InvalidArgumentException('registrationIds cannot be empty');
86 | }
87 |
88 | if (!is_array($registrationIds)) {
89 | $registrationIds = array($registrationIds);
90 | }
91 |
92 | $chunks = array_chunk($registrationIds, 1000);
93 |
94 | $multicastResults = array();
95 | foreach($chunks as $chunk) {
96 | $attempt = 0;
97 | $backoff = self::BACKOFF_INITIAL_DELAY;
98 | $results = array();
99 | $unsentRegistrationIds = array_values($chunk);
100 | $multicastIds = array();
101 | do {
102 | $attempt++;
103 |
104 | try {
105 | $multicastResult = $this->makeRequest($message, $unsentRegistrationIds);
106 | $multicastIds[] = $multicastResult->getMulticastId();
107 | $unsentRegistrationIds = $this->updateStatus($unsentRegistrationIds, $results, $multicastResult);
108 | } catch (InvalidRequestException $e) {
109 | if ($attempt >= $this->retries) {
110 | throw $e;
111 | }
112 | }
113 |
114 | $tryAgain = count($unsentRegistrationIds) > 0 && $attempt <= $this->retries;
115 | if ($tryAgain) {
116 | $sleepTime = $backoff / 2 + rand(0, $backoff);
117 | sleep($sleepTime / 1000);
118 | if (2 * $backoff < self::MAX_BACKOFF_DELAY) {
119 | $backoff *= 2;
120 | }
121 | }
122 | } while ($tryAgain);
123 |
124 | $success = $failure = $canonicalIds = 0;
125 | foreach ($results as $result) {
126 | if (!is_null($result->getMessageId())) {
127 | $success++;
128 |
129 | if (!is_null($result->getCanonicalRegistrationId())) {
130 | $canonicalIds++;
131 | }
132 | } else {
133 | $failure++;
134 | }
135 | }
136 |
137 | $result = new MulticastResult($success, $failure, $canonicalIds, $multicastIds[0], $multicastIds);
138 | foreach ($registrationIds as $registrationId) {
139 | $result->addResult($results[$registrationId]);
140 | }
141 |
142 | $multicastResults[] = $result;
143 | }
144 |
145 | return new AggregateResult($multicastResults);
146 | }
147 |
148 | /**
149 | * Creates a device group under the specified senderId with the specificed notificationKeyName and adds all
150 | * devices in registrationIds to the group.
151 | *
152 | * @param $senderId A unique numerical value created when you configure your API project
153 | * (given as "Project Number" in the Google Developers Console). The sender ID is used in the registration
154 | * process to identify an app server that is permitted to send messages to the client app.
155 | * @param $notificationKeyName a name or identifier (e.g., it can be a username) that is unique to a given group.
156 | * The notificationKeyName and notificationKey are unique to a group of registration tokens. It is important
157 | * that notificationKeyName is unique per client app if you have multiple client apps for the same sender ID.
158 | * This ensures that messages only go to the intended target app.
159 | * @param string|array $registrationIds String registration id or an array of registration ids of the devices to add to the group.
160 | * @return string notificationKey used to send a notification to all the devices in the group.
161 | * @throws \InvalidArgumentException If senderId, notificationKeyName or registrationIds are empty.
162 | * @throws InvalidRequestException If GCM did not return a 200.
163 | */
164 | public function createDeviceGroup($senderId, $notificationKeyName, array $registrationIds) {
165 | return $this->performDeviceGroupOperation($senderId, $notificationKeyName, null, $registrationIds, self::DEVICE_GROUP_CREATE);
166 | }
167 |
168 | /**
169 | * Adds devices to an existing device group.
170 | *
171 | * @param $senderId A unique numerical value created when you configure your API project
172 | * (given as "Project Number" in the Google Developers Console). The sender ID is used in the registration
173 | * process to identify an app server that is permitted to send messages to the client app.
174 | * @param $notificationKeyName a name or identifier (e.g., it can be a username) that is unique to a given group.
175 | * The notificationKeyName and notificationKey are unique to a group of registration tokens. It is important
176 | * that notificationKeyName is unique per client app if you have multiple client apps for the same sender ID.
177 | * This ensures that messages only go to the intended target app.
178 | * @param $notificationKey the notificationKey returned from Sender#createDeviceGroup.
179 | * @param string|array $registrationIds String registration id or an array of registration ids of the devices to add to the group.
180 | * @return string notificationKey used to send a notification to all the devices in the group.
181 | * @throws \InvalidArgumentException If senderId, notificationKeyName, notificationKey or registrationIds are empty.
182 | * @throws InvalidRequestException If GCM did not return a 200.
183 | */
184 | public function addDeviceToGroup($senderId, $notificationKeyName, $notificationKey, array $registrationIds) {
185 | if (empty($notificationKey)) {
186 | throw new \InvalidArgumentException('notificationKey cannot be empty');
187 | }
188 |
189 | return $this->performDeviceGroupOperation($senderId, $notificationKeyName, $notificationKey, $registrationIds, self::DEVICE_GROUP_ADD);
190 | }
191 |
192 | /**
193 | * Removes devices from an existing device group.
194 | *
195 | * @param $senderId A unique numerical value created when you configure your API project
196 | * (given as "Project Number" in the Google Developers Console). The sender ID is used in the registration
197 | * process to identify an app server that is permitted to send messages to the client app.
198 | * @param $notificationKeyName a name or identifier (e.g., it can be a username) that is unique to a given group.
199 | * The notificationKeyName and notificationKey are unique to a group of registration tokens. It is important
200 | * that notificationKeyName is unique per client app if you have multiple client apps for the same sender ID.
201 | * This ensures that messages only go to the intended target app.
202 | * @param $notificationKey the notificationKey returned from Sender#createDeviceGroup.
203 | * @param string|array $registrationIds String registration id or an array of registration ids of the devices to add to the group.
204 | * @return string notificationKey used to send a notification to all the devices in the group.
205 | * @throws \InvalidArgumentException If senderId, notificationKeyName, notificationKey or registrationIds are empty.
206 | * @throws InvalidRequestException If GCM did not return a 200.
207 | */
208 | public function removeDeviceFromGroup($senderId, $notificationKeyName, $notificationKey, array $registrationIds) {
209 | if (empty($notificationKey)) {
210 | throw new \InvalidArgumentException('notificationKey cannot be empty');
211 | }
212 |
213 | return $this->performDeviceGroupOperation($senderId, $notificationKeyName, $notificationKey, $registrationIds, self::DEVICE_GROUP_REMOVE);
214 | }
215 |
216 | private function performDeviceGroupOperation($senderId, $notificationKeyName, $notificationKey, array $registrationIds, $operation) {
217 | if (empty($senderId)) {
218 | throw new \InvalidArgumentException('senderId cannot be empty');
219 | }
220 |
221 | if (empty($notificationKeyName)) {
222 | throw new \InvalidArgumentException('notificationKeyName cannot be empty');
223 | }
224 |
225 | if (empty($registrationIds)) {
226 | throw new \InvalidArgumentException('registrationIds cannot be empty');
227 | }
228 |
229 | if (!is_array($registrationIds)) {
230 | $registrationIds = array($registrationIds);
231 | }
232 |
233 | $request = array();
234 | $request[self::DEVICE_GROUP_OPERATION] = $operation;
235 | $request[self::DEVICE_GROUP_NOTIFICATION_KEY_NAME] = $notificationKeyName;
236 | $request[self::DEVICE_GROUP_REGISTRATION_IDS] = $registrationIds;
237 |
238 | if ($notificationKey != null) {
239 | $request[self::DEVICE_GROUP_NOTIFICATION_KEY] = $notificationKey;
240 | }
241 |
242 | $ch = $this->getCurlRequest();
243 | curl_setopt($ch, CURLOPT_URL, self::DEVICE_GROUP_ENDPOINT);
244 | curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json', 'Authorization: key=' . $this->key, self::DEVICE_GROUP_PROJET_ID_HEADER . ': ' . $senderId));
245 | curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($request));
246 | $response = curl_exec($ch);
247 | $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
248 | curl_close($ch);
249 |
250 | if ($status != 200) {
251 | $response = json_decode($response, true);
252 | throw new InvalidRequestException($status, $response[self::ERROR]);
253 | }
254 |
255 | $response = json_decode($response, true);
256 | return $response[self::DEVICE_GROUP_NOTIFICATION_KEY];
257 | }
258 |
259 | private function makeRequest(Message $message, array $registrationIds) {
260 | $ch = $this->getCurlRequest();
261 | curl_setopt($ch, CURLOPT_URL, self::SEND_ENDPOINT);
262 | curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json', 'Authorization: key=' . $this->key));
263 | curl_setopt($ch, CURLOPT_POSTFIELDS, $message->build($registrationIds));
264 | $response = curl_exec($ch);
265 | $status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
266 | curl_close($ch);
267 |
268 | if ($status == 400) {
269 | throw new InvalidRequestException($status, 'Check that the JSON message is properly formatted and contains valid fields.');
270 | } else if ($status == 401) {
271 | throw new InvalidRequestException($status, 'The sender account used to send a message could not be authenticated.');
272 | } else if ($status == 500) {
273 | throw new InvalidRequestException($status, 'The server encountered an error while trying to process the request.');
274 | } else if ($status == 503) {
275 | throw new InvalidRequestException($status, 'The server could not process the request in time.');
276 | } else if ($status != 200) {
277 | throw new InvalidRequestException($status, $response);
278 | }
279 |
280 | $response = json_decode($response, true);
281 | $success = $response[self::SUCCESS];
282 | $failure = $response[self::FAILURE];
283 | $canonicalIds = $response[self::CANONICAL_IDS];
284 | $multicastId = $response[self::MULTICAST_ID];
285 |
286 | $multicastResult = new MulticastResult($success, $failure, $canonicalIds, $multicastId);
287 |
288 | if(isset($response[self::RESULTS])){
289 | $individualResults = $response[self::RESULTS];
290 |
291 | foreach($individualResults as $singleResult) {
292 | $messageId = isset($singleResult[self::MESSAGE_ID]) ? $singleResult[self::MESSAGE_ID] : null;
293 | $canonicalRegId = isset($singleResult[self::REGISTRATION_ID]) ? $singleResult[self::REGISTRATION_ID] : null;
294 | $error = isset($singleResult[self::ERROR]) ? $singleResult[self::ERROR] : null;
295 |
296 | $result = new Result();
297 | $result->setMessageId($messageId);
298 | $result->setCanonicalRegistrationId($canonicalRegId);
299 | $result->setErrorCode($error);
300 |
301 | $multicastResult->addResult($result);
302 | }
303 | }
304 |
305 | return $multicastResult;
306 | }
307 |
308 | /**
309 | * Updates the status of the messages sent to devices and the list of devices
310 | * that should be retried.
311 | *
312 | * @param array $unsentRegIds list of devices that are still pending an update.
313 | * @param array $allResults map of status that will be updated.
314 | * @param MulticastResult multicastResult result of the last multicast sent.
315 | *
316 | * @return array updated version of devices that should be retried.
317 | */
318 | private function updateStatus($unsentRegIds, &$allResults, MulticastResult $multicastResult) {
319 | $results = $multicastResult->getResults();
320 | if(count($results) != count($unsentRegIds)) {
321 | // should never happen, unless there is a flaw in the algorithm
322 | throw new \RuntimeException('Internal error: sizes do not match. currentResults: ' . $results .
323 | '; unsentRegIds: ' . $unsentRegIds);
324 | }
325 |
326 | $newUnsentRegIds = array();
327 | for ($i = 0; $i < count($unsentRegIds); $i++) {
328 | $regId = $unsentRegIds[$i];
329 | $result = $results[$i];
330 | $allResults[$regId] = $result;
331 | $error = $result->getErrorCode();
332 |
333 | if(!is_null($error) && $error == Constants::$ERROR_UNAVAILABLE)
334 | $newUnsentRegIds[] = $regId;
335 | }
336 |
337 | return $newUnsentRegIds;
338 | }
339 |
340 | private function getCurlRequest() {
341 | $ch = curl_init();
342 |
343 | if ($this->certificatePath != null) {
344 | curl_setopt($ch, CURLOPT_CAINFO, $this->certificatePath);
345 | }
346 |
347 | curl_setopt($ch, CURLOPT_POST, true);
348 | curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
349 |
350 | return $ch;
351 | }
352 | }
353 |
--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
1 | vendor/bin/phpunit
2 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/AggregateResultTest.php:
--------------------------------------------------------------------------------
1 | assertEquals('multicast-id1', $aggregateResult->getMulticastId());
16 | $this->assertEquals(3, $aggregateResult->getSuccess());
17 | $this->assertEquals(9, $aggregateResult->getTotal());
18 | $this->assertEquals(6, $aggregateResult->getFailure());
19 | $this->assertEquals(3, $aggregateResult->getCanonicalIds());
20 | $this->assertTrue(is_array($aggregateResult->getResults()) && empty($aggregateResult->getResults()));
21 | $this->assertTrue(is_array($aggregateResult->getRetryMulticastIds()) && empty($aggregateResult->getRetryMulticastIds()));
22 | }
23 |
24 | public function testGetMulticastId() {
25 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
26 |
27 | $this->assertEquals('multicast-id', $result->getMulticastId());
28 | }
29 |
30 | public function testGetSuccess() {
31 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
32 |
33 | $this->assertEquals(1, $result->getSuccess());
34 | }
35 |
36 | public function testGetTotal() {
37 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
38 |
39 | $this->assertEquals(3, $result->getTotal());
40 | }
41 |
42 | public function testGetFailure() {
43 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
44 |
45 | $this->assertEquals(2, $result->getFailure());
46 | }
47 |
48 | public function testGetCanonicalIds() {
49 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
50 |
51 | $this->assertEquals(1, $result->getCanonicalIds());
52 | }
53 |
54 | public function testGetResults() {
55 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
56 | $result->addResult(new Result());
57 |
58 | $this->assertTrue(is_array($result->getResults()));
59 | $this->assertEquals(array(new Result()), $result->getResults());
60 | }
61 |
62 | public function testGetRetryMulticastIds() {
63 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array(1));
64 |
65 | $this->assertEquals(array(1), $result->getRetryMulticastIds());
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/InvalidRequestExceptionTest.php:
--------------------------------------------------------------------------------
1 | assertEquals(422, $exception->getHttpStatusCode());
11 | $this->assertEquals('', $exception->getDescription());
12 | $this->assertEquals('PHP_GCM\InvalidRequestException: HTTP Status Code: 422 ()', (string) $exception);
13 | }
14 |
15 | public function testConstructsCorrectlyWithDescription() {
16 | $exception = new InvalidRequestException(422, 'there was an error');
17 |
18 | $this->assertEquals(422, $exception->getHttpStatusCode());
19 | $this->assertEquals('there was an error', $exception->getDescription());
20 | $this->assertEquals('PHP_GCM\InvalidRequestException: HTTP Status Code: 422 (there was an error)', (string) $exception);
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/MessageTest.php:
--------------------------------------------------------------------------------
1 | assertEquals(2419200, $message->getTimeToLive());
11 | $this->assertEquals(false, $message->getDelayWhileIdle());
12 | $this->assertFalse($message->getDryRun());
13 | }
14 |
15 | public function testSetsCollapseKey() {
16 | $message = new Message();
17 |
18 | $message->collapseKey('collapse_key');
19 |
20 | $this->assertEquals('collapse_key', $message->getCollapseKey());
21 | }
22 |
23 | public function testSetsDelayWhileIdle() {
24 | $message = new Message();
25 |
26 | $message->delayWhileIdle(true);
27 |
28 | $this->assertTrue($message->getDelayWhileIdle());
29 | }
30 |
31 | public function testSetsDryRun() {
32 | $message = new Message();
33 |
34 | $message->dryRun(true);
35 |
36 | $this->assertTrue($message->getDryRun());
37 | }
38 |
39 | public function testSetsTimeToLive() {
40 | $message = new Message();
41 |
42 | $message->timeToLive(100);
43 |
44 | $this->assertEquals(100, $message->getTimeToLive());
45 | }
46 |
47 | public function testAddsData() {
48 | $message = new Message();
49 |
50 | $message->addData('key1', 'value1');
51 |
52 | $this->assertEquals(array('key1' => 'value1'), $message->getData());
53 | }
54 |
55 | public function testAddsDataWhenDataAlreadyExists() {
56 | $message = new Message();
57 | $message->data(array('key1' => 'value1', 'key2' => 'value2'));
58 |
59 | $message->addData('key3', 'value3');
60 |
61 | $this->assertEquals(array('key1' => 'value1', 'key2' => 'value2', 'key3' => 'value3'), $message->getData());
62 | }
63 |
64 | public function testSetsData() {
65 | $message = new Message();
66 |
67 | $message->data(array('key1' => 'value1', 'key2' => 'value2'));
68 |
69 | $this->assertEquals(array('key1' => 'value1', 'key2' => 'value2'), $message->getData());
70 | }
71 |
72 | public function testSetsRestrictedPackageName() {
73 | $message = new Message();
74 |
75 | $message->restrictedPackageName('com.lukekorth.android');
76 |
77 | $this->assertEquals('com.lukekorth.android', $message->getRestrictedPackageName());
78 | }
79 |
80 | public function testSetsNotification() {
81 | $message = new Message();
82 | $notification = new Notification();
83 |
84 | $message->notification($notification);
85 |
86 | $this->assertEquals($notification, $message->getNotification());
87 | }
88 |
89 | public function testSetsContentAvailable() {
90 | $message = new Message();
91 |
92 | $message->contentAvailable(true);
93 |
94 | $this->assertTrue($message->getContentAvailable());
95 | }
96 |
97 | public function testSetsPriority() {
98 | $message = new Message();
99 |
100 | $message->priority("high");
101 |
102 | $this->assertEquals("high", $message->getPriority());
103 | }
104 |
105 | public function testSettersAreChainable() {
106 | $message = new Message();
107 | $message->collapseKey('collapse-key')
108 | ->delayWhileIdle(true)
109 | ->dryRun(true)
110 | ->timeToLive(100)
111 | ->data(array('key1' => 'value1'))
112 | ->addData('key2', 'value2')
113 | ->restrictedPackageName('com.lukekorth.android')
114 | ->contentAvailable(true)
115 | ->priority("high");
116 |
117 | $this->assertEquals('collapse-key', $message->getCollapseKey());
118 | $this->assertEquals(true, $message->getDelayWhileIdle());
119 | $this->assertEquals(true, $message->getDryRun());
120 | $this->assertEquals(100, $message->getTimeToLive());
121 | $this->assertEquals(array('key1' => 'value1', 'key2' => 'value2'), $message->getData());
122 | $this->assertEquals('com.lukekorth.android', $message->getRestrictedPackageName());
123 | $this->assertTrue($message->getContentAvailable());
124 | $this->assertEquals("high", $message->getPriority());
125 | }
126 |
127 | public function testBuildAcceptsSingleRecipient() {
128 | $message = new Message();
129 |
130 | $builtMessage = json_decode($message->build('recipient'), true);
131 |
132 | $this->assertEquals('recipient', $builtMessage[Message::TO]);
133 | }
134 |
135 | public function testBuildAcceptsArrayWithSingleRecipient() {
136 | $message = new Message();
137 |
138 | $builtMessage = json_decode($message->build(array('recipient')), true);
139 |
140 | $this->assertEquals('recipient', $builtMessage[Message::TO]);
141 | }
142 |
143 | public function testBuildAcceptsArrayWithMultipleRecipients() {
144 | $message = new Message();
145 |
146 | $builtMessage = json_decode($message->build(array('recipient', 'other-recipient')), true);
147 |
148 | $this->assertEquals(2, count($builtMessage[Message::REGISTRATION_IDS]));
149 | }
150 |
151 | public function testBuildDoesNotSetCollapseKeyWhenAbsent() {
152 | $message = new Message();
153 |
154 | $builtMessage = json_decode($message->build(array('recipient')), true);
155 |
156 | $this->assertFalse(array_key_exists(Message::COLLAPSE_KEY, $builtMessage));
157 | }
158 |
159 | public function testBuildSetsCollapseKey() {
160 | $message = new Message();
161 | $message->collapseKey('collapse-key');
162 |
163 | $builtMessage = json_decode($message->build(array('recipient')), true);
164 |
165 | $this->assertEquals('collapse-key', $builtMessage[Message::COLLAPSE_KEY]);
166 | }
167 |
168 | public function testBuildSetsDelayWhileIdle() {
169 | $message = new Message();
170 | $message->delayWhileIdle(true);
171 |
172 | $builtMessage = json_decode($message->build(array('recipient')), true);
173 |
174 | $this->assertTrue($builtMessage[Message::DELAY_WHILE_IDLE]);
175 | }
176 |
177 | public function testBuildSetsTimeToLive() {
178 | $message = new Message();
179 | $message->timeToLive(100);
180 |
181 | $builtMessage = json_decode($message->build(array('recipient')), true);
182 |
183 | $this->assertEquals(100, $builtMessage[Message::TIME_TO_LIVE]);
184 | }
185 |
186 | public function testBuildSetsDryRun() {
187 | $message = new Message();
188 | $message->dryRun(true);
189 |
190 | $builtMessage = json_decode($message->build(array('recipient')), true);
191 |
192 | $this->assertTrue($builtMessage[Message::DRY_RUN]);
193 | }
194 |
195 | public function testBuildDoesNotSetRestrictedPackageNameWhenAbsent() {
196 | $message = new Message();
197 |
198 | $builtMessage = json_decode($message->build(array('recipient')), true);
199 |
200 | $this->assertFalse(array_key_exists(Message::RESTRICTED_PACKAGE_NAME, $builtMessage));
201 | }
202 |
203 | public function testBuildSetsRestrictedPackageName() {
204 | $message = new Message();
205 | $message->restrictedPackageName('package-name');
206 |
207 | $builtMessage = json_decode($message->build(array('recipient')), true);
208 |
209 | $this->assertEquals('package-name', $builtMessage[Message::RESTRICTED_PACKAGE_NAME]);
210 | }
211 |
212 | public function testBuildSetsContentAvailableWhenTrue() {
213 | $message = new Message();
214 | $message->contentAvailable(true);
215 |
216 | $builtMessage = json_decode($message->build(array('recipient')), true);
217 |
218 | $this->assertTrue($builtMessage[Message::CONTENT_AVAILABLE]);
219 | }
220 |
221 | public function testBuildSetsContentAvailableWhenFalse() {
222 | $message = new Message();
223 | $message->contentAvailable(false);
224 |
225 | $builtMessage = json_decode($message->build(array('recipient')), true);
226 |
227 | $this->assertFalse($builtMessage[Message::CONTENT_AVAILABLE]);
228 | }
229 |
230 | public function testBuildDoesNotSetContentAvailableWhenAbsent() {
231 | $message = new Message();
232 |
233 | $builtMessage = json_decode($message->build(array('recipient')), true);
234 |
235 | $this->assertFalse(array_key_exists(Message::CONTENT_AVAILABLE, $builtMessage));
236 | }
237 |
238 | public function testBuildSetsPriority() {
239 | $message = new Message();
240 | $message->priority("high");
241 |
242 | $builtMessage = json_decode($message->build(array('recipient')), true);
243 |
244 | $this->assertEquals("high", $builtMessage[Message::PRIORITY]);
245 | }
246 |
247 | public function testBuildDoesNotSetPriorityWhenAbsent() {
248 | $message = new Message();
249 |
250 | $builtMessage = json_decode($message->build(array('recipient')), true);
251 |
252 | $this->assertFalse(array_key_exists(Message::PRIORITY, $builtMessage));
253 | }
254 |
255 | public function testBuildDoesNotSetDataWhenDataIsAbsent() {
256 | $message = new Message();
257 |
258 | $builtMessage = json_decode($message->build(array('recipient')), true);
259 |
260 | $this->assertFalse(array_key_exists(Message::DATA, $builtMessage));
261 | }
262 |
263 | public function testBuildDoesNotSetDataWhenDataIsEmpty() {
264 | $message = new Message();
265 | $message->data(array());
266 |
267 | $builtMessage = json_decode($message->build(array('recipient')), true);
268 |
269 | $this->assertFalse(array_key_exists(Message::DATA, $builtMessage));
270 | }
271 |
272 | public function testBuildSetsData() {
273 | $message = new Message();
274 | $message->data(array('key' => 'value'));
275 |
276 | $builtMessage = json_decode($message->build(array('recipient')), true);
277 |
278 | $this->assertEquals('value', $builtMessage[Message::DATA]['key']);
279 | }
280 |
281 | public function testBuildHandlesMultiDimentionalArraysForData() {
282 | $message = new Message();
283 | $message->data(array('foo' => array('bar' => 'baz')));
284 |
285 | $builtMessage = json_decode($message->build(array('recipient')), true);
286 |
287 | $this->assertEquals('baz', $builtMessage[Message::DATA]['foo']['bar']);
288 | }
289 |
290 | public function testBuildDoesNotIncludeNotificationWhenNotSet() {
291 | $message = new Message();
292 |
293 | $builtMessage = json_decode($message->build('recipient'), true);
294 |
295 | $this->assertFalse(array_key_exists(Message::NOTIFICATION, $builtMessage));
296 | }
297 |
298 | public function testBuildIncludesNotificationWhenSet() {
299 | $message = new Message();
300 | $message->notification(new Notification());
301 |
302 | $builtMessage = json_decode($message->build('recipient'), true);
303 |
304 | $this->assertTrue(array_key_exists(Message::NOTIFICATION, $builtMessage));
305 | }
306 |
307 | public function testBuildSetsNotification() {
308 | $notification = new Notification();
309 | $notification->icon('icon')
310 | ->sound('sound')
311 | ->title('title')
312 | ->body('body')
313 | ->badge(1)
314 | ->tag('tag')
315 | ->color('color')
316 | ->clickAction('click-action')
317 | ->bodyLocKey('bodyLocKey')
318 | ->bodyLocArgs(array('key' => 'value'))
319 | ->titleLocKey('titleLocKey')
320 | ->titleLocArgs(array('key' => 'value'));
321 | $message = new Message();
322 | $message->notification($notification);
323 |
324 | $builtMessage = json_decode($message->build('recipient'), true);
325 | $builtNotification = $builtMessage[Message::NOTIFICATION];
326 |
327 | $this->assertEquals('icon', $builtNotification[Message::NOTIFICATION_ICON]);
328 | $this->assertEquals('sound', $builtNotification[Message::NOTIFICATION_SOUND]);
329 | $this->assertEquals('title', $builtNotification[Message::NOTIFICATION_TITLE]);
330 | $this->assertEquals('body', $builtNotification[Message::NOTIFICATION_BODY]);
331 | $this->assertEquals(1, $builtNotification[Message::NOTIFICATION_BADGE]);
332 | $this->assertEquals('tag', $builtNotification[Message::NOTIFICATION_TAG]);
333 | $this->assertEquals('color', $builtNotification[Message::NOTIFICATION_COLOR]);
334 | $this->assertEquals('click-action', $builtNotification[Message::NOTIFICATION_CLICK_ACTION]);
335 | $this->assertEquals('bodyLocKey', $builtNotification[Message::NOTIFICATION_BODY_LOC_KEY]);
336 | $this->assertEquals(array('key' => 'value'), $builtNotification[Message::NOTIFICATION_BODY_LOC_ARGS]);
337 | $this->assertEquals('titleLocKey', $builtNotification[Message::NOTIFICATION_TITLE_LOC_KEY]);
338 | $this->assertEquals(array('key' => 'value'), $builtNotification[Message::NOTIFICATION_TITLE_LOC_ARGS]);
339 | }
340 | }
341 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/MulticastResultTest.php:
--------------------------------------------------------------------------------
1 | assertEquals('multicast-id', $result->getMulticastId());
11 | $this->assertEquals(1, $result->getSuccess());
12 | $this->assertEquals(3, $result->getTotal());
13 | $this->assertEquals(2, $result->getFailure());
14 | $this->assertEquals(1, $result->getCanonicalIds());
15 | $this->assertTrue(is_array($result->getResults()) && empty($result->getResults()));
16 | $this->assertTrue(is_array($result->getRetryMulticastIds()) && empty($result->getRetryMulticastIds()));
17 | }
18 |
19 | public function testAddResult() {
20 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
21 | $this->assertTrue(is_array($result->getResults()) && empty($result->getResults()));
22 |
23 | $result->addResult(new Result());
24 |
25 | $this->assertTrue(is_array($result->getResults()) && count($result->getResults()) == 1);
26 | }
27 |
28 | public function testGetMulticastId() {
29 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
30 |
31 | $this->assertEquals('multicast-id', $result->getMulticastId());
32 | }
33 |
34 | public function testGetSuccess() {
35 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
36 |
37 | $this->assertEquals(1, $result->getSuccess());
38 | }
39 |
40 | public function testGetTotal() {
41 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
42 |
43 | $this->assertEquals(3, $result->getTotal());
44 | }
45 |
46 | public function testGetFailure() {
47 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
48 |
49 | $this->assertEquals(2, $result->getFailure());
50 | }
51 |
52 | public function testGetCanonicalIds() {
53 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
54 |
55 | $this->assertEquals(1, $result->getCanonicalIds());
56 | }
57 |
58 | public function testGetResults() {
59 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array());
60 | $result->addResult(new Result());
61 |
62 | $this->assertTrue(is_array($result->getResults()));
63 | $this->assertEquals(array(new Result()), $result->getResults());
64 | }
65 |
66 | public function testGetRetryMulticastIds() {
67 | $result = new MulticastResult(1, 2, 1, 'multicast-id', array(1));
68 |
69 | $this->assertEquals(array(1), $result->getRetryMulticastIds());
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/NotificationTest.php:
--------------------------------------------------------------------------------
1 | notification = new Notification();
11 | }
12 |
13 | public function testConstructsCorrectly() {
14 | $this->assertEquals('default', $this->notification->getSound());
15 | }
16 |
17 | public function testSetsIcon() {
18 | $this->notification->icon('icon');
19 |
20 | $this->assertEquals('icon', $this->notification->getIcon());
21 | }
22 |
23 | public function testSetsSound() {
24 | $this->notification->sound('sound');
25 |
26 | $this->assertEquals('sound', $this->notification->getSound());
27 | }
28 |
29 | public function testSetsTitle() {
30 | $this->notification->title('title');
31 |
32 | $this->assertEquals('title', $this->notification->getTitle());
33 | }
34 |
35 | public function testSetsBody() {
36 | $this->notification->body('body');
37 |
38 | $this->assertEquals('body', $this->notification->getBody());
39 | }
40 |
41 | public function testSetsBadge() {
42 | $this->notification->badge(1);
43 |
44 | $this->assertEquals(1, $this->notification->getBadge());
45 | }
46 |
47 | public function testSetsTag() {
48 | $this->notification->tag('tag');
49 |
50 | $this->assertEquals('tag', $this->notification->getTag());
51 | }
52 |
53 | public function testSetsColor() {
54 | $this->notification->color('color');
55 |
56 | $this->assertEquals('color', $this->notification->getColor());
57 | }
58 |
59 | public function testSetsClickAction() {
60 | $this->notification->clickAction('click-action');
61 |
62 | $this->assertEquals('click-action', $this->notification->getClickAction());
63 | }
64 |
65 | public function testSetsBodyLocKey() {
66 | $this->notification->bodyLocKey('bodyLocKey');
67 |
68 | $this->assertEquals('bodyLocKey', $this->notification->getBodyLocKey());
69 | }
70 |
71 | public function testSetsBodyLocArgs() {
72 | $this->notification->bodyLocArgs(array('key' => 'value'));
73 |
74 | $this->assertEquals(array('key' => 'value'), $this->notification->getBodyLocArgs());
75 | }
76 |
77 | public function testSetsTitleLocKey() {
78 | $this->notification->titleLocKey('titleLocKey');
79 |
80 | $this->assertEquals('titleLocKey', $this->notification->getTitleLocKey());
81 | }
82 |
83 | public function testSetsTitleLocArgs() {
84 | $this->notification->titleLocArgs(array('key' => 'value'));
85 |
86 | $this->assertEquals(array('key' => 'value'), $this->notification->getTitleLocArgs());
87 | }
88 |
89 | public function testSettersAreChainable() {
90 | $this->notification->icon('icon')
91 | ->sound('sound')
92 | ->title('title')
93 | ->body('body')
94 | ->badge(1)
95 | ->tag('tag')
96 | ->color('color')
97 | ->clickAction('click-action')
98 | ->bodyLocKey('bodyLocKey')
99 | ->bodyLocArgs(array('key' => 'value'))
100 | ->titleLocKey('titleLocKey')
101 | ->titleLocArgs(array('key' => 'value'));
102 |
103 | $this->assertEquals('icon', $this->notification->getIcon());
104 | $this->assertEquals('sound', $this->notification->getSound());
105 | $this->assertEquals('title', $this->notification->getTitle());
106 | $this->assertEquals('body', $this->notification->getBody());
107 | $this->assertEquals(1, $this->notification->getBadge());
108 | $this->assertEquals('tag', $this->notification->getTag());
109 | $this->assertEquals('color', $this->notification->getColor());
110 | $this->assertEquals('click-action', $this->notification->getClickAction());
111 | $this->assertEquals('bodyLocKey', $this->notification->getBodyLocKey());
112 | $this->assertEquals(array('key' => 'value'), $this->notification->getBodyLocArgs());
113 | $this->assertEquals('titleLocKey', $this->notification->getTitleLocKey());
114 | $this->assertEquals(array('key' => 'value'), $this->notification->getTitleLocArgs());
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/ResultTest.php:
--------------------------------------------------------------------------------
1 | assertEquals('', $result->getMessageId());
11 | $this->assertEquals('', $result->getCanonicalRegistrationId());
12 | $this->assertEquals('', $result->getErrorCode());
13 | }
14 |
15 | public function testSetsMessageId() {
16 | $result = new Result();
17 |
18 | $result->setMessageId('message-id');
19 |
20 | $this->assertEquals('message-id', $result->getMessageId());
21 | }
22 |
23 | public function testSetsCanonicalRegistrationId() {
24 | $result = new Result();
25 |
26 | $result->setCanonicalRegistrationId('canonical-registration-id');
27 |
28 | $this->assertEquals('canonical-registration-id', $result->getCanonicalRegistrationId());
29 | }
30 |
31 | public function testSetsErrorCode() {
32 | $result = new Result();
33 |
34 | $result->setErrorCode(422);
35 |
36 | $this->assertEquals(422, $result->getErrorCode());
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/tests/PHP_GCM/SenderTest.php:
--------------------------------------------------------------------------------
1 | assertNotNull($sender);
11 | }
12 | }
13 |
--------------------------------------------------------------------------------