Testing promise failure

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):
@@ -418,13 +418,6 @@ def _next(self):
                 self.result.add_callbacks(self._continue, self._continue)
                 break
 
-        if isinstance(self.result, DeferredException):
-            # Print the exception to stderr and stop if there aren't any
-            # further errbacks to process
-            sys.excepthook(self.result.type, self.result.value,
-                           self.result.traceback)
-            return False
-
 
 def defer(func, *args, **kwargs):
     """Invoke the given function that may or not may be a Deferred.

graphql/core/execution/executor.py

@@ -200,7 +200,7 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
                     info,
                     resolved
                 ),
-                lambda error: fail(GraphQLError(str(error), field_asts, error))
+                lambda error: fail(GraphQLError(str(error.value), field_asts, error))
             )
 
         if isinstance(result, Exception):

tests/core_execution/test_concurrent_executor.py

@@ -1,10 +1,11 @@
 from graphql.core.execution import Executor
 from graphql.core.execution.middlewares.sync import SynchronousExecutionMiddleware
-from graphql.core.defer import succeed, Deferred
+from graphql.core.defer import succeed, Deferred, fail
 from graphql.core.language.location import SourceLocation
 from graphql.core.language.parser import parse
 from graphql.core.type import (GraphQLSchema, GraphQLObjectType, GraphQLField,
                                GraphQLArgument, GraphQLList, GraphQLInt, GraphQLString)
+from graphql.core.type.definition import GraphQLNonNull
 
 from .utils import raise_callback_results
 
@@ -151,6 +152,64 @@ def notPromise(self):
                                          'when using SynchronousExecutionMiddleware'}]
 
 
+def test_synchronous_executor_doesnt_support_defers():
+    class Data(object):
+        def promise(self):
+            return succeed('i shouldn\'nt work')
+
+        def notPromise(self):
+            return 'i should work'
+
+    DataType = GraphQLObjectType('DataType', {
+        'promise': GraphQLField(GraphQLNonNull(GraphQLString)),
+        'notPromise': GraphQLField(GraphQLString),
+    })
+    doc = '''
+    query Example {
+        promise
+        notPromise
+    }
+    '''
+    schema = GraphQLSchema(query=DataType)
+    executor = Executor(schema, [SynchronousExecutionMiddleware()])
+
+    result = executor.execute(doc, Data(), operation_name='Example')
+    assert not isinstance(result, Deferred)
+    assert result.data is None
+    assert result.errors == [{'locations': [SourceLocation(line=3, column=9)],
+                              'message': 'You cannot return a Deferred from a resolver '
+                                         'when using SynchronousExecutionMiddleware'}]
+
+
+def test_executor_defer_failure():
+    class Data(object):
+        def promise(self):
+            return fail(Exception('Something bad happened! Sucks :('))
+
+        def notPromise(self):
+            return 'i should work'
+
+    DataType = GraphQLObjectType('DataType', {
+        'promise': GraphQLField(GraphQLNonNull(GraphQLString)),
+        'notPromise': GraphQLField(GraphQLString),
+    })
+    doc = '''
+    query Example {
+        promise
+        notPromise
+    }
+    '''
+    schema = GraphQLSchema(query=DataType)
+    executor = Executor(schema)
+
+    result = executor.execute(doc, Data(), operation_name='Example')
+    assert result.called
+    result = result.result
+    assert result.data is None
+    assert result.errors == [{'locations': [SourceLocation(line=3, column=9)],
+                              'message': "Something bad happened! Sucks :("}]
+
+
 def test_synchronous_executor_will_synchronously_resolve():
     class Data(object):
         def promise(self):

tests/core_execution/test_deferred.py

@@ -234,4 +234,32 @@ def test_callback_var_args():
     d.add_callback(lambda *args, **kwargs: holder.append((args, kwargs)), 2, 3, a=4, b=5)
     d.callback(1)
 
-    assert holder[0] == ((1, 2, 3), {'a': 4, 'b': 5})
+    assert holder[0] == ((1, 2, 3), {'a': 4, 'b': 5})
+
+
+def test_deferred_callback_returns_another_deferred():
+    d = Deferred()
+    d2 = Deferred()
+
+    d.add_callback(lambda r: succeed(r + 5).add_callback(lambda v: v + 5))
+    d.add_callback(lambda r: d2)
+    d.callback(5)
+
+    assert d.result is d2
+    assert d.paused
+    assert d.called
+
+    d2.callback(7)
+    assert d.result == 7
+    assert d2.result == 7
+
+
+def test_deferred_exception_catch():
+    def dummy_errback(deferred_exception):
+        deferred_exception.catch(OSError)
+        return "caught"
+
+    deferred = Deferred()
+    deferred.add_errback(dummy_errback)
+    deferred.errback(OSError())
+    assert deferred.result == 'caught'

tests_py35/core_execution/test_asyncio_executor.py

@@ -4,6 +4,7 @@
 import functools
 from graphql.core.execution import Executor
 from graphql.core.execution.middlewares.asyncio import AsyncioExecutionMiddleware
+from graphql.core.language.location import SourceLocation
 from graphql.core.type import (
     GraphQLSchema,
     GraphQLObjectType,
@@ -40,4 +41,26 @@ async def resolver_2(context, *_):
     executor = Executor(GraphQLSchema(Type), [AsyncioExecutionMiddleware()])
     result = await executor.execute(doc)
     assert not result.errors
-    assert result.data == {'a': 'hey', 'b': 'hey2'}
+    assert result.data == {'a': 'hey', 'b': 'hey2'}
+
+@run_until_complete
+async def test_asyncio_py35_executor_with_error():
+    doc = 'query Example { a, b }'
+
+    async def resolver(context, *_):
+        await asyncio.sleep(0.001)
+        return 'hey'
+
+    async def resolver_2(context, *_):
+        await asyncio.sleep(0.003)
+        raise Exception('resolver_2 failed!')
+
+    Type = GraphQLObjectType('Type', {
+        'a': GraphQLField(GraphQLString, resolver=resolver),
+        'b': GraphQLField(GraphQLString, resolver=resolver_2)
+    })
+
+    executor = Executor(GraphQLSchema(Type), [AsyncioExecutionMiddleware()])
+    result = await executor.execute(doc)
+    assert result.errors == [{'locations': [SourceLocation(1, 20)], 'message': 'resolver_2 failed!'}]
+    assert result.data == {'a': 'hey', 'b': None}