GraphQL\Tests\Validator\LoneSchemaDefinitionTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	188
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	testExtendSchemaInSchemaExtension()	0	20	1
A	testNoSchema()	0	10	1
A	schemaDefinitionNotAlone()	0	5	1
A	testOneSchemaDefinition()	0	14	1
A	testRedefineImplicitSchemaInSchemaExtension()	0	20	1
A	testMultipleSchemaDefinitions()	0	24	1
A	testRedefineSchemaInSchemaExtension()	0	19	1
A	expectSDLErrors()	0	3	1
A	canNotDefineSchemaWithinExtension()	0	5	1
A	testDefineSchemaInSchemaExtension()	0	16	1

<?php

declare(strict_types=1);

namespace GraphQL\Tests\Validator;

use GraphQL\Error\FormattedError;
use GraphQL\Language\SourceLocation;
use GraphQL\Utils\BuildSchema;
use GraphQL\Validator\Rules\KnownDirectives;
use GraphQL\Validator\Rules\LoneSchemaDefinition;

class LoneSchemaDefinitionTest extends ValidatorTestCase
{
    private function expectSDLErrors($sdlString, $schema = null, $errors = [])
    {
        return $this->expectSDLErrorsFromRule(new LoneSchemaDefinition(), $sdlString, $schema, $errors);

Are you sure the usage of $this->expectSDLErrorsFromRule(new GraphQL\Validator\Rules\LoneSchemaDefinition(), $sdlString, $schema, $errors) targeting GraphQL\Tests\Validator\ValidatorTestCase::expectSDLErrorsFromRule() seems to always return null.

    }

    private function schemaDefinitionNotAlone($line, $column)
    {
        return FormattedError::create(

The function GraphQL\Error\FormattedError::create() has been deprecated: as of v0.8.0

            LoneSchemaDefinition::schemaDefinitionNotAloneMessage(),
            [new SourceLocation($line, $column)]
        );
    }

    private function canNotDefineSchemaWithinExtension($line, $column)
    {
        return FormattedError::create(

The function GraphQL\Error\FormattedError::create() has been deprecated: as of v0.8.0

            LoneSchemaDefinition::canNotDefineSchemaWithinExtensionMessage(),
            [new SourceLocation($line, $column)]
        );
    }

    // Validate: Schema definition should be alone

    /**
     * @see it('no schema')
     */
    public function testNoSchema()
    {
        $this->expectSDLErrors(
            '
          type Query {
            foo: String
          }
            ',
            null,
            []
        );
    }

    /**
     * @see it('one schema definition')
     */
    public function testOneSchemaDefinition()
    {
        $this->expectSDLErrors(
            '
          schema {
            query: Foo
          }
    
          type Foo {
            foo: String
          }
            ',
            null,
            []
        );
    }

    /**
     * @see it('multiple schema definitions')
     */
    public function testMultipleSchemaDefinitions()
    {
        $this->expectSDLErrors(
            '
      schema {
        query: Foo
      }

      type Foo {
        foo: String
      }

      schema {
        mutation: Foo
      }

      schema {
        subscription: Foo
      }
            ',
            null,
            [
                $this->schemaDefinitionNotAlone(10, 7),
                $this->schemaDefinitionNotAlone(14, 7),
            ]
        );
    }

    /**
     * @see it('define schema in schema extension')
     */
    public function testDefineSchemaInSchemaExtension()
    {
        $schema = BuildSchema::build('
          type Foo {
            foo: String
          }
        ');

        $this->expectSDLErrors(
            '
                schema {
                  query: Foo
                }
            ',
            $schema,
            []
        );
    }

    /**
     * @see it('redefine schema in schema extension')
     */
    public function testRedefineSchemaInSchemaExtension()
    {
        $schema = BuildSchema::build('
          schema {
            query: Foo
          }
    
          type Foo {
            foo: String
          }');

        $this->expectSDLErrors(
            '
                schema {
                  mutation: Foo
                }
            ',
            $schema,
            [$this->canNotDefineSchemaWithinExtension(2, 17)]
        );
    }

    /**
     * @see it('redefine implicit schema in schema extension')
     */
    public function testRedefineImplicitSchemaInSchemaExtension()
    {
        $schema = BuildSchema::build('
          type Query {
            fooField: Foo
          }
    
          type Foo {
            foo: String
          }
        ');

        $this->expectSDLErrors(
            '
                schema {
                  mutation: Foo
                }
            ',
            $schema,
            [$this->canNotDefineSchemaWithinExtension(2, 17)]
        );
    }

    /**
     * @see it('extend schema in schema extension')
     */
    public function testExtendSchemaInSchemaExtension()
    {
        $schema = BuildSchema::build('
          type Query {
            fooField: Foo
          }
    
          type Foo {
            foo: String
          }
        ');

        $this->expectSDLErrors(
            '
                extend schema {
                  mutation: Foo
                }
            ',
            $schema,
            []
        );
    }
}