def test_object_builder_creates_object_using_field_resolvers(self):
User = g.ObjectType("User",
fields=(g.field("name",
type=g.String,
params=(g.param(
"truncate",
type=g.Int,
default=None), )), ))
object_builder = g.create_object_builder(
User(
g.key("name", User.fields.name()),
g.key("initial",
User.fields.name(User.fields.name.params.truncate(1))),
))
@object_builder.field(User.fields.name)
def resolve_name(field_query):
if field_query.args.truncate is None:
return lambda user: user["name"]
else:
return lambda user: user["name"][:field_query.args.truncate]
result = object_builder({"name": "Bob"})
assert_that(result, has_attrs(
name="Bob",
initial="B",
))
def test_object_builder_getters_access_value_directly(self):
User = g.ObjectType("User",
fields=(
g.field("name", type=g.String),
g.field("email_address", type=g.String),
))
object_builder = g.create_object_builder(
User(
g.key("n", User.fields.name()),
g.key("e", User.fields.email_address()),
))
@object_builder.getter(User.fields.name)
def resolve_name(user):
return user["name"]
@object_builder.getter(User.fields.email_address)
def resolve_email_address(user):
return user["emailAddress"]
result = object_builder({
"name": "Bob",
"emailAddress": "*****@*****.**"
})
assert_that(result, has_attrs(
n="Bob",
e="*****@*****.**",
))
def test_when_type_is_object_then_typename_field_is_resolved(self):
User = g.ObjectType("User", fields=(g.field("name", type=g.String), ))
object_builder = g.create_object_builder(
User(g.key("type", schema.typename_field()), ))
result = object_builder({})
assert_that(result, has_attrs(type="User", ))
def test_when_type_is_interface_then_typename_field_is_unresolved(self):
User = g.InterfaceType("User",
fields=(g.field("name", type=g.String), ))
object_builder = g.create_object_builder(
User(g.key("type", schema.typename_field()), ))
error = pytest.raises(g.GraphError, lambda: object_builder({}))
assert_that(str(error.value),
equal_to("Resolver missing for field type_name"))
def resolve_books(graph, query, books):
build_book_object = g.create_object_builder(query.type_query)
@build_book_object.getter(Book.fields.title)
def field_title(book):
return book
return {
book_id: build_book_object(books[book_id])
for book_id in query.ids
}
def test_field_resolvers_can_be_defined_using_field_name(self):
User = g.ObjectType("User", fields=(g.field("name", type=g.String), ))
object_builder = g.create_object_builder(
User(g.key("n", User.fields.name()), ))
@object_builder.getter("name")
def resolve_name(user):
return user["name"]
result = object_builder({"name": "Bob"})
assert_that(result, has_attrs(n="Bob", ))
def field_page_info(field_query):
build_page_info = g.create_object_builder(field_query.type_query)
@build_page_info.getter(PageInfo.fields.has_next_page)
def field_has_next_page(_):
return has_next_page
@build_page_info.getter(PageInfo.fields.end_cursor)
def field_end_cursor(_):
if edge_cursors:
return cursor_encoding.encode(edge_cursors[-1])
else:
return None
return lambda _: build_page_info(None)
def field_edges(field_query):
build_edge = g.create_object_builder(
field_query.type_query.element_query)
@build_edge.getter(Edge.fields.cursor)
def field_cursor(cursor):
return cursor_encoding.encode(cursor)
@build_edge.field(Edge.fields.node)
def field_node(field_query):
edges = graph.resolve(
select_by_cursor(field_query.type_query, edge_cursors))
return lambda edge_cursor: edges[edge_cursor]
return lambda _: [
build_edge(edge_cursor) for edge_cursor in edge_cursors
]
def test_constant_uses_value_to_resolve_field(self):
User = g.ObjectType("User",
fields=(
g.field("name", type=g.String),
g.field("email_address", type=g.String),
))
object_builder = g.create_object_builder(
User(
g.key("n", User.fields.name()),
g.key("e", User.fields.email_address()),
))
object_builder.constant(User.fields.name, "Bob")
object_builder.constant(User.fields.email_address, "*****@*****.**")
result = object_builder(None)
assert_that(result, has_attrs(
n="Bob",
e="*****@*****.**",
))
def test_attr_uses_attr_name_to_resolve_field(self):
User = g.ObjectType("User",
fields=(
g.field("name", type=g.String),
g.field("email_address", type=g.String),
))
object_builder = g.create_object_builder(
User(
g.key("n", User.fields.name()),
g.key("e", User.fields.email_address()),
))
object_builder.attr(User.fields.name, "name")
object_builder.attr(User.fields.email_address, "email")
result = object_builder(
types.SimpleNamespace(name="Bob", email="*****@*****.**"))
assert_that(result, has_attrs(
n="Bob",
e="*****@*****.**",
))
def resolve_connection(graph, query, *, injector):
build_connection = g.create_object_builder(query.type_query)
if query.after is None:
after_cursor = None
else:
after_cursor = cursor_encoding.decode(query.after)
edge_cursors = injector.call_with_dependencies(
fetch_cursors, after_cursor=after_cursor, limit=query.first + 1)
if len(edge_cursors) > query.first:
edge_cursors = edge_cursors[:-1]
has_next_page = True
else:
has_next_page = False
@build_connection.field(Connection.fields.edges)
def field_edges(field_query):
build_edge = g.create_object_builder(
field_query.type_query.element_query)
@build_edge.getter(Edge.fields.cursor)
def field_cursor(cursor):
return cursor_encoding.encode(cursor)
@build_edge.field(Edge.fields.node)
def field_node(field_query):
edges = graph.resolve(
select_by_cursor(field_query.type_query, edge_cursors))
return lambda edge_cursor: edges[edge_cursor]
return lambda _: [
build_edge(edge_cursor) for edge_cursor in edge_cursors
]
@build_connection.field(Connection.fields.nodes)
def field_nodes(field_query):
nodes = graph.resolve(
select_by_cursor(field_query.type_query.element_query,
edge_cursors))
result = [nodes[edge_cursor] for edge_cursor in edge_cursors]
return lambda _: result
@build_connection.field(Connection.fields.page_info)
def field_page_info(field_query):
build_page_info = g.create_object_builder(field_query.type_query)
@build_page_info.getter(PageInfo.fields.has_next_page)
def field_has_next_page(_):
return has_next_page
@build_page_info.getter(PageInfo.fields.end_cursor)
def field_end_cursor(_):
if edge_cursors:
return cursor_encoding.encode(edge_cursors[-1])
else:
return None
return lambda _: build_page_info(None)
return build_connection(None)