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)
