Rebilly\OpenAPI\PhpUnit\HeadersConstraint

Complexity

Total Complexity

13

Size/Duplication

Total Lines	107
Duplicated Lines	14.02 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	1

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	matches()	15	24	6
A	failureDescription()	0	4	1
A	additionalFailureDescription()	0	4	1
A	toString()	0	4	1
A	normalizeJsonSchema()	0	4	1
A	normalizeHeaderValue()	0	8	2

<?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 PHPUnit_Framework_Constraint as Constraint;
use Rebilly\OpenAPI\JsonSchema\Validator;
use Rebilly\OpenAPI\UnexpectedValueException;

/**
 * Constraint that asserts that the headers list matches the expected defined schemas.
 */
final class HeadersConstraint extends Constraint
{
    /**
     * @var array
     */
    private $errors = [];

    /**
     * @var array
     */
    private $expectedHeadersSchemas;

    /**
     * @var Validator
     */
    private $validator;

    /**
     * @param array $expectedHeadersSchemas
     */
    public function __construct(array $expectedHeadersSchemas) {
        parent::__construct();

        $this->expectedHeadersSchemas = array_map([$this, 'normalizeJsonSchema'], $expectedHeadersSchemas);
        $this->validator = new Validator('undefined');
    }

    /**
     * {@inheritdoc}
     */
    protected function matches($actualHeaders)
    {
        if (!is_array($actualHeaders)) {
            throw new UnexpectedValueException('Array expected');
        }

        foreach ($this->expectedHeadersSchemas as $name => $expectedSchema) {

This code seems to be duplicated across your project.

            if (isset($actualHeaders[$name])) {
                $errors = $this->validator->validate(
                    $this->normalizeHeaderValue($actualHeaders[$name]),
                    $expectedSchema,
                    $name
                );
                $this->errors = array_merge($this->errors, $errors);
            } elseif (isset($expectedSchema->required) && $expectedSchema->required) {
                $this->errors[] = [
                    'property' => $name,
                    'message' => "Missing required header ({$name})",
                ];
            }
        }

        return empty($this->errors);
    }

    /**
     * {@inheritdoc}
     */
    protected function failureDescription($other)
    {
        return json_encode($other) . ' ' . $this->toString();
    }

    /**
     * {@inheritdoc}
     */
    protected function additionalFailureDescription($other)
    {
        return $this->validator->serializeErrors($this->errors);
    }

    /**
     * {@inheritdoc}
     */
    public function toString()
    {
        return 'matches an specified headers schemas';
    }

    /**
     * Ensure schema is object.
     *
     * @param object|array $schema
     *
     * @return object
     */
    private static function normalizeJsonSchema($schema)
    {
        return (object) $schema;
    }

    /**
     * Ensure header value is array.
     *
     * @param mixed $value
     *
     * @return array
     */
    private static function normalizeHeaderValue($value)
    {
        if (is_string($value)) {
            return preg_split('#\s*,\s*#', $value, -1, PREG_SPLIT_NO_EMPTY);
        } else {
            return (array) $value;
        }
    }
}