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" }), ),