Some more tests for the middleware implementation

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 
 The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js
 version 14.0.2. All parts of the API are covered by an extensive test suite of
-currently 1609 unit tests.
+currently 1614 unit tests.
 
 
 ## Documentation

graphql/execution/execute.py

@@ -60,7 +60,7 @@ class ExecutionResult(NamedTuple):
 
 ExecutionResult.__new__.__defaults__ = (None, None)  # type: ignore
 
-Middleware = Optional[Union[Iterable[Any], MiddlewareManager]]
+Middleware = Optional[Union[Tuple, List, MiddlewareManager]]
 
 
 def execute(
@@ -168,13 +168,13 @@ def build(
         fragments: Dict[str, FragmentDefinitionNode] = {}
         middleware_manager: Optional[MiddlewareManager] = None
         if middleware is not None:
-            if isinstance(middleware, Iterable):
+            if isinstance(middleware, (list, tuple)):
                 middleware_manager = MiddlewareManager(*middleware)
             elif isinstance(middleware, MiddlewareManager):
                 middleware_manager = middleware
             else:
                 raise TypeError(
-                    "Middleware must be passed as a sequence of functions"
+                    "Middleware must be passed as a list or tuple of functions"
                     " or objects, or as a single MiddlewareManager object."
                     f" Got {middleware!r} instead.")
 

tests/execution/test_middleware.py

@@ -1,3 +1,5 @@
+from pytest import raises
+
 from graphql.execution import MiddlewareManager, execute
 from graphql.language.parser import parse
 from graphql.type import (
@@ -6,86 +8,182 @@
 
 def describe_middleware():
 
-    def with_function_as_middleware():
-        doc = parse("{ first second }")
+    def describe_with_manager():
+
+        def default():
+            doc = parse("{ field }")
+
+            # noinspection PyMethodMayBeStatic
+            class Data:
+                def field(self, _info):
+                    return 'resolved'
+
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            middlewares = MiddlewareManager()
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
+
+            assert result.data['field'] == 'resolved'
+
+        def single_function():
+            doc = parse("{ first second }")
+
+            # noinspection PyMethodMayBeStatic
+            class Data:
+                def first(self, _info):
+                    return 'one'
+
+                def second(self, _info):
+                    return 'two'
+
+            test_type = GraphQLObjectType('TestType', {
+                'first': GraphQLField(GraphQLString),
+                'second': GraphQLField(GraphQLString)})
+
+            def reverse_middleware(next_, *args, **kwargs):
+                return next_(*args, **kwargs)[::-1]
+
+            middlewares = MiddlewareManager(reverse_middleware)
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
 
-        # noinspection PyMethodMayBeStatic
-        class Data:
-            def first(self, _info):
-                return 'one'
+            assert result.data == {'first': 'eno', 'second': 'owt'}
 
-            def second(self, _info):
-                return 'two'
+        def single_object():
+            doc = parse("{ first second }")
 
-        test_type = GraphQLObjectType('Type', {
-            'first': GraphQLField(GraphQLString),
-            'second': GraphQLField(GraphQLString)})
+            # noinspection PyMethodMayBeStatic
+            class Data:
+                def first(self, _info):
+                    return 'one'
 
-        def reverse_middleware(next_, *args, **kwargs):
-            return next_(*args, **kwargs)[::-1]
+                def second(self, _info):
+                    return 'two'
 
-        middlewares = MiddlewareManager(reverse_middleware)
-        result = execute(
-            GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
-        assert result.data == {'first': 'eno', 'second': 'owt'}
+            test_type = GraphQLObjectType('TestType', {
+                'first': GraphQLField(GraphQLString),
+                'second': GraphQLField(GraphQLString)})
 
-    def with_object_as_middleware():
-        doc = parse("{ first second }")
+            class ReverseMiddleware:
 
-        # noinspection PyMethodMayBeStatic
-        class Data:
-            def first(self, _info):
-                return 'one'
+                # noinspection PyMethodMayBeStatic
+                def resolve(self, next_, *args, **kwargs):
+                    return next_(*args, **kwargs)[::-1]
 
-            def second(self, _info):
-                return 'two'
+            middlewares = MiddlewareManager(ReverseMiddleware())
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
 
-        test_type = GraphQLObjectType('Type', {
-            'first': GraphQLField(GraphQLString),
-            'second': GraphQLField(GraphQLString)})
+            assert result.data == {'first': 'eno', 'second': 'owt'}
 
-        class ReverseMiddleware:
+        def with_function_and_object():
+            doc = parse("{ field }")
 
             # noinspection PyMethodMayBeStatic
-            def resolve(self, next_, *args, **kwargs):
+            class Data:
+                def field(self, _info):
+                    return 'resolved'
+
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            def reverse_middleware(next_, *args, **kwargs):
                 return next_(*args, **kwargs)[::-1]
 
-        middlewares = MiddlewareManager(ReverseMiddleware())
-        result = execute(
-            GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
-        assert result.data == {'first': 'eno', 'second': 'owt'}
+            class CaptitalizeMiddleware:
+
+                # noinspection PyMethodMayBeStatic
+                def resolve(self, next_, *args, **kwargs):
+                    return next_(*args, **kwargs).capitalize()
+
+            middlewares = MiddlewareManager(
+                reverse_middleware, CaptitalizeMiddleware())
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
+            assert result.data == {'field': 'Devloser'}
 
-    def with_middleware_chain():
-        doc = parse("{ field }")
+    def describe_without_manager():
 
-        # noinspection PyMethodMayBeStatic
-        class Data:
-            def field(self, _info):
-                return 'resolved'
+        def no_middleware():
+            doc = parse("{ field }")
 
-        test_type = GraphQLObjectType('Type', {
-            'field': GraphQLField(GraphQLString)})
+            # noinspection PyMethodMayBeStatic
+            class Data:
+                def field(self, _info):
+                    return 'resolved'
+
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=None)
+
+            assert result.data['field'] == 'resolved'
+
+        def empty_middleware_list():
+            doc = parse("{ field }")
+
+            # noinspection PyMethodMayBeStatic
+            class Data:
+                def field(self, _info):
+                    return 'resolved'
+
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=[])
+
+            assert result.data['field'] == 'resolved'
 
-        log = []
+        def bad_middleware_object():
+            doc = parse("{ field }")
 
-        class LogMiddleware:
-            def __init__(self, name):
-                self.name = name
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            with raises(TypeError) as exc_info:
+                execute(GraphQLSchema(test_type), doc, None,
+                        middleware={'bad': 'value'})
+
+            assert str(exc_info.value) == (
+                'Middleware must be passed as a list or tuple of functions'
+                ' or objects, or as a single MiddlewareManager object.'
+                " Got {'bad': 'value'} instead.")
+
+        def list_of_functions():
+            doc = parse("{ field }")
 
             # noinspection PyMethodMayBeStatic
-            def resolve(self, next_, *args, **kwargs):
-                log.append(f'enter {self.name}')
-                value = next_(*args, **kwargs)
-                log.append(f'exit {self.name}')
-                return value
-
-        middlewares = [
-            LogMiddleware('A'), LogMiddleware('B'), LogMiddleware('C')]
-
-        result = execute(
-            GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
-        assert result.data == {'field': 'resolved'}
-
-        assert log == [
-            'enter C', 'enter B', 'enter A',
-            'exit A', 'exit B', 'exit C']
+            class Data:
+                def field(self, _info):
+                    return 'resolved'
+
+            test_type = GraphQLObjectType('TestType', {
+                'field': GraphQLField(GraphQLString)})
+
+            log = []
+
+            class LogMiddleware:
+                def __init__(self, name):
+                    self.name = name
+
+                # noinspection PyMethodMayBeStatic
+                def resolve(self, next_, *args, **kwargs):
+                    log.append(f'enter {self.name}')
+                    value = next_(*args, **kwargs)
+                    log.append(f'exit {self.name}')
+                    return value
+
+            middlewares = [
+                LogMiddleware('A'), LogMiddleware('B'), LogMiddleware('C')]
+
+            result = execute(
+                GraphQLSchema(test_type), doc, Data(), middleware=middlewares)
+            assert result.data == {'field': 'resolved'}
+
+            assert log == [
+                'enter C', 'enter B', 'enter A',
+                'exit A', 'exit B', 'exit C']