def test_when_field_value_in_input_object_in_input_object_is_not_set_then_default_is_used(): Input = schema.InputObjectType( "Input", fields=( schema.input_field("field0", type=schema.Int, default=42), ), ) OuterInput = schema.InputObjectType( "OuterInput", fields=( schema.input_field("value", type=Input), ), ) Root = g.ObjectType( "Root", fields=( g.field("one", type=g.Int, params=[ g.param("arg", type=OuterInput), ]), ), ) graphql_query = """ query { one(arg: {value: {}}) } """ object_query = _document_text_to_graph_query(graphql_query, query_type=Root) assert_that(object_query.field_queries[0].args.arg, has_attrs( value=has_attrs( field0=42, ), ))
def test_when_there_are_fewer_edges_than_requested_then_all_edges_are_fetched( ): graph = create_graph({ 42: "Leave it to Psmith", }) result = graph.resolve( Query( g.key( "books", Query.fields.books_connection( Query.fields.books_connection.params.first(2), g.key( "edges", BooksConnection.fields.edges( g.key( "node", BookEdge.fields.node( g.key("title", Book.fields.title()), )), )), g.key( "page_info", BooksConnection.fields.page_info( g.key("has_next_page", PageInfo.fields.has_next_page()), )), )), )) assert_that( result.books, has_attrs( edges=contains_exactly( has_attrs(node=has_attrs(title="Leave it to Psmith")), ), page_info=has_attrs(has_next_page=False), ))
def test_when_there_are_no_edges_then_connection_is_empty(): graph = create_graph({}) result = graph.resolve( Query( g.key( "books", Query.fields.books_connection( Query.fields.books_connection.params.first(2), g.key( "edges", BooksConnection.fields.edges( g.key( "node", BookEdge.fields.node( g.key("title", Book.fields.title()), )), )), g.key( "page_info", BooksConnection.fields.page_info( g.key("end_cursor", PageInfo.fields.end_cursor()), g.key("has_next_page", PageInfo.fields.has_next_page()), )), )), )) assert_that( result.books, has_attrs( edges=contains_exactly(), page_info=has_attrs(end_cursor=None, has_next_page=False), ))
def test_nodes_can_be_fetched_directly(): graph = create_graph({ 42: "Leave it to Psmith", 43: "The Gentleman's Guide to Vice and Virtue", 44: "Catch-22", }) result = graph.resolve( Query( g.key( "books", Query.fields.books_connection( Query.fields.books_connection.params.first(2), g.key( "nodes", BooksConnection.fields.nodes( g.key("title", Book.fields.title()), )), g.key( "page_info", BooksConnection.fields.page_info( g.key("has_next_page", PageInfo.fields.has_next_page()), )), )), )) assert_that( result.books, has_attrs(nodes=contains_exactly( has_attrs(title="Leave it to Psmith"), has_attrs(title="The Gentleman's Guide to Vice and Virtue"), ), ))
def test_can_recursively_resolve(): Root = g.ObjectType( "Root", fields=lambda: [ g.field("books", type=g.ListType(Book)), ], ) Book = g.ObjectType( "Book", fields=lambda: [ g.field("title", type=g.String), ], ) @g.resolver(Root) def resolve_root(graph, query): return query.create_object(iterables.to_dict( (field_query.key, graph.resolve(field_query.type_query)) for field_query in query.field_queries )) @g.resolver(g.ListType(Book)) def resolve_book(graph, query): books = [ dict(title="Leave it to Psmith"), dict(title="Pericles, Prince of Tyre"), ] return [ query.element_query.create_object(iterables.to_dict( (field_query.key, book[field_query.field.name]) for field_query in query.element_query.field_queries )) for book in books ] resolvers = [resolve_root, resolve_book] query = Root( g.key("books", Root.fields.books( g.key("title", Book.fields.title()), )), ) result = g.create_graph(resolvers).resolve(query) assert_that(result, has_attrs( books=contains_exactly( has_attrs(title="Leave it to Psmith"), has_attrs(title="Pericles, Prince of Tyre"), ), ))
def test_can_get_fields_backed_by_expressions(): Base = sqlalchemy.ext.declarative.declarative_base() class BookRow(Base): __tablename__ = "book" c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True) c_title = sqlalchemy.Column(sqlalchemy.Unicode, nullable=False) engine = sqlalchemy.create_engine("sqlite:///:memory:") Base.metadata.create_all(engine) session = sqlalchemy.orm.Session(engine) session.add(BookRow(c_title="Leave it to Psmith")) session.add(BookRow(c_title="Pericles, Prince of Tyre")) session.commit() Book = g.ObjectType( "Book", fields=lambda: [ g.field("title", type=g.String), ], ) book_resolver = gsql.sql_table_resolver( Book, BookRow, fields={ Book.fields.title: gsql.expression(BookRow.c_title), }, ) resolvers = [book_resolver] query = gsql.select( g.ListType(Book)(g.key("title", Book.fields.title()), )) 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(title="Leave it to Psmith", ), has_attrs(title="Pericles, Prince of Tyre", ), ))
def matches_when_properties_all_match(): matcher = has_attrs( username=equal_to("bob"), email_address=equal_to("*****@*****.**"), ) assert_equal(matched(), matcher.match(User("bob", "*****@*****.**")))
def test_can_get_scalar_from_root(): Root = g.ObjectType( "Root", fields=[ g.field("one", type=g.Int), g.field("two", type=g.Int), ], ) @g.resolver(Root) def resolve_root(graph, query): values = dict( one=1, two=2, ) return query.create_object( iterables.to_dict((field_query.key, values[field_query.field.name]) for field_query in query.fields)) resolvers = [resolve_root] query = Root(g.key("value", Root.fields.one()), ) result = g.create_graph(resolvers).resolve(query) assert_that(result, has_attrs(value=1))
def test_diff_with_render_true_renders_content(self): # TODO: handle rendering when last_render is out of date content = dedent(""" --- old +++ new @@ -1,2 +1,2 @@ -x = 1 +x = 2 print(x) """) element = parser.Diff( name="example", content=content, render=True, ) state = { "example": compiler.Code( language="python", content="x = 1\nprint(x)\n", pending_lines=(), ), } new_state, new_element = _execute(state, element) assert_that(new_element, is_literal_block(content=content)) assert_that(new_state["example"], has_attrs(pending_lines=is_sequence()))
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_field_value_in_input_object_in_list_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.ListType(Input)), ]), ), ) graphql_query = """ query ($value: Int!) { one(arg: [{}]) } """ object_query = _document_text_to_graph_query(graphql_query, query_type=Root) assert_that(object_query.fields[0].args.arg, is_sequence(has_attrs(field0=42, ), ))
def submatcher_is_coerced_to_matcher(): matcher = has_attrs(username="******") assert_equal( unmatched("attribute username was 'bobbity'"), matcher.match(User("bobbity", None)) )
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_diff_with_render_false_renders_nothing(self): element = parser.Diff( name="example", content=dedent(""" --- old +++ new @@ -1,2 +1,2 @@ -x = 1 +x = 2 print(x) """), render=False, ) state = { "example": compiler.Code( language="python", content="x = 1\nprint(x)\n", pending_lines=(), ), } new_state, new_element = _execute(state, element) assert_that(new_element, is_empty_element) assert_that(new_state["example"], has_attrs(pending_lines=is_sequence("x = 2")))
def can_pass_properties_as_dictionary(): matcher = has_attrs({ "username": equal_to("bob"), }) assert_equal("object with attributes:\n * username: '******'", matcher.describe())
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 is_graphql_argument(type=None): if type is None: type = anything return all_of( is_instance(graphql.GraphQLArgument), has_attrs(type=type), )
def mismatches_when_property_is_missing(): matcher = has_attrs( ("username", equal_to("bob")), ("email_address", equal_to("*****@*****.**")), ) assert_equal(unmatched("was missing attribute username"), matcher.match("bobbity"))
def can_pass_properties_as_dictionary(): matcher = has_attrs({ "username": equal_to("bob"), }) assert_equal( "object with attributes:\n * username: '******'", matcher.describe() )
def description_contains_descriptions_of_properties(): matcher = has_attrs( username=equal_to("bob"), ) assert_equal( "object with attributes:\n * username: '******'", matcher.describe() )
def explanation_of_mismatch_contains_mismatch_of_property(): matcher = has_attrs( username=equal_to("bob"), email_address=equal_to("*****@*****.**"), ) assert_equal( unmatched("attribute email_address was '*****@*****.**'"), matcher.match(User("bob", "*****@*****.**")))
def can_pass_properties_as_list_of_tuples(): matcher = has_attrs( ("username", equal_to("bob")), ("email_address", equal_to("*****@*****.**")), ) assert_equal( "object with attributes:\n * username: '******'\n * email_address: '*****@*****.**'", matcher.describe())
def can_pass_properties_as_list_of_tuples(): matcher = has_attrs( ("username", equal_to("bob")), ("email_address", equal_to("*****@*****.**")), ) assert_equal( "object with attributes:\n * username: '******'\n * email_address: '*****@*****.**'", matcher.describe() )
def mismatches_when_property_is_missing(): matcher = has_attrs( ("username", equal_to("bob")), ("email_address", equal_to("*****@*****.**")), ) assert_equal( unmatched("was missing attribute username"), matcher.match("bobbity") )
def explanation_of_mismatch_contains_mismatch_of_property(): matcher = has_attrs( username=equal_to("bob"), email_address=equal_to("*****@*****.**"), ) assert_equal( unmatched("attribute email_address was '*****@*****.**'"), matcher.match(User("bob", "*****@*****.**")) )
def is_graphql_field(type=None, args=None): if type is None: type = anything if args is None: args = anything return all_of( is_instance(graphql.GraphQLField), has_attrs(type=type, args=args), )
def is_graphql_interface_type(name, fields=None): if fields is None: fields = anything return all_of( is_instance(graphql.GraphQLInterfaceType), has_attrs( name=name, fields=fields, ), )
def test_given_no_mutation_type_is_defined_when_operation_is_mutation_then_error_is_raised(): QueryRoot = g.ObjectType( "Query", ( g.field("query_value", type=g.Int), ), ) graphql_query = """ mutation { queryValue } """ error = pytest.raises( GraphQLError, lambda: _document_text_to_graph_query(graphql_query, query_type=QueryRoot), ) assert_that(error.value.message, equal_to("unsupported operation: mutation")) assert_that(error.value.nodes, is_sequence(has_attrs(operation=has_attrs(value="mutation"))))
def test_start_with_render_false_renders_nothing(self): element = parser.Start( name="example", language="python", content="x = 1\nprint(x)", render=False, ) state = {} new_state, new_element = _execute(state, element) assert_that(new_element, is_empty_element) assert_that(new_state["example"], has_attrs(pending_lines=is_sequence("x = 1", "print(x)")))
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 test_run_operator_can_be_created(): run_operator = SpellRunOperator( spell_conn_id="testing-spell-run-operator", task_id="testing-task-id", ) assert_that( run_operator, has_attrs( spell_conn_id="testing-spell-run-operator", task_id="testing-task-id", ), )
def is_graphql_input_object_type(name=None, fields=None): if name is None: name = anything if fields is None: fields = anything return all_of( is_instance(graphql.GraphQLInputObjectType), has_attrs( name=name, fields=fields, ), )
def is_query(query): if isinstance(query, schema.ScalarQuery): return is_instance(schema.ScalarQuery) elif isinstance(query, schema.EnumQuery): return is_instance(schema.EnumQuery) elif isinstance(query, schema.FieldQuery): return has_attrs( key=query.key, field=query.field, type_query=is_query(query.type_query), args=has_attrs(_values=is_mapping(query.args._values)), ) elif isinstance(query, schema.ListQuery): return has_attrs( type=query.type, element_query=is_query(query.element_query), ) elif isinstance(query, schema.NullableQuery): return has_attrs( type=query.type, element_query=is_query(query.element_query), ) elif isinstance(query, schema.ObjectQuery): return has_attrs( type=query.type, field_queries=is_sequence( * [is_query(field_query) for field_query in query.field_queries]), ) else: raise Exception("Unhandled query type: {}".format(type(query)))
def test_given_input_field_has_default_when_input_field_is_not_set_then_default_is_used(): Input = schema.InputObjectType( "Input", fields=( schema.input_field("field0", type=schema.Int, default=None), schema.input_field("field1", type=schema.Int, default=42), ), ) input_value = Input() assert_that(input_value, has_attrs( field0=None, field1=42, ))
def test_render_does_not_change_code_content(self): element = parser.Render( name="example", content="print(x)", ) state = { "example": _create_code( language="python", content="x = 1\nprint(x)", ), } new_state, new_element = _execute(state, element) assert_that(new_state["example"], has_attrs(content="x = 1\nprint(x)"))
def test_start_with_render_true_renders_content(self): element = parser.Start( name="example", language="python", content="x = 1", render=True, ) state = {} new_state, new_element = _execute(state, element) assert_that(new_element, is_code_block( language="python", content="x = 1", )) assert_that(new_state["example"], has_attrs(pending_lines=is_sequence()))
def is_text(value): return all_of( instance_of(documents.Text), has_attrs(value=value), )
def matcher(**kwargs): return all_of( instance_of(element_type), has_attrs(**kwargs), )