Login   Register  
PHP Classes
elePHPant
Icontem

File: test/WebPower/gcm/server/SenderTest.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Christiaan Baartse  >  PHP Google Cloud Messaging Server  >  test/WebPower/gcm/server/SenderTest.php  >  Download  
File: test/WebPower/gcm/server/SenderTest.php
Role: Unit test script
Content type: text/plain
Description: Unit test script
Class: PHP Google Cloud Messaging Server
Send messages to Android applications using GCM
Author: By
Last change:
Date: 1 year ago
Size: 9,675 bytes
 

Contents

Class file image Download
<?php
namespace WebPower\gcm\server;

class 
MockHttpClient implements HttpClient
{
    public 
$apiKey;
    public 
$url;
    public 
$mimeType;
    public 
$requestBody;

    public 
$responseList = array();

    public function 
post($apiKey$url$mimeType$requestBody)
    {
        
$this->apiKey $apiKey;
        
$this->url $url;
        
$this->mimeType $mimeType;
        
$this->requestBody $requestBody;

        return 
array_shift($this->responseList);
    }
}

class 
SenderTest extends \PHPUnit_Framework_TestCase
{
    private 
$regId "15;16";
    private 
$collapseKey "collapseKey";
    private 
$delayWhileIdle true;
    private 
$ttl 108;
    private 
$authKey "4815162342";

    
/** @var Message */
    
private $message;

    
/** @var MockHttpClient */
    
private $mockClient;

    
/** @var Sender */
    
private $sender;

    protected function 
setUp()
    {
        
parent::setUp();
        
$this->message Message::builder()
            ->
collapseKey($this->collapseKey)
            ->
delayWhileIdle($this->delayWhileIdle)
            ->
timeToLive($this->ttl)
            ->
addData('k1''v1')
            ->
addData('k2''v2')
            ->
addData('k3''v3')
            ->
build();

        
$this->mockClient = new MockHttpClient();
        
$this->sender = new Sender($this->authKey);
        
$this->sender->setHttpClient($this->mockClient);
    }

    public function 
setResponseExpectations($statusCode$content)
    {
        
$this->mockClient->responseList[] = new HttpClientResponse($statusCode$content);
    }

    
/**
     * @expectedException \InvalidArgumentException
     */
    
public function testConstructorNull()
    {
        new 
Sender(null);
    }

    public function 
testSendNoRetry_ok()
    {
        
$this->setResponseExpectations(200"id=4815162342");
        
$result $this->sender->singleSendNoRetry($this->message$this->regId);
        
$this->assertNotNull($result);
        
$this->assertEquals("4815162342"$result->getMessageId());
        
$this->assertNull($result->getCanonicalRegistrationId());
        
$this->assertNull($result->getErrorCodeName());
        
$this->assertRequestBody();
    }

    public function 
testSendNoRetry_ok_canonical()
    {
        
$this->setResponseExpectations(
            
200,
            
"id=4815162342\nregistration_id=108"
        
);
        
$result $this->sender->singleSendNoRetry($this->message$this->regId);
        
$this->assertNotNull($result);
        
$this->assertEquals("4815162342"$result->getMessageId());
        
$this->assertEquals("108"$result->getCanonicalRegistrationId());
        
$this->assertNull($result->getErrorCodeName());
        
$this->assertRequestBody();
    }

    public function 
testSendNoRetry_unauthorized()
    {
        
$this->setResponseExpectations(401"");
        try {
            
$this->sender->singleSendNoRetry($this->message$this->regId);
            
$this->fail("Should have thrown InvalidRequestException");
        } catch (
InvalidRequestException $e) {
            
$this->assertEquals(401$e->getHttpStatusCode());
        }
        
$this->assertRequestBody();
    }

    public function 
testSendNoRetry_error()
    {
        
$this->setResponseExpectations(200"Error=D'OH!");
        
$result $this->sender->singleSendNoRetry($this->message$this->regId);
        
$this->assertNull($result->getMessageId());
        
$this->assertNull($result->getCanonicalRegistrationId());
        
$this->assertEquals("D'OH!"$result->getErrorCodeName());
        
$this->assertRequestBody();
    }

    public function 
testSendNoRetry_serviceUnavailable()
    {
        
$this->setResponseExpectations(503"");
        
$result $this->sender->singleSendNoRetry($this->message$this->regId);
        
$this->assertNull($result);
        
$this->assertRequestBody();
    }

    
/**
     * @expectedException \RuntimeException
     */
    
public function testSendNoRetry_emptyBody()
    {
        
$this->setResponseExpectations(200"");
        
$this->sender->singleSendNoRetry($this->message$this->regId);
    }

    
/**
     * @expectedException \RuntimeException
     */
    
public function testSendNoRetry_noToken()
    {
        
$this->setResponseExpectations(200'no token');
        
$this->sender->singleSendNoRetry($this->message$this->regId);
    }

    
/**
     * @expectedException \RuntimeException
     */
    
public function testSendNoRetry_invalidToken()
    {
        
$this->setResponseExpectations(200'bad=token');
        
$this->sender->singleSendNoRetry($this->message$this->regId);
    }

    public function 
testSendNoRetry_invalidHttpStatusCode()
    {
        
$this->setResponseExpectations(108'id=4815162342');
        try {
            
$this->sender->singleSendNoRetry($this->message$this->regId);
            
$this->fail('Should have thrown InvalidRequestException');
        } catch (
InvalidRequestException $e) {
            
$this->assertEquals(108$e->getHttpStatusCode());
        }
    }

    
/**
     * @expectedException \InvalidArgumentException
     */
    
public function testSendNoRetry_noRegistrationId()
    {
        
$this->sender->singleSendNoRetry(Message::builder()->build(), null);
    }

    public function 
testSendNoRetry_json_badRequest()
    {
        
$this->setResponseExpectations(42"bad json");
        try {
            
$this->sender->sendNoRetry($this->message, array("108"));
        } catch (
InvalidRequestException $e) {
            
$this->assertEquals(42$e->getHttpStatusCode());
            
$this->assertEquals("bad json"$e->getDescription());
            
$this->assertRequestJsonBody(array("108"));
        }
    }

    public function 
testSendNoRetry_json_ok()
    {
        
$json json_encode(array(
                
"multicast_id" => 108,
                
"success" => 2,
                
"failure" => 1,
                
"canonical_ids" => 1,
                
"results" => array(
                    array(
'message_id' => 16),
                    array(
'error' => 'DOH!'),
                    array(
'message_id' => 23'registration_id' => 42)
                )
            ));

        
$this->setResponseExpectations(200$json);
        
$registrationIds = array("4""8""15");
        
$multicastResponse $this->sender->sendNoRetry(
            
$this->message,
            
$registrationIds
        
);
        
$this->assertNotNull($multicastResponse);
        
$this->assertEquals(3$multicastResponse->getTotal());
        
$this->assertEquals(2$multicastResponse->getSuccess());
        
$this->assertEquals(1$multicastResponse->getFailure());
        
$this->assertEquals(1$multicastResponse->getCanonicalIds());
        
$this->assertEquals(108$multicastResponse->getMulticastId());
        
$results $multicastResponse->getResults();
        
$this->assertNotNull($results);
        
$this->assertEquals(3count($results));
        
$this->assertResult($results[0], "16"nullnull);
        
$this->assertResult($results[1], null'DOH!'null);
        
$this->assertResult($results[2], "23"null"42");
        
$this->assertRequestJsonBody($registrationIds);
    }

    private function 
assertRequestBody()
    {
        
$body $this->mockClient->requestBody;
        
$params = array();
        foreach (
explode('&'$body) as $param) {
            list(
$key$value) = explode('='$param2);
            
$params[$key] = $value;
        }

        
$this->assertEquals(7count($params), $body);
        
$this->assertParameter($params'registration_id'$this->regId);
        
$this->assertParameter($params'collapse_key'$this->collapseKey);
        
$this->assertParameter($params'delay_while_idle'$this->delayWhileIdle "1" "0");
        
$this->assertParameter($params'time_to_live'"" $this->ttl);
        
$this->assertParameter($params'data.k1''v1');
        
$this->assertParameter($params'data.k2''v2');
        
$this->assertParameter($params'data.k3''v3');
    }

    private function 
assertParameter($params$name$expectedValue)
    {
        
$this->assertEquals(
            
$expectedValue,
            
$params[$name],
            
"invalid value for request parameter parameter " $name
        
);
    }

    private function 
assertRequestJsonBody(array $expectedRegIds)
    {
        
$this->assertEquals(
            
Constants::GCM_SEND_ENDPOINT,
            
$this->mockClient->url
        
);
        
$this->assertEquals('application/json'$this->mockClient->mimeType);
        
$body $this->mockClient->requestBody;
        
$json json_decode($bodytrue);
        
$this->assertEquals($this->ttl$json['time_to_live']);
        
$this->assertEquals($this->collapseKey$json['collapse_key']);
        
$this->assertEquals($this->delayWhileIdle$json['delay_while_idle']);
        
$payload $json['data'];
        
$this->assertNotNull($payload'no payload');
        
$this->assertEquals(3count($payload), 'wrong payload size');
        
$this->assertEquals('v1'$payload['k1']);
        
$this->assertEquals('v2'$payload['k2']);
        
$this->assertEquals('v3'$payload['k3']);
        
$actualRegIds $json['registration_ids'];
        
$this->assertEquals(count($expectedRegIds), count($actualRegIds));
        
$this->assertEquals($expectedRegIds$actualRegIds);
    }

    private function 
assertResult(
        
Result $result,
        
$messageId,
        
$error,
        
$canonicalRegistrationId
    
) {
        
$this->assertEquals($messageId$result->getMessageId());
        
$this->assertEquals($error$result->getErrorCodeName());
        
$this->assertEquals(
            
$canonicalRegistrationId,
            
$result->getCanonicalRegistrationId()
        );
    }
}