Http\Adapter\React\Client

Complexity

Total Complexity

13

Size/Duplication

Total Lines	154
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	10

Test Coverage

Coverage

87.69%

Importance

Changes	3
Bugs	1	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
B	__construct()	0	15	5
A	sendRequest()	0	6	1
A	sendAsyncRequest()	0	48	3
A	buildReactRequest()	0	16	3
A	buildResponse()	0	14	1

<?php

namespace Http\Adapter\React;

use Psr\Http\Message\ResponseInterface;
use React\EventLoop\LoopInterface;
use React\Promise\Deferred;
use React\HttpClient\Client as ReactClient;
use React\HttpClient\Request as ReactRequest;
use React\HttpClient\Response as ReactResponse;
use Http\Client\HttpClient;
use Http\Client\HttpAsyncClient;
use Http\Client\Exception\HttpException;
use Http\Client\Exception\RequestException;
use Http\Message\MessageFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\StreamInterface;

/**
 * Client for the React promise implementation.
 *
 * @author Stéphane Hulard <stephane@hlrd.me>
 */
class Client implements HttpClient, HttpAsyncClient
{
    /**
     * React HTTP client.
     *
     * @var Client
     */
    private $client;

    /**
     * React event loop.
     *
     * @var LoopInterface
     */
    private $loop;

    /**
     * HttpPlug message factory.
     *
     * @var MessageFactory
     */
    private $messageFactory;

    /**
     * Initialize the React client.
     *
     * @param MessageFactory     $messageFactory
     * @param LoopInterface|null $loop     React Event loop
     * @param ReactClient        $client   React client to use
     */
    public function __construct(
        MessageFactory $messageFactory,
        LoopInterface $loop = null,
        ReactClient $client = null
    ) {
        if (null !== $client && null === $loop) {
            throw new \RuntimeException(
                'You must give a LoopInterface instance with the Client'
            );
        }
        $this->loop = (null !== $loop) ?: ReactFactory::buildEventLoop();

It seems like null !== $loop ?: \Http\Adapter\React\ReactFactory::buildEventLoop() can also be of type boolean. However, the property $loop is declared as type object<React\EventLoop\LoopInterface>. Maybe add an additional type check?

        $this->client = (null !== $client) ?: ReactFactory::buildHttpClient($this->loop);

It seems like $this->loop can also be of type boolean; however, Http\Adapter\React\ReactFactory::buildHttpClient() does only seem to accept object<React\EventLoop\LoopInterface>, maybe add an additional type check?

It seems like null !== $client ?: \Http\Adapter\React\ReactFactory::buildHttpClient($this->loop) of type boolean or object<React\HttpClient\Client> is incompatible with the declared type object<Http\Adapter\React\Client> of property $client.

        $this->messageFactory = $messageFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        $promise = $this->sendAsyncRequest($request);

        return $promise->wait();
    }

    /**
     * {@inheritdoc}
     */
    public function sendAsyncRequest(RequestInterface $request)
    {
        $reactRequest = $this->buildReactRequest($request);
        $deferred = new Deferred();

        $reactRequest->on('error', function (\Exception $error) use ($deferred, $request) {
            $deferred->reject(new RequestException(
                $error->getMessage(),
                $request,
                $error
            ));
        });
        $reactRequest->on('response', function (ReactResponse $reactResponse = null) use ($deferred, $reactRequest, $request) {
            $bodyStream = null;
            $reactResponse->on('data', function ($data) use (&$bodyStream) {

It seems like $reactResponse is not always an object, but can also be of type null. Maybe add an additional type check?

                if ($data instanceof StreamInterface) {
                    $bodyStream = $data;
                } else {
                    $bodyStream->write($data);

The method write cannot be called on $bodyStream (of type null).

                }
            });

            $reactResponse->on('end', function (\Exception $error = null) use ($deferred, $request, $reactResponse, &$bodyStream) {

It seems like $reactResponse is not always an object, but can also be of type null. Maybe add an additional type check?

                $bodyStream->rewind();

The method rewind cannot be called on $bodyStream (of type null).

                $response = $this->buildResponse(
                    $reactResponse,

It seems like $reactResponse defined by parameter $reactResponse on line 95 can be null; however, Http\Adapter\React\Client::buildResponse() does not accept null, maybe add an additional type check?

                    $bodyStream

$bodyStream is of type null, but the function expects a object<Psr\Http\Message\StreamInterface>.

                );
                if (null !== $error) {
                    $deferred->reject(new HttpException(
                        $error->getMessage(),
                        $request,
                        $response,
                        $error
                    ));
                } else {
                    $deferred->resolve($response);
                }
            });
        });

        $reactRequest->end((string) $request->getBody());

        $promise = new Promise($deferred->promise());
        $promise->setLoop($this->loop);

        return $promise;
    }

    /**
     * Build a React request from the PSR7 RequestInterface.
     *
     * @param RequestInterface $request
     *
     * @return ReactRequest
     */
    private function buildReactRequest(RequestInterface $request)
    {
        $headers = [];
        foreach ($request->getHeaders() as $name => $value) {
            $headers[$name] = (is_array($value) ? $value[0] : $value);
        }

        $reactRequest = $this->client->request(

The method request() does not exist on Http\Adapter\React\Client. Did you maybe mean sendRequest()?

            $request->getMethod(),
            (string) $request->getUri(),
            $headers,
            $request->getProtocolVersion()
        );

        return $reactRequest;
    }

    /**
     * Transform a React Response to a valid PSR7 ResponseInterface instance.
     *
     * @param ReactResponse $response
     *
     * @return ResponseInterface
     */
    private function buildResponse(
        ReactResponse $response,
        StreamInterface $body
    ) {
        $body->rewind();

        return $this->messageFactory->createResponse(
            $response->getCode(),
            $response->getReasonPhrase(),
            $response->getHeaders(),
            $body,
            $response->getVersion()
        );
    }
}