Improved serial resolver. Added mutations and variables tests

Author: syrusakbary

graphql/execution/querybuilder/executor.py

@@ -76,5 +76,7 @@ def execute_operation(exe_context, operation, root_value):
     type = get_operation_root_type(exe_context.schema, operation)
     execute_serially = operation.operation == 'mutation'
 
-    fragment = Fragment(type=type, selection_set=operation.selection_set, context=exe_context, execute_serially=execute_serially)
+    fragment = Fragment(type=type, selection_set=operation.selection_set, context=exe_context)
+    if execute_serially:
+        return fragment.resolve_serially(root_value)
     return fragment.resolve(root_value)

graphql/execution/querybuilder/fragment.py

@@ -1,5 +1,6 @@
-from promise import promise_for_dict
+from promise import promise_for_dict, Promise
 
+import functools
 from functools import partial
 from ...pyutils.cached_property import cached_property
 from ..values import get_argument_values, get_variable_values
@@ -73,10 +74,9 @@ def get_resolvers(context, type, selection_set):
 
 
 class Fragment(object):
-    def __init__(self, type, selection_set, context=None, execute_serially=False):
+    def __init__(self, type, selection_set, context=None):
         self.type = type
         self.selection_set = selection_set
-        self.execute_serially = execute_serially
         self.context = context
 
     @cached_property
@@ -114,17 +114,40 @@ def resolve(self, root):
         #     for field_name, field_resolver, field_args, context, info in self.partial_resolvers
         # }
 
+    def resolve_serially(self, root):
+        def execute_field_callback(results, resolver):
+            response_name, field_resolver, field_args, context, info = resolver
+
+            result = field_resolver(root, field_args, context, info)
+
+            if result is Undefined:
+                return results
+
+            if is_promise(result):
+                def collect_result(resolved_result):
+                    results[response_name] = resolved_result
+                    return results
+
+                return result.then(collect_result, None)
+
+            results[response_name] = result
+            return results
+
+        def execute_field(prev_promise, resolver):
+            return prev_promise.then(lambda results: execute_field_callback(results, resolver))
+
+        return functools.reduce(execute_field, self.partial_resolvers, Promise.resolve(OrderedDict()))
+
     def __eq__(self, other):
         return isinstance(other, Fragment) and (
             other.type == self.type and
             other.selection_set == self.selection_set and
-            other.context == self.context and
-            other.execute_serially == self.execute_serially
+            other.context == self.context
         )
 
 
 class AbstractFragment(object):
-    def __init__(self, abstract_type, selection_set, context=None, info=None): # execute_serially=False
+    def __init__(self, abstract_type, selection_set, context=None, info=None):
         self.abstract_type = abstract_type
         self.selection_set = selection_set
         self.context = context

graphql/execution/querybuilder/tests/test_mutations.py

@@ -0,0 +1,139 @@
+from ..executor import execute
+from graphql.language.parser import parse
+from graphql.type import (GraphQLArgument, GraphQLField, GraphQLInt,
+                          GraphQLList, GraphQLObjectType, GraphQLSchema,
+                          GraphQLString)
+
+
+class NumberHolder(object):
+
+    def __init__(self, n):
+        self.theNumber = n
+
+
+class Root(object):
+
+    def __init__(self, n):
+        self.numberHolder = NumberHolder(n)
+
+    def immediately_change_the_number(self, n):
+        self.numberHolder.theNumber = n
+        return self.numberHolder
+
+    def promise_to_change_the_number(self, n):
+        # TODO: async
+        return self.immediately_change_the_number(n)
+
+    def fail_to_change_the_number(self, n):
+        raise Exception('Cannot change the number')
+
+    def promise_and_fail_to_change_the_number(self, n):
+        # TODO: async
+        self.fail_to_change_the_number(n)
+
+
+NumberHolderType = GraphQLObjectType('NumberHolder', {
+    'theNumber': GraphQLField(GraphQLInt)
+})
+
+QueryType = GraphQLObjectType('Query', {
+    'numberHolder': GraphQLField(NumberHolderType)
+})
+
+MutationType = GraphQLObjectType('Mutation', {
+    'immediatelyChangeTheNumber': GraphQLField(
+        NumberHolderType,
+        args={'newNumber': GraphQLArgument(GraphQLInt)},
+        resolver=lambda obj, args, *_:
+            obj.immediately_change_the_number(args['newNumber'])),
+    'promiseToChangeTheNumber': GraphQLField(
+        NumberHolderType,
+        args={'newNumber': GraphQLArgument(GraphQLInt)},
+        resolver=lambda obj, args, *_:
+            obj.promise_to_change_the_number(args['newNumber'])),
+    'failToChangeTheNumber': GraphQLField(
+        NumberHolderType,
+        args={'newNumber': GraphQLArgument(GraphQLInt)},
+        resolver=lambda obj, args, *_:
+            obj.fail_to_change_the_number(args['newNumber'])),
+    'promiseAndFailToChangeTheNumber': GraphQLField(
+        NumberHolderType,
+        args={'newNumber': GraphQLArgument(GraphQLInt)},
+        resolver=lambda obj, args, *_:
+            obj.promise_and_fail_to_change_the_number(args['newNumber'])),
+})
+
+schema = GraphQLSchema(QueryType, MutationType)
+
+
+def assert_evaluate_mutations_serially(executor=None):
+    doc = '''mutation M {
+      first: immediatelyChangeTheNumber(newNumber: 1) {
+        theNumber
+      },
+      second: promiseToChangeTheNumber(newNumber: 2) {
+        theNumber
+      },
+      third: immediatelyChangeTheNumber(newNumber: 3) {
+        theNumber
+      }
+      fourth: promiseToChangeTheNumber(newNumber: 4) {
+        theNumber
+      },
+      fifth: immediatelyChangeTheNumber(newNumber: 5) {
+        theNumber
+      }
+    }'''
+    ast = parse(doc)
+    result = execute(schema, ast, Root(6), operation_name='M', executor=executor)
+    assert not result.errors
+    assert result.data == \
+        {
+            'first': {'theNumber': 1},
+            'second': {'theNumber': 2},
+            'third': {'theNumber': 3},
+            'fourth': {'theNumber': 4},
+            'fifth': {'theNumber': 5},
+        }
+
+
+def test_evaluates_mutations_serially():
+    assert_evaluate_mutations_serially()
+
+
+def test_evaluates_mutations_correctly_in_the_presense_of_a_failed_mutation():
+    doc = '''mutation M {
+      first: immediatelyChangeTheNumber(newNumber: 1) {
+        theNumber
+      },
+      second: promiseToChangeTheNumber(newNumber: 2) {
+        theNumber
+      },
+      third: failToChangeTheNumber(newNumber: 3) {
+        theNumber
+      }
+      fourth: promiseToChangeTheNumber(newNumber: 4) {
+        theNumber
+      },
+      fifth: immediatelyChangeTheNumber(newNumber: 5) {
+        theNumber
+      }
+      sixth: promiseAndFailToChangeTheNumber(newNumber: 6) {
+        theNumber
+      }
+    }'''
+    ast = parse(doc)
+    result = execute(schema, ast, Root(6), operation_name='M')
+    assert result.data == \
+        {
+            'first': {'theNumber': 1},
+            'second': {'theNumber': 2},
+            'third': None,
+            'fourth': {'theNumber': 4},
+            'fifth': {'theNumber': 5},
+            'sixth': None,
+        }
+    assert len(result.errors) == 2
+    # TODO: check error location
+    assert result.errors[0].message == 'Cannot change the number'
+    assert result.errors[1].message == 'Cannot change the number'