def prints_string_field_with_string_arg_with_default(): output = print_single_field_schema( GraphQLField(type_=GraphQLString, args={ 'argOne': GraphQLArgument(GraphQLString, default_value='tes\t de\fault') })) assert output == dedent(r""" type Query { singleField(argOne: String = "tes\t de\fault"): String } """)
def transforms_arguments_using_out_names(): # This is an extension of GraphQL.js. schema = _test_schema( GraphQLField( GraphQLString, args={ "aStr": GraphQLArgument(GraphQLString, out_name="a_str"), "aInt": GraphQLArgument(GraphQLInt, out_name="a_int"), }, resolve=lambda source, info, **args: repr([source, args]), )) def execute(source, root_value=None): return graphql_sync(schema=schema, source=source, root_value=root_value) assert execute("{ test }") == ({"test": "[None, {}]"}, None) assert execute("{ test }", "Source!") == ( { "test": "['Source!', {}]" }, None, ) assert execute('{ test(aStr: "String!") }', "Source!") == ( { "test": "['Source!', {'a_str': 'String!'}]" }, None, ) assert execute('{ test(aInt: -123, aStr: "String!") }', "Source!") == ( { "test": "['Source!', {'a_str': 'String!', 'a_int': -123}]" }, None, )
def includes_nested_input_objects_in_the_map(): NestedInputObject = GraphQLInputObjectType( 'NestedInputObject', {'value': GraphQLInputField(GraphQLString)}) SomeInputObject = GraphQLInputObjectType( 'SomeInputObject', {'nested': GraphQLInputField(NestedInputObject)}) SomeMutation = GraphQLObjectType( 'SomeMutation', { 'mutateSomething': GraphQLField(BlogArticle, {'input': GraphQLArgument(SomeInputObject)}) }) SomeSubscription = GraphQLObjectType( 'SomeSubscription', { 'subscribeToSomething': GraphQLField(BlogArticle, {'input': GraphQLArgument(SomeInputObject)}) }) schema = GraphQLSchema(query=BlogQuery, mutation=SomeMutation, subscription=SomeSubscription) assert schema.type_map['NestedInputObject'] is NestedInputObject
def prints_string_field_with_multiple_args_last_is_default(): schema = build_single_field_schema( GraphQLField( type_=GraphQLString, args={ "argOne": GraphQLArgument(GraphQLInt), "argTwo": GraphQLArgument(GraphQLString), "argThree": GraphQLArgument(GraphQLBoolean, default_value=False), }, )) assert expect_printed_schema(schema) == dedent(""" type Query { singleField(argOne: Int, argTwo: String, argThree: Boolean = false): String } """ # noqa: E501 )
def includes_input_types_only_used_in_directives(): directive = GraphQLDirective( name="dir", locations=[DirectiveLocation.OBJECT], args={ "arg": GraphQLArgument( GraphQLInputObjectType( "Foo", {"field": GraphQLInputField(GraphQLString)} ) ), "argList": GraphQLArgument( GraphQLList( GraphQLInputObjectType( "Bar", {"field": GraphQLInputField(GraphQLString)} ) ) ), }, ) schema = GraphQLSchema(directives=[directive]) assert "Foo" in schema.type_map assert "Bar" in schema.type_map
def prints_string_field_with_int_arg(): output = print_single_field_schema( GraphQLField( type_=GraphQLString, args={"argOne": GraphQLArgument(GraphQLInt)} ) ) assert output == dedent( """ type Query { singleField(argOne: Int): String } """ )
def test_correctly_threads_arguments(): # type: () -> None doc = """ query Example { b(numArg: 123, stringArg: "foo") } """ def resolver(source, info, numArg, stringArg): # type: (Optional[Any], ResolveInfo, int, str) -> None assert numArg == 123 assert stringArg == "foo" resolver.got_here = True resolver.got_here = False doc_ast = parse(doc) Type = GraphQLObjectType( "Type", { "b": GraphQLField( GraphQLString, args={ "numArg": GraphQLArgument(GraphQLInt), "stringArg": GraphQLArgument(GraphQLString), }, resolver=resolver, ) }, ) result = execute(GraphQLSchema(Type), doc_ast, None, operation_name="Example") assert not result.errors assert resolver.got_here
def prints_string_field_with_int_arg_with_default_null(): output = print_single_field_schema( GraphQLField( type_=GraphQLString, args={ "argOne": GraphQLArgument(GraphQLInt, default_value=None) }, )) assert output == dedent(""" type Query { singleField(argOne: Int = null): String } """)
def transforms_arguments_with_inputs_using_out_names(): # This is an extension of GraphQL.js. TestInputObject = GraphQLInputObjectType( "TestInputObjectType", lambda: { "inputOne": GraphQLInputField(GraphQLString, out_name="input_one"), "inputRecursive": GraphQLInputField(TestInputObject, out_name="input_recursive"), }, ) schema = _test_schema( GraphQLField( GraphQLString, args={ "aInput": GraphQLArgument(TestInputObject, out_name="a_input") }, resolve=lambda source, info, **args: repr([source, args]), )) def execute(source, root_value=None): return graphql_sync( schema=schema, source=source, root_value=root_value, ) assert execute("{ test }") == ({"test": "[None, {}]"}, None) assert execute( '{ test(aInput: {inputOne: "String!"}) }', "Source!") == ( { "test": "['Source!', {'a_input': {'input_one': 'String!'}}]" }, None, ) assert execute( '{ test(aInput: {inputRecursive: {inputOne: "SourceRecursive!"}}) }', "Source!", ) == ( { "test": "['Source!'," " {'a_input': {'input_recursive': {'input_one': 'SourceRecursive!'}}}]" }, None, )
def test_maps_argument_out_names_well_with_input(): # type: () -> None def resolver(source, info, **args): # type: (Optional[str], ResolveInfo, **Any) -> str return json.dumps([source, args], separators=(",", ":")) TestInputObject = GraphQLInputObjectType( "TestInputObject", lambda: OrderedDict([ ( "inputOne", GraphQLInputObjectField(GraphQLString, out_name="input_one"), ), ( "inputRecursive", GraphQLInputObjectField(TestInputObject, out_name="input_recursive"), ), ]), ) schema = _test_schema( GraphQLField( GraphQLString, args=OrderedDict([("aInput", GraphQLArgument(TestInputObject, out_name="a_input"))]), resolver=resolver, )) result = graphql(schema, "{ test }", None) assert not result.errors assert result.data == {"test": "[null,{}]"} result = graphql(schema, '{ test(aInput: {inputOne: "String!"} ) }', "Source!") assert not result.errors assert result.data == { "test": '["Source!",{"a_input":{"input_one":"String!"}}]' } result = graphql( schema, '{ test(aInput: {inputRecursive:{inputOne: "SourceRecursive!"}} ) }', "Source!", ) assert not result.errors assert result.data == { "test": '["Source!",{"a_input":{"input_recursive":{"input_one":"SourceRecursive!"}}}]' }
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_does_not_include_arguments_that_were_not_set(): schema = GraphQLSchema(GraphQLObjectType( 'Type', { 'field': GraphQLField( GraphQLString, resolver=lambda data, args, *_: args and json.dumps(args, sort_keys=True, separators=(',', ':')), args={ 'a': GraphQLArgument(GraphQLBoolean), 'b': GraphQLArgument(GraphQLBoolean), 'c': GraphQLArgument(GraphQLBoolean), 'd': GraphQLArgument(GraphQLInt), 'e': GraphQLArgument(GraphQLInt), } ) } )) ast = parse('{ field(a: true, c: false, e: 0) }') result = execute(schema, ast) assert result.data == { 'field': '{"a":true,"c":false,"e":0}' }
def prints_string_field_with_int_arg(): schema = build_single_field_schema( GraphQLField( type_=GraphQLString, args={"argOne": GraphQLArgument(GraphQLInt)} ) ) assert expect_printed_schema(schema) == dedent( """ type Query { singleField(argOne: Int): String } """ )
def does_not_include_arguments_that_were_not_set(): schema = GraphQLSchema( GraphQLObjectType( 'Type', { 'field': GraphQLField(GraphQLString, args={ 'a': GraphQLArgument(GraphQLBoolean), 'b': GraphQLArgument(GraphQLBoolean), 'c': GraphQLArgument(GraphQLBoolean), 'd': GraphQLArgument(GraphQLInt), 'e': GraphQLArgument(GraphQLInt) }, resolve=lambda _source, _info, **args: args and dumps(args)) })) query = parse('{ field(a: true, c: false, e: 0) }') assert execute(schema, query) == ({ 'field': '{"a": true, "c": false, "e": 0}' }, None)
def test_builds_a_schema_with_field_arguments(): schema = GraphQLSchema( query=GraphQLObjectType( name='ArgFields', fields=OrderedDict([ ('one', GraphQLField(GraphQLString, description='A field with a single arg', args={ 'intArg': GraphQLArgument(GraphQLInt, description='This is an int arg') })), ('two', GraphQLField(GraphQLString, description='A field with two args', args=OrderedDict([ ('listArg', GraphQLArgument( GraphQLList(GraphQLInt), description='This is a list of int arg' )), ('requiredArg', GraphQLArgument( GraphQLNonNull(GraphQLBoolean), description='This is a required arg' )) ]))), ]) ) ) _test_schema(schema)
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 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.fields == TestObject2.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.fields == TestInputObject2.fields assert input_fields == { "field1": GraphQLInputObjectField(GraphQLString), "field2": GraphQLInputObjectField(GraphQLString), }
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.fields == TestObject2.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.fields == TestInputObject2.fields assert input_fields == { 'field1': GraphQLInputObjectField(GraphQLString), 'field2': GraphQLInputObjectField(GraphQLString), }
def prints_custom_directives(): simple_directive = GraphQLDirective( "simpleDirective", [DirectiveLocation.FIELD] ) complex_directive = GraphQLDirective( "complexDirective", [DirectiveLocation.FIELD, DirectiveLocation.QUERY], description="Complex Directive", args={ "stringArg": GraphQLArgument(GraphQLString), "intArg": GraphQLArgument(GraphQLInt, default_value=-1), }, is_repeatable=True, ) schema = GraphQLSchema(directives=[simple_directive, complex_directive]) assert expect_printed_schema(schema) == dedent( ''' directive @simpleDirective on FIELD """Complex Directive""" directive @complexDirective(stringArg: String, intArg: Int = -1) repeatable on FIELD | QUERY ''' # noqa: E501 )
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) })), ('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 can_create_instance(): arg = GraphQLArgument(GraphQLString, description='arg description') node = DirectiveDefinitionNode() locations = [DirectiveLocation.SCHEMA, DirectiveLocation.OBJECT] directive = GraphQLDirective( name='test', locations=[DirectiveLocation.SCHEMA, DirectiveLocation.OBJECT], args={'arg': arg}, description='test description', ast_node=node) assert directive.name == 'test' assert directive.locations == locations assert directive.args == {'arg': arg} assert directive.description == 'test description' assert directive.ast_node is node
def uses_provided_resolve_function(): schema = _test_schema( GraphQLField( GraphQLString, args={ "aStr": GraphQLArgument(GraphQLString), "aInt": GraphQLArgument(GraphQLInt), }, resolve=lambda source, info, **args: repr([source, args]), ) ) def execute_query(query: str, root_value: Any = None) -> ExecutionResult: document = parse(query) return execute_sync( schema=schema, document=document, root_value=root_value, ) assert execute_query("{ test }") == ({"test": "[None, {}]"}, None) assert execute_query("{ test }", "Source!") == ( {"test": "['Source!', {}]"}, None, ) assert execute_query('{ test(aStr: "String!") }', "Source!") == ( {"test": "['Source!', {'aStr': 'String!'}]"}, None, ) assert execute_query('{ test(aInt: -123, aStr: "String!") }', "Source!") == ( {"test": "['Source!', {'aStr': 'String!', 'aInt': -123}]"}, None, )
def email_schema_with_resolvers(subscribe_fn=None, resolve_fn=None): return GraphQLSchema( query=QueryType, subscription=GraphQLObjectType( "Subscription", { "importantEmail": GraphQLField( EmailEventType, args={"priority": GraphQLArgument(GraphQLInt)}, resolve=resolve_fn, subscribe=subscribe_fn, ) }, ), )
def builds_a_schema_with_field_arguments(): schema = GraphQLSchema( GraphQLObjectType( "ArgFields", { "one": GraphQLField( GraphQLString, description="A field with a single arg", args={ "intArg": GraphQLArgument(GraphQLInt, description="This is an int arg") }, ), "two": GraphQLField( GraphQLString, description="A field with two args", args={ "listArg": GraphQLArgument( GraphQLList(GraphQLInt), description="This is a list of int arg", ), "requiredArg": GraphQLArgument( GraphQLNonNull(GraphQLBoolean), description="This is a required arg", ), }, ), }, )) check_schema(schema)
def test_sorts_fields_and_argument_keys_if_not_using_ordered_dict(): fields = { 'b': GraphQLField(GraphQLString), 'c': GraphQLField(GraphQLString), 'a': GraphQLField(GraphQLString), 'd': GraphQLField(GraphQLString, args={ 'q': GraphQLArgument(GraphQLString), 'x': GraphQLArgument(GraphQLString), 'v': GraphQLArgument(GraphQLString), 'a': GraphQLArgument(GraphQLString), 'n': GraphQLArgument(GraphQLString) }) } test_object = GraphQLObjectType(name='Test', fields=fields) ordered_fields = test_object.get_fields() assert list(ordered_fields.keys()) == ['a', 'b', 'c', 'd'] field_with_args = test_object.get_fields().get('d') assert [a.name for a in field_with_args.args] == ['a', 'n', 'q', 'v', 'x']
def _schema_with_input_field_of_type(input_field_type: GraphQLInputType): BadInputObjectType = GraphQLInputObjectType( "BadInputObject", {"badField": GraphQLInputField(input_field_type)}) return GraphQLSchema( GraphQLObjectType( "Query", { "f": GraphQLField( GraphQLString, args={"badArg": GraphQLArgument(BadInputObjectType)}, ) }, ))
def describe_find_deprecated_usages(): enum_type = GraphQLEnumType( "EnumType", { "ONE": GraphQLEnumValue(), "TWO": GraphQLEnumValue(deprecation_reason="Some enum reason."), }, ) schema = GraphQLSchema( GraphQLObjectType( "Query", { "normalField": GraphQLField(GraphQLString, args={"enumArg": GraphQLArgument(enum_type)}), "deprecatedField": GraphQLField(GraphQLString, deprecation_reason="Some field reason."), }, )) def should_report_empty_set_for_no_deprecated_usages(): errors = find_deprecated_usages(schema, parse("{ normalField(enumArg: ONE) }")) assert errors == [] def should_report_usage_of_deprecated_fields(): errors = find_deprecated_usages( schema, parse("{ normalField, deprecatedField }")) error_messages = [err.message for err in errors] assert error_messages == [ "The field Query.deprecatedField is deprecated. Some field reason." ] def should_report_usage_of_deprecated_enums(): errors = find_deprecated_usages(schema, parse("{ normalField(enumArg: TWO) }")) error_messages = [err.message for err in errors] assert error_messages == [ "The enum value EnumType.TWO is deprecated. Some enum reason." ]
def can_create_instance(): arg = GraphQLArgument(GraphQLString, description="arg description") node = DirectiveDefinitionNode() locations = [DirectiveLocation.SCHEMA, DirectiveLocation.OBJECT] directive = GraphQLDirective( name="test", locations=[DirectiveLocation.SCHEMA, DirectiveLocation.OBJECT], args={"arg": arg}, description="test description", ast_node=node, ) assert directive.name == "test" assert directive.locations == locations assert directive.args == {"arg": arg} assert directive.description == "test description" assert directive.ast_node is node
def reject_field_args_with_invalid_names(): QueryType = GraphQLObjectType( "SomeObject", { "badField": GraphQLField( GraphQLString, args={"bad-name-with-dashes": GraphQLArgument(GraphQLString)}, ) }, ) schema = GraphQLSchema(QueryType) msg = validate_schema(schema)[0].message assert msg == ( "Names must match /^[_a-zA-Z][_a-zA-Z0-9]*$/" " but 'bad-name-with-dashes' does not." )
def prints_string_field_with_string_arg_with_default(): schema = build_single_field_schema( GraphQLField( type_=GraphQLString, args={ "argOne": GraphQLArgument(GraphQLString, default_value="tes\t de\fault") }, )) assert expect_printed_schema(schema) == dedent(r""" type Query { singleField(argOne: String = "tes\t de\fault"): String } """)