Behapi\Context\JsonMatcher

Complexity

Total Complexity

9

Size/Duplication

Total Lines	85
Duplicated Lines	44.71 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	root_should_match()	0	15	2
A	path_should_match()	19	19	2
A	path_should_not_match()	19	19	2
A	getJson()	0	4	1
A	getValue()	0	4	1

<?php
namespace Behapi\Context;

use InvalidArgumentException;

use Behat\Behat\Context\Context;
use Behat\Gherkin\Node\PyStringNode;

use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessor;

use Behapi\Tools\HttpHistory;
use Behapi\Tools\BehapiFactory;

class JsonMatcher implements Context
{
    use ApiTrait;

    /** @var BehapiFactory */
    private $factory;

    /** @var PropertyAccessor */
    private $accessor;

    public function __construct(HttpHistory $history)

The parameter $history is not used and could be removed.

    {
        $this->factory = new BehapiFactory;
        $this->accessor = PropertyAccess::createPropertyAccessor();
    }

    /** @Then the root should match: */
    public function root_should_match(PyStringNode $pattern)
    {
        $matcher = $this->factory->createMatcher();

        if ($matcher->match($this->getJson(), $pattern->getRaw())) {
            return;
        }

        throw new InvalidArgumentException(
            sprintf(
                'The json root does not match with the given pattern (error : %s)',
                $matcher->getError()
            )
        );
    }

    /** @Then in the json, :path should match: */
    public function path_should_match(string $path, PyStringNode $pattern)
    {
        $value = $this->getValue($path);
        $matcher = $this->factory->createMatcher();

        $json = json_encode($value);

        if ($matcher->match($json, $pattern->getRaw())) {
            return;
        }

        throw new InvalidArgumentException(
            sprintf(
                'The json path "%s" does not match with the given pattern (error : %s)',
                $path,
                $matcher->getError()
            )
        );
    }

    /** @Then in the json, :path should not match: */
    public function path_should_not_match(string $path, PyStringNode $pattern)
    {
        $value = $this->getValue($path);
        $matcher = $this->factory->createMatcher();

        $json = json_encode($value);

        if (!$matcher->match($json, $pattern->getRaw())) {
            return;
        }

        throw new InvalidArgumentException(
            sprintf(
                'The json path "%s" matches with the given pattern (error : %s)',
                $path,
                $matcher->getError()
            )
        );
    }

    private function getJson(): string
    {
        return json_decode((string) $this->getResponse()->getBody());
    }

    private function getValue(string $path)
    {
        return $this->accessor->getValue($this->getJson(), $path);

$this->getJson() is of type string, but the function expects a object|array.

    }
}