Promise tests

Author: mcg-web

tests/Executor/NonNullTest.php

@@ -1,14 +1,18 @@
 <?php
+
 namespace GraphQL\Tests\Executor;
 
-use GraphQL\Error\Error;
+
 use GraphQL\Executor\Executor;
 use GraphQL\Error\FormattedError;
 use GraphQL\Language\Parser;
 use GraphQL\Language\SourceLocation;
+use GraphQL\Promise\Adapter\ReactPromiseAdapter;
 use GraphQL\Schema;
 use GraphQL\Type\Definition\ObjectType;
 use GraphQL\Type\Definition\Type;
+use React\Promise\Promise;
+use React\Promise\PromiseInterface;
 
 class NonNullTest extends \PHPUnit_Framework_TestCase
 {
@@ -17,6 +21,13 @@ class NonNullTest extends \PHPUnit_Framework_TestCase
 
     /** @var \Exception */
     public $nonNullSyncError;
+
+    /** @var  \Exception */
+    public $promiseError;
+
+    /** @var  \Exception */
+    public $nonNullPromiseError;
+
     public $throwingData;
     public $nullingData;
     public $schema;
@@ -25,6 +36,8 @@ public function setUp()
     {
         $this->syncError = new \Exception('sync');
         $this->nonNullSyncError = new \Exception('nonNullSync');
+        $this->promiseError = new \Exception('promise');
+        $this->nonNullPromiseError = new \Exception('nonNullPromise');
 
         $this->throwingData = [
             'sync' => function () {
@@ -33,12 +46,32 @@ public function setUp()
             'nonNullSync' => function () {
                 throw $this->nonNullSyncError;
             },
+            'promise' => function () {
+                return new Promise(function () {
+                    throw $this->promiseError;
+                });
+            },
+            'nonNullPromise' => function () {
+                return new Promise(function () {
+                    throw $this->nonNullPromiseError;
+                });
+            },
             'nest' => function () {
                 return $this->throwingData;
             },
             'nonNullNest' => function () {
                 return $this->throwingData;
             },
+            'promiseNest' => function () {
+                return new Promise(function (callable $resolve) {
+                    $resolve($this->throwingData);
+                });
+            },
+            'nonNullPromiseNest' => function () {
+                return new Promise(function (callable $resolve) {
+                    $resolve($this->throwingData);
+                });
+            },
         ];
 
         $this->nullingData = [
@@ -48,12 +81,32 @@ public function setUp()
             'nonNullSync' => function () {
                 return null;
             },
+            'promise' => function () {
+                return new Promise(function (callable $resolve) {
+                    return $resolve(null);
+                });
+            },
+            'nonNullPromise' => function () {
+                return new Promise(function (callable $resolve) {
+                    return $resolve(null);
+                });
+            },
             'nest' => function () {
                 return $this->nullingData;
             },
             'nonNullNest' => function () {
                 return $this->nullingData;
             },
+            'promiseNest' => function () {
+                return new Promise(function (callable $resolve) {
+                    $resolve($this->nullingData);
+                });
+            },
+            'nonNullPromiseNest' => function () {
+                return new Promise(function (callable $resolve) {
+                    $resolve($this->nullingData);
+                });
+            },
         ];
 
         $dataType = new ObjectType([
@@ -62,13 +115,18 @@ public function setUp()
                 return [
                     'sync' => ['type' => Type::string()],
                     'nonNullSync' => ['type' => Type::nonNull(Type::string())],
+                    'promise' => Type::string(),
+                    'nonNullPromise' => Type::nonNull(Type::string()),
                     'nest' => $dataType,
-                    'nonNullNest' => Type::nonNull($dataType)
+                    'nonNullNest' => Type::nonNull($dataType),
+                    'promiseNest' => $dataType,
+                    'nonNullPromiseNest' => Type::nonNull($dataType),
                 ];
             }
         ]);
 
         $this->schema = new Schema(['query' => $dataType]);
+        Executor::setPromiseAdapter(null);
     }
 
     // Execute: handles non-nullable types
@@ -100,6 +158,32 @@ public function testNullsANullableFieldThatThrowsSynchronously()
         $this->assertArraySubset($expected, Executor::execute($this->schema, $ast, $this->throwingData, null, [], 'Q')->toArray());
     }
 
+    public function testNullsANullableFieldThatThrowsInAPromise()
+    {
+        $doc = '
+      query Q {
+        promise
+      }
+        ';
+
+        $ast = Parser::parse($doc);
+
+        $expected = [
+            'data' => [
+                'promise' => null,
+            ],
+            'errors' => [
+                FormattedError::create(
+                    $this->promiseError->getMessage(),
+                    [new SourceLocation(3, 9)]
+                )
+            ]
+        ];
+
+        Executor::setPromiseAdapter(new ReactPromiseAdapter());
+        $this->assertArraySubsetPromise($expected, Executor::execute($this->schema, $ast, $this->throwingData, null, [], 'Q'));
+    }
+
     public function testNullsASynchronouslyReturnedObjectThatContainsANonNullableFieldThatThrowsSynchronously()
     {
         // nulls a synchronously returned object that contains a non-nullable field that throws synchronously
@@ -124,6 +208,31 @@ public function testNullsASynchronouslyReturnedObjectThatContainsANonNullableFie
         $this->assertArraySubset($expected, Executor::execute($this->schema, $ast, $this->throwingData, null, [], 'Q')->toArray());
     }
 
+    public function testNullsAsynchronouslyReturnedObjectThatContainsANonNullableFieldThatThrowsInAPromise()
+    {
+        $doc = '
+      query Q {
+        nest {
+          nonNullPromise,
+        }
+      }
+    ';
+
+        $ast = Parser::parse($doc);
+
+        $expected = [
+            'data' => [
+                'nest' => null
+            ],
+            'errors' => [
+                FormattedError::create($this->nonNullPromiseError->getMessage(), [new SourceLocation(4, 11)])
+            ]
+        ];
+
+        Executor::setPromiseAdapter(new ReactPromiseAdapter());
+        $this->assertArraySubsetPromise($expected, Executor::execute($this->schema, $ast, $this->throwingData, null, [], 'Q'));
+    }
+
     public function testNullsAComplexTreeOfNullableFieldsThatThrow()
     {
         $doc = '
@@ -262,4 +371,14 @@ public function testNullsTheTopLevelIfSyncNonNullableFieldReturnsNull()
         ];
         $this->assertArraySubset($expected, Executor::execute($this->schema, Parser::parse($doc), $this->nullingData)->toArray());
     }
+
+    private function assertArraySubsetPromise($subset, PromiseInterface $promise)
+    {
+        $array = null;
+        $promise->then(function ($value) use (&$array) {
+            $array = $value;
+        });
+
+        $this->assertArraySubset($subset, $array);
+    }
 }