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_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 }