KleijnWeb\SwaggerBundle\Test\ApiTestCase

Complexity

Total Complexity

27

Size/Duplication

Total Lines	267
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	5
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
B	initSchemaManager()	0	26	2
A	setUp()	0	6	2
A	createClient()	0	9	1
A	get()	0	4	1
A	delete()	0	4	1
A	patch()	0	4	1
A	post()	0	4	1
A	put()	0	4	1
A	sendRequest()	0	12	3
A	assembleUri()	0	9	2
B	getJsonForLastRequest()	0	37	6
B	validateResponse()	0	27	6

<?php

For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 21 and the first side effect is on line 2.

declare(strict_types=1);
/*
 * This file is part of the KleijnWeb\SwaggerBundle package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace KleijnWeb\SwaggerBundle\Test;

use FR3D\SwaggerAssertions\{PhpUnit\AssertsTrait, SchemaManager};
use org\bovigo\vfs\{vfsStream, vfsStreamDirectory, vfsStreamWrapper};
use Symfony\Component\{Yaml\Yaml, HttpFoundation\Response};
use KleijnWeb\SwaggerBundle\Document\{DocumentRepository, SwaggerDocument};
use JsonSchema\Validator;

/**
 * @author John Kleijn <john@kleijnweb.nl>
 */
trait ApiTestCase
{
    use AssertsTrait;

    /**
     * @var SchemaManager
     */
    protected static $schemaManager;

    /**
     * @var SwaggerDocument
     */
    protected static $document;

    /**
     * @var ApiTestClient
     */
    protected $client;

    /**
     * PHPUnit cannot add this to code coverage
     *
     * @codeCoverageIgnore
     *
     * @param $swaggerPath
     *
     * @throws \InvalidArgumentException
     * @throws \org\bovigo\vfs\vfsStreamException
     */
    public static function initSchemaManager($swaggerPath)
    {
        $validator = new Validator();
        $validator->check(
            json_decode(json_encode(Yaml::parse(file_get_contents($swaggerPath)))),
            json_decode(file_get_contents(__DIR__ . '/../../assets/swagger-schema.json'))
        );

        if (!$validator->isValid()) {
            throw new \InvalidArgumentException(
                "Swagger '$swaggerPath' not valid"
            );
        }

        vfsStreamWrapper::register();
        vfsStreamWrapper::setRoot(new vfsStreamDirectory('root'));

        file_put_contents(
            vfsStream::url('root') . '/swagger.json',
            json_encode(Yaml::parse(file_get_contents($swaggerPath)))
        );

        self::$schemaManager = new SchemaManager(vfsStream::url('root') . '/swagger.json');

It seems like new \FR3D\SwaggerAssertions\SchemaManager(\org\bovigo\vfs\vfsStream::url('root') . '/swagger.json') of type object<FR3D\SwaggerAssertions\SchemaManager> is incompatible with the declared type object<SchemaManager> of property $schemaManager.

        $repository = new DocumentRepository(dirname($swaggerPath));
        self::$document = $repository->get(basename($swaggerPath));

It seems like $repository->get(basename($swaggerPath)) of type object<KleijnWeb\SwaggerBundle\Document\SwaggerDocument> is incompatible with the declared type object<SwaggerDocument> of property $document.

    }

    /**
     * Create a client, booting the kernel using SYMFONY_ENV = $this->env
     */
    protected function setUp()
    {
        $this->client = static::createClient(['environment' => $this->env ?: 'test', 'debug' => true]);

The property env does not exist. Did you maybe forget to declare it?

It seems like static::createClient(array('environment' => $this->env ?: 'test', 'debug' => true)) of type object<KleijnWeb\SwaggerBundle\Test\Client> is incompatible with the declared type object<KleijnWeb\SwaggerBundle\Test\ApiTestClient> of property $client.

        parent::setUp();
    }

    /**
     * Creates a Client.
     *
     * @param array $options An array of options to pass to the createKernel class
     * @param array $server  An array of server parameters
     *
     * @return Client A Client instance
     */
    protected static function createClient(array $options = array(), array $server = array())
    {
        static::bootKernel($options);

        $client = static::$kernel->getContainer()->get('swagger.test.client');
        $client->setServerParameters($server);

        return $client;
    }


