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)