StarWarsQueryTest::testAllowsUsToQueryForTheFriendsOfFriendsOfR2D2() - Code Metrics - Inspection of "Merge branch 'master' into annotations" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — annotations ( a85f92...4ec00b )

by Jérémiah

created 2019-03-08 06:20 UTC

testAllowsUsToQueryForTheFriendsOfFriendsOfR2D2() A

↳ Parent: StarWarsQueryTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	54
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	26
dl	0
loc	54
rs	9.504
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

/*
 * This file is part of the OverblogGraphQLPhpGenerator package.
 *
 * (c) Overblog <http://github.com/overblog/>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Overblog\GraphQLGenerator\Tests;

class StarWarsQueryTest extends AbstractStarWarsTest
{
    // Star Wars Query Tests
    // Basic Queries
    public function testCorrectlyIdentifiesR2D2AsTheHeroOfTheStarWarsSaga()
    {
        // Correctly identifies R2-D2 as the hero of the Star Wars Saga
        $query = '
        query HeroNameQuery {
          hero {
            name
          }
        }
        ';
        $expected = [
            'hero' => [
                'name' => 'R2-D2'
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    public function testAllowsUsToQueryForTheIDAndFriendsOfR2D2()
    {
        $query = '
        query HeroNameAndFriendsQuery {
          hero {
            id
            name
            friends {
              name
            }
          }
        }
        ';
        $expected = [
            'hero' => [
                'id' => '2001',
                'name' => 'R2-D2',
                'friends' => [
                    [
                        'name' => 'Luke Skywalker',
                    ],
                    [
                        'name' => 'Han Solo',
                    ],
                    [
                        'name' => 'Leia Organa',
                    ],
                ]
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    // Nested Queries
    public function testAllowsUsToQueryForTheFriendsOfFriendsOfR2D2()
    {
        $query = '
        query NestedQuery {
          hero {
            name
            friends {
              name
              appearsIn
              friends {
                name
              }
            }
          }
        }
        ';
        $expected = [
            'hero' => [
                'name' => 'R2-D2',
                'friends' => [
                    [
                        'name' => 'Luke Skywalker',
                        'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI',],
                        'friends' => [
                            ['name' => 'Han Solo',],
                            ['name' => 'Leia Organa',],
                            ['name' => 'C-3PO',],
                            ['name' => 'R2-D2',],
                        ],
                    ],
                    [
                        'name' => 'Han Solo',
                        'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI'],
                        'friends' => [
                            ['name' => 'Luke Skywalker',],
                            ['name' => 'Leia Organa'],
                            ['name' => 'R2-D2',],
                        ]
                    ],
                    [
                        'name' => 'Leia Organa',
                        'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI'],
                        'friends' =>
                            [
                                ['name' => 'Luke Skywalker',],
                                ['name' => 'Han Solo',],
                                ['name' => 'C-3PO',],
                                ['name' => 'R2-D2',],
                            ],
                    ],
                ],
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    // Using IDs and query parameters to refetch objects
    public function testAllowsUsToQueryForLukeSkywalkerDirectlyUsingHisID()
    {
        $query = '
        query FetchLukeQuery {
          human(id: "1000") {
            name
          }
        }
        ';
        $expected = [
            'human' => [
                'name' => 'Luke Skywalker'
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }
    public function testGenericQueryToGetLukeSkywalkerById()
    {
        // Allows us to create a generic query, then use it to fetch Luke Skywalker using his ID
        $query = '
        query FetchSomeIDQuery($someId: String!) {
          human(id: $someId) {
            name
          }
        }
        ';
        $params = [
            'someId' => '1000'
        ];
        $expected = [
            'human' => [
                'name' => 'Luke Skywalker'
            ]
        ];
        $this->assertValidQuery($query, $expected, $params);
    }

    public function testGenericQueryToGetHanSoloById()
    {
        // Allows us to create a generic query, then use it to fetch Han Solo using his ID
        $query = '
        query FetchSomeIDQuery($someId: String!) {
          human(id: $someId) {
            name
          }
        }
        ';
        $params = [
            'someId' => '1002'
        ];
        $expected = [
            'human' => [
                'name' => 'Han Solo'
            ]
        ];
        $this->assertValidQuery($query, $expected, $params);
    }

    public function testGenericQueryWithInvalidId()
    {
        // Allows us to create a generic query, then pass an invalid ID to get null back
        $query = '
        query humanQuery($id: String!) {
          human(id: $id) {
            name
          }
        }
        ';
        $params = [
            'id' => 'not a valid id'
        ];
        $expected = [
            'human' => null
        ];
        $this->assertValidQuery($query, $expected, $params);
    }

    // Using aliases to change the key in the response
    public function testLukeKeyAlias()
    {
        // Allows us to query for Luke, changing his key with an alias
        $query = '
        query FetchLukeAliased {
          luke: human(id: "1000") {
            name
          }
        }
        ';
        $expected = [
            'luke' => [
                'name' => 'Luke Skywalker'
            ],
        ];
        $this->assertValidQuery($query, $expected);
    }

    public function testTwoRootKeysAsAnAlias()
    {
        // Allows us to query for both Luke and Leia, using two root fields and an alias
        $query = '
        query FetchLukeAndLeiaAliased {
          luke: human(id: "1000") {
            name
          }
          leia: human(id: "1003") {
            name
          }
        }
        ';
        $expected = [
            'luke' => [
                'name' => 'Luke Skywalker'
            ],
            'leia' => [
                'name' => 'Leia Organa'
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    // Uses fragments to express more complex queries
    public function testQueryUsingDuplicatedContent()
    {
        // Allows us to query using duplicated content
        $query = '
        query DuplicateFields {
          luke: human(id: "1000") {
            name
            homePlanet
          }
          leia: human(id: "1003") {
            name
            homePlanet
          }
        }
        ';
        $expected = [
            'luke' => [
                'name' => 'Luke Skywalker',
                'homePlanet' => 'Tatooine'
            ],
            'leia' => [
                'name' => 'Leia Organa',
                'homePlanet' => 'Alderaan'
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    public function testUsingFragment()
    {
        // Allows us to use a fragment to avoid duplicating content
        $query = '
        query UseFragment {
          luke: human(id: "1000") {
            ...HumanFragment
          }
          leia: human(id: "1003") {
            ...HumanFragment
          }
        }
        fragment HumanFragment on Human {
          name
          homePlanet
        }
        ';
        $expected = [
            'luke' => [
                'name' => 'Luke Skywalker',
                'homePlanet' => 'Tatooine'
            ],
            'leia' => [
                'name' => 'Leia Organa',
                'homePlanet' => 'Alderaan'
            ]
        ];
        $this->assertValidQuery($query, $expected);
    }

    // Using __typename to find the type of an object
    public function testVerifyThatR2D2IsADroid()
    {
        $query = '
        query CheckTypeOfR2 {
          hero {
            __typename
            name
          }
        }
        ';
        $expected = [
            'hero' => [
                '__typename' => 'Droid',
                'name' => 'R2-D2'
            ],
        ];
        $this->assertValidQuery($query, $expected);
    }

    public function testVerifyThatLukeIsHuman()
    {
        $query = '
        query CheckTypeOfLuke($episode: HeroInput!) {
          hero(episode: $episode) {
            __typename
            name
          }
        }
        ';
        $expected = [
            'hero' => [
                '__typename' => 'Human',
                'name' => 'Luke Skywalker'
            ],
        ];
        $this->assertValidQuery($query, $expected, ['episode' => ['name' => 'EMPIRE']]);
    }

    public function testDateTime()
    {
        $query = '{ dateTime }';
        $expected = [
            'dateTime' => '2016-11-28 12:00:00',
        ];
        $this->assertValidQuery($query, $expected);

        $query = '{ dateTime(dateTime: "2016-01-18 23:00:00") }';
        $expected = [
            'dateTime' => '2016-01-18 23:00:00',
        ];
        $this->assertValidQuery($query, $expected);
        $this->assertEquals('The DateTime type', $this->getType('DateTime')->description);
    }
}


1			<?php
2
3			/*
4			* This file is part of the OverblogGraphQLPhpGenerator package.
5			*
6			* (c) Overblog <http://github.com/overblog/>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Overblog\GraphQLGenerator\Tests;
13
14			class StarWarsQueryTest extends AbstractStarWarsTest
15			{
16			// Star Wars Query Tests
17			// Basic Queries
18			public function testCorrectlyIdentifiesR2D2AsTheHeroOfTheStarWarsSaga()
19			{
20			// Correctly identifies R2-D2 as the hero of the Star Wars Saga
21			$query = '
22			query HeroNameQuery {
23			hero {
24			name
25			}
26			}
27			';
28			$expected = [
29			'hero' => [
30			'name' => 'R2-D2'
31			]
32			];
33			$this->assertValidQuery($query, $expected);
34			}
35
36			public function testAllowsUsToQueryForTheIDAndFriendsOfR2D2()
37			{
38			$query = '
39			query HeroNameAndFriendsQuery {
40			hero {
41			id
42			name
43			friends {
44			name
45			}
46			}
47			}
48			';
49			$expected = [
50			'hero' => [
51			'id' => '2001',
52			'name' => 'R2-D2',
53			'friends' => [
54			[
55			'name' => 'Luke Skywalker',
56			],
57			[
58			'name' => 'Han Solo',
59			],
60			[
61			'name' => 'Leia Organa',
62			],
63			]
64			]
65			];
66			$this->assertValidQuery($query, $expected);
67			}
68
69			// Nested Queries
70			public function testAllowsUsToQueryForTheFriendsOfFriendsOfR2D2()
71			{
72			$query = '
73			query NestedQuery {
74			hero {
75			name
76			friends {
77			name
78			appearsIn
79			friends {
80			name
81			}
82			}
83			}
84			}
85			';
86			$expected = [
87			'hero' => [
88			'name' => 'R2-D2',
89			'friends' => [
90			[
91			'name' => 'Luke Skywalker',
92			'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI',],
93			'friends' => [
94			['name' => 'Han Solo',],
95			['name' => 'Leia Organa',],
96			['name' => 'C-3PO',],
97			['name' => 'R2-D2',],
98			],
99			],
100			[
101			'name' => 'Han Solo',
102			'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI'],
103			'friends' => [
104			['name' => 'Luke Skywalker',],
105			['name' => 'Leia Organa'],
106			['name' => 'R2-D2',],
107			]
108			],
109			[
110			'name' => 'Leia Organa',
111			'appearsIn' => ['NEWHOPE', 'EMPIRE', 'JEDI'],
112			'friends' =>
113			[
114			['name' => 'Luke Skywalker',],
115			['name' => 'Han Solo',],
116			['name' => 'C-3PO',],
117			['name' => 'R2-D2',],
118			],
119			],
120			],
121			]
122			];
123			$this->assertValidQuery($query, $expected);
124			}
125
126			// Using IDs and query parameters to refetch objects
127			public function testAllowsUsToQueryForLukeSkywalkerDirectlyUsingHisID()
128			{
129			$query = '
130			query FetchLukeQuery {
131			human(id: "1000") {
132			name
133			}
134			}
135			';
136			$expected = [
137			'human' => [
138			'name' => 'Luke Skywalker'
139			]
140			];
141			$this->assertValidQuery($query, $expected);
142			}
143			public function testGenericQueryToGetLukeSkywalkerById()
144			{
145			// Allows us to create a generic query, then use it to fetch Luke Skywalker using his ID
146			$query = '
147			query FetchSomeIDQuery($someId: String!) {
148			human(id: $someId) {
149			name
150			}
151			}
152			';
153			$params = [
154			'someId' => '1000'
155			];
156			$expected = [
157			'human' => [
158			'name' => 'Luke Skywalker'
159			]
160			];
161			$this->assertValidQuery($query, $expected, $params);
162			}
163
164			public function testGenericQueryToGetHanSoloById()
165			{
166			// Allows us to create a generic query, then use it to fetch Han Solo using his ID
167			$query = '
168			query FetchSomeIDQuery($someId: String!) {
169			human(id: $someId) {
170			name
171			}
172			}
173			';
174			$params = [
175			'someId' => '1002'
176			];
177			$expected = [
178			'human' => [
179			'name' => 'Han Solo'
180			]
181			];
182			$this->assertValidQuery($query, $expected, $params);
183			}
184
185			public function testGenericQueryWithInvalidId()
186			{
187			// Allows us to create a generic query, then pass an invalid ID to get null back
188			$query = '
189			query humanQuery($id: String!) {
190			human(id: $id) {
191			name
192			}
193			}
194			';
195			$params = [
196			'id' => 'not a valid id'
197			];
198			$expected = [
199			'human' => null
200			];
201			$this->assertValidQuery($query, $expected, $params);
202			}
203
204			// Using aliases to change the key in the response
205			public function testLukeKeyAlias()
206			{
207			// Allows us to query for Luke, changing his key with an alias
208			$query = '
209			query FetchLukeAliased {
210			luke: human(id: "1000") {
211			name
212			}
213			}
214			';
215			$expected = [
216			'luke' => [
217			'name' => 'Luke Skywalker'
218			],
219			];
220			$this->assertValidQuery($query, $expected);
221			}
222
223			public function testTwoRootKeysAsAnAlias()
224			{
225			// Allows us to query for both Luke and Leia, using two root fields and an alias
226			$query = '
227			query FetchLukeAndLeiaAliased {
228			luke: human(id: "1000") {
229			name
230			}
231			leia: human(id: "1003") {
232			name
233			}
234			}
235			';
236			$expected = [
237			'luke' => [
238			'name' => 'Luke Skywalker'
239			],
240			'leia' => [
241			'name' => 'Leia Organa'
242			]
243			];
244			$this->assertValidQuery($query, $expected);
245			}
246
247			// Uses fragments to express more complex queries
248			public function testQueryUsingDuplicatedContent()
249			{
250			// Allows us to query using duplicated content
251			$query = '
252			query DuplicateFields {
253			luke: human(id: "1000") {
254			name
255			homePlanet
256			}
257			leia: human(id: "1003") {
258			name
259			homePlanet
260			}
261			}
262			';
263			$expected = [
264			'luke' => [
265			'name' => 'Luke Skywalker',
266			'homePlanet' => 'Tatooine'
267			],
268			'leia' => [
269			'name' => 'Leia Organa',
270			'homePlanet' => 'Alderaan'
271			]
272			];
273			$this->assertValidQuery($query, $expected);
274			}
275
276			public function testUsingFragment()
277			{
278			// Allows us to use a fragment to avoid duplicating content
279			$query = '
280			query UseFragment {
281			luke: human(id: "1000") {
282			...HumanFragment
283			}
284			leia: human(id: "1003") {
285			...HumanFragment
286			}
287			}
288			fragment HumanFragment on Human {
289			name
290			homePlanet
291			}
292			';
293			$expected = [
294			'luke' => [
295			'name' => 'Luke Skywalker',
296			'homePlanet' => 'Tatooine'
297			],
298			'leia' => [
299			'name' => 'Leia Organa',
300			'homePlanet' => 'Alderaan'
301			]
302			];
303			$this->assertValidQuery($query, $expected);
304			}
305
306			// Using __typename to find the type of an object
307			public function testVerifyThatR2D2IsADroid()
308			{
309			$query = '
310			query CheckTypeOfR2 {
311			hero {
312			__typename
313			name
314			}
315			}
316			';
317			$expected = [
318			'hero' => [
319			'__typename' => 'Droid',
320			'name' => 'R2-D2'
321			],
322			];
323			$this->assertValidQuery($query, $expected);
324			}
325
326			public function testVerifyThatLukeIsHuman()
327			{
328			$query = '
329			query CheckTypeOfLuke($episode: HeroInput!) {
330			hero(episode: $episode) {
331			__typename
332			name
333			}
334			}
335			';
336			$expected = [
337			'hero' => [
338			'__typename' => 'Human',
339			'name' => 'Luke Skywalker'
340			],
341			];
342			$this->assertValidQuery($query, $expected, ['episode' => ['name' => 'EMPIRE']]);
343			}
344
345			public function testDateTime()
346			{
347			$query = '{ dateTime }';
348			$expected = [
349			'dateTime' => '2016-11-28 12:00:00',
350			];
351			$this->assertValidQuery($query, $expected);
352
353			$query = '{ dateTime(dateTime: "2016-01-18 23:00:00") }';
354			$expected = [
355			'dateTime' => '2016-01-18 23:00:00',
356			];
357			$this->assertValidQuery($query, $expected);
358			$this->assertEquals('The DateTime type', $this->getType('DateTime')->description);
359			}
360			}
361

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Push — annotations ( a85f92...4ec00b )

testAllowsUsToQueryForTheFriendsOfFriendsOfR2D2() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like