RecursiveTypeMapperTest::testMapClassToType() - Code Metrics - Inspection of "Merge pull request #44 from moufmouf/interfaces" - thecodingmachine/graphql-controllers - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1e6eb5...15e5c5 )

by David

created 2018-11-27 14:17 UTC

RecursiveTypeMapperTest::testMapClassToType() A

↳ Parent: RecursiveTypeMapperTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	20
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	12
dl	0
loc	20
rs	9.8666
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\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\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);

        $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 testMapClassToInputType()
    {
        $inputObjectType = new InputObjectType([
            'name' => 'Foobar'
        ]);

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

        $recursiveTypeMapper = new RecursiveTypeMapper($typeMapper);

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

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

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

        $typeGenerator = new TypeGenerator($this->getRegistry());

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

        $recursiveMapper = new RecursiveTypeMapper($mapper);

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


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

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


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\NullCache;
11			use TheCodingMachine\GraphQL\Controllers\AbstractQueryProviderTest;
12			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassA;
13			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassB;
14			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\ClassC;
15			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassAType;
16			use TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types\ClassBType;
17			use TheCodingMachine\GraphQL\Controllers\Fixtures\TestObject;
18			use TheCodingMachine\GraphQL\Controllers\TypeGenerator;
19
20			class RecursiveTypeMapperTest extends AbstractQueryProviderTest
21			{
22
23			public function testMapClassToType()
24			{
25			$objectType = new ObjectType([
26			'name' => 'Foobar'
27			]);
28
29			$typeMapper = new StaticTypeMapper();
30			$typeMapper->setTypes([
31			ClassB::class => $objectType
32			]);
33
34			$recursiveTypeMapper = new RecursiveTypeMapper($typeMapper);
35
36			$this->assertFalse($typeMapper->canMapClassToType(ClassC::class));
37			$this->assertTrue($recursiveTypeMapper->canMapClassToType(ClassC::class));
38			$this->assertSame($objectType, $recursiveTypeMapper->mapClassToType(ClassC::class));
39
40			$this->assertFalse($recursiveTypeMapper->canMapClassToType(ClassA::class));
41			$this->expectException(CannotMapTypeException::class);
42			$recursiveTypeMapper->mapClassToType(ClassA::class);
43			}
44
45			public function testMapClassToInputType()
46			{
47			$inputObjectType = new InputObjectType([
48			'name' => 'Foobar'
49			]);
50
51			$typeMapper = new StaticTypeMapper();
52			$typeMapper->setInputTypes([
53			ClassB::class => $inputObjectType
54			]);
55
56			$recursiveTypeMapper = new RecursiveTypeMapper($typeMapper);
57
58			$this->assertFalse($recursiveTypeMapper->canMapClassToInputType(ClassC::class));
59
60			$this->expectException(CannotMapTypeException::class);
61			$recursiveTypeMapper->mapClassToInputType(ClassC::class);
62			}
63
64			public function testMapClassToInterfaceOrType()
65			{
66			$container = new Picotainer([
67			ClassAType::class => function() {
68			return new ClassAType();
69			},
70			ClassBType::class => function() {
71			return new ClassBType();
72			}
73			]);
74
75			$typeGenerator = new TypeGenerator($this->getRegistry());
76
77			$mapper = new GlobTypeMapper('TheCodingMachine\GraphQL\Controllers\Fixtures\Interfaces\Types', $typeGenerator, $container, new \TheCodingMachine\GraphQL\Controllers\AnnotationReader(new AnnotationReader()), new NullCache());
78
79			$recursiveMapper = new RecursiveTypeMapper($mapper);
80
81			$type = $recursiveMapper->mapClassToInterfaceOrType(ClassA::class);
82			$this->assertInstanceOf(InterfaceType::class, $type);
83			$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...
84
85			$type = $recursiveMapper->mapClassToInterfaceOrType(ClassC::class);
86			$this->assertInstanceOf(ObjectType::class, $type);
87			$this->assertSame('ClassB', $type->name);
88
89			$this->expectException(CannotMapTypeException::class);
90			$recursiveMapper->mapClassToInterfaceOrType('Not exists');
91			}
92			}
93

thecodingmachine / graphql-controllers

Push — master ( 1e6eb5...15e5c5 )

RecursiveTypeMapperTest::testMapClassToType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like