Merge branch 'master' of github.com:dan98765/graphql-core into middleware_runs_in_passed_in_order

Author: Daniel Gallagher

graphql/backend/decider.py

@@ -66,7 +66,7 @@ def main_thread_terminated(self):
                 # add or remove items
                 size = self._queue.qsize()
 
-                print("Sentry is attempting to send %i pending error messages" % size)
+                print("GraphQL is attempting to retrieve %i pending documents" % size)
                 print("Waiting up to %s seconds" % timeout)
 
                 if os.name == "nt":

graphql/execution/tests/test_middleware.py

@@ -1,159 +1,191 @@
+# type: ignore
 from __future__ import print_function
 
+import json
+
+from pytest import raises
+from graphql.error import GraphQLError
 from graphql.execution import MiddlewareManager, execute
-from graphql.execution.middleware import (get_middleware_resolvers,
-                                          middleware_chain)
+from graphql.execution.middleware import get_middleware_resolvers, middleware_chain
 from graphql.language.parser import parse
-from graphql.type import (GraphQLArgument, GraphQLBoolean, GraphQLField,
-                          GraphQLID, GraphQLInt, GraphQLList, GraphQLNonNull,
-                          GraphQLObjectType, GraphQLSchema, GraphQLString)
+from graphql.type import (
+    GraphQLArgument,
+    GraphQLBoolean,
+    GraphQLField,
+    GraphQLInt,
+    GraphQLList,
+    GraphQLObjectType,
+    GraphQLSchema,
+    GraphQLString,
+    GraphQLNonNull,
+    GraphQLID,
+)
 from promise import Promise
 
 
 def test_middleware():
-    doc = '''{
+    # type: () -> None
+    doc = """{
         ok
         not_ok
-    }'''
+    }"""
 
     class Data(object):
-
         def ok(self):
-            return 'ok'
+            # type: () -> str
+            return "ok"
 
         def not_ok(self):
-            return 'not_ok'
+            # type: () -> str
+            return "not_ok"
 
     doc_ast = parse(doc)
 
-    Type = GraphQLObjectType('Type', {
-        'ok': GraphQLField(GraphQLString),
-        'not_ok': GraphQLField(GraphQLString),
-    })
+    Type = GraphQLObjectType(
+        "Type",
+        {"ok": GraphQLField(GraphQLString), "not_ok": GraphQLField(GraphQLString)},
+    )
 
     def reversed_middleware(next, *args, **kwargs):
+        # type: (Callable, *Any, **Any) -> Promise
         p = next(*args, **kwargs)
         return p.then(lambda x: x[::-1])
 
     middlewares = MiddlewareManager(reversed_middleware)
-    result = execute(GraphQLSchema(Type), doc_ast,
-                     Data(), middleware=middlewares)
-    assert result.data == {'ok': 'ko', 'not_ok': 'ko_ton'}
+    result = execute(GraphQLSchema(Type), doc_ast, Data(), middleware=middlewares)
+    assert result.data == {"ok": "ko", "not_ok": "ko_ton"}
 
 
 def test_middleware_class():
-    doc = '''{
+    # type: () -> None
+    doc = """{
         ok
         not_ok
-    }'''
+    }"""
 
     class Data(object):
-
         def ok(self):
-            return 'ok'
+            # type: () -> str
+            return "ok"
 
         def not_ok(self):
-            return 'not_ok'
+            # type: () -> str
+            return "not_ok"
 
     doc_ast = parse(doc)
 
-    Type = GraphQLObjectType('Type', {
-        'ok': GraphQLField(GraphQLString),
-        'not_ok': GraphQLField(GraphQLString),
-    })
+    Type = GraphQLObjectType(
+        "Type",
+        {"ok": GraphQLField(GraphQLString), "not_ok": GraphQLField(GraphQLString)},
+    )
 
     class MyMiddleware(object):
         def resolve(self, next, *args, **kwargs):
+            # type: (Callable, *Any, **Any) -> Promise
             p = next(*args, **kwargs)
             return p.then(lambda x: x[::-1])
 
     middlewares = MiddlewareManager(MyMiddleware())
-    result = execute(GraphQLSchema(Type), doc_ast,
-                     Data(), middleware=middlewares)
-    assert result.data == {'ok': 'ko', 'not_ok': 'ko_ton'}
+    result = execute(GraphQLSchema(Type), doc_ast, Data(), middleware=middlewares)
+    assert result.data == {"ok": "ko", "not_ok": "ko_ton"}
 
 
 def test_middleware_skip_promise_wrap():
-    doc = '''{
+    # type: () -> None
+    doc = """{
         ok
         not_ok
-    }'''
+    }"""
 
     class Data(object):
-
         def ok(self):
-            return 'ok'
+            # type: () -> str
+            return "ok"
 
         def not_ok(self):
-            return 'not_ok'
+            # type: () -> str
+            return "not_ok"
 
     doc_ast = parse(doc)
 
-    Type = GraphQLObjectType('Type', {
-        'ok': GraphQLField(GraphQLString),
-        'not_ok': GraphQLField(GraphQLString),
-    })
+    Type = GraphQLObjectType(
+        "Type",
+        {"ok": GraphQLField(GraphQLString), "not_ok": GraphQLField(GraphQLString)},
+    )
 
     class MyPromiseMiddleware(object):
         def resolve(self, next, *args, **kwargs):
+            # type: (Callable, *Any, **Any) -> Promise
             return Promise.resolve(next(*args, **kwargs))
 
     class MyEmptyMiddleware(object):
         def resolve(self, next, *args, **kwargs):
+            # type: (Callable, *Any, **Any) -> str
             return next(*args, **kwargs)
 
     middlewares_with_promise = MiddlewareManager(
-        MyPromiseMiddleware(), wrap_in_promise=False)
+        MyPromiseMiddleware(), wrap_in_promise=False
+    )
     middlewares_without_promise = MiddlewareManager(
-        MyEmptyMiddleware(), wrap_in_promise=False)
+        MyEmptyMiddleware(), wrap_in_promise=False
+    )
 
-    result1 = execute(GraphQLSchema(Type), doc_ast, Data(),
-                      middleware=middlewares_with_promise)
-    result2 = execute(GraphQLSchema(Type), doc_ast, Data(),
-                      middleware=middlewares_without_promise)
+    result1 = execute(
+        GraphQLSchema(Type), doc_ast, Data(), middleware=middlewares_with_promise
+    )
+    result2 = execute(
+        GraphQLSchema(Type), doc_ast, Data(), middleware=middlewares_without_promise
+    )
     assert result1.data == result2.data and result1.data == {
-        'ok': 'ok', 'not_ok': 'not_ok'}
+        "ok": "ok",
+        "not_ok": "not_ok",
+    }
 
 
 def test_middleware_chain(capsys):
-
+    # type: () -> None
     class CharPrintingMiddleware(object):
         def __init__(self, char):
+            # type: (str) -> None
             self.char = char
 
         def resolve(self, next, *args, **kwargs):
+            # type: (Callable, *Any, **Any) -> str
             print("resolve() called for middleware {}".format(self.char))
             return next(*args, **kwargs).then(
                 lambda x: print("then() for {}".format(self.char))
             )
 
     middlewares = [
-        CharPrintingMiddleware('a'),
-        CharPrintingMiddleware('b'),
-        CharPrintingMiddleware('c'),
+        CharPrintingMiddleware("a"),
+        CharPrintingMiddleware("b"),
+        CharPrintingMiddleware("c"),
     ]
 
     middlewares_resolvers = get_middleware_resolvers(middlewares)
 
-    def func(): return
+    def func():
+        # type: () -> None
+        return
 
-    chain_iter = middleware_chain(func, middlewares_resolvers)
+    chain_iter = middleware_chain(func, middlewares_resolvers, wrap_in_promise=True)
 
     assert_stdout(capsys, "")
 
     chain_iter()
 
     expected_stdout = (
-        'resolve() called for middleware c\n'
-        'resolve() called for middleware b\n'
-        'resolve() called for middleware a\n'
-        'then() for a\n'
-        'then() for b\n'
-        'then() for c\n'
+        "resolve() called for middleware c\n"
+        "resolve() called for middleware b\n"
+        "resolve() called for middleware a\n"
+        "then() for a\n"
+        "then() for b\n"
+        "then() for c\n"
     )
     assert_stdout(capsys, expected_stdout)
 
 
 def assert_stdout(capsys, expected_stdout):
+    # type: (Any, str) -> None
     captured = capsys.readouterr()
     assert captured.out == expected_stdout

graphql/execution/utils.py

@@ -136,13 +136,12 @@ def get_field_resolver(self, field_resolver):
     def get_argument_values(self, field_def, field_ast):
         # type: (GraphQLField, Field) -> Dict[str, Any]
         k = field_def, field_ast
-        result = self.argument_values_cache.get(k)
-        if not result:
-            result = self.argument_values_cache[k] = get_argument_values(
+        if k not in self.argument_values_cache:
+            self.argument_values_cache[k] = get_argument_values(
                 field_def.args, field_ast.arguments, self.variable_values
             )
 
-        return result
+        return self.argument_values_cache[k]
 
     def report_error(self, error, traceback=None):
         # type: (Exception, Optional[TracebackType]) -> None

graphql/flags.py

@@ -0,0 +1,9 @@
+# This file makes it easier to know what are the features
+# the GraphQL-core API supports
+
+# This permits to plug different backend when executing graphql(...)
+BACKEND_EXECUTOR = True
+
+# This add a new path attribute to ResolveInfo, filled with the
+# path of the field where is being executed
+PATH_IN_RESOLVEINFO = True