RetailCRM-Mirror/graphql-php
1
0
Fork 0
mirror of https://github.com/retailcrm/graphql-php.git synced 2024-11-22 12:56: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')
*/ */

221
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,92 +147,6 @@ class AstFromValueTest extends TestCase
$this->assertEquals(null, AST::astFromValue('VALUE', $this->myEnum())); $this->assertEquals(null, AST::astFromValue('VALUE', $this->myEnum()));
} }
/**
* @see it('converts array values to List ASTs')
*/
public function testConvertsArrayValuesToListASTs() : void
{
$value1 = new ListValueNode([
'values' => [
new StringValueNode(['value' => 'FOO']),
new StringValueNode(['value' => 'BAR'])
]
]);
$this->assertEquals($value1, AST::astFromValue(['FOO', 'BAR'], Type::listOf(Type::string())));
$value2 = new ListValueNode([
'values' => [
new EnumValueNode(['value' => 'HELLO']),
new EnumValueNode(['value' => 'GOODBYE']),
]
]);
$this->assertEquals($value2, AST::astFromValue(['HELLO', 'GOODBYE'], Type::listOf($this->myEnum())));
}
/**
* @see it('converts list singletons')
*/
public function testConvertsListSingletons() : void
{
$this->assertEquals(new StringValueNode(['value' => 'FOO']), AST::astFromValue('FOO', Type::listOf(Type::string())));
}
/**
* @see it('converts input objects')
*/
public function testConvertsInputObjects() : void
{
$inputObj = new InputObjectType([
'name' => 'MyInputObj',
'fields' => [
'foo' => Type::float(),
'bar' => $this->myEnum()
]
]);
$expected = new ObjectValueNode([
'fields' => [
$this->objectField('foo', new IntValueNode(['value' => '3'])),
$this->objectField('bar', new EnumValueNode(['value' => 'HELLO']))
]
]);
$data = ['foo' => 3, 'bar' => 'HELLO'];
$this->assertEquals($expected, AST::astFromValue($data, $inputObj));
$this->assertEquals($expected, AST::astFromValue((object) $data, $inputObj));
}
/**
* @see it('converts input objects with explicit nulls')
*/
public function testConvertsInputObjectsWithExplicitNulls() : void
{
$inputObj = new InputObjectType([
'name' => 'MyInputObj',
'fields' => [
'foo' => Type::float(),
'bar' => $this->myEnum()
]
]);
$this->assertEquals(new ObjectValueNode([
'fields' => [
$this->objectField('foo', new NullValueNode([]))
]
]), 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 * @return EnumType
*/ */
@ -226,21 +157,111 @@ class AstFromValueTest extends TestCase
'values' => [ 'values' => [
'HELLO' => [], 'HELLO' => [],
'GOODBYE' => [], 'GOODBYE' => [],
'COMPLEX' => ['value' => $this->complexValue()] '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')
*/
public function testConvertsArrayValuesToListASTs() : void
{
$value1 = new ListValueNode([
'values' => [
new StringValueNode(['value' => 'FOO']),
new StringValueNode(['value' => 'BAR']),
],
]);
$this->assertEquals($value1, AST::astFromValue(['FOO', 'BAR'], Type::listOf(Type::string())));
$value2 = new ListValueNode([
'values' => [
new EnumValueNode(['value' => 'HELLO']),
new EnumValueNode(['value' => 'GOODBYE']),
],
]);
$this->assertEquals($value2, AST::astFromValue(['HELLO', 'GOODBYE'], Type::listOf($this->myEnum())));
}
/**
* @see it('converts list singletons')
*/
public function testConvertsListSingletons() : void
{
$this->assertEquals(
new StringValueNode(['value' => 'FOO']),
AST::astFromValue('FOO', Type::listOf(Type::string()))
);
}
/**
* @see it('converts input objects')
*/
public function testConvertsInputObjects() : void
{
$inputObj = new InputObjectType([
'name' => 'MyInputObj',
'fields' => [
'foo' => Type::float(),
'bar' => $this->myEnum(),
],
]);
$expected = new ObjectValueNode([
'fields' => [
$this->objectField('foo', new IntValueNode(['value' => '3'])),
$this->objectField('bar', new EnumValueNode(['value' => 'HELLO'])),
],
]);
$data = ['foo' => 3, 'bar' => 'HELLO'];
$this->assertEquals($expected, AST::astFromValue($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,
]); ]);
} }
/** /**
* @param $name * @see it('converts input objects with explicit nulls')
* @param $value
* @return ObjectFieldNode
*/ */
private function objectField($name, $value) public function testConvertsInputObjectsWithExplicitNulls() : void
{ {
return new ObjectFieldNode([ $inputObj = new InputObjectType([
'name' => new NameNode(['value' => $name]), 'name' => 'MyInputObj',
'value' => $value 'fields' => [
'foo' => Type::float(),
'bar' => $this->myEnum(),
],
]); ]);
$this->assertEquals(
new ObjectValueNode([
'fields' => [
$this->objectField('foo', new NullValueNode([])),
],
]),
AST::astFromValue(['foo' => null], $inputObj)
);
} }
} }

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')
*/ */

