Scaytrase\Api\Rpc\Tests\RpcMockClientTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	122
Duplicated Lines	6.56 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	testClientReturnsResponse()	0	10	1
A	testClientFiltersResponse()	0	12	1
A	testClientReturnsMultipleResponses()	0	50	3
A	createRequestMock()	8	8	1
A	creatResponseMock()	0	9	3
A	createErrorMock()	0	8	1

<?php

namespace Scaytrase\Api\Rpc\Tests;

use ScayTrase\Api\Rpc\RpcErrorInterface;
use ScayTrase\Api\Rpc\RpcRequestInterface;
use ScayTrase\Api\Rpc\RpcResponseInterface;
use ScayTrase\Api\Rpc\Test\MockClientException;
use ScayTrase\Api\Rpc\Test\RpcMockClient;

class RpcMockClientTest extends \PHPUnit_Framework_TestCase
{
    public function testClientReturnsResponse()
    {
        $client = new RpcMockClient();
        $client->push($this->creatResponseMock(true, 5));
        $request  = $this->createRequestMock('test');
        $response = $client->invoke($request)->getResponse($request);
        self::assertTrue($response->isSuccessful());
        self::assertNull($response->getError());
        self::assertSame(5, $response->getBody());
    }

    /**
     * @expectedException \ScayTrase\Api\Rpc\Test\MockClientException
     */
    public function testClientFiltersResponse()
    {
        $client = new RpcMockClient();
        $client->push(
            $this->creatResponseMock(true, 5),
            function (RpcRequestInterface $request) {
                return $request->getMethod() === 'entity';
            }
        );
        $request = $this->createRequestMock('test');
        $client->invoke($request)->getResponse($request);
    }

    public function testClientReturnsMultipleResponses()
    {
        $client = new RpcMockClient();
        $client->push($this->creatResponseMock(true, 5));
        $client->push($this->creatResponseMock(false, null, $this->createErrorMock(-1, 'invalid')));
        $client->push(
            $this->creatResponseMock(true, []),
            function (RpcRequestInterface $request) {
                return $request->getMethod() === 'entity';
            }
        );
        self::assertCount(3, $client->getQueue());
        $request1  = $this->createRequestMock('test');
        $request2  = $this->createRequestMock('test2');
        $request3  = $this->createRequestMock('entity');
        $response1 = $client->invoke($request1)->getResponse($request1);
        self::assertCount(2, $client->getQueue());
        self::assertTrue($response1->isSuccessful());
        self::assertNull($response1->getError());
        self::assertSame(5, $response1->getBody());

        $coll = $client->invoke([$request2, $request3]);
        self::assertCount(0, $client->getQueue());
        $response2 = $coll->getResponse($request2);
        $response3 = $coll->getResponse($request3);

        self::assertFalse($response2->isSuccessful());
        self::assertNull($response2->getBody());
        self::assertNotNull($response2->getError());
        self::assertSame(-1, $response2->getError()->getCode());
        self::assertSame('invalid', $response2->getError()->getMessage());

        self::assertTrue($response3->isSuccessful());
        self::assertNull($response3->getError());
        self::assertSame([], $response3->getBody());

        $request4 = $this->createRequestMock('empty');
        self::assertCount(0, $client->getQueue());
        try {
            $client->invoke($request4);
        } catch (MockClientException $exception) {
            self::assertEquals($request4, $exception->getRequest());
            self::assertEquals('Mock queue is empty while calling "empty"', $exception->getMessage());
        }

        self::assertCount(2, $coll);
        foreach ($coll as $response) {
            self::assertContains($response, [$response2, $response3]);
        }
    }


    /**
     * @param string               $method
     * @param \stdClass|array|null $parameters
     *
     * @return RpcRequestInterface
     */
    private function createRequestMock($method, $parameters = null)

This method seems to be duplicated in your project.

    {
        $mock = $this->prophesize(RpcRequestInterface::class);
        $mock->getMethod()->willReturn((string)$method);

The method getMethod() does not exist on Prophecy\Prophecy\ObjectProphecy. Did you maybe mean getMethodProphecies()?

        $mock->getParameters()->willReturn($parameters);

        return $mock->reveal();
    }

    /**
     * @param bool                       $success
     * @param \stdClass|array|null|mixed $body
     * @param RpcErrorInterface          $error
     *
     * @return RpcResponseInterface
     */
    private function creatResponseMock($success = true, $body = null, RpcErrorInterface $error = null)
    {
        $mock = $this->prophesize(RpcResponseInterface::class);
        $mock->isSuccessful()->willReturn($success);
        $mock->getError()->willReturn($success ? null : $error);
        $mock->getBody()->willReturn($success ? $body : null);

        return $mock->reveal();
    }

    private function createErrorMock($code, $message)
    {
        $mock = $this->prophesize(RpcErrorInterface::class);
        $mock->getCode()->willReturn($code);
        $mock->getMessage()->willReturn($message);

        return $mock->reveal();
    }
}