NonNullScalarValidationTest::setUp() - Code Metrics - Inspection of "ListOf Refactor" - shmax/graphql-php-validation-toolkit - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7)

by Max

created 2019-10-07 14:50 UTC

NonNullScalarValidationTest::setUp() A

↳ Parent: Project

Complexity

Conditions	2
Paths	1

Size

Total Lines	55
Code Lines	36

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	36
nc	1
nop	0
dl	0
loc	55
rs	9.344
c	1
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace GraphQL\Tests\Type\ValidatedFieldDefinition;

use GraphQL\GraphQL;
use GraphQL\Tests\Utils;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\ValidatedFieldDefinition;
use GraphQL\Type\Schema;
use PHPUnit\Framework\TestCase;

final class NonNullScalarValidationTest extends TestCase
{
    /** @var Type */
    protected $bookType;

    /** @var Type */
    protected $personType;

    /** @var mixed[] */
    protected $data = [
        'people' => [
            1 => ['firstName' => 'Wilson'],
        ],
        'books' => [
            1 => [
                'title' => 'Where the Red Fern Grows',
                'author' => 1,
            ],
        ],
    ];

    /** @var Schema */
    protected $schema;

    protected function setUp(): void
    {
        $this->personType = new ObjectType([
            'name' => 'Person',
            'fields' => [
                'firstName' => [
                    'type' => Type::string(),
                    'phoneNumbers' => [
                        'type' => Type::listOf(Type::string()),
                    ],
                ],
            ],
        ]);

        $this->bookType = new ObjectType([
            'name' => 'Book',
            'fields' => [
                'title' => [
                    'type' => Type::string(),
                    'resolve' => static function ($book) {
                        return $book['title'];
                    },
                ],
                'author' => [
                    'type' => $this->personType,
                    'resolve' => static function ($book) {
                        return $book['author'];
                    },
                ],
            ],
        ]);

        $this->schema = new Schema([
            'mutation' => new ObjectType([
                'name' => 'Mutation',
                'fields' => function () {
                    return [
                        'updateBook' => new ValidatedFieldDefinition([
                            'name' => 'updateBook',
                            'type' => $this->bookType,
                            'args' => [
                                'bookId' => [
                                    'type' => Type::nonNull(Type::id()),
                                    'errorCodes' => ['bookNotFound'],
                                    'validate' => function ($bookId) {
                                        if (isset($this->data['books'][$bookId])) {
                                            return 0;
                                        }

                                        return ['bookNotFound', 'Unknown book!'];
                                    },
                                ],
                            ],
                            'resolve' => function ($value, $args) : array {
                                return $this->data['books'][$args['bookId']];
                            },
                        ]),
                    ];
                },
            ]),
        ]);
    }

