Docta\MercadoLibre\Test\ClientBaseTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	279
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

<?php
class ClientBaseTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var string Auth site
     */
    protected $authSite = 'MLA';

    /**
     * @var string Client ID
     */
    protected $clientId;

    /**
     * @var string Cliente secret key
     */
    protected $clientSecret;

    /**
     * @var string Redirect URI
     */
    protected $redirectUri = 'https://example.com/oauth';

    /**
     * @var string Code
     */
    protected $code;

    /**
     * @var string Token type
     */
    protected $tokenType = 'bearer';

    /**
     * @var string Access token
     */
    protected $accessToken;

    /**
     * @var string Refresh token
     */
    protected $refreshToken;

    /**
     * @var string User id
     */
    protected $userId;

    /**
     * @var integer Token expires in
     */
    protected $expiresIn = 10800;

    /**
     * @var string Token scope
     */
    protected $scope = 'write read';

    /**
     * @var string Token json
     */
    protected $jsonToken;

    /**
     * @var string User json
     */
    protected $jsonUser;

    /**
     * @var array Headers
     */
    protected $headers = ['content-type' => 'json'];

    /**
     * @var Client Client instance
     */
    protected $mercadolibre;

    /**
     * Setup test.
     *
     * @return void
     */
    protected function setUp()
    {
        $this->clientId = uniqid('id_', true);
        $this->clientSecret = uniqid('sk_', true);
        $this->code = uniqid('cd_', true);
        $this->accessToken = uniqid('at_', true);
        $this->refreshToken = uniqid('rt_', true);
        $this->userId = uniqid('ui_', true);

        $this->jsonToken = json_encode([
            'token_type' => $this->tokenType,
            'access_token' => $this->accessToken,
            'refresh_token' => $this->refreshToken,
            'user_id' => $this->userId,
            'expires_in' => $this->expiresIn,
            'scope' => $this->scope
        ]);

        $this->jsonUser = json_encode([
            'id' => $this->userId
        ]);

        $this->mercadolibre = new Client([
            'authSite' => $this->authSite,
            'clientId' => $this->clientId,
            'clientSecret' => $this->clientSecret,
            'redirectUri' => $this->redirectUri
        ]);
    }

    /**
     * Tear down test.
     *
     * @return void
     */
    public function tearDown()
    {
        parent::tearDown();
    }

    /**
     * testAuthorize method
     *
     * @return void
     */
    public function testAuthorize()
    {
        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonToken);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $this->mercadolibre->setClient($client);

        $token = $this->mercadolibre->authorize($this->code);
        $this->assertEquals($this->accessToken, $token->getToken());
        $this->assertEquals($this->refreshToken, $token->getRefreshToken());
        $this->assertEquals($this->userId, $token->getResourceOwnerId());
        $this->assertInternalType('int', $token->getExpires());
        $this->assertGreaterThan(time(), $token->getExpires());
    }

    /**
     * testRefresh method
     *
     * @return void
     */
    public function testRefresh()
    {
        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonToken);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $this->mercadolibre->setClient($client);

        $token = $this->mercadolibre->getToken($this->code);
        $token = $this->mercadolibre->refresh($token);
        $this->assertEquals($this->accessToken, $token->getToken());
        $this->assertEquals($this->refreshToken, $token->getRefreshToken());
        $this->assertEquals($this->userId, $token->getResourceOwnerId());
        $this->assertInternalType('int', $token->getExpires());
        $this->assertGreaterThan(time(), $token->getExpires());
    }

    /**
     * testGetOptions method
     *
     * @return void
     */
    public function testGetOptions()
    {
        $options = $this->mercadolibre->getOptions([]);
        $this->assertEmpty($options);

        $options = $this->mercadolibre->getOptions(['data_key' => 'data_value']);
        $this->assertArrayHasKey('body', $options);
        $this->assertArrayHasKey('headers', $options);
        $this->assertArrayHasKey('content-type', $options['headers']);
        $this->assertEquals('{"data_key":"data_value"}', $options['body']);
        $this->assertEquals('application/json', $options['headers']['content-type']);
    }

    /**
     * testGetPath method
     *
     * @return void
     */
    public function testGetPath()
    {
        $expected = sprintf('/users/me?access_token=%s', $this->accessToken);
        $actual = $this->mercadolibre->getPath('/users/me', ['access_token' => $this->accessToken]);
        $this->assertEquals($expected, $actual);
    }

    /**
     * testGetRequest method
     *
     * @return void
     */
    public function testGetRequest()
    {
        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonToken);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $this->mercadolibre->setClient($client);
        $this->mercadolibre->getToken($this->code);

        $requestQuery = ['query_key' => 'query_value'];
        $requestData = ['data_key' => 'data_value'];
        $request = $this->mercadolibre->getRequest('POST', '/users/me', $requestQuery, $requestData);

        $this->assertContains('application/json', $request->getHeader('content-type'));
        $this->assertEquals('{"data_key":"data_value"}', (string) $request->getBody());

        $uri = (string) $request->getUri();
        $uri = parse_url($uri);
        $this->assertArrayHasKey('scheme', $uri);
        $this->assertArrayHasKey('host', $uri);
        $this->assertArrayHasKey('path', $uri);
        $this->assertArrayHasKey('query', $uri);
        $this->assertEquals('https', $uri['scheme']);
        $this->assertEquals('api.mercadolibre.com', $uri['host']);
        $this->assertEquals('/users/me', $uri['path']);

        parse_str($uri['query'], $query);
        $this->assertArrayHasKey('access_token', $query);
        $this->assertArrayHasKey('query_key', $query);
        $this->assertEquals($this->accessToken, $query['access_token']);
        $this->assertEquals('query_value', $query['query_key']);
    }

    /**
     * testGetRequest method
     *
     * @return void
     */
    public function testGetResponse()
    {
        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonToken);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $this->mercadolibre->setClient($client);
        $this->mercadolibre->getToken($this->code);

        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonUser);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $this->mercadolibre->setClient($client);

        $response = $this->mercadolibre->getResponse('POST', '/users/me');
        $this->assertArrayHasKey('id', $response);
        $this->assertEquals($this->userId, $response['id']);
    }

    /**
     * testSetClient method
     *
     * @return void
     */
    public function testSetClient()
    {
        $response = Mockery::mock('GuzzleHttp\Psr7\Response');
        $response->shouldReceive('getHeader')->andReturn($this->headers);
        $response->shouldReceive('getBody')->andReturn($this->jsonToken);
        $client = Mockery::mock('GuzzleHttp\Client');
        $client->shouldReceive('send')->times(1)->andReturn($response);
        $provider = $this->mercadolibre->setClient($client);
        $this->assertEquals($client, $provider->getHttpClient());
    }
}