AbstractRequester::hasSchema() - Code Metrics - Inspection of "Change the HttpClient to support Mock HTTP" - byjg/php-swagger-test - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#50)

by Joao

created 2020-04-21 16:28 UTC

AbstractRequester::hasSchema() A

↳ Parent: AbstractRequester

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace ByJG\ApiTools;

use ByJG\ApiTools\Base\Schema;
use ByJG\ApiTools\Exception\NotMatchedException;
use ByJG\ApiTools\Exception\StatusCodeNotMatchedException;
use ByJG\Util\Psr7\MessageException;
use ByJG\Util\Psr7\Request;
use ByJG\Util\Uri;
use MintWare\Streams\MemoryStream;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;

/**
 * Abstract baseclass for request handlers.
 *
 * The baseclass provides processing and verification of request and response.
 * It only delegates the actual message exchange to the derived class. For the
 * messages, it uses the PSR-7 implementation from Guzzle.
 *
 * This is an implementation of the Template Method Patttern
 * (https://en.wikipedia.org/wiki/Template_method_pattern).
 */
abstract class AbstractRequester
{
    protected $method = 'get';
    protected $path = '/';
    protected $requestHeader = [];
    protected $query = [];
    protected $requestBody = null;
    /**
     * @var Schema
     */
    protected $schema = null;

    protected $statusExpected = 200;
    protected $assertHeader = [];

    /**
     * abstract function to be implemented by derived classes
     *
     * This function must be implemented by derived classes. It should process
     * the given request and return an according response.
     *
     * @param RequestInterface $request
     * @return ResponseInterface
     */
    abstract protected function handleRequest(RequestInterface $request);

    /**
     * @param Schema $schema
     * @return $this
     */
    public function withSchema($schema)
    {
        $this->schema = $schema;

        return $this;
    }

    /**
     * @return bool
     */
    public function hasSchema()
    {
        return !empty($this->schema);
    }

    /**
     * @param string $method
     * @return $this
     */
    public function withMethod($method)
    {
        $this->method = $method;

        return $this;
    }

    /**
     * @param string $path
     * @return $this
     */
    public function withPath($path)
    {
        $this->path = $path;

        return $this;
    }

    /**
     * @param array $requestHeader
     * @return $this
     */
    public function withRequestHeader($requestHeader)
    {
        if (is_null($requestHeader)) {
            $this->requestHeader = [];
            return $this;
        }

        $this->requestHeader = array_merge($this->requestHeader, $requestHeader);

        return $this;
    }

    /**
     * @param array $query
     * @return $this
     */
    public function withQuery($query)
    {
        if (is_null($query)) {
            $this->query = [];
            return $this;
        }

        $this->query = array_merge($this->query, $query);

        return $this;
    }

    /**
     * @param null $requestBody
     * @return $this
     */
    public function withRequestBody($requestBody)
    {
        $this->requestBody = $requestBody;

        return $this;
    }

    public function assertResponseCode($code)
    {
        $this->statusExpected = $code;

        return $this;
    }

    public function assertHeaderContains($header, $contains)
    {
        $this->assertHeader[$header] = $contains;

        return $this;
    }