    public function testNonNullScalarValidationSuccess(): void
    {
        $res = GraphQL::executeQuery(
            $this->schema,
            Utils::nowdoc('
                mutation UpdateBook(
                    $bookId:ID!
                ) {
                    updateBook (bookId: $bookId) {
                        valid
                        suberrors {
                            bookId {
                                code
                                msg
                            }
                        }
                        result {
                            title
                        }
                    }
                }
            '),
            [],
            null,
            ['bookId' => 1]
        );

        static::assertTrue($res->data['updateBook']['valid']);
    }

    public function testNonNullScalarValidationFail() : void
    {
        $res = GraphQL::executeQuery(
            $this->schema,
            Utils::nowdoc('
                mutation UpdateBook(
                        $bookId:ID!
                    ) {
                        updateBook (bookId: $bookId) {
                            valid
                            suberrors {
                                bookId {
                                    code
                                    msg
                                }
                            }
                            result {
                                title
                            }
                        }
                    }
            '),
            [],
            null,
            ['bookId' => 37]
        );

        static::assertEmpty($res->errors);
        static::assertFalse($res->data['updateBook']['valid']);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace GraphQL\Tests\Type\ValidatedFieldDefinition;
6
7			use GraphQL\GraphQL;
8			use GraphQL\Tests\Utils;
9			use GraphQL\Type\Definition\ObjectType;
10			use GraphQL\Type\Definition\Type;
11			use GraphQL\Type\Definition\ValidatedFieldDefinition;
12			use GraphQL\Type\Schema;
13			use PHPUnit\Framework\TestCase;
14
15			final class NonNullScalarValidationTest extends TestCase
16			{
17			/** @var Type */
18			protected $bookType;
19
20			/** @var Type */
21			protected $personType;
22
23			/** @var mixed[] */
24			protected $data = [
25			'people' => [
26			1 => ['firstName' => 'Wilson'],
27			],
28			'books' => [
29			1 => [
30			'title' => 'Where the Red Fern Grows',
31			'author' => 1,
32			],
33			],
34			];
35
36			/** @var Schema */
37			protected $schema;
38
39			protected function setUp(): void
40			{
41			$this->personType = new ObjectType([
42			'name' => 'Person',
43			'fields' => [
44			'firstName' => [
45			'type' => Type::string(),
46			'phoneNumbers' => [
47			'type' => Type::listOf(Type::string()),
48			],
49			],
50			],
51			]);
52
53			$this->bookType = new ObjectType([
54			'name' => 'Book',
55			'fields' => [
56			'title' => [
57			'type' => Type::string(),
58			'resolve' => static function ($book) {
59			return $book['title'];
60			},
61			],
62			'author' => [
63			'type' => $this->personType,
64			'resolve' => static function ($book) {
65			return $book['author'];
66			},
67			],
68			],
69			]);
70
71			$this->schema = new Schema([
72			'mutation' => new ObjectType([
73			'name' => 'Mutation',
74			'fields' => function () {
75			return [
76			'updateBook' => new ValidatedFieldDefinition([
77			'name' => 'updateBook',
78			'type' => $this->bookType,
79			'args' => [
80			'bookId' => [
81			'type' => Type::nonNull(Type::id()),
82			'errorCodes' => ['bookNotFound'],
83			'validate' => function ($bookId) {
84			if (isset($this->data['books'][$bookId])) {
85			return 0;
86			}
87
88			return ['bookNotFound', 'Unknown book!'];
89			},
90			],
91			],
92			'resolve' => function ($value, $args) : array {
93			return $this->data['books'][$args['bookId']];
94			},
95			]),
96			];
97			},
98			]),
99			]);
100			}
101
102			public function testNonNullScalarValidationSuccess(): void
103			{
104			$res = GraphQL::executeQuery(
105			$this->schema,
106			Utils::nowdoc('
107			mutation UpdateBook(
108			$bookId:ID!
109			) {
110			updateBook (bookId: $bookId) {
111			valid
112			suberrors {
113			bookId {
114			code
115			msg
116			}
117			}
118			result {
119			title
120			}
121			}
122			}
123			'),
124			[],
125			null,
126			['bookId' => 1]
127			);
128
129			static::assertTrue($res->data['updateBook']['valid']);
130			}
131
132			public function testNonNullScalarValidationFail() : void
133			{
134			$res = GraphQL::executeQuery(
135			$this->schema,
136			Utils::nowdoc('
137			mutation UpdateBook(
138			$bookId:ID!
139			) {
140			updateBook (bookId: $bookId) {
141			valid
142			suberrors {
143			bookId {
144			code
145			msg
146			}
147			}
148			result {
149			title
150			}
151			}
152			}
153			'),
154			[],
155			null,
156			['bookId' => 37]
157			);
158
159			static::assertEmpty($res->errors);
160			static::assertFalse($res->data['updateBook']['valid']);
161			}
162			}
163

shmax / graphql-php-validation-toolkit

Pull Request — master (#7)

NonNullScalarValidationTest::setUp() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like