2015-07-15 20:05:46 +03:00
|
|
|
<?php
|
2016-04-09 10:36:53 +03:00
|
|
|
namespace GraphQL\Tests\Executor;
|
2015-07-15 20:05:46 +03:00
|
|
|
|
2015-08-17 17:01:55 +03:00
|
|
|
use GraphQL\Error;
|
2016-04-09 10:36:53 +03:00
|
|
|
use GraphQL\Executor\Executor;
|
2015-07-15 20:05:46 +03:00
|
|
|
use GraphQL\FormattedError;
|
|
|
|
use GraphQL\Language\Parser;
|
|
|
|
use GraphQL\Language\SourceLocation;
|
|
|
|
use GraphQL\Schema;
|
|
|
|
use GraphQL\Type\Definition\ObjectType;
|
|
|
|
use GraphQL\Type\Definition\Type;
|
|
|
|
|
|
|
|
class ListsTest extends \PHPUnit_Framework_TestCase
|
|
|
|
{
|
|
|
|
// Execute: Handles list nullability
|
|
|
|
|
|
|
|
public function testHandlesListsWhenTheyReturnNonNullValues()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
list,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
$expected = ['data' => ['nest' => ['list' => [1,2]]]];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesListsOfNonNullsWhenTheyReturnNonNullValues()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
listOfNonNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'listOfNonNull' => [1, 2],
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
|
|
|
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfWhenTheyReturnNonNullValues()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullList,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'nonNullList' => [1, 2],
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfNonNullsWhenTheyReturnNonNullValues()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullListOfNonNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'nonNullListOfNonNull' => [1, 2],
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesListsWhenTheyReturnNullAsAValue()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
listContainsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'listContainsNull' => [1, null, 2],
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesListsOfNonNullsWhenTheyReturnNullAsAValue()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
listOfNonNullContainsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'listOfNonNullContainsNull' => null
|
|
|
|
]
|
|
|
|
],
|
|
|
|
'errors' => [
|
2015-08-17 17:01:55 +03:00
|
|
|
FormattedError::create(
|
2015-07-15 20:05:46 +03:00
|
|
|
'Cannot return null for non-nullable type.',
|
|
|
|
[new SourceLocation(4, 11)]
|
|
|
|
)
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfWhenTheyReturnNullAsAValue()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullListContainsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => ['nonNullListContainsNull' => [1, null, 2]]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfNonNullsWhenTheyReturnNullAsAValue()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullListOfNonNullContainsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => null
|
|
|
|
],
|
|
|
|
'errors' => [
|
2015-08-17 17:01:55 +03:00
|
|
|
FormattedError::create(
|
2015-07-15 20:05:46 +03:00
|
|
|
'Cannot return null for non-nullable type.',
|
|
|
|
[new SourceLocation(4, 11)]
|
|
|
|
)
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesListsWhenTheyReturnNull()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
listReturnsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'listReturnsNull' => null
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesListsOfNonNullsWhenTheyReturnNull()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
listOfNonNullReturnsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => [
|
|
|
|
'listOfNonNullReturnsNull' => null
|
|
|
|
]
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfWhenTheyReturnNull()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullListReturnsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => null,
|
|
|
|
],
|
|
|
|
'errors' => [
|
2015-08-17 17:01:55 +03:00
|
|
|
FormattedError::create(
|
2015-07-15 20:05:46 +03:00
|
|
|
'Cannot return null for non-nullable type.',
|
|
|
|
[new SourceLocation(4, 11)]
|
|
|
|
)
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
public function testHandlesNonNullListsOfNonNullsWhenTheyReturnNull()
|
|
|
|
{
|
|
|
|
$doc = '
|
|
|
|
query Q {
|
|
|
|
nest {
|
|
|
|
nonNullListOfNonNullReturnsNull,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
';
|
|
|
|
|
|
|
|
$ast = Parser::parse($doc);
|
|
|
|
|
|
|
|
$expected = [
|
|
|
|
'data' => [
|
|
|
|
'nest' => null
|
|
|
|
],
|
|
|
|
'errors' => [
|
2015-08-17 17:01:55 +03:00
|
|
|
FormattedError::create(
|
2015-07-15 20:05:46 +03:00
|
|
|
'Cannot return null for non-nullable type.',
|
|
|
|
[new SourceLocation(4, 11)]
|
|
|
|
)
|
|
|
|
]
|
|
|
|
];
|
2015-08-17 17:01:55 +03:00
|
|
|
$this->assertEquals($expected, Executor::execute($this->schema(), $ast, $this->data(), [], 'Q')->toArray());
|
2015-07-15 20:05:46 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private function schema()
|
|
|
|
{
|
|
|
|
$dataType = new ObjectType([
|
|
|
|
'name' => 'DataType',
|
|
|
|
'fields' => [
|
|
|
|
'list' => [
|
|
|
|
'type' => Type::listOf(Type::int())
|
|
|
|
],
|
|
|
|
'listOfNonNull' => [
|
|
|
|
'type' => Type::listOf(Type::nonNull(Type::int()))
|
|
|
|
],
|
|
|
|
'nonNullList' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::int()))
|
|
|
|
],
|
|
|
|
'nonNullListOfNonNull' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::nonNull(Type::int())))
|
|
|
|
],
|
|
|
|
'listContainsNull' => [
|
|
|
|
'type' => Type::listOf(Type::int())
|
|
|
|
],
|
|
|
|
'listOfNonNullContainsNull' => [
|
|
|
|
'type' => Type::listOf(Type::nonNull(Type::int())),
|
|
|
|
],
|
|
|
|
'nonNullListContainsNull' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::int()))
|
|
|
|
],
|
|
|
|
'nonNullListOfNonNullContainsNull' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::nonNull(Type::int())))
|
|
|
|
],
|
|
|
|
'listReturnsNull' => [
|
|
|
|
'type' => Type::listOf(Type::int())
|
|
|
|
],
|
|
|
|
'listOfNonNullReturnsNull' => [
|
|
|
|
'type' => Type::listOf(Type::nonNull(Type::int()))
|
|
|
|
],
|
|
|
|
'nonNullListReturnsNull' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::int()))
|
|
|
|
],
|
|
|
|
'nonNullListOfNonNullReturnsNull' => [
|
|
|
|
'type' => Type::nonNull(Type::listOf(Type::nonNull(Type::int())))
|
|
|
|
],
|
|
|
|
'nest' => ['type' => function () use (&$dataType) {
|
|
|
|
return $dataType;
|
|
|
|
}]
|
|
|
|
]
|
|
|
|
]);
|
|
|
|
|
|
|
|
$schema = new Schema($dataType);
|
|
|
|
return $schema;
|
|
|
|
}
|
|
|
|
|
|
|
|
private function data()
|
|
|
|
{
|
|
|
|
return [
|
|
|
|
'list' => function () {
|
|
|
|
return [1, 2];
|
|
|
|
},
|
|
|
|
'listOfNonNull' => function () {
|
|
|
|
return [1, 2];
|
|
|
|
},
|
|
|
|
'nonNullList' => function () {
|
|
|
|
return [1, 2];
|
|
|
|
},
|
|
|
|
'nonNullListOfNonNull' => function () {
|
|
|
|
return [1, 2];
|
|
|
|
},
|
|
|
|
'listContainsNull' => function () {
|
|
|
|
return [1, null, 2];
|
|
|
|
},
|
|
|
|
'listOfNonNullContainsNull' => function () {
|
|
|
|
return [1, null, 2];
|
|
|
|
},
|
|
|
|
'nonNullListContainsNull' => function () {
|
|
|
|
return [1, null, 2];
|
|
|
|
},
|
|
|
|
'nonNullListOfNonNullContainsNull' => function () {
|
|
|
|
return [1, null, 2];
|
|
|
|
},
|
|
|
|
'listReturnsNull' => function () {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
'listOfNonNullReturnsNull' => function () {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
'nonNullListReturnsNull' => function () {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
'nonNullListOfNonNullReturnsNull' => function () {
|
|
|
|
return null;
|
|
|
|
},
|
|
|
|
'nest' => function () {
|
|
|
|
return self::data();
|
|
|
|
}
|
|
|
|
];
|
|
|
|
}
|
2016-04-09 10:36:53 +03:00
|
|
|
}
|