ProcessorTest::testInit() - Code Metrics - Inspection of "fixed parse argument value for non null type" - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 48a1e6...3c3b08 )

by Portey
created 2016-09-07 19:03 UTC
ProcessorTest::testInit() A

↳ Parent: ProcessorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	3
Bugs	0	Features	0
Metric	Value
c	3
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0
<?php
/*
 * 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\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;

    /**
     * @expectedException \Youshido\GraphQL\Validator\Exception\ConfigurationException
     * @expectedExceptionMessage Schema has to have fields
     */
    public function testInit()
    {
        new Processor(new TestEmptySchema());
    }

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

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

    }

    public function testNestedVariables()
    {
        $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']);
        $this->assertEquals($expectedData, $processor->getResponseData());

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

    public function testListNullResponse()

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


    public function testSubscriptionNullResponse()

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

    public function testSchemaOperations()
    {
        $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' => function ($value, $args) {
                                        return empty($args['shorten']) ? $value['firstName'] : $value['firstName'];
                                    }
                                ],
                                'id_alias'  => [
                                    'type'    => new IdType(),
                                    'resolve' => function ($value) {
                                        return $value['id'];
                                    }
                                ],
                                'lastName'  => new StringType(),
                                'code'      => new StringType(),
                            ]
                        ]),
                        'resolve' => function ($value, $args) {
                            $data = ['id' => '123', 'firstName' => 'John', 'code' => '007'];
                            if (!empty($args['upper'])) {
                                foreach ($data as $key => $value) {
                                    $data[$key] = strtoupper($value);
                                }
                            }

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

        $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(),
                        'default' => 1
                    ]
                ]
            ]))->addField(new Field([
                'name'    => 'invalidResolveTypeMutation',
                'type'    => new NonNullType(new IntType()),
                'resolve' => function () {
                    return null;
                }
            ]))->addField(new Field([
                'name'    => 'interfacedMutation',
                'type'    => new TestInterfaceType(),
                'resolve' => 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"']]], $processor->getResponseData());

        $processor->processPayload('mutation { increaseCounter(noArg: 2) }');
        $this->assertEquals(['errors' => [['message' => 'Unknown argument "noArg" on field "increaseCounter"']]], $processor->getResponseData());

        $processor->processPayload('mutation { increaseCounter(amount: 2) { invalidProp } }');
        $this->assertEquals(['errors' => [['message' => 'Fields are not found in query "increaseCounter"']], 'data' => ['increaseCounter' => null]], $processor->getResponseData());

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

        $processor->processPayload('{ invalidQuery }');
        $this->assertEquals(['errors' => [['message' => 'Field "invalidQuery" not found in type "RootQuery"']]], $processor->getResponseData());

        $processor->processPayload('{ invalidValueQuery { id } }');
        $this->assertEquals(['errors' => [['message' => 'Not valid value for OBJECT field invalidValueQuery']], 'data' => ['invalidValueQuery' => null]], $processor->getResponseData());

        $processor->processPayload('{ me { firstName(shorten: true), middle }}');
        $this->assertEquals(['errors' => [['message' => 'Field "middle" is not found in type "User"']], 'data' => ['me' => null]], $processor->getResponseData());

        $processor->processPayload('{ randomUser { region }}');
        $this->assertEquals(['errors' => [['message' => 'Property "region" not found in resolve result']]], $processor->getResponseData());

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

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

    public function testEnumType()
    {
        $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' => function ($value, $args) {
                            return $args['argument1'];
                        }
                    ]
                ]
            ])
        ]));

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

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

        $processor->processPayload('{ alias: test(argument1: VALUE4) }');
        $response = $processor->getResponseData();
        $this->assertEquals(['errors' => [['message' => 'Not valid type for argument "argument1" in query "test"']]], $response);

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

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

        $processor->processPayload('{ listQuery }');
        $this->assertEquals(['errors' => [
            ['message' => 'Not valid value for LIST field listQuery']
        ], 'data'                     => ['listQuery' => null]], $processor->getResponseData());

        $processor->processPayload('{ listEnumQuery }');
        $this->assertEquals(['errors' => [
            ['message' => 'Not valid resolve value in listEnumQuery field']
        ], 'data'                     => ['listEnumQuery' => [null]]], $processor->getResponseData());

        $processor->processPayload('{ invalidEnumQuery }');
        $this->assertEquals(['errors' => [
            ['message' => 'Not valid value for ENUM field invalidEnumQuery']
        ], 'data'                     => ['invalidEnumQuery' => null]], $processor->getResponseData());

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

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

        $processor->processPayload('{ invalidNonNullInsideQuery }');
        $this->assertEquals(['errors' => [
            ['message' => 'Not valid value for SCALAR field invalidNonNullInsideQuery']
        ], 'data'                     => ['invalidNonNullInsideQuery' => null]], $processor->getResponseData());

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

    public function testTypedFragment()
    {

        $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' => function ($object) use ($object1, $object2) {
                if (isset($object['id'])) {
                    return $object1;
                }

                return $object2;
            }
        ]);
        $invalidUnion = new UnionType([
            'name'        => 'TestUnion',
            'types'       => [$object1, $object2],
            'resolveType' => 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' => function ($value, $args) {
                            if ($args['type'] == 'object1') {
                                return [
                                    'id' => 43
                                ];
                            } else {
                                return [
                                    'name' => 'name resolved'
                                ];
                            }
                        }
                    ],
                    'invalidUnion' => [
                        'type'    => $invalidUnion,
                        'resolve' => 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' => []
            ],
            'errors' => [
                ['message' => 'Field "name" is not found in type "Object1"']
            ]
        ], $processor->getResponseData());

        $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(['errors' => [['message' => 'Type Object3 not exist in types of Object2']]], $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 testComplexityReducer()
    {
        $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' => function ($value, $args) {
                                                    return empty($args['shorten']) ? $value : $value;
                                                }
                                            ],
                                            'lastName'  => new StringType(),
                                            'code'      => new StringType(),
                                            'likes'     => [
                                                'type'    => new IntType(),
                                                'cost'    => 10,
                                                'resolve' => function () {
                                                    return 42;
                                                }
                                            ]
                                        ]
                                    ]
                                ),
                                'cost'    => function ($args, $context, $childCost) {
                                    $argsCost = isset($args['cost']) ? $args['cost'] : 1;

                                    return 1 + $argsCost * $childCost;
                                },
                                'resolve' => 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 { firstName, likes } }');
        $this->assertEquals(['errors' => [['message' => 'query exceeded max allowed complexity of 10']]], $processor->getResponseData());

        // don't let complexity reducer affect query errors
        $processor->processPayload('{ me { badfield } }');
        $this->assertArraySubset(['errors' => [['message' => 'Field "badfield" is not found in type "User"']]], $processor->getResponseData());

        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

Push — master ( 48a1e6...3c3b08 )

ProcessorTest::testInit() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
