Mikemirten\Component\JsonApi\HttpClient\Decorator\SymfonyEventDispatcherDecorator

Complexity

Total Complexity

5

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

90.91%

Importance

Changes

0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	1
B	request()	0	28	4

<?php
declare(strict_types = 1);

namespace Mikemirten\Component\JsonApi\HttpClient\Decorator;

use Mikemirten\Component\JsonApi\HttpClient\Decorator\SymfonyEvent\ExceptionEvent;
use Mikemirten\Component\JsonApi\HttpClient\Decorator\SymfonyEvent\RequestEvent;
use Mikemirten\Component\JsonApi\HttpClient\Decorator\SymfonyEvent\ResponseEvent;
use Mikemirten\Component\JsonApi\HttpClient\Exception\RequestException;
use Mikemirten\Component\JsonApi\HttpClient\HttpClientInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Events handling decorator based on the Symfony EventDispatcher component.
 *
 * @package Mikemirten\Component\JsonApi\HttpClient\Decorator
 */
class SymfonyEventDispatcherDecorator implements HttpClientInterface
{
    /**
     * HTTP Client
     *
     * @var HttpClientInterface
     */
    protected $client;

    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * @var string
     */
    protected $requestEvent;

    /**
     * @var string
     */
    protected $responseEvent;

    /**
     * @var string
     */
    protected $exceptionEvent;

    /**
     * SymfonyEventDispatcherDecorator constructor.
     *
     * @param HttpClientInterface      $client
     * @param EventDispatcherInterface $dispatcher
     *
     * @param string $requestEvent
     * @param string $responseEvent
     * @param string $exceptionEvent
     */
    public function __construct(
        HttpClientInterface      $client,
        EventDispatcherInterface $dispatcher,

        string $requestEvent,
        string $responseEvent,
        string $exceptionEvent
    ) {
        $this->client     = $client;
        $this->dispatcher = $dispatcher;

        $this->requestEvent   = $requestEvent;
        $this->responseEvent  = $responseEvent;
        $this->exceptionEvent = $exceptionEvent;
    }

    /**
     * {@inheritdoc}
     */
    public function request(RequestInterface $request): ResponseInterface
    {
        $requestEvent = new RequestEvent($request);
        $this->dispatcher->dispatch($this->requestEvent, $requestEvent);

        try {
            $response = $this->client->request($requestEvent->getRequest());
        }
        catch (\Throwable $exception) {
            $exceptionEvent = new ExceptionEvent($request, $exception);
            $this->dispatcher->dispatch($this->exceptionEvent, $exceptionEvent);

            if (! $exceptionEvent->hasResponse()) {
                throw new RequestException($request, $exception);

$exception of type object<Throwable> is not a sub-type of object<Exception>. It seems like you assume a concrete implementation of the interface Throwable to be always present.

            }

            $response = $exceptionEvent->getResponse();

            if (! $exceptionEvent->isResponseEventEnabled()) {
                return $response;
            }
        }

        $responseEvent = new ResponseEvent($response);
        $this->dispatcher->dispatch($this->responseEvent, $responseEvent);

        return $responseEvent->getResponse();
    }
}