ProcessorTest - Code Metrics - Inspection of "do not explicitly cast to array when iterating ove..." - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#15)

unknown

created 2016-07-19 12:09 UTC

ProcessorTest B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	488
Duplicated Lines	11.48 %

Coupling/Cohesion

Components	1
Dependencies	16

Importance

Changes	17
Bugs	3	Features	1

Metric	Value
wmc	17
c	17
b	3
f	1
lcom	1
cbo	16
dl	56
loc	488
rs	8.4614

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testInit()	0	4	1
A	testEmptyQueries()	0	14	1
B	testNestedVariables()	0	27	1
A	testListNullResponse()	18	18	1
A	testSubscriptionNullResponse()	18	18	1
B	testListEnumsSchemaOperations()	0	100	1
B	testTypedFragment()	0	95	3
B	testSchemaOperations()	10	128	4
B	testComplexityReducer()	10	65	4

How to fix Duplicated Code

<?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\Field\Field;
use Youshido\GraphQL\Schema\Schema;
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\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 : $value;
                                    }
                                ],
                                'lastName'  => new StringType(),
                                'code'      => new StringType(),
                            ]
                        ]),
                        'resolve' => function ($value, $args) {

                            $data = ['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';
                        }
                    ],
                ],
            ])
        ]);
        $processor = new Processor($schema);

        $processor->processPayload('{ me { firstName } }');
        $this->assertEquals(['data' => ['me' => ['firstName' => 'John']]], $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());

        $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' => 'Field "invalidProp" not found in type "Int"']], '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" 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 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']
            ]
        ]);

        $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']
                        ],
                        '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" 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());

    }

    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;
                                              }
                                          ]
                                      ]
                                  ]
                              ),
                              'resolve' => function ($value, $args) {

                                $data = ['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
                                  ]
                              ]
                          ]
                      ]
                  ]
              )
          ]
      );
      $processor = new Processor($schema);

      $processor->setMaxComplexity(10);

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

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


1		<?php
2		/*
3		* This file is a part of GraphQL project.
4		*
5		* @author Alexandr Viniychuk <[email protected]>
6		* created: 11:02 PM 5/13/16
7		*/
8
9		namespace Youshido\Tests\Schema;
10
11
12		use Youshido\GraphQL\Execution\Processor;
13		use Youshido\GraphQL\Execution\ResolveInfo;
14		use Youshido\GraphQL\Field\Field;
15		use Youshido\GraphQL\Schema\Schema;
16		use Youshido\GraphQL\Type\ListType\ListType;
17		use Youshido\GraphQL\Type\NonNullType;
18		use Youshido\GraphQL\Type\Object\ObjectType;
19		use Youshido\GraphQL\Type\Scalar\BooleanType;
20		use Youshido\GraphQL\Type\Scalar\IntType;
21		use Youshido\GraphQL\Type\Scalar\StringType;
22		use Youshido\GraphQL\Type\Union\UnionType;
23		use Youshido\Tests\DataProvider\TestEmptySchema;
24		use Youshido\Tests\DataProvider\TestEnumType;
25		use Youshido\Tests\DataProvider\TestInterfaceType;
26		use Youshido\Tests\DataProvider\TestObjectType;
27		use Youshido\Tests\DataProvider\TestSchema;
28
29		class ProcessorTest extends \PHPUnit_Framework_TestCase
30		{
31
32		private $_counter = 0;
33
34		/**
35		* @expectedException \Youshido\GraphQL\Validator\Exception\ConfigurationException
36		* @expectedExceptionMessage Schema has to have fields
37		*/
38		public function testInit()
39		{
40		new Processor(new TestEmptySchema());
41		}
42
43		public function testEmptyQueries()
44		{
45		$processor = new Processor(new TestSchema());
46		$processor->processPayload('');
47		$this->assertEquals(['errors' => [
48		['message' => 'Must provide an operation.']
49		]], $processor->getResponseData());
50
51		$processor->processPayload('{ me { name } }');
52		$this->assertEquals(['data' => [
53		'me' => ['name' => 'John']
54		]], $processor->getResponseData());
55
56		}
57
58		public function testNestedVariables() {
59		$processor = new Processor(new TestSchema());
60		$noArgsQuery = '{ me { echo(value:"foo") } }';
61		$expectedData = ['data' => ['me' => ['echo' => 'foo']]];
62		$processor->processPayload($noArgsQuery, ['value' => 'foo']);
63		$this->assertEquals($expectedData, $processor->getResponseData());
64
65		$parameterizedFieldQuery =
66		'query nestedFieldQuery($value:String!){
67		me {
68		echo(value:$value)
69		}
70		}';
71		$processor->processPayload($parameterizedFieldQuery, ['value' => 'foo']);
72		$this->assertEquals($expectedData, $processor->getResponseData());
73
74		$parameterizedQueryQuery =
75		'query nestedQueryQuery($value:Int){
76		me {
77		location(noop:$value) {
78		address
79		}
80		}
81		}';
82		$processor->processPayload($parameterizedQueryQuery, ['value' => 1]);
83		$this->assertArrayNotHasKey('errors', $processor->getResponseData());
84		}
85
86	View Code Duplication	public function testListNullResponse()
		0 ignored issues – show Duplication introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
