GraphQLTests\Doctrine\TypesTest

Complexity

Total Complexity

33

Size/Duplication

Total Lines	324
Duplicated Lines	0 %

Importance

Changes

0

28 Methods

Rating	Name	Duplication	Size	Complexity
A	assertObjectType()	0	3	1
A	testCanGetOutputTypes()	0	10	1
A	testCanGetUserDefinedScalarTypes()	0	10	1
A	testFieldWithoutTypeMustThrow()	0	5	1
A	testDefaultValuesInput()	0	4	1
A	setUp()	0	14	1
A	testFieldWithExtraArgumentMustThrow()	0	5	1
A	testNonPublicGetterMustBeIgnored()	0	4	1
A	testDoctrineWithoutAnnotationDriverMustThrow()	0	12	1
A	testCanGetInputTypes()	0	9	1
B	assertType()	0	42	6
A	testCanDeclareArrayOfEntity()	0	4	1
A	testFieldWithObjectTypeArgumentMustThrow()	0	5	1
A	assertInputType()	0	3	1
A	testCanGetMappedTypesEitherByMappedPhpClassOrDirectTypeClass()	0	5	1
A	testGraphQLSchemaFromDocumentationMustBeValid()	0	67	1
A	testHas()	0	7	1
A	testCannotGetInvalidType()	0	4	1
A	testDefaultValuesPartialInput()	0	4	1
A	testArgumentWithoutTypeMustThrow()	0	5	1
A	testInputWithoutTypeMustThrow()	0	5	1
A	testCanGetUserMappedTypes()	0	6	1
A	testNonRegisteredCustomTypeMustThrow()	0	4	1
A	testCanGetTypesWithBackslashPrefix()	0	4	1
A	testBlogMapping()	0	6	1
A	testFieldWithArrayArgumentMustThrow()	0	5	1
A	testFieldReturningCollectionWithoutTypeMustThrow()	0	5	1
A	testDefaultValuesOutput()	0	4	1

<?php

declare(strict_types=1);

namespace GraphQLTests\Doctrine;

use DateTime;
use Doctrine\Common\Persistence\Mapping\Driver\MappingDriverChain;
use Doctrine\ORM\Tools\SchemaValidator;
use GraphQL\Doctrine\Types;
use GraphQL\Type\Definition\BooleanType;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use GraphQLTests\Doctrine\Blog\Model\Post;
use GraphQLTests\Doctrine\Blog\Model\User;
use GraphQLTests\Doctrine\Blog\Types\CustomType;
use GraphQLTests\Doctrine\Blog\Types\DateTimeType;
use GraphQLTests\Doctrine\Blog\Types\PostStatusType;
use stdClass;
use Zend\ServiceManager\ServiceManager;

class TypesTest extends \PHPUnit\Framework\TestCase
{
    use EntityManagerTrait;

    /**
     * @var Types
     */
    private $types;

    public function setUp(): void
    {
        $this->setUpEntityManager();

        $customTypes = new ServiceManager([
            'invokables' => [
                BooleanType::class => BooleanType::class,
                DateTime::class => DateTimeType::class,
                stdClass::class => CustomType::class,
                'PostStatus' => PostStatusType::class,
            ],
        ]);

        $this->types = new Types($this->entityManager, $customTypes);
    }

    public function testBlogMapping(): void
    {
        $validator = new SchemaValidator($this->entityManager);
        $errors = $validator->validateMapping();

        self::assertEmpty($errors, 'doctrine annotations should be valid');
    }

