Client::assertRequestHasValidBody() - Code Metrics - Inspection of "Add support for using Buzz\Browser instance (fixes..." - php-http/buzz-adapter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

unknown

created 2016-07-07 16:56 UTC

Client::assertRequestHasValidBody() A

↳ Parent: Client

Complexity

Conditions	4
Paths	2

Size

Total Lines	21
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	20

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
c	2
b	0
f	1
dl	0
loc	21
ccs	0
cts	0
cp	0
rs	9.0534
cc	4
eloc	12
nc	2
nop	1
crap	20

<?php

namespace Http\Adapter\Buzz;

use Buzz\Browser;
use Buzz\Client\ClientInterface;
use Buzz\Client\Curl;
use Buzz\Client\FileGetContents;
use Buzz\Exception as BuzzException;
use Buzz\Message\Request as BuzzRequest;
use Buzz\Message\RequestInterface as BuzzRequestInterface;
use Buzz\Message\Response as BuzzResponse;
use Http\Client\HttpClient;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\MessageFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Http\Client\Exception as HttplugException;

/**
 * @author Tobias Nyholm <[email protected]>
 */
class Client implements HttpClient
{

    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @var MessageFactory
     */
    private $messageFactory;

    /**
     * @param ClientInterface|Browser|null $client
     * @param MessageFactory|null          $messageFactory
     */
    public function __construct($client = null, MessageFactory $messageFactory = null)
    {
        $this->client = $client;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        if ($this->client === null) {
            $this->client = new FileGetContents();
            $this->client->setMaxRedirects(0);
        }

        if ((!$this->client instanceof ClientInterface) && (!$this->client instanceof Browser)) {
            throw new \InvalidArgumentException(
                sprintf(
                    'The client passed to the Buzz adapter must either implement %s or be an instance of %s. You passed %s.',
                    ClientInterface::class,
                    Browser::class,
                    is_object($client) ? get_class($client) : gettype($client)
                )
            );
        }

        $this->messageFactory = $messageFactory ?: MessageFactoryDiscovery::find();
    }

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

        $buzzRequest = $this->createRequest($request);

        try {
            $buzzResponse = new BuzzResponse();
            $this->client->send($buzzRequest, $buzzResponse);
        } catch (BuzzException\ClientException $e) {
            throw new HttplugException\TransferException($e->getMessage(), 0, $e);
        }

        return $this->createResponse($buzzResponse);
    }

    /**
     * Converts a PSR request into a BuzzRequest request.
     *
     * @param RequestInterface $request
     *
     * @return BuzzRequest
     */
    private function createRequest(RequestInterface $request)
    {
        $buzzRequest = new BuzzRequest();
        $buzzRequest->setMethod($request->getMethod());
        $buzzRequest->fromUrl($request->getUri()->__toString());
        $buzzRequest->setProtocolVersion($request->getProtocolVersion());
        $buzzRequest->setContent((string) $request->getBody());

        $this->addPsrHeadersToBuzzRequest($request, $buzzRequest);

        return $buzzRequest;
    }

    /**
     * Converts a Buzz response into a PSR response.
     *
     * @param BuzzResponse $response
     *
     * @return ResponseInterface
     */
    private function createResponse(BuzzResponse $response)
    {
        $body = $response->getContent();

        return $this->messageFactory->createResponse(
            $response->getStatusCode(),
            null,
            $this->getBuzzHeaders($response),
            $body,
            number_format($response->getProtocolVersion(), 1)
        );
    }

    /**
     * Apply headers on a Buzz request.
     *
     * @param RequestInterface $request
     * @param BuzzRequest      $buzzRequest
     */
    private function addPsrHeadersToBuzzRequest(RequestInterface $request, BuzzRequest $buzzRequest)
    {
        $headers = $request->getHeaders();
        foreach ($headers as $name => $values) {
            foreach ($values as $header) {
                $buzzRequest->addHeader($name.': '.$header);
            }
        }
    }

    /**
     * Get headers from a Buzz response.
     *
     * @param BuzzResponse $response
     *
     * @return array
     */
    private function getBuzzHeaders(BuzzResponse $response)
    {
        $buzzHeaders = $response->getHeaders();
        unset($buzzHeaders[0]);
        $headers = [];
        foreach ($buzzHeaders as $headerLine) {
            list($name, $value) = explode(':', $headerLine, 2);
            $headers[$name] = trim($value);
        }

        return $headers;
    }

    /**
     * Assert that the request has a valid body based on the request method.
     *
     * @param RequestInterface $request
     */
    private function assertRequestHasValidBody(RequestInterface $request)
    {
        $validMethods = [
            BuzzRequestInterface::METHOD_POST,
            BuzzRequestInterface::METHOD_PUT,
            BuzzRequestInterface::METHOD_DELETE,
            BuzzRequestInterface::METHOD_PATCH,
            BuzzRequestInterface::METHOD_OPTIONS,
        ];

        // The Buzz Curl client does not send request bodies for request methods such as GET, HEAD and TRACE. Instead of
        // silently ignoring the request body in these cases, throw an exception to make users aware.
        if ($this->client instanceof Curl &&
            $request->getBody()->getContents() &&
            !in_array(strtoupper($request->getMethod()), $validMethods, true)
        ) {
            throw new \InvalidArgumentException(
                sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod())
            );
        }
    }
}


1		<?php
2
3		namespace Http\Adapter\Buzz;
4
5		use Buzz\Browser;
6		use Buzz\Client\ClientInterface;
7		use Buzz\Client\Curl;
8		use Buzz\Client\FileGetContents;
9		use Buzz\Exception as BuzzException;
10		use Buzz\Message\Request as BuzzRequest;
11		use Buzz\Message\RequestInterface as BuzzRequestInterface;
12		use Buzz\Message\Response as BuzzResponse;
13		use Http\Client\HttpClient;
14		use Http\Discovery\MessageFactoryDiscovery;
15		use Http\Message\MessageFactory;
16		use Psr\Http\Message\RequestInterface;
17		use Psr\Http\Message\ResponseInterface;
18		use Http\Client\Exception as HttplugException;
19
20		/**
21		* @author Tobias Nyholm <[email protected]>
22		*/
23		class Client implements HttpClient
24		{
25
26		/**
27		* @var ClientInterface
28		*/
29		private $client;
30
31		/**
32		* @var MessageFactory
33		*/
34		private $messageFactory;
35
36	53	/**
37		* @param ClientInterface\|Browser\|null $client
38	53	* @param MessageFactory\|null $messageFactory
39	53	*/
40		public function __construct($client = null, MessageFactory $messageFactory = null)
41	53	{
42	53	$this->client = $client;
		0 ignored issues – show Documentation Bug introduced 2016-07-06 09:36 UTC by Report Bug Copy Issue Report It seems like `$client` can also be of type `object<Buzz\Browser>`. However, the property `$client` is declared as type `object<Buzz\Client\ClientInterface>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
43
44		if ($this->client === null) {
45		$this->client = new FileGetContents();
46		$this->client->setMaxRedirects(0);
47	53	}
48
49	53	if ((!$this->client instanceof ClientInterface) && (!$this->client instanceof Browser)) {
50		throw new \InvalidArgumentException(
51		sprintf(
52	53	'The client passed to the Buzz adapter must either implement %s or be an instance of %s. You passed %s.',
53	53	ClientInterface::class,
54	53	Browser::class,
55	1	is_object($client) ? get_class($client) : gettype($client)
56		)
57		);
58	52	}
59
60		$this->messageFactory = $messageFactory ?: MessageFactoryDiscovery::find();
61		}
62
63		/**
64		* {@inheritdoc}
65		*/
66		public function sendRequest(RequestInterface $request)
67		{
68	53	$this->assertRequestHasValidBody($request);
69
70	53	$buzzRequest = $this->createRequest($request);
71	53
72	53	try {
73	53	$buzzResponse = new BuzzResponse();
74	53	$this->client->send($buzzRequest, $buzzResponse);
75		} catch (BuzzException\ClientException $e) {
76	53	throw new HttplugException\TransferException($e->getMessage(), 0, $e);
77		}
78	53
79		return $this->createResponse($buzzResponse);
80		}
81
82		/**
83		* Converts a PSR request into a BuzzRequest request.
84		*
85		* @param RequestInterface $request
86		*
87		* @return BuzzRequest
88	52	*/
89		private function createRequest(RequestInterface $request)
90	52	{
91		$buzzRequest = new BuzzRequest();
92	52	$buzzRequest->setMethod($request->getMethod());
93	52	$buzzRequest->fromUrl($request->getUri()->__toString());
94	52	$buzzRequest->setProtocolVersion($request->getProtocolVersion());
95	52	$buzzRequest->setContent((string) $request->getBody());
96	52
97	52	$this->addPsrHeadersToBuzzRequest($request, $buzzRequest);
98	52
99		return $buzzRequest;
100		}
101
102		/**
103		* Converts a Buzz response into a PSR response.
104		*
105		* @param BuzzResponse $response
106		*
107	53	* @return ResponseInterface
108	1	*/
109	53	private function createResponse(BuzzResponse $response)
110	53	{
111	53	$body = $response->getContent();
112	53
113	53	return $this->messageFactory->createResponse(
114	53	$response->getStatusCode(),
115	53	null,
116		$this->getBuzzHeaders($response),
117		$body,
118		number_format($response->getProtocolVersion(), 1)
119		);
120		}
121
122		/**
123		* Apply headers on a Buzz request.
124	52	*
125		* @param RequestInterface $request
126	52	* @param BuzzRequest $buzzRequest
127	52	*/
128	52	private function addPsrHeadersToBuzzRequest(RequestInterface $request, BuzzRequest $buzzRequest)
129	52	{
130	52	$headers = $request->getHeaders();
131	52	foreach ($headers as $name => $values) {
132	52	foreach ($values as $header) {
133		$buzzRequest->addHeader($name.': '.$header);
134	52	}
135		}
136		}
137
138		/**
139		* Get headers from a Buzz response.
140		*
141		* @param BuzzResponse $response
142		*
143		* @return array
144		*/
145		private function getBuzzHeaders(BuzzResponse $response)
146		{
147		$buzzHeaders = $response->getHeaders();
148		unset($buzzHeaders[0]);
149		$headers = [];
150		foreach ($buzzHeaders as $headerLine) {
151		list($name, $value) = explode(':', $headerLine, 2);
152		$headers[$name] = trim($value);
153		}
154
155		return $headers;
156		}
157
158		/**
159		* Assert that the request has a valid body based on the request method.
160		*
161		* @param RequestInterface $request
162		*/
163		private function assertRequestHasValidBody(RequestInterface $request)
164		{
165		$validMethods = [
166		BuzzRequestInterface::METHOD_POST,
167		BuzzRequestInterface::METHOD_PUT,
168		BuzzRequestInterface::METHOD_DELETE,
169		BuzzRequestInterface::METHOD_PATCH,
170		BuzzRequestInterface::METHOD_OPTIONS,
171		];
172
173		// The Buzz Curl client does not send request bodies for request methods such as GET, HEAD and TRACE. Instead of
174		// silently ignoring the request body in these cases, throw an exception to make users aware.
175		if ($this->client instanceof Curl &&
176		$request->getBody()->getContents() &&
177		!in_array(strtoupper($request->getMethod()), $validMethods, true)
178		) {
179		throw new \InvalidArgumentException(
180		sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod())
181		);
182		}
183		}
184		}
185

php-http / buzz-adapter

Pull Request — master (#4)

Client::assertRequestHasValidBody() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like