RecursiveTypeMapperTest::getTypeMapper() - Code Metrics - Inspection of "Adding a type loader" - thecodingmachine/graphql-controllers - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#60)

by David

created 2018-12-12 10:39 UTC

RecursiveTypeMapperTest::getTypeMapper() A

↳ Parent: RecursiveTypeMapperTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	8
dl	0
loc	16
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace TheCodingMachine\GraphQL\Controllers\Mappers;

use Doctrine\Common\Annotations\AnnotationReader;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\InterfaceType;
use GraphQL\Type\Definition\ObjectType;
use Mouf\Picotainer\Picotainer;
use Symfony\Component\Cache\Simple\ArrayCache;
use Symfony\Component\Cache\Simple\NullCache;
use TheCodingMachine\GraphQL\Controllers\AbstractQueryProviderTest;
use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassA;
use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassB;
use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassC;
use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassAType;
use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassBType;
use TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject;
use TheCodingMachine\GraphQL\Controllers\NamingStrategy;
use TheCodingMachine\GraphQL\Controllers\TypeGenerator;

class RecursiveTypeMapperTest extends AbstractQueryProviderTest
{

    public function testMapClassToType()
    {
        $objectType = new ObjectType([
            'name' => 'Foobar'
        ]);

        $typeMapper = new StaticTypeMapper();
        $typeMapper->setTypes([
            ClassB::class => $objectType
        ]);

        $recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());

        $this->assertFalse($typeMapper->canMapClassToType(ClassC::class));
        $this->assertTrue($recursiveTypeMapper->canMapClassToType(ClassC::class));
        $this->assertSame($objectType, $recursiveTypeMapper->mapClassToType(ClassC::class));

        $this->assertFalse($recursiveTypeMapper->canMapClassToType(ClassA::class));
        $this->expectException(CannotMapTypeException::class);
        $recursiveTypeMapper->mapClassToType(ClassA::class);
    }

    public function testMapNameToType()
    {
        $objectType = new ObjectType([
            'name' => 'Foobar'
        ]);

        $typeMapper = new StaticTypeMapper();
        $typeMapper->setTypes([
            ClassB::class => $objectType
        ]);

        $recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());

        $this->assertTrue($recursiveTypeMapper->canMapNameToType('Foobar'));
        $this->assertSame($objectType, $recursiveTypeMapper->mapNameToType('Foobar'));
    }

    public function testMapNameToType2()
    {
        $recursiveMapper = $this->getTypeMapper();

        $this->assertTrue($recursiveMapper->canMapNameToType('ClassA'));
        $this->assertTrue($recursiveMapper->canMapNameToType('ClassB'));
        $this->assertTrue($recursiveMapper->canMapNameToType('ClassAInterface'));
        $this->assertFalse($recursiveMapper->canMapNameToType('NotExists'));
        $this->assertSame('ClassA', $recursiveMapper->mapNameToType('ClassA')->name);
        $this->assertSame('ClassAInterface', $recursiveMapper->mapNameToType('ClassAInterface')->name);

        $this->expectException(CannotMapTypeException::class);
        $recursiveMapper->mapNameToType('NotExists');
    }


    public function testMapClassToInputType()
    {
        $inputObjectType = new InputObjectType([
            'name' => 'Foobar'
        ]);

        $typeMapper = new StaticTypeMapper();
        $typeMapper->setInputTypes([
            ClassB::class => $inputObjectType
        ]);

        $recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());

        $this->assertFalse($recursiveTypeMapper->canMapClassToInputType(ClassC::class));

        $this->expectException(CannotMapTypeException::class);
        $recursiveTypeMapper->mapClassToInputType(ClassC::class);
    }

    protected function getTypeMapper()
    {
        $container = new Picotainer([
            ClassAType::class => function() {
                return new ClassAType();
            },
            ClassBType::class => function() {
                return new ClassBType();
            }
        ]);

        $typeGenerator = new TypeGenerator($this->getAnnotationReader(), $this->getControllerQueryProviderFactory());

        $mapper = new GlobTypeMapper('TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types', $typeGenerator, $container, new \TheCodingMachine\GraphQL\Controllers\AnnotationReader(new AnnotationReader()), new NullCache());

        return new RecursiveTypeMapper($mapper, new NamingStrategy(), new ArrayCache());
    }

    public function testMapClassToInterfaceOrType()
    {
        $recursiveMapper = $this->getTypeMapper();

        $type = $recursiveMapper->mapClassToInterfaceOrType(ClassA::class);
        $this->assertInstanceOf(InterfaceType::class, $type);
        $this->assertSame('ClassAInterface', $type->name);


        $classAObjectType = $recursiveMapper->mapClassToType(ClassA::class);
        $this->assertInstanceOf(ObjectType::class, $classAObjectType);
        $this->assertCount(1, $classAObjectType->getInterfaces());

        $type = $recursiveMapper->mapClassToInterfaceOrType(ClassC::class);
        $this->assertInstanceOf(ObjectType::class, $type);
        $this->assertSame('ClassB', $type->name);

        $interfaces = $recursiveMapper->findInterfaces(ClassC::class);
        $this->assertCount(1, $interfaces);
        $this->assertSame('ClassAInterface', $interfaces[0]->name);

        $classBObjectType = $recursiveMapper->mapClassToType(ClassC::class);
        $this->assertInstanceOf(ObjectType::class, $classBObjectType);
        $this->assertCount(1, $classBObjectType->getInterfaces());

        $this->expectException(CannotMapTypeException::class);
        $recursiveMapper->mapClassToInterfaceOrType('Not exists');
    }

    public function testGetOutputTypes()
    {
        $recursiveMapper = $this->getTypeMapper();

        $outputTypes = $recursiveMapper->getOutputTypes();
        $this->assertArrayHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassA', $outputTypes);
        $this->assertArrayHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassB', $outputTypes);
        $this->assertArrayNotHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassC', $outputTypes);
    }


}