    public function testGraphQLSchemaFromDocumentationMustBeValid(): void
    {
        $schema = new Schema([
            'query' => new ObjectType([
                'name' => 'query',
                'fields' => [
                    'users' => [
                        'type' => Type::listOf($this->types->getOutput(User::class)), // Use automated ObjectType for output
                        'resolve' => function ($root, $args): void {

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

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

                            // call to repository...
                        },
                    ],
                    'posts' => [
                        'type' => Type::listOf($this->types->getOutput(Post::class)), // Use automated ObjectType for output
                        'resolve' => function ($root, $args): void {

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

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

                            // call to repository...
                        },
                    ],
                ],
            ]),
            'mutation' => new ObjectType([
                'name' => 'mutation',
                'fields' => [
                    'createUser' => [
                        'type' => Type::nonNull($this->types->getOutput(User::class)),
                        'args' => [
                            'input' => Type::nonNull($this->types->getInput(User::class)), // Use automated InputObjectType for input
                        ],
                        'resolve' => function ($root, $args): void {

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

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

                            // create new user and flush...
                        },
                    ],
                    'updateUser' => [
                        'type' => Type::nonNull($this->types->getOutput(User::class)),
                        'args' => [
                            'id' => Type::nonNull(Type::id()), // Use standard API when needed
                            'input' => $this->types->getInput(User::class),
                        ],
                        'resolve' => function ($root, $args): void {

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

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

                            // update existing user and flush...
                        },
                    ],
                    'createPost' => [
                        'type' => Type::nonNull($this->types->getOutput(Post::class)),
                        'args' => [
                            'input' => Type::nonNull($this->types->getInput(Post::class)), // Use automated InputObjectType for input
                        ],
                        'resolve' => function ($root, $args): void {

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

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

                            // create new post and flush...
                        },
                    ],
                    'updatePost' => [
                        'type' => Type::nonNull($this->types->getOutput(Post::class)),
                        'args' => [
                            'id' => Type::nonNull(Type::id()), // Use standard API when needed
                            'input' => $this->types->getInput(Post::class),
                        ],
                        'resolve' => function ($root, $args): void {

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

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

                            // update existing post and flush...
                        },
                    ],
                ],
            ]),
        ]);

        $schema->assertValid();
        self::assertTrue(true, 'passed validation successfully');
    }

    public function testCanGetUserDefinedScalarTypes(): void
    {
        $bool = $this->types->get(BooleanType::class);
        $status = $this->types->get(PostStatusType::class);

        self::assertInstanceOf(BooleanType::class, $bool, 'must be a instance of bool');
        self::assertInstanceOf(PostStatusType::class, $status, 'must be an instance of post status');

        self::assertSame($bool, $this->types->get(BooleanType::class), 'must returns the same instance of bool');
        self::assertSame($status, $this->types->get(PostStatusType::class), 'must returns the same instance of post status');
    }

    public function testCanGetUserMappedTypes(): void
    {
        $type = $this->types->get(stdClass::class);

        self::assertInstanceOf(CustomType::class, $type, 'must be a instance of CustomType');
        self::assertSame($type, $this->types->get('customName'));
    }

    public function testCanGetTypesWithBackslashPrefix(): void
    {
        $type = $this->types->getOutput(Post::class);
        self::assertSame($type, $this->types->getOutput('\\' . Post::class));
    }

    public function testCanGetOutputTypes(): void
    {
        $userType = $this->types->getOutput(User::class);

        $this->assertObjectType('data/UserOutput.php', $userType);
        self::assertSame($userType, $this->types->getOutput(User::class), 'must returns the same instance of user type');

        $postType = $this->types->getOutput(Post::class);
        $this->assertObjectType('data/PostOutput.php', $postType);
        self::assertSame($postType, $this->types->getOutput(Post::class), 'must returns the same instance of post type');
    }

    public function testCanGetInputTypes(): void
    {
        $userType = $this->types->getInput(User::class);
        $this->assertInputType('data/UserInput.php', $userType);
        self::assertSame($userType, $this->types->getInput(User::class), 'must returns the same instance of user type');

        $postType = $this->types->getInput(Post::class);
        $this->assertInputType('data/PostInput.php', $postType);
        self::assertSame($postType, $this->types->getInput(Post::class), 'must returns the same instance of post type');
    }

