Ynlo\GraphQLBundle\Test\GraphQLHelperTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	212
Duplicated Lines	0 %

Test Coverage

Coverage

85.33%

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
	flattenExpectation()	0	18	?
A	query()	0	7	2
A	hp$0 ➔ literalValue()	0	14	1
A	endpoint()	0	3	1
	graphqlQuery()	0	16	?
A	hp$0 ➔ debugQuery()	0	3	1
B	hp$0 ➔ flattenQuery()	0	32	4
	literalValue()	0	14	?
	debugQuery()	0	3	?
A	hp$0 ➔ __construct()	0	3	1
C	hp$0 ➔ flattenParameters()	0	23	7
B	hp$0 ➔ flattenExpectation()	0	18	6
A	hp$0 ➔ graphqlQuery()	0	16	2
A	hp$0 ➔ __toString()	0	3	1
	flattenParameters()	0	23	?
A	encodeID()	0	3	1
A	decodeID()	0	3	1
	flattenQuery()	0	32	?
A	mutation()	0	3	1

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <support@ynloultratech.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Test;

use Doctrine\Common\Util\Inflector;
use Symfony\Component\BrowserKit\Client;
use Symfony\Component\HttpFoundation\Request;
use Ynlo\GraphQLBundle\Model\ID;

/**
 * @method Client getClient()
 */
trait GraphQLHelperTrait
{
    private static $endpoint;

    private static $query;

    /**
     * @param string $endpoint
     */
    protected static function endpoint($endpoint)
    {
        self::$endpoint = $endpoint;
    }

    /**
     * @param string     $name
     * @param array      $parameters (optional)
     * @param array|null $expected
     */
    protected static function query($name, array $parameters, array $expected = null)
    {
        if (null === $expected) {
            $expected = $parameters;
            $parameters = [];
        }
        self::graphqlQuery('query', $name, $parameters, $expected);
    }

    /**
     * @param string $name
     * @param array  $parameters
     * @param array  $expected
     */
    protected static function mutation($name, array $parameters = [], array $expected = [])
    {
        self::graphqlQuery('mutation', $name, $parameters, $expected);
    }


    /**
     * @param string $nodeType
     * @param string $databaseId
     *
     * @return string
     */
    protected static function encodeID($nodeType, $databaseId)
    {
        return ID::encode($nodeType, $databaseId);
    }

    /**
     * @param string $globalID
     *
     * @return ID
     */
    protected static function decodeID($globalID):ID
    {
        return ID::createFromString($globalID);
    }

    /**
     * @param string $value
     *
     * @return object
     */
    protected static function literalValue($value)
    {
        return new class ($value)
        {
            private $value;

            public function __construct($value)
            {
                $this->value = (string) $value;
            }

            public function __toString()
            {
                return $this->value;
            }
        };
    }

    /**
     * debugQuery
     */
    protected static function debugQuery()
    {
        print_r(self::$query);
    }

    /**
     * @param string $type
     * @param string $name
     * @param array  $parameters
     * @param array  $expected
     */
    private static function graphqlQuery($type, $name, array $parameters = [], array $expected = [])
    {
        $flattenQuery = self::flattenQuery($name, $parameters, $expected);
        if (strpos($name, '.') !== false) {
            $name = Inflector::camelize(str_replace('.', '_', $name));
        }
        $query =
            <<<GrahpQL
$type $name{
  $flattenQuery
}
GrahpQL;

        $body = ['query' => $query];
        self::$query = $query;
        self::getClient()->request(Request::METHOD_POST, self::$endpoint, [], [], [], json_encode($body));

The method Ynlo\GraphQLBundle\Test\GraphQLHelperTrait::getClient() is not static, but was called statically.

    }

    /**
     * @param string $name
     * @param array  $parameters
     * @param array  $expected
     *
     * @return string
     */
    private static function flattenQuery($name, array $parameters = [], array $expected = [])
    {
        $expectedStr = self::flattenExpectation($expected);

        //namespaced query
        if (strpos($name, '.') !== false) {
            $namespace = explode('.', $name);

            $name = array_reverse($namespace)[0];
            array_pop($namespace);
            $query = '{child}';
            foreach ($namespace as $path) {
                $content = <<<GrahpQL
$path {
    {child}
}
GrahpQL;
                $query = str_replace('{child}', $content, $query);
            }

            return str_replace('{child}', self::flattenQuery($name, $parameters, $expected), $query);
        }


        $paramsStr = null;
        if ($parameters) {

The expression $parameters 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.

            $paramsStr = self::flattenParameters($parameters);
        }

        return <<<GrahpQL
  $name$paramsStr{
    $expectedStr
  }
GrahpQL;
    }

    /**
     * @param array $parameters
     * @param array $wrappers
     *
     * @return string
     */
    private static function flattenParameters(array $parameters, $wrappers = ['(', ')'])
    {
        foreach ($parameters as $key => &$value) {
            if (\is_string($value)) {
                $value = "\"$value\"";
            }
            if (\is_bool($value)) {
                $value = $value ? 'true' : 'false';
            }
            if (\is_array($value)) {
                if (array_key_exists(0, $value)) {
                    $value = json_encode($value);
                } else {
                    $value = self::flattenParameters($value, ['{', '}']);
                }
            }
            $value = "$key: $value";
        }
        unset($value);

        list($start, $end) = $wrappers;

        return "$start ".implode(', ', $parameters)." $end";
    }

    /**
     * @param array $expectation
     *
     * @return string
     */
    private static function flattenExpectation(array $expectation)
    {
        $expectNormalized = [];
        foreach ($expectation as $path => $value) {
            if (\is_array($value)) {
                if (isset($value[0], $value[1])
                    && is_array($value[0])
                    && is_array($value[1])
                ) {
                    $value = self::flattenQuery($path, $value[0], $value[1]);
                } else {
                    $value = $path." {\n\t\t".self::flattenExpectation($value)."\n\t}";
                }
            }
            $expectNormalized[] = $value;
        }

        return implode("\n\t", $expectNormalized);
    }
}