    /**
     * @param string $path
     * @param array  $params
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function get($path, array $params = [])
    {
        return $this->sendRequest($path, 'GET', $params);

'GET' is of type string, but the function expects a array.

    }

    /**
     * @param string $path
     * @param array  $params
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function delete($path, array $params = [])
    {
        return $this->sendRequest($path, 'DELETE', $params);

'DELETE' is of type string, but the function expects a array.

    }

    /**
     * @param string $path
     * @param array  $content
     * @param array  $params
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function patch($path, array $content, array $params = [])
    {
        return $this->sendRequest($path, 'PATCH', $params, $content);

'PATCH' is of type string, but the function expects a array.

    }

    /**
     * @param string $path
     * @param array  $content
     * @param array  $params
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function post($path, array $content, array $params = [])
    {
        return $this->sendRequest($path, 'POST', $params, $content);

'POST' is of type string, but the function expects a array.

    }

    /**
     * @param string $path
     * @param array  $content
     * @param array  $params
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function put($path, array $content, array $params = [])
    {
        return $this->sendRequest($path, 'PUT', $params, $content);

'PUT' is of type string, but the function expects a array.

    }

    /**
     * @param string     $path
     * @param array      $method
     * @param array      $params
     * @param array|null $content
     *
     * @return \stdClass
     * @throws ApiResponseErrorException
     */
    protected function sendRequest($path, $method, array $params = [], array $content = null)
    {
        $request = new ApiRequest($this->assembleUri($path, $params), $method);

$method is of type array, but the function expects a string.

        $defaults = $this->defaultServerVars ?? [];

The property defaultServerVars does not exist. Did you maybe forget to declare it?

        $request->setServer(array_merge($defaults ?: [], ['CONTENT_TYPE' => 'application/json']));
        if ($content !== null) {
            $request->setContent(json_encode($content));
        }
        $this->client->requestFromRequest($request);

        return $this->getJsonForLastRequest($path, $method);

$method is of type array, but the function expects a string.

    }


    /**
     * @param string $path
     * @param array  $params
     *
     * @return string
     */
    private function assembleUri($path, array $params = [])
    {
        $uri = $path;
        if ($params) {

The expression $params of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $uri = $path . '?' . http_build_query($params);
        }

        return $uri;
    }

    /**
     * @param string $fullPath
     * @param string $method
     *
     * @return \stdClass|null
     * @throws ApiResponseErrorException
     */
    private function getJsonForLastRequest($fullPath, $method)
    {
        $method = strtolower($method);
        $response = $this->client->getResponse();
        $json = $response->getContent();
        $data = json_decode($json);

        if ($response->getStatusCode() !== 204) {
            static $errors = [
                JSON_ERROR_NONE           => 'No error',
                JSON_ERROR_DEPTH          => 'Maximum stack depth exceeded',
                JSON_ERROR_STATE_MISMATCH => 'State mismatch (invalid or malformed JSON)',
                JSON_ERROR_CTRL_CHAR      => 'Control character error, possibly incorrectly encoded',
                JSON_ERROR_SYNTAX         => 'Syntax error',
                JSON_ERROR_UTF8           => 'Malformed UTF-8 characters, possibly incorrectly encoded'
            ];
            $error = json_last_error();
            $jsonErrorMessage = isset($errors[$error]) ? $errors[$error] : 'Unknown error';
            $this->assertSame(

It seems like assertSame() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                JSON_ERROR_NONE,
                json_last_error(),
                "Not valid JSON: " . $jsonErrorMessage . "(" . var_export($json, true) . ")"
            );
        }

        if (substr((string)$response->getStatusCode(), 0, 1) != '2') {
            if (!isset($this->validateErrorResponse) || $this->validateErrorResponse) {

The property validateErrorResponse does not exist. Did you maybe forget to declare it?

                $this->validateResponse($response->getStatusCode(), $response, $method, $fullPath, $data);
            }
            // This throws an exception so that tests can catch it when it is expected
            throw new ApiResponseErrorException($json, $data, $response->getStatusCode());
        }

        $this->validateResponse($response->getStatusCode(), $response, $method, $fullPath, $data);

        return $data;
    }

    /**
     * @param          $code
     * @param Response $response
     * @param string   $method
     * @param string   $fullPath
     * @param mixed    $data
     */
    private function validateResponse($code, $response, $method, $fullPath, $data)
    {
        $request = $this->client->getRequest();
        if (!self::$schemaManager->hasPath(['paths', $request->get('_swagger_path'), $method, 'responses', $code])) {
            $statusClass = (int)substr((string)$code, 0, 1);
            if (in_array($statusClass, [4, 5])) {
                return;
            }
            throw new \UnexpectedValueException(
                "There is no $code response definition for {$request->get('_swagger_path')}:$method. "
            );
        }
        $headers = [];

        foreach ($response->headers->all() as $key => $values) {
            $headers[str_replace(' ', '-', ucwords(str_replace('-', ' ', $key)))] = $values[0];
        }
        try {
            $this->assertResponseHeadersMatch($headers, self::$schemaManager, $fullPath, $method, $code);
            $this->assertResponseBodyMatch($data, self::$schemaManager, $fullPath, $method, $code);
        } catch (\UnexpectedValueException $e) {
            $statusClass = (int)(string)$code[0];
            if (in_array($statusClass, [4, 5])) {
                return;
            }
        }
    }
}