    private function assertType(string $expectedFile, Type $type, bool $assertArgs): void
    {
        $fields = [];
        foreach ($type->getFields() as $field) {

The method getFields() does not exist on GraphQL\Type\Definition\Type. It seems like you code against a sub-type of GraphQL\Type\Definition\Type such as GraphQL\Type\Definition\InterfaceType or GraphQL\Type\Definition\ObjectType or GraphQL\Type\Definition\InputObjectType.

            $data = [
                'name' => $field->name,
                'type' => $field->getType()->toString(),
                'description' => $field->description,
            ];

            if ($assertArgs) {
                $args = [];
                foreach ($field->args as $arg) {
                    $argData = [
                        'name' => $arg->name,
                        'type' => $arg->getType()->toString(),
                        'description' => $arg->description,

                    ];

                    if ($arg->defaultValueExists()) {
                        $argData['defaultValue'] = $arg->defaultValue;
                    }

                    $args[] = $argData;
                }
                $data['args'] = $args;
            } elseif ($field->defaultValueExists()) {
                $data['defaultValue'] = $field->defaultValue;
            }

            $fields[] = $data;
        }

        $actual = [
            'name' => $type->name,
            'description' => $type->description,
            'fields' => $fields,
        ];

        $expected = require $expectedFile;
        self::assertEquals($expected, $actual, 'Should equals expectation from: ' . $expectedFile);
    }

    private function assertInputType(string $expectedFile, InputObjectType $type): void
    {
        $this->assertType($expectedFile, $type, false);
    }

    private function assertObjectType(string $expectedFile, ObjectType $type): void
    {
        $this->assertType($expectedFile, $type, true);
    }

    public function testNonPublicGetterMustBeIgnored(): void
    {
        $actual = $this->types->getOutput(Blog\Model\Special\IgnoredGetter::class);
        $this->assertObjectType('data/IgnoredGetter.php', $actual);
    }

    public function testCanDeclareArrayOfEntity(): void
    {
        $actual = $this->types->getOutput(Blog\Model\Special\ArrayOfEntity::class);
        $this->assertObjectType('data/ArrayOfEntity.php', $actual);
    }

    public function testDefaultValuesInput(): void
    {
        $actual = $this->types->getInput(Blog\Model\Special\DefaultValue::class);
        $this->assertInputType('data/DefaultValueInput.php', $actual);
    }

    public function testDefaultValuesPartialInput(): void
    {
        $actual = $this->types->getPartialInput(Blog\Model\Special\DefaultValue::class);
        $this->assertInputType('data/DefaultValuePartialInput.php', $actual);
    }

    public function testDefaultValuesOutput(): void
    {
        $actual = $this->types->getOutput(Blog\Model\Special\DefaultValue::class);
        $this->assertObjectType('data/DefaultValue.php', $actual);
    }

    public function testFieldWithoutTypeMustThrow(): void
    {
        $this->expectExceptionMessage('Could not find type for method `GraphQLTests\Doctrine\Blog\Model\Special\NoType::getWithoutTypeHint()`. Either type hint the return value, or specify the type with `@API\Field` annotation.');
        $type = $this->types->getOutput(Blog\Model\Special\NoType::class);
        $type->getFields();
    }

    public function testFieldReturningCollectionWithoutTypeMustThrow(): void
    {
        $this->expectExceptionMessage('The method `GraphQLTests\Doctrine\Blog\Model\Special\NoTypeCollection::getFoos()` is type hinted with a return type of `Doctrine\Common\Collections\Collection`, but the entity contained in that collection could not be automatically detected. Either fix the type hint, fix the doctrine mapping, or specify the type with `@API\Field` annotation.');
        $type = $this->types->getOutput(Blog\Model\Special\NoTypeCollection::class);
        $type->getFields();
    }

    public function testCannotGetInvalidType(): void
    {
        $this->expectExceptionMessage('Given class name `DateTimeImmutable` is not a Doctrine entity. Either register a custom GraphQL type for `DateTimeImmutable` when instantiating `GraphQL\Doctrine\Types`, or change the usage of that class to something else.');
        $this->types->getOutput(\DateTimeImmutable::class);
    }

