Elmage\TextNg\Exception\HttpException

Complexity

Total Complexity

12

Size/Duplication

Total Lines	62
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	getRequest()	0	3	1
A	__construct()	0	6	1
A	getStatusCode()	0	3	1
B	exceptionClass()	0	17	7
A	getResponse()	0	3	1
A	wrap()	0	8	1

<?php

namespace Elmage\TextNg\Exception;

use GuzzleHttp\Exception\RequestException;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

class HttpException extends RuntimeException
{
    private $request;
    private $response;

    /**
     * Wraps an API exception in the appropriate domain exception.
     *
     * @param RequestException $e The API exception
     *
     * @return HttpException
     */
    public static function wrap(RequestException $e)
    {
        $response = $e->getResponse();

        $class = self::exceptionClass($response);

It seems like $response can also be of type null; however, parameter $response of Elmage\TextNg\Exception\HttpException::exceptionClass() does only seem to accept Psr\Http\Message\ResponseInterface, maybe add an additional type check?

        $message = $e->getMessage();

        return new $class($message, $e->getRequest(), $response, $e);
    }

    public function __construct($message, RequestInterface $request, ResponseInterface $response, \Exception $previous)
    {
        parent::__construct($message, 0, $previous);

        $this->request = $request;
        $this->response = $response;
    }

    public function getRequest()
    {
        return $this->request;
    }

    public function getResponse()
    {
        return $this->response;
    }

    public function getStatusCode()
    {
        return $this->response->getStatusCode();
    }

    private static function exceptionClass(ResponseInterface $response)
    {
        switch ($response->getStatusCode()) {
            case 400:
                return BadRequestException::class;
            case 401:
                return UnauthorizedException::class;
            case 404:
                return NotFoundException::class;
            case 422:
                return ValidationException::class;
            case 500:
                return InternalServerException::class;
            case 503:
                return ServiceUnavailableException::class;
            default:
                return HttpException::class;
        }
    }
}