GraphQL\Tests\StartWarsValidationTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	145
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	StarWarsValidationTest::testValidatesAComplexButValidQuery()	0	22	1
A	StarWarsValidationTest::testDisallowsFieldsOnScalars()	0	13	1
A	StarWarsValidationTest::testRequiresFieldsOnObjects()	0	10	1
A	StarWarsValidationTest::testThatNonExistentFieldsAreInvalid()	0	11	1
A	StarWarsValidationTest::testAllowsObjectFieldsInInlineFragments()	0	14	1
A	StarWarsValidationTest::testDisallowsObjectFieldsOnInterfaces()	0	12	1
A	StarWarsValidationTest::testAllowsObjectFieldsInFragments()	0	16	1

<?php
namespace GraphQL\Tests;

use GraphQL\Language\Parser;
use GraphQL\Validator\DocumentValidator;
use PHPUnit\Framework\TestCase;

class StarWarsValidationTest extends TestCase
{
    // Star Wars Validation Tests
    // Basic Queries

    /**
     * @it Validates a complex but valid query
     */
    public function testValidatesAComplexButValidQuery()
    {
        $query = '
        query NestedQueryWithFragment {
          hero {
            ...NameAndAppearances
            friends {
              ...NameAndAppearances
              friends {
                ...NameAndAppearances
              }
            }
          }
        }

        fragment NameAndAppearances on Character {
          name
          appearsIn
        }
      ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(true, empty($errors));
    }

    /**
     * @it Notes that non-existent fields are invalid
     */
    public function testThatNonExistentFieldsAreInvalid()
    {
        $query = '
        query HeroSpaceshipQuery {
          hero {
            favoriteSpaceship
          }
        }
        ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(false, empty($errors));
    }

    /**
     * @it Requires fields on objects
     */
    public function testRequiresFieldsOnObjects()
    {
        $query = '
        query HeroNoFieldsQuery {
          hero
        }
        ';

        $errors = $this->validationErrors($query);
        $this->assertEquals(false, empty($errors));
    }

    /**
     * @it Disallows fields on scalars
     */
    public function testDisallowsFieldsOnScalars()
    {
      $query = '
        query HeroFieldsOnScalarQuery {
          hero {
            name {
              firstCharacterOfName
            }
          }
        }
        ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(false, empty($errors));
    }

    /**
     * @it Disallows object fields on interfaces
     */
    public function testDisallowsObjectFieldsOnInterfaces()
    {
        $query = '
        query DroidFieldOnCharacter {
          hero {
            name
            primaryFunction
          }
        }
        ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(false, empty($errors));
    }

    /**
     * @it Allows object fields in fragments
     */
    public function testAllowsObjectFieldsInFragments()
    {
        $query = '
        query DroidFieldInFragment {
          hero {
            name
            ...DroidFields
          }
        }

        fragment DroidFields on Droid {
          primaryFunction
        }
        ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(true, empty($errors));
    }

    /**
     * @it Allows object fields in inline fragments
     */
    public function testAllowsObjectFieldsInInlineFragments()
    {
        $query = '
        query DroidFieldInFragment {
          hero {
            name
            ... on Droid {
              primaryFunction
            }
          }
        }
        ';
        $errors = $this->validationErrors($query);
        $this->assertEquals(true, empty($errors));
    }

    /**
     * Helper function to test a query and the expected response.
     */
    private function validationErrors($query)
    {
        $ast = Parser::parse($query);
        return DocumentValidator::validate(StarWarsSchema::build(), $ast);
    }
}