def graphlayer_performance():
import graphlayer as g
from graphlayer import graphql
User = g.ObjectType("User",
fields=(
g.field("id", type=g.Int),
g.field("name", type=g.String),
))
Query = g.ObjectType("Query",
fields=(g.field("users", type=g.ListType(User)), ))
root_resolver = g.root_object_resolver(Query)
@root_resolver.field(Query.fields.users)
def root_resolve_users(graph, query, args):
return graph.resolve(query)
@g.resolver(g.ListType(User))
def resolve_users(graph, query):
return [
query.element_query.create_object(
dict((field_query.key, getattr(user, field_query.field.name))
for field_query in query.element_query.fields))
for user in users
]
resolvers = (root_resolver, resolve_users)
graph_definition = g.define_graph(resolvers=resolvers)
graph = graph_definition.create_graph({})
return lambda document_text: graphql.execute(
graph=graph, document_text=document_text, query_type=Query)
def test_can_query_schema():
Root = g.ObjectType("Root", fields=(g.field("value", g.String), ))
graph_definition = g.define_graph(resolvers=())
graph = graph_definition.create_graph({})
query = """
query {
__schema {
queryType { name }
}
}
"""
result = graphql.execute(graph=graph, document_text=query, query_type=Root)
assert_that(
result,
is_success(data=equal_to({
"__schema": {
"queryType": {
"name": "Root",
},
},
})))
def test_can_query_schema_with_other_data():
Root = g.ObjectType("Root", fields=(g.field("value", g.String), ))
root_resolver = g.root_object_resolver(Root)
@root_resolver.field(Root.fields.value)
def root_resolve_value(graph, query, args):
return "resolved"
graph_definition = g.define_graph(resolvers=(root_resolver, ))
graph = graph_definition.create_graph({})
query = """
query {
value
__schema {
queryType { name }
}
}
"""
result = graphql.execute(graph=graph, document_text=query, query_type=Root)
assert_that(
result,
is_success(data=equal_to({
"value": "resolved",
"__schema": {
"queryType": {
"name": "Root",
},
},
})))
def test_typename():
Root = g.ObjectType("Root", fields=(g.field("value", g.String), ))
root_resolver = g.root_object_resolver(Root)
@root_resolver.field(Root.fields.value)
def root_resolve_value(graph, query, args):
return "resolved"
graph_definition = g.define_graph(resolvers=(root_resolver, ))
graph = graph_definition.create_graph({})
query = """
query {
__typename
value
typename: __typename
}
"""
result = graphql.execute(graph=graph, document_text=query, query_type=Root)
assert_that(
result,
is_success(data=equal_to({
"__typename": "Root",
"value": "resolved",
"typename": "Root"
})))
def test_variables_can_be_used_in_schema_query():
Root = g.ObjectType("Root", fields=(g.field("value", g.String), ))
graph_definition = g.define_graph(resolvers=())
graph = graph_definition.create_graph({})
query = """
query ($f: Boolean!, $t: Boolean!) {
included: __schema @include(if: $t) {
queryType { name }
}
excluded: __schema @include(if: $f) {
queryType { name }
}
}
"""
variables = {"t": True, "f": False}
result = graphql.execute(graph=graph,
document_text=query,
query_type=Root,
variables=variables)
assert_that(
result,
is_success(data=equal_to({
"included": {
"queryType": {
"name": "Root",
},
},
})))
def test_when_resolution_raises_graph_error_then_result_is_invalid():
Root = g.ObjectType("Root", fields=(
g.field("value", g.String),
))
root_resolver = g.root_object_resolver(Root)
@root_resolver.field(Root.fields.value)
def root_resolve_value(graph, query, args):
raise g.GraphError("BAD")
graph_definition = g.define_graph(resolvers=(root_resolver, ))
graph = graph_definition.create_graph({})
query = """
query {
value
}
"""
result = graphql.execute(graph=graph, document_text=query, query_type=Root)
assert_that(result, is_invalid(errors=contains_exactly(
all_of(
is_instance(GraphQLError),
has_str("BAD"),
),
)))
def test_query_is_validated():
Root = g.ObjectType("Root", fields=(
g.field("value", g.String),
))
graph_definition = g.define_graph(resolvers=())
graph = graph_definition.create_graph({})
query = """
{
x
}
"""
error = pytest.raises(GraphQLError, lambda: graphql.execute(graph=graph, document_text=query, query_type=Root))
assert_that(str(error.value), equal_to(('Cannot query field "x" on type "Root".')))
def test_when_query_is_invalid_then_result_is_invalid():
Root = g.ObjectType("Root", fields=(g.field("value", g.String), ))
graph_definition = g.define_graph(resolvers=())
graph = graph_definition.create_graph({})
query = """
query {
bad
}
"""
result = graphql.execute(graph=graph, document_text=query, query_type=Root)
assert_that(
result,
is_invalid(errors=contains_exactly(
has_attrs(message="Cannot query field 'bad' on type 'Root'."), )))
