RequestExpectationComparator::checkScenarioNameOrThrowException() - Code Metrics - Inspection of "Added new JsonPath condition" - mcustiel/phiremock-server - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Retried Inspection

Pull Request — master (#17)

by Aleksey

created 2024-12-09 06:55 UTC

checkScenarioNameOrThrowException() A

↳ Parent: RequestExpectationComparator

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php
/**
 * This file is part of Phiremock.
 *
 * Phiremock is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Phiremock is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Phiremock.  If not, see <http://www.gnu.org/licenses/>.
 */

namespace Mcustiel\Phiremock\Server\Utils;

use InvalidArgumentException;
use Mcustiel\Phiremock\Domain\Conditions;
use Mcustiel\Phiremock\Domain\Expectation;
use Mcustiel\Phiremock\Server\Model\ScenarioStorage;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Log\LoggerInterface;

class RequestExpectationComparator
{
    /** @var ScenarioStorage */
    private $scenarioStorage;
    /** @var LoggerInterface */
    private $logger;

    public function __construct(
        ScenarioStorage $scenarioStorage,
        LoggerInterface $logger
    ) {
        $this->scenarioStorage = $scenarioStorage;
        $this->logger = $logger;
    }

    public function equals(ServerRequestInterface $httpRequest, Expectation $expectation): bool
    {
        $this->logger->debug('Checking if request matches an expectation');

        if (!$this->isExpectedScenarioState($expectation)) {
            return false;
        }

        $expectedRequest = $expectation->getRequest();

        $foundMatch = $this->compareRequestParts($httpRequest, $expectedRequest);
        $this->logger->debug('Matches? ' . ((bool) $foundMatch ? 'yes' : 'no'));

        return $foundMatch;
    }

    private function compareRequestParts(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        return $this->requestMethodMatchesExpectation($httpRequest, $expectedRequest)
            && $this->requestUrlMatchesExpectation($httpRequest, $expectedRequest)
            && $this->requestBodyMatchesExpectation($httpRequest, $expectedRequest)
            && $this->requestHeadersMatchExpectation($httpRequest, $expectedRequest)
            && $this->requestFormDataMatchExpectation($httpRequest, $expectedRequest)
            && $this->requestJsonMatchesExpectation($httpRequest, $expectedRequest);
    }

    private function isExpectedScenarioState(Expectation $expectation): bool
    {
        if ($expectation->getRequest()->hasScenarioState()) {
            $this->checkScenarioNameOrThrowException($expectation);
            $this->logger->debug('Checking scenario state again expectation');
            $scenarioState = $this->scenarioStorage->getScenarioState(
                $expectation->getScenarioName()
            );
            if (!$expectation->getRequest()->getScenarioState()->equals($scenarioState)) {
                return false;
            }
        }

        return true;
    }

    /** @throws InvalidArgumentException */
    private function checkScenarioNameOrThrowException(Expectation $expectation)
    {
        if (!$expectation->hasScenarioName()) {
            throw new InvalidArgumentException('Expecting scenario state without specifying scenario name');
        }
    }

    private function requestMethodMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        $method = $expectedRequest->getMethod();
        if (!$method) {
            return true;
        }
        $this->logger->debug('Checking METHOD against expectation');

        return $method->getMatcher()->matches($httpRequest->getMethod());
    }

    private function requestUrlMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        $url = $expectedRequest->getUrl();
        if (!$url) {
            return true;
        }
        $this->logger->debug('Checking URL against expectation');

        $requestUrl = $this->getComparableRequestUrl($httpRequest);

        return $url->getMatcher()->matches($requestUrl);
    }

    private function getComparableRequestUrl($httpRequest)
    {
        $requestUrl = $httpRequest->getUri()->getPath();
        if ($httpRequest->getUri()->getQuery()) {
            $requestUrl .= '?' . $httpRequest->getUri()->getQuery();
        }
        if ($httpRequest->getUri()->getFragment()) {
            $requestUrl .= '#' . $httpRequest->getUri()->getFragment();
        }

        return $requestUrl;
    }

    private function requestBodyMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        $bodycondition = $expectedRequest->getBody();
        if (!$bodycondition) {
            return true;
        }
        $this->logger->debug('Checking BODY against expectation');

        return $bodycondition->getMatcher()->matches($httpRequest->getBody()->__toString());
    }

    private function requestHeadersMatchExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        $headerConditions = $expectedRequest->getHeaders();
        if (!$headerConditions) {
            return true;
        }
        $this->logger->debug('Checking HEADERS against expectation');
        foreach ($headerConditions as $header => $headerCondition) {
            $headerName = $header->asString();
            $this->logger->debug("Checking $headerName against expectation");

            $matches = $headerCondition->getMatcher()->matches(
                $httpRequest->getHeaderLine($headerName)
            );
            if (!$matches) {
                return false;
            }
        }

        return true;
    }

    private function requestFormDataMatchExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        $formDataConditions = $expectedRequest->getFormFields();
        if (!$formDataConditions) {
            return true;
        }
        $this->logger->debug('Checking FORM DATA against expectation');
        foreach ($formDataConditions as $field => $fieldCondition) {
            $fieldName = $field->asString();
            $this->logger->debug("Checking $fieldName against expectation");

            if (!isset($httpRequest->getParsedBody()[$fieldName])) {
                return false;
            }

            $matches = $fieldCondition->getMatcher()->matches(
                $httpRequest->getParsedBody()[$fieldName]
            );
            if (!$matches) {
                return false;
            }
        }

        return true;
    }

    private function requestJsonMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
    {
        if (!$expectedRequest->hasJsonPath()) {
            return true;
        }
        
        $this->logger->debug('Checking JSON PATH against expectation');
        
        $requestBody = $httpRequest->getBody()->__toString();
        $requestData = json_decode($requestBody, true);
        
        if (json_last_error() !== JSON_ERROR_NONE) {
            return false;
        }
        
        /** @var JsonPathName $pathName */
        /** @var JsonPathCondition $jsonCondition */
        foreach ($expectedRequest->getJsonPath() as $pathName => $jsonCondition) {
            $path = explode('.', $pathName->asString());
            $value = $requestData;
            
            foreach ($path as $key) {
                if (!is_array($value) || !isset($value[$key])) {
                    return false;
                }
                $value = $value[$key];
            }
            
            if (!$jsonCondition->getMatcher()->matches($value)) {
                return false;
            }
        }
        
        return true;
    }
}


