GraphQL\Tests\Type\ValidatedFieldDefinition\InputObjectValidationTest

Complexity

Total Complexity

6

Size/Duplication

Total Lines	271
Duplicated Lines	0 %

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	66	3
A	testValidationFail()	0	68	1
A	testValidationSuccess()	0	51	1
A	testValidationEmptyInput()	0	48	1

<?php

declare(strict_types=1);

namespace GraphQL\Tests\Type\ValidatedFieldDefinition;

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

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

    /** @var InputObjectType */
    protected $bookAttributesInputType;

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

    /** @var mixed[] */
    protected $data = [
        'people' => [
            1 => ['firstName' => 'Wilson'],
            2 => ['firstName' => 'J.D.'],
            3 => ['firstName' => 'Diana'],
        ],
    ];

    /** @var ObjectType */
    protected $query;

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

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

        $this->bookAttributesInputType = new InputObjectType([
            'name' => 'BookAttributes',
            'fields' => [
                'title' => [
                    'type' => Type::string(),
                    'description' => 'Enter a book title, no more than 10 characters in length',
                    'validate' => static function (string $title) {
                        if (strlen($title) > 10) {
                            return [1, 'book title must be less than 10 chaacters'];
                        }
                        return 0;
                    },
                ],
                'author' => [
                    'type' => Type::id(),
                    'description' => 'Provide a valid author id',
                    'errorCodes' => [
                        'unknownAuthor',
                        'authorDeceased',
                    ],
                    'validate' => function (string $authorId) {
                        if (! isset($this->data['people'][$authorId])) {
                            return ['unknownAuthor', 'We have no record of that author'];
                        }
                        return 0;
                    },
                ],
            ],
        ]);

        $this->query = new ObjectType(['name' => 'Query']);

        $this->schema = new Schema([
            'query' => $this->query,
            'mutation' => new ObjectType([
                'name' => 'Mutation',
                'fields' => function () {
                    return [
                        'updateBook' => new ValidatedFieldDefinition([
                            'name' => 'updateBook',
                            'type' => Type::boolean(),
                            'args' => [
                                'bookAttributes' => [
                                    'type' => $this->bookAttributesInputType,
                                ],
                            ],
                            'resolve' => static function ($value, $args) : bool {

The parameter $value is not used and could be removed.

The parameter $args is not used and could be removed.

                                // ...
                                // do update
                                // ...

                                return true;
                            },
                        ]),
                    ];
                },
            ]),
        ]);
    }

    public function testValidationFail()
    {
        $res = GraphQL::executeQuery(
            $this->schema,
            Utils::nowdoc('
				mutation UpdateBook(
                        $bookAttributes: BookAttributes
                    ) {
                        updateBook (
                            bookAttributes: $bookAttributes
                        ) {
                            valid
                            suberrors {
                                bookAttributes {
                                    suberrors {
                                        title {
                                            code
                                            msg
                                        }
                                        author {
                                            code
                                            msg
                                        }
                                    }
                                }
                            }
                            result
                        }
                    }
			'),
            [],
            null,
            [
                'bookAttributes' => [
                    'title' => 'The Catcher in the Rye',
                    'author' => 4,
                ],
            ]
        );

        static::assertEquals(
            [
                'valid' => false,
                'suberrors' =>
                    [
                        'bookAttributes' =>
                            [
                                'suberrors' =>
                                    [
                                        'title' =>
                                            [
                                                'code' => 1,
                                                'msg' => 'book title must be less than 10 chaacters',
                                            ],
                                        'author' =>
                                            [
                                                'code' => 'unknownAuthor',
                                                'msg' => 'We have no record of that author',
                                            ],
                                    ],
                            ],
                    ],
                'result' => null,
            ],
            $res->data['updateBook']
        );

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

    public function testValidationSuccess()
    {
        $res = GraphQL::executeQuery(
            $this->schema,
            Utils::nowdoc('
				mutation UpdateBook(
                        $bookAttributes: BookAttributes
                    ) {
                        updateBook (
                            bookAttributes: $bookAttributes
                        ) {
                            valid
                            suberrors {
                                bookAttributes {
                                    suberrors {
                                        title {
                                            code
                                            msg
                                        }
                                        author {
                                            code
                                            msg
                                        }
                                    }
                                }
                            }
                            result
                        }
                    }
			'),
            [],
            null,
            [
                'bookAttributes' => [
                    'title' => 'Dogsbody',
                    'author' => 3,
                ],
            ]
        );

        static::assertEmpty($res->errors);
        static::assertEquals(
            [
                'valid' => true,
                'suberrors' => null,
                'result' => true,
            ],
            $res->data['updateBook']
        );

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

    public function testValidationEmptyInput()
    {
        $res = GraphQL::executeQuery(
            $this->schema,
            Utils::nowdoc('
				mutation UpdateBook(
                        $bookAttributes: BookAttributes
                    ) {
                        updateBook (
                            bookAttributes: $bookAttributes
                        ) {
                            valid
                            suberrors {
                                bookAttributes {
                                    suberrors {
                                        title {
                                            code
                                            msg
                                        }
                                        author {
                                            code
                                            msg
                                        }
                                    }
                                }
                            }
                            result
                        }
                    }
			'),
            [],
            null,
            [
                'bookAttributes' => [],
            ]
        );

        static::assertEmpty($res->errors);
        static::assertEquals(
            [
                'valid' => true,
                'suberrors' => null,
                'result' => true,
            ],
            $res->data['updateBook']
        );

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