def does_not_mutate_passed_field_definitions():
fields = {
"field1":
GraphQLField(GraphQLString),
"field2":
GraphQLField(GraphQLString,
args={"id": GraphQLArgument(GraphQLString)}),
}
TestObject1 = GraphQLObjectType("Test1", fields)
TestObject2 = GraphQLObjectType("Test2", fields)
assert TestObject1.fields == TestObject2.fields
assert fields == {
"field1":
GraphQLField(GraphQLString),
"field2":
GraphQLField(GraphQLString,
args={"id": GraphQLArgument(GraphQLString)}),
}
input_fields = {
"field1": GraphQLInputField(GraphQLString),
"field2": GraphQLInputField(GraphQLString),
}
TestInputObject1 = GraphQLInputObjectType("Test1", input_fields)
TestInputObject2 = GraphQLInputObjectType("Test2", input_fields)
assert TestInputObject1.fields == TestInputObject2.fields
assert input_fields == {
"field1": GraphQLInputField(GraphQLString),
"field2": GraphQLInputField(GraphQLString),
}
def test_includes_nested_input_objects_in_the_map():
NestedInputObject = GraphQLInputObjectType(
name="NestedInputObject",
fields={"value": GraphQLInputObjectField(GraphQLString)},
)
SomeInputObject = GraphQLInputObjectType(
name="SomeInputObject",
fields={"nested": GraphQLInputObjectField(NestedInputObject)},
)
SomeMutation = GraphQLObjectType(
name="SomeMutation",
fields={
"mutateSomething":
GraphQLField(type=BlogArticle,
args={"input": GraphQLArgument(SomeInputObject)})
},
)
SomeSubscription = GraphQLObjectType(
name="SomeSubscription",
fields={
"subscribeToSomething":
GraphQLField(type=BlogArticle,
args={"input": GraphQLArgument(SomeInputObject)})
},
)
schema = GraphQLSchema(query=BlogQuery,
mutation=SomeMutation,
subscription=SomeSubscription)
assert schema.get_type_map()["NestedInputObject"] is NestedInputObject
def does_not_mutate_passed_field_definitions():
output_fields = {
"field1": GraphQLField(ScalarType),
"field2": GraphQLField(
ScalarType, args={"id": GraphQLArgument(ScalarType)}
),
}
test_object_1 = GraphQLObjectType("Test1", output_fields)
test_object_2 = GraphQLObjectType("Test2", output_fields)
assert test_object_1.fields == test_object_2.fields
assert output_fields == {
"field1": GraphQLField(ScalarType),
"field2": GraphQLField(
ScalarType, args={"id": GraphQLArgument(ScalarType)}
),
}
input_fields = {
"field1": GraphQLInputField(ScalarType),
"field2": GraphQLInputField(ScalarType),
}
test_input_object_1 = GraphQLInputObjectType("Test1", input_fields)
test_input_object_2 = GraphQLInputObjectType("Test2", input_fields)
assert test_input_object_1.fields == test_input_object_2.fields
assert input_fields == {
"field1": GraphQLInputField(ScalarType),
"field2": GraphQLInputField(ScalarType),
}
def test_does_not_mutate_passed_field_definitions():
fields = {
'field1': GraphQLField(GraphQLString),
'field2': GraphQLField(GraphQLString, args={'id': GraphQLArgument(GraphQLString)}),
}
TestObject1 = GraphQLObjectType(name='Test1', fields=fields)
TestObject2 = GraphQLObjectType(name='Test1', fields=fields)
assert TestObject1.get_fields() == TestObject2.get_fields()
assert fields == {
'field1': GraphQLField(GraphQLString),
'field2': GraphQLField(GraphQLString, args={'id': GraphQLArgument(GraphQLString)}),
}
input_fields = {
'field1': GraphQLInputObjectField(GraphQLString),
'field2': GraphQLInputObjectField(GraphQLString),
}
TestInputObject1 = GraphQLInputObjectType(name='Test1', fields=input_fields)
TestInputObject2 = GraphQLInputObjectType(name='Test2', fields=input_fields)
assert TestInputObject1.get_fields() == TestInputObject2.get_fields()
assert input_fields == {
'field1': GraphQLInputObjectField(GraphQLString),
'field2': GraphQLInputObjectField(GraphQLString),
}
def test_includes_nested_input_objects_in_the_map():
NestedInputObject = GraphQLInputObjectType(
name='NestedInputObject',
fields={'value': GraphQLInputObjectField(GraphQLString)})
SomeInputObject = GraphQLInputObjectType(
name='SomeInputObject',
fields={'nested': GraphQLInputObjectField(NestedInputObject)})
SomeMutation = GraphQLObjectType(
name='SomeMutation',
fields={
'mutateSomething':
GraphQLField(type=BlogArticle,
args={'input': GraphQLArgument(SomeInputObject)})
})
SomeSubscription = GraphQLObjectType(
name='SomeSubscription',
fields={
'subscribeToSomething':
GraphQLField(type=BlogArticle,
args={'input': GraphQLArgument(SomeInputObject)})
})
schema = GraphQLSchema(query=BlogQuery,
mutation=SomeMutation,
subscription=SomeSubscription)
assert schema.get_type_map()['NestedInputObject'] is NestedInputObject
def does_not_mutate_passed_field_definitions():
fields = {
'field1':
GraphQLField(GraphQLString),
'field2':
GraphQLField(GraphQLString,
args={'id': GraphQLArgument(GraphQLString)})
}
TestObject1 = GraphQLObjectType('Test1', fields)
TestObject2 = GraphQLObjectType('Test2', fields)
assert TestObject1.fields == TestObject2.fields
assert fields == {
'field1':
GraphQLField(GraphQLString),
'field2':
GraphQLField(GraphQLString,
args={'id': GraphQLArgument(GraphQLString)})
}
input_fields = {
'field1': GraphQLInputField(GraphQLString),
'field2': GraphQLInputField(GraphQLString)
}
TestInputObject1 = GraphQLInputObjectType('Test1', input_fields)
TestInputObject2 = GraphQLInputObjectType('Test2', input_fields)
assert TestInputObject1.fields == TestInputObject2.fields
assert input_fields == {
'field1': GraphQLInputField(GraphQLString),
'field2': GraphQLInputField(GraphQLString)
}
def without_extensions():
some_input_object = GraphQLInputObjectType(
"SomeInputObject", {"someInputField": GraphQLInputField(dummy_type)}
)
assert some_input_object.extensions is None
some_input_field = some_input_object.fields["someInputField"]
assert some_input_field.extensions is None
assert some_input_object.to_kwargs()["extensions"] is None
assert some_input_field.to_kwargs()["extensions"] is None
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 accepts_an_input_object_type_with_input_type_as_field():
# this is a shortcut syntax for simple input fields
input_obj_type = GraphQLInputObjectType("SomeInputObject",
{"f": GraphQLString})
field = input_obj_type.fields["f"]
assert isinstance(field, GraphQLInputField)
assert field.type is GraphQLString
def builds_a_schema_with_an_input_object():
address_type = GraphQLInputObjectType('Address', {
'street':
GraphQLInputField(GraphQLNonNull(GraphQLString),
description='What street is this address?'),
'city':
GraphQLInputField(GraphQLNonNull(GraphQLString),
description='The city the address is within?'),
'country':
GraphQLInputField(
GraphQLString,
default_value='USA',
description='The country (blank will assume USA).')
},
description='An input address')
schema = GraphQLSchema(
GraphQLObjectType(
'HasInputObjectFields', {
'geocode':
GraphQLField(GraphQLString,
args={
'address':
GraphQLArgument(
address_type,
description='The address to lookup')
},
description='Get a geocode from an address')
}))
check_schema(schema)
def prints_input_type():
InputType = GraphQLInputObjectType(
name='InputType', fields={'int': GraphQLInputField(GraphQLInt)})
Root = GraphQLObjectType(
name='Root',
fields={
'str':
GraphQLField(GraphQLString,
args={'argOne': GraphQLArgument(InputType)})
})
Schema = GraphQLSchema(Root)
output = print_for_test(Schema)
assert output == dedent("""
schema {
query: Root
}
input InputType {
int: Int
}
type Root {
str(argOne: InputType): String
}
""")
def test_builds_a_schema_with_an_input_object():
AddressType = GraphQLInputObjectType(
name='Address',
description='An input address',
fields=OrderedDict([
('street',
GraphQLInputObjectField(
GraphQLNonNull(GraphQLString),
description='What street is this address?')),
('city',
GraphQLInputObjectField(
GraphQLNonNull(GraphQLString),
description='The city the address is within?')),
('country',
GraphQLInputObjectField(
GraphQLString,
description='The country (blank will assume USA).',
default_value='USA')),
]))
schema = GraphQLSchema(query=GraphQLObjectType(
name='HasInputObjectFields',
fields={
'geocode':
GraphQLField(description='Get a geocode from an address',
type=GraphQLString,
args={
'address':
GraphQLArgument(
description='The address to lookup',
type=AddressType)
})
}))
_test_schema(schema)
def prints_input_type():
InputType = GraphQLInputObjectType(
name="InputType", fields={"int": GraphQLInputField(GraphQLInt)}
)
Root = GraphQLObjectType(
name="Root",
fields={
"str": GraphQLField(
GraphQLString, args={"argOne": GraphQLArgument(InputType)}
)
},
)
Schema = GraphQLSchema(Root)
output = print_for_test(Schema)
assert output == dedent(
"""
schema {
query: Root
}
input InputType {
int: Int
}
type Root {
str(argOne: InputType): String
}
"""
)
def with_bad_extensions(extensions):
with raises(TypeError, match=bad_extensions_msg("SomeInputObject")):
# noinspection PyTypeChecker
GraphQLInputObjectType("SomeInputObject", {}, extensions=extensions)
with raises(TypeError, match=bad_extensions_msg("Input field")):
# noinspection PyTypeChecker
GraphQLInputField(dummy_type, extensions=extensions)
def describe_for_graphql_input_object():
TestInputObject = GraphQLInputObjectType(
"TestInputObject",
{
"foo": GraphQLInputField(GraphQLNonNull(GraphQLInt)),
"bar": GraphQLInputField(GraphQLInt),
},
)
def returns_no_error_for_a_valid_input():
result = coerce_value({"foo": 123}, TestInputObject)
assert expect_value(result) == {"foo": 123}
def returns_an_error_for_a_non_dict_value():
result = coerce_value(123, TestInputObject)
assert expect_error(result) == [
"Expected type TestInputObject to be a dict."
]
def returns_an_error_for_an_invalid_field():
result = coerce_value({"foo": "abc"}, TestInputObject)
assert expect_error(result) == [
"Expected type Int at value.foo;"
" Int cannot represent non-integer value: 'abc'"
]
def returns_multiple_errors_for_multiple_invalid_fields():
result = coerce_value({
"foo": "abc",
"bar": "def"
}, TestInputObject)
assert expect_error(result) == [
"Expected type Int at value.foo;"
" Int cannot represent non-integer value: 'abc'",
"Expected type Int at value.bar;"
" Int cannot represent non-integer value: 'def'",
]
def returns_error_for_a_missing_required_field():
result = coerce_value({"bar": 123}, TestInputObject)
assert expect_error(result) == [
"Field value.foo of required type Int! was not provided."
]
def returns_error_for_an_unknown_field():
result = coerce_value({
"foo": 123,
"unknownField": 123
}, TestInputObject)
assert expect_error(result) == [
"Field 'unknownField' is not defined by type TestInputObject."
]
def returns_error_for_a_misspelled_field():
result = coerce_value({"foo": 123, "bart": 123}, TestInputObject)
assert expect_error(result) == [
"Field 'bart' is not defined by type TestInputObject;"
" did you mean bar?"
]
def rejects_an_input_object_type_with_resolver_constant():
with raises(
TypeError, match="got an unexpected keyword argument 'resolve'"
):
# noinspection PyArgumentList
GraphQLInputObjectType(
"SomeInputObject", {"f": GraphQLInputField(ScalarType, resolve={})}
)
def rejects_an_input_object_type_with_resolvers():
with raises(TypeError) as exc_info:
# noinspection PyArgumentList
GraphQLInputObjectType(
'SomeInputObject',
{'f': GraphQLInputField(GraphQLString, resolve=lambda: 0)})
msg = str(exc_info.value)
assert "got an unexpected keyword argument 'resolve'" in msg
input_obj_type = GraphQLInputObjectType(
'SomeInputObject',
{'f': GraphQLField(GraphQLString, resolve=lambda: 0)})
with raises(TypeError) as exc_info:
if input_obj_type.fields:
pass
msg = str(exc_info.value)
assert msg == ('SomeInputObject fields must be GraphQLInputField'
' or input type objects.')
def rejects_an_input_object_type_with_resolver_constant():
with raises(TypeError) as exc_info:
# noinspection PyArgumentList
GraphQLInputObjectType(
"SomeInputObject",
{"f": GraphQLInputField(GraphQLString, resolve={})})
msg = str(exc_info.value)
assert "got an unexpected keyword argument 'resolve'" in msg
def accepts_an_input_object_type_with_a_field_function():
input_obj_type = GraphQLInputObjectType(
"SomeInputObject", lambda: {"f": GraphQLInputField(ScalarType)}
)
assert list(input_obj_type.fields) == ["f"]
input_field = input_obj_type.fields["f"]
assert isinstance(input_field, GraphQLInputField)
assert input_field.type is ScalarType
def test_builds_a_schema_with_field_arguments_with_default_values():
GeoType = GraphQLInputObjectType(
name="Geo",
fields=OrderedDict([
("lat", GraphQLInputObjectField(GraphQLFloat)),
("lon", GraphQLInputObjectField(GraphQLFloat)),
]),
)
schema = GraphQLSchema(query=GraphQLObjectType(
name="ArgFields",
fields=OrderedDict([
(
"defaultInt",
GraphQLField(
GraphQLString,
args={
"intArg": GraphQLArgument(GraphQLInt, default_value=10)
},
),
),
('defaultNullInt',
GraphQLField(GraphQLString,
args={
'intArg':
GraphQLArgument(GraphQLInt, default_value=None)
})),
(
"defaultList",
GraphQLField(
GraphQLString,
args={
"listArg":
GraphQLArgument(GraphQLList(GraphQLInt),
default_value=[1, 2, 3])
},
),
),
(
"defaultObject",
GraphQLField(
GraphQLString,
args={
"objArg":
GraphQLArgument(
GeoType,
default_value={
"lat": 37.485,
"lon": -122.148
},
)
},
),
),
]),
))
_test_schema(schema)
def includes_nested_input_objects_in_the_map():
NestedInputObject = GraphQLInputObjectType("NestedInputObject", {})
SomeInputObject = GraphQLInputObjectType(
"SomeInputObject",
{"nested": GraphQLInputField(NestedInputObject)})
schema = GraphQLSchema(
GraphQLObjectType(
"Query",
{
"something":
GraphQLField(
GraphQLString,
{"input": GraphQLArgument(SomeInputObject)})
},
))
assert schema.type_map["SomeInputObject"] is SomeInputObject
assert schema.type_map["NestedInputObject"] is NestedInputObject
def build_delete_type(self):
# TODO: Use a function cache.
type = getattr(self, '_delete_type', None)
if not type:
type = GraphQLInputObjectType(
name='DeleteByIDInput',
fields={'id': GraphQLInputField(GraphQLInt)})
self._delete_type = type
return type
def _get_test_input_object(default_value):
return GraphQLInputObjectType(
"TestInputObject",
{
"foo":
GraphQLInputField(GraphQLScalarType("TestScalar"),
default_value=default_value)
},
)
def converts_input_objects_with_explicit_nulls():
input_obj = GraphQLInputObjectType(
"MyInputObj",
{"foo": GraphQLInputField(GraphQLFloat), "bar": GraphQLInputField(my_enum)},
)
assert ast_from_value({"foo": None}, input_obj) == ObjectValueNode(
fields=[ObjectFieldNode(name=NameNode(value="foo"), value=NullValueNode())]
)
def returns_a_list_for_a_dictionary():
test_list_of_objects = GraphQLList(
GraphQLInputObjectType(
"TestObject", {"length": GraphQLInputField(GraphQLInt)}
)
)
result = _coerce_value({"length": 100500}, test_list_of_objects)
assert expect_value(result) == [{"length": 100500}]
def builds_a_schema_with_field_arguments_with_default_values():
geo_type = GraphQLInputObjectType(
"Geo",
{
"lat": GraphQLInputField(GraphQLFloat),
"lon": GraphQLInputField(GraphQLFloat),
},
)
schema = GraphQLSchema(
GraphQLObjectType(
"ArgFields",
{
"defaultInt":
GraphQLField(
GraphQLString,
args={
"intArg": GraphQLArgument(GraphQLInt,
default_value=10)
},
),
"defaultList":
GraphQLField(
GraphQLString,
args={
"listArg":
GraphQLArgument(GraphQLList(GraphQLInt),
default_value=[1, 2, 3])
},
),
"defaultObject":
GraphQLField(
GraphQLString,
args={
"objArg":
GraphQLArgument(geo_type,
default_value={
"lat": 37.485,
"lon": -122.148
})
},
),
"defaultNull":
GraphQLField(
GraphQLString,
args={
"intArg":
GraphQLArgument(GraphQLInt, default_value=None)
},
),
"noDefaults":
GraphQLField(GraphQLString,
args={"intArg": GraphQLArgument(GraphQLInt)}),
},
))
check_schema(schema)
def rejects_an_input_object_type_with_incorrect_fields_function():
input_obj_type = GraphQLInputObjectType("SomeInputObject", lambda: [])
with raises(TypeError) as exc_info:
if input_obj_type.fields:
pass
msg = str(exc_info.value)
assert msg == (
"SomeInputObject fields must be a dict with field names as keys"
" or a function which returns such an object.")
def internal_type(cls, schema):
if cls._meta.abstract:
raise Exception(
"Abstract InputObjectTypes don't have a specific type.")
return GraphQLInputObjectType(
cls._meta.type_name,
description=cls._meta.description,
fields=partial(cls.fields_internal_types, schema),
)
def prints_input_type():
input_type = GraphQLInputObjectType(
name="InputType", fields={"int": GraphQLInputField(GraphQLInt)})
schema = GraphQLSchema(types=[input_type])
assert expect_printed_schema(schema) == dedent("""
input InputType {
int: Int
}
""")
def prints_input_type():
input_type = GraphQLInputObjectType(
name="InputType", fields={"int": GraphQLInputField(GraphQLInt)})
schema = GraphQLSchema(types=[input_type])
output = print_for_test(schema)
assert output == dedent("""
input InputType {
int: Int
}
""")
def transforms_values_with_out_type():
# This is an extension of GraphQL.js.
complex_input_obj = GraphQLInputObjectType(
"Complex",
{
"real": GraphQLInputField(GraphQLFloat),
"imag": GraphQLInputField(GraphQLFloat),
},
out_type=lambda value: complex(value["real"], value["imag"]),
)
assert _value_from("{ real: 1, imag: 2 }", complex_input_obj) == 1 + 2j
