PTS\JsonSchema

Complexity

Total Complexity

12

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	setBaseUri()	0	4	1
A	getBaseUri()	0	4	1
A	loadAllSchemas()	0	11	2
A	prepareDirPath()	0	8	2
A	resolveSchemaByPath()	0	4	1
A	validateJsonSchema()	0	11	1
A	getErrorMessage()	0	13	3

<?php
namespace PTS;

use FilesystemIterator;
use JsonSchema\Constraints\Factory;
use JsonSchema\SchemaStorage;
use JsonSchema\Validator;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;

/**
 * Json schema module for codeception
 */
class JsonSchema
{
    protected $baseUri = 'http://demo.org';

    /** @var Validator */
    protected $validator;
    /** @var SchemaStorage */
    protected $schemaStorage;

    public function __construct()
    {
        $this->schemaStorage = new SchemaStorage;
        $this->validator = new Validator( new Factory($this->schemaStorage));
    }

    public function setBaseUri(string $baseUri = 'http://demo.org'): void
    {
        $this->baseUri = $baseUri;
    }

    public function getBaseUri(): string
    {
        return $this->baseUri;
    }

    public function loadAllSchemas(string $schemaDir): void
    {
        $schemaDir = $this->prepareDirPath($schemaDir);

        $iterator = new RecursiveDirectoryIterator($schemaDir, FilesystemIterator::SKIP_DOTS);
        foreach (new RecursiveIteratorIterator($iterator) as $path) {
            $relPath = str_replace($schemaDir, '', $path);
            $schema = json_decode(file_get_contents($path));
            $this->schemaStorage->addSchema($this->baseUri . $relPath, $schema);
        }
    }

    protected function prepareDirPath(string $schemaDir): string
    {
        if (substr($schemaDir, -1) !== DIRECTORY_SEPARATOR) {
            $schemaDir .= DIRECTORY_SEPARATOR;
        }

        return $schemaDir;
    }

    public function resolveSchemaByPath(string $path): \stdClass
    {
        return $this->schemaStorage->getSchema($this->baseUri . $path);
    }

    public function validateJsonSchema(string $response, string $pathSchema): ?string
    {
        $responseData = json_decode($response);
        $schema = $this->resolveSchemaByPath($pathSchema);

        $this->validator->reset();
        $this->validator->validate($responseData, $schema);
        $isValid = $this->validator->isValid();

        return $this->getErrorMessage($isValid);
    }

    protected function getErrorMessage(bool $isValid): ?string
    {
        if ($isValid) {
            return null;
        }

        $message = [];
        foreach ($this->validator->getErrors() as $error) {
            $message[] = sprintf("[%s] %s", $error['property'], $error['message']);
        }

        return implode('; ', $message);
    }
}