def test_filters():
test_parent_1 = ParentModel(name="Adriel")
test_parent_2 = ParentModel(name="Carolina")
test_parent_3 = ParentModel(name="Cotu")
session.add(test_parent_1)
session.add(test_parent_2)
session.add(test_parent_3)
session.commit()
schema = R.Schema(R.Query)
query = '{{parentModels (ids:[{}, {}]) {{id, name}} }}'.format(test_parent_1.id, test_parent_2.id)
results = graphql(schema, query)
expected_results = {
'parentModels': [
{'name': 'Adriel', 'id': test_parent_1.id}, {'name': 'Carolina', 'id': test_parent_2.id}
]
}
assert results.data == expected_results
query = '{{parentModels (ids:[{}, {}], name:"Adriel") {{id, name}} }}'.format(test_parent_1.id, test_parent_2.id)
results = graphql(schema, query)
expected_results = {
'parentModels': [
{'name': 'Adriel', 'id': test_parent_1.id}
]
}
assert results.data == expected_results
session.delete(test_parent_3)
session.delete(test_parent_2)
session.delete(test_parent_1)
session.commit()
def test_normal_querying():
test_parent_1 = ParentModel(name="Adriel")
test_parent_2 = ParentModel(name="Carolina")
session.add(test_parent_1)
session.add(test_parent_2)
session.commit()
schema = R.Schema(R.Query)
query = "{parentModels {id, name}}"
results = graphql(schema, query)
assert len(results.data.get("parentModels")) == 2
test_child_1 = ChildModel(name="Oona", parent_id=test_parent_1.id)
session.add(test_child_1)
session.commit()
query = "{childModel {id,name, parent {id, name}}}"
results = graphql(schema, query)
expected_results = {
"childModel": {
"id": test_child_1.id,
"name": "Oona",
"parent": {
"id": test_parent_1.id,
"name": test_parent_1.name
}
}
}
assert results.data == expected_results
query = '{additionalFilters (name:"Someting"){id,name}'
assert len(results.errors) == 0
session.delete(test_parent_2)
session.delete(test_parent_1)
session.commit()
def test_cannot_use_client_schema_for_general_execution():
customScalar = GraphQLScalarType(name='CustomScalar',
serialize=lambda: None)
schema = GraphQLSchema(query=GraphQLObjectType(
name='Query',
fields={
'foo':
GraphQLField(GraphQLString,
args=OrderedDict([('custom1',
GraphQLArgument(customScalar)),
('custom2',
GraphQLArgument(customScalar))]))
}))
introspection = graphql(schema, introspection_query)
client_schema = build_client_schema(introspection.data)
class data:
foo = 'bar'
result = graphql(
client_schema,
'query NoNo($v: CustomScalar) { foo(custom1: 123, custom2: $v) }',
data, {'v': 'baz'})
assert result.data == {'foo': None}
assert [format_error(e) for e in result.errors] == [{
'locations': [{
'column': 32,
'line': 1
}],
'message':
'Client Schema cannot be used for execution.'
}]
def _test_schema(server_schema):
initial_introspection = graphql(server_schema, introspection_query)
client_schema = build_client_schema(initial_introspection.data)
second_introspection = graphql(client_schema, introspection_query)
assert initial_introspection.data == second_introspection.data
return client_schema
def _test_schema(server_schema):
initial_introspection = graphql(server_schema, introspection_query)
client_schema = build_client_schema(initial_introspection.data)
second_introspection = graphql(client_schema, introspection_query)
assert initial_introspection.data == second_introspection.data
return client_schema
def test_custom_scalar_type():
R = TypeRegistry()
def serialize_date_time(dt):
assert isinstance(dt, datetime.datetime)
return dt.isoformat()
def parse_literal(node):
if isinstance(node, ast.StringValue):
return datetime.datetime.strptime(node.value, "%Y-%m-%dT%H:%M:%S.%f")
def parse_value(value):
return datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
DateTimeType = GraphQLScalarType(name='DateTime', serialize=serialize_date_time,
parse_literal=parse_literal,
parse_value=parse_value)
R(DateTimeType)
class Query(R.ObjectType):
datetime = R.DateTime(args={
'in': R.DateTime
})
def resolve_datetime(self, obj, args, info):
return args.get('in')
now = datetime.datetime.now()
isoformat = now.isoformat()
Schema = R.Schema(R.Query)
response = graphql(Schema, '''
{
datetime(in: "%s")
}
''' % isoformat)
assert not response.errors
assert response.data == {
'datetime': isoformat
}
response = graphql(Schema, '''
query Test($date: DateTime) {
datetime(in: $date)
}
''', args={
'date': isoformat
})
assert not response.errors
assert response.data == {
'datetime': isoformat
}
def test_allows_fetching():
query = '''
{
usernames(usernames:["dschafer", "leebyron", "schrockn"]) {
username
url
}
}
'''
expected = {
'usernames': [
{
'username': '******',
'url': 'www.facebook.com/dschafer'
},
{
'username': '******',
'url': 'www.facebook.com/leebyron'
},
{
'username': '******',
'url': 'www.facebook.com/schrockn'
},
]
}
result = graphql(schema, query)
assert result.errors == None
assert result.data == expected
def test_requires_an_argument():
query = '''
mutation M {
simpleMutation {
result
}
}
'''
expected = {
'allObjects': [
{
'id': 'VXNlcjox'
},
{
'id': 'VXNlcjoy'
},
{
'id': 'UGhvdG86MQ=='
},
{
'id': 'UGhvdG86Mg=='
},
]
}
result = graphql(schema, query)
assert len(result.errors) == 1
def handle(request):
schema, root_value, pretty = get_options(request)
if request.method != 'GET' and request.method != 'POST':
return error_response(
Error('GraphQL only supports GET and POST requests.',
status=405,
headers={'Allow': 'GET, POST'}), pretty)
try:
data = parse_body(request)
except Error as e:
return error_response(e, pretty)
try:
query, variables, operation_name = get_graphql_params(
request, data)
except Error as e:
return error_response(e, pretty)
result = graphql(schema, query, root_value, variables, operation_name)
if result.invalid:
status = 400
else:
status = 200
d = {'data': result.data}
if result.errors:
d['errors'] = [format_error(error) for error in result.errors]
return Response(status=status,
content_type='application/json',
body=json_dump(d, pretty))
def test_use_fragment():
query = '''
query UseFragment {
luke: human(id: "1000") {
...HumanFragment
}
leia: human(id: "1003") {
...HumanFragment
}
}
fragment HumanFragment on Human {
name
homePlanet
}
'''
expected = {
'luke': {
'name': 'Luke Skywalker',
'homePlanet': 'Tatooine',
},
'leia': {
'name': 'Leia Organa',
'homePlanet': 'Alderaan',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_does_not_accept_string_variables_as_enum_input():
result = graphql(
Schema, 'query test($color: String!) { colorEnum(fromEnum: $color) }',
None, {'color': 'BLUE'})
assert not result.data
assert result.errors[
0].message == 'Variable "color" of type "String!" used in position expecting type "Color".'
def test_enum_may_be_both_input_and_output_type():
result = graphql(Schema, '{ colorEnum(fromEnum: GREEN) }')
assert not result.errors
assert result.data == {
'colorEnum': 'GREEN'
}
def test_identifies_deprecated_enum_values():
TestEnum = GraphQLEnumType('TestEnum', OrderedDict([
('NONDEPRECATED', GraphQLEnumValue(0)),
('DEPRECATED', GraphQLEnumValue(1, deprecation_reason='Removed in 1.0')),
('ALSONONDEPRECATED', GraphQLEnumValue(2))
]))
TestType = GraphQLObjectType('TestType', {
'testEnum': GraphQLField(TestEnum)
})
schema = GraphQLSchema(TestType)
request = '''{__type(name: "TestEnum") {
name
enumValues(includeDeprecated: true) {
name
isDeprecated
deprecationReason
}
} }'''
result = graphql(schema, request)
assert not result.errors
assert result.data == {'__type': {
'name': 'TestEnum',
'enumValues': [
{'name': 'NONDEPRECATED', 'isDeprecated': False, 'deprecationReason': None},
{'name': 'DEPRECATED', 'isDeprecated': True, 'deprecationReason': 'Removed in 1.0'},
{'name': 'ALSONONDEPRECATED', 'isDeprecated': False, 'deprecationReason': None},
]}}
def test_identifies_deprecated_enum_values():
TestEnum = GraphQLEnumType(
"TestEnum",
{
"NONDEPRECATED": 0,
"DEPRECATED": GraphQLEnumValue(1, deprecation_reason="Removed in 1.0"),
"ALSONONDEPRECATED": 2,
},
)
TestType = GraphQLObjectType("TestType", {"testEnum": GraphQLField(TestEnum)})
schema = GraphQLSchema(TestType)
request = """{__type(name: "TestEnum") {
name
enumValues(includeDeprecated: true) {
name
isDeprecated
deprecationReason
}
} }"""
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists(
{
"__type": {
"name": "TestEnum",
"enumValues": [
{"name": "NONDEPRECATED", "isDeprecated": False, "deprecationReason": None},
{"name": "DEPRECATED", "isDeprecated": True, "deprecationReason": "Removed in 1.0"},
{"name": "ALSONONDEPRECATED", "isDeprecated": False, "deprecationReason": None},
],
}
}
)
def test_input_type():
R = TypeRegistry()
class SimpleInput(R.InputType):
a = R.Int
b = R.Int
class Query(R.ObjectType):
f = R.String(args={
'input': R.SimpleInput
})
def resolve_f(self, obj, args, info):
input = SimpleInput(args['input'])
return "I was given {i.a} and {i.b}".format(i=input)
Schema = R.Schema(R.Query)
query = '''
{
f(input: {a: 1, b: 2})
}
'''
result = graphql(Schema, query)
assert not result.errors
assert result.data == {
'f': "I was given 1 and 2"
}
def test_relay_node_field_resolver():
data_source = InMemoryDataSource()
R = TypeRegistry()
Relay = R.Mixin(RelayMixin, data_source)
class Pet(R.Implements[R.Node]):
name = R.String
class Query(R.ObjectType):
pets = R.Pet.List
node = Relay.NodeField
schema = R.Schema(R.Query)
data_source.add(Pet(id=5, name="Garfield"))
data_source.add(Pet(id=6, name="Odis"))
result = graphql(
schema,
"""
{
node(id: "UGV0OjU=") {
id,
... on Pet {
name
}
}
}
""",
)
assert not result.errors
assert result.data == {"node": {"id": "UGV0OjU=", "name": "Garfield"}}
def test_identifies_deprecated_fields():
TestType = GraphQLObjectType(
"TestType",
{
"nonDeprecated": GraphQLField(GraphQLString),
"deprecated": GraphQLField(GraphQLString, deprecation_reason="Removed in 1.0"),
},
)
schema = GraphQLSchema(TestType)
request = """{__type(name: "TestType") {
name
fields(includeDeprecated: true) {
name
isDeprecated
deprecationReason
}
} }"""
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists(
{
"__type": {
"name": "TestType",
"fields": [
{"name": "nonDeprecated", "isDeprecated": False, "deprecationReason": None},
{"name": "deprecated", "isDeprecated": True, "deprecationReason": "Removed in 1.0"},
],
}
}
)
def test_hero_name_and_friends_query():
query = '''
query HeroNameAndFriendsQuery {
hero {
id
name
friends {
name
}
}
}
'''
expected = {
'hero': {
'id': '2001',
'name': 'R2-D2',
'friends': [
{'name': 'Luke Skywalker'},
{'name': 'Han Solo'},
{'name': 'Leia Organa'},
]
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_use_fragment():
query = '''
query UseFragment {
luke: human(id: "1000") {
...HumanFragment
}
leia: human(id: "1003") {
...HumanFragment
}
}
fragment HumanFragment on Human {
name
homePlanet
}
'''
expected = {
'luke': {
'name': 'Luke Skywalker',
'homePlanet': 'Tatooine',
},
'leia': {
'name': 'Leia Organa',
'homePlanet': 'Alderaan',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_fails_as_expected_on_the_type_root_field_without_an_arg():
TestType = GraphQLObjectType("TestType", {"testField": GraphQLField(GraphQLString)})
schema = GraphQLSchema(TestType)
request = "{ __type { name } }"
result = graphql(schema, request)
# TODO: change after implementing validation
assert not result.errors
def test_duplicate_fields():
query = '''
query DuplicateFields {
luke: human(id: "1000") {
name
homePlanet
}
leia: human(id: "1003") {
name
homePlanet
}
}
'''
expected = {
'luke': {
'name': 'Luke Skywalker',
'homePlanet': 'Tatooine',
},
'leia': {
'name': 'Leia Organa',
'homePlanet': 'Alderaan',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_object_type_can_override_interface_resolver():
R = TypeRegistry()
class Pet(R.Interface):
make_noise = R.String
def resolve_make_noise(self, *args):
return 'I am a pet, hear me roar!'
class Dog(R.Implements.Pet):
make_noise = R.String
def resolve_make_noise(self, *args):
return 'Woof woof! Bark bark!'
class Query(R.ObjectType):
dog = R.Dog
def resolve_dog(self, *args):
return Dog()
schema = R.Schema(R.Query)
result = graphql(schema, '{ dog { makeNoise } }')
assert not result.errors
assert result.data == {'dog': {'makeNoise': 'Woof woof! Bark bark!'}}
def test_will_choose_first_resolver_of_first_defined_interface():
R = TypeRegistry()
class Pet(R.Interface):
make_noise = R.String
def resolve_make_noise(self, *args):
return 'I am a pet, hear me roar!'
class Barker(R.Interface):
make_noise = R.String
def resolve_make_noise(self, *args):
return 'Woof, woof!!'
class Dog(R.Implements[Barker, Pet]):
make_noise = R.String
class Query(R.ObjectType):
dog = R.Dog
def resolve_dog(self, *args):
return Dog()
schema = R.Schema(R.Query)
result = graphql(schema, '{ dog { makeNoise } }')
assert not result.errors
assert result.data == {'dog': {'makeNoise': 'Woof, woof!!'}}
def test_correct_fetch_first_ship_rebels():
query = '''
query RebelsShipsQuery {
rebels {
name,
ships(first: 1) {
edges {
node {
name
}
}
}
}
}
'''
expected = {
'rebels': {
'name': 'Alliance to Restore the Republic',
'ships': {
'edges': [
{
'node': {
'name': 'X-Wing'
}
}
]
}
}
}
result = graphql(StarWarsSchema, query)
assert result.errors == None
assert result.data == expected
def test_does_not_accept_internal_value_as_enum_input():
result = graphql(
Schema, 'query test($color: Int!) { colorEnum(fromEnum: $color) }',
None, {'color': 2})
assert not result.data
assert result.errors[
0].message == 'Variable "color" of type "Int!" used in position expecting type "Color".'
def test_identifies_deprecated_fields():
TestType = GraphQLObjectType('TestType', {
'nonDeprecated': GraphQLField(GraphQLString),
'deprecated': GraphQLField(GraphQLString,
deprecation_reason='Removed in 1.0')
})
schema = GraphQLSchema(TestType)
request = '''{__type(name: "TestType") {
name
fields(includeDeprecated: true) {
name
isDeprecated
deprecationReason
}
} }'''
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists({'__type': {
'name': 'TestType',
'fields': [
{'name': 'nonDeprecated', 'isDeprecated': False, 'deprecationReason': None},
{'name': 'deprecated', 'isDeprecated': True,
'deprecationReason': 'Removed in 1.0'},
]
}})
def test_relay_node_definition_using_custom_type():
R = TypeRegistry()
Relay = R.Mixin(RelayMixin, InMemoryDataSource())
class Pet(R.Implements[R.Node]):
name = R.String
class Query(R.ObjectType):
pets = R.Pet.List
node = Relay.NodeField
schema = R.Schema(R.Query)
@R.Pet.CanBe
class MyPet(object):
def __init__(self, id, name):
self.id = id
self.name = name
pets = {5: MyPet(id=5, name="Garfield"), 6: MyPet(id=6, name="Odis")}
data = Query(pets=[pets[5], pets[6]])
result = graphql(schema, "{ pets { id, name } }", data)
assert result.data == {"pets": [{"id": "UGV0OjU=", "name": "Garfield"}, {"id": "UGV0OjY=", "name": "Odis"}]}
assert not result.errors
def test_duplicate_fields():
query = '''
query DuplicateFields {
luke: human(id: "1000") {
name
homePlanet
}
leia: human(id: "1003") {
name
homePlanet
}
}
'''
expected = {
'luke': {
'name': 'Luke Skywalker',
'homePlanet': 'Tatooine',
},
'leia': {
'name': 'Leia Organa',
'homePlanet': 'Alderaan',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_gives_different_ids():
query = '''
{
allObjects {
id
}
}
'''
expected = {
'allObjects': [
{
'id': 'VXNlcjox'
},
{
'id': 'VXNlcjoy'
},
{
'id': 'UGhvdG86MQ=='
},
{
'id': 'UGhvdG86Mg=='
},
]
}
result = graphql(schema, query)
assert result.errors == None
assert result.data == expected
def test_hero_name_and_friends_query():
query = '''
query HeroNameAndFriendsQuery {
hero {
id
name
friends {
name
}
}
}
'''
expected = {
'hero': {
'id':
'2001',
'name':
'R2-D2',
'friends': [
{
'name': 'Luke Skywalker'
},
{
'name': 'Han Solo'
},
{
'name': 'Leia Organa'
},
]
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_respects_the_includedeprecated_parameter_for_fields():
TestType = GraphQLObjectType(
"TestType",
{
"nonDeprecated": GraphQLField(GraphQLString),
"deprecated": GraphQLField(GraphQLString, deprecation_reason="Removed in 1.0"),
},
)
schema = GraphQLSchema(TestType)
request = """{__type(name: "TestType") {
name
trueFields: fields(includeDeprecated: true) { name }
falseFields: fields(includeDeprecated: false) { name }
omittedFields: fields { name }
} }"""
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists(
{
"__type": {
"name": "TestType",
"trueFields": [{"name": "nonDeprecated"}, {"name": "deprecated"}],
"falseFields": [{"name": "nonDeprecated"}],
"omittedFields": [{"name": "nonDeprecated"}],
}
}
)
def test_respects_the_includedeprecated_parameter_for_fields():
TestType = GraphQLObjectType(
'TestType', {
'nonDeprecated':
GraphQLField(GraphQLString),
'deprecated':
GraphQLField(GraphQLString, deprecation_reason='Removed in 1.0')
})
schema = GraphQLSchema(TestType)
request = '''{__type(name: "TestType") {
name
trueFields: fields(includeDeprecated: true) { name }
falseFields: fields(includeDeprecated: false) { name }
omittedFields: fields { name }
} }'''
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists({
'__type': {
'name': 'TestType',
'trueFields': [{
'name': 'nonDeprecated'
}, {
'name': 'deprecated'
}],
'falseFields': [{
'name': 'nonDeprecated'
}],
'omittedFields': [{
'name': 'nonDeprecated'
}],
}
})
def test_respects_the_includedeprecated_parameter_for_enum_values():
TestEnum = GraphQLEnumType(
"TestEnum",
{
"NONDEPRECATED": 0,
"DEPRECATED": GraphQLEnumValue(1, deprecation_reason="Removed in 1.0"),
"ALSONONDEPRECATED": 2,
},
)
TestType = GraphQLObjectType("TestType", {"testEnum": GraphQLField(TestEnum)})
schema = GraphQLSchema(TestType)
request = """{__type(name: "TestEnum") {
name
trueValues: enumValues(includeDeprecated: true) { name }
falseValues: enumValues(includeDeprecated: false) { name }
omittedValues: enumValues { name }
} }"""
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists(
{
"__type": {
"name": "TestEnum",
"trueValues": [{"name": "NONDEPRECATED"}, {"name": "DEPRECATED"}, {"name": "ALSONONDEPRECATED"}],
"falseValues": [{"name": "NONDEPRECATED"}, {"name": "ALSONONDEPRECATED"}],
"omittedValues": [{"name": "NONDEPRECATED"}, {"name": "ALSONONDEPRECATED"}],
}
}
)
def test_accepts_enum_literals_as_input_arguments_to_subscriptions():
result = graphql(
Schema,
'subscription x($color: Color!) { subscribeToEnum(color: $color) }',
None, {'color': 'GREEN'})
assert not result.errors
assert result.data == {'subscribeToEnum': 'GREEN'}
def test_identifies_deprecated_fields():
TestType = GraphQLObjectType('TestType', {
'nonDeprecated': GraphQLField(GraphQLString),
'deprecated': GraphQLField(GraphQLString,
deprecation_reason='Removed in 1.0')
})
schema = GraphQLSchema(TestType)
request = '''{__type(name: "TestType") {
name
fields(includeDeprecated: true) {
name
isDeprecated
deprecationReason
}
} }'''
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists({'__type': {
'name': 'TestType',
'fields': [
{'name': 'nonDeprecated', 'isDeprecated': False, 'deprecationReason': None},
{'name': 'deprecated', 'isDeprecated': True,
'deprecationReason': 'Removed in 1.0'},
]
}})
def test_does_not_accept_internal_value_as_enum_variable():
result = graphql(
Schema, 'query test($color: Color!) { colorEnum(fromEnum: $color) }',
None, {'color': 2})
assert not result.data
assert result.errors[0].message == 'Variable "$color" got invalid value 2.\n' \
'Expected type "Color", found 2.'
def test_respects_the_includedeprecated_parameter_for_enum_values():
TestEnum = GraphQLEnumType('TestEnum', OrderedDict([
('NONDEPRECATED', GraphQLEnumValue(0)),
('DEPRECATED', GraphQLEnumValue(1, deprecation_reason='Removed in 1.0')),
('ALSONONDEPRECATED', GraphQLEnumValue(2))
]))
TestType = GraphQLObjectType('TestType', {
'testEnum': GraphQLField(TestEnum)
})
schema = GraphQLSchema(TestType)
request = '''{__type(name: "TestEnum") {
name
trueValues: enumValues(includeDeprecated: true) { name }
falseValues: enumValues(includeDeprecated: false) { name }
omittedValues: enumValues { name }
} }'''
result = graphql(schema, request)
assert not result.errors
assert result.data == {'__type': {
'name': 'TestEnum',
'trueValues': [{'name': 'NONDEPRECATED'}, {'name': 'DEPRECATED'},
{'name': 'ALSONONDEPRECATED'}],
'falseValues': [{'name': 'NONDEPRECATED'},
{'name': 'ALSONONDEPRECATED'}],
'omittedValues': [{'name': 'NONDEPRECATED'},
{'name': 'ALSONONDEPRECATED'}],
}}
def test_refetches_the_ids():
query = '''
{
user: node(id: "VXNlcjox") {
id
... on User {
name
}
},
photo: node(id: "UGhvdG86MQ==") {
id
... on Photo {
width
}
}
}
'''
expected = {
'user': {
'id': 'VXNlcjox',
'name': 'John Doe'
},
'photo': {
'id': 'UGhvdG86MQ==',
'width': 300
}
}
result = graphql(schema, query)
assert result.errors == None
assert result.data == expected
def test_contains_correct_field():
query = '''
{
__schema {
mutationType {
fields {
name
args {
name
type {
name
kind
ofType {
name
kind
}
}
}
type {
name
kind
}
}
}
}
}
'''
expected = {
'__schema': {
'mutationType': {
'fields': [
{
'name': 'simpleMutation',
'args': [
{
'name': 'input',
'type': {
'name': None,
'kind': 'NON_NULL',
'ofType': {
'name': 'SimpleMutationInput',
'kind': 'INPUT_OBJECT'
}
},
}
],
'type': {
'name': 'SimpleMutationPayload',
'kind': 'OBJECT',
}
},
]
}
}
}
result = graphql(schema, query)
assert result.errors == None
assert result.data == expected
def test_fails_as_expected_on_the_type_root_field_without_an_arg():
TestType = GraphQLObjectType('TestType',
{'testField': GraphQLField(GraphQLString)})
schema = GraphQLSchema(TestType)
request = '{ __type { name } }'
result = graphql(schema, request)
# TODO: change after implementing validation
assert not result.errors
def test_is_type_of_used_to_resolve_runtime_type_for_interface():
PetType = GraphQLInterfaceType(
name='Pet',
fields={
'name': GraphQLField(GraphQLString)
}
)
DogType = GraphQLObjectType(
name='Dog',
interfaces=[PetType],
is_type_of=is_type_of(Dog),
fields={
'name': GraphQLField(GraphQLString),
'woofs': GraphQLField(GraphQLBoolean)
}
)
CatType = GraphQLObjectType(
name='Cat',
interfaces=[PetType],
is_type_of=is_type_of(Cat),
fields={
'name': GraphQLField(GraphQLString),
'meows': GraphQLField(GraphQLBoolean)
}
)
schema = GraphQLSchema(
query=GraphQLObjectType(
name='Query',
fields={
'pets': GraphQLField(
GraphQLList(PetType),
resolver=lambda *_: [Dog('Odie', True), Cat('Garfield', False)]
)
}
)
)
query = '''
{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}
'''
result = graphql(schema, query)
assert not result.errors
assert result.data == {'pets': [{'woofs': True, 'name': 'Odie'}, {'name': 'Garfield', 'meows': False}]}
def test_object_type_as_data():
jake = Human(name='Jake', favorite_color='Red')
assert jake.name == 'Jake'
assert jake.favorite_color == 'Red'
assert repr(jake) == '<Human name={!r} favorite_color={!r}>'.format(jake.name, jake.favorite_color)
result = graphql(Schema, '{ name favoriteColor }', jake)
assert not result.errors
assert result.data == {'name': 'Jake', 'favoriteColor': 'Red'}
def test_object_type_as_data_with_partial_fields_provided():
jake = Human(name='Jake')
assert jake.name == 'Jake'
assert jake.favorite_color is None
assert repr(jake) == '<Human name={!r} favorite_color={!r}>'.format(jake.name, jake.favorite_color)
result = graphql(Schema, '{ name favoriteColor }', jake)
assert not result.errors
assert result.data == {'name': 'Jake', 'favoriteColor': None}
def test_exposes_descriptions_on_types_and_fields():
QueryRoot = GraphQLObjectType('QueryRoot',
{'f': GraphQLField(GraphQLString)})
schema = GraphQLSchema(QueryRoot)
request = '''{
schemaType: __type(name: "__Schema") {
name,
description,
fields {
name,
description
}
}
}
'''
result = graphql(schema, request)
assert not result.errors
assert result.data == {
'schemaType': {
'name':
'__Schema',
'description':
'A GraphQL Schema defines the capabilities of a ' +
'GraphQL server. It exposes all available types and ' +
'directives on the server, as well as the entry ' +
'points for query, mutation and subscription operations.',
'fields': [{
'name':
'types',
'description':
'A list of all types supported by this server.'
}, {
'name':
'queryType',
'description':
'The type that query operations will be rooted at.'
}, {
'name':
'mutationType',
'description':
'If this server supports mutation, the type that '
'mutation operations will be rooted at.'
}, {
'name':
'subscriptionType',
'description':
'If this server support subscription, the type '
'that subscription operations will be rooted at.'
}, {
'name':
'directives',
'description':
'A list of all directives supported by this server.'
}]
}
}
def test_parse_error():
query = '''
qeury
'''
result = graphql(StarWarsSchema, query)
assert result.invalid
formatted_error = format_error(result.errors[0])
assert formatted_error['locations'] == [{'column': 9, 'line': 2}]
assert 'Syntax Error GraphQL request (2:9) Unexpected Name "qeury"' in formatted_error['message']
assert result.data is None
def test_is_type_of_used_to_resolve_runtime_type_for_interface():
PetType = GraphQLInterfaceType(
name='Pet', fields={'name': GraphQLField(GraphQLString)})
DogType = GraphQLObjectType(name='Dog',
interfaces=[PetType],
is_type_of=is_type_of(Dog),
fields={
'name': GraphQLField(GraphQLString),
'woofs': GraphQLField(GraphQLBoolean)
})
CatType = GraphQLObjectType(name='Cat',
interfaces=[PetType],
is_type_of=is_type_of(Cat),
fields={
'name': GraphQLField(GraphQLString),
'meows': GraphQLField(GraphQLBoolean)
})
schema = GraphQLSchema(query=GraphQLObjectType(
name='Query',
fields={
'pets':
GraphQLField(
GraphQLList(PetType),
resolver=lambda *_:
[Dog('Odie', True), Cat('Garfield', False)])
}))
query = '''
{
pets {
name
... on Dog {
woofs
}
... on Cat {
meows
}
}
}
'''
result = graphql(schema, query)
assert not result.errors
assert result.data == {
'pets': [{
'woofs': True,
'name': 'Odie'
}, {
'name': 'Garfield',
'meows': False
}]
}
def test_hero_name_query():
query = '''
query HeroNameQuery {
hero {
name
}
}
'''
expected = {'hero': {'name': 'R2-D2'}}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_query():
schema = GraphQLSchema(query=Human_type)
query = '''
{
name
pet {
type
}
}
'''
expected = {'name': 'Peter', 'pet': {'type': 'Dog'}}
result = graphql(schema, query, root=Human(object()))
assert not result.errors
assert result.data == expected
def test_fails_as_expected_on_the_type_root_field_without_an_arg():
TestType = GraphQLObjectType('TestType', {
'testField': GraphQLField(GraphQLString)
})
schema = GraphQLSchema(TestType)
request = '''
{
__type {
name
}
}'''
result = graphql(schema, request)
expected_error = {'message': ProvidedNonNullArguments.missing_field_arg_message('__type', 'name', 'String!'),
'locations': [dict(line=3, column=9)]}
assert (expected_error in [format_error(error) for error in result.errors])
def test_invalid_id_query():
query = '''
query humanQuery($id: String!) {
human(id: $id) {
name
}
}
'''
params = {
'id': 'not a valid id',
}
expected = {'human': None}
result = graphql(StarWarsSchema, query, None, params)
assert not result.errors
assert result.data == expected
def test_fetch_luke_aliased():
query = '''
query FetchLukeAliased {
luke: human(id: "1000") {
name
}
}
'''
expected = {
'luke': {
'name': 'Luke Skywalker',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_fails_on_a_deep_non_null():
schema = GraphQLSchema(query=GraphQLObjectType(
name='Query',
fields={
'foo':
GraphQLField(
GraphQLList(
GraphQLList(GraphQLList(GraphQLNonNull(GraphQLString)))))
}))
introspection = graphql(schema, introspection_query)
with raises(Exception) as excinfo:
build_client_schema(introspection.data)
assert str(
excinfo.value) == 'Decorated type deeper than introspection query.'
def test_check_type_of_luke():
query = '''
query CheckTypeOfLuke {
hero(episode: EMPIRE) {
__typename
name
}
}
'''
expected = {
'hero': {
'__typename': 'Human',
'name': 'Luke Skywalker',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_check_type_of_r2():
query = '''
query CheckTypeOfR2 {
hero {
__typename
name
}
}
'''
expected = {
'hero': {
'__typename': 'Droid',
'name': 'R2-D2',
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_fetch_some_id_query2():
query = '''
query FetchSomeIDQuery($someId: String!) {
human(id: $someId) {
name
}
}
'''
params = {
'someId': '1002',
}
expected = {
'human': {
'name': 'Han Solo',
}
}
result = graphql(StarWarsSchema, query, None, params)
assert not result.errors
assert result.data == expected
def test_introspects_on_input_object():
TestInputObject = GraphQLInputObjectType(
'TestInputObject', {
'a': GraphQLInputObjectField(GraphQLString, default_value='foo'),
'b': GraphQLInputObjectField(GraphQLList(GraphQLString)),
})
TestType = GraphQLObjectType(
'TestType', {
'field':
GraphQLField(type=GraphQLString,
args={'complex': GraphQLArgument(TestInputObject)},
resolver=lambda obj, args, info: json.dumps(
args.get('complex')))
})
schema = GraphQLSchema(TestType)
request = '''
{
__schema {
types {
kind
name
inputFields {
name
type { ...TypeRef }
defaultValue
}
}
}
}
fragment TypeRef on __Type {
kind
name
ofType {
kind
name
ofType {
kind
name
ofType {
kind
name
}
}
}
}
'''
result = graphql(schema, request)
assert not result.errors
assert sort_lists({'kind': 'INPUT_OBJECT',
'name': 'TestInputObject',
'inputFields':
[{'name': 'a',
'type':
{'kind': 'SCALAR',
'name': 'String',
'ofType': None},
'defaultValue': '"foo"'},
{'name': 'b',
'type':
{'kind': 'LIST',
'name': None,
'ofType':
{'kind': 'SCALAR',
'name': 'String',
'ofType': None}},
'defaultValue': None}]}) in \
sort_lists(result.data['__schema']['types'])
def test_nested_query():
query = '''
query NestedQuery {
hero {
name
friends {
name
appearsIn
friends {
name
}
}
}
}
'''
expected = {
'hero': {
'name':
'R2-D2',
'friends': [
{
'name':
'Luke Skywalker',
'appearsIn': ['NEWHOPE', 'EMPIRE', 'JEDI'],
'friends': [
{
'name': 'Han Solo',
},
{
'name': 'Leia Organa',
},
{
'name': 'C-3PO',
},
{
'name': 'R2-D2',
},
]
},
{
'name':
'Han Solo',
'appearsIn': ['NEWHOPE', 'EMPIRE', 'JEDI'],
'friends': [
{
'name': 'Luke Skywalker',
},
{
'name': 'Leia Organa',
},
{
'name': 'R2-D2',
},
]
},
{
'name':
'Leia Organa',
'appearsIn': ['NEWHOPE', 'EMPIRE', 'JEDI'],
'friends': [
{
'name': 'Luke Skywalker',
},
{
'name': 'Han Solo',
},
{
'name': 'C-3PO',
},
{
'name': 'R2-D2',
},
]
},
]
}
}
result = graphql(StarWarsSchema, query)
assert not result.errors
assert result.data == expected
def test_exposes_descriptions_on_enums():
QueryRoot = GraphQLObjectType('QueryRoot', {})
schema = GraphQLSchema(QueryRoot)
request = '''{
typeKindType: __type(name: "__TypeKind") {
name,
description,
enumValues {
name,
description
}
}
}
'''
result = graphql(schema, request)
assert not result.errors
assert sort_lists(result.data) == sort_lists({
'typeKindType': {
'name':
'__TypeKind',
'description':
'An enum describing what kind of type a given __Type is',
'enumValues': [{
'description': 'Indicates this type is a scalar.',
'name': 'SCALAR'
}, {
'description':
'Indicates this type is an object. ' +
'`fields` and `interfaces` are valid fields.',
'name':
'OBJECT'
}, {
'description':
'Indicates this type is an interface. ' +
'`fields` and `possibleTypes` are valid fields.',
'name':
'INTERFACE'
}, {
'description': 'Indicates this type is a union. ' +
'`possibleTypes` is a valid field.',
'name': 'UNION'
}, {
'description': 'Indicates this type is an enum. ' +
'`enumValues` is a valid field.',
'name': 'ENUM'
}, {
'description':
'Indicates this type is an input object. ' +
'`inputFields` is a valid field.',
'name':
'INPUT_OBJECT'
}, {
'description': 'Indicates this type is a list. ' +
'`ofType` is a valid field.',
'name': 'LIST'
}, {
'description':
'Indicates this type is a non-null. ' +
'`ofType` is a valid field.',
'name':
'NON_NULL'
}]
}
})
