Xabbuh\XApi\Client\Tests\Api\ApiClientTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	4
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	6	1
A	createRequestHandlerMock()	0	4	1
A	createSerializerRegistry()	0	10	1
A	createSerializerMock()	0	4	1
A	validateDeserializer()	0	8	1
A	validateSerializer()	0	16	3
A	createRequestMock()	0	12	2
A	createResponseMock()	0	16	1
A	validateRequest()	0	12	1
B	validateRetrieveApiCall()	0	28	3
A	validateStoreApiCall()	0	14	1
A	validateDeleteDocumentCall()	0	6	1

<?php

/*
 * This file is part of the xAPI package.
 *
 * (c) Christian Flothmann <christian.flothmann@xabbuh.de>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Xabbuh\XApi\Client\Tests\Api;

use JMS\Serializer\SerializerInterface;
use Xabbuh\XApi\Client\Request\HandlerInterface;
use Xabbuh\XApi\Common\Exception\NotFoundException;
use Xabbuh\XApi\Serializer\ActorSerializer;
use Xabbuh\XApi\Serializer\DocumentDataSerializer;
use Xabbuh\XApi\Serializer\SerializerRegistry;
use Xabbuh\XApi\Serializer\StatementResultSerializer;
use Xabbuh\XApi\Serializer\StatementSerializer;

/**
 * @author Christian Flothmann <christian.flothmann@xabbuh.de>
 */
abstract class ApiClientTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var HandlerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $requestHandler;

    /**
     * @var SerializerInterface|\PHPUnit_Framework_MockObject_MockObject
     */
    protected $serializer;

    /**
     * @var SerializerRegistry
     */
    protected $serializerRegistry;

    protected function setUp()
    {
        $this->requestHandler = $this->createRequestHandlerMock();
        $this->serializer = $this->createSerializerMock();
        $this->serializerRegistry = $this->createSerializerRegistry();
    }

    protected function createRequestHandlerMock()
    {
        return $this->getMock('\Xabbuh\XApi\Client\Request\HandlerInterface');
    }

    protected function createSerializerRegistry()
    {
        $registry = new SerializerRegistry();
        $registry->setStatementSerializer(new StatementSerializer($this->serializer));
        $registry->setStatementResultSerializer(new StatementResultSerializer($this->serializer));
        $registry->setActorSerializer(new ActorSerializer($this->serializer));
        $registry->setDocumentDataSerializer(new DocumentDataSerializer($this->serializer));

        return $registry;
    }

    protected function createSerializerMock()
    {
        return $this->getMock('\JMS\Serializer\SerializerInterface');
    }

    protected function validateDeserializer($data, $type, $returnValue)
    {
        $this->serializer

The method expects() does not seem to exist on object<JMS\Serializer\SerializerInterface>.

            ->expects($this->once())
            ->method('deserialize')
            ->with($data, 'Xabbuh\XApi\Model\\'.$type, 'json')
            ->will($this->returnValue($returnValue));
    }

    protected function validateSerializer(array $serializerMap)
    {
        $this

The method expects() does not seem to exist on object<JMS\Serializer\SerializerInterface>.

            ->serializer
            ->expects($this->any())
            ->method('serialize')
            ->will($this->returnCallback(function ($data) use ($serializerMap) {
                foreach ($serializerMap as $entry) {
                    if ($data == $entry['data']) {
                        return $entry['result'];
                    }
                }

                return '';
            }));
    }

    protected function createRequestMock($response = null)
    {
        $request = $this->getMock('\Guzzle\Http\Message\RequestInterface');

        if (null !== $response) {
            $request->expects($this->any())
                ->method('send')
                ->will($this->returnValue($response));
        }

        return $request;
    }

    protected function createResponseMock($statusCode, $body)
    {
        $response = $this->getMock(
            '\Guzzle\Http\Message\Response',
            array(),
            array($statusCode)
        );
        $response->expects($this->any())
            ->method('getStatusCode')
            ->will($this->returnValue($statusCode));
        $response->expects($this->any())
            ->method('getBody')
            ->will($this->returnValue($body));

        return $response;
    }

    protected function validateRequest($method, $uri, array $urlParameters, $body = null, $response = null)
    {
        $request = $this->createRequestMock($response);
        $this
            ->requestHandler
            ->expects($this->once())
            ->method('createRequest')
            ->with($method, $uri, $urlParameters, $body)
            ->will($this->returnValue($request));

        return $request;
    }

    protected function validateRetrieveApiCall($method, $uri, array $urlParameters, $statusCode, $type, $transformedResult, array $serializerMap = array())
    {
        $rawResponse = 'the-server-response';
        $response = $this->createResponseMock($statusCode, $rawResponse);
        $request = $this->validateRequest($method, $uri, $urlParameters, null, $response);

        if (404 === $statusCode) {
            $this
                ->requestHandler
                ->expects($this->once())
                ->method('executeRequest')
                ->with($request)
                ->will($this->throwException(new NotFoundException('Not found')));
        } else {
            $this
                ->requestHandler
                ->expects($this->once())
                ->method('executeRequest')
                ->with($request)
                ->will($this->returnValue($response));
        }

        $this->validateSerializer($serializerMap);

        if ($statusCode < 400) {
            $this->validateDeserializer($rawResponse, $type, $transformedResult);
        }
    }

    protected function validateStoreApiCall($method, $uri, array $urlParameters, $statusCode, $rawResponse, $object, array $serializerMap = array())
    {
        $rawRequest = 'the-request-body';
        $response = $this->createResponseMock($statusCode, $rawResponse);
        $request = $this->validateRequest($method, $uri, $urlParameters, $rawRequest, $response);
        $this
            ->requestHandler
            ->expects($this->once())
            ->method('executeRequest')
            ->with($request, array($statusCode))
            ->will($this->returnValue($response));
        $serializerMap[] = array('data' => $object, 'result' => $rawRequest);
        $this->validateSerializer($serializerMap);
    }

    protected function validateDeleteDocumentCall($uri, array $urlParameters, array $serializerMap = array())
    {
        $response = $this->createResponseMock(204, '');
        $this->validateRequest('delete', $uri, $urlParameters, '', $response);
        $this->validateSerializer($serializerMap);
    }
}