1			<?php
2
3			namespace TheCodingMachine\GraphQL\Controllers\Mappers;
4
5			use Doctrine\Common\Annotations\AnnotationReader;
6			use GraphQL\Type\Definition\InputObjectType;
7			use GraphQL\Type\Definition\InterfaceType;
8			use GraphQL\Type\Definition\ObjectType;
9			use Mouf\Picotainer\Picotainer;
10			use Symfony\Component\Cache\Simple\ArrayCache;
11			use Symfony\Component\Cache\Simple\NullCache;
12			use TheCodingMachine\GraphQL\Controllers\AbstractQueryProviderTest;
13			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassA;
14			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassB;
15			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassC;
16			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassAType;
17			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassBType;
18			use TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject;
19			use TheCodingMachine\GraphQL\Controllers\NamingStrategy;
20			use TheCodingMachine\GraphQL\Controllers\TypeGenerator;
21
22			class RecursiveTypeMapperTest extends AbstractQueryProviderTest
23			{
24
25			public function testMapClassToType()
26			{
27			$objectType = new ObjectType([
28			'name' => 'Foobar'
29			]);
30
31			$typeMapper = new StaticTypeMapper();
32			$typeMapper->setTypes([
33			ClassB::class => $objectType
34			]);
35
36			$recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());
37
38			$this->assertFalse($typeMapper->canMapClassToType(ClassC::class));
39			$this->assertTrue($recursiveTypeMapper->canMapClassToType(ClassC::class));
40			$this->assertSame($objectType, $recursiveTypeMapper->mapClassToType(ClassC::class));
41
42			$this->assertFalse($recursiveTypeMapper->canMapClassToType(ClassA::class));
43			$this->expectException(CannotMapTypeException::class);
44			$recursiveTypeMapper->mapClassToType(ClassA::class);
45			}
46
47			public function testMapNameToType()
48			{
49			$objectType = new ObjectType([
50			'name' => 'Foobar'
51			]);
52
53			$typeMapper = new StaticTypeMapper();
54			$typeMapper->setTypes([
55			ClassB::class => $objectType
56			]);
57
58			$recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());
59
60			$this->assertTrue($recursiveTypeMapper->canMapNameToType('Foobar'));
61			$this->assertSame($objectType, $recursiveTypeMapper->mapNameToType('Foobar'));
62			}
63
64			public function testMapNameToType2()
65			{
66			$recursiveMapper = $this->getTypeMapper();
67
68			$this->assertTrue($recursiveMapper->canMapNameToType('ClassA'));
69			$this->assertTrue($recursiveMapper->canMapNameToType('ClassB'));
70			$this->assertTrue($recursiveMapper->canMapNameToType('ClassAInterface'));
71			$this->assertFalse($recursiveMapper->canMapNameToType('NotExists'));
72			$this->assertSame('ClassA', $recursiveMapper->mapNameToType('ClassA')->name);
73			$this->assertSame('ClassAInterface', $recursiveMapper->mapNameToType('ClassAInterface')->name);
74
75			$this->expectException(CannotMapTypeException::class);
76			$recursiveMapper->mapNameToType('NotExists');
77			}
78
79
80			public function testMapClassToInputType()
81			{
82			$inputObjectType = new InputObjectType([
83			'name' => 'Foobar'
84			]);
85
86			$typeMapper = new StaticTypeMapper();
87			$typeMapper->setInputTypes([
88			ClassB::class => $inputObjectType
89			]);
90
91			$recursiveTypeMapper = new RecursiveTypeMapper($typeMapper, new NamingStrategy(), new ArrayCache());
92
93			$this->assertFalse($recursiveTypeMapper->canMapClassToInputType(ClassC::class));
94
95			$this->expectException(CannotMapTypeException::class);
96			$recursiveTypeMapper->mapClassToInputType(ClassC::class);
97			}
98
99			protected function getTypeMapper()
100			{
101			$container = new Picotainer([
102			ClassAType::class => function() {
103			return new ClassAType();
104			},
105			ClassBType::class => function() {
106			return new ClassBType();
107			}
108			]);
109
110			$typeGenerator = new TypeGenerator($this->getAnnotationReader(), $this->getControllerQueryProviderFactory());
111
112			$mapper = new GlobTypeMapper('TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types', $typeGenerator, $container, new \TheCodingMachine\GraphQL\Controllers\AnnotationReader(new AnnotationReader()), new NullCache());
113
114			return new RecursiveTypeMapper($mapper, new NamingStrategy(), new ArrayCache());
115			}
116
117			public function testMapClassToInterfaceOrType()
118			{
119			$recursiveMapper = $this->getTypeMapper();
120
121			$type = $recursiveMapper->mapClassToInterfaceOrType(ClassA::class);
122			$this->assertInstanceOf(InterfaceType::class, $type);
123			$this->assertSame('ClassAInterface', $type->name);
			0 ignored issues – show Bug introduced 2018-11-27 10:08 UTC by Report Bug Copy Issue Report Accessing `name` on the interface `GraphQL\Type\Definition\OutputType` suggest that you code against a concrete implementation. How about adding an `instanceof` check? Loading history...
124
125			$classAObjectType = $recursiveMapper->mapClassToType(ClassA::class);
126			$this->assertInstanceOf(ObjectType::class, $classAObjectType);
127			$this->assertCount(1, $classAObjectType->getInterfaces());
128
129			$type = $recursiveMapper->mapClassToInterfaceOrType(ClassC::class);
130			$this->assertInstanceOf(ObjectType::class, $type);
131			$this->assertSame('ClassB', $type->name);
132
133			$interfaces = $recursiveMapper->findInterfaces(ClassC::class);
134			$this->assertCount(1, $interfaces);
135			$this->assertSame('ClassAInterface', $interfaces[0]->name);
136
137			$classBObjectType = $recursiveMapper->mapClassToType(ClassC::class);
138			$this->assertInstanceOf(ObjectType::class, $classBObjectType);
139			$this->assertCount(1, $classBObjectType->getInterfaces());
140
141			$this->expectException(CannotMapTypeException::class);
142			$recursiveMapper->mapClassToInterfaceOrType('Not exists');
143			}
144
145			public function testGetOutputTypes()
146			{
147			$recursiveMapper = $this->getTypeMapper();
148
149			$outputTypes = $recursiveMapper->getOutputTypes();
150			$this->assertArrayHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassA', $outputTypes);
151			$this->assertArrayHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassB', $outputTypes);
152			$this->assertArrayNotHasKey('TheCodingMachine\\GraphQL\\Controllers\\Fixtures\\Interfaces\\ClassC', $outputTypes);
153			}
154
155
156			}
157

thecodingmachine / graphql-controllers

Pull Request — master (#60)

RecursiveTypeMapperTest::getTypeMapper() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like