def test_Schema_is_possible_type_is_accurate(): schema = Schema( ObjectType("Query", [Field("getObject", Interface, resolver=_null_resolver)]), directives=[Dir], ) assert not schema.is_possible_type(Interface, Implementing)
def test_register_resolver_on_root_type(): schema = Schema(ObjectType("Query", [Field("author", BlogAuthor)])) resolver = lambda *_, **__: None schema.register_resolver("Query", "author", resolver) assert schema.query_type.fields[0].resolver is resolver # type: ignore
def test_register_resolver_raises_on_unknown_field(): Object = ObjectType("Object", [Field("id", String)]) schema = Schema(ObjectType("Query", [Field("foo", Object)])) resolver = lambda *_, **__: None with pytest.raises(SchemaError): schema.register_resolver("Object", "foo", resolver)
def test_replace_mutation_type(schema: Schema) -> None: NewMutation = ObjectType( "Mutation", fields=[Field("update_some_number", Int)], ) schema._replace_types_and_directives({"Mutation": NewMutation}) assert schema.mutation_type is NewMutation
def test_register_subscription_raises_on_missing_field(): Query = ObjectType("Query", [Field("id", String)]) Subscription = ObjectType("Subscription", [Field("values", Int)]) schema = Schema(Query, subscription_type=Subscription) with pytest.raises(SchemaError): schema.register_subscription("Subscription", "value", lambda *_: 42)
def test_Schema_is_possible_handles_non_object_types(): schema = Schema( ObjectType("Query", [Field("getObject", Interface, resolver=_null_resolver)]), directives=[Dir], ) assert not schema.is_possible_type(Interface, Int)
def test_Schema_get_type_raises_on_unknown_type(): schema = Schema( ObjectType("Query", [Field("getObject", Interface, resolver=_null_resolver)]), directives=[Dir], ) with pytest.raises(UnknownType): schema.get_type("UnknownType")
def test_Schema_includes_input_types_only_used_in_directives(): schema = Schema( ObjectType("Query", [Field("getObject", Interface, resolver=_null_resolver)]), directives=[Dir], ) assert schema.get_type("DirInput") is DirInput assert schema.get_type("WrappedDirInput") is WrappedDirInput
def test_accept_callable_object(self, schema: Schema) -> None: class Resolver: def __call__(self, root, ctx, info, b, c, a="s"): pass schema.register_resolver("Object", "field", Resolver()) validate_schema(schema)
def test_Schema_is_possible_rejects_non_abstract_types(): schema = Schema( ObjectType("Query", [Field("getObject", Interface, resolver=_null_resolver)]), directives=[Dir], ) with pytest.raises(TypeError): schema.is_possible_type(Int, Implementing) # type: ignore
def test_register_resolver_raises_on_override_by_default(): resolver = lambda *_, **__: None Object = ObjectType("Object", [Field("id", String, resolver=resolver)]) schema = Schema(ObjectType("Query", [Field("foo", Object)])) new_resolver = lambda *_, **__: None with pytest.raises(ValueError): schema.register_resolver("Object", "id", new_resolver)
def test_register_subscription_works(): Query = ObjectType("Query", [Field("id", String)]) Subscription = ObjectType("Subscription", [Field("values", Int)]) schema = Schema(Query, subscription_type=Subscription) schema.register_subscription("Subscription", "values", lambda *_: 42) assert (schema.subscription_type.field_map[ # type: ignore "values"].subscription_resolver() == 42)
def test_resolver_decorator_with_wildcard(): Query = ObjectType("Query", [Field("id", String)]) schema = Schema(Query) @schema.resolver("Query.*") def query_default(root, ctx, info): return 42 assert (cast(ObjectType, schema.get_type("Query")).default_resolver is query_default)
def test_register_resolver_on_child_type(): Object = ObjectType("Object", [Field("id", String)]) schema = Schema(ObjectType("Query", [Field("foo", Object)])) resolver = lambda *_, **__: None schema.register_resolver("Object", "id", resolver) assert (schema.get_type("Object").fields[0].resolver is resolver # type: ignore )
def test_Schema_includes_introspection_types(): schema = Schema(ObjectType("Query", [Field("author", BlogAuthor)])) assert schema.get_type("__Schema") is not None assert schema.get_type("__Directive") is not None assert schema.get_type("__DirectiveLocation") is not None assert schema.get_type("__Type") is not None assert schema.get_type("__EnumValue") is not None assert schema.get_type("__InputValue") is not None assert schema.get_type("__Field") is not None assert schema.get_type("__TypeKind") is not None
def test_register_default_resolver(): Query = ObjectType("Query", [Field("id", String)]) schema = Schema(Query) def query_default(root, ctx, info): return 42 schema.register_default_resolver("Query", query_default) assert (cast(ObjectType, schema.get_type("Query")).default_resolver is query_default)
def test_register_resolver_accepts_override_with_flag(): old_resolver = lambda *_, **__: None Object = ObjectType("Object", [Field("id", String, resolver=old_resolver)]) schema = Schema(ObjectType("Query", [Field("foo", Object)])) resolver = lambda *_, **__: None schema.register_resolver("Object", "id", resolver, allow_override=True) assert (schema.get_type("Object").fields[0].resolver is resolver # type: ignore )
def test_replace_interface_in_implementers(schema: Schema) -> None: NewObject = InterfaceType( "Object", fields=[ Field("id", NonNullType(ID)), Field("name", NonNullType(String)), ], ) schema._replace_types_and_directives({"Object": NewObject}) assert (cast(ObjectType, schema.get_type("Person")).interfaces[0] is cast( ObjectType, schema.get_type("Animal")).interfaces[0] is schema.types["Object"] is NewObject)
def test_Schema_refuses_duplicate_type_names(): type_1 = ObjectType("Object", [Field("f", String)]) type_2 = ObjectType("Object", [Field("f", String)]) with pytest.raises(SchemaError) as exc_info: Schema(ObjectType("Query", [Field("f1", type_1), Field("f2", type_2)])) assert str(exc_info.value) == 'Duplicate type "Object"'
async def test_custom_scalar(assert_execution): Email = RegexType("Email", r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)") schema = Schema( ObjectType( "Query", [Field("foo", UUID), Field("bar", Email)])) await assert_execution( schema, """ { foo bar } """, initial_value={ "foo": "aff929fe-25a1-5e3d-8634-4c122f38d596", "bar": "*****@*****.**", }, expected_data={ "foo": "aff929fe-25a1-5e3d-8634-4c122f38d596", "bar": "*****@*****.**", }, )
def test_reject_non_object_query_type(): schema = Schema(String) # type: ignore with pytest.raises(SchemaError) as exc_info: validate_schema(schema) assert 'Query must be ObjectType but got "String"' in str(exc_info.value)
async def test_forwarded_resolver_arguments(mocker, assert_execution): resolver = mocker.Mock(return_value="foo") context = mocker.Mock() root = mocker.Mock() field = Field("test", String, [Argument("arg", String)], resolver=resolver) query_type = ObjectType("Test", [field]) doc = parse("query ($var: String) { result: test(arg: $var) }") schema = Schema(query_type) result = assert_execution( schema, doc, context_value=context, initial_value=root, variables={"var": 123}, ) if isawaitable(result): await result (parent_value, ctx, info), args = resolver.call_args assert info.field_definition is field assert info.parent_type is query_type assert info.path == ["result"] assert info.variables == {"var": "123"} assert info.schema is schema assert ctx is context assert parent_value is root assert args == {"arg": "123"}
def test_unions(): Foo = ObjectType("Foo", [Field("str", String)]) Bar = ObjectType("Bar", [Field("int", Int)]) SingleUnion = UnionType("SingleUnion", types=[Foo]) MultiUnion = UnionType("MultiUnion", types=[Foo, Bar]) Query = ObjectType( "Query", [Field("single", SingleUnion), Field("multi", MultiUnion)]) assert print_schema(Schema(Query), indent=" ") == dedent(""" type Bar { int: Int } type Foo { str: String } union MultiUnion = Foo | Bar type Query { single: SingleUnion multi: MultiUnion } union SingleUnion = Foo """)
def test_Schema_includes_nested_input_objects_in_the_map(): NestedInputObject = InputObjectType("NestedInputObject", [InputField("value", String)]) SomeInputObject = InputObjectType( "SomeInputObject", [InputField("nested", NestedInputObject)]) SomeMutation = ObjectType( "SomeMutation", [ Field( "mutateSomething", BlogArticle, [Argument("input", SomeInputObject)], ) ], ) SomeSubscription = ObjectType( "SomeSubscription", [ Field( "subscribeToSomething", BlogArticle, [Argument("input", SomeInputObject)], ) ], ) schema = Schema( BlogQuery, mutation_type=SomeMutation, subscription_type=SomeSubscription, ) assert schema.types.get("NestedInputObject") is NestedInputObject
def test_mutation(): assert (dedent(""" type Mutation { foo: Int } """) == print_schema( Schema(mutation_type=ObjectType("Mutation", [Field("foo", Int)]))))
async def run_test(test_type, test_data, *, assert_execution, expected_data=None, expected_errors=None, expected_exc=None, expected_msg=None): data = _obj(test=test_data) data_type = ObjectType( "DataType", [ Field("test", test_type), Field("nest", lambda: data_type, resolver=lambda *_: data), ], ) # type: ObjectType schema = Schema(data_type) await assert_execution( schema, "{ nest { test } }", initial_value=data, expected_data=({ "nest": { "test": expected_data } } if expected_data is not None else None), expected_errors=expected_errors, expected_exc=(expected_exc, expected_msg), )
def test_interfaces(): Foo = InterfaceType("Foo", [Field("str", String)]) Baz = InterfaceType("Baz", [Field("int", Int)]) Bar = ObjectType( "Bar", [Field("str", String), Field("int", Int)], interfaces=[Foo, Baz]) Query = ObjectType("Query", [Field("bar", Bar)]) assert print_schema(Schema(Query), indent=" ") == dedent(""" type Bar implements Foo & Baz { str: String int: Int } interface Baz { int: Int } interface Foo { str: String } type Query { bar: Bar } """)
def test_replace_type_in_union(schema: Schema) -> None: NewPerson = ObjectType( "Person", fields=(list(cast(ObjectType, schema.types["Person"]).fields) + [Field("last_name", NonNullType(String))]), interfaces=[cast(InterfaceType, schema.types["Object"])], ) schema._replace_types_and_directives({"Person": NewPerson}) assert cast(ObjectType, schema.get_type("Person")) is NewPerson union_type = cast(UnionType, schema.get_type("LivingBeing")) assert NewPerson in union_type.types assert 2 == len(union_type.types)
def test_reject_bad_global_default_resolver(self, schema: Schema) -> None: def default_resolver(root, info, ctx): pass schema.default_resolver = default_resolver with pytest.raises(SchemaError): validate_schema(schema)
def test_accept_generic_global_default_resolver(self, schema: Schema) -> None: def default_resolver(root, info, ctx, **args): pass schema.default_resolver = default_resolver validate_schema(schema)