    public function testArgumentWithoutTypeMustThrow(): void
    {
        $this->expectExceptionMessage('Could not find type for parameter `$bar` for method `GraphQLTests\Doctrine\Blog\Model\Special\NoTypeArgument::getFoo()`. Either type hint the parameter, or specify the type with `@API\Argument` annotation.');
        $type = $this->types->getOutput(Blog\Model\Special\NoTypeArgument::class);
        $type->getFields();
    }

    public function testInputWithoutTypeMustThrow(): void
    {
        $this->expectExceptionMessage('Could not find type for parameter `$bar` for method `GraphQLTests\Doctrine\Blog\Model\Special\NoTypeInput::setFoo()`. Either type hint the parameter, or specify the type with `@API\Input` annotation.');
        $type = $this->types->getInput(Blog\Model\Special\NoTypeInput::class);
        $type->getFields();
    }

    public function testFieldWithExtraArgumentMustThrow(): void
    {
        $this->expectExceptionMessage('The following arguments were declared via `@API\Argument` annotation but do not match actual parameter names on method `GraphQLTests\Doctrine\Blog\Model\Special\ExtraArgument::getWithParams()`. Either rename or remove the annotations: misspelled_name');
        $type = $this->types->getOutput(Blog\Model\Special\ExtraArgument::class);
        $type->getFields();
    }

    public function testFieldWithArrayArgumentMustThrow(): void
    {
        $this->expectExceptionMessage('The parameter `$arg1` on method `GraphQLTests\Doctrine\Blog\Model\Special\ArrayArgument::getWithParams()` is type hinted as `array` and is not overridden via `@API\Argument` annotation. Either change the type hint or specify the type with `@API\Argument` annotation.');
        $type = $this->types->getOutput(Blog\Model\Special\ArrayArgument::class);
        $type->getFields();
    }

    public function testFieldWithObjectTypeArgumentMustThrow(): void
    {
        $this->expectExceptionMessage('Type for parameter `$user` for method `GraphQLTests\Doctrine\Blog\Model\Special\ObjectTypeArgument::getWithParams()` must be an instance of `GraphQL\Type\Definition\InputType`, but was `GraphQL\Type\Definition\ObjectType`. Use `@API\Argument` annotation to specify a custom InputType.');
        $type = $this->types->getOutput(Blog\Model\Special\ObjectTypeArgument::class);
        $type->getFields();
    }

    public function testCanGetMappedTypesEitherByMappedPhpClassOrDirectTypeClass(): void
    {
        $viaPhp = $this->types->get(DateTime::class);
        $viaType = $this->types->get(DateTimeType::class);
        self::assertSame($viaPhp, $viaType);
    }

    public function testDoctrineWithoutAnnotationDriverMustThrow(): void
    {
        // Replace annotation driver with a driver chain
        $config = $this->entityManager->getConfiguration();
        $chain = new MappingDriverChain();
        $chain->setDefaultDriver($config->getMetadataDriverImpl());
        $config->setMetadataDriverImpl($chain);

        $type = $this->types->getOutput(Post::class);

        $this->expectExceptionMessage('graphql-doctrine requires Doctrine to be configured with a `Doctrine\Common\Persistence\Mapping\Driver\AnnotationDriver`.');
        $type->getFields();
    }

    public function testNonRegisteredCustomTypeMustThrow(): void
    {
        $this->expectExceptionMessage('No type registered with key `foo`. Either correct the usage, or register it in your custom types container when instantiating `GraphQL\Doctrine\Types`');
        $this->types->get('foo');
    }

    public function testHas(): void
    {
        $this->assertTrue($this->types->has(stdClass::class), 'should have custom registered key');
        $this->assertFalse($this->types->has('non-existing'), 'should not have non-existing things');

        $this->types->get(stdClass::class);
        $this->assertTrue($this->types->has('customName'), 'should have custom registered type by its name, even if custom key was different, once type is created');
    }
}