def _preheat(schema_name: str) -> "GraphQLSchema":
"""
Loads the SDL and converts it to a GraphQLSchema instance before baking
each registered objects of this schema.
:param schema_name: name of the schema to treat
:type schema_name: str
:return: a pre-baked GraphQLSchema instance
:rtype: GraphQLSchema
"""
schema_info = SchemaRegistry.find_schema_info(schema_name)
sdl = schema_info["sdl"]
schema = schema_from_sdl(sdl, schema_name=schema_name)
schema_info["inst"] = schema
return schema
def _preheat(schema_name: str) -> GraphQLSchema:
schema_info = SchemaRegistry.find_schema_info(schema_name)
schema = schema_info.get("inst", GraphQLSchema(name=schema_name))
sdl = schema_info["sdl"]
build_graphql_schema_from_sdl(sdl, schema=schema)
for object_ids in _SCHEMA_OBJECT_IDS:
for obj in schema_info.get(object_ids, {}).values():
obj.bake(schema)
schema_info["inst"] = schema
return schema
def _preheat(
schema_name: str,
exclude_builtins_scalars: Optional[List[str]]) -> GraphQLSchema:
schema_info = SchemaRegistry.find_schema_info(schema_name)
schema = schema_info.get("inst", GraphQLSchema(name=schema_name))
sdl = schema_info["sdl"]
build_graphql_schema_from_sdl(sdl, schema=schema)
SchemaBakery._inject_default_object(schema_name,
exclude_builtins_scalars)
for object_ids in _SCHEMA_OBJECT_IDS:
for obj in schema_info.get(object_ids, {}).values():
obj.bake(schema)
schema_info["inst"] = schema
return schema
def pytest_runtest_setup(item):
marker = _get_ttftt_engine_marker(item)
if not marker or not getattr(item, "allow_schema_bake", True):
return
resolvers = marker.kwargs.get("resolvers") or {}
type_resolvers = marker.kwargs.get("type_resolvers") or {}
subscriptions = marker.kwargs.get("subscriptions") or {}
directives = marker.kwargs.get("directives") or {}
if not (resolvers or subscriptions or directives):
return
schema_name = _get_schema_name_from_marker(marker)
# Init schema definitions
SchemaRegistry._schemas.setdefault(schema_name, {})
# Reset schema resolvers
if resolvers:
SchemaRegistry._schemas[schema_name]["resolvers"] = {}
# Reset schema type_resolvers
if type_resolvers:
SchemaRegistry._schemas[schema_name]["type_resolvers"] = {}
if subscriptions:
SchemaRegistry._schemas[schema_name]["subscriptions"] = {}
if directives:
SchemaRegistry._schemas[schema_name]["directives"] = {}
# Apply "Resolver" decorators to resolvers functions
for name, implementation in resolvers.items():
Resolver(name, schema_name=schema_name)(implementation)
# Apply "TypeResolver" decorators to type resolvers functions
for name, implementation in type_resolvers.items():
TypeResolver(name, schema_name=schema_name)(implementation)
# Apply "Subscription" decorators to resolvers functions
for name, implementation in subscriptions.items():
Subscription(name, schema_name=schema_name)(implementation)
# Apply "Directive" decorators to resolvers functions
for name, implementation in directives.items():
Directive(name, schema_name=schema_name)(implementation)
# Bake resolvers
for resolver in (SchemaRegistry._schemas[schema_name].get("resolvers")
or {}).values():
resolver.bake(_TTFTT_ENGINES[schema_name]._schema)
# Bake type resolvers
for type_resolver in (
SchemaRegistry._schemas[schema_name].get("type_resolvers")
or {}).values():
type_resolver.bake(_TTFTT_ENGINES[schema_name]._schema)
# Bake subscriptions
for subscription in (
SchemaRegistry._schemas[schema_name].get("subscriptions")
or {}).values():
subscription.bake(_TTFTT_ENGINES[schema_name]._schema)
# Bake directives
for directive in (SchemaRegistry._schemas[schema_name].get("directives")
or {}).values():
directive.bake(_TTFTT_ENGINES[schema_name]._schema)
# Re-bake engine schema
SchemaRegistry.find_schema_info(
schema_name=schema_name)["inst"] = _TTFTT_ENGINES[schema_name]._schema
loop = asyncio.new_event_loop()
loop.run_until_complete(_TTFTT_ENGINES[schema_name]._schema.bake())