583
tests/Utils/BreakingChangesFinderTest.php
View File

File diff suppressed because it is too large Load Diff

73
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(
@ -84,6 +82,14 @@ 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')
*/ */
@ -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);
} }
@ -467,16 +473,16 @@ type WorldTwo {
[ [
'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);
@ -531,16 +537,16 @@ type WorldTwo {
'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);
@ -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));
} }
@ -1184,9 +1196,10 @@ interface Hello {
$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, 'RED' => $enumValue,
'GREEN' => $enumValue, 'GREEN' => $enumValue,
'BLUE' => $enumValue, 'BLUE' => $enumValue,
], $defaultConfig['values']); ],
$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);
@ -1261,8 +1276,9 @@ type World implements Hello {
$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);
} }
} }

71
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,7 +13,10 @@ 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()
@ -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.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.bar; Int cannot represent non 32-bit signed integer value: def',
], $result['errors']); ],
$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']);
}
} }

210
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,72 +15,43 @@ 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()
@ -85,136 +59,136 @@ class ExtractTypesTest extends TestCase
$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 [ return [
$this->node->getField('id'), $this->node->getField('id'),
$this->content->getField('title'), $this->content->getField('title'),
$this->content->getField('body'), $this->content->getField('body'),
$this->content->getField('author'), $this->content->getField('author'),
$this->content->getField('comments'), $this->content->getField('comments'),
$this->content->getField('categories') $this->content->getField('categories'),
]; ];
}, },
]); ]);
$this->link = new ObjectType([ new ObjectType([
'name' => 'Link', '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'),
'url' => Type::string() 'url' => Type::string(),
]; ];
}, },
]); ]);
$this->video = new ObjectType([ new ObjectType([
'name' => 'Video', 'name' => 'Video',
'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(), '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([
@ -223,8 +197,18 @@ class ExtractTypesTest extends TestCase
'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([
@ -234,28 +218,20 @@ class ExtractTypesTest extends TestCase
'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([
@ -264,13 +240,13 @@ class ExtractTypesTest extends TestCase
'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(),
] ],
] ],
] ],
]); ]);
} }
@ -317,15 +293,15 @@ class ExtractTypesTest extends TestCase
{ {
$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')
*/ */

83
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')
*/ */

358
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
);
} }
/** /**
@ -134,17 +155,18 @@ type Query {
{ {
$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
);
} }
/** /**
@ -264,14 +306,17 @@ type Query {
'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
);
} }
/** /**
@ -284,14 +329,17 @@ type Query {
'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
);
} }
/** /**
@ -304,14 +352,17 @@ type Query {
'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
);
} }
/** /**
@ -324,9 +375,7 @@ type Query {
'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 {
@ -347,26 +396,27 @@ type CustomQueryType {
{ {
$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
);
} }
/** /**
@ -388,34 +440,35 @@ type Query {
{ {
$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
);
} }
/** /**
@ -442,35 +497,36 @@ type Query {
{ {
$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
);
} }
/** /**
@ -497,7 +555,7 @@ union SingleUnion = Foo
{ {
$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([
@ -505,14 +563,15 @@ union SingleUnion = Foo
'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
);
} }
/** /**
@ -530,27 +591,30 @@ type Query {
{ {
$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
);
} }
/** /**
@ -563,20 +627,21 @@ type Query {
'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
);
} }
/** /**
@ -598,14 +665,14 @@ enum RGB {
'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([
@ -614,13 +681,16 @@ enum RGB {
]); ]);
$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
);
} }
/** /**
@ -630,16 +700,19 @@ type Query {
{ {
$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'];
@ -653,18 +726,21 @@ type Query {
{ {
$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'];
@ -678,17 +754,20 @@ type Query {
{ {
$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'];
@ -703,8 +782,8 @@ type Query {
$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]);
@ -948,14 +1027,15 @@ EOT;
$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')
*/ */

99
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')
*/ */
@ -74,7 +74,7 @@ class ValueFromAstTest extends TestCase
'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);
@ -102,12 +102,12 @@ class ValueFromAstTest extends TestCase
$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);
} }
@ -119,12 +119,12 @@ class ValueFromAstTest extends TestCase
$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]);
} }
/** /**
@ -135,10 +135,10 @@ class ValueFromAstTest extends TestCase
$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);
} }
@ -151,28 +151,14 @@ class ValueFromAstTest extends TestCase
$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')
*/ */
@ -185,20 +171,41 @@ class ValueFromAstTest extends TestCase
$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));
} }
/** /**
@ -209,13 +216,13 @@ class ValueFromAstTest extends TestCase
$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]
); );
} }
} }