def test_object_type_not_union_if_abstract():
schema = Schema()
class Query1(ObjectType):
field1 = String()
class Meta:
abstract = True
class Query2(ObjectType):
field2 = String()
class Meta:
abstract = True
class Query(Query1, Query2):
'''Query description'''
my_attr = True
object_type = schema.T(Query)
assert issubclass(Query, ObjectType)
assert Query._meta.type_name == 'Query'
assert Query._meta.description == 'Query description'
assert isinstance(object_type, GraphQLObjectType)
assert list(Query._meta.fields_map.keys()) == ['field1', 'field2']
def test_field_none_type_raises_error():
s = Schema()
f = Field(None)
f.contribute_to_class(MyOt, 'field_name')
with raises(Exception) as excinfo:
s.T(f)
assert str(
excinfo.value) == "Internal type for field MyOt.field_name is None"
def test_argument_internal_type():
class MyObjectType(ObjectType):
pass
schema = Schema(query=MyObjectType)
a = Argument(MyObjectType, description='My argument', default='3')
type = schema.T(a)
assert isinstance(type, GraphQLArgument)
assert type.description == 'My argument'
assert type.default_value == '3'
def test_field_self():
field = Field('self', name='my_customName')
class MyObjectType(ObjectType):
my_field = field
schema = Schema()
assert schema.T(field).type == schema.T(MyObjectType)
def test_field_string_reference():
field = Field('MyObjectType', name='my_customName')
class MyObjectType(ObjectType):
my_field = field
schema = Schema(query=MyObjectType)
assert isinstance(field.type, LazyType)
assert schema.T(field.type) == schema.T(MyObjectType)
def test_field_resolve_argument():
def resolver(instance, args, info):
return args.get('first_name')
field = Field(String(), first_name=String(), description='My argument', resolver=resolver)
class Query(ObjectType):
my_field = field
schema = Schema(query=Query)
type = schema.T(field)
assert type.resolver(None, {'firstName': 'Peter'}, None, None) == 'Peter'
def test_field_internal_type_deprecated():
deprecation_reason = 'No more used'
field = Field(String(), description='My argument',
deprecation_reason=deprecation_reason)
class Query(ObjectType):
my_field = field
schema = Schema(query=Query)
type = schema.T(field)
assert isinstance(type, GraphQLField)
assert type.deprecation_reason == deprecation_reason
def test_inputobjecttype():
class InputCharacter(InputObjectType):
'''InputCharacter description'''
name = String()
schema = Schema()
object_type = schema.T(InputCharacter)
assert isinstance(object_type, GraphQLInputObjectType)
assert InputCharacter._meta.type_name == 'InputCharacter'
assert object_type.description == 'InputCharacter description'
assert list(object_type.get_fields().keys()) == ['name']
def test_enum_values():
RGB = Enum('RGB', dict(RED=0, GREEN=1, BLUE=2), description='RGB enum description')
schema = Schema()
object_type = schema.T(RGB)
assert isinstance(object_type, GraphQLEnumType)
assert RGB._meta.type_name == 'RGB'
assert RGB._meta.description == 'RGB enum description'
assert RGB.RED == 0
assert RGB.GREEN == 1
assert RGB.BLUE == 2
def test_object_type():
class Human(ObjectType):
'''Human description'''
name = String()
friends = String()
schema = Schema()
object_type = schema.T(Human)
assert Human._meta.type_name == 'Human'
assert isinstance(object_type, GraphQLObjectType)
assert object_type.description == 'Human description'
assert list(object_type.get_fields().keys()) == ['name', 'friends']
assert Human._meta.fields_map['name'].object_type == Human
def test_interface():
class Character(Interface):
'''Character description'''
name = String()
schema = Schema()
object_type = schema.T(Character)
assert issubclass(Character, Interface)
assert isinstance(object_type, GraphQLInterfaceType)
assert Character._meta.interface
assert Character._meta.type_name == 'Character'
assert object_type.description == 'Character description'
assert list(object_type.get_fields().keys()) == ['name']
def test_field_resolve_type_custom():
class MyCustomType(ObjectType):
pass
f = Field('MyCustomType')
class OtherType(ObjectType):
field_name = f
s = Schema()
s.query = OtherType
s.register(MyCustomType)
assert s.T(f).type == s.T(MyCustomType)
def test_field_objectype_resolver():
field = Field(String)
class Query(ObjectType):
my_field = field
def resolve_my_field(self, *args, **kwargs):
'''Custom description'''
return 'RESOLVED'
schema = Schema(query=Query)
type = schema.T(field)
assert isinstance(type, GraphQLField)
assert type.description == 'Custom description'
assert type.resolver(Query(), {}, None, None) == 'RESOLVED'
def test_enum():
class RGB(Enum):
'''RGB enum description'''
RED = 0
GREEN = 1
BLUE = 2
schema = Schema()
object_type = schema.T(RGB)
assert isinstance(object_type, GraphQLEnumType)
assert RGB._meta.type_name == 'RGB'
assert RGB._meta.description == 'RGB enum description'
assert RGB.RED == 0
assert RGB.GREEN == 1
assert RGB.BLUE == 2
def test_mutation():
class MyMutation(Mutation):
'''MyMutation description'''
class Input:
arg_name = String()
name = String()
schema = Schema()
object_type = schema.T(MyMutation)
assert MyMutation._meta.type_name == 'MyMutation'
assert isinstance(object_type, GraphQLObjectType)
assert object_type.description == 'MyMutation description'
assert list(object_type.get_fields().keys()) == ['name']
assert MyMutation._meta.fields_map['name'].object_type == MyMutation
assert isinstance(MyMutation.arguments, ArgumentsGroup)
assert 'argName' in schema.T(MyMutation.arguments)
def test_inputfield_string_reference():
class MyInput(InputObjectType):
my_field = InputField(String, description='My input field', default='3')
my_input_field = InputField('MyInput')
class OtherInput(InputObjectType):
my_input = my_input_field
class Query(ObjectType):
a = String()
schema = Schema(query=Query)
my_input_type = schema.T(MyInput)
my_input_field_type = schema.T(my_input_field)
assert my_input_field_type.type == my_input_type
def test_inputfield_internal_type():
field = InputField(String, description='My input field', default='3')
class MyObjectType(InputObjectType):
my_field = field
class Query(ObjectType):
input_ot = Field(MyObjectType)
schema = Schema(query=MyObjectType)
type = schema.T(field)
assert field.name is None
assert field.attname == 'my_field'
assert isinstance(type, GraphQLInputObjectField)
assert type.description == 'My input field'
assert type.default_value == '3'
def test_field_internal_type():
def resolver(*args):
return 'RESOLVED'
field = Field(String(), description='My argument', resolver=resolver)
class Query(ObjectType):
my_field = field
schema = Schema(query=Query)
type = schema.T(field)
assert field.name is None
assert field.attname == 'my_field'
assert isinstance(type, GraphQLField)
assert type.description == 'My argument'
assert type.resolver(None, {}, None, None) == 'RESOLVED'
assert type.type == GraphQLString
def test_interface_inheritance():
class Character(Interface):
pass
class GeneralInterface(Interface):
pass
class ShouldBeObjectType(GeneralInterface, Character):
pass
schema = Schema()
assert Character._meta.interface
assert not ShouldBeObjectType._meta.interface
assert issubclass(ShouldBeObjectType, ObjectType)
assert Character in ShouldBeObjectType._meta.interfaces
assert GeneralInterface in ShouldBeObjectType._meta.interfaces
assert isinstance(schema.T(Character), GraphQLInterfaceType)
assert isinstance(schema.T(ShouldBeObjectType), GraphQLObjectType)
def test_uniontype():
class Human(ObjectType):
name = String()
class Pet(ObjectType):
name = String()
class Thing(UnionType):
'''Thing union description'''
class Meta:
types = [Human, Pet]
schema = Schema()
object_type = schema.T(Thing)
assert isinstance(object_type, GraphQLUnionType)
assert Thing._meta.type_name == 'Thing'
assert object_type.description == 'Thing union description'
assert object_type.get_types() == [schema.T(Human), schema.T(Pet)]
def test_field_resolve_vars():
class Query(ObjectType):
hello = String(first_name=String())
def resolve_hello(self, args, info):
return 'Hello ' + args.get('first_name')
schema = Schema(query=Query)
result = schema.execute("""
query foo($firstName:String)
{
hello(firstName:$firstName)
}
""",
args={"firstName": "Serkan"})
expected = {'hello': 'Hello Serkan'}
assert result.data == expected
def test_field_resolve_vars():
class Query(ObjectType):
hello = String(first_name=String())
def resolve_hello(self, args, info):
return 'Hello ' + args.get('first_name')
schema = Schema(query=Query)
result = schema.execute("""
query foo($firstName:String)
{
hello(firstName:$firstName)
}
""", variable_values={"firstName": "Serkan"})
expected = {
'hello': 'Hello Serkan'
}
assert result.data == expected
def test_field_resolve_type_custom():
class MyCustomType(ObjectType):
pass
f = Field('MyCustomType')
class OtherType(ObjectType):
field_name = f
s = Schema()
s.query = OtherType
s.register(MyCustomType)
assert s.T(f).type == s.T(MyCustomType)
def test_field_name_as_argument():
field = Field(None, name=String())
schema = Schema()
args = field.arguments
assert 'name' in schema.T(args)
return self._write_prop
@write_prop.setter
def write_prop(self, value):
self._write_prop = value
class Droid(Character):
'''Droid description'''
class CharacterType(Droid, Human):
'''Union Type'''
schema = Schema()
def test_interface():
object_type = schema.T(Character)
assert Character._meta.is_interface is True
assert isinstance(object_type, GraphQLInterfaceType)
assert Character._meta.type_name == 'core_Character'
assert object_type.description == 'Character description'
assert list(object_type.get_fields().keys()) == ['name']
def test_interface_cannot_initialize():
with raises(Exception) as excinfo:
Character()
assert 'An interface cannot be initialized' == str(excinfo.value)
class Human(Character):
friends = List(Character)
pet = Field(Pet)
def resolve_name(self, *args):
return 'Peter'
def resolve_friend(self, *args):
return Human(object())
def resolve_pet(self, *args):
return Pet(object())
schema = Schema()
Human_type = schema.T(Human)
def test_type():
assert Human._meta.fields_map['name'].resolver(Human(object()), {},
None) == 'Peter'
def test_query():
schema = GraphQLSchema(query=Human_type)
query = '''
{
name
pet {
def test_field_custom_arguments():
field = Field(None, name='my_customName', p=String())
schema = Schema()
args = field.arguments
assert 'p' in schema.T(args)
to = graphene.Int()
result = graphene.String()
@classmethod
def mutate(cls, instance, args, info):
global my_id
my_id = args.get('to', my_id + 1)
return ChangeNumber(result=my_id)
class MyResultMutation(graphene.ObjectType):
change_number = graphene.Field(ChangeNumber)
schema = Schema(query=Query, mutation=MyResultMutation)
def test_mutation_input():
assert list(schema.T(ChangeNumber.arguments).keys()) == ['to']
def test_execute_mutations():
query = '''
mutation M{
first: changeNumber {
result
},
second: changeNumber {
result
}
