ProcessorTest::testComplexityReducer() - Code Metrics - Inspection of "Tooling, linting, etc." - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#204)

by Ryan
created 2018-03-05 23:07 UTC
ProcessorTest::testComplexityReducer() B

↳ Parent: Project
Complexity

Conditions	4
Paths	2
Size

Total Lines	101
Code Lines	55
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	101
rs	8.1935
c	0
b	0
f	0
cc	4
eloc	55
nc	2
nop	0
How to fix Long Method

<?php
/**
 * Copyright (c) 2015–2018 Alexandr Viniychuk <http://youshido.com>.
 * Copyright (c) 2015–2018 Portey Vasil <https://github.com/portey>.
 * Copyright (c) 2018 Ryan Parman <https://github.com/skyzyx>.
 * Copyright (c) 2018 Ashley Hutson <https://github.com/asheliahut>.
 * Copyright (c) 2015–2018 Contributors.
 *
 * http://opensource.org/licenses/MIT
 */

declare(strict_types=1);
/*
 * This file is a part of GraphQL project.
 *
 * @author Alexandr Viniychuk <[email protected]>
 * created: 11:02 PM 5/13/16
 */

namespace Youshido\Tests\Schema;

use Youshido\GraphQL\Execution\Container\Container;
use Youshido\GraphQL\Execution\Context\ExecutionContext;
use Youshido\GraphQL\Execution\Processor;
use Youshido\GraphQL\Execution\ResolveInfo;
use Youshido\GraphQL\Execution\Visitor\MaxComplexityQueryVisitor;
use Youshido\GraphQL\Field\Field;
use Youshido\GraphQL\Schema\Schema;
use Youshido\GraphQL\Type\Enum\EnumType;
use Youshido\GraphQL\Type\ListType\ListType;
use Youshido\GraphQL\Type\NonNullType;
use Youshido\GraphQL\Type\Object\ObjectType;
use Youshido\GraphQL\Type\Scalar\BooleanType;
use Youshido\GraphQL\Type\Scalar\IdType;
use Youshido\GraphQL\Type\Scalar\IntType;
use Youshido\GraphQL\Type\Scalar\StringType;
use Youshido\GraphQL\Type\Union\UnionType;
use Youshido\Tests\DataProvider\TestEmptySchema;
use Youshido\Tests\DataProvider\TestEnumType;
use Youshido\Tests\DataProvider\TestInterfaceType;
use Youshido\Tests\DataProvider\TestObjectType;
use Youshido\Tests\DataProvider\TestSchema;

class ProcessorTest extends \PHPUnit_Framework_TestCase
{
    private $_counter = 0;

    public function testInit(): void
    {
        $processor = new Processor(new TestEmptySchema());
        $this->assertEquals([['message' => 'Schema has to have fields']], $processor->getExecutionContext()->getErrorsArray());
    }

    public function testEmptyQueries(): void
    {
        $processor = new Processor(new TestSchema());
        $processor->processPayload('');
        $this->assertEquals(['errors' => [
            ['message' => 'Must provide an operation.'],
        ]], $processor->getResponseData());

        $processor->getExecutionContext()->clearErrors();
        $processor->processPayload('{ me { name } }');
        $this->assertEquals(['data' => [
            'me' => ['name' => 'John'],
        ]], $processor->getResponseData());
    }

    public function testNestedVariables(): void
    {
        $processor    = new Processor(new TestSchema());
        $noArgsQuery  = '{ me { echo(value:"foo") } }';
        $expectedData = ['data' => ['me' => ['echo' => 'foo']]];
        $processor->processPayload($noArgsQuery, ['value' => 'foo']);
        $this->assertEquals($expectedData, $processor->getResponseData());

        $parameterizedFieldQuery = 'query nestedFieldQuery($value:String!){
          me {
            echo(value:$value)
          }
        }';
        $processor->processPayload($parameterizedFieldQuery, ['value' => 'foo']);
        $response = $processor->getResponseData();
        $this->assertEquals($expectedData, $response);

        $parameterizedQueryQuery = 'query nestedQueryQuery($value:Int){
          me {
            location(noop:$value) {
              address
            }
          }
        }';
        $processor->processPayload($parameterizedQueryQuery, ['value' => 1]);
        $this->assertArrayNotHasKey('errors', $processor->getResponseData());
    }

    public function testNullListVariable(): void
    {
        $processor = new Processor(new TestSchema());
        $processor->processPayload(
            'mutation ($list: [Int], $status: TestEnum) { updateStatus(list: $list, newStatus: $status) }',
            [
                'list'   => null,
                'status' => null,
            ]
        );

        $this->assertArrayNotHasKey('errors', $processor->getResponseData());
    }

    public function testListNullResponse(): void
    {
        $processor = new Processor(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'list' => [
                        'type'    => new ListType(new StringType()),
                        'resolve' => static function () {
                        },
                    ],
                ],
            ]),
        ]));
        $data = $processor->processPayload(' { list }')->getResponseData();
        $this->assertEquals(['data' => ['list' => null]], $data);
    }

    public function testSubscriptionNullResponse(): void
    {
        $processor = new Processor(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'list' => [
                        'type'    => new ListType(new StringType()),
                        'resolve' => static function () {
                        },
                    ],
                ],
            ]),
        ]));
        $data = $processor->processPayload(' { __schema { subscriptionType { name } } }')->getResponseData();
        $this->assertEquals(['data' => ['__schema' => ['subscriptionType' => null]]], $data);
    }

    public function testSchemaOperations(): void
    {
        $schema = new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'me' => [
                        'type' => new ObjectType([
                            'name'   => 'User',
                            'fields' => [
                                'firstName' => [
                                    'type' => new StringType(),
                                    'args' => [
                                        'shorten' => new BooleanType(),
                                    ],
                                    'resolve' => static function ($value, $args) {
                                        return empty($args['shorten']) ? $value['firstName'] : $value['firstName'];
                                    },
                                ],
                                'id_alias' => [
                                    'type'    => new IdType(),
                                    'resolve' => static function ($value) {
                                        return $value['id'];
                                    },
                                ],
                                'lastName' => new StringType(),
                                'code'     => new StringType(),
                            ],
                        ]),
                        'resolve' => static function ($value, $args) {
                            $data = ['id' => '123', 'firstName' => 'John', 'code' => '007'];

                            if (!empty($args['upper'])) {
                                foreach ($data as $key => $value) {
                                    $data[$key] = \mb_strtoupper($value);
                                }
                            }

                            return $data;
                        },
                        'args' => [
                            'upper' => [
                                'type'         => new BooleanType(),
                                'defaultValue' => false,
                            ],
                        ],
                    ],
                    'randomUser' => [
                        'type'    => new TestObjectType(),
                        'resolve' => static function () {
                            return ['invalidField' => 'John'];
                        },
                    ],
                    'invalidValueQuery' => [
                        'type'    => new TestObjectType(),
                        'resolve' => static function () {
                            return 'stringValue';
                        },
                    ],
                    'labels' => [
                        'type'    => new ListType(new StringType()),
                        'resolve' => static function () {
                            return ['one', 'two'];
                        },
                    ],
                ],
            ]),
        ]);
        $processor = new Processor($schema);

        $processor->processPayload('mutation { __typename }');
        $this->assertEquals(['data' => ['__typename' => 'RootSchemaMutation']], $processor->getResponseData());

        $processor->processPayload('{ __typename }');
        $this->assertEquals(['data' => ['__typename' => 'RootQuery']], $processor->getResponseData());

        $processor->processPayload('{ me { firstName } }');
        $this->assertEquals(['data' => ['me' => ['firstName' => 'John']]], $processor->getResponseData());

        $processor->processPayload('{ me { id_alias } }');
        $this->assertEquals(['data' => ['me' => ['id_alias' => '123']]], $processor->getResponseData());

        $processor->processPayload('{ me { firstName, lastName } }');
        $this->assertEquals(['data' => ['me' => ['firstName' => 'John', 'lastName' => null]]], $processor->getResponseData());

        $processor->processPayload('{ me { code } }');
        $this->assertEquals(['data' => ['me' => ['code' => 7]]], $processor->getResponseData());

        $processor->processPayload('{ me(upper:true) { firstName } }');
        $this->assertEquals(['data' => ['me' => ['firstName' => 'JOHN']]], $processor->getResponseData());

        $processor->processPayload('{ labels }');
        $this->assertEquals(['data' => ['labels' => ['one', 'two']]], $processor->getResponseData());

        $schema->getMutationType()
            ->addField(new Field([
                'name'    => 'increaseCounter',
                'type'    => new IntType(),
                'resolve' => function ($value, $args, ResolveInfo $info) {
                    return $this->_counter += $args['amount'];
                },
                'args' => [
                    'amount' => [
                        'type'         => new IntType(),
                        'defaultValue' => 1,
                    ],
                ],
            ]))->addField(new Field([
                'name'    => 'invalidResolveTypeMutation',
                'type'    => new NonNullType(new IntType()),
                'resolve' => static function () {
                },
            ]))->addField(new Field([
                'name'    => 'interfacedMutation',
                'type'    => new TestInterfaceType(),
                'resolve' => static function () {
                    return ['name' => 'John'];
                },
            ]));
        $processor->processPayload('mutation { increaseCounter }');
        $this->assertEquals(['data' => ['increaseCounter' => 1]], $processor->getResponseData());

        $processor->processPayload('mutation { invalidMutation }');
        $this->assertEquals(['errors' => [[
            'message'   => 'Field "invalidMutation" not found in type "RootSchemaMutation". Available fields are: "increaseCounter", "invalidResolveTypeMutation", "interfacedMutation"',
            'locations' => [
                [
                    'line'   => 1,
                    'column' => 12,
                ],
            ],
        ]]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('mutation { increaseCounter(noArg: 2) }');
        $this->assertEquals([
            'data'   => ['increaseCounter' => null],
            'errors' => [[
                'message'   => 'Unknown argument "noArg" on field "increaseCounter"',
                'locations' => [
                    [
                        'line'   => 1,
                        'column' => 28,
                    ],
                ],
            ]],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('mutation { increaseCounter(amount: 2) { invalidProp } }');
        $this->assertEquals(['errors' => [[
            'message'   => 'You can\'t specify fields for scalar type "Int"',
            'locations' => [
                [
                    'line'   => 1,
                    'column' => 12,
                ],
            ],
        ]], 'data' => ['increaseCounter' => null]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('mutation { increaseCounter(amount: 2) }');
        $this->assertEquals(['data' => ['increaseCounter' => 3]], $processor->getResponseData());

        $processor->processPayload('{ invalidQuery }');
        $this->assertEquals(['errors' => [[
            'message'   => 'Field "invalidQuery" not found in type "RootQuery". Available fields are: "me", "randomUser", "invalidValueQuery", "labels", "__schema", "__type"',
            'locations' => [
                [
                    'line'   => 1,
                    'column' => 3,
                ],
            ],
        ]]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ invalidValueQuery { id } }');
        $this->assertEquals(['errors' => [['message' => 'Not valid resolved type for field "invalidValueQuery": (no details available)']], 'data' => ['invalidValueQuery' => null]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ me { firstName(shorten: true), middle }}');
        $this->assertEquals([
            'data'   => ['me' => null],
            'errors' => [[
                'message'   => 'Field "middle" not found in type "User". Available fields are: "firstName", "id_alias", "lastName", "code"',
                'locations' => [
                    [
                        'line'   => 1,
                        'column' => 34,
                    ],
                ],
            ]],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ randomUser { region }}');
        $this->assertEquals([
            'data'   => ['randomUser' => null],
            'errors' => [[
                'message'   => 'You have to specify fields for "region"',
                'locations' => [
                    [
                        'line'   => 1,
                        'column' => 16,
                    ],
                ],
            ]],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('mutation { invalidResolveTypeMutation }');
        $this->assertEquals([
            'data'   => ['invalidResolveTypeMutation' => null],
            'errors' => [['message' => 'Cannot return null for non-nullable field "invalidResolveTypeMutation"']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('mutation { user:interfacedMutation { name }  }');
        $this->assertEquals(['data' => ['user' => ['name' => 'John']]], $processor->getResponseData());
    }

    public function testEnumType(): void
    {
        $processor = new Processor(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'test' => [
                        'args' => [
                            'argument1' => new NonNullType(new EnumType([
                                'name'   => 'TestEnumType',
                                'values' => [
                                    [
                                        'name'  => 'VALUE1',
                                        'value' => 'val1',
                                    ],
                                    [
                                        'name'  => 'VALUE2',
                                        'value' => 'val2',
                                    ],
                                ],
                            ])),
                        ],
                        'type'    => new StringType(),
                        'resolve' => static function ($value, $args) {
                            return $args['argument1'];
                        },
                    ],
                ],
            ]),
        ]));

        $processor->processPayload('{ test }');
        $response = $processor->getResponseData();
        $this->assertEquals([
            'data'   => ['test' => null],
            'errors' => [['message' => 'Require "argument1" arguments to query "test"']],
        ], $response);
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ alias: test() }');
        $response = $processor->getResponseData();
        $this->assertEquals([
            'data'   => ['alias' => null],
            'errors' => [['message' => 'Require "argument1" arguments to query "test"']],
        ], $response);
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ alias: test(argument1: VALUE4) }');
        $response = $processor->getResponseData();
        $this->assertEquals([
            'data'   => ['alias' => null],
            'errors' => [[
                'message'   => 'Not valid type for argument "argument1" in query "test": Value must be one of the allowed ones: VALUE1 (val1), VALUE2 (val2)',
                'locations' => [
                    [
                        'line'   => 1,
                        'column' => 15,
                    ],
                ],
            ]],
        ], $response);
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ alias: test(argument1: VALUE1) }');
        $response = $processor->getResponseData();
        $this->assertEquals(['data' => ['alias' => 'val1']], $response);
    }

    public function testListEnumsSchemaOperations(): void
    {
        $processor = new Processor(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'listQuery' => [
                        'type'    => new ListType(new TestEnumType()),
                        'resolve' => static function () {
                            return 'invalid list';
                        },
                    ],
                    'listEnumQuery' => [
                        'type'    => new ListType(new TestEnumType()),
                        'resolve' => static function () {
                            return ['invalid enum'];
                        },
                    ],
                    'invalidEnumQuery' => [
                        'type'    => new TestEnumType(),
                        'resolve' => static function () {
                            return 'invalid enum';
                        },
                    ],
                    'enumQuery' => [
                        'type'    => new TestEnumType(),
                        'resolve' => static function () {
                            return 1;
                        },
                    ],
                    'invalidNonNullQuery' => [
                        'type'    => new NonNullType(new IntType()),
                        'resolve' => static function () {
                        },
                    ],
                    'invalidNonNullInsideQuery' => [
                        'type'    => new NonNullType(new IntType()),
                        'resolve' => static function () {
                            return 'hello';
                        },
                    ],
                    'objectQuery' => [
                        'type'    => new TestObjectType(),
                        'resolve' => static function () {
                            return ['name' => 'John'];
                        },
                    ],
                    'deepObjectQuery' => [
                        'type' => new ObjectType([
                            'name'   => 'deepObject',
                            'fields' => [
                                'object' => new TestObjectType(),
                                'enum'   => new TestEnumType(),
                            ],
                        ]),
                        'resolve' => static function () {
                            return [
                                'object' => [
                                    'name' => 'John',
                                ],
                                'enum' => 1,
                            ];
                        },
                    ],
                ],
            ]),
        ]));

        $processor->processPayload('{ listQuery }');
        $this->assertEquals([
            'data'   => ['listQuery' => null],
            'errors' => [['message' => 'Not valid resolved type for field "listQuery": The value is not an iterable.']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ listEnumQuery }');
        $this->assertEquals([
            'data'   => ['listEnumQuery' => [null]],
            'errors' => [['message' => 'Not valid resolved type for field "listEnumQuery": Value must be one of the allowed ones: FINISHED (1), NEW (0)']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ invalidEnumQuery }');
        $this->assertEquals([
            'data'   => ['invalidEnumQuery' => null],
            'errors' => [['message' => 'Not valid resolved type for field "invalidEnumQuery": Value must be one of the allowed ones: FINISHED (1), NEW (0)']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ enumQuery }');
        $this->assertEquals(['data' => ['enumQuery' => 'FINISHED']], $processor->getResponseData());

        $processor->processPayload('{ invalidNonNullQuery }');
        $this->assertEquals([
            'data'   => ['invalidNonNullQuery' => null],
            'errors' => [['message' => 'Cannot return null for non-nullable field "invalidNonNullQuery"']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ invalidNonNullInsideQuery }');
        $this->assertEquals([
            'data'   => ['invalidNonNullInsideQuery' => null],
            'errors' => [['message' => 'Not valid resolved type for field "invalidNonNullInsideQuery": (no details available)']],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ test:deepObjectQuery { object { name } } }');
        $this->assertEquals(['data' => ['test' => ['object' => ['name' => 'John']]]], $processor->getResponseData());
    }

    public function testTypedFragment(): void
    {
        $object1 = new ObjectType([
            'name'   => 'Object1',
            'fields' => [
                'id' => ['type' => 'int', 'cost' => 13],
            ],
        ]);

        $object2 = new ObjectType([
            'name'   => 'Object2',
            'fields' => [
                'name' => ['type' => 'string'],
            ],
        ]);

        $object3 = new ObjectType([
            'name'   => 'Object3',
            'fields' => [
                'name' => ['type' => 'string'],
            ],
        ]);

        $union = new UnionType([
            'name'        => 'TestUnion',
            'types'       => [$object1, $object2],
            'resolveType' => static function ($object) use ($object1, $object2) {
                if (isset($object['id'])) {
                    return $object1;
                }

                return $object2;
            },
        ]);
        $invalidUnion = new UnionType([
            'name'        => 'TestUnion',
            'types'       => [$object1, $object2],
            'resolveType' => static function ($object) use ($object3) {
                return $object3;
            },
        ]);
        $processor = new Processor(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'union' => [
                        'type' => $union,
                        'args' => [
                            'type' => ['type' => 'string'],
                        ],
                        'cost'    => 10,
                        'resolve' => static function ($value, $args) {
                            if ('object1' === $args['type']) {
                                return [
                                    'id' => 43,
                                ];
                            }

                            return [
                                    'name' => 'name resolved',
                                ];
                        },
                    ],
                    'invalidUnion' => [
                        'type'    => $invalidUnion,
                        'resolve' => static function () {
                            return ['name' => 'name resolved'];
                        },
                    ],
                ],
            ]),
        ]));
        $processor->processPayload('{ union(type: "object1") { ... on Object2 { id } } }');
        $this->assertEquals(['data' => ['union' => []]], $processor->getResponseData());

        $processor->processPayload('{ union(type: "object1") { ... on Object1 { name } } }');
        $this->assertEquals([
            'data' => [
                'union' => null,
            ],
            'errors' => [
                [
                    'message'   => 'Field "name" not found in type "Object1". Available fields are: "id"',
                    'locations' => [
                        [
                            'line'   => 1,
                            'column' => 45,
                        ],
                    ],
                ],
            ],
        ], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ union(type: "object1") { ... on Object1 { id } } }');
        $this->assertEquals(['data' => ['union' => ['id' => 43]]], $processor->getResponseData());

        $processor->processPayload('{ union(type: "asd") { ... on Object2 { name } } }');
        $this->assertEquals(['data' => ['union' => ['name' => 'name resolved']]], $processor->getResponseData());

        $processor->processPayload('{ invalidUnion { ... on Object2 { name } } }');
        $this->assertEquals([
            'data' => [
                'invalidUnion' => null,
            ],
            'errors' => [
                ['message' => 'Type "Object3" not exist in types of "TestUnion"'],
            ],
        ], $processor->getResponseData());

        $visitor = new MaxComplexityQueryVisitor(1000); // arbitrarily high cost
        $processor->processPayload('{ union(type: "object1") { ... on Object1 { id } } }', [], [$visitor]);
        $this->assertEquals(10 + 13, $visitor->getMemo());

        $visitor = new MaxComplexityQueryVisitor(1000); // arbitrarily high cost
        $processor->processPayload('{ union(type: "object1") { ... on Object1 { id }, ... on Object2 { name } } }', [], [$visitor]);
        $this->assertEquals(10 + 13 + 1, $visitor->getMemo());

        // planning phase currently has no knowledge of what types the union will resolve to, this will have the same score as above
        $visitor = new MaxComplexityQueryVisitor(1000); // arbitrarily high cost
        $processor->processPayload('{ union(type: "object2") { ... on Object1 { id }, ... on Object2 { name } } }', [], [$visitor]);
        $this->assertEquals(10 + 13 + 1, $visitor->getMemo());
    }

    public function testContainer(): void
    {
        $container = new Container();
        $container->set('user', ['name' => 'Alex']);

        $executionContext = new ExecutionContext(new Schema([
            'query' => new ObjectType([
                'name'   => 'RootQuery',
                'fields' => [
                    'currentUser' => [
                        'type'    => new StringType(),
                        'resolve' => static function ($source, $args, ResolveInfo $info) {
                            return $info->getContainer()->get('user')['name'];
                        },
                    ],
                ],
            ]),
        ]));
        $executionContext->setContainer($container);
        $this->assertNotNull($executionContext->getContainer());

        $processor = new Processor($executionContext->getSchema());
        $processor->getExecutionContext()->setContainer($container);

        $this->assertEquals(['data' => ['currentUser' => 'Alex']], $processor->processPayload('{ currentUser }')->getResponseData());
    }

    public function testComplexityReducer(): void
    {
        $schema = new Schema(
            [
                'query' => new ObjectType(
                    [
                        'name'   => 'RootQuery',
                        'fields' => [
                            'me' => [
                                'type' => new ObjectType(
                                    [
                                        'name'   => 'User',
                                        'fields' => [
                                            'firstName' => [
                                                'type' => new StringType(),
                                                'args' => [
                                                    'shorten' => new BooleanType(),
                                                ],
                                                'resolve' => static function ($value, $args) {
                                                    return empty($args['shorten']) ? $value['firstName'] : $value['firstName'];
                                                },
                                            ],
                                            'lastName' => new StringType(),
                                            'code'     => new StringType(),
                                            'likes'    => [
                                                'type'    => new IntType(),
                                                'cost'    => 10,
                                                'resolve' => static function () {
                                                    return 42;
                                                },
                                            ],
                                        ],
                                    ]
                                ),
                                'cost' => static function ($args, $context, $childCost) {
                                    $argsCost = $args['cost'] ?? 1;

                                    return 1 + $argsCost * $childCost;
                                },
                                'resolve' => static function ($value, $args) {
                                    $data = ['firstName' => 'John', 'code' => '007'];

                                    return $data;
                                },
                                'args' => [
                                    'cost' => [
                                        'type'    => new IntType(),
                                        'default' => 1,
                                    ],
                                ],
                            ],
                        ],
                    ]
                ),
            ]
        );
        $processor = new Processor($schema);

        $processor->setMaxComplexity(10);

        $processor->processPayload('{ me { firstName, lastName } }');
        $this->assertArrayNotHasKey('error', $processor->getResponseData());

        $processor->processPayload('{ me { } }');
        $this->assertEquals(['errors' => [[
            'message'   => 'Unexpected token "RBRACE"',
            'locations' => [
                [
                    'line'   => 1,
                    'column' => 10,
                ],
            ],
        ]]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        $processor->processPayload('{ me { firstName, likes } }');
        $this->assertEquals(['errors' => [['message' => 'query exceeded max allowed complexity of 10']]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        // don't let complexity reducer affect query errors
        $processor->processPayload('{ me { badfield } }');
        $this->assertArraySubset(['errors' => [['message' => 'Field "badfield" not found in type "User". Available fields are: "firstName", "lastName", "code", "likes"']]], $processor->getResponseData());
        $processor->getExecutionContext()->clearErrors();

        foreach (\range(1, 5) as $cost_multiplier) {
            $visitor = new MaxComplexityQueryVisitor(1000); // arbitrarily high cost
            $processor->processPayload("{ me (cost: ${cost_multiplier}) { firstName, lastName, code, likes } }", ['cost' => $cost_multiplier], [$visitor]);
            $expected = 1 + 13 * (1 + $cost_multiplier);
            $this->assertEquals($expected, $visitor->getMemo());
        }

        // TODO, variables not yet supported
        /*$query = 'query costQuery ($cost: Int) { me (cost: $cost) { firstName, lastName, code, likes } }';
        foreach (range(1,5) as $cost_multiplier) {
          $visitor = new \Youshido\GraphQL\Execution\Visitor\MaxComplexityQueryVisitor(1000); // arbitrarily high cost
          $processor->processPayload($query, ['cost' => $cost_multiplier], [$visitor]);
          $expected = 1 + 13 * (1 + $cost_multiplier);
          $this->assertEquals($expected, $visitor->getMemo());
        }*/
    }
}

Youshido / GraphQL

Pull Request — master (#204)

ProcessorTest::testComplexityReducer() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
