Http\Adapter\React\Client

Complexity

Total Complexity

14

Size/Duplication

Total Lines	156
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	13

Test Coverage

Coverage

86.89%

Importance

Changes	4
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	sendRequest()	0	6	1
B	__construct()	0	18	7
B	sendAsyncRequest()	0	41	2
A	buildReactRequest()	0	17	3
A	buildResponse()	0	14	1

<?php

namespace Http\Adapter\React;

use Http\Client\HttpClient;
use Http\Client\HttpAsyncClient;
use Http\Client\Exception\HttpException;
use Http\Client\Exception\RequestException;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Discovery\StreamFactoryDiscovery;
use Http\Message\ResponseFactory;
use Http\Message\StreamFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\StreamInterface;
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;

/**
 * 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;

    /**
     * @var ResponseFactory
     */
    private $responseFactory;

    /**
     * @var StreamFactory
     */
    private $streamFactory;

    /**
     * Initialize the React client.
     *
     * @param ResponseFactory|null $responseFactory
     * @param LoopInterface|null   $loop
     * @param ReactClient|null     $client
     * @param StreamFactory|null   $streamFactory
     */
    public function __construct(
        ResponseFactory $responseFactory = null,
        LoopInterface $loop = null,
        ReactClient $client = null,
        StreamFactory $streamFactory = null
    ) {
        if (null !== $client && null === $loop) {
            throw new \RuntimeException(
                'You must give a LoopInterface instance with the Client'
            );
        }

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

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

        $this->responseFactory = $responseFactory ?: MessageFactoryDiscovery::find();
        $this->streamFactory = $streamFactory ?: StreamFactoryDiscovery::find();
    }

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

        return $promise->wait();
    }

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

        $reactRequest->on('error', function (\Exception $error) use ($promise, $request) {
            $promise->reject(new RequestException(
                $error->getMessage(),
                $request,
                $error
            ));
        });

        $reactRequest->on('response', function (ReactResponse $reactResponse = null) use ($promise, $request) {
            $bodyStream = $this->streamFactory->createStream();
            $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?

                $bodyStream->write((string) $data);
            });

            $reactResponse->on('end', function (\Exception $error = null) use ($promise, $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?

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

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

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

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

        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
     * @param StreamInterface $body
     *
     * @return ResponseInterface
     */
    private function buildResponse(
        ReactResponse $response,
        StreamInterface $body
    ) {
        $body->rewind();

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