AbstractRequester::handleRequest()

Passed

Pull Request — master (#50)

by Joao

created 2020-04-22 14:51 UTC

↳ Parent: AbstractRequester

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	1
c	0
b	0
f	0
nc	1

<?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 = [];
    protected $assertBody = null;

    /**
     * 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 = null)
    {
        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;
    }

    public function assertBodyContains($contains)
    {
        $this->assertBody = $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);
        }

        $response = $this->handleRequest($request);
        $responseHeader = $response->getHeaders();
        $responseBodyStr = (string) $response->getBody();
        $responseBody = json_decode($responseBodyStr, 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);

        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
                );
            }
        }

        if (!empty($this->assertBody) && strpos($responseBodyStr, $this->assertBody) === false) {
            throw new NotMatchedException("Body does not contain '{$this->assertBody}'");
        }

        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			protected $assertBody = null;
40
41			/**
42			* abstract function to be implemented by derived classes
43			*
44			* This function must be implemented by derived classes. It should process
45			* the given request and return an according response.
46			*
47			* @param RequestInterface $request
48			* @return ResponseInterface
49			*/
50			abstract protected function handleRequest(RequestInterface $request);
51
52			/**
53			* @param Schema $schema
54			* @return $this
55			*/
56			public function withSchema($schema)
57			{
58			$this->schema = $schema;
59
60			return $this;
61			}
62
63			/**
64			* @return bool
65			*/
66			public function hasSchema()
67			{
68			return !empty($this->schema);
69			}
70
71			/**
72			* @param string $method
73			* @return $this
74			*/
75			public function withMethod($method)
76			{
77			$this->method = $method;
78
79			return $this;
80			}
81
82			/**
83			* @param string $path
84			* @return $this
85			*/
86			public function withPath($path)
87			{
88			$this->path = $path;
89
90			return $this;
91			}
92
93			/**
94			* @param array $requestHeader
95			* @return $this
96			*/
97			public function withRequestHeader($requestHeader)
98			{
99			if (is_null($requestHeader)) {
100			$this->requestHeader = [];
101			return $this;
102			}
103
104			$this->requestHeader = array_merge($this->requestHeader, $requestHeader);
105
106			return $this;
107			}
108
109			/**
110			* @param array $query
111			* @return $this
112			*/
113			public function withQuery($query = null)
114			{
115			if (is_null($query)) {
116			$this->query = [];
117			return $this;
118			}
119
120			$this->query = array_merge($this->query, $query);
121
122			return $this;
123			}
124
125			/**
126			* @param null $requestBody
127			* @return $this
128			*/
129			public function withRequestBody($requestBody)
130			{
131			$this->requestBody = $requestBody;
132
133			return $this;
134			}
135
136			public function assertResponseCode($code)
137			{
138			$this->statusExpected = $code;
139
140			return $this;
141			}
142
143			public function assertHeaderContains($header, $contains)
144			{
145			$this->assertHeader[$header] = $contains;
146
147			return $this;
148			}
149
150			public function assertBodyContains($contains)
151			{
152			$this->assertBody = $contains;
153
154			return $this;
155			}
156
157			/**
158			* @return mixed
159			* @throws Exception\DefinitionNotFoundException
160			* @throws Exception\GenericSwaggerException
161			* @throws Exception\HttpMethodNotFoundException
162			* @throws Exception\InvalidDefinitionException
163			* @throws Exception\PathNotFoundException
164			* @throws NotMatchedException
165			* @throws StatusCodeNotMatchedException
166			* @throws MessageException
167			*/
168			public function send()
169			{
170			// Preparing Parameters
171			$paramInQuery = null;
172			if (!empty($this->query)) {
173			$paramInQuery = '?' . http_build_query($this->query);
174			}
175
176			// Preparing Header
177			if (empty($this->requestHeader)) {
178			$this->requestHeader = [];
179			}
180			$header = array_merge(
181			[
182			'Accept' => 'application/json'
183			],
184			$this->requestHeader
185			);
186
187			// Defining Variables
188			$serverUrl = $this->schema->getServerUrl();
189			$basePath = $this->schema->getBasePath();
190			$pathName = $this->path;
191
192			// Check if the body is the expected before request
193			$bodyRequestDef = $this->schema->getRequestParameters("$basePath$pathName", $this->method);
194			$bodyRequestDef->match($this->requestBody);
195
196			// Make the request
197			$request = Request::getInstance(Uri::getInstanceFromString($serverUrl . $pathName . $paramInQuery))
198			->withMethod($this->method);
199
200			if (!empty($this->requestBody)) {
201			$request->withBody(new MemoryStream(json_encode($this->requestBody)));
202			}
203
204			foreach ($header as $key => $value) {
205			$request->withHeader($key, $value);
206			}
207
208			$response = $this->handleRequest($request);
209			$responseHeader = $response->getHeaders();
210			$responseBodyStr = (string) $response->getBody();
211			$responseBody = json_decode($responseBodyStr, true);
212			$statusReturned = $response->getStatusCode();
213
214			// Assert results
215			if ($this->statusExpected != $statusReturned) {
216			throw new StatusCodeNotMatchedException(
217			"Status code not matched: Expected {$this->statusExpected}, got {$statusReturned}",
218			$responseBody
219			);
220			}
221
222			$bodyResponseDef = $this->schema->getResponseParameters(
223			"$basePath$pathName",
224			$this->method,
225			$this->statusExpected
226			);
227			$bodyResponseDef->match($responseBody);
228
229			foreach ($this->assertHeader as $key => $value) {
230			if (!isset($responseHeader[$key]) \|\| strpos($responseHeader[$key][0], $value) === false) {
231			throw new NotMatchedException(
232			"Does not exists header '$key' with value '$value'",
233			$responseHeader
234			);
235			}
236			}
237
238			if (!empty($this->assertBody) && strpos($responseBodyStr, $this->assertBody) === false) {
239			throw new NotMatchedException("Body does not contain '{$this->assertBody}'");
240			}
241
242			return $responseBody;
243			}
244			}
245

byjg / php-swagger-test

Pull Request — master (#50)

AbstractRequester::handleRequest()

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like