ResponseService::__construct() - Code Metrics - Inspection of "Handle unknown kintone error response" - ochi51/cybozu-http - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#76)

unknown
created 2024-05-13 04:20 UTC
ResponseService::__construct() A

↳ Parent: ResponseService
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	4
CRAP Score	1
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	3
c	1
b	0
f	0
nc	1
nop	3
dl	0
loc	5
ccs	4
cts	4
cp	1
crap	1
rs	10
<?php

namespace CybozuHttp\Service;

use CybozuHttp\Exception\RuntimeException;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\ServerException;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * @author ochi51 <[email protected]>
 */
class ResponseService
{
    /**
     * @var RequestInterface
     */
    private $request;

    /**
     * @var ResponseInterface
     */
    private $response;

    /**
     * @var string|null
     */
    private $responseBody = null;

    /**
     * @var \Throwable|null
     */
    private $previousThrowable;

    /**
     * ResponseService constructor.
     * @param RequestInterface $request
     * @param ResponseInterface $response
     * @param \Throwable|null $previousThrowable
     */
    public function __construct(RequestInterface $request, ResponseInterface $response, ?\Throwable $previousThrowable = null)
    {
        $this->request = $request;
        $this->response = $response;
        $this->previousThrowable = $previousThrowable;
    }

    /**
     * @return bool
     */
    public function isJsonResponse(): bool
    {
        $contentType = $this->response->getHeader('Content-Type');
        $contentType = is_array($contentType) && isset($contentType[0]) ? $contentType[0] : $contentType;

        return is_string($contentType) && strpos($contentType, 'application/json') === 0;
    }

    /**
     * @return bool
     */
    public function isHtmlResponse(): bool
    {
        $contentType = $this->response->getHeader('Content-Type');
        $contentType = is_array($contentType) && isset($contentType[0]) ? $contentType[0] : $contentType;

        return is_string($contentType) && strpos($contentType, 'text/html') === 0;
    }

    /**
     * @throws RequestException
     * @throws RuntimeException
     */
    public function handleError(): void
    {
        if ($this->isJsonResponse()) {
            $this->handleJsonError();
        } else if ($this->isHtmlResponse()) {
            $this->handleDomError();
        }

        throw $this->createRuntimeException('Failed to extract error message because Content-Type of error response is unexpected.');
    }

    /**
     * @throws RequestException
     * @throws RuntimeException
     */
    private function handleDomError(): void
    {
        $body = $this->getResponseBody();
        $dom = new \DOMDocument('1.0', 'UTF-8');
        $dom->preserveWhiteSpace = false;
        $dom->formatOutput = true;
        if ($dom->loadHTML($body)) {
            $title = $dom->getElementsByTagName('title');
            if (is_object($title)) {
                $title = $title->item(0)->nodeValue;
            }
            if ($title === 'Error') {
                $message = $dom->getElementsByTagName('h3')->item(0)->nodeValue;
                if (is_null($message)) {

                    throw $this->createRuntimeException('Failed to extract error message from DOM response.');
                }
                throw $this->createException($message);
            }
            if ($title === 'Unauthorized') {
                $message = $dom->getElementsByTagName('h2')->item(0)->nodeValue;
                if (is_null($message)) {

                    throw $this->createRuntimeException('Failed to extract error message from DOM response.');
                }
                throw $this->createException($message);
            }

            throw $this->createException('Invalid auth.');
        }

        throw new \InvalidArgumentException('Body is not DOM.');
    }

    /**
     * @throws RequestException
     * @throws RuntimeException
     */
    private function handleJsonError(): void
    {
        $body = $this->getResponseBody();
        $json = \GuzzleHttp\json_decode($body, true);
        $json = /** @scrutinizer ignore-deprecated */ \GuzzleHttp\json_decode($body, true);

        $message = $json['message'];
        if (isset($json['errors']) && is_array($json['errors'])) {
            $message .= $this->addErrorMessages($json['errors']);
        }
        if (is_null($message) && isset($json['reason'])) {
            $message = $json['reason'];
        }

        if (is_null($message)) {
            throw $this->createRuntimeException('Failed to extract error message from JSON response.');
        }
        throw $this->createException($message);
    }

    /**
     * @param array $errors
     * @return string
     */
    private function addErrorMessages(array $errors): string
    {
        $message = ' (';
        foreach ($errors as $k => $err) {
            $message .= $k . ' : ';
            if (is_array($err['messages'])) {
                foreach ($err['messages'] as $m) {
                    $message .= $m . ' ';
                }
            } else {
                $message .= $err['messages'];
            }
        }
        $message .= ')';

        return $message;
    }

    /**
     * In stream mode, contents can be obtained only once, so this method makes it reusable.
     * @return string
     */
    private function getResponseBody(): string
    {
        if (is_null($this->responseBody)) {
            $this->responseBody = $this->response->getBody()->getContents();
        }

        return $this->responseBody;
    }

    /**
     * @param string $message
     * @return RequestException
     */
    private function createException(string $message): RequestException
    {
        $level = (int) floor($this->response->getStatusCode() / 100);
        $className = RequestException::class;

        if ($level === 4) {
            $className = ClientException::class;
        } elseif ($level === 5) {
            $className = ServerException::class;
        }

        return new $className($message, $this->request, $this->response);
    }

    /**
     * @param string $message
     * @return RuntimeException
     */
    private function createRuntimeException(string $message): RuntimeException
    {
        return new RuntimeException(
            $message,
            0,
            $this->previousThrowable,
            ['responseBody' => $this->getResponseBody()]
        );
    }
}

ochi51 / cybozu-http

Pull Request — master (#76)

ResponseService::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
