StarWarsIntrospectionTest.php

<?php declare(strict_types=1);

namespace GraphQL\Tests;

use GraphQL\GraphQL;
use PHPUnit\Framework\TestCase;

/**
 * @see describe('Star Wars Introspection Tests', () => {
 * @see describe('Basic Introspection', () => {
 */
final class StarWarsIntrospectionTest extends TestCase
{
    /** @see it('Allows querying the schema for types') */
    public function testAllowsQueryingTheSchemaForTypes(): void
    {
        $query = '
        {
          __schema {
            types {
              name
            }
          }
        }
        ';
        $expected = [
            '__schema' => [
                'types' => [
                    ['name' => 'Human'],
                    ['name' => 'Character'],
                    ['name' => 'String'],
                    ['name' => 'Episode'],
                    ['name' => 'Droid'],
                    ['name' => 'Query'],
                    ['name' => 'Boolean'],
                    ['name' => '__Schema'],
                    ['name' => '__Type'],
                    ['name' => '__TypeKind'],
                    ['name' => '__Field'],
                    ['name' => '__InputValue'],
                    ['name' => '__EnumValue'],
                    ['name' => '__Directive'],
                    ['name' => '__DirectiveLocation'],
                ],
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /**
     * Helper function to test a query and the expected response.
     *
     * @param array<string, mixed> $expected
     *
     * @throws \Exception
     */
    private static function assertValidQuery(string $query, array $expected): void
    {
        self::assertEquals(
            ['data' => $expected],
            GraphQL::executeQuery(StarWarsSchema::build(), $query)->toArray()
        );
    }

    /** @see it('Allows querying the schema for query type') */
    public function testAllowsQueryingTheSchemaForQueryType(): void
    {
        $query = '
        query IntrospectionQueryTypeQuery {
          __schema {
            queryType {
              name
            }
          }
        }
        ';
        $expected = [
            '__schema' => [
                'queryType' => ['name' => 'Query'],
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for a specific type') */
    public function testAllowsQueryingTheSchemaForASpecificType(): void
    {
        $query = '
        query IntrospectionDroidTypeQuery {
          __type(name: "Droid") {
            name
          }
        }
        ';
        $expected = [
            '__type' => ['name' => 'Droid'],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for an object kind') */
    public function testAllowsQueryingForAnObjectKind(): void
    {
        $query = '
        query IntrospectionDroidKindQuery {
          __type(name: "Droid") {
            name
            kind
          }
        }
        ';
        $expected = [
            '__type' => [
                'name' => 'Droid',
                'kind' => 'OBJECT',
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for an interface kind') */
    public function testAllowsQueryingForInterfaceKind(): void
    {
        $query = '
        query IntrospectionCharacterKindQuery {
          __type(name: "Character") {
            name
            kind
          }
        }
        ';
        $expected = [
            '__type' => [
                'name' => 'Character',
                'kind' => 'INTERFACE',
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for object fields') */
    public function testAllowsQueryingForObjectFields(): void
    {
        $query = '
        query IntrospectionDroidFieldsQuery {
          __type(name: "Droid") {
            name
            fields {
              name
              type {
                name
                kind
              }
            }
          }
        }
        ';
        $expected = [
            '__type' => [
                'name' => 'Droid',
                'fields' => [
                    [
                        'name' => 'id',
                        'type' => [
                            'name' => null,
                            'kind' => 'NON_NULL',
                        ],
                    ],
                    [
                        'name' => 'name',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                        ],
                    ],
                    [
                        'name' => 'friends',
                        'type' => [
                            'name' => null,
                            'kind' => 'LIST',
                        ],
                    ],
                    [
                        'name' => 'appearsIn',
                        'type' => [
                            'name' => null,
                            'kind' => 'LIST',
                        ],
                    ],
                    [
                        'name' => 'secretBackstory',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                        ],
                    ],
                    [
                        'name' => 'primaryFunction',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                        ],
                    ],
                ],
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for nested object fields') */
    public function testAllowsQueryingTheSchemaForNestedObjectFields(): void
    {
        $query = '
        query IntrospectionDroidNestedFieldsQuery {
          __type(name: "Droid") {
            name
            fields {
              name
              type {
                name
                kind
                ofType {
                  name
                  kind
                }
              }
            }
          }
        }
        ';
        $expected = [
            '__type' => [
                'name' => 'Droid',
                'fields' => [
                    [
                        'name' => 'id',
                        'type' => [
                            'name' => null,
                            'kind' => 'NON_NULL',
                            'ofType' => [
                                'name' => 'String',
                                'kind' => 'SCALAR',
                            ],
                        ],
                    ],
                    [
                        'name' => 'name',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                            'ofType' => null,
                        ],
                    ],
                    [
                        'name' => 'friends',
                        'type' => [
                            'name' => null,
                            'kind' => 'LIST',
                            'ofType' => [
                                'name' => 'Character',
                                'kind' => 'INTERFACE',
                            ],
                        ],
                    ],
                    [
                        'name' => 'appearsIn',
                        'type' => [
                            'name' => null,
                            'kind' => 'LIST',
                            'ofType' => [
                                'name' => 'Episode',
                                'kind' => 'ENUM',
                            ],
                        ],
                    ],
                    [
                        'name' => 'secretBackstory',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                            'ofType' => null,
                        ],
                    ],
                    [
                        'name' => 'primaryFunction',
                        'type' => [
                            'name' => 'String',
                            'kind' => 'SCALAR',
                            'ofType' => null,
                        ],
                    ],
                ],
            ],
        ];
        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for field args') */
    public function testAllowsQueryingTheSchemaForFieldArgs(): void
    {
        $query = '
        query IntrospectionQueryTypeQuery {
          __schema {
            queryType {
              fields {
                name
                args {
                  name
                  description
                  type {
                    name
                    kind
                    ofType {
                      name
                      kind
                    }
                  }
                  defaultValue
                }
              }
            }
          }
        }
        ';

        $expected = [
            '__schema' => [
                'queryType' => [
                    'fields' => [
                        [
                            'name' => 'hero',
                            'args' => [
                                [
                                    'defaultValue' => null,
                                    'description' => 'If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode.',
                                    'name' => 'episode',
                                    'type' => [
                                        'kind' => 'ENUM',
                                        'name' => 'Episode',
                                        'ofType' => null,
                                    ],
                                ],
                            ],
                        ],
                        [
                            'name' => 'human',
                            'args' => [
                                [
                                    'name' => 'id',
                                    'description' => 'id of the human',
                                    'type' => [
                                        'kind' => 'NON_NULL',
                                        'name' => null,
                                        'ofType' => [
                                            'kind' => 'SCALAR',
                                            'name' => 'String',
                                        ],
                                    ],
                                    'defaultValue' => null,
                                ],
                            ],
                        ],
                        [
                            'name' => 'droid',
                            'args' => [
                                [
                                    'name' => 'id',
                                    'description' => 'id of the droid',
                                    'type' => [
                                        'kind' => 'NON_NULL',
                                        'name' => null,
                                        'ofType' => [
                                            'kind' => 'SCALAR',
                                            'name' => 'String',
                                        ],
                                    ],
                                    'defaultValue' => null,
                                ],
                            ],
                        ],
                    ],
                ],
            ],
        ];

        self::assertValidQuery($query, $expected);
    }

    /** @see it('Allows querying the schema for documentation') */
    public function testAllowsQueryingTheSchemaForDocumentation(): void
    {
        $query = '
        query IntrospectionDroidDescriptionQuery {
          __type(name: "Droid") {
            name
            description
          }
        }
        ';
        $expected = [
            '__type' => [
                'name' => 'Droid',
                'description' => 'A mechanical creature in the Star Wars universe.',
            ],
        ];
        self::assertValidQuery($query, $expected);
    }
}