Unit tests for deferred.

Author: jhgg

graphql/core/defer.py

@@ -113,7 +113,7 @@ def raise_exception(self):
             raise self.type(self.value).with_traceback(self.traceback)
 
     else:
-        exec("""def raise_exception(self):
+        exec ("""def raise_exception(self):
     raise self.type, self.value, self.traceback""")
 
     def catch(self, *errors):
@@ -258,6 +258,8 @@ def add_callbacks(self, callback, errback=None,
         if self.called:
             self._next()
 
+        return self
+
     def add_errback(self, func, *args, **kwargs):
         """Add a callable (function or method) to the errback chain only.
 
@@ -288,8 +290,8 @@ def add_errback(self, func, *args, **kwargs):
         >>> deferred.result
         'ignored'
         """
-        self.add_callbacks(_passthrough, func, errback_args=args,
-                           errback_kwargs=kwargs)
+        return self.add_callbacks(_passthrough, func, errback_args=args,
+                                  errback_kwargs=kwargs)
 
     def add_callback(self, func, *args, **kwargs):
         """Add a callable (function or method) to the callback chain only.
@@ -312,8 +314,8 @@ def add_callback(self, func, *args, **kwargs):
         >>> deferred.result
         2
         """
-        self.add_callbacks(func, _passthrough, callback_args=args,
-                           callback_kwargs=kwargs)
+        return self.add_callbacks(func, _passthrough, callback_args=args,
+                                  callback_kwargs=kwargs)
 
     def errback(self, error=None):
         """Start processing the errorback chain starting with the
@@ -339,6 +341,7 @@ def errback(self, error=None):
         elif not isinstance(error, DeferredException):
             assert isinstance(error, Exception)
             error = DeferredException(error.__class__, error, None)
+
         self.called = True
         self.result = error
         self._next()
@@ -358,16 +361,28 @@ def callback(self, result=None):
         if self.called:
             raise AlreadyCalledDeferred()
         self.called = True
+
+        if isinstance(result, Deferred):
+            self.paused = True
+            return result.add_callbacks(self._continue, self._continue)
+
         self.result = result
         self._next()
 
     def _continue(self, result):
         """Continue processing the Deferred with the given result."""
+        # If the result of the deferred is another deferred, we will need to wait for
+        # it to resolve again.
+        if isinstance(result, Deferred):
+            return result.add_callbacks(self._continue, self._continue)
+
         self.result = result
         self.paused = False
         if self.called:
             self._next()
 
+        return result
+
     def _next(self):
         """Process the next callback."""
         if self._running or self.paused:
@@ -380,18 +395,19 @@ def _next(self):
             callback, args, kwargs = next_pair[isinstance(self.result,
                                                           DeferredException)]
 
-            if callback is _passthrough:
-                continue
+            if callback is not _passthrough:
+                self._running = True
+                try:
+                    self.result = callback(self.result, *args, **kwargs)
 
-            self._running = True
-            try:
-                self.result = callback(self.result, *args, **kwargs)
+                except:
+                    self.result = DeferredException()
 
-            except:
-                self.result = DeferredException()
+                finally:
+                    self._running = False
 
-            finally:
-                self._running = False
+                if isinstance(self.result, Exception):
+                    self.result = DeferredException(self.result)
 
             if isinstance(self.result, Deferred):
                 # If a Deferred was returned add this deferred as callbacks to
@@ -428,12 +444,15 @@ def defer(func, *args, **kwargs):
     True
     """
     assert isinstance(func, collections.Callable)
+
     try:
         result = func(*args, **kwargs)
     except:
         result = DeferredException()
+
     if isinstance(result, Deferred):
         return result
+
     deferred = Deferred()
     deferred.callback(result)
     return deferred

graphql/core/execution/executor.py

@@ -61,14 +61,13 @@ def _execute(self, request='', root=None, args=None, operation_name=None, execut
     def _execute_graphql_query(self, root, ast, operation_name, args, execute_serially=False):
         ctx = ExecutionContext(self.schema, root, ast, operation_name, args)
 
-        d = defer(self._execute_operation, ctx, root, ctx.operation, execute_serially)
-        d.add_errback(
+        return defer(self._execute_operation, ctx, root, ctx.operation, execute_serially) \
+            .add_errback(
             lambda error: ctx.errors.append(error)
-        )
-        d.add_callback(
+        ) \
+            .add_callback(
             lambda data: ExecutionResult(data, list(map(format_error, ctx.errors))),
         )
-        return d
 
     def _execute_operation(self, ctx, root, operation, execute_serially):
         type = get_operation_root_type(ctx.schema, operation)
@@ -91,15 +90,13 @@ def collect_result(resolved_result):
                 return results
 
             if isinstance(result, Deferred):
-                result.add_callback(collect_result)
-                return result
+                return result.add_callback(collect_result)
 
             else:
                 return collect_result(result)
 
         def execute_field(prev_deferred, response_name):
-            prev_deferred.add_callback(execute_field_callback, response_name)
-            return prev_deferred
+            return prev_deferred.add_callback(execute_field_callback, response_name)
 
         return functools.reduce(execute_field, fields.keys(), succeed({}))
 
@@ -169,8 +166,7 @@ def handle_error(error):
                     ctx.errors.append(error)
                     return None
 
-                completed.add_errback(handle_error)
-                return completed
+                return completed.add_errback(handle_error)
 
             return completed
         except Exception as e:
@@ -196,7 +192,7 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
         """
         # If field type is NonNull, complete for inner type, and throw field error if result is null.
         if isinstance(result, Deferred):
-            result.add_callbacks(
+            return result.add_callbacks(
                 lambda resolved: self.complete_value(
                     ctx,
                     return_type,
@@ -206,7 +202,6 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
                 ),
                 lambda error: fail(GraphQLError(str(error), field_asts, error))
             )
-            return result
 
         if isinstance(result, Exception):
             raise GraphQLError(str(result), field_asts, result)
@@ -263,7 +258,7 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
             runtime_type = return_type.resolve_type(result)
             if runtime_type and not return_type.is_possible_type(runtime_type):
                 raise GraphQLError(
-                    'Runtime Object type "{}" is nt a possible type for "{}".'.format(runtime_type, return_type),
+                    'Runtime Object type "{}" is not a possible type for "{}".'.format(runtime_type, return_type),
                     field_asts
                 )