def test_when_null_variable_is_missing_then_variable_is_null():
Root = g.ObjectType(
"Root",
fields=(
g.field("one", type=g.Int, params=[
g.param("arg", type=g.NullableType(g.Int)),
]),
),
)
graphql_query = """
query ($var: Int) {
one(arg: $var)
}
"""
object_query = _document_text_to_graph_query(graphql_query, query_type=Root, variables={})
assert_that(object_query, is_query(
Root(
g.key("one", Root.fields.one(
Root.fields.one.params.arg(None),
)),
),
))
def test_when_field_value_in_nullable_input_object_is_not_set_then_default_is_used():
Input = schema.InputObjectType(
"Input",
fields=(
schema.input_field("field0", type=schema.Int, default=42),
),
)
Root = g.ObjectType(
"Root",
fields=(
g.field("one", type=g.Int, params=[
g.param("arg", type=g.NullableType(Input)),
]),
),
)
graphql_query = """
query {
one(arg: {})
}
"""
object_query = _document_text_to_graph_query(graphql_query, query_type=Root)
assert_that(object_query.field_queries[0].args.arg, has_attrs(
field0=42,
))
def test_fragment_can_be_spread_into_nullable_type():
User = g.ObjectType("User", fields=lambda: (
g.field("name", type=g.String),
))
Root = g.ObjectType(
"Root",
fields=lambda: (
g.field("user", type=g.NullableType(User)),
),
)
graphql_query = """
query {
user {
... on User {
name
}
}
}
"""
object_query = _document_text_to_graph_query(graphql_query, query_type=Root)
assert_that(object_query, is_query(
Root(
g.key("user", Root.fields.user(
g.key("name", User.fields.name()),
)),
),
))
def field(self, field_name):
return g.field(field_name,
type=self.Connection,
params=(
g.param("after",
type=g.NullableType(g.String),
default=None),
g.param("first", type=g.Int),
))
def test_fragment_fields_are_updated_to_fields_for_element_type():
Person = g.InterfaceType(
"Person",
fields=lambda: (
g.field("name", type=g.String),
),
)
User = g.ObjectType(
"User",
fields=lambda: (
g.field("name", type=g.String),
),
interfaces=lambda: (Person, ),
)
Root = g.ObjectType(
"Root",
fields=lambda: (
g.field("users", type=g.ListType(g.NullableType(User))),
),
)
graphql_query = """
query {
users {
... on Person {
name
}
}
}
"""
object_query = _document_text_to_graph_query(graphql_query, query_type=Root)
assert_that(object_query, is_query(
Root(
g.key("users", Root.fields.users(
g.key("name", User.fields.name()),
)),
),
))
self.select_field = select_field
def field(self, field_name):
return g.field(field_name,
type=self.Connection,
params=(
g.param("after",
type=g.NullableType(g.String),
default=None),
g.param("first", type=g.Int),
))
PageInfo = g.ObjectType(
"PageInfo",
fields=lambda: (
g.field("end_cursor", type=g.NullableType(g.String)),
g.field("has_next_page", type=g.Boolean),
),
)
class int_cursor_encoding(object):
@staticmethod
def encode(cursor):
return base64.b64encode(str(cursor).encode("ascii")).decode("ascii")
@staticmethod
def decode(cursor):
return int(base64.b64decode(cursor.encode("ascii")).decode("ascii"))
def test_nullable_type_is_converted_to_graphql_type_without_non_null():
assert_that(to_graphql_type(g.NullableType(g.Boolean)), is_graphql_boolean)
import graphlayer as g
import graphlayer.connections
import graphlayer.sqlalchemy as gsql
from .. import database
Molecule = g.ObjectType(
"Molecule",
fields=lambda: (
g.field("pref_name", type=g.NullableType(g.String)),
g.field("chembl_id", type=g.String),
g.field("synonyms", type=g.ListType(MoleculeSynonym)),
),
)
class MoleculeQuery(object):
@staticmethod
def select(query):
return gsql.select(query)
@staticmethod
def select_by_molregno(query, molregnos):
return gsql.select(query).by(database.Molecule.molregno, molregnos)
resolve_molecule = gsql.sql_table_resolver(
Molecule,
database.Molecule,
fields=lambda: {
class Season(enum.Enum):
winter = "WINTER"
spring = "SPRING"
summer = "SUMMER"
autumn = "AUTUMN"
# TODO: deduplicate arg/variable tests
@pytest.mark.parametrize("arg_type, arg_string, arg_value", [
(g.Boolean, "true", True),
(g.Float, "4.2", 4.2),
(g.Int, "42", 42),
(g.String, '"value"', "value"),
(g.EnumType(Season), 'WINTER', Season.winter),
(g.NullableType(g.Int), "42", 42),
(g.NullableType(g.Int), "null", None),
(g.ListType(g.Int), "[]", []),
(g.ListType(g.Int), "[1, 2, 3]", [1, 2, 3]),
(
g.InputObjectType("User", fields=(
g.input_field("id", type=g.Int),
g.input_field("name", type=g.String),
)),
'{id: 42, name: "Bob"}',
lambda input_type: input_type(id=42, name="Bob"),
),
(
g.InputObjectType("Casing", fields=(
g.input_field("field_zero", type=g.Int),
)),
def test_can_resolve_many_to_one_or_zero_field():
Base = sqlalchemy.ext.declarative.declarative_base()
class LeftRow(Base):
__tablename__ = "left"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
class RightRow(Base):
__tablename__ = "right"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
engine = sqlalchemy.create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sqlalchemy.orm.Session(engine)
session.add(LeftRow(c_id=1, c_value="one"))
session.add(RightRow(c_id=1, c_value="two"))
session.add(LeftRow(c_id=2, c_value="three"))
session.commit()
Left = g.ObjectType(
"Left",
fields=lambda: [
g.field("value", type=g.String),
g.field("right", type=g.NullableType(Right)),
],
)
Right = g.ObjectType(
"Right",
fields=lambda: [
g.field("value", type=g.String),
],
)
left_resolver = gsql.sql_table_resolver(
Left,
LeftRow,
fields={
Left.fields.value:
gsql.expression(LeftRow.c_value),
Left.fields.right:
g.single_or_null(gsql.sql_join({
LeftRow.c_id: RightRow.c_id,
})),
},
)
right_resolver = gsql.sql_table_resolver(
Right,
RightRow,
fields={
Right.fields.value: gsql.expression(RightRow.c_value),
},
)
resolvers = [left_resolver, right_resolver]
query = gsql.select(
g.ListType(Left)(
g.key("value", Left.fields.value()),
g.key("right",
Left.fields.right(g.key("value", Right.fields.value()), )),
))
graph_definition = g.define_graph(resolvers)
graph = graph_definition.create_graph({sqlalchemy.orm.Session: session})
result = graph.resolve(query)
assert_that(
result,
contains_exactly(
has_attrs(
value="one",
right=has_attrs(value="two", ),
),
has_attrs(
value="three",
right=None,
),
))
class Season(enum.Enum):
winter = "WINTER"
spring = "SPRING"
summer = "SUMMER"
autumn = "AUTUMN"
@pytest.mark.parametrize(
"arg_type, arg_string, arg_value",
[
(g.Boolean, "true", True),
(g.Float, "4.2", 4.2),
(g.Int, "42", 42),
(g.String, '"value"', "value"),
(g.EnumType(Season), '"WINTER"', Season.winter),
(g.NullableType(g.Int), "42", 42),
#~ (g.NullableType(g.Int), "null", None),
(g.ListType(g.Int), "[]", []),
(g.ListType(g.Int), "[1, 2, 3]", [1, 2, 3]),
(
g.InputObjectType("User",
fields=(
g.input_field("id", type=g.Int),
g.input_field("name", type=g.String),
)),
'{id: 42, name: "Bob"}',
g.Object({
"id": 42,
"name": "Bob"
}),
),
