def with_extensions():
interface_extensions = {"SomeInterfaceExt": "interface"}
field_extensions = {"SomeFieldExt": "field"}
arg_extensions = {"SomeArgExt": "arg"}
some_interface = GraphQLInterfaceType(
"SomeInterface",
{
"someField": GraphQLField(
dummy_type,
{
"someArg": GraphQLArgument(
dummy_type, extensions=arg_extensions
)
},
extensions=field_extensions,
)
},
extensions=interface_extensions,
)
assert some_interface.extensions is interface_extensions
some_field = some_interface.fields["someField"]
assert some_field.extensions is field_extensions
some_arg = some_field.args["someArg"]
assert some_arg.extensions is arg_extensions
assert some_interface.to_kwargs()["extensions"] is interface_extensions
assert some_field.to_kwargs()["extensions"] is field_extensions
assert some_arg.to_kwargs()["extensions"] is arg_extensions
def prints_multiple_interfaces():
foo_type = GraphQLInterfaceType(
name="Foo", fields={"str": GraphQLField(GraphQLString)})
baz_type = GraphQLInterfaceType(
name="Baz", fields={"int": GraphQLField(GraphQLInt)})
bar_type = GraphQLObjectType(
name="Bar",
fields={
"str": GraphQLField(GraphQLString),
"int": GraphQLField(GraphQLInt),
},
interfaces=[foo_type, baz_type],
)
schema = GraphQLSchema(types=[bar_type])
output = print_for_test(schema)
assert output == dedent("""
type Bar implements Foo & Baz {
str: String
int: Int
}
interface Foo {
str: String
}
interface Baz {
int: Int
}
""")
def includes_interfaces_thunk_subtypes_in_the_type_map():
AnotherInterface = GraphQLInterfaceType("AnotherInterface", {})
SomeInterface = GraphQLInterfaceType(
"SomeInterface", {}, interfaces=lambda: [AnotherInterface])
SomeSubtype = GraphQLObjectType("SomeSubtype", {},
interfaces=lambda: [SomeInterface])
schema = GraphQLSchema(types=[SomeSubtype], )
assert schema.type_map["SomeInterface"] is SomeInterface
assert schema.type_map["AnotherInterface"] is AnotherInterface
assert schema.type_map["SomeSubtype"] is SomeSubtype
def implementing_interface_is_subtype_of_interface():
iface = GraphQLInterfaceType(
"Interface", {"field": GraphQLField(GraphQLString)})
iface2 = GraphQLInterfaceType(
"Interface2", {"field": GraphQLField(GraphQLString)}, [iface])
impl = GraphQLObjectType(
"Object",
{"field": GraphQLField(GraphQLString)},
[iface2, iface],
)
schema = _test_schema(impl)
assert is_type_sub_type_of(schema, iface2, iface)
def test_prints_multiple_interfaces():
FooType = GraphQLInterfaceType(
name="Foo",
resolve_type=lambda *_: None,
fields={"str": GraphQLField(GraphQLString)},
)
BaazType = GraphQLInterfaceType(
name="Baaz",
resolve_type=lambda *_: None,
fields={"int": GraphQLField(GraphQLInt)},
)
BarType = GraphQLObjectType(
name="Bar",
fields=OrderedDict(
[("str", GraphQLField(GraphQLString)), ("int", GraphQLField(GraphQLInt))]
),
interfaces=[FooType, BaazType],
)
Root = GraphQLObjectType(name="Root", fields={"bar": GraphQLField(BarType)})
Schema = GraphQLSchema(Root, types=[BarType])
output = print_for_test(Schema)
assert (
output
== """
schema {
query: Root
}
interface Baaz {
int: Int
}
type Bar implements Foo & Baaz {
str: String
int: Int
}
interface Foo {
str: String
}
type Root {
bar: Bar
}
"""
)
def prints_hierarchical_interface():
foo_type = GraphQLInterfaceType(
name="Foo", fields={"str": GraphQLField(GraphQLString)}
)
baz_type = GraphQLInterfaceType(
name="Baz",
interfaces=[foo_type],
fields={
"int": GraphQLField(GraphQLInt),
"str": GraphQLField(GraphQLString),
},
)
bar_type = GraphQLObjectType(
name="Bar",
fields={
"str": GraphQLField(GraphQLString),
"int": GraphQLField(GraphQLInt),
},
interfaces=[foo_type, baz_type],
)
query = GraphQLObjectType(name="Query", fields={"bar": GraphQLField(bar_type)})
schema = GraphQLSchema(query, types=[bar_type])
output = print_for_test(schema)
assert output == dedent(
"""
type Bar implements Foo & Baz {
str: String
int: Int
}
interface Baz implements Foo {
int: Int
str: String
}
interface Foo {
str: String
}
type Query {
bar: Bar
}
"""
)
def test_includes_interfaces_thunk_subtypes_in_the_type_map():
SomeInterface = GraphQLInterfaceType(
name='SomeInterface',
fields={
'f': GraphQLField(GraphQLInt)
}
)
SomeSubtype = GraphQLObjectType(
name='SomeSubtype',
fields={
'f': GraphQLField(GraphQLInt)
},
interfaces=lambda: [SomeInterface],
is_type_of=lambda: True
)
schema = GraphQLSchema(query=GraphQLObjectType(
name='Query',
fields={
'iface': GraphQLField(SomeInterface)
}
), types=[SomeSubtype])
assert schema.get_type_map()['SomeSubtype'] is SomeSubtype
def prints_empty_types():
schema = GraphQLSchema(
types=[
GraphQLEnumType("SomeEnum", cast(Dict[str, Any], {})),
GraphQLInputObjectType("SomeInputObject", {}),
GraphQLInterfaceType("SomeInterface", {}),
GraphQLObjectType("SomeObject", {}),
GraphQLUnionType("SomeUnion", []),
]
)
output = print_for_test(schema)
assert output == dedent(
"""
enum SomeEnum
input SomeInputObject
interface SomeInterface
type SomeObject
union SomeUnion
"""
)
def node_definitions(id_fetcher, type_resolver=None, id_resolver=None):
"""
Given a function to map from an ID to an underlying object, and a function
to map from an underlying object to the concrete GraphQLObjectType it
corresponds to, constructs a `Node` interface that objects can implement,
and a field config for a `node` root field.
If the type_resolver is omitted, object resolution on the interface will be
handled with the `isTypeOf` method on object types, as with any GraphQL
interface without a provided `resolveType` method.
"""
node_interface = GraphQLInterfaceType(
'Node',
description='An object with an ID',
fields=lambda: OrderedDict((('id',
GraphQLField(
GraphQLNonNull(GraphQLID),
description='The id of the object.',
resolver=id_resolver,
)), )),
resolve_type=type_resolver)
node_field = GraphQLField(
node_interface,
description='Fetches an object given its ID',
args=OrderedDict(
(('id',
GraphQLArgument(GraphQLNonNull(GraphQLID),
description='The ID of an object')), )),
resolver=lambda _obj, info, id: id_fetcher(id, info))
return node_interface, node_field
async def resolve_type_allows_resolving_with_type_name():
PetType = GraphQLInterfaceType(
"Pet",
{"name": GraphQLField(GraphQLString)},
resolve_type=get_type_resolver({Dog: "Dog", Cat: "Cat"}),
)
DogType = GraphQLObjectType(
"Dog",
{
"name": GraphQLField(GraphQLString),
"woofs": GraphQLField(GraphQLBoolean),
},
interfaces=[PetType],
)
CatType = GraphQLObjectType(
"Cat",
{
"name": GraphQLField(GraphQLString),
"meows": GraphQLField(GraphQLBoolean),
},
interfaces=[PetType],
)
schema = GraphQLSchema(
GraphQLObjectType(
"Query",
{
"pets": GraphQLField(
GraphQLList(PetType),
resolve=lambda *_: [Dog("Odie", True), Cat("Garfield", False)],
)
},
),
types=[CatType, DogType],
)
query = """{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}"""
result = await graphql(schema, query)
assert result == (
{
"pets": [
{"name": "Odie", "woofs": True},
{"name": "Garfield", "meows": False},
]
},
None,
)
def test_builds_a_schema_with_an_interface():
FriendlyType = GraphQLInterfaceType(
name='Friendly',
resolve_type=lambda: None,
fields=lambda: {
'bestFriend':
GraphQLField(FriendlyType,
description='The best friend of this friendly thing.')
})
DogType = GraphQLObjectType(
name='DogType',
interfaces=[FriendlyType],
fields=lambda: {'bestFriend': GraphQLField(FriendlyType)})
HumanType = GraphQLObjectType(
name='Human',
interfaces=[FriendlyType],
fields=lambda: {'bestFriend': GraphQLField(FriendlyType)})
schema = GraphQLSchema(query=GraphQLObjectType(
name='WithInterface', fields={'friendly': GraphQLField(FriendlyType)}),
types=[DogType, HumanType])
_test_schema(schema)
def returning_invalid_value_from_resolve_type_yields_useful_error():
fooInterface = GraphQLInterfaceType(
'FooInterface', {'bar': GraphQLField(GraphQLString)},
resolve_type=lambda *_args: [])
fooObject = GraphQLObjectType('FooObject',
{'bar': GraphQLField(GraphQLString)},
interfaces=[fooInterface])
schema = GraphQLSchema(GraphQLObjectType(
'Query', {
'foo': GraphQLField(fooInterface,
resolve=lambda *_args: 'dummy')
}),
types=[fooObject])
result = graphql_sync(schema, '{ foo { bar } }')
assert result == ({
'foo': None
}, [{
'message':
'Abstract type FooInterface must resolve to an Object type'
" at runtime for field Query.foo with value 'dummy',"
" received '[]'. Either the FooInterface type should provide"
' a "resolve_type" function or each possible type'
' should provide an "is_type_of" function.',
'locations': [(1, 3)],
'path': ['foo']
}])
def builds_a_schema_with_an_interface():
friendly_type = GraphQLInterfaceType(
"Friendly",
lambda: {
"bestFriend":
GraphQLField(friendly_type,
description=
"The best friend of this friendly thing.")
},
)
dog_type = GraphQLObjectType(
"DogType",
lambda: {"bestFriend": GraphQLField(friendly_type)},
interfaces=[friendly_type],
)
human_type = GraphQLObjectType(
"Human",
lambda: {"bestFriend": GraphQLField(friendly_type)},
interfaces=[friendly_type],
)
schema = GraphQLSchema(
GraphQLObjectType("WithInterface",
{"friendly": GraphQLField(friendly_type)}),
types=[dog_type, human_type],
)
check_schema(schema)
def returning_invalid_value_from_resolve_type_yields_useful_error():
fooInterface = GraphQLInterfaceType(
"FooInterface",
{"bar": GraphQLField(GraphQLString)},
resolve_type=lambda *_args: [],
)
fooObject = GraphQLObjectType(
"FooObject", {"bar": GraphQLField(GraphQLString)}, interfaces=[fooInterface]
)
schema = GraphQLSchema(
GraphQLObjectType(
"Query",
{"foo": GraphQLField(fooInterface, resolve=lambda *_args: "dummy")},
),
types=[fooObject],
)
result = graphql_sync(schema, "{ foo { bar } }")
assert result == (
{"foo": None},
[
{
"message": "Abstract type FooInterface must resolve to an"
" Object type at runtime for field Query.foo with value 'dummy',"
" received '[]'. Either the FooInterface type should provide"
' a "resolve_type" function or each possible type'
' should provide an "is_type_of" function.',
"locations": [(1, 3)],
"path": ["foo"],
}
],
)
def test_prints_interface():
FooType = GraphQLInterfaceType(
name='Foo',
resolve_type=lambda *_: None,
fields={
'str': GraphQLField(GraphQLString)
}
)
BarType = GraphQLObjectType(
name='Bar',
fields={
'str': GraphQLField(GraphQLString),
},
interfaces=[FooType]
)
Root = GraphQLObjectType(
name='Root',
fields={
'bar': GraphQLField(BarType)
}
)
Schema = GraphQLSchema(Root, types=[BarType])
output = print_for_test(Schema)
assert output == '''
def test_builds_a_schema_with_an_interface():
FriendlyType = GraphQLInterfaceType(
name="Friendly",
resolve_type=lambda: None,
fields=lambda: {
"bestFriend":
GraphQLField(FriendlyType,
description="The best friend of this friendly thing.")
},
)
DogType = GraphQLObjectType(
name="DogType",
interfaces=[FriendlyType],
fields=lambda: {"bestFriend": GraphQLField(FriendlyType)},
)
HumanType = GraphQLObjectType(
name="Human",
interfaces=[FriendlyType],
fields=lambda: {"bestFriend": GraphQLField(FriendlyType)},
)
schema = GraphQLSchema(
query=GraphQLObjectType(
name="WithInterface",
fields={"friendly": GraphQLField(FriendlyType)}),
types=[DogType, HumanType],
)
_test_schema(schema)
def prints_interface():
FooType = GraphQLInterfaceType(
name="Foo", fields={"str": GraphQLField(GraphQLString)}
)
BarType = GraphQLObjectType(
name="Bar",
fields={"str": GraphQLField(GraphQLString)},
interfaces=[FooType],
)
Root = GraphQLObjectType(name="Root", fields={"bar": GraphQLField(BarType)})
Schema = GraphQLSchema(Root, types=[BarType])
output = print_for_test(Schema)
assert output == dedent(
"""
schema {
query: Root
}
type Bar implements Foo {
str: String
}
interface Foo {
str: String
}
type Root {
bar: Bar
}
"""
)
def prints_interface():
foo_type = GraphQLInterfaceType(
name="Foo", fields={"str": GraphQLField(GraphQLString)})
bar_type = GraphQLObjectType(
name="Bar",
fields={"str": GraphQLField(GraphQLString)},
interfaces=[foo_type],
)
query = GraphQLObjectType(name="Query",
fields={"bar": GraphQLField(bar_type)})
schema = GraphQLSchema(query, types=[bar_type])
output = print_for_test(schema)
assert output == dedent("""
type Bar implements Foo {
str: String
}
interface Foo {
str: String
}
type Query {
bar: Bar
}
""")
def uses_a_custom_type_resolver():
document = parse("{ foo { bar } }")
foo_interface = GraphQLInterfaceType(
"FooInterface", {"bar": GraphQLField(GraphQLString)})
foo_object = GraphQLObjectType("FooObject",
{"bar": GraphQLField(GraphQLString)},
[foo_interface])
schema = GraphQLSchema(
GraphQLObjectType("Query", {"foo": GraphQLField(foo_interface)}),
types=[foo_object],
)
possible_types = None
def type_resolver(_source, info, abstract_type):
# Resolver should be able to figure out all possible types on its own
nonlocal possible_types
possible_types = info.schema.get_possible_types(abstract_type)
return "FooObject"
root_value = {"foo": {"bar": "bar"}}
result = execute(schema,
document,
root_value,
type_resolver=type_resolver)
assert result == ({"foo": {"bar": "bar"}}, None)
assert possible_types == [foo_object]
def implementation_is_subtype_of_interface():
iface = GraphQLInterfaceType(
'Interface', {'field': GraphQLField(GraphQLString)})
impl = GraphQLObjectType(
'Object',
fields={'field': GraphQLField(GraphQLString)},
interfaces=[iface])
schema = test_schema(impl)
assert is_type_sub_type_of(schema, impl, iface)
async def is_type_of_with_async_error():
PetType = GraphQLInterfaceType('Pet',
{'name': GraphQLField(GraphQLString)})
DogType = GraphQLObjectType('Dog', {
'name': GraphQLField(GraphQLString),
'woofs': GraphQLField(GraphQLBoolean)
},
interfaces=[PetType],
is_type_of=is_type_of_error)
CatType = GraphQLObjectType('Cat', {
'name': GraphQLField(GraphQLString),
'meows': GraphQLField(GraphQLBoolean)
},
interfaces=[PetType],
is_type_of=get_is_type_of(Cat))
schema = GraphQLSchema(GraphQLObjectType(
'Query', {
'pets':
GraphQLField(GraphQLList(PetType),
resolve=lambda *_args:
[Dog('Odie', True),
Cat('Garfield', False)])
}),
types=[CatType, DogType])
query = """
{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}
"""
result = await graphql(schema, query)
# Note: we get two errors, because first all types are resolved
# and only then they are checked sequentially
assert result.data == {'pets': [None, None]}
assert list(map(format_error, result.errors)) == [{
'message':
'We are testing this error',
'locations': [(3, 15)],
'path': ['pets', 0]
}, {
'message':
'We are testing this error',
'locations': [(3, 15)],
'path': ['pets', 1]
}]
def schema_with_interface_field_of_type(field_type):
BadInterfaceType = GraphQLInterfaceType('BadInterface', {
'badField': GraphQLField(field_type)})
BadImplementingType = GraphQLObjectType('BadImplementing', {
'badField': GraphQLField(field_type)},
interfaces=[BadInterfaceType])
return GraphQLSchema(GraphQLObjectType('Query', {
'f': GraphQLField(BadInterfaceType)}),
types=[BadImplementingType, SomeObjectType])
def rejects_an_interface_type_with_an_incorrect_type_for_resolve_type():
with raises(TypeError) as exc_info:
# noinspection PyTypeChecker
GraphQLInterfaceType("AnotherInterface", {}, resolve_type={})
msg = str(exc_info.value)
assert msg == (
"AnotherInterface must provide 'resolve_type' as a function,"
" but got: {}."
)
def includes_interfaces_thunk_subtypes_in_the_type_map():
SomeInterface = GraphQLInterfaceType('SomeInterface',
{'f': GraphQLField(GraphQLInt)})
SomeSubtype = GraphQLObjectType('SomeSubtype',
{'f': GraphQLField(GraphQLInt)},
interfaces=lambda: [SomeInterface])
schema = GraphQLSchema(query=GraphQLObjectType(
'Query', {'iface': GraphQLField(SomeInterface)}),
types=[SomeSubtype])
assert schema.type_map['SomeSubtype'] is SomeSubtype
def implementation_is_subtype_of_interface():
iface = GraphQLInterfaceType(
"Interface", {"field": GraphQLField(GraphQLString)})
impl = GraphQLObjectType(
"Object",
fields={"field": GraphQLField(GraphQLString)},
interfaces=[iface],
)
schema = _test_schema(impl)
assert is_type_sub_type_of(schema, impl, iface)
def without_extensions():
some_interface = GraphQLInterfaceType(
"SomeInterface",
{
"someField": GraphQLField(
dummy_type, {"someArg": GraphQLArgument(dummy_type)}
)
},
)
assert some_interface.extensions is None
some_field = some_interface.fields["someField"]
assert some_field.extensions is None
some_arg = some_field.args["someArg"]
assert some_arg.extensions is None
assert some_interface.to_kwargs()["extensions"] is None
assert some_field.to_kwargs()["extensions"] is None
assert some_arg.to_kwargs()["extensions"] is None
def accepts_an_interface_type_defining_resolve_type():
AnotherInterfaceType = GraphQLInterfaceType(
"AnotherInterface", {"f": GraphQLField(GraphQLString)})
schema = schema_with_field_type(
GraphQLObjectType("SomeObject", {"f": GraphQLField(GraphQLString)},
[AnotherInterfaceType]))
assert (schema.query_type.fields["field"].type.interfaces[0] is
AnotherInterfaceType)
def accepts_an_interface_type_defining_resolve_type():
AnotherInterfaceType = GraphQLInterfaceType(
'AnotherInterface', {'f': GraphQLField(GraphQLString)})
schema = schema_with_field_type(
GraphQLObjectType('SomeObject', {'f': GraphQLField(GraphQLString)},
[AnotherInterfaceType]))
assert schema.query_type.fields['field'].type.interfaces[
0] is AnotherInterfaceType
async def is_type_of_with_no_suitable_type(sync):
# added in GraphQL-core to improve coverage
pet_type = GraphQLInterfaceType("Pet",
{"name": GraphQLField(GraphQLString)})
dog_type = GraphQLObjectType(
"Dog",
{
"name": GraphQLField(GraphQLString),
"woofs": GraphQLField(GraphQLBoolean),
},
interfaces=[pet_type],
is_type_of=get_is_type_of(Cat, sync),
)
schema = GraphQLSchema(
GraphQLObjectType(
"Query",
{
"pets":
GraphQLField(
GraphQLList(pet_type),
resolve=lambda *_args: [Dog("Odie", True)],
)
},
),
types=[dog_type],
)
query = """
{
pets {
name
... on Dog {
woofs
}
}
}
"""
message = (
"Abstract type 'Pet' must resolve to an Object type at runtime"
" for field 'Query.pets'."
" Either the 'Pet' type should provide a 'resolve_type' function"
" or each possible type should provide an 'is_type_of' function.")
assert await execute_query(sync, schema, query) == (
{
"pets": [None]
},
[{
"message": message,
"locations": [(3, 15)],
"path": ["pets", 0]
}],
)
def resolve_type_allows_resolving_with_type_name():
PetType = GraphQLInterfaceType('Pet',
{'name': GraphQLField(GraphQLString)},
resolve_type=get_type_resolver({
Dog:
'Dog',
Cat:
'Cat'
}))
DogType = GraphQLObjectType('Dog', {
'name': GraphQLField(GraphQLString),
'woofs': GraphQLField(GraphQLBoolean)
},
interfaces=[PetType])
CatType = GraphQLObjectType('Cat', {
'name': GraphQLField(GraphQLString),
'meows': GraphQLField(GraphQLBoolean)
},
interfaces=[PetType])
schema = GraphQLSchema(GraphQLObjectType(
'Query', {
'pets':
GraphQLField(GraphQLList(PetType),
resolve=lambda *_:
[Dog('Odie', True),
Cat('Garfield', False)])
}),
types=[CatType, DogType])
query = """
{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}"""
result = graphql_sync(schema, query)
assert result == ({
'pets': [{
'name': 'Odie',
'woofs': True
}, {
'name': 'Garfield',
'meows': False
}]
}, None)
