TBolier\RethinkQL\UnitTest\Connection\BaseConnectionTestCase

Complexity

Total Complexity

8

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	21	1
A	connect()	0	10	2
A	setExpectations()	0	14	2
A	catchStreamWrite()	0	10	1
A	catchStreamRead()	0	11	2

<?php
declare(strict_types=1);

namespace TBolier\RethinkQL\UnitTest\Connection;

use Mockery;
use Mockery\MockInterface;
use Psr\Http\Message\StreamInterface;
use Symfony\Component\Serializer\SerializerInterface;
use TBolier\RethinkQL\Connection\Connection;
use TBolier\RethinkQL\Connection\ConnectionInterface;
use TBolier\RethinkQL\Connection\Socket\HandshakeInterface;
use TBolier\RethinkQL\UnitTest\BaseUnitTestCase;

class BaseConnectionTestCase extends BaseUnitTestCase
{
    /**
     * @var Connection
     */
    protected $connection;

    /**
     * @var MockInterface
     */
    protected $handshake;

    /**
     * @var MockInterface
     */
    protected $querySerializer;

    /**
     * @var MockInterface
     */
    protected $responseSerializer;

    /**
     * @var MockInterface
     */
    protected $stream;

    /**
     * @var MockInterface
     */
    protected $streamWrapper;

    protected function setUp()
    {
        parent::setUp();

        $this->stream = Mockery::mock(StreamInterface::class);
        $this->streamWrapper = function () {

It seems like function () { return $this->stream; } of type object<Closure> is incompatible with the declared type object<Mockery\MockInterface> of property $streamWrapper.

            return $this->stream;
        };

        $this->handshake = Mockery::mock(HandshakeInterface::class);
        $this->querySerializer = Mockery::mock(SerializerInterface::class);
        $this->responseSerializer = Mockery::mock(SerializerInterface::class);

        $this->connection = new Connection(
            $this->streamWrapper,
            $this->handshake,
            'test',
            $this->querySerializer,
            $this->responseSerializer
        );
    }

    /**
     * @return void
     */
    protected function connect(): void
    {
        try {
            $this->handshake->shouldReceive('hello')->once();
            /** @var ConnectionInterface $connection */
            $this->assertInstanceOf(ConnectionInterface::class, $this->connection->connect());
        } catch (\Exception $e) {
            $this->fail($e->getMessage());
        }
    }

    /**
     * @param mixed|null $response
     * @return void
     */
    protected function setExpectations($response = null): void
    {
        $this->querySerializer->shouldReceive('serialize')->atLeast()->andReturn("['serialized': true]");

        $buffer = new \stdClass();
        $this->catchStreamWrite($buffer);

        if ($response) {
            $this->catchStreamRead(4 + 8, $buffer);
            $this->catchStreamRead(20, $buffer);

            $this->responseSerializer->shouldReceive('deserialize')->atLeast()->andReturn($response);
        }
    }

    /**
     * @param \stdClass $buffer
     * @return mixed
     */
    protected function catchStreamWrite(\stdClass $buffer)
    {
        $this->stream->shouldReceive('write')->andReturnUsing(function ($string) use ($buffer) {
            $buffer->data = $string;

            return 20;
        });

        return $buffer;
    }

    protected function catchStreamRead(int $bytes, \stdClass $buffer): void
    {
        $this->stream->shouldReceive('read')->once()->with($bytes)->andReturnUsing(function ($bytes) use (&$buffer) {
            $data = '';
            if (isset($buffer->data)) {
                $data = substr($buffer->data, 0, $bytes);
            }

            return $data;
        });
    }
}