    /**
     * @return mixed
     * @throws Exception\DefinitionNotFoundException
     * @throws Exception\GenericSwaggerException
     * @throws Exception\HttpMethodNotFoundException
     * @throws Exception\InvalidDefinitionException
     * @throws Exception\PathNotFoundException
     * @throws NotMatchedException
     * @throws StatusCodeNotMatchedException
     * @throws MessageException
     */
    public function send()
    {
        // Preparing Parameters
        $paramInQuery = null;
        if (!empty($this->query)) {
            $paramInQuery = '?' . http_build_query($this->query);
        }

        // Preparing Header
        if (empty($this->requestHeader)) {
            $this->requestHeader = [];
        }
        $header = array_merge(
            [
                'Accept' => 'application/json'
            ],
            $this->requestHeader
        );

        // Defining Variables
        $serverUrl = $this->schema->getServerUrl();
        $basePath = $this->schema->getBasePath();
        $pathName = $this->path;

        // Check if the body is the expected before request
        $bodyRequestDef = $this->schema->getRequestParameters("$basePath$pathName", $this->method);
        $bodyRequestDef->match($this->requestBody);

        // Make the request
        $request = Request::getInstance(Uri::getInstanceFromString($serverUrl . $pathName . $paramInQuery))
            ->withMethod($this->method);

        if (!empty($this->requestBody)) {
            $request->withBody(new MemoryStream(json_encode($this->requestBody)));
        }

        foreach ($header as $key => $value) {
            $request->withHeader($key, $value);
        }

        $statusReturned = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        $response = $this->handleRequest($request);
        $responseHeader = $response->getHeaders();
        $responseBody = json_decode((string) $response->getBody(), true);
        $statusReturned = $response->getStatusCode();

        // Assert results
        if ($this->statusExpected != $statusReturned) {
            throw new StatusCodeNotMatchedException(
                "Status code not matched: Expected {$this->statusExpected}, got {$statusReturned}",
                $responseBody
            );
        }

        $bodyResponseDef = $this->schema->getResponseParameters(
            "$basePath$pathName",
            $this->method,
            $this->statusExpected
        );
        $bodyResponseDef->match($responseBody);

        if (count($this->assertHeader) > 0) {
            foreach ($this->assertHeader as $key => $value) {
                if (!isset($responseHeader[$key]) || strpos($responseHeader[$key][0], $value) === false) {
                    throw new NotMatchedException(
                        "Does not exists header '$key' with value '$value'",
                        $responseHeader
                    );
                }
            }
        }

        return $responseBody;
    }
}


