anonymous//tests/Mappers/CompositeTypeMapperTest.php$0 ➔ setUp()

Complexity

Conditions

1

Size

Total Lines

86

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	CompositeTypeMapperTest.php$0 ➔ canMapClassToInputType()	0	3	1
A	CompositeTypeMapperTest.php$0 ➔ mapClassToInputType()	0	11	2
A	CompositeTypeMapperTest.php$0 ➔ canMapClassToType()	0	3	1
A	CompositeTypeMapperTest.php$0 ➔ mapClassToType()	0	11	2
A	CompositeTypeMapperTest.php$0 ➔ getSupportedClasses()	0	3	1
A	CompositeTypeMapperTest.php$0 ➔ mapNameToType()	0	12	2
A	CompositeTypeMapperTest.php$0 ➔ canMapNameToType()	0	3	1

<?php

namespace TheCodingMachine\GraphQL\Controllers\Mappers;

use GraphQL\Type\Definition\InputType;
use GraphQL\Type\Definition\OutputType;
use GraphQL\Type\Definition\Type;
use PHPUnit\Framework\TestCase;
use TheCodingMachine\GraphQL\Controllers\AbstractQueryProviderTest;
use TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject;
use TheCodingMachine\GraphQL\Controllers\TypeMappingException;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\ObjectType;

class CompositeTypeMapperTest extends AbstractQueryProviderTest
{
    /**
     * @var CompositeTypeMapper
     */
    protected $composite;

    public function setUp()
    {
        $typeMapper1 = new class() implements TypeMapperInterface {
            public function mapClassToType(string $className, RecursiveTypeMapperInterface $recursiveTypeMapper): ObjectType
            {
                if ($className === TestObject::class) {
                    return new ObjectType([
                        'name'    => 'TestObject',
                        'fields'  => [
                            'test'   => Type::string(),
                        ],
                    ]);
                } else {
                    throw TypeMappingException::createFromType(TestObject::class);

TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject::class of type string is incompatible with the type phpDocumentor\Reflection\Type expected by parameter $type of TheCodingMachine\GraphQL\Controllers\TypeMappingException::createFromType().

                }
            }

            public function mapClassToInputType(string $className): InputType
            {
                if ($className === TestObject::class) {
                    return new InputObjectType([
                        'name'    => 'TestObject',
                        'fields'  => [
                            'test'   => Type::string(),
                        ],
                    ]);
                } else {
                    throw TypeMappingException::createFromType(TestObject::class);

TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject::class of type string is incompatible with the type phpDocumentor\Reflection\Type expected by parameter $type of TheCodingMachine\GraphQL\Controllers\TypeMappingException::createFromType().

                }
            }

            public function canMapClassToType(string $className): bool
            {
                return $className === TestObject::class;
            }

            public function canMapClassToInputType(string $className): bool
            {
                return $className === TestObject::class;
            }

            /**
             * Returns the list of classes that have matching input GraphQL types.
             *
             * @return string[]
             */
            public function getSupportedClasses(): array
            {
                return [TestObject::class];
            }

            /**
             * Returns a GraphQL type by name (can be either an input or output type)
             *
             * @param string $typeName The name of the GraphQL type
             * @param RecursiveTypeMapperInterface $recursiveTypeMapper
             * @return Type&(InputType|OutputType)
             */
            public function mapNameToType(string $typeName, RecursiveTypeMapperInterface $recursiveTypeMapper): Type
            {
                switch ($typeName) {
                    case 'TestObject':
                        return new ObjectType([
                            'name'    => 'TestObject',
                            'fields'  => [
                                'test'   => Type::string(),
                            ],
                        ]);
                    default:
                        throw CannotMapTypeException::createForName($typeName);
                }
            }

            /**
             * Returns true if this type mapper can map the $typeName GraphQL name to a GraphQL type.
             *
             * @param string $typeName The name of the GraphQL type
             * @return bool
             */
            public function canMapNameToType(string $typeName): bool
            {
                return $typeName === 'TestObject';
            }
        };

        $this->composite = new CompositeTypeMapper([$typeMapper1]);
    }


    public function testComposite(): void
    {
        $this->assertTrue($this->composite->canMapClassToType(TestObject::class));
        $this->assertFalse($this->composite->canMapClassToType(\Exception::class));
        $this->assertTrue($this->composite->canMapClassToInputType(TestObject::class));
        $this->assertFalse($this->composite->canMapClassToInputType(\Exception::class));
        $this->assertInstanceOf(ObjectType::class, $this->composite->mapClassToType(TestObject::class, $this->getTypeMapper()));
        $this->assertInstanceOf(InputObjectType::class, $this->composite->mapClassToInputType(TestObject::class));
        $this->assertSame([TestObject::class], $this->composite->getSupportedClasses());
        $this->assertInstanceOf(ObjectType::class, $this->composite->mapNameToType('TestObject', $this->getTypeMapper()));
        $this->assertTrue($this->composite->canMapNameToType('TestObject'));
        $this->assertFalse($this->composite->canMapNameToType('NotExists'));
    }

    public function testException1(): void
    {
        $this->expectException(CannotMapTypeException::class);
        $this->composite->mapClassToType(\Exception::class, $this->getTypeMapper());
    }

    public function testException2(): void
    {
        $this->expectException(CannotMapTypeException::class);
        $this->composite->mapClassToInputType(\Exception::class);
    }

    public function testException3(): void
    {
        $this->expectException(CannotMapTypeException::class);
        $this->composite->mapNameToType('NotExists', $this->getTypeMapper());
    }
}