GraphQL\Tests\Type\SchemaTest

Complexity

Total Complexity

3

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	testIncludesInputTypesOnlyUsedInDirectives()	0	5	1
A	setUp()	0	59	1
A	testThrowsHumanReableErrorIfSchemaTypesIsNotDefined()	0	11	1

<?php
namespace GraphQL\Tests\Type;

use GraphQL\Error\InvariantViolation;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\InterfaceType;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use PHPUnit\Framework\TestCase;

class SchemaTest extends TestCase
{
    private $interfaceType;

    private $implementingType;

    private $directiveInputType;

    private $wrappedDirectiveInputType;

    private $directive;

    /** @var Schema */
    private $schema;

    public function setUp()
    {
        $this->interfaceType = new InterfaceType([
            'name' => 'Interface',
            'fields' => ['fieldName' => ['type' => Type::string()]],
        ]);

        $this->implementingType = new ObjectType([
            'name' => 'Object',
            'interfaces' => [$this->interfaceType],
            'fields' => ['fieldName' => ['type' => Type::string(), 'resolve' => function () {
                return '';
            }]],
        ]);

        $this->directiveInputType = new InputObjectType([
            'name' => 'DirInput',
            'fields' => [
                'field' => [
                    'type' => Type::string(),
                ],
            ],
        ]);

        $this->wrappedDirectiveInputType = new InputObjectType([
            'name' => 'WrappedDirInput',
            'fields' => [
                'field' => [
                    'type' => Type::string(),
                ],
            ],
        ]);

        $this->directive = new Directive([
            'name' => 'dir',
            'locations' => ['OBJECT'],
            'args' => [
                'arg' => [
                    'type' => $this->directiveInputType,
                ],
                'argList' => [
                    'type' => Type::listOf($this->wrappedDirectiveInputType),
                ],
            ],
        ]);

        $this->schema = new Schema([
            'query' => new ObjectType([
                'name' => 'Query',
                'fields' => [
                    'getObject' => [
                        'type' => $this->interfaceType,
                        'resolve' => function () {
                            return [];
                        },
                    ],
                ],
            ]),
            'directives' => [$this->directive],
        ]);
    }

    // Type System: Schema
    // Getting possible types

    /**
     * @it throws human-reable error if schema.types is not defined
     */
    public function testThrowsHumanReableErrorIfSchemaTypesIsNotDefined()
    {
        $this->markTestSkipped("Can't check interface implementations without full schema scan");

        $this->expectException(InvariantViolation::class);
        $this->expectExceptionMessage(
            'Could not find possible implementing types for Interface in schema. ' .
            'Check that schema.types is defined and is an array of all possible ' .
            'types in the schema.'
        );
        $this->schema->isPossibleType($this->interfaceType, $this->implementingType);
    }

    // Type Map

    /**
     * @it includes input types only used in directives
     */
    public function testIncludesInputTypesOnlyUsedInDirectives()
    {
        $typeMap = $this->schema->getTypeMap();
        $this->assertArrayHasKey('DirInput', $typeMap);
        $this->assertArrayHasKey('WrappedDirInput', $typeMap);
    }
}