ParserTest::testTypedFragment() - Code Metrics - Inspection of "- add ability for parser to parse typed fragment" - Youshido/GraphQL - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 325209...de8c12 )

by Portey

created 2015-12-16 11:51 UTC

ParserTest::testTypedFragment() B

↳ Parent: ParserTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	30
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	30
rs	8.8571
cc	1
eloc	12
nc	1
nop	0

<?php
/**
 * Date: 01.12.15
 *
 * @author Portey Vasil <[email protected]>
 */

namespace Youshido\tests\GraphQL\Parser;

use Youshido\GraphQL\Parser\Ast\Argument;
use Youshido\GraphQL\Parser\Ast\Field;
use Youshido\GraphQL\Parser\Ast\Fragment;
use Youshido\GraphQL\Parser\Ast\FragmentReference;
use Youshido\GraphQL\Parser\Ast\Mutation;
use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;
use Youshido\GraphQL\Parser\Value\InputList;
use Youshido\GraphQL\Parser\Value\InputObject;
use Youshido\GraphQL\Parser\Value\Literal;
use Youshido\GraphQL\Parser\Ast\Query;
use Youshido\GraphQL\Parser\Parser;
use Youshido\GraphQL\Parser\Value\Variable;

class ParserTest extends \PHPUnit_Framework_TestCase
{

    /**
     * @param $query string
     *
     * @dataProvider wrongQueriesProvider
     * @expectedException Youshido\GraphQL\Parser\SyntaxErrorException
     */
    public function testWrongQueries($query)
    {
        $parser = new Parser();

        $parser->setSource($query);
        $parser->parse();
    }

    public function wrongQueriesProvider()
    {
        return [
            ['{ test { id,, asd } }'],
            ['{ test { id,, } }'],
            ['{ test (a: $a, b: <basd>) { id }'],
            ['{ test (asd: [..., asd]) { id } }'],
            ['{ test (asd: { "a": 4, b: 5}) { id } }'],
            ['{ test (asd: { "a": 4, "m": null, "asd": false  "b": 5, "c" : { a }}) { id } }'],
            ['asdasd'],
            ['mutation { test(asd: ... ){ ...,asd, asd } }'],
            ['mutation { test( asd: $,as ){ ...,asd, asd } }']
        ];
    }

    /**
     * @dataProvider mutationProvider
     */
    public function testMutations($query, $structure)
    {
        $parser = new Parser();
        $parser->setSource($query);

        $parsedStructure = $parser->parse();

        $this->assertEquals($parsedStructure, $structure);
    }

