RetailCRM-Mirror/graphql-php
1
0
Fork 0
mirror of https://github.com/retailcrm/graphql-php.git synced 2024-11-25 06:16:05 +03:00
Code Issues Projects Releases Wiki Activity

Fix CS in tests/Utils

Browse Source
This commit is contained in:
Simon Podlipsky 2018-09-02 12:44:21 +02:00
parent ec54d6152b
commit 737da333fb
No known key found for this signature in database
GPG Key ID: 725C2BD962B42663
13 changed files with 1373 additions and 1200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/Utils/AssertValidNameTest.php
View File

@ -1,4 +1,7 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Error\Error; use GraphQL\Error\Error;
@ -9,7 +12,6 @@ use PHPUnit\Framework\TestCase;
class AssertValidNameTest extends TestCase class AssertValidNameTest extends TestCase
{ {
// Describe: assertValidName() // Describe: assertValidName()
/** /**
* @see it('throws for use of leading double underscores') * @see it('throws for use of leading double underscores')
*/ */

141
tests/Utils/AstFromValueTest.php
View File

@ -1,4 +1,7 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Language\AST\BooleanValueNode; use GraphQL\Language\AST\BooleanValueNode;
@ -16,10 +19,12 @@ use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\Type; use GraphQL\Type\Definition\Type;
use GraphQL\Utils\AST; use GraphQL\Utils\AST;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
use stdClass;
class AstFromValueTest extends TestCase class AstFromValueTest extends TestCase
{ {
// Describe: astFromValue /** @var stdClass */
private $complexValue;
/** /**
* @see it('converts boolean values to ASTs') * @see it('converts boolean values to ASTs')
@ -31,8 +36,14 @@ class AstFromValueTest extends TestCase
$this->assertEquals(new NullValueNode([]), AST::astFromValue(null, Type::boolean())); $this->assertEquals(new NullValueNode([]), AST::astFromValue(null, Type::boolean()));
$this->assertEquals(new BooleanValueNode(['value' => false]), AST::astFromValue(0, Type::boolean())); $this->assertEquals(new BooleanValueNode(['value' => false]), AST::astFromValue(0, Type::boolean()));
$this->assertEquals(new BooleanValueNode(['value' => true]), AST::astFromValue(1, Type::boolean())); $this->assertEquals(new BooleanValueNode(['value' => true]), AST::astFromValue(1, Type::boolean()));
$this->assertEquals(new BooleanValueNode(['value' => false]), AST::astFromValue(0, Type::nonNull(Type::boolean()))); $this->assertEquals(
$this->assertEquals(null, AST::astFromValue(null, Type::nonNull(Type::boolean()))); // Note: null means that AST cannot new BooleanValueNode(['value' => false]),
AST::astFromValue(0, Type::nonNull(Type::boolean()))
);
$this->assertEquals(
null,
AST::astFromValue(null, Type::nonNull(Type::boolean()))
); // Note: null means that AST cannot
} }
/** /**
@ -59,7 +70,10 @@ class AstFromValueTest extends TestCase
{ {
$this->expectException(\Throwable::class); $this->expectException(\Throwable::class);
$this->expectExceptionMessage('Int cannot represent non 32-bit signed integer value: 1.0E+40'); $this->expectExceptionMessage('Int cannot represent non 32-bit signed integer value: 1.0E+40');
AST::astFromValue(1e40, Type::int()); // Note: js version will produce 1e+40, both values are valid GraphQL floats AST::astFromValue(
1e40,
Type::int()
); // Note: js version will produce 1e+40, both values are valid GraphQL floats
} }
/** /**
@ -121,7 +135,10 @@ class AstFromValueTest extends TestCase
public function testConvertsStringValuesToEnumASTsIfPossible() : void public function testConvertsStringValuesToEnumASTsIfPossible() : void
{ {
$this->assertEquals(new EnumValueNode(['value' => 'HELLO']), AST::astFromValue('HELLO', $this->myEnum())); $this->assertEquals(new EnumValueNode(['value' => 'HELLO']), AST::astFromValue('HELLO', $this->myEnum()));
$this->assertEquals(new EnumValueNode(['value' => 'COMPLEX']), AST::astFromValue($this->complexValue(), $this->myEnum())); $this->assertEquals(
new EnumValueNode(['value' => 'COMPLEX']),
AST::astFromValue($this->complexValue(), $this->myEnum())
);
// Note: case sensitive // Note: case sensitive
$this->assertEquals(null, AST::astFromValue('hello', $this->myEnum())); $this->assertEquals(null, AST::astFromValue('hello', $this->myEnum()));
@ -130,6 +147,31 @@ class AstFromValueTest extends TestCase
$this->assertEquals(null, AST::astFromValue('VALUE', $this->myEnum())); $this->assertEquals(null, AST::astFromValue('VALUE', $this->myEnum()));
} }
/**
* @return EnumType
*/
private function myEnum()
{
return new EnumType([
'name' => 'MyEnum',
'values' => [
'HELLO' => [],
'GOODBYE' => [],
'COMPLEX' => ['value' => $this->complexValue()],
],
]);
}
private function complexValue()
{
if (! $this->complexValue) {
$this->complexValue = new \stdClass();
$this->complexValue->someArbitrary = 'complexValue';
}
return $this->complexValue;
}
/** /**
* @see it('converts array values to List ASTs') * @see it('converts array values to List ASTs')
*/ */
@ -138,8 +180,8 @@ class AstFromValueTest extends TestCase
$value1 = new ListValueNode([ $value1 = new ListValueNode([
'values' => [ 'values' => [
new StringValueNode(['value' => 'FOO']), new StringValueNode(['value' => 'FOO']),
new StringValueNode(['value' => 'BAR']) new StringValueNode(['value' => 'BAR']),
] ],
]); ]);
$this->assertEquals($value1, AST::astFromValue(['FOO', 'BAR'], Type::listOf(Type::string()))); $this->assertEquals($value1, AST::astFromValue(['FOO', 'BAR'], Type::listOf(Type::string())));
@ -147,7 +189,7 @@ class AstFromValueTest extends TestCase
'values' => [ 'values' => [
new EnumValueNode(['value' => 'HELLO']), new EnumValueNode(['value' => 'HELLO']),
new EnumValueNode(['value' => 'GOODBYE']), new EnumValueNode(['value' => 'GOODBYE']),
] ],
]); ]);
$this->assertEquals($value2, AST::astFromValue(['HELLO', 'GOODBYE'], Type::listOf($this->myEnum()))); $this->assertEquals($value2, AST::astFromValue(['HELLO', 'GOODBYE'], Type::listOf($this->myEnum())));
} }
@ -157,7 +199,10 @@ class AstFromValueTest extends TestCase
*/ */
public function testConvertsListSingletons() : void public function testConvertsListSingletons() : void
{ {
$this->assertEquals(new StringValueNode(['value' => 'FOO']), AST::astFromValue('FOO', Type::listOf(Type::string()))); $this->assertEquals(
new StringValueNode(['value' => 'FOO']),
AST::astFromValue('FOO', Type::listOf(Type::string()))
);
} }
/** /**
@ -166,18 +211,18 @@ class AstFromValueTest extends TestCase
public function testConvertsInputObjects() : void public function testConvertsInputObjects() : void
{ {
$inputObj = new InputObjectType([ $inputObj = new InputObjectType([
'name' => 'MyInputObj', 'name' => 'MyInputObj',
'fields' => [ 'fields' => [
'foo' => Type::float(), 'foo' => Type::float(),
'bar' => $this->myEnum() 'bar' => $this->myEnum(),
] ],
]); ]);
$expected = new ObjectValueNode([ $expected = new ObjectValueNode([
'fields' => [ 'fields' => [
$this->objectField('foo', new IntValueNode(['value' => '3'])), $this->objectField('foo', new IntValueNode(['value' => '3'])),
$this->objectField('bar', new EnumValueNode(['value' => 'HELLO'])) $this->objectField('bar', new EnumValueNode(['value' => 'HELLO'])),
] ],
]); ]);
$data = ['foo' => 3, 'bar' => 'HELLO']; $data = ['foo' => 3, 'bar' => 'HELLO'];
@ -185,62 +230,38 @@ class AstFromValueTest extends TestCase
$this->assertEquals($expected, AST::astFromValue((object) $data, $inputObj)); $this->assertEquals($expected, AST::astFromValue((object) $data, $inputObj));
} }
/**
* @param mixed $value
* @return ObjectFieldNode
*/
private function objectField(string $name, $value)
{
return new ObjectFieldNode([
'name' => new NameNode(['value' => $name]),
'value' => $value,
]);
}
/** /**
* @see it('converts input objects with explicit nulls') * @see it('converts input objects with explicit nulls')
*/ */
public function testConvertsInputObjectsWithExplicitNulls() : void public function testConvertsInputObjectsWithExplicitNulls() : void
{ {
$inputObj = new InputObjectType([ $inputObj = new InputObjectType([
'name' => 'MyInputObj', 'name' => 'MyInputObj',
'fields' => [ 'fields' => [
'foo' => Type::float(), 'foo' => Type::float(),
'bar' => $this->myEnum() 'bar' => $this->myEnum(),
] ],
]); ]);
$this->assertEquals(new ObjectValueNode([ $this->assertEquals(
new ObjectValueNode([
'fields' => [ 'fields' => [
$this->objectField('foo', new NullValueNode([])) $this->objectField('foo', new NullValueNode([])),
] ],
]), AST::astFromValue(['foo' => null], $inputObj)); ]),
} AST::astFromValue(['foo' => null], $inputObj)
);
private $complexValue;
private function complexValue()
{
if (!$this->complexValue) {
$this->complexValue = new \stdClass();
$this->complexValue->someArbitrary = 'complexValue';
}
return $this->complexValue;
}
/**
* @return EnumType
*/
private function myEnum()
{
return new EnumType([
'name' => 'MyEnum',
'values' => [
'HELLO' => [],
'GOODBYE' => [],
'COMPLEX' => ['value' => $this->complexValue()]
]
]);
}
/**
* @param $name
* @param $value
* @return ObjectFieldNode
*/
private function objectField($name, $value)
{
return new ObjectFieldNode([
'name' => new NameNode(['value' => $name]),
'value' => $value
]);
} }
} }

22
tests/Utils/AstFromValueUntypedTest.php
View File

@ -1,4 +1,7 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Language\Parser; use GraphQL\Language\Parser;
@ -8,14 +11,6 @@ use PHPUnit\Framework\TestCase;
class AstFromValueUntypedTest extends TestCase class AstFromValueUntypedTest extends TestCase
{ {
// Describe: valueFromASTUntyped // Describe: valueFromASTUntyped
private function assertTestCase($valueText, $expected, array $variables = null) {
$this->assertEquals(
$expected,
AST::valueFromASTUntyped(Parser::parseValue($valueText), $variables)
);
}
/** /**
* @see it('parses simple values') * @see it('parses simple values')
*/ */
@ -29,6 +24,17 @@ class AstFromValueUntypedTest extends TestCase
$this->assertTestCase('abc123', 'abc123'); $this->assertTestCase('abc123', 'abc123');
} }
/**
* @param mixed[]|null $variables
*/
private function assertTestCase($valueText, $expected, ?array $variables = null) : void
{
$this->assertEquals(
$expected,
AST::valueFromASTUntyped(Parser::parseValue($valueText), $variables)
);
}
/** /**
* @see it('parses lists of values') * @see it('parses lists of values')
*/ */

1113
tests/Utils/BreakingChangesFinderTest.php
View File

File diff suppressed because it is too large Load Diff

217
tests/Utils/BuildSchemaTest.php
View File

