Rebilly\OpenAPI\PhpUnit\UriConstraint

Complexity

Total Complexity

25

Size/Duplication

Total Lines	176
Duplicated Lines	10.23 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	1
A	assertPathSegment()	0	9	2
A	assertPathParam()	0	12	1
C	matches()	18	74	13
A	failureDescription()	0	4	1
A	additionalFailureDescription()	0	4	1
A	toString()	0	4	1
A	normalizeUri()	0	8	1
A	normalizeJsonSchema()	0	4	1
A	normalizeNumericString()	0	8	2
A	splitString()	0	4	1

<?php
/**
 * This file is part of Rebilly.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @see http://rebilly.com
 */

namespace Rebilly\OpenAPI\PhpUnit;

use JsonSchema\Entity\JsonPointer;
use PHPUnit\Framework\Constraint\Constraint;
use Psr\Http\Message\UriInterface;
use Rebilly\OpenAPI\JsonSchema\Validator;
use Rebilly\OpenAPI\UnexpectedValueException;
use stdClass;

/**
 * Constraint that asserts that the URI matches the expected
 * allowed schemes, base URI, URI paths and query-params.
 */
final class UriConstraint extends Constraint
{
    private $servers;

    private $path;

    private $pathParameters;

    private $queryParameters;

    private $validator;

    private $errors = [];

    public function __construct(
        array $servers,
        string $path,
        array $pathParameters,
        array $queryParameters
    ) {
        parent::__construct();
        $this->servers = array_map('strtolower', $servers);
        $this->path = $path;
        $this->pathParameters = array_map([$this, 'normalizeJsonSchema'], $pathParameters);
        $this->queryParameters = array_map([$this, 'normalizeJsonSchema'], $queryParameters);
        $this->validator = new Validator('undefined');
    }

    private function assertPathSegment(string $expectedSegment, string $actualSegment)
    {
        if ($actualSegment !== $expectedSegment) {
            $this->errors[] = [
                'property' => 'path',
                'message' => "Missing path segment ({$expectedSegment})",
            ];
        }
    }

    private function assertPathParam(string $expectedSegment, string $actualSegment)
    {
        $pathParamSchema = $this->pathParameters[substr($expectedSegment, 1, -1)];

        // TODO: Consider to disallow non-string params in path, that make no sense
        $actualSegment = $this->normalizeNumericString($actualSegment);

        $this->errors = array_merge(
            $this->errors,
            $this->validator->validate($actualSegment, $pathParamSchema, new JsonPointer('#/path'))
        );
    }

    protected function matches($uri): bool
    {
        if (!$uri instanceof UriInterface) {
            throw new UnexpectedValueException('The object should implements UriInterface');
        }

        $baseUrl = null;

        foreach ($this->servers as $serverUrl) {
            if (strpos((string) $uri, $serverUrl) === 0) {
                $baseUrl = $serverUrl;

                continue;
            }
        }

        if ($baseUrl === null) {
            $this->errors[] = [
                'property' => 'baseUrl',
                'message' => sprintf('Unexpected URL, does not found in defined servers (%s)', implode(', ', $this->servers)),
            ];

            return false;
        }

        $pathStart = strlen($baseUrl) - strpos($baseUrl, '/', strpos($baseUrl, '://') + 3);
        $path = substr($uri->getPath(), $pathStart + 1);
        $actualSegments = $this->splitString('#\/#', $path);
        $expectedSegments = $this->splitString('#\/#', $this->path);

        if (count($actualSegments) !== count($expectedSegments)) {
            $this->errors[] = [
                'property' => 'path',
                'message' => "Unexpected URI path, does not match the template ({$this->path})",
            ];

            return false;
        }

        foreach ($expectedSegments as $i => $expectedSegment) {
            $actualSegment = $actualSegments[$i];
            strpos($expectedSegment, '{') === false
                ? $this->assertPathSegment($expectedSegment, $actualSegment)
                : $this->assertPathParam($expectedSegment, $actualSegment);
        }

        if (!empty($this->errors)) {
            return false;
        }

        parse_str($uri->getQuery(), $actualQueryParams);

        // TODO: Assert query params
        foreach ($this->queryParameters as $name => $queryParamSchema) {

This code seems to be duplicated across your project.

            if (isset($actualQueryParams[$name])) {
                $actualQueryParam = $actualQueryParams[$name];

                // TODO: Consider to disallow non-string params in query, that make no sense
                $actualQueryParam = $this->normalizeNumericString($actualQueryParam);

                $this->errors = array_merge(
                    $this->errors,
                    $this->validator->validate($actualQueryParam, $queryParamSchema, new JsonPointer('#/query'))
                );
            } elseif (isset($queryParamSchema->required) && $queryParamSchema->required) {
                $this->errors[] = [
                    'property' => 'query',
                    'message' => "Missing required query param ({$name})",
                ];
            }
        }

        return empty($this->errors);
    }

    protected function failureDescription($other): string
    {
        return json_encode((object) $this->normalizeUri($other)) . ' ' . $this->toString();
    }

    protected function additionalFailureDescription($other): string
    {
        return $this->validator->serializeErrors($this->errors);
    }

    public function toString(): string
    {
        return 'matches an specified URI parts';
    }

    private static function normalizeUri(UriInterface $uri): array

This method is not used, and could be removed.

    {
        return [
            'schema' => $uri->getScheme(),
            'host' => $uri->getHost(),
            'path' => $uri->getPath(),
        ];
    }

    private static function normalizeJsonSchema($schema): stdClass
    {
        return (object) $schema;
    }

    /**
     * Cast numeric values, JSON validator does not do it.
     *
     * @param mixed $value
     *
     * @return mixed
     */
    private static function normalizeNumericString($value)
    {
        if (is_numeric($value)) {
            $value += 0;
        }

        return $value;
    }

    private static function splitString(string $pattern, string $subject): array
    {
        return preg_split($pattern, $subject, -1, PREG_SPLIT_NO_EMPTY);
    }
}