1			<?php
2			/**
3			* This file is part of Phiremock.
4			*
5			* Phiremock is free software: you can redistribute it and/or modify
6			* it under the terms of the GNU Lesser General Public License as published by
7			* the Free Software Foundation, either version 3 of the License, or
8			* (at your option) any later version.
9			*
10			* Phiremock is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			*
15			* You should have received a copy of the GNU General Public License
16			* along with Phiremock. If not, see <http://www.gnu.org/licenses/>.
17			*/
18
19			namespace Mcustiel\Phiremock\Server\Utils;
20
21			use InvalidArgumentException;
22			use Mcustiel\Phiremock\Domain\Conditions;
23			use Mcustiel\Phiremock\Domain\Expectation;
24			use Mcustiel\Phiremock\Server\Model\ScenarioStorage;
25			use Psr\Http\Message\ServerRequestInterface;
26			use Psr\Log\LoggerInterface;
27
28			class RequestExpectationComparator
29			{
30			/** @var ScenarioStorage */
31			private $scenarioStorage;
32			/** @var LoggerInterface */
33			private $logger;
34
35			public function __construct(
36			ScenarioStorage $scenarioStorage,
37			LoggerInterface $logger
38			) {
39			$this->scenarioStorage = $scenarioStorage;
40			$this->logger = $logger;
41			}
42
43			public function equals(ServerRequestInterface $httpRequest, Expectation $expectation): bool
44			{
45			$this->logger->debug('Checking if request matches an expectation');
46
47			if (!$this->isExpectedScenarioState($expectation)) {
48			return false;
49			}
50
51			$expectedRequest = $expectation->getRequest();
52
53			$foundMatch = $this->compareRequestParts($httpRequest, $expectedRequest);
54			$this->logger->debug('Matches? ' . ((bool) $foundMatch ? 'yes' : 'no'));
55
56			return $foundMatch;
57			}
58
59			private function compareRequestParts(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
60			{
61			return $this->requestMethodMatchesExpectation($httpRequest, $expectedRequest)
62			&& $this->requestUrlMatchesExpectation($httpRequest, $expectedRequest)
63			&& $this->requestBodyMatchesExpectation($httpRequest, $expectedRequest)
64			&& $this->requestHeadersMatchExpectation($httpRequest, $expectedRequest)
65			&& $this->requestFormDataMatchExpectation($httpRequest, $expectedRequest)
66			&& $this->requestJsonMatchesExpectation($httpRequest, $expectedRequest);
67			}
68
69			private function isExpectedScenarioState(Expectation $expectation): bool
70			{
71			if ($expectation->getRequest()->hasScenarioState()) {
72			$this->checkScenarioNameOrThrowException($expectation);
73			$this->logger->debug('Checking scenario state again expectation');
74			$scenarioState = $this->scenarioStorage->getScenarioState(
75			$expectation->getScenarioName()
76			);
77			if (!$expectation->getRequest()->getScenarioState()->equals($scenarioState)) {
78			return false;
79			}
80			}
81
82			return true;
83			}
84
85			/** @throws InvalidArgumentException */
86			private function checkScenarioNameOrThrowException(Expectation $expectation)
87			{
88			if (!$expectation->hasScenarioName()) {
89			throw new InvalidArgumentException('Expecting scenario state without specifying scenario name');
90			}
91			}
92
93			private function requestMethodMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
94			{
95			$method = $expectedRequest->getMethod();
96			if (!$method) {
97			return true;
98			}
99			$this->logger->debug('Checking METHOD against expectation');
100
101			return $method->getMatcher()->matches($httpRequest->getMethod());
102			}
103
104			private function requestUrlMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
105			{
106			$url = $expectedRequest->getUrl();
107			if (!$url) {
108			return true;
109			}
110			$this->logger->debug('Checking URL against expectation');
111
112			$requestUrl = $this->getComparableRequestUrl($httpRequest);
113
114			return $url->getMatcher()->matches($requestUrl);
115			}
116
117			private function getComparableRequestUrl($httpRequest)
118			{
119			$requestUrl = $httpRequest->getUri()->getPath();
120			if ($httpRequest->getUri()->getQuery()) {
121			$requestUrl .= '?' . $httpRequest->getUri()->getQuery();
122			}
123			if ($httpRequest->getUri()->getFragment()) {
124			$requestUrl .= '#' . $httpRequest->getUri()->getFragment();
125			}
126
127			return $requestUrl;
128			}
129
130			private function requestBodyMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
131			{
132			$bodycondition = $expectedRequest->getBody();
133			if (!$bodycondition) {
134			return true;
135			}
136			$this->logger->debug('Checking BODY against expectation');
137
138			return $bodycondition->getMatcher()->matches($httpRequest->getBody()->__toString());
139			}
140
141			private function requestHeadersMatchExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
142			{
143			$headerConditions = $expectedRequest->getHeaders();
144			if (!$headerConditions) {
145			return true;
146			}
147			$this->logger->debug('Checking HEADERS against expectation');
148			foreach ($headerConditions as $header => $headerCondition) {
149			$headerName = $header->asString();
150			$this->logger->debug("Checking $headerName against expectation");
151
152			$matches = $headerCondition->getMatcher()->matches(
153			$httpRequest->getHeaderLine($headerName)
154			);
155			if (!$matches) {
156			return false;
157			}
158			}
159
160			return true;
161			}
162
163			private function requestFormDataMatchExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
164			{
165			$formDataConditions = $expectedRequest->getFormFields();
166			if (!$formDataConditions) {
167			return true;
168			}
169			$this->logger->debug('Checking FORM DATA against expectation');
170			foreach ($formDataConditions as $field => $fieldCondition) {
171			$fieldName = $field->asString();
172			$this->logger->debug("Checking $fieldName against expectation");
173
174			if (!isset($httpRequest->getParsedBody()[$fieldName])) {
175			return false;
176			}
177
178			$matches = $fieldCondition->getMatcher()->matches(
179			$httpRequest->getParsedBody()[$fieldName]
180			);
181			if (!$matches) {
182			return false;
183			}
184			}
185
186			return true;
187			}
188
189			private function requestJsonMatchesExpectation(ServerRequestInterface $httpRequest, Conditions $expectedRequest): bool
190			{
191			if (!$expectedRequest->hasJsonPath()) {
192			return true;
193			}
194
195			$this->logger->debug('Checking JSON PATH against expectation');
196
197			$requestBody = $httpRequest->getBody()->__toString();
198			$requestData = json_decode($requestBody, true);
199
200			if (json_last_error() !== JSON_ERROR_NONE) {
201			return false;
202			}
203
204			/** @var JsonPathName $pathName */
205			/** @var JsonPathCondition $jsonCondition */
206			foreach ($expectedRequest->getJsonPath() as $pathName => $jsonCondition) {
207			$path = explode('.', $pathName->asString());
208			$value = $requestData;
209
210			foreach ($path as $key) {
211			if (!is_array($value) \|\| !isset($value[$key])) {
212			return false;
213			}
214			$value = $value[$key];
215			}
216
217			if (!$jsonCondition->getMatcher()->matches($value)) {
218			return false;
219			}
220			}
221
222			return true;
223			}
224			}
225

mcustiel / phiremock-server

Pull Request — master (#17)

checkScenarioNameOrThrowException() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like