Overblog\GraphQLBundle\Tests\Resolver\ResolverMapTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	125
Duplicated Lines	6.4 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	testResolve()	0	6	1
A	testMapMustBeOverride()	0	12	1
A	testInvalidMap()	0	11	1
A	testUnresolvable()	0	12	1
A	invalidMapDataProvider()	0	10	1
A	validMapDataProvider()	0	19	2
A	createResolverMapMock()	8	8	1
A	map()	0	18	1

<?php

namespace Overblog\GraphQLBundle\Tests\Resolver;

use Overblog\GraphQLBundle\Resolver\ResolverMap;
use Overblog\GraphQLBundle\Resolver\UnresolvableException;
use PHPUnit\Framework\TestCase;

class ResolverMapTest extends TestCase
{
    /**
     * @param array|\ArrayAccess $map
     * @param string             $typeName
     * @param string             $fieldName
     * @param \Closure|null      $expectedResolver
     *
     * @dataProvider validMapDataProvider
     */
    public function testResolve($map, $typeName, $fieldName, $expectedResolver)
    {
        $resolverMap = $this->createResolverMapMock($map);
        $resolver = $resolverMap->resolve($typeName, $fieldName);

The method resolve does only exist in Overblog\GraphQLBundle\Resolver\ResolverMap, but not in PHPUnit_Framework_MockObject_MockObject.

        $this->assertSame($expectedResolver, $resolver);
    }

    public function testMapMustBeOverride()
    {
        /** @var ResolverMap|\PHPUnit_Framework_MockObject_MockObject $resolverMap */
        $resolverMap = $this->getMockBuilder(ResolverMap::class)->setMethods(null)->getMock();
        $this->expectException(\LogicException::class);
        $this->expectExceptionMessage(sprintf(
            'You must override the %s::map() method.',
            get_class($resolverMap)
        ));

        $resolverMap->resolve('Foo', 'bar');

The method resolve does only exist in Overblog\GraphQLBundle\Resolver\ResolverMap, but not in PHPUnit_Framework_MockObject_MockObject.

    }

    /**
     * @dataProvider invalidMapDataProvider
     *
     * @param mixed  $invalidMap
     * @param string $invalidType
     */
    public function testInvalidMap($invalidMap, $invalidType)
    {
        $resolverMap = $this->createResolverMapMock($invalidMap);
        $this->expectException(\RuntimeException::class);
        $this->expectExceptionMessage(sprintf(
            '%s::map() should return an array or an instance of \ArrayAccess and \Traversable but got "%s".',
            get_class($resolverMap),
            $invalidType
        ));
        $resolverMap->resolve('Foo', 'bar');

The method resolve does only exist in Overblog\GraphQLBundle\Resolver\ResolverMap, but not in PHPUnit_Framework_MockObject_MockObject.

    }

    public function testUnresolvable()
    {
        $resolverMap = $this->createResolverMapMock([
            'Query' => [
                ResolverMap::RESOLVE_FIELD => function () {
                },
            ],
        ]);
        $this->expectException(UnresolvableException::class);
        $this->expectExceptionMessage('Field "Foo.bar" could not be resolved.');
        $resolverMap->resolve('Foo', 'bar');

The method resolve does only exist in Overblog\GraphQLBundle\Resolver\ResolverMap, but not in PHPUnit_Framework_MockObject_MockObject.

    }

    public function invalidMapDataProvider()
    {
        return [
            [null, 'NULL'],
            [false, 'boolean'],
            [true, 'boolean'],
            ['baz', 'string'],
            [new \stdClass(), 'stdClass'],
        ];
    }

    public function validMapDataProvider()
    {
        $arrayMap = $this->map();
        $objectMap = new \ArrayObject($arrayMap);

        $validMap = [];

        foreach ([$arrayMap, $objectMap] as $map) {
            $validMap = array_merge($validMap, [
                [$map, 'Query', ResolverMap::RESOLVE_FIELD, $map['Query'][ResolverMap::RESOLVE_FIELD]],
                [$map, 'Query', 'foo', $map['Query']['foo']],
                [$map, 'Query', 'bar', $map['Query']['bar']],
                [$map, 'Query', 'baz', null],
                [$map, 'FooInterface', ResolverMap::RESOLVE_TYPE, $map['FooInterface'][ResolverMap::RESOLVE_TYPE]],
            ]);
        }

        return $validMap;
    }

    /**
     * @param mixed $map
     *
     * @return ResolverMap|\PHPUnit_Framework_MockObject_MockObject
     */
    private function createResolverMapMock($map)

This method seems to be duplicated in your project.

    {
        /** @var ResolverMap|\PHPUnit_Framework_MockObject_MockObject $resolverMap */
        $resolverMap = $this->getMockBuilder(ResolverMap::class)->setMethods(['map'])->getMock();
        $resolverMap->method('map')->willReturn($map);

        return $resolverMap;
    }

    private function map()
    {
        return [
            'Query' => [
                ResolverMap::RESOLVE_FIELD => function () {
                },
                'foo' => function () {
                },
                'bar' => function () {
                },
                'baz' => null,
            ],
            'FooInterface' => [
                ResolverMap::RESOLVE_TYPE => function () {
                },
            ],
        ];
    }
}