    public function testTypedFragment()
    {
        $parser = new Parser();
        $parser->setSource('
            {
                test: test {
                    name,
                    ... on UnionType {
                        unionName
                    }
                }
            }
        ');

        $parsedStructure = $parser->parse();

        $this->assertEquals($parsedStructure, [
            'queries' => [
                new Query('test', 'test', [],
                    [
                        new Field('name', null),
                        new TypedFragmentReference('UnionType', [
                            new Field('unionName')
                        ])
                    ])
            ],
            'mutations' => [],
            'fragments' => []
        ]);
    }

    public function mutationProvider()
    {
        return [
            [
                '{ query ( teas: $variable ) { alias: name } }',
                [
                    'queries' => [
                        new Query('query', null,
                            [
                                new Argument('teas', new Variable('variable'))
                            ],
                            [
                                new Field('name', 'alias')
                            ])
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{ query { alias: name } }',
                [
                    'queries' => [
                        new Query('query', null, [], [new Field('name', 'alias')])
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                'mutation { createUser ( email: "[email protected]", active: true ) { id } }',
                [
                    'queries'   => [],
                    'mutations' => [
                        new Mutation(
                            'createUser',
                            null,
                            [
                                new Argument('email', new Literal('[email protected]')),
                                new Argument('active', new Literal(true)),
                            ],
                            [
                                new Field('id')
                            ]
                        )
                    ],
                    'fragments' => []
                ]
            ],
            [
                'mutation { test : createUser (id: 4) }',
                [
                    'queries'   => [],
                    'mutations' => [
                        new Mutation(
                            'createUser',
                            'test',
                            [
                                new Argument('id', new Literal(4)),
                            ],
                            []
                        )
                    ],
                    'fragments' => []
                ]
            ]
        ];
    }

    /**
     * @dataProvider queryProvider
     */
    public function testParser($query, $structure)
    {
        $parser = new Parser();
        $parser->setSource($query);

        $parsedStructure = $parser->parse();

        $this->assertEquals($parsedStructure, $structure);
    }


    public function queryProvider()
    {
        return [
            [
                'query CheckTypeOfLuke {
                  hero(episode: EMPIRE) {
                    __typename,
                    name
                  }
                }',
                [
                    'queries'   => [
                        new Query('hero', null, [
                            new Argument('episode', new Literal('EMPIRE'))
                        ], [
                            new Field('__typename'),
                            new Field('name'),
                        ])
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{ test { __typename, id } }',
                [
                    'queries'   => [
                        new Query('test', null, [], [
                            new Field('__typename'),
                            new Field('id'),
                        ])
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{}',
                [
                    'queries'   => [],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                'query test {}',
                [
                    'queries'   => [],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                'query {}',
                [
                    'queries'   => [],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                'mutation setName { setUserName }',
                [
                    'queries'   => [],
                    'mutations' => [new Mutation('setUserName')],
                    'fragments' => []
                ]
            ],
            [
                '{ test { ...userDataFragment } } fragment userDataFragment on User { id, name, email }',
                [
                    'queries'   => [
                        new Query('test', null, [], [new FragmentReference('userDataFragment')])
                    ],
                    'mutations' => [],
                    'fragments' => [
                        new Fragment('userDataFragment', 'User', [
                            new Field('id'),
                            new Field('name'),
                            new Field('email')
                        ])
                    ]
                ]
            ],
            [
                '{ user (id: 10, name: "max", float: 123.123 ) { id, name } }',
                [
                    'queries'   => [
                        new Query(
                            'user',
                            null,
                            [
                                new Argument('id', new Literal('10')),
                                new Argument('name', new Literal('max')),
                                new Argument('float', new Literal('123.123'))
                            ],
                            [
                                new Field('id'),
                                new Field('name')
                            ]
                        )
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{ allUsers : users ( id: [ 1, 2, 3] ) { id } }',
                [
                    'queries'   => [
                        new Query(
                            'users',
                            'allUsers',
                            [
                                new Argument('id', new InputList([1, 2, 3]))
                            ],
                            [
                                new Field('id')
                            ]
                        )
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{ allUsers : users ( id: [ 1, "2", true, null] ) { id } }',
                [
                    'queries'   => [
                        new Query(
                            'users',
                            'allUsers',
                            [
                                new Argument('id', new InputList([1, "2", true, null]))
                            ],
                            [
                                new Field('id')
                            ]
                        )
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ],
            [
                '{ allUsers : users ( object: { "a": 123, "d": "asd",  "b" : [ 1, 2, 4 ], "c": { "a" : 123, "b":  "asd" } } ) { id } }',
                [
                    'queries'   => [
                        new Query(
                            'users',
                            'allUsers',
                            [
                                new Argument('object', new InputObject([
                                    'a' => 123,
                                    'd' => 'asd',
                                    'b' => [1, 2, 4],
                                    'c' => [
                                        'a' => 123,
                                        'b' => 'asd'
                                    ]
                                ]))
                            ],
                            [
                                new Field('id')
                            ]
                        )
                    ],
                    'mutations' => [],
                    'fragments' => []
                ]
            ]
        ];
    }

}

1			<?php
2			/**
3			* Date: 01.12.15
4			*
5			* @author Portey Vasil <[email protected]>
6			*/
7
8			namespace Youshido\tests\GraphQL\Parser;
9
10			use Youshido\GraphQL\Parser\Ast\Argument;
11			use Youshido\GraphQL\Parser\Ast\Field;
12			use Youshido\GraphQL\Parser\Ast\Fragment;
13			use Youshido\GraphQL\Parser\Ast\FragmentReference;
14			use Youshido\GraphQL\Parser\Ast\Mutation;
15			use Youshido\GraphQL\Parser\Ast\TypedFragmentReference;
16			use Youshido\GraphQL\Parser\Value\InputList;
17			use Youshido\GraphQL\Parser\Value\InputObject;
18			use Youshido\GraphQL\Parser\Value\Literal;
19			use Youshido\GraphQL\Parser\Ast\Query;
20			use Youshido\GraphQL\Parser\Parser;
21			use Youshido\GraphQL\Parser\Value\Variable;
22
23			class ParserTest extends \PHPUnit_Framework_TestCase
24			{
25
26			/**
27			* @param $query string
28			*
29			* @dataProvider wrongQueriesProvider
30			* @expectedException Youshido\GraphQL\Parser\SyntaxErrorException
31			*/
32			public function testWrongQueries($query)
33			{
34			$parser = new Parser();
35
36			$parser->setSource($query);
37			$parser->parse();
38			}
39
40			public function wrongQueriesProvider()
41			{
42			return [
43			['{ test { id,, asd } }'],
44			['{ test { id,, } }'],
45			['{ test (a: $a, b: <basd>) { id }'],
46			['{ test (asd: [..., asd]) { id } }'],
47			['{ test (asd: { "a": 4, b: 5}) { id } }'],
48			['{ test (asd: { "a": 4, "m": null, "asd": false "b": 5, "c" : { a }}) { id } }'],
49			['asdasd'],
50			['mutation { test(asd: ... ){ ...,asd, asd } }'],
51			['mutation { test( asd: $,as ){ ...,asd, asd } }']
52			];
53			}
54
55			/**
56			* @dataProvider mutationProvider
57			*/
58			public function testMutations($query, $structure)
59			{
60			$parser = new Parser();
61			$parser->setSource($query);
62
63			$parsedStructure = $parser->parse();
64
65			$this->assertEquals($parsedStructure, $structure);
66			}
67
68			public function testTypedFragment()
69			{
70			$parser = new Parser();
71			$parser->setSource('
72			{
73			test: test {
74			name,
75			... on UnionType {
76			unionName
77			}
78			}
79			}
80			');
81
82			$parsedStructure = $parser->parse();
83
84			$this->assertEquals($parsedStructure, [
85			'queries' => [
86			new Query('test', 'test', [],
87			[
88			new Field('name', null),
89			new TypedFragmentReference('UnionType', [
90			new Field('unionName')
91			])
92			])
93			],
94			'mutations' => [],
95			'fragments' => []
96			]);
97			}
98
99			public function mutationProvider()
100			{
101			return [
102			[
103			'{ query ( teas: $variable ) { alias: name } }',
104			[
105			'queries' => [
106			new Query('query', null,
107			[
108			new Argument('teas', new Variable('variable'))
109			],
110			[
111			new Field('name', 'alias')
112			])
113			],
114			'mutations' => [],
115			'fragments' => []
116			]
117			],
118			[
119			'{ query { alias: name } }',
120			[
121			'queries' => [
122			new Query('query', null, [], [new Field('name', 'alias')])
123			],
124			'mutations' => [],
125			'fragments' => []
126			]
127			],
128			[
129			'mutation { createUser ( email: "[email protected]", active: true ) { id } }',
130			[
131			'queries' => [],
132			'mutations' => [
133			new Mutation(
134			'createUser',
135			null,
136			[
137			new Argument('email', new Literal('[email protected]')),
138			new Argument('active', new Literal(true)),
139			],
140			[
141			new Field('id')
142			]
143			)
144			],
145			'fragments' => []
146			]
147			],
148			[
149			'mutation { test : createUser (id: 4) }',
150			[
151			'queries' => [],
152			'mutations' => [
153			new Mutation(
154			'createUser',
155			'test',
156			[
157			new Argument('id', new Literal(4)),
158			],
159			[]
160			)
161			],
162			'fragments' => []
163			]
164			]
165			];
166			}
167
168			/**
169			* @dataProvider queryProvider
170			*/
171			public function testParser($query, $structure)
172			{
173			$parser = new Parser();
174			$parser->setSource($query);
175
176			$parsedStructure = $parser->parse();
177
178			$this->assertEquals($parsedStructure, $structure);
179			}
180
181
182			public function queryProvider()
183			{
184			return [
185			[
186			'query CheckTypeOfLuke {
187			hero(episode: EMPIRE) {
188			__typename,
189			name
190			}
191			}',
192			[
193			'queries' => [
194			new Query('hero', null, [
195			new Argument('episode', new Literal('EMPIRE'))
196			], [
197			new Field('__typename'),
198			new Field('name'),
199			])
200			],
201			'mutations' => [],
202			'fragments' => []
203			]
204			],
205			[
206			'{ test { __typename, id } }',
207			[
208			'queries' => [
209			new Query('test', null, [], [
210			new Field('__typename'),
211			new Field('id'),
212			])
213			],
214			'mutations' => [],
215			'fragments' => []
216			]
217			],
218			[
219			'{}',
220			[
221			'queries' => [],
222			'mutations' => [],
223			'fragments' => []
224			]
225			],
226			[
227			'query test {}',
228			[
229			'queries' => [],
230			'mutations' => [],
231			'fragments' => []
232			]
233			],
234			[
235			'query {}',
236			[
237			'queries' => [],
238			'mutations' => [],
239			'fragments' => []
240			]
241			],
242			[
243			'mutation setName { setUserName }',
244			[
245			'queries' => [],
246			'mutations' => [new Mutation('setUserName')],
247			'fragments' => []
248			]
249			],
250			[
251			'{ test { ...userDataFragment } } fragment userDataFragment on User { id, name, email }',
252			[
253			'queries' => [
254			new Query('test', null, [], [new FragmentReference('userDataFragment')])
255			],
256			'mutations' => [],
257			'fragments' => [
258			new Fragment('userDataFragment', 'User', [
259			new Field('id'),
260			new Field('name'),
261			new Field('email')
262			])
263			]
264			]
265			],
266			[
267			'{ user (id: 10, name: "max", float: 123.123 ) { id, name } }',
268			[
269			'queries' => [
270			new Query(
271			'user',
272			null,
273			[
274			new Argument('id', new Literal('10')),
275			new Argument('name', new Literal('max')),
276			new Argument('float', new Literal('123.123'))
277			],
278			[
279			new Field('id'),
280			new Field('name')
281			]
282			)
283			],
284			'mutations' => [],
285			'fragments' => []
286			]
287			],
288			[
289			'{ allUsers : users ( id: [ 1, 2, 3] ) { id } }',
290			[
291			'queries' => [
292			new Query(
293			'users',
294			'allUsers',
295			[
296			new Argument('id', new InputList([1, 2, 3]))
297			],
298			[
299			new Field('id')
300			]
301			)
302			],
303			'mutations' => [],
304			'fragments' => []
305			]
306			],
307			[
308			'{ allUsers : users ( id: [ 1, "2", true, null] ) { id } }',
309			[
310			'queries' => [
311			new Query(
312			'users',
313			'allUsers',
314			[
315			new Argument('id', new InputList([1, "2", true, null]))
316			],
317			[
318			new Field('id')
319			]
320			)
321			],
322			'mutations' => [],
323			'fragments' => []
324			]
325			],
326			[
327			'{ allUsers : users ( object: { "a": 123, "d": "asd", "b" : [ 1, 2, 4 ], "c": { "a" : 123, "b": "asd" } } ) { id } }',
328			[
329			'queries' => [
330			new Query(
331			'users',
332			'allUsers',
333			[
334			new Argument('object', new InputObject([
335			'a' => 123,
336			'd' => 'asd',
337			'b' => [1, 2, 4],
338			'c' => [
339			'a' => 123,
340			'b' => 'asd'
341			]
342			]))
343			],
344			[
345			new Field('id')
346			]
347			)
348			],
349			'mutations' => [],
350			'fragments' => []
351			]
352			]
353			];
354			}
355
356			}

Youshido / GraphQL

Push — master ( 325209...de8c12 )

ParserTest::testTypedFragment() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like