@ -1,4 +1,7 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Error\Error; use GraphQL\Error\Error;
@ -8,24 +11,19 @@ use GraphQL\Language\AST\InterfaceTypeDefinitionNode;
use GraphQL\Language\AST\ObjectTypeDefinitionNode; use GraphQL\Language\AST\ObjectTypeDefinitionNode;
use GraphQL\Language\Parser; use GraphQL\Language\Parser;
use GraphQL\Language\Printer; use GraphQL\Language\Printer;
use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\EnumType; use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\ObjectType; use GraphQL\Type\Definition\ObjectType;
use GraphQL\Utils\BuildSchema; use GraphQL\Utils\BuildSchema;
use GraphQL\Utils\SchemaPrinter; use GraphQL\Utils\SchemaPrinter;
use GraphQL\Type\Definition\Directive;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
use function array_keys;
use function count;
class BuildSchemaTest extends TestCase class BuildSchemaTest extends TestCase
{ {
// Describe: Schema Builder // Describe: Schema Builder
private function cycleOutput($body, $options = [])
{
$ast = Parser::parse($body);
$schema = BuildSchema::buildAST($ast, null, $options);
return "\n" . SchemaPrinter::doPrint($schema, $options);
}
/** /**
* @see it('can use built schema for limited execution') * @see it('can use built schema for limited execution')
*/ */
@ -46,16 +44,16 @@ class BuildSchemaTest extends TestCase
*/ */
public function testBuildSchemaDirectlyFromSource() : void public function testBuildSchemaDirectlyFromSource() : void
{ {
$schema = BuildSchema::build(" $schema = BuildSchema::build('
type Query { type Query {
add(x: Int, y: Int): Int add(x: Int, y: Int): Int
} }
"); ');
$root = [ $root = [
'add' => function ($root, $args) { 'add' => function ($root, $args) {
return $args['x'] + $args['y']; return $args['x'] + $args['y'];
} },
]; ];
$result = GraphQL::executeQuery( $result = GraphQL::executeQuery(
@ -71,7 +69,7 @@ class BuildSchemaTest extends TestCase
*/ */
public function testSimpleType() : void public function testSimpleType() : void
{ {
$body = ' $body = '
type HelloScalars { type HelloScalars {
str: String str: String
int: Int int: Int
@ -84,12 +82,20 @@ type HelloScalars {
$this->assertEquals($output, $body); $this->assertEquals($output, $body);
} }
private function cycleOutput($body, $options = [])
{
$ast = Parser::parse($body);
$schema = BuildSchema::buildAST($ast, null, $options);
return "\n" . SchemaPrinter::doPrint($schema, $options);
}
/** /**
* @see it('With directives') * @see it('With directives')
*/ */
public function testWithDirectives() : void public function testWithDirectives() : void
{ {
$body = ' $body = '
directive @foo(arg: Int) on FIELD directive @foo(arg: Int) on FIELD
type Query { type Query {
@ -105,7 +111,7 @@ type Query {
*/ */
public function testSupportsDescriptions() : void public function testSupportsDescriptions() : void
{ {
$body = ' $body = '
"""This is a directive""" """This is a directive"""
directive @foo( directive @foo(
"""It has an argument""" """It has an argument"""
@ -137,7 +143,7 @@ type Query {
*/ */
public function testSupportsOptionForCommentDescriptions() : void public function testSupportsOptionForCommentDescriptions() : void
{ {
$body = ' $body = '
# This is a directive # This is a directive
directive @foo( directive @foo(
# It has an argument # It has an argument
@ -159,7 +165,7 @@ type Query {
str: String str: String
} }
'; ';
$output = $this->cycleOutput($body, [ 'commentDescriptions' => true ]); $output = $this->cycleOutput($body, ['commentDescriptions' => true]);
$this->assertEquals($body, $output); $this->assertEquals($body, $output);
} }
@ -168,7 +174,7 @@ type Query {
*/ */
public function testMaintainsSkipAndInclude() : void public function testMaintainsSkipAndInclude() : void
{ {
$body = ' $body = '
type Query { type Query {
str: String str: String
} }
@ -185,7 +191,7 @@ type Query {
*/ */
public function testOverridingDirectivesExcludesSpecified() : void public function testOverridingDirectivesExcludesSpecified() : void
{ {
$body = ' $body = '
directive @skip on FIELD directive @skip on FIELD
directive @include on FIELD directive @include on FIELD
directive @deprecated on FIELD_DEFINITION directive @deprecated on FIELD_DEFINITION
@ -206,7 +212,7 @@ type Query {
*/ */
public function testAddingDirectivesMaintainsSkipAndInclude() : void public function testAddingDirectivesMaintainsSkipAndInclude() : void
{ {
$body = ' $body = '
directive @foo(arg: Int) on FIELD directive @foo(arg: Int) on FIELD
type Query { type Query {
@ -225,7 +231,7 @@ type Query {
*/ */
public function testTypeModifiers() : void public function testTypeModifiers() : void
{ {
$body = ' $body = '
type HelloScalars { type HelloScalars {
nonNullStr: String! nonNullStr: String!
listOfStrs: [String] listOfStrs: [String]
@ -243,7 +249,7 @@ type HelloScalars {
*/ */
public function testRecursiveType() : void public function testRecursiveType() : void
{ {
$body = ' $body = '
type Query { type Query {
str: String str: String
recurse: Query recurse: Query
@ -258,7 +264,7 @@ type Query {
*/ */
public function testTwoTypesCircular() : void public function testTwoTypesCircular() : void
{ {
$body = ' $body = '
schema { schema {
query: TypeOne query: TypeOne
} }
@ -282,7 +288,7 @@ type TypeTwo {
*/ */
public function testSingleArgumentField() : void public function testSingleArgumentField() : void
{ {
$body = ' $body = '
type Query { type Query {
str(int: Int): String str(int: Int): String
floatToStr(float: Float): String floatToStr(float: Float): String
@ -300,7 +306,7 @@ type Query {
*/ */
public function testSimpleTypeWithMultipleArguments() : void public function testSimpleTypeWithMultipleArguments() : void
{ {
$body = ' $body = '
type Query { type Query {
str(int: Int, bool: Boolean): String str(int: Int, bool: Boolean): String
} }
@ -314,7 +320,7 @@ type Query {
*/ */
public function testSimpleTypeWithInterface() : void public function testSimpleTypeWithInterface() : void
{ {
$body = ' $body = '
type Query implements WorldInterface { type Query implements WorldInterface {
str: String str: String
} }
@ -332,7 +338,7 @@ interface WorldInterface {
*/ */
public function testSimpleOutputEnum() : void public function testSimpleOutputEnum() : void
{ {
$body = ' $body = '
enum Hello { enum Hello {
WORLD WORLD
} }
@ -350,7 +356,7 @@ type Query {
*/ */
public function testSimpleInputEnum() : void public function testSimpleInputEnum() : void
{ {
$body = ' $body = '
enum Hello { enum Hello {
WORLD WORLD
} }
@ -368,7 +374,7 @@ type Query {
*/ */
public function testMultipleValueEnum() : void public function testMultipleValueEnum() : void
{ {
$body = ' $body = '
enum Hello { enum Hello {
WO WO
RLD RLD
@ -387,7 +393,7 @@ type Query {
*/ */
public function testSimpleUnion() : void public function testSimpleUnion() : void
{ {
$body = ' $body = '
union Hello = World union Hello = World
type Query { type Query {
@ -407,7 +413,7 @@ type World {
*/ */
public function testMultipleUnion() : void public function testMultipleUnion() : void
{ {
$body = ' $body = '
union Hello = WorldOne | WorldTwo union Hello = WorldOne | WorldTwo
type Query { type Query {
@ -431,7 +437,7 @@ type WorldTwo {
*/ */
public function testSpecifyingUnionTypeUsingTypename() : void public function testSpecifyingUnionTypeUsingTypename() : void
{ {
$schema = BuildSchema::buildAST(Parser::parse(' $schema = BuildSchema::buildAST(Parser::parse('
type Query { type Query {
fruits: [Fruit] fruits: [Fruit]
} }
@ -446,7 +452,7 @@ type WorldTwo {
length: Int length: Int
} }
')); '));
$query = ' $query = '
{ {
fruits { fruits {
... on Apple { ... on Apple {
@ -458,25 +464,25 @@ type WorldTwo {
} }
} }
'; ';
$root = [ $root = [
'fruits' => [ 'fruits' => [
[ [
'color' => 'green', 'color' => 'green',
'__typename' => 'Apple', '__typename' => 'Apple',
], ],
[ [
'length' => 5, 'length' => 5,
'__typename' => 'Banana', '__typename' => 'Banana',
] ],
] ],
]; ];
$expected = [ $expected = [
'data' => [ 'data' => [
'fruits' => [ 'fruits' => [
['color' => 'green'], ['color' => 'green'],
['length' => 5], ['length' => 5],
] ],
] ],
]; ];
$result = GraphQL::executeQuery($schema, $query, $root); $result = GraphQL::executeQuery($schema, $query, $root);
@ -488,7 +494,7 @@ type WorldTwo {
*/ */
public function testSpecifyingInterfaceUsingTypename() : void public function testSpecifyingInterfaceUsingTypename() : void
{ {
$schema = BuildSchema::buildAST(Parser::parse(' $schema = BuildSchema::buildAST(Parser::parse('
type Query { type Query {
characters: [Character] characters: [Character]
} }
@ -507,7 +513,7 @@ type WorldTwo {
primaryFunction: String primaryFunction: String
} }
')); '));
$query = ' $query = '
{ {
characters { characters {
name name
@ -520,27 +526,27 @@ type WorldTwo {
} }
} }
'; ';
$root = [ $root = [
'characters' => [ 'characters' => [
[ [
'name' => 'Han Solo', 'name' => 'Han Solo',
'totalCredits' => 10, 'totalCredits' => 10,
'__typename' => 'Human', '__typename' => 'Human',
], ],
[ [
'name' => 'R2-D2', 'name' => 'R2-D2',
'primaryFunction' => 'Astromech', 'primaryFunction' => 'Astromech',
'__typename' => 'Droid', '__typename' => 'Droid',
] ],
] ],
]; ];
$expected = [ $expected = [
'data' => [ 'data' => [
'characters' => [ 'characters' => [
['name' => 'Han Solo', 'totalCredits' => 10], ['name' => 'Han Solo', 'totalCredits' => 10],
['name' => 'R2-D2', 'primaryFunction' => 'Astromech'], ['name' => 'R2-D2', 'primaryFunction' => 'Astromech'],
] ],
] ],
]; ];
$result = GraphQL::executeQuery($schema, $query, $root); $result = GraphQL::executeQuery($schema, $query, $root);
@ -552,7 +558,7 @@ type WorldTwo {
*/ */
public function testCustomScalar() : void public function testCustomScalar() : void
{ {
$body = ' $body = '
scalar CustomScalar scalar CustomScalar
type Query { type Query {
@ -568,7 +574,7 @@ type Query {
*/ */
public function testInputObject() : void public function testInputObject() : void
{ {
$body = ' $body = '
input Input { input Input {
int: Int int: Int
} }
@ -586,7 +592,7 @@ type Query {
*/ */
public function testSimpleArgumentFieldWithDefault() : void public function testSimpleArgumentFieldWithDefault() : void
{ {
$body = ' $body = '
type Query { type Query {
str(int: Int = 2): String str(int: Int = 2): String
} }
@ -600,7 +606,7 @@ type Query {
*/ */
public function testCustomScalarArgumentFieldWithDefault() : void public function testCustomScalarArgumentFieldWithDefault() : void
{ {
$body = ' $body = '
scalar CustomScalar scalar CustomScalar
type Query { type Query {
@ -616,7 +622,7 @@ type Query {
*/ */
public function testSimpleTypeWithMutation() : void public function testSimpleTypeWithMutation() : void
{ {
$body = ' $body = '
schema { schema {
query: HelloScalars query: HelloScalars
mutation: Mutation mutation: Mutation
@ -641,7 +647,7 @@ type Mutation {
*/ */
public function testSimpleTypeWithSubscription() : void public function testSimpleTypeWithSubscription() : void
{ {
$body = ' $body = '
schema { schema {
query: HelloScalars query: HelloScalars
subscription: Subscription subscription: Subscription
@ -666,7 +672,7 @@ type Subscription {
*/ */
public function testUnreferencedTypeImplementingReferencedInterface() : void public function testUnreferencedTypeImplementingReferencedInterface() : void
{ {
$body = ' $body = '
type Concrete implements Iface { type Concrete implements Iface {
key: String key: String
} }
@ -688,7 +694,7 @@ type Query {
*/ */
public function testUnreferencedTypeImplementingReferencedUnion() : void public function testUnreferencedTypeImplementingReferencedUnion() : void
{ {
$body = ' $body = '
type Concrete { type Concrete {
key: String key: String
} }
@ -708,7 +714,7 @@ union Union = Concrete
*/ */
public function testSupportsDeprecated() : void public function testSupportsDeprecated() : void
{ {
$body = ' $body = '
enum MyEnum { enum MyEnum {
VALUE VALUE
OLD_VALUE @deprecated OLD_VALUE @deprecated
@ -724,7 +730,7 @@ type Query {
$output = $this->cycleOutput($body); $output = $this->cycleOutput($body);
$this->assertEquals($output, $body); $this->assertEquals($output, $body);
$ast = Parser::parse($body); $ast = Parser::parse($body);
$schema = BuildSchema::buildAST($ast); $schema = BuildSchema::buildAST($ast);
/** @var EnumType $myEnum */ /** @var EnumType $myEnum */
@ -785,15 +791,15 @@ type Query {
directive @test(arg: TestScalar) on FIELD directive @test(arg: TestScalar) on FIELD
'); ');
$schema = BuildSchema::buildAST($schemaAST); $schema = BuildSchema::buildAST($schemaAST);
/** @var ObjectType $query */ /** @var ObjectType $query */
$query = $schema->getType('Query'); $query = $schema->getType('Query');
$testInput = $schema->getType('TestInput'); $testInput = $schema->getType('TestInput');
$testEnum = $schema->getType('TestEnum'); $testEnum = $schema->getType('TestEnum');
$testUnion = $schema->getType('TestUnion'); $testUnion = $schema->getType('TestUnion');
$testInterface = $schema->getType('TestInterface'); $testInterface = $schema->getType('TestInterface');
$testType = $schema->getType('TestType'); $testType = $schema->getType('TestType');
$testScalar = $schema->getType('TestScalar'); $testScalar = $schema->getType('TestScalar');
$testDirective = $schema->getDirective('test'); $testDirective = $schema->getDirective('test');
$restoredIDL = SchemaPrinter::doPrint(BuildSchema::build( $restoredIDL = SchemaPrinter::doPrint(BuildSchema::build(
@ -813,9 +819,15 @@ type Query {
$testField = $query->getField('testField'); $testField = $query->getField('testField');
$this->assertEquals('testField(testArg: TestInput): TestUnion', Printer::doPrint($testField->astNode)); $this->assertEquals('testField(testArg: TestInput): TestUnion', Printer::doPrint($testField->astNode));
$this->assertEquals('testArg: TestInput', Printer::doPrint($testField->args[0]->astNode)); $this->assertEquals('testArg: TestInput', Printer::doPrint($testField->args[0]->astNode));
$this->assertEquals('testInputField: TestEnum', Printer::doPrint($testInput->getField('testInputField')->astNode)); $this->assertEquals(
'testInputField: TestEnum',
Printer::doPrint($testInput->getField('testInputField')->astNode)
);
$this->assertEquals('TEST_VALUE', Printer::doPrint($testEnum->getValue('TEST_VALUE')->astNode)); $this->assertEquals('TEST_VALUE', Printer::doPrint($testEnum->getValue('TEST_VALUE')->astNode));
$this->assertEquals('interfaceField: String', Printer::doPrint($testInterface->getField('interfaceField')->astNode)); $this->assertEquals(
'interfaceField: String',
Printer::doPrint($testInterface->getField('interfaceField')->astNode)
);
$this->assertEquals('interfaceField: String', Printer::doPrint($testType->getField('interfaceField')->astNode)); $this->assertEquals('interfaceField: String', Printer::doPrint($testType->getField('interfaceField')->astNode));
$this->assertEquals('arg: TestScalar', Printer::doPrint($testDirective->args[0]->astNode)); $this->assertEquals('arg: TestScalar', Printer::doPrint($testDirective->args[0]->astNode));
} }
@ -893,7 +905,7 @@ type Hello {
bar: Bar bar: Bar
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -918,7 +930,7 @@ type Yellow {
isColor: Boolean isColor: Boolean
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -944,7 +956,7 @@ type Yellow {
isColor: Boolean isColor: Boolean
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -970,7 +982,7 @@ type Yellow {
isColor: Boolean isColor: Boolean
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -981,7 +993,7 @@ type Yellow {
{ {
$this->expectException(Error::class); $this->expectException(Error::class);
$this->expectExceptionMessage('Type "Bar" not found in document.'); $this->expectExceptionMessage('Type "Bar" not found in document.');
$body = ' $body = '
schema { schema {
query: Hello query: Hello
} }
@ -990,7 +1002,7 @@ type Hello {
bar: Bar bar: Bar
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$schema = BuildSchema::buildAST($doc); $schema = BuildSchema::buildAST($doc);
$schema->getTypeMap(); $schema->getTypeMap();
} }
@ -1002,12 +1014,12 @@ type Hello {
{ {
$this->expectException(Error::class); $this->expectException(Error::class);
$this->expectExceptionMessage('Type "Bar" not found in document.'); $this->expectExceptionMessage('Type "Bar" not found in document.');
$body = ' $body = '
type Query implements Bar { type Query implements Bar {
field: String field: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$schema = BuildSchema::buildAST($doc); $schema = BuildSchema::buildAST($doc);
$schema->getTypeMap(); $schema->getTypeMap();
} }
@ -1019,11 +1031,11 @@ type Query implements Bar {
{ {
$this->expectException(Error::class); $this->expectException(Error::class);
$this->expectExceptionMessage('Type "Bar" not found in document.'); $this->expectExceptionMessage('Type "Bar" not found in document.');
$body = ' $body = '
union TestUnion = Bar union TestUnion = Bar
type Query { testUnion: TestUnion } type Query { testUnion: TestUnion }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$schema = BuildSchema::buildAST($doc); $schema = BuildSchema::buildAST($doc);
$schema->getTypeMap(); $schema->getTypeMap();
} }
@ -1044,7 +1056,7 @@ type Hello {
str: String str: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -1065,7 +1077,7 @@ type Hello {
str: String str: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -1091,7 +1103,7 @@ type Wat {
str: String str: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -1109,7 +1121,7 @@ schema {
query Foo { field } query Foo { field }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -1127,7 +1139,7 @@ schema {
fragment Foo on Type { field } fragment Foo on Type { field }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
BuildSchema::buildAST($doc); BuildSchema::buildAST($doc);
} }
@ -1149,7 +1161,7 @@ type Repeated {
id: String id: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$this->expectException(Error::class); $this->expectException(Error::class);
$this->expectExceptionMessage('Type "Repeated" was defined more than once.'); $this->expectExceptionMessage('Type "Repeated" was defined more than once.');
@ -1179,14 +1191,15 @@ interface Hello {
world: String world: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$decorated = []; $decorated = [];
$calls = []; $calls = [];
$typeConfigDecorator = function($defaultConfig, $node, $allNodesMap) use (&$decorated, &$calls) { $typeConfigDecorator = function ($defaultConfig, $node, $allNodesMap) use (&$decorated, &$calls) {
$decorated[] = $defaultConfig['name']; $decorated[] = $defaultConfig['name'];
$calls[] = [$defaultConfig, $node, $allNodesMap]; $calls[] = [$defaultConfig, $node, $allNodesMap];
return ['description' => 'My description of ' . $node->name->value] + $defaultConfig; return ['description' => 'My description of ' . $node->name->value] + $defaultConfig;
}; };
@ -1204,19 +1217,21 @@ interface Hello {
$this->assertEquals(array_keys($allNodesMap), ['Query', 'Color', 'Hello']); $this->assertEquals(array_keys($allNodesMap), ['Query', 'Color', 'Hello']);
$this->assertEquals('My description of Query', $schema->getType('Query')->description); $this->assertEquals('My description of Query', $schema->getType('Query')->description);
list($defaultConfig, $node, $allNodesMap) = $calls[1]; list($defaultConfig, $node, $allNodesMap) = $calls[1];
$this->assertInstanceOf(EnumTypeDefinitionNode::class, $node); $this->assertInstanceOf(EnumTypeDefinitionNode::class, $node);
$this->assertEquals('Color', $defaultConfig['name']); $this->assertEquals('Color', $defaultConfig['name']);
$enumValue = [ $enumValue = [
'description' => '', 'description' => '',
'deprecationReason' => '' 'deprecationReason' => '',
]; ];
$this->assertArraySubset([ $this->assertArraySubset(
'RED' => $enumValue, [
'GREEN' => $enumValue, 'RED' => $enumValue,
'BLUE' => $enumValue, 'GREEN' => $enumValue,
], $defaultConfig['values']); 'BLUE' => $enumValue,
],
$defaultConfig['values']
);
$this->assertCount(4, $defaultConfig); // 3 + astNode $this->assertCount(4, $defaultConfig); // 3 + astNode
$this->assertEquals(array_keys($allNodesMap), ['Query', 'Color', 'Hello']); $this->assertEquals(array_keys($allNodesMap), ['Query', 'Color', 'Hello']);
$this->assertEquals('My description of Color', $schema->getType('Color')->description); $this->assertEquals('My description of Color', $schema->getType('Color')->description);
@ -1233,7 +1248,7 @@ interface Hello {
public function testCreatesTypesLazily() : void public function testCreatesTypesLazily() : void
{ {
$body = ' $body = '
schema { schema {
query: Query query: Query
} }
@ -1258,11 +1273,12 @@ type World implements Hello {
world: String world: String
} }
'; ';
$doc = Parser::parse($body); $doc = Parser::parse($body);
$created = []; $created = [];
$typeConfigDecorator = function($config, $node) use (&$created) { $typeConfigDecorator = function ($config, $node) use (&$created) {
$created[] = $node->name->value; $created[] = $node->name->value;
return $config; return $config;
}; };
@ -1282,5 +1298,4 @@ type World implements Hello {
$this->assertArrayHasKey('Hello', $types); $this->assertArrayHasKey('Hello', $types);
$this->assertArrayHasKey('World', $types); $this->assertArrayHasKey('World', $types);
} }
} }

79
tests/Utils/CoerceValueTest.php
View File

@ -1,8 +1,9 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Error\Error;
use GraphQL\Executor\Values;
use GraphQL\Type\Definition\EnumType; use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\InputObjectType; use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\Type; use GraphQL\Type\Definition\Type;
@ -12,13 +13,16 @@ use PHPUnit\Framework\TestCase;
class CoerceValueTest extends TestCase class CoerceValueTest extends TestCase
{ {
/** @var EnumType */
private $testEnum; private $testEnum;
/** @var InputObjectType */
private $testInputObject; private $testInputObject;
public function setUp() public function setUp()
{ {
$this->testEnum = new EnumType([ $this->testEnum = new EnumType([
'name' => 'TestEnum', 'name' => 'TestEnum',
'values' => [ 'values' => [
'FOO' => 'InternalFoo', 'FOO' => 'InternalFoo',
'BAR' => 123456789, 'BAR' => 123456789,
@ -26,7 +30,7 @@ class CoerceValueTest extends TestCase
]); ]);
$this->testInputObject = new InputObjectType([ $this->testInputObject = new InputObjectType([
'name' => 'TestInputObject', 'name' => 'TestInputObject',
'fields' => [ 'fields' => [
'foo' => Type::nonNull(Type::int()), 'foo' => Type::nonNull(Type::int()),
'bar' => Type::int(), 'bar' => Type::int(),
@ -34,9 +38,9 @@ class CoerceValueTest extends TestCase
]); ]);
} }
// Describe: coerceValue
/** /**
* Describe: coerceValue
*
* @see it('coercing an array to GraphQLString produces an error') * @see it('coercing an array to GraphQLString produces an error')
*/ */
public function testCoercingAnArrayToGraphQLStringProducesAnError() : void public function testCoercingAnArrayToGraphQLStringProducesAnError() : void
@ -53,7 +57,17 @@ class CoerceValueTest extends TestCase
); );
} }
// Describe: for GraphQLInt /**
* Describe: for GraphQLInt
*/
private function expectError($result, $expected)
{
$this->assertInternalType('array', $result);
$this->assertInternalType('array', $result['errors']);
$this->assertCount(1, $result['errors']);
$this->assertEquals($expected, $result['errors'][0]->getMessage());
$this->assertEquals(Utils::undefined(), $result['value']);
}
/** /**
* @see it('returns no error for int input') * @see it('returns no error for int input')
@ -64,6 +78,13 @@ class CoerceValueTest extends TestCase
$this->expectNoErrors($result); $this->expectNoErrors($result);
} }
private function expectNoErrors($result)
{
$this->assertInternalType('array', $result);
$this->assertNull($result['errors']);
$this->assertNotEquals(Utils::undefined(), $result['value']);
}
/** /**
* @see it('returns no error for negative int input') * @see it('returns no error for negative int input')
*/ */
@ -115,6 +136,8 @@ class CoerceValueTest extends TestCase
); );
} }
// Describe: for GraphQLFloat
/** /**
* @see it('returns a single error for char input') * @see it('returns a single error for char input')
*/ */
@ -139,8 +162,6 @@ class CoerceValueTest extends TestCase
); );
} }
// Describe: for GraphQLFloat
/** /**
* @see it('returns no error for int input') * @see it('returns no error for int input')
*/ */
@ -189,6 +210,8 @@ class CoerceValueTest extends TestCase
); );
} }
// DESCRIBE: for GraphQLEnum
/** /**
* @see it('returns a single error for char input') * @see it('returns a single error for char input')
*/ */
@ -213,8 +236,6 @@ class CoerceValueTest extends TestCase
); );
} }
// DESCRIBE: for GraphQLEnum
/** /**
* @see it('returns no error for a known enum name') * @see it('returns no error for a known enum name')
*/ */
@ -229,6 +250,8 @@ class CoerceValueTest extends TestCase
$this->assertEquals(123456789, $barResult['value']); $this->assertEquals(123456789, $barResult['value']);
} }
// DESCRIBE: for GraphQLInputObject
/** /**
* @see it('results error for misspelled enum value') * @see it('results error for misspelled enum value')
*/ */
@ -250,8 +273,6 @@ class CoerceValueTest extends TestCase
$this->expectError($result2, 'Expected type TestEnum.'); $this->expectError($result2, 'Expected type TestEnum.');
} }
// DESCRIBE: for GraphQLInputObject
/** /**
* @see it('returns no error for a valid input') * @see it('returns no error for a valid input')
*/ */
@ -277,7 +298,10 @@ class CoerceValueTest extends TestCase
public function testReturnErrorForAnInvalidField() : void public function testReturnErrorForAnInvalidField() : void
{ {
$result = Value::coerceValue(['foo' => 'abc'], $this->testInputObject); $result = Value::coerceValue(['foo' => 'abc'], $this->testInputObject);
$this->expectError($result, 'Expected type Int at value.foo; Int cannot represent non 32-bit signed integer value: abc'); $this->expectError(
$result,
'Expected type Int at value.foo; Int cannot represent non 32-bit signed integer value: abc'
);
} }
/** /**
@ -286,10 +310,13 @@ class CoerceValueTest extends TestCase
public function testReturnsMultipleErrorsForMultipleInvalidFields() : void public function testReturnsMultipleErrorsForMultipleInvalidFields() : void
{ {
$result = Value::coerceValue(['foo' => 'abc', 'bar' => 'def'], $this->testInputObject); $result = Value::coerceValue(['foo' => 'abc', 'bar' => 'def'], $this->testInputObject);
$this->assertEquals([ $this->assertEquals(
'Expected type Int at value.foo; Int cannot represent non 32-bit signed integer value: abc', [
'Expected type Int at value.bar; Int cannot represent non 32-bit signed integer value: def', 'Expected type Int at value.foo; Int cannot represent non 32-bit signed integer value: abc',
], $result['errors']); 'Expected type Int at value.bar; Int cannot represent non 32-bit signed integer value: def',
],
$result['errors']
);
} }
/** /**
@ -318,20 +345,4 @@ class CoerceValueTest extends TestCase
$result = Value::coerceValue(['foo' => 123, 'bart' => 123], $this->testInputObject); $result = Value::coerceValue(['foo' => 123, 'bart' => 123], $this->testInputObject);
$this->expectError($result, 'Field "bart" is not defined by type TestInputObject; did you mean bar?'); $this->expectError($result, 'Field "bart" is not defined by type TestInputObject; did you mean bar?');
} }
private function expectNoErrors($result)
{
$this->assertInternalType('array', $result);
$this->assertNull($result['errors']);
$this->assertNotEquals(Utils::undefined(), $result['value']);
}
private function expectError($result, $expected) {
$this->assertInternalType('array', $result);
$this->assertInternalType('array', $result['errors']);
$this->assertCount(1, $result['errors']);
$this->assertEquals($expected, $result['errors'][0]->getMessage());
$this->assertEquals(Utils::undefined(), $result['value']);
}
} }

324
tests/Utils/ExtractTypesTest.php
View File

@ -1,5 +1,8 @@
<?php <?php
namespace Utils;
declare(strict_types=1);
namespace GraphQL\Tests\Utils;
use GraphQL\Error\InvariantViolation; use GraphQL\Error\InvariantViolation;
use GraphQL\Type\Definition\InputObjectType; use GraphQL\Type\Definition\InputObjectType;
@ -12,121 +15,74 @@ use PHPUnit\Framework\TestCase;
class ExtractTypesTest extends TestCase class ExtractTypesTest extends TestCase
{ {
/** /** @var ObjectType */
* @var ObjectType
*/
private $query; private $query;
/** /** @var ObjectType */
* @var ObjectType
*/
private $mutation; private $mutation;
/** /** @var InterfaceType */
* @var InterfaceType
*/
private $node; private $node;
/** /** @var InterfaceType */
* @var InterfaceType
*/
private $content; private $content;
/** /** @var ObjectType */
* @var ObjectType
*/
private $blogStory; private $blogStory;
/** /** @var ObjectType */
* @var ObjectType
*/
private $link;
/**
* @var ObjectType
*/
private $video;
/**
* @var ObjectType
*/
private $videoMetadata;
/**
* @var ObjectType
*/
private $comment; private $comment;
/** /** @var ObjectType */
* @var ObjectType
*/
private $user; private $user;
/** /** @var ObjectType */
* @var ObjectType
*/
private $category; private $category;
/** /** @var UnionType */
* @var UnionType
*/
private $mention; private $mention;
/** @var ObjectType */
private $postStoryMutation; private $postStoryMutation;
/** @var InputObjectType */
private $postStoryMutationInput; private $postStoryMutationInput;
/** @var ObjectType */
private $postCommentMutation; private $postCommentMutation;
/** @var InputObjectType */
private $postCommentMutationInput; private $postCommentMutationInput;
public function setUp() public function setUp()
{ {
$this->node = new InterfaceType([ $this->node = new InterfaceType([
'name' => 'Node', 'name' => 'Node',
'fields' => [ 'fields' => [
'id' => Type::string() 'id' => Type::string(),
] ],
]); ]);
$this->content = new InterfaceType([ $this->content = new InterfaceType([
'name' => 'Content', 'name' => 'Content',
'fields' => function() { 'fields' => function () {
return [ return [
'title' => Type::string(), 'title' => Type::string(),
'body' => Type::string(), 'body' => Type::string(),
'author' => $this->user, 'author' => $this->user,
'comments' => Type::listOf($this->comment), 'comments' => Type::listOf($this->comment),
'categories' => Type::listOf($this->category) 'categories' => Type::listOf($this->category),
]; ];
} },
]); ]);
$this->blogStory = new ObjectType([ $this->blogStory = new ObjectType([
'name' => 'BlogStory', 'name' => 'BlogStory',
'interfaces' => [ 'interfaces' => [
$this->node, $this->node,
$this->content $this->content,
], ],
'fields' => function() { 'fields' => function () {
return [
$this->node->getField('id'),
$this->content->getField('title'),
$this->content->getField('body'),
$this->content->getField('author'),
$this->content->getField('comments'),
$this->content->getField('categories')
];
},
]);
$this->link = new ObjectType([
'name' => 'Link',
'interfaces' => [
$this->node,
$this->content
],
'fields' => function() {
return [ return [
$this->node->getField('id'), $this->node->getField('id'),
$this->content->getField('title'), $this->content->getField('title'),
@ -134,156 +90,176 @@ class ExtractTypesTest extends TestCase
$this->content->getField('author'), $this->content->getField('author'),
$this->content->getField('comments'), $this->content->getField('comments'),
$this->content->getField('categories'), $this->content->getField('categories'),
'url' => Type::string()
]; ];
}, },
]); ]);
$this->video = new ObjectType([ new ObjectType([
'name' => 'Video', 'name' => 'Link',
'interfaces' => [ 'interfaces' => [
$this->node, $this->node,
$this->content $this->content,
], ],
'fields' => function() { 'fields' => function () {
return [ return [
$this->node->getField('id'), 'id' => $this->node->getField('id'),
$this->content->getField('title'), 'title' => $this->content->getField('title'),
$this->content->getField('body'), 'body' => $this->content->getField('body'),
$this->content->getField('author'), 'author' => $this->content->getField('author'),
$this->content->getField('comments'), 'comments' => $this->content->getField('comments'),
$this->content->getField('categories'), 'categories' => $this->content->getField('categories'),
'streamUrl' => Type::string(), 'url' => Type::string(),
];
},
]);
new ObjectType([
'name' => 'Video',
'interfaces' => [
$this->node,
$this->content,
],
'fields' => function () {
return [
'id' => $this->node->getField('id'),
'title' => $this->content->getField('title'),
'body' => $this->content->getField('body'),
'author' => $this->content->getField('author'),
'comments' => $this->content->getField('comments'),
'categories' => $this->content->getField('categories'),
'streamUrl' => Type::string(),
'downloadUrl' => Type::string(), 'downloadUrl' => Type::string(),
'metadata' => $this->videoMetadata = new ObjectType([ 'metadata' => new ObjectType([
'name' => 'VideoMetadata', 'name' => 'VideoMetadata',
'fields' => [ 'fields' => [
'lat' => Type::float(), 'lat' => Type::float(),
'lng' => Type::float() 'lng' => Type::float(),
] ],
]) ]),
]; ];
} },
]); ]);
$this->comment = new ObjectType([ $this->comment = new ObjectType([
'name' => 'Comment', 'name' => 'Comment',
'interfaces' => [ 'interfaces' => [
$this->node $this->node,
], ],
'fields' => function() { 'fields' => function () {
return [ return [
$this->node->getField('id'), 'id' => $this->node->getField('id'),
'author' => $this->user, 'author' => $this->user,
'text' => Type::string(), 'text' => Type::string(),
'replies' => Type::listOf($this->comment), 'replies' => Type::listOf($this->comment),
'parent' => $this->comment, 'parent' => $this->comment,
'content' => $this->content 'content' => $this->content,
]; ];
} },
]); ]);
$this->user = new ObjectType([ $this->user = new ObjectType([
'name' => 'User', 'name' => 'User',
'interfaces' => [ 'interfaces' => [
$this->node $this->node,
], ],
'fields' => function() { 'fields' => function () {
return [ return [
$this->node->getField('id'), 'id' => $this->node->getField('id'),
'name' => Type::string(), 'name' => Type::string(),
]; ];
} },
]); ]);
$this->category = new ObjectType([ $this->category = new ObjectType([
'name' => 'Category', 'name' => 'Category',
'interfaces' => [ 'interfaces' => [
$this->node $this->node,
], ],
'fields' => function() { 'fields' => function () {
return [ return [
$this->node->getField('id'), 'id' => $this->node->getField('id'),
'name' => Type::string() 'name' => Type::string(),
]; ];
} },
]); ]);
$this->mention = new UnionType([ $this->mention = new UnionType([
'name' => 'Mention', 'name' => 'Mention',
'types' => [ 'types' => [
$this->user, $this->user,
$this->category $this->category,
] ],
]); ]);
$this->query = new ObjectType([ $this->query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'viewer' => $this->user, 'viewer' => $this->user,
'latestContent' => $this->content, 'latestContent' => $this->content,
'node' => $this->node, 'node' => $this->node,
'mentions' => Type::listOf($this->mention) 'mentions' => Type::listOf($this->mention),
] ],
]);
$this->postStoryMutationInput = new InputObjectType([
'name' => 'PostStoryMutationInput',
'fields' => [
'title' => Type::string(),
'body' => Type::string(),
'author' => Type::id(),
'category' => Type::id(),
],
]); ]);
$this->mutation = new ObjectType([ $this->mutation = new ObjectType([
'name' => 'Mutation', 'name' => 'Mutation',
'fields' => [ 'fields' => [
'postStory' => [ 'postStory' => [
'type' => $this->postStoryMutation = new ObjectType([ 'type' => $this->postStoryMutation = new ObjectType([
'name' => 'PostStoryMutation', 'name' => 'PostStoryMutation',
'fields' => [ 'fields' => [
'story' => $this->blogStory 'story' => $this->blogStory,
] ],
]), ]),
'args' => [ 'args' => [
'input' => Type::nonNull($this->postStoryMutationInput = new InputObjectType([ 'input' => Type::nonNull($this->postStoryMutationInput),
'name' => 'PostStoryMutationInput', 'clientRequestId' => Type::string(),
'fields' => [ ],
'title' => Type::string(),
'body' => Type::string(),
'author' => Type::id(),
'category' => Type::id()
]
])),
'clientRequestId' => Type::string()
]
], ],
'postComment' => [ 'postComment' => [
'type' => $this->postCommentMutation = new ObjectType([ 'type' => $this->postCommentMutation = new ObjectType([
'name' => 'PostCommentMutation', 'name' => 'PostCommentMutation',
'fields' => [ 'fields' => [
'comment' => $this->comment 'comment' => $this->comment,
] ],
]), ]),
'args' => [ 'args' => [
'input' => Type::nonNull($this->postCommentMutationInput = new InputObjectType([ 'input' => Type::nonNull($this->postCommentMutationInput = new InputObjectType([
'name' => 'PostCommentMutationInput', 'name' => 'PostCommentMutationInput',
'fields' => [ 'fields' => [
'text' => Type::nonNull(Type::string()), 'text' => Type::nonNull(Type::string()),
'author' => Type::nonNull(Type::id()), 'author' => Type::nonNull(Type::id()),
'content' => Type::id(), 'content' => Type::id(),
'parent' => Type::id() 'parent' => Type::id(),
] ],
])), ])),
'clientRequestId' => Type::string() 'clientRequestId' => Type::string(),
] ],
] ],
] ],
]); ]);
} }
public function testExtractTypesFromQuery() : void public function testExtractTypesFromQuery() : void
{ {
$expectedTypeMap = [ $expectedTypeMap = [
'Query' => $this->query, 'Query' => $this->query,
'User' => $this->user, 'User' => $this->user,
'Node' => $this->node, 'Node' => $this->node,
'String' => Type::string(), 'String' => Type::string(),
'Content' => $this->content, 'Content' => $this->content,
'Comment' => $this->comment, 'Comment' => $this->comment,
'Mention' => $this->mention, 'Mention' => $this->mention,
'Category' => $this->category, 'Category' => $this->category,
]; ];
@ -294,19 +270,19 @@ class ExtractTypesTest extends TestCase
public function testExtractTypesFromMutation() : void public function testExtractTypesFromMutation() : void
{ {
$expectedTypeMap = [ $expectedTypeMap = [
'Mutation' => $this->mutation, 'Mutation' => $this->mutation,
'User' => $this->user, 'User' => $this->user,
'Node' => $this->node, 'Node' => $this->node,
'String' => Type::string(), 'String' => Type::string(),
'Content' => $this->content, 'Content' => $this->content,
'Comment' => $this->comment, 'Comment' => $this->comment,
'BlogStory' => $this->blogStory, 'BlogStory' => $this->blogStory,
'Category' => $this->category, 'Category' => $this->category,
'PostStoryMutationInput' => $this->postStoryMutationInput, 'PostStoryMutationInput' => $this->postStoryMutationInput,
'ID' => Type::id(), 'ID' => Type::id(),
'PostStoryMutation' => $this->postStoryMutation, 'PostStoryMutation' => $this->postStoryMutation,
'PostCommentMutationInput' => $this->postCommentMutationInput, 'PostCommentMutationInput' => $this->postCommentMutationInput,
'PostCommentMutation' => $this->postCommentMutation, 'PostCommentMutation' => $this->postCommentMutation,
]; ];
$actualTypeMap = TypeInfo::extractTypes($this->mutation); $actualTypeMap = TypeInfo::extractTypes($this->mutation);
@ -316,16 +292,16 @@ class ExtractTypesTest extends TestCase
public function testThrowsOnMultipleTypesWithSameName() : void public function testThrowsOnMultipleTypesWithSameName() : void
{ {
$otherUserType = new ObjectType([ $otherUserType = new ObjectType([
'name' => 'User', 'name' => 'User',
'fields' => ['a' => Type::string()] 'fields' => ['a' => Type::string()],
]); ]);
$queryType = new ObjectType([ $queryType = new ObjectType([
'name' => 'Test', 'name' => 'Test',
'fields' => [ 'fields' => [
'otherUser' => $otherUserType, 'otherUser' => $otherUserType,
'user' => $this->user 'user' => $this->user,
] ],
]); ]);
$this->expectException(InvariantViolation::class); $this->expectException(InvariantViolation::class);

5
tests/Utils/IsValidLiteralValueTest.php
View File

@ -1,17 +1,18 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Language\Parser; use GraphQL\Language\Parser;
use GraphQL\Language\SourceLocation; use GraphQL\Language\SourceLocation;
use GraphQL\Type\Definition\Type; use GraphQL\Type\Definition\Type;
use GraphQL\Utils\Utils;
use GraphQL\Validator\DocumentValidator; use GraphQL\Validator\DocumentValidator;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class IsValidLiteralValueTest extends TestCase class IsValidLiteralValueTest extends TestCase
{ {
// DESCRIBE: isValidLiteralValue // DESCRIBE: isValidLiteralValue
/** /**
* @see it('Returns no errors for a valid value') * @see it('Returns no errors for a valid value')
*/ */

85
tests/Utils/MixedStoreTest.php
View File

@ -1,16 +1,16 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Utils\Utils;
use GraphQL\Utils\MixedStore; use GraphQL\Utils\MixedStore;
use GraphQL\Utils\Utils;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class MixedStoreTest extends TestCase class MixedStoreTest extends TestCase
{ {
/** /** @var MixedStore */
* @var MixedStore
*/
private $mixedStore; private $mixedStore;
public function setUp() public function setUp()
@ -18,6 +18,13 @@ class MixedStoreTest extends TestCase
$this->mixedStore = new MixedStore(); $this->mixedStore = new MixedStore();
} }
public function testAcceptsNullKeys() : void
{
foreach ($this->getPossibleValues() as $value) {
$this->assertAcceptsKeyValue(null, $value);
}
}
public function getPossibleValues() public function getPossibleValues()
{ {
return [ return [
@ -30,16 +37,38 @@ class MixedStoreTest extends TestCase
'a', 'a',
[], [],
new \stdClass(), new \stdClass(),
function() {}, function () {
new MixedStore() },
new MixedStore(),
]; ];
} }
public function testAcceptsNullKeys() : void private function assertAcceptsKeyValue($key, $value)
{ {
foreach ($this->getPossibleValues() as $value) { $err = 'Failed assertion that MixedStore accepts key ' .
$this->assertAcceptsKeyValue(null, $value); Utils::printSafe($key) . ' with value ' . Utils::printSafe($value);
}
$this->assertFalse($this->mixedStore->offsetExists($key), $err);
$this->mixedStore->offsetSet($key, $value);
$this->assertTrue($this->mixedStore->offsetExists($key), $err);
$this->assertSame($value, $this->mixedStore->offsetGet($key), $err);
$this->mixedStore->offsetUnset($key);
$this->assertFalse($this->mixedStore->offsetExists($key), $err);
$this->assertProvidesArrayAccess($key, $value);
}
private function assertProvidesArrayAccess($key, $value)
{
$err = 'Failed assertion that MixedStore provides array access for key ' .
Utils::printSafe($key) . ' with value ' . Utils::printSafe($value);
$this->assertFalse(isset($this->mixedStore[$key]), $err);
$this->mixedStore[$key] = $value;
$this->assertTrue(isset($this->mixedStore[$key]), $err);
$this->assertEquals(! empty($value), ! empty($this->mixedStore[$key]), $err);
$this->assertSame($value, $this->mixedStore[$key], $err);
unset($this->mixedStore[$key]);
$this->assertFalse(isset($this->mixedStore[$key]), $err);
} }
public function testAcceptsBoolKeys() : void public function testAcceptsBoolKeys() : void
@ -93,35 +122,11 @@ class MixedStoreTest extends TestCase
foreach ($this->getPossibleValues() as $value) { foreach ($this->getPossibleValues() as $value) {
$this->assertAcceptsKeyValue(new \stdClass(), $value); $this->assertAcceptsKeyValue(new \stdClass(), $value);
$this->assertAcceptsKeyValue(new MixedStore(), $value); $this->assertAcceptsKeyValue(new MixedStore(), $value);
$this->assertAcceptsKeyValue(function() {}, $value); $this->assertAcceptsKeyValue(
function () {
},
$value
);
} }
} }
private function assertAcceptsKeyValue($key, $value)
{
$err = 'Failed assertion that MixedStore accepts key ' .
Utils::printSafe($key) . ' with value ' . Utils::printSafe($value);
$this->assertFalse($this->mixedStore->offsetExists($key), $err);
$this->mixedStore->offsetSet($key, $value);
$this->assertTrue($this->mixedStore->offsetExists($key), $err);
$this->assertSame($value, $this->mixedStore->offsetGet($key), $err);
$this->mixedStore->offsetUnset($key);
$this->assertFalse($this->mixedStore->offsetExists($key), $err);
$this->assertProvidesArrayAccess($key, $value);
}
private function assertProvidesArrayAccess($key, $value)
{
$err = 'Failed assertion that MixedStore provides array access for key ' .
Utils::printSafe($key) . ' with value ' . Utils::printSafe($value);
$this->assertFalse(isset($this->mixedStore[$key]), $err);
$this->mixedStore[$key] = $value;
$this->assertTrue(isset($this->mixedStore[$key]), $err);
$this->assertEquals(!empty($value), !empty($this->mixedStore[$key]), $err);
$this->assertSame($value, $this->mixedStore[$key], $err);
unset($this->mixedStore[$key]);
$this->assertFalse(isset($this->mixedStore[$key]), $err);
}
} }

7
tests/Utils/QuotedOrListTest.php
View File

@ -1,16 +1,15 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Executor\Values;
use GraphQL\Type\Definition\Type;
use GraphQL\Utils\Utils; use GraphQL\Utils\Utils;
use GraphQL\Utils\Value;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class QuotedOrListTest extends TestCase class QuotedOrListTest extends TestCase
{ {
// DESCRIBE: quotedOrList // DESCRIBE: quotedOrList
/** /**
* @see it('Does not accept an empty list') * @see it('Does not accept an empty list')
*/ */

450
tests/Utils/SchemaPrinterTest.php
View File

@ -1,16 +1,19 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Language\DirectiveLocation; use GraphQL\Language\DirectiveLocation;
use GraphQL\Type\Schema;
use GraphQL\Type\Definition\CustomScalarType; use GraphQL\Type\Definition\CustomScalarType;
use GraphQL\Type\Definition\Directive; use GraphQL\Type\Definition\Directive;
use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\InputObjectType; use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\InterfaceType; use GraphQL\Type\Definition\InterfaceType;
use GraphQL\Type\Definition\ObjectType; use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type; use GraphQL\Type\Definition\Type;
use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\UnionType; use GraphQL\Type\Definition\UnionType;
use GraphQL\Type\Schema;
use GraphQL\Utils\BuildSchema; use GraphQL\Utils\BuildSchema;
use GraphQL\Utils\SchemaPrinter; use GraphQL\Utils\SchemaPrinter;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
@ -19,37 +22,40 @@ class SchemaPrinterTest extends TestCase
{ {
// Describe: Type System Printer // Describe: Type System Printer
private function printForTest($schema)
{
$schemaText = SchemaPrinter::doPrint($schema);
$this->assertEquals($schemaText, SchemaPrinter::doPrint(BuildSchema::build($schemaText)));
return "\n" . $schemaText;
}
private function printSingleFieldSchema($fieldConfig)
{
$query = new ObjectType([
'name' => 'Query',
'fields' => [
'singleField' => $fieldConfig
]
]);
return $this->printForTest(new Schema(['query' => $query]));
}
/** /**
* @see it('Prints String Field') * @see it('Prints String Field')
*/ */
public function testPrintsStringField() : void public function testPrintsStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string() 'type' => Type::string(),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: String singleField: String
} }
', $output); ',
$output
);
}
private function printSingleFieldSchema($fieldConfig)
{
$query = new ObjectType([
'name' => 'Query',
'fields' => ['singleField' => $fieldConfig],
]);
return $this->printForTest(new Schema(['query' => $query]));
}
private function printForTest($schema)
{
$schemaText = SchemaPrinter::doPrint($schema);
$this->assertEquals($schemaText, SchemaPrinter::doPrint(BuildSchema::build($schemaText)));
return "\n" . $schemaText;
} }
/** /**
@ -58,13 +64,16 @@ type Query {
public function testPrintArrayStringField() : void public function testPrintArrayStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::listOf(Type::string()) 'type' => Type::listOf(Type::string()),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: [String] singleField: [String]
} }
', $output); ',
$output
);
} }
/** /**
@ -73,13 +82,16 @@ type Query {
public function testPrintNonNullStringField() : void public function testPrintNonNullStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::nonNull(Type::string()) 'type' => Type::nonNull(Type::string()),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: String! singleField: String!
} }
', $output); ',
$output
);
} }
/** /**
@ -88,13 +100,16 @@ type Query {
public function testPrintNonNullArrayStringField() : void public function testPrintNonNullArrayStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::nonNull(Type::listOf(Type::string())) 'type' => Type::nonNull(Type::listOf(Type::string())),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: [String]! singleField: [String]!
} }
', $output); ',
$output
);
} }
/** /**
@ -103,13 +118,16 @@ type Query {
public function testPrintArrayNonNullStringField() : void public function testPrintArrayNonNullStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::listOf(Type::nonNull(Type::string())) 'type' => Type::listOf(Type::nonNull(Type::string())),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: [String!] singleField: [String!]
} }
', $output); ',
$output
);
} }
/** /**
@ -118,13 +136,16 @@ type Query {
public function testPrintNonNullArrayNonNullStringField() : void public function testPrintNonNullArrayNonNullStringField() : void
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::nonNull(Type::listOf(Type::nonNull(Type::string()))) 'type' => Type::nonNull(Type::listOf(Type::nonNull(Type::string()))),
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField: [String!]! singleField: [String!]!
} }
', $output); ',
$output
);
} }
/** /**
@ -133,18 +154,19 @@ type Query {
public function testPrintObjectField() : void public function testPrintObjectField() : void
{ {
$fooType = new ObjectType([ $fooType = new ObjectType([
'name' => 'Foo', 'name' => 'Foo',
'fields' => ['str' => ['type' => Type::string()]] 'fields' => ['str' => ['type' => Type::string()]],
]); ]);
$root = new ObjectType([ $root = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => ['foo' => ['type' => $fooType]] 'fields' => ['foo' => ['type' => $fooType]],
]); ]);
$schema = new Schema(['query' => $root]); $schema = new Schema(['query' => $root]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
type Foo { type Foo {
str: String str: String
} }
@ -152,7 +174,9 @@ type Foo {
type Query { type Query {
foo: Foo foo: Foo
} }
', $output); ',
$output
);
} }
/** /**
@ -162,13 +186,16 @@ type Query {
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => Type::int()]] 'args' => ['argOne' => ['type' => Type::int()]],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int): String singleField(argOne: Int): String
} }
', $output); ',
$output
);
} }
/** /**
@ -178,13 +205,16 @@ type Query {
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => Type::int(), 'defaultValue' => 2]] 'args' => ['argOne' => ['type' => Type::int(), 'defaultValue' => 2]],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int = 2): String singleField(argOne: Int = 2): String
} }
', $output); ',
$output
);
} }
/** /**
@ -196,11 +226,14 @@ type Query {
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => Type::string(), 'defaultValue' => "tes\t de\fault"]], 'args' => ['argOne' => ['type' => Type::string(), 'defaultValue' => "tes\t de\fault"]],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: String = "tes\t de\fault"): String singleField(argOne: String = "tes\t de\fault"): String
} }
', $output); ',
$output
);
} }
/** /**
@ -210,13 +243,16 @@ type Query {
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => Type::int(), 'defaultValue' => null]] 'args' => ['argOne' => ['type' => Type::int(), 'defaultValue' => null]],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int = null): String singleField(argOne: Int = null): String
} }
', $output); ',
$output
);
} }
/** /**
@ -226,13 +262,16 @@ type Query {
{ {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => Type::nonNull(Type::int())]] 'args' => ['argOne' => ['type' => Type::nonNull(Type::int())]],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int!): String singleField(argOne: Int!): String
} }
', $output); ',
$output
);
} }
/** /**
@ -244,14 +283,17 @@ type Query {
'type' => Type::string(), 'type' => Type::string(),
'args' => [ 'args' => [
'argOne' => ['type' => Type::int()], 'argOne' => ['type' => Type::int()],
'argTwo' => ['type' => Type::string()] 'argTwo' => ['type' => Type::string()],
] ],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int, argTwo: String): String singleField(argOne: Int, argTwo: String): String
} }
', $output); ',
$output
);
} }
/** /**
@ -262,16 +304,19 @@ type Query {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => [ 'args' => [
'argOne' => ['type' => Type::int(), 'defaultValue' => 1], 'argOne' => ['type' => Type::int(), 'defaultValue' => 1],
'argTwo' => ['type' => Type::string()], 'argTwo' => ['type' => Type::string()],
'argThree' => ['type' => Type::boolean()] 'argThree' => ['type' => Type::boolean()],
] ],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int = 1, argTwo: String, argThree: Boolean): String singleField(argOne: Int = 1, argTwo: String, argThree: Boolean): String
} }
', $output); ',
$output
);
} }
/** /**
@ -282,16 +327,19 @@ type Query {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => [ 'args' => [
'argOne' => ['type' => Type::int()], 'argOne' => ['type' => Type::int()],
'argTwo' => ['type' => Type::string(), 'defaultValue' => 'foo'], 'argTwo' => ['type' => Type::string(), 'defaultValue' => 'foo'],
'argThree' => ['type' => Type::boolean()] 'argThree' => ['type' => Type::boolean()],
] ],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int, argTwo: String = "foo", argThree: Boolean): String singleField(argOne: Int, argTwo: String = "foo", argThree: Boolean): String
} }
', $output); ',
$output
);
} }
/** /**
@ -302,16 +350,19 @@ type Query {
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
'type' => Type::string(), 'type' => Type::string(),
'args' => [ 'args' => [
'argOne' => ['type' => Type::int()], 'argOne' => ['type' => Type::int()],
'argTwo' => ['type' => Type::string()], 'argTwo' => ['type' => Type::string()],
'argThree' => ['type' => Type::boolean(), 'defaultValue' => false] 'argThree' => ['type' => Type::boolean(), 'defaultValue' => false],
] ],
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
singleField(argOne: Int, argTwo: String, argThree: Boolean = false): String singleField(argOne: Int, argTwo: String, argThree: Boolean = false): String
} }
', $output); ',
$output
);
} }
/** /**
@ -320,14 +371,12 @@ type Query {
public function testPrintsCustomQueryRootType() : void public function testPrintsCustomQueryRootType() : void
{ {
$customQueryType = new ObjectType([ $customQueryType = new ObjectType([
'name' => 'CustomQueryType', 'name' => 'CustomQueryType',
'fields' => ['bar' => ['type' => Type::string()]], 'fields' => ['bar' => ['type' => Type::string()]],
]); ]);
$schema = new Schema([ $schema = new Schema(['query' => $customQueryType]);
'query' => $customQueryType, $output = $this->printForTest($schema);
]);
$output = $this->printForTest($schema);
$expected = ' $expected = '
schema { schema {
query: CustomQueryType query: CustomQueryType
@ -346,27 +395,28 @@ type CustomQueryType {
public function testPrintInterface() : void public function testPrintInterface() : void
{ {
$fooType = new InterfaceType([ $fooType = new InterfaceType([
'name' => 'Foo', 'name' => 'Foo',
'fields' => ['str' => ['type' => Type::string()]] 'fields' => ['str' => ['type' => Type::string()]],
]); ]);
$barType = new ObjectType([ $barType = new ObjectType([
'name' => 'Bar', 'name' => 'Bar',
'fields' => ['str' => ['type' => Type::string()]], 'fields' => ['str' => ['type' => Type::string()]],
'interfaces' => [$fooType] 'interfaces' => [$fooType],
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => ['bar' => ['type' => $barType]] 'fields' => ['bar' => ['type' => $barType]],
]); ]);
$schema = new Schema([ $schema = new Schema([
'query' => $query, 'query' => $query,
'types' => [$barType] 'types' => [$barType],
]); ]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
type Bar implements Foo { type Bar implements Foo {
str: String str: String
} }
@ -378,7 +428,9 @@ interface Foo {
type Query { type Query {
bar: Bar bar: Bar
} }
', $output); ',
$output
);
} }
/** /**
@ -387,35 +439,36 @@ type Query {
public function testPrintMultipleInterface() : void public function testPrintMultipleInterface() : void
{ {
$fooType = new InterfaceType([ $fooType = new InterfaceType([
'name' => 'Foo', 'name' => 'Foo',
'fields' => ['str' => ['type' => Type::string()]] 'fields' => ['str' => ['type' => Type::string()]],
]); ]);
$baazType = new InterfaceType([ $baazType = new InterfaceType([
'name' => 'Baaz', 'name' => 'Baaz',
'fields' => ['int' => ['type' => Type::int()]] 'fields' => ['int' => ['type' => Type::int()]],
]); ]);
$barType = new ObjectType([ $barType = new ObjectType([
'name' => 'Bar', 'name' => 'Bar',
'fields' => [ 'fields' => [
'str' => ['type' => Type::string()], 'str' => ['type' => Type::string()],
'int' => ['type' => Type::int()] 'int' => ['type' => Type::int()],
], ],
'interfaces' => [$fooType, $baazType] 'interfaces' => [$fooType, $baazType],
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => ['bar' => ['type' => $barType]] 'fields' => ['bar' => ['type' => $barType]],
]); ]);
$schema = new Schema([ $schema = new Schema([
'query' => $query, 'query' => $query,
'types' => [$barType] 'types' => [$barType],
]); ]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
interface Baaz { interface Baaz {
int: Int int: Int
} }
@ -432,7 +485,9 @@ interface Foo {
type Query { type Query {
bar: Bar bar: Bar
} }
', $output); ',
$output
);
} }
/** /**
@ -441,36 +496,37 @@ type Query {
public function testPrintUnions() : void public function testPrintUnions() : void
{ {
$fooType = new ObjectType([ $fooType = new ObjectType([
'name' => 'Foo', 'name' => 'Foo',
'fields' => ['bool' => ['type' => Type::boolean()]] 'fields' => ['bool' => ['type' => Type::boolean()]],
]); ]);
$barType = new ObjectType([ $barType = new ObjectType([
'name' => 'Bar', 'name' => 'Bar',
'fields' => ['str' => ['type' => Type::string()]] 'fields' => ['str' => ['type' => Type::string()]],
]); ]);
$singleUnion = new UnionType([ $singleUnion = new UnionType([
'name' => 'SingleUnion', 'name' => 'SingleUnion',
'types' => [$fooType] 'types' => [$fooType],
]); ]);
$multipleUnion = new UnionType([ $multipleUnion = new UnionType([
'name' => 'MultipleUnion', 'name' => 'MultipleUnion',
'types' => [$fooType, $barType] 'types' => [$fooType, $barType],
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'single' => ['type' => $singleUnion], 'single' => ['type' => $singleUnion],
'multiple' => ['type' => $multipleUnion] 'multiple' => ['type' => $multipleUnion],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
type Bar { type Bar {
str: String str: String
} }
@ -487,7 +543,9 @@ type Query {
} }
union SingleUnion = Foo union SingleUnion = Foo
', $output); ',
$output
);
} }
/** /**
@ -496,23 +554,24 @@ union SingleUnion = Foo
public function testInputType() : void public function testInputType() : void
{ {
$inputType = new InputObjectType([ $inputType = new InputObjectType([
'name' => 'InputType', 'name' => 'InputType',
'fields' => ['int' => ['type' => Type::int()]] 'fields' => ['int' => ['type' => Type::int()]],
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'str' => [ 'str' => [
'type' => Type::string(), 'type' => Type::string(),
'args' => ['argOne' => ['type' => $inputType]] 'args' => ['argOne' => ['type' => $inputType]],
] ],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
input InputType { input InputType {
int: Int int: Int
} }
@ -520,7 +579,9 @@ input InputType {
type Query { type Query {
str(argOne: InputType): String str(argOne: InputType): String
} }
', $output); ',
$output
);
} }
/** /**
@ -529,28 +590,31 @@ type Query {
public function testCustomScalar() : void public function testCustomScalar() : void
{ {
$oddType = new CustomScalarType([ $oddType = new CustomScalarType([
'name' => 'Odd', 'name' => 'Odd',
'serialize' => function($value) { 'serialize' => function ($value) {
return $value % 2 === 1 ? $value : null; return $value % 2 === 1 ? $value : null;
} },
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'odd' => ['type' => $oddType] 'odd' => ['type' => $oddType],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
scalar Odd scalar Odd
type Query { type Query {
odd: Odd odd: Odd
} }
', $output); ',
$output
);
} }
/** /**
@ -559,24 +623,25 @@ type Query {
public function testEnum() : void public function testEnum() : void
{ {
$RGBType = new EnumType([ $RGBType = new EnumType([
'name' => 'RGB', 'name' => 'RGB',
'values' => [ 'values' => [
'RED' => ['value' => 0], 'RED' => ['value' => 0],
'GREEN' => ['value' => 1], 'GREEN' => ['value' => 1],
'BLUE' => ['value' => 2] 'BLUE' => ['value' => 2],
] ],
]); ]);
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'rgb' => ['type' => $RGBType] 'rgb' => ['type' => $RGBType],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
rgb: RGB rgb: RGB
} }
@ -586,7 +651,9 @@ enum RGB {
GREEN GREEN
BLUE BLUE
} }
', $output); ',
$output
);
} }
/** /**
@ -595,32 +662,35 @@ enum RGB {
public function testPrintsCustomDirectives() : void public function testPrintsCustomDirectives() : void
{ {
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'field' => ['type' => Type::string()], 'field' => ['type' => Type::string()],
] ],
]); ]);
$customDirectives = new Directive([ $customDirectives = new Directive([
'name' => 'customDirective', 'name' => 'customDirective',
'locations' => [ 'locations' => [
DirectiveLocation::FIELD DirectiveLocation::FIELD,
] ],
]); ]);
$schema = new Schema([ $schema = new Schema([
'query' => $query, 'query' => $query,
'directives' => [$customDirectives], 'directives' => [$customDirectives],
]); ]);
$output = $this->printForTest($schema); $output = $this->printForTest($schema);
$this->assertEquals(' $this->assertEquals(
'
directive @customDirective on FIELD directive @customDirective on FIELD
type Query { type Query {
field: String field: String
} }
', $output); ',
$output
);
} }
/** /**
@ -629,19 +699,22 @@ type Query {
public function testOneLinePrintsAShortDescription() : void public function testOneLinePrintsAShortDescription() : void
{ {
$description = 'This field is awesome'; $description = 'This field is awesome';
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
"type" => Type::string(), 'type' => Type::string(),
"description" => $description 'description' => $description,
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
"""This field is awesome""" """This field is awesome"""
singleField: String singleField: String
} }
', $output); ',
$output
);
$recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query']; $recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query'];
$recreatedField = $recreatedRoot->getFields()['singleField']; $recreatedField = $recreatedRoot->getFields()['singleField'];
$this->assertEquals($description, $recreatedField->description); $this->assertEquals($description, $recreatedField->description);
} }
@ -652,21 +725,24 @@ type Query {
public function testDoesNotOneLinePrintADescriptionThatEndsWithAQuote() : void public function testDoesNotOneLinePrintADescriptionThatEndsWithAQuote() : void
{ {
$description = 'This field is "awesome"'; $description = 'This field is "awesome"';
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
"type" => Type::string(), 'type' => Type::string(),
"description" => $description 'description' => $description,
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
""" """
This field is "awesome" This field is "awesome"
""" """
singleField: String singleField: String
} }
', $output); ',
$output
);
$recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query']; $recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query'];
$recreatedField = $recreatedRoot->getFields()['singleField']; $recreatedField = $recreatedRoot->getFields()['singleField'];
$this->assertEquals($description, $recreatedField->description); $this->assertEquals($description, $recreatedField->description);
} }
@ -677,20 +753,23 @@ type Query {
public function testPReservesLeadingSpacesWhenPrintingADescription() : void public function testPReservesLeadingSpacesWhenPrintingADescription() : void
{ {
$description = ' This field is "awesome"'; $description = ' This field is "awesome"';
$output = $this->printSingleFieldSchema([ $output = $this->printSingleFieldSchema([
"type" => Type::string(), 'type' => Type::string(),
"description" => $description 'description' => $description,
]); ]);
$this->assertEquals(' $this->assertEquals(
'
type Query { type Query {
""" This field is "awesome" """ This field is "awesome"
""" """
singleField: String singleField: String
} }
', $output); ',
$output
);
$recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query']; $recreatedRoot = BuildSchema::build($output)->getTypeMap()['Query'];
$recreatedField = $recreatedRoot->getFields()['singleField']; $recreatedField = $recreatedRoot->getFields()['singleField'];
$this->assertEquals($description, $recreatedField->description); $this->assertEquals($description, $recreatedField->description);
} }
@ -701,14 +780,14 @@ type Query {
public function testPrintIntrospectionSchema() : void public function testPrintIntrospectionSchema() : void
{ {
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'onlyField' => ['type' => Type::string()] 'onlyField' => ['type' => Type::string()],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = SchemaPrinter::printIntrosepctionSchema($schema); $output = SchemaPrinter::printIntrosepctionSchema($schema);
$introspectionSchema = <<<'EOT' $introspectionSchema = <<<'EOT'
""" """
Directs the executor to include this field or fragment only when the `if` argument is true. Directs the executor to include this field or fragment only when the `if` argument is true.
@ -946,16 +1025,17 @@ EOT;
public function testPrintIntrospectionSchemaWithCommentDescriptions() : void public function testPrintIntrospectionSchemaWithCommentDescriptions() : void
{ {
$query = new ObjectType([ $query = new ObjectType([
'name' => 'Query', 'name' => 'Query',
'fields' => [ 'fields' => [
'onlyField' => ['type' => Type::string()] 'onlyField' => ['type' => Type::string()],
] ],
]); ]);
$schema = new Schema(['query' => $query]); $schema = new Schema(['query' => $query]);
$output = SchemaPrinter::printIntrosepctionSchema($schema, [ $output = SchemaPrinter::printIntrosepctionSchema(
'commentDescriptions' => true $schema,
]); ['commentDescriptions' => true]
);
$introspectionSchema = <<<'EOT' $introspectionSchema = <<<'EOT'
# Directs the executor to include this field or fragment only when the `if` argument is true. # Directs the executor to include this field or fragment only when the `if` argument is true.
directive @include( directive @include(

7
tests/Utils/SuggestionListTest.php
View File

@ -1,16 +1,15 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Executor\Values;
use GraphQL\Type\Definition\Type;
use GraphQL\Utils\Utils; use GraphQL\Utils\Utils;
use GraphQL\Utils\Value;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class SuggestionListTest extends TestCase class SuggestionListTest extends TestCase
{ {
// DESCRIBE: suggestionList // DESCRIBE: suggestionList
/** /**
* @see it('Returns results when input is empty') * @see it('Returns results when input is empty')
*/ */

119
tests/Utils/ValueFromAstTest.php
View File

@ -1,26 +1,21 @@
<?php <?php
declare(strict_types=1);
namespace GraphQL\Tests\Utils; namespace GraphQL\Tests\Utils;
use GraphQL\Language\AST\NullValueNode;
use GraphQL\Language\Parser; use GraphQL\Language\Parser;
use GraphQL\Type\Definition\EnumType; use GraphQL\Type\Definition\EnumType;
use GraphQL\Type\Definition\InputObjectType; use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\Type; use GraphQL\Type\Definition\Type;
use GraphQL\Utils\Utils;
use GraphQL\Utils\AST; use GraphQL\Utils\AST;
use GraphQL\Utils\Utils;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
class ValueFromAstTest extends TestCase class ValueFromAstTest extends TestCase
{ {
private function runTestCase($type, $valueText, $expected) /** @var InputObjectType */
{ private $inputObj;
$this->assertEquals($expected, AST::valueFromAST(Parser::parseValue($valueText), $type));
}
private function runTestCaseWithVars($variables, $type, $valueText, $expected)
{
$this->assertEquals($expected, AST::valueFromAST(Parser::parseValue($valueText), $type, $variables));
}
/** /**
* @see it('rejects empty input') * @see it('rejects empty input')
@ -45,6 +40,11 @@ class ValueFromAstTest extends TestCase
$this->runTestCase(Type::id(), '"123456"', '123456'); $this->runTestCase(Type::id(), '"123456"', '123456');
} }
private function runTestCase($type, $valueText, $expected)
{
$this->assertEquals($expected, AST::valueFromAST(Parser::parseValue($valueText), $type));
}
/** /**
* @see it('does not convert when input coercion rules reject a value') * @see it('does not convert when input coercion rules reject a value')
*/ */
@ -68,13 +68,13 @@ class ValueFromAstTest extends TestCase
public function testConvertsEnumValuesAccordingToInputCoercionRules() : void public function testConvertsEnumValuesAccordingToInputCoercionRules() : void
{ {
$testEnum = new EnumType([ $testEnum = new EnumType([
'name' => 'TestColor', 'name' => 'TestColor',
'values' => [ 'values' => [
'RED' => ['value' => 1], 'RED' => ['value' => 1],
'GREEN' => ['value' => 2], 'GREEN' => ['value' => 2],
'BLUE' => ['value' => 3], 'BLUE' => ['value' => 3],
'NULL' => ['value' => null], 'NULL' => ['value' => null],
] ],
]); ]);
$this->runTestCase($testEnum, 'RED', 1); $this->runTestCase($testEnum, 'RED', 1);
@ -100,14 +100,14 @@ class ValueFromAstTest extends TestCase
public function testCoercesListsOfValues() : void public function testCoercesListsOfValues() : void
{ {
$listOfBool = Type::listOf(Type::boolean()); $listOfBool = Type::listOf(Type::boolean());
$undefined = Utils::undefined(); $undefined = Utils::undefined();
$this->runTestCase($listOfBool, 'true', [ true ]); $this->runTestCase($listOfBool, 'true', [true]);
$this->runTestCase($listOfBool, '123', $undefined); $this->runTestCase($listOfBool, '123', $undefined);
$this->runTestCase($listOfBool, 'null', null); $this->runTestCase($listOfBool, 'null', null);
$this->runTestCase($listOfBool, '[true, false]', [ true, false ]); $this->runTestCase($listOfBool, '[true, false]', [true, false]);
$this->runTestCase($listOfBool, '[true, 123]', $undefined); $this->runTestCase($listOfBool, '[true, 123]', $undefined);
$this->runTestCase($listOfBool, '[true, null]', [ true, null ]); $this->runTestCase($listOfBool, '[true, null]', [true, null]);
$this->runTestCase($listOfBool, '{ true: true }', $undefined); $this->runTestCase($listOfBool, '{ true: true }', $undefined);
} }
@ -117,14 +117,14 @@ class ValueFromAstTest extends TestCase
public function testCoercesNonNullListsOfValues() : void public function testCoercesNonNullListsOfValues() : void
{ {
$nonNullListOfBool = Type::nonNull(Type::listOf(Type::boolean())); $nonNullListOfBool = Type::nonNull(Type::listOf(Type::boolean()));
$undefined = Utils::undefined(); $undefined = Utils::undefined();
$this->runTestCase($nonNullListOfBool, 'true', [ true ]); $this->runTestCase($nonNullListOfBool, 'true', [true]);
$this->runTestCase($nonNullListOfBool, '123', $undefined); $this->runTestCase($nonNullListOfBool, '123', $undefined);
$this->runTestCase($nonNullListOfBool, 'null', $undefined); $this->runTestCase($nonNullListOfBool, 'null', $undefined);
$this->runTestCase($nonNullListOfBool, '[true, false]', [ true, false ]); $this->runTestCase($nonNullListOfBool, '[true, false]', [true, false]);
$this->runTestCase($nonNullListOfBool, '[true, 123]', $undefined); $this->runTestCase($nonNullListOfBool, '[true, 123]', $undefined);
$this->runTestCase($nonNullListOfBool, '[true, null]', [ true, null ]); $this->runTestCase($nonNullListOfBool, '[true, null]', [true, null]);
} }
/** /**
@ -133,12 +133,12 @@ class ValueFromAstTest extends TestCase
public function testCoercesListsOfNonNullValues() : void public function testCoercesListsOfNonNullValues() : void
{ {
$listOfNonNullBool = Type::listOf(Type::nonNull(Type::boolean())); $listOfNonNullBool = Type::listOf(Type::nonNull(Type::boolean()));
$undefined = Utils::undefined(); $undefined = Utils::undefined();
$this->runTestCase($listOfNonNullBool, 'true', [ true ]); $this->runTestCase($listOfNonNullBool, 'true', [true]);
$this->runTestCase($listOfNonNullBool, '123', $undefined); $this->runTestCase($listOfNonNullBool, '123', $undefined);
$this->runTestCase($listOfNonNullBool, 'null', null); $this->runTestCase($listOfNonNullBool, 'null', null);
$this->runTestCase($listOfNonNullBool, '[true, false]', [ true, false ]); $this->runTestCase($listOfNonNullBool, '[true, false]', [true, false]);
$this->runTestCase($listOfNonNullBool, '[true, 123]', $undefined); $this->runTestCase($listOfNonNullBool, '[true, 123]', $undefined);
$this->runTestCase($listOfNonNullBool, '[true, null]', $undefined); $this->runTestCase($listOfNonNullBool, '[true, null]', $undefined);
} }
@ -149,56 +149,63 @@ class ValueFromAstTest extends TestCase
public function testCoercesNonNullListsOfNonNullValues() : void public function testCoercesNonNullListsOfNonNullValues() : void
{ {
$nonNullListOfNonNullBool = Type::nonNull(Type::listOf(Type::nonNull(Type::boolean()))); $nonNullListOfNonNullBool = Type::nonNull(Type::listOf(Type::nonNull(Type::boolean())));
$undefined = Utils::undefined(); $undefined = Utils::undefined();
$this->runTestCase($nonNullListOfNonNullBool, 'true', [ true ]); $this->runTestCase($nonNullListOfNonNullBool, 'true', [true]);
$this->runTestCase($nonNullListOfNonNullBool, '123', $undefined); $this->runTestCase($nonNullListOfNonNullBool, '123', $undefined);
$this->runTestCase($nonNullListOfNonNullBool, 'null', $undefined); $this->runTestCase($nonNullListOfNonNullBool, 'null', $undefined);
$this->runTestCase($nonNullListOfNonNullBool, '[true, false]', [ true, false ]); $this->runTestCase($nonNullListOfNonNullBool, '[true, false]', [true, false]);
$this->runTestCase($nonNullListOfNonNullBool, '[true, 123]', $undefined); $this->runTestCase($nonNullListOfNonNullBool, '[true, 123]', $undefined);
$this->runTestCase($nonNullListOfNonNullBool, '[true, null]', $undefined); $this->runTestCase($nonNullListOfNonNullBool, '[true, null]', $undefined);
} }
private $inputObj;
private function inputObj()
{
return $this->inputObj ?: $this->inputObj = new InputObjectType([
'name' => 'TestInput',
'fields' => [
'int' => [ 'type' => Type::int(), 'defaultValue' => 42 ],
'bool' => [ 'type' => Type::boolean() ],
'requiredBool' => [ 'type' => Type::nonNull(Type::boolean()) ],
]
]);
}
/** /**
* @see it('coerces input objects according to input coercion rules') * @see it('coerces input objects according to input coercion rules')
*/ */
public function testCoercesInputObjectsAccordingToInputCoercionRules() : void public function testCoercesInputObjectsAccordingToInputCoercionRules() : void
{ {
$testInputObj = $this->inputObj(); $testInputObj = $this->inputObj();
$undefined = Utils::undefined(); $undefined = Utils::undefined();
$this->runTestCase($testInputObj, 'null', null); $this->runTestCase($testInputObj, 'null', null);
$this->runTestCase($testInputObj, '123', $undefined); $this->runTestCase($testInputObj, '123', $undefined);
$this->runTestCase($testInputObj, '[]', $undefined); $this->runTestCase($testInputObj, '[]', $undefined);
$this->runTestCase($testInputObj, '{ int: 123, requiredBool: false }', ['int' => 123, 'requiredBool' => false]); $this->runTestCase($testInputObj, '{ int: 123, requiredBool: false }', ['int' => 123, 'requiredBool' => false]);
$this->runTestCase($testInputObj, '{ bool: true, requiredBool: false }', [ 'int' => 42, 'bool' => true, 'requiredBool' => false ]); $this->runTestCase(
$testInputObj,
'{ bool: true, requiredBool: false }',
['int' => 42, 'bool' => true, 'requiredBool' => false]
);
$this->runTestCase($testInputObj, '{ int: true, requiredBool: true }', $undefined); $this->runTestCase($testInputObj, '{ int: true, requiredBool: true }', $undefined);
$this->runTestCase($testInputObj, '{ requiredBool: null }', $undefined); $this->runTestCase($testInputObj, '{ requiredBool: null }', $undefined);
$this->runTestCase($testInputObj, '{ bool: true }', $undefined); $this->runTestCase($testInputObj, '{ bool: true }', $undefined);
} }
private function inputObj()
{
return $this->inputObj ?: $this->inputObj = new InputObjectType([
'name' => 'TestInput',
'fields' => [
'int' => ['type' => Type::int(), 'defaultValue' => 42],
'bool' => ['type' => Type::boolean()],
'requiredBool' => ['type' => Type::nonNull(Type::boolean())],
],
]);
}
/** /**
* @see it('accepts variable values assuming already coerced') * @see it('accepts variable values assuming already coerced')
*/ */
public function testAcceptsVariableValuesAssumingAlreadyCoerced() : void public function testAcceptsVariableValuesAssumingAlreadyCoerced() : void
{ {
$this->runTestCaseWithVars([], Type::boolean(), '$var', Utils::undefined()); $this->runTestCaseWithVars([], Type::boolean(), '$var', Utils::undefined());
$this->runTestCaseWithVars([ 'var' => true ], Type::boolean(), '$var', true); $this->runTestCaseWithVars(['var' => true], Type::boolean(), '$var', true);
$this->runTestCaseWithVars([ 'var' => null ], Type::boolean(), '$var', null); $this->runTestCaseWithVars(['var' => null], Type::boolean(), '$var', null);
}
private function runTestCaseWithVars($variables, $type, $valueText, $expected)
{
$this->assertEquals($expected, AST::valueFromAST(Parser::parseValue($valueText), $type, $variables));
} }
/** /**
@ -206,16 +213,16 @@ class ValueFromAstTest extends TestCase
*/ */
public function testAssertsVariablesAreProvidedAsItemsInLists() : void public function testAssertsVariablesAreProvidedAsItemsInLists() : void
{ {
$listOfBool = Type::listOf(Type::boolean()); $listOfBool = Type::listOf(Type::boolean());
$listOfNonNullBool = Type::listOf(Type::nonNull(Type::boolean())); $listOfNonNullBool = Type::listOf(Type::nonNull(Type::boolean()));
$this->runTestCaseWithVars([], $listOfBool, '[ $foo ]', [ null ]); $this->runTestCaseWithVars([], $listOfBool, '[ $foo ]', [null]);
$this->runTestCaseWithVars([], $listOfNonNullBool, '[ $foo ]', Utils::undefined()); $this->runTestCaseWithVars([], $listOfNonNullBool, '[ $foo ]', Utils::undefined());
$this->runTestCaseWithVars([ 'foo' => true ], $listOfNonNullBool, '[ $foo ]', [ true ]); $this->runTestCaseWithVars(['foo' => true], $listOfNonNullBool, '[ $foo ]', [true]);
// Note: variables are expected to have already been coerced, so we // Note: variables are expected to have already been coerced, so we
// do not expect the singleton wrapping behavior for variables. // do not expect the singleton wrapping behavior for variables.
$this->runTestCaseWithVars([ 'foo' => true ], $listOfNonNullBool, '$foo', true); $this->runTestCaseWithVars(['foo' => true], $listOfNonNullBool, '$foo', true);
$this->runTestCaseWithVars([ 'foo' => [ true ] ], $listOfNonNullBool, '$foo', [ true ]); $this->runTestCaseWithVars(['foo' => [true]], $listOfNonNullBool, '$foo', [true]);
} }
/** /**
@ -229,7 +236,7 @@ class ValueFromAstTest extends TestCase
[], [],
$testInputObj, $testInputObj,
'{ int: $foo, bool: $foo, requiredBool: true }', '{ int: $foo, bool: $foo, requiredBool: true }',
[ 'int' => 42, 'requiredBool' => true ] ['int' => 42, 'requiredBool' => true]
); );
$this->runTestCaseWithVars( $this->runTestCaseWithVars(
[], [],
@ -238,10 +245,10 @@ class ValueFromAstTest extends TestCase
Utils::undefined() Utils::undefined()
); );
$this->runTestCaseWithVars( $this->runTestCaseWithVars(
[ 'foo' => true ], ['foo' => true],
$testInputObj, $testInputObj,
'{ requiredBool: $foo }', '{ requiredBool: $foo }',
[ 'int' => 42, 'requiredBool' => true ] ['int' => 42, 'requiredBool' => true]
); );
} }
} }