Add tests for concurrent executor as well.

Author: jhgg

graphql/core/execution/executor.py

@@ -116,7 +116,7 @@ def collect_result(resolved_result):
                 return results
 
             if isinstance(result, Deferred):
-                return result.add_callback(collect_result)
+                return succeed(result).add_callback(collect_result)
 
             else:
                 return collect_result(result)

graphql/core/pyutils/defer.py

@@ -472,13 +472,13 @@ def _schedule_callbacks(self, items, result, objects_remaining_to_resolve=None,
         self._result = result
         for key, value in items:
             if isinstance(value, Deferred):
-                value.add_callbacks(self._cb_deferred, self._cb_deferred,
-                                    callback_args=(key, True),
-                                    errback_args=(key, False))
-
                 # We will place a value in place of the resolved key, so that insert order is preserved.
                 if preserve_insert_ordering:
                     result[key] = None
+
+                value.add_callbacks(self._cb_deferred, self._cb_deferred,
+                                    callback_args=(key, True),
+                                    errback_args=(key, False))
             else:
                 self.objects_remaining_to_resolve -= 1
                 result[key] = value

graphql/core/utils/build_ast_schema.py

@@ -68,7 +68,6 @@ def build_ast_schema(document, query_type_name, mutation_type_name=None):
 
     def produce_type_def(type_ast):
         type_name = _get_inner_type_name(type_ast)
-        print('ptd', type_name)
         if type_name in inner_type_map:
             return _build_wrapped_type(inner_type_map[type_name], type_ast)
 

tests/core_execution/test_concurrent_executor.py

@@ -1,3 +1,4 @@
+from collections import OrderedDict
 from graphql.core.error import format_error
 from graphql.core.execution import Executor
 from graphql.core.execution.middlewares.sync import SynchronousExecutionMiddleware
@@ -233,3 +234,36 @@ def promise(self):
     assert not isinstance(result, Deferred)
     assert result.data == {"promise": 'I should work'}
     assert not result.errors
+
+
+def test_executor_can_enforce_strict_ordering():
+    Type = GraphQLObjectType('Type', lambda: {
+        'a': GraphQLField(GraphQLString,
+                          resolver=lambda *_: succeed('Apple')),
+        'b': GraphQLField(GraphQLString,
+                          resolver=lambda *_: succeed('Banana')),
+        'c': GraphQLField(GraphQLString,
+                          resolver=lambda *_: succeed('Cherry')),
+        'deep': GraphQLField(Type, resolver=lambda *_: succeed({})),
+    })
+    schema = GraphQLSchema(query=Type)
+    executor = Executor(map_type=OrderedDict)
+
+    query = '{ a b c aa: c cc: c bb: b aaz: a bbz: b deep { b a c deeper: deep { c a b } } ' \
+            'ccz: c zzz: c aaa: a }'
+
+    def handle_results(result):
+        assert not result.errors
+
+        data = result.data
+        assert isinstance(data, OrderedDict)
+        assert list(data.keys()) == ['a', 'b', 'c', 'aa', 'cc', 'bb', 'aaz', 'bbz', 'deep', 'ccz', 'zzz', 'aaa']
+        deep = data['deep']
+        assert isinstance(deep, OrderedDict)
+        assert list(deep.keys()) == ['b', 'a', 'c', 'deeper']
+        deeper = deep['deeper']
+        assert isinstance(deeper, OrderedDict)
+        assert list(deeper.keys()) == ['c', 'a', 'b']
+
+    raise_callback_results(executor.execute(schema, query), handle_results)
+    raise_callback_results(executor.execute(schema, query, execute_serially=True), handle_results)

tests/core_execution/test_executor.py

@@ -466,18 +466,21 @@ def test_executor_can_enforce_strict_ordering():
     })
     schema = GraphQLSchema(query=Type)
     executor = Executor(execution_middlewares=[SynchronousExecutionMiddleware], map_type=OrderedDict)
-
-    result = executor.execute(schema, '{ a b c aa: c cc: c bb: b aaz: a bbz: b deep { b a c deeper: deep { c a b } } '
-                                      'ccz: c zzz: c aaa: a }')
-
-    assert not result.errors
-
-    data = result.data
-    assert isinstance(data, OrderedDict)
-    assert list(data.keys()) == ['a', 'b', 'c', 'aa', 'cc', 'bb', 'aaz', 'bbz', 'deep', 'ccz', 'zzz', 'aaa']
-    deep = data['deep']
-    assert isinstance(deep, OrderedDict)
-    assert list(deep.keys()) == ['b', 'a', 'c', 'deeper']
-    deeper = deep['deeper']
-    assert isinstance(deeper, OrderedDict)
-    assert list(deeper.keys()) == ['c', 'a', 'b']
+    query = '{ a b c aa: c cc: c bb: b aaz: a bbz: b deep { b a c deeper: deep { c a b } } ' \
+            'ccz: c zzz: c aaa: a }'
+
+    def check_result(result):
+        assert not result.errors
+
+        data = result.data
+        assert isinstance(data, OrderedDict)
+        assert list(data.keys()) == ['a', 'b', 'c', 'aa', 'cc', 'bb', 'aaz', 'bbz', 'deep', 'ccz', 'zzz', 'aaa']
+        deep = data['deep']
+        assert isinstance(deep, OrderedDict)
+        assert list(deep.keys()) == ['b', 'a', 'c', 'deeper']
+        deeper = deep['deeper']
+        assert isinstance(deeper, OrderedDict)
+        assert list(deeper.keys()) == ['c', 'a', 'b']
+
+    check_result(executor.execute(schema, query))
+    check_result(executor.execute(schema, query, execute_serially=True))