1			<?php
2
3			namespace ByJG\ApiTools;
4
5			use ByJG\ApiTools\Base\Schema;
6			use ByJG\ApiTools\Exception\NotMatchedException;
7			use ByJG\ApiTools\Exception\StatusCodeNotMatchedException;
8			use ByJG\Util\Psr7\MessageException;
9			use ByJG\Util\Psr7\Request;
10			use ByJG\Util\Uri;
11			use MintWare\Streams\MemoryStream;
12			use Psr\Http\Message\RequestInterface;
13			use Psr\Http\Message\ResponseInterface;
14
15			/**
16			* Abstract baseclass for request handlers.
17			*
18			* The baseclass provides processing and verification of request and response.
19			* It only delegates the actual message exchange to the derived class. For the
20			* messages, it uses the PSR-7 implementation from Guzzle.
21			*
22			* This is an implementation of the Template Method Patttern
23			* (https://en.wikipedia.org/wiki/Template_method_pattern).
24			*/
25			abstract class AbstractRequester
26			{
27			protected $method = 'get';
28			protected $path = '/';
29			protected $requestHeader = [];
30			protected $query = [];
31			protected $requestBody = null;
32			/**
33			* @var Schema
34			*/
35			protected $schema = null;
36
37			protected $statusExpected = 200;
38			protected $assertHeader = [];
39
40			/**
41			* abstract function to be implemented by derived classes
42			*
43			* This function must be implemented by derived classes. It should process
44			* the given request and return an according response.
45			*
46			* @param RequestInterface $request
47			* @return ResponseInterface
48			*/
49			abstract protected function handleRequest(RequestInterface $request);
50
51			/**
52			* @param Schema $schema
53			* @return $this
54			*/
55			public function withSchema($schema)
56			{
57			$this->schema = $schema;
58
59			return $this;
60			}
61
62			/**
63			* @return bool
64			*/
65			public function hasSchema()
66			{
67			return !empty($this->schema);
68			}
69
70			/**
71			* @param string $method
72			* @return $this
73			*/
74			public function withMethod($method)
75			{
76			$this->method = $method;
77
78			return $this;
79			}
80
81			/**
82			* @param string $path
83			* @return $this
84			*/
85			public function withPath($path)
86			{
87			$this->path = $path;
88
89			return $this;
90			}
91
92			/**
93			* @param array $requestHeader
94			* @return $this
95			*/
96			public function withRequestHeader($requestHeader)
97			{
98			if (is_null($requestHeader)) {
99			$this->requestHeader = [];
100			return $this;
101			}
102
103			$this->requestHeader = array_merge($this->requestHeader, $requestHeader);
104
105			return $this;
106			}
107
108			/**
109			* @param array $query
110			* @return $this
111			*/
112			public function withQuery($query)
113			{
114			if (is_null($query)) {
115			$this->query = [];
116			return $this;
117			}
118
119			$this->query = array_merge($this->query, $query);
120
121			return $this;
122			}
123
124			/**
125			* @param null $requestBody
126			* @return $this
127			*/
128			public function withRequestBody($requestBody)
129			{
130			$this->requestBody = $requestBody;
131
132			return $this;
133			}
134
135			public function assertResponseCode($code)
136			{
137			$this->statusExpected = $code;
138
139			return $this;
140			}
141
142			public function assertHeaderContains($header, $contains)
143			{
144			$this->assertHeader[$header] = $contains;
145
146			return $this;
147			}
148
149			/**
150			* @return mixed
151			* @throws Exception\DefinitionNotFoundException
152			* @throws Exception\GenericSwaggerException
153			* @throws Exception\HttpMethodNotFoundException
154			* @throws Exception\InvalidDefinitionException
155			* @throws Exception\PathNotFoundException
156			* @throws NotMatchedException
157			* @throws StatusCodeNotMatchedException
158			* @throws MessageException
159			*/
160			public function send()
161			{
162			// Preparing Parameters
163			$paramInQuery = null;
164			if (!empty($this->query)) {
165			$paramInQuery = '?' . http_build_query($this->query);
166			}
167
168			// Preparing Header
169			if (empty($this->requestHeader)) {
170			$this->requestHeader = [];
171			}
172			$header = array_merge(
173			[
174			'Accept' => 'application/json'
175			],
176			$this->requestHeader
177			);
178
179			// Defining Variables
180			$serverUrl = $this->schema->getServerUrl();
181			$basePath = $this->schema->getBasePath();
182			$pathName = $this->path;
183
184			// Check if the body is the expected before request
185			$bodyRequestDef = $this->schema->getRequestParameters("$basePath$pathName", $this->method);
186			$bodyRequestDef->match($this->requestBody);
187
188			// Make the request
189			$request = Request::getInstance(Uri::getInstanceFromString($serverUrl . $pathName . $paramInQuery))
190			->withMethod($this->method);
191
192			if (!empty($this->requestBody)) {
193			$request->withBody(new MemoryStream(json_encode($this->requestBody)));
194			}
195
196			foreach ($header as $key => $value) {
197			$request->withHeader($key, $value);
198			}
199
200			$statusReturned = null;
			0 ignored issues – show Unused Code introduced 2020-04-21 14:27 UTC by Report Bug Copy Issue Report `$statusReturned` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
201
202			$response = $this->handleRequest($request);
203			$responseHeader = $response->getHeaders();
204			$responseBody = json_decode((string) $response->getBody(), true);
205			$statusReturned = $response->getStatusCode();
206
207			// Assert results
208			if ($this->statusExpected != $statusReturned) {
209			throw new StatusCodeNotMatchedException(
210			"Status code not matched: Expected {$this->statusExpected}, got {$statusReturned}",
211			$responseBody
212			);
213			}
214
215			$bodyResponseDef = $this->schema->getResponseParameters(
216			"$basePath$pathName",
217			$this->method,
218			$this->statusExpected
219			);
220			$bodyResponseDef->match($responseBody);
221
222			if (count($this->assertHeader) > 0) {
223			foreach ($this->assertHeader as $key => $value) {
224			if (!isset($responseHeader[$key]) \|\| strpos($responseHeader[$key][0], $value) === false) {
225			throw new NotMatchedException(
226			"Does not exists header '$key' with value '$value'",
227			$responseHeader
228			);
229			}
230			}
231			}
232
233			return $responseBody;
234			}
235			}
236

byjg / php-swagger-test

Pull Request — master (#50)

AbstractRequester::hasSchema() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like