def with_function_and_object():
doc = parse("{ field }")
# noinspection PyMethodMayBeStatic
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]
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"} # type: ignore
middlewares = MiddlewareManager(CaptitalizeMiddleware(), reverse_middleware)
result = execute(
GraphQLSchema(test_type), doc, Data(), middleware=middlewares
)
assert result.data == {"field": "devloseR"} # type: ignore
def test_middleware_skip_promise_wrap():
# type: () -> None
doc = """{
ok
not_ok
}"""
class Data(object):
def ok(self):
# type: () -> str
return "ok"
def not_ok(self):
# type: () -> str
return "not_ok"
doc_ast = parse(doc)
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
)
middlewares_without_promise = MiddlewareManager(
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
)
assert result1.data == result2.data and result1.data == {
"ok": "ok",
"not_ok": "not_ok",
}
def test_middleware_class():
doc = '''{
ok
not_ok
}'''
class Data(object):
def ok(self):
return 'ok'
def not_ok(self):
return 'not_ok'
doc_ast = parse(doc)
Type = GraphQLObjectType('Type', {
'ok': GraphQLField(GraphQLString),
'not_ok': GraphQLField(GraphQLString),
})
class MyMiddleware(object):
def resolve(self, next, *args, **kwargs):
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'}
async def single_async_function():
doc = parse("{ first second }")
# noinspection PyMethodMayBeStatic
class Data:
async def first(self, _info):
return "one"
async def second(self, _info):
return "two"
test_type = GraphQLObjectType(
"TestType",
{
"first": GraphQLField(GraphQLString),
"second": GraphQLField(GraphQLString),
},
)
async def reverse_middleware(next_, *args, **kwargs):
return (await next_(*args, **kwargs))[::-1]
middlewares = MiddlewareManager(reverse_middleware)
awaitable_result = execute(
GraphQLSchema(test_type), doc, Data(), middleware=middlewares
)
assert isinstance(awaitable_result, Awaitable)
result = await awaitable_result
assert result.data == {"first": "eno", "second": "owt"}
def two_functions_and_field_resolvers():
doc = parse("{ first second }")
# noinspection PyMethodMayBeStatic
class Data:
first = "one"
second = "two"
test_type = GraphQLObjectType(
"TestType",
{
"first": GraphQLField(
GraphQLString, resolve=lambda obj, _info: obj.first
),
"second": GraphQLField(
GraphQLString, resolve=lambda obj, _info: obj.second
),
},
)
def reverse_middleware(next_, *args, **kwargs):
return next_(*args, **kwargs)[::-1]
def capitalize_middleware(next_, *args, **kwargs):
return next_(*args, **kwargs).capitalize()
middlewares = MiddlewareManager(reverse_middleware, capitalize_middleware)
result = execute(
GraphQLSchema(test_type), doc, Data(), middleware=middlewares
)
assert result.data == {"first": "Eno", "second": "Owt"} # type: ignore
def single_object():
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),
},
)
class ReverseMiddleware:
# noinspection PyMethodMayBeStatic
def resolve(self, 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"} # type: ignore
def test_middleware_class():
# type: () -> None
doc = """{
ok
not_ok
}"""
class Data(object):
def ok(self):
# type: () -> str
return "ok"
def not_ok(self):
# type: () -> str
return "not_ok"
doc_ast = parse(doc)
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"}
def test_middleware_skip_promise_wrap():
doc = '''{
ok
not_ok
}'''
class Data(object):
def ok(self):
return 'ok'
def not_ok(self):
return 'not_ok'
doc_ast = parse(doc)
Type = GraphQLObjectType('Type', {
'ok': GraphQLField(GraphQLString),
'not_ok': GraphQLField(GraphQLString),
})
class MyPromiseMiddleware(object):
def resolve(self, next, *args, **kwargs):
return Promise.resolve(next(*args, **kwargs))
class MyEmptyMiddleware(object):
def resolve(self, next, *args, **kwargs):
return next(*args, **kwargs)
middlewares_with_promise = MiddlewareManager(MyPromiseMiddleware(),
wrap_in_promise=False)
middlewares_without_promise = MiddlewareManager(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)
assert result1.data == result2.data and result1.data == {
'ok': 'ok',
'not_ok': 'not_ok'
}
def get_middleware_for_request(
self, environ: dict, context: Optional[ContextValue]
) -> Optional[MiddlewareManager]:
middleware = self.middleware
if callable(middleware):
middleware = middleware(environ, context)
if middleware:
return MiddlewareManager(*middleware)
return None
async def get_middleware_for_request(
self, request: Any,
context: Optional[ContextValue]) -> Optional[MiddlewareManager]:
middleware = self.middleware
if callable(middleware):
middleware = middleware(request, context)
if isawaitable(middleware):
middleware = await middleware # type: ignore
if middleware:
middleware = cast(list, middleware)
return MiddlewareManager(*middleware)
return None
def skip_middleware_without_resolve_method():
class BadMiddleware:
pass # no resolve method here
assert execute(
GraphQLSchema(
GraphQLObjectType(
"TestType",
{"foo": GraphQLField(GraphQLString)},
)
),
parse("{ foo }"),
{"foo": "bar"},
middleware=MiddlewareManager(BadMiddleware()),
) == ({"foo": "bar"}, None)
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" # type: ignore
def as_middleware_manager(
self, manager: Optional[MiddlewareManager]) -> MiddlewareManager:
if manager and manager.middlewares:
return MiddlewareManager(*self.extensions, *manager.middlewares)
return MiddlewareManager(*self.extensions)