87		{
88		$processor = new Processor(new Schema([
89		'query' => new ObjectType([
90		'name' => 'RootQuery',
91		'fields' => [
92		'list' => [
93		'type' => new ListType(new StringType()),
94		'resolve' => function() {
95		return null;
96		}
97		]
98		]
99		])
100		]));
101		$data = $processor->processPayload(' { list }')->getResponseData();
102		$this->assertEquals(['data' => ['list' => null]], $data);
103		}
104
105
106	View Code Duplication	public function testSubscriptionNullResponse()
		0 ignored issues – show Duplication introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
107		{
108		$processor = new Processor(new Schema([
109		'query' => new ObjectType([
110		'name' => 'RootQuery',
111		'fields' => [
112		'list' => [
113		'type' => new ListType(new StringType()),
114		'resolve' => function() {
115		return null;
116		}
117		]
118		]
119		])
120		]));
121		$data = $processor->processPayload(' { __schema { subscriptionType { name } } }')->getResponseData();
122		$this->assertEquals(['data' => ['__schema' => ['subscriptionType' => null]]], $data);
123		}
124
125		public function testSchemaOperations()
126		{
127		$schema = new Schema([
128		'query' => new ObjectType([
129		'name' => 'RootQuery',
130		'fields' => [
131		'me' => [
132		'type' => new ObjectType([
133		'name' => 'User',
134		'fields' => [
135		'firstName' => [
136		'type' => new StringType(),
137		'args' => [
138		'shorten' => new BooleanType()
139		],
140		'resolve' => function ($value, $args) {
141		return empty($args['shorten']) ? $value : $value;
142		}
143		],
144		'lastName' => new StringType(),
145		'code' => new StringType(),
146		]
147		]),
148	View Code Duplication	'resolve' => function ($value, $args) {
		0 ignored issues – show Duplication introduced 2016-07-19 12:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
149		$data = ['firstName' => 'John', 'code' => '007'];
150		if (!empty($args['upper'])) {
151		foreach ($data as $key => $value) {
152		$data[$key] = strtoupper($value);
153		}
154		}
155
156		return $data;
157		},
158		'args' => [
159		'upper' => [
160		'type' => new BooleanType(),
161		'default' => false
162		]
163		]
164		],
165		'randomUser' => [
166		'type' => new TestObjectType(),
167		'resolve' => function () {
168		return ['invalidField' => 'John'];
169		}
170		],
171		'invalidValueQuery' => [
172		'type' => new TestObjectType(),
173		'resolve' => function () {
174		return 'stringValue';
175		}
176		],
177		],
178		])
179		]);
180		$processor = new Processor($schema);
181
182		$processor->processPayload('{ me { firstName } }');
183		$this->assertEquals(['data' => ['me' => ['firstName' => 'John']]], $processor->getResponseData());
184
185		$processor->processPayload('{ me { firstName, lastName } }');
186		$this->assertEquals(['data' => ['me' => ['firstName' => 'John', 'lastName' => null]]], $processor->getResponseData());
187
188		$processor->processPayload('{ me { code } }');
189		$this->assertEquals(['data' => ['me' => ['code' => 7]]], $processor->getResponseData());
190
191		$processor->processPayload('{ me(upper:true) { firstName } }');
192		$this->assertEquals(['data' => ['me' => ['firstName' => 'JOHN']]], $processor->getResponseData());
193
194		$schema->getMutationType()
195		->addField(new Field([
196		'name' => 'increaseCounter',
197		'type' => new IntType(),
198		'resolve' => function ($value, $args, ResolveInfo $info) {
		0 ignored issues – show Unused Code introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report The parameter `$info` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
199		return $this->_counter += $args['amount'];
200		},
201		'args' => [
202		'amount' => [
203		'type' => new IntType(),
204		'default' => 1
205		]
206		]
207		]))->addField(new Field([
208		'name' => 'invalidResolveTypeMutation',
209		'type' => new NonNullType(new IntType()),
210		'resolve' => function () {
211		return null;
212		}
213		]))->addField(new Field([
214		'name' => 'interfacedMutation',
215		'type' => new TestInterfaceType(),
216		'resolve' => function () {
217		return ['name' => 'John'];
218		}
219		]));
220		$processor->processPayload('mutation { increaseCounter }');
221		$this->assertEquals(['data' => ['increaseCounter' => 1]], $processor->getResponseData());
222
223		$processor->processPayload('mutation { invalidMutation }');
224		$this->assertEquals(['errors' => [['message' => 'Field "invalidMutation" not found in type "RootSchemaMutation"']]], $processor->getResponseData());
225
226		$processor->processPayload('mutation { increaseCounter(noArg: 2) }');
227		$this->assertEquals(['errors' => [['message' => 'Unknown argument "noArg" on field "increaseCounter"']]], $processor->getResponseData());
228
229		$processor->processPayload('mutation { increaseCounter(amount: 2) { invalidProp } }');
230		$this->assertEquals(['errors' => [['message' => 'Field "invalidProp" not found in type "Int"']], 'data' => ['increaseCounter' => null]], $processor->getResponseData());
231
232		$processor->processPayload('mutation { increaseCounter(amount: 2) }');
233		$this->assertEquals(['data' => ['increaseCounter' => 5]], $processor->getResponseData());
234
235		$processor->processPayload('{ invalidQuery }');
236		$this->assertEquals(['errors' => [['message' => 'Field "invalidQuery" not found in type "RootQuery"']]], $processor->getResponseData());
237
238		$processor->processPayload('{ invalidValueQuery { id } }');
239		$this->assertEquals(['errors' => [['message' => 'Not valid value for OBJECT field invalidValueQuery']], 'data' => ['invalidValueQuery' => null]], $processor->getResponseData());
240
241		$processor->processPayload('{ me { firstName(shorten: true), middle }}');
242		$this->assertEquals(['errors' => [['message' => 'Field "middle" not found in type "User"']], 'data' => ['me' => null]], $processor->getResponseData());
243
244		$processor->processPayload('{ randomUser { region }}');
245		$this->assertEquals(['errors' => [['message' => 'Property "region" not found in resolve result']]], $processor->getResponseData());
246
247		$processor->processPayload('mutation { invalidResolveTypeMutation }');
248		$this->assertEquals(['errors' => [['message' => 'Cannot return null for non-nullable field invalidResolveTypeMutation']], 'data' => ['invalidResolveTypeMutation' => null]], $processor->getResponseData());
249
250		$processor->processPayload('mutation { user:interfacedMutation { name } }');
251		$this->assertEquals(['data' => ['user' => ['name' => 'John']]], $processor->getResponseData());
252		}
253
254		public function testListEnumsSchemaOperations()
255		{
256		$processor = new Processor(new Schema([
257		'query' => new ObjectType([
258		'name' => 'RootQuery',
259		'fields' => [
260		'listQuery' => [
261		'type' => new ListType(new TestEnumType()),
262		'resolve' => function () {
263		return 'invalid list';
264		}
265		],
266		'listEnumQuery' => [
267		'type' => new ListType(new TestEnumType()),
268		'resolve' => function () {
269		return ['invalid enum'];
270		}
271		],
272		'invalidEnumQuery' => [
273		'type' => new TestEnumType(),
274		'resolve' => function () {
275		return 'invalid enum';
276		}
277		],
278		'enumQuery' => [
279		'type' => new TestEnumType(),
280		'resolve' => function () {
281		return 1;
282		}
283		],
284		'invalidNonNullQuery' => [
285		'type' => new NonNullType(new IntType()),
286		'resolve' => function () {
287		return null;
288		}
289		],
290		'invalidNonNullInsideQuery' => [
291		'type' => new NonNullType(new IntType()),
292		'resolve' => function () {
293		return 'hello';
294		}
295		],
296		'objectQuery' => [
297		'type' => new TestObjectType(),
298		'resolve' => function () {
299		return ['name' => 'John'];
300		}
301		],
302		'deepObjectQuery' => [
303		'type' => new ObjectType([
304		'name' => 'deepObject',
305		'fields' => [
306		'object' => new TestObjectType(),
307		'enum' => new TestEnumType(),
308		],
309		]),
310		'resolve' => function () {
311		return [
312		'object' => [
313		'name' => 'John'
314		],
315		'enum' => 1
316		];
317		},
318		],
319		]
320		])
321		]));
322
323		$processor->processPayload('{ listQuery }');
324		$this->assertEquals(['errors' => [
325		['message' => 'Not valid value for LIST field listQuery']
326		], 'data' => ['listQuery' => null]], $processor->getResponseData());
327
328		$processor->processPayload('{ listEnumQuery }');
329		$this->assertEquals(['errors' => [
330		['message' => 'Not valid resolve value in listEnumQuery field']
331		], 'data' => ['listEnumQuery' => [null]]], $processor->getResponseData());
332
333		$processor->processPayload('{ invalidEnumQuery }');
334		$this->assertEquals(['errors' => [
335		['message' => 'Not valid value for ENUM field invalidEnumQuery']
336		], 'data' => ['invalidEnumQuery' => null]], $processor->getResponseData());
337
338		$processor->processPayload('{ enumQuery }');
339		$this->assertEquals(['data' => ['enumQuery' => 'FINISHED']], $processor->getResponseData());
340
341		$processor->processPayload('{ invalidNonNullQuery }');
342		$this->assertEquals(['errors' => [
343		['message' => 'Cannot return null for non-nullable field invalidNonNullQuery']
344		], 'data' => ['invalidNonNullQuery' => null]], $processor->getResponseData());
345
346		$processor->processPayload('{ invalidNonNullInsideQuery }');
347		$this->assertEquals(['errors' => [
348		['message' => 'Not valid value for SCALAR field invalidNonNullInsideQuery']
349		], 'data' => ['invalidNonNullInsideQuery' => null]], $processor->getResponseData());
350
351		$processor->processPayload('{ test:deepObjectQuery { object { name } } }');
352		$this->assertEquals(['data' => ['test' => ['object' => ['name' => 'John']]]], $processor->getResponseData());
353		}
354
355		public function testTypedFragment()
356		{
357
358		$object1 = new ObjectType([
359		'name' => 'Object1',
360		'fields' => [
361		'id' => ['type' => 'int']
362		]
363		]);
364
365		$object2 = new ObjectType([
366		'name' => 'Object2',
367		'fields' => [
368		'name' => ['type' => 'string']
369		]
370		]);
371
372		$object3 = new ObjectType([
373		'name' => 'Object3',
374		'fields' => [
375		'name' => ['type' => 'string']
376		]
377		]);
378
379		$union = new UnionType([
380		'name' => 'TestUnion',
381		'types' => [$object1, $object2],
382		'resolveType' => function ($object) use ($object1, $object2) {
383		if (isset($object['id'])) {
384		return $object1;
385		}
386
387		return $object2;
388		}
389		]);
390		$invalidUnion = new UnionType([
391		'name' => 'TestUnion',
392		'types' => [$object1, $object2],
393		'resolveType' => function ($object) use ($object3) {
		0 ignored issues – show Unused Code introduced 2016-05-21 01:18 UTC by Report Bug Copy Issue Report The parameter `$object` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
394		return $object3;
395		}
396		]);
397		$processor = new Processor(new Schema([
398		'query' => new ObjectType([
399		'name' => 'RootQuery',
400		'fields' => [
401		'union' => [
402		'type' => $union,
403		'args' => [
404		'type' => ['type' => 'string']
405		],
406		'resolve' => function ($value, $args) {
407		if ($args['type'] == 'object1') {
408		return [
409		'id' => 43
410		];
411		} else {
412		return [
413		'name' => 'name resolved'
414		];
415		}
416		}
417		],
418		'invalidUnion' => [
419		'type' => $invalidUnion,
420		'resolve' => function () {
421		return ['name' => 'name resolved'];
422		}
423		],
424		]
425		])
426		]));
427		$processor->processPayload('{ union(type: "object1") { ... on Object2 { id } } }');
428		$this->assertEquals(['data' => ['union' => []]], $processor->getResponseData());
429
430		$processor->processPayload('{ union(type: "object1") { ... on Object1 { name } } }');
431		$this->assertEquals([
432		'data' => [
433		'union' => []
434		],
435		'errors' => [
436		['message' => 'Field "name" not found in type "Object1"']
437		]
438		], $processor->getResponseData());
439
440		$processor->processPayload('{ union(type: "object1") { ... on Object1 { id } } }');
441		$this->assertEquals(['data' => ['union' => ['id' => 43]]], $processor->getResponseData());
442
443		$processor->processPayload('{ union(type: "asd") { ... on Object2 { name } } }');
444		$this->assertEquals(['data' => ['union' => ['name' => 'name resolved']]], $processor->getResponseData());
445
446		$processor->processPayload('{ invalidUnion { ... on Object2 { name } } }');
447		$this->assertEquals(['errors' => [['message' => 'Type Object3 not exist in types of Object2']]], $processor->getResponseData());
448
449		}
450
451		public function testComplexityReducer() {
452		$schema = new Schema(
453		[
454		'query' => new ObjectType(
455		[
456		'name' => 'RootQuery',
457		'fields' => [
458		'me' => [
459		'type' => new ObjectType(
460		[
461		'name' => 'User',
462		'fields' => [
463		'firstName' => [
464		'type' => new StringType(),
465		'args' => [
466		'shorten' => new BooleanType()
467		],
468		'resolve' => function ($value, $args) {
469		return empty($args['shorten']) ? $value : $value;
470		}
471		],
472		'lastName' => new StringType(),
473		'code' => new StringType(),
474		'likes' => [
475		'type' => new IntType(),
476		'cost' => 10,
477		'resolve' => function () {
478		return 42;
479		}
480		]
481		]
482		]
483		),
484	View Code Duplication	'resolve' => function ($value, $args) {
		0 ignored issues – show Duplication introduced 2016-07-19 12:12 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
485		$data = ['firstName' => 'John', 'code' => '007'];
486		if (!empty($args['upper'])) {
487		foreach ($data as $key => $value) {
488		$data[$key] = strtoupper($value);
489		}
490		}
491
492		return $data;
493		},
494		'args' => [
495		'upper' => [
496		'type' => new BooleanType(),
497		'default' => false
498		]
499		]
500		]
501		]
502		]
503		)
504		]
505		);
506		$processor = new Processor($schema);
507
508		$processor->setMaxComplexity(10);
509
510		$processor->processPayload('{ me { firstName, lastName } }');
511		$this->assertArrayNotHasKey('error', $processor->getResponseData());
512
513		$processor->processPayload('{ me { firstname likes { count } } }');
514		$this->assertEquals(['errors' => [['message' => 'query exceeded max allowed complexity of 10']]], $processor->getResponseData());
515		}
516		}
517

Youshido / GraphQL

Pull Request — master (#15)

ProcessorTest B

Complexity

Size/Duplication

Coupling/Cohesion

Importance

9 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like