def test_parses_multi_byte_characters():
# type: () -> None
result = parse(
u"""
# This comment has a \u0A0A multi-byte character.
{ field(arg: "Has a \u0A0A multi-byte character.") }
""",
no_location=True,
no_source=True,
)
assert result == ast.Document(definitions=[
ast.OperationDefinition(
operation="query",
name=None,
variable_definitions=None,
directives=[],
selection_set=ast.SelectionSet(selections=[
ast.Field(
alias=None,
name=ast.Name(value=u"field"),
arguments=[
ast.Argument(
name=ast.Name(value=u"arg"),
value=ast.StringValue(
value=u"Has a \u0a0a multi-byte character."),
)
],
directives=[],
selection_set=None,
)
]),
)
])
def test_parses_simple_interface():
# type: () -> None
body = """
interface Hello {
world: String
}
"""
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.InterfaceTypeDefinition(
name=ast.Name(value="Hello", loc=loc(11, 16)),
directives=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value="world", loc=loc(21, 26)),
arguments=[],
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(28, 34)),
loc=loc(28, 34),
),
directives=[],
loc=loc(21, 34),
)
],
loc=loc(1, 36),
)
],
loc=loc(1, 37),
)
assert doc == expected
def test_parses_simple_type_inheriting_multiple_interfaces():
# type: () -> None
body = "type Hello implements Wo & rld { }"
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value="Hello", loc=loc(5, 10)),
interfaces=[
ast.NamedType(
name=ast.Name(value="Wo", loc=loc(22, 24)), loc=loc(22, 24)
),
ast.NamedType(
name=ast.Name(value="rld", loc=loc(26, 29)), loc=loc(26, 29)
),
],
directives=[],
fields=[],
loc=loc(0, 33),
)
],
loc=loc(0, 33),
)
assert doc == expected
def test_parses_double_value_enum():
# type: () -> None
body = "enum Hello { WO, RLD }"
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.EnumTypeDefinition(
name=ast.Name(value="Hello", loc=loc(5, 10)),
directives=[],
values=[
ast.EnumValueDefinition(
name=ast.Name(value="WO", loc=loc(13, 15)),
directives=[],
loc=loc(13, 15),
),
ast.EnumValueDefinition(
name=ast.Name(value="RLD", loc=loc(17, 20)),
directives=[],
loc=loc(17, 20),
),
],
loc=loc(0, 22),
)
],
loc=loc(0, 22),
)
assert doc == expected
def test_parses_simple_interface():
body = '''
interface Hello {
world: String
}
'''
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.InterfaceTypeDefinition(
name=ast.Name(value='Hello', loc=loc(11, 16)),
directives=[],
fields=[
ast.FieldDefinition(name=ast.Name(value='world',
loc=loc(21, 26)),
arguments=[],
type=ast.NamedType(name=ast.Name(
value='String', loc=loc(28, 34)),
loc=loc(28, 34)),
directives=[],
loc=loc(21, 34))
],
loc=loc(1, 36))
],
loc=loc(1, 37))
assert doc == expected
def test_parses_simple_type():
# type: () -> None
body = """
type Hello {
world: String
}"""
doc = parse(body)
loc = create_loc_fn(body)
expected = ast.Document(
definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value="Hello", loc=loc(6, 11)),
interfaces=[],
directives=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value="world", loc=loc(16, 21)),
arguments=[],
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(23, 29)),
loc=loc(23, 29),
),
directives=[],
loc=loc(16, 29),
)
],
loc=loc(1, 31),
)
],
loc=loc(1, 31),
)
assert doc == expected
def test_parses_simple_input_object():
body = '''
input Hello {
world: String
}'''
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.InputObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(7, 12)),
directives=[],
fields=[
ast.InputValueDefinition(name=ast.Name(value='world',
loc=loc(17, 22)),
type=ast.NamedType(name=ast.Name(
value='String', loc=loc(24, 30)),
loc=loc(24, 30)),
default_value=None,
directives=[],
loc=loc(17, 30))
],
loc=loc(1, 32))
],
loc=loc(1, 32))
assert doc == expected
def test_parses_simple_extension():
body = '''
extend type Hello {
world: String
}'''
doc = parse(body)
loc = create_loc_fn(body)
expected = ast.Document(definitions=[
ast.TypeExtensionDefinition(definition=ast.ObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(13, 18)),
interfaces=[],
directives=[],
fields=[
ast.FieldDefinition(name=ast.Name(value='world',
loc=loc(23, 28)),
arguments=[],
type=ast.NamedType(name=ast.Name(
value='String', loc=loc(30, 36)),
loc=loc(30, 36)),
directives=[],
loc=loc(23, 36))
],
loc=loc(8, 38)),
loc=loc(1, 38))
],
loc=loc(1, 38))
assert doc == expected
def test_parses_simple_field_with_arg_with_default_value():
body = '''
type Hello {
world(flag: Boolean = true): String
}'''
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(6, 11)),
interfaces=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value='world', loc=loc(16, 21)),
arguments=[
ast.InputValueDefinition(
name=ast.Name(value='flag', loc=loc(22, 26)),
type=ast.NamedType(name=ast.Name(value='Boolean',
loc=loc(28, 35)),
loc=loc(28, 35)),
default_value=ast.BooleanValue(value=True,
loc=loc(38, 42)),
loc=loc(22, 42))
],
type=ast.NamedType(name=ast.Name(value='String',
loc=loc(45, 51)),
loc=loc(45, 51)),
loc=loc(16, 51))
],
loc=loc(1, 53))
],
loc=loc(1, 53))
assert doc == expected
def test_parses_simple_field_with_list_arg():
body = '''
type Hello {
world(things: [String]): String
}'''
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(6, 11)),
interfaces=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value='world', loc=loc(16, 21)),
arguments=[
ast.InputValueDefinition(
name=ast.Name(value='things', loc=loc(22, 28)),
type=ast.ListType(type=ast.NamedType(
name=ast.Name(value='String', loc=loc(31, 37)),
loc=loc(31, 37)),
loc=loc(30, 38)),
default_value=None,
loc=loc(22, 38))
],
type=ast.NamedType(name=ast.Name(value='String',
loc=loc(41, 47)),
loc=loc(41, 47)),
loc=loc(16, 47))
],
loc=loc(1, 49))
],
loc=loc(1, 49))
assert doc == expected
def test_simple_non_null_type():
body = '''
type Hello {
world: String!
}'''
doc = parse(body)
loc = create_loc_fn(body)
expected = ast.Document(definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(6, 11)),
interfaces=[],
directives=[],
fields=[
ast.FieldDefinition(name=ast.Name(value='world',
loc=loc(16, 21)),
arguments=[],
type=ast.NonNullType(type=ast.NamedType(
name=ast.Name(value='String',
loc=loc(23, 29)),
loc=loc(23, 29)),
loc=loc(23, 30)),
directives=[],
loc=loc(16, 30))
],
loc=loc(1, 32))
],
loc=loc(1, 32))
assert doc == expected
def _get_basic_schema_ast(query_type):
"""Create a basic AST Document representing a nearly blank schema.
The output AST contains a single query type, whose name is the input string. The query type
is guaranteed to be the second entry of Document definitions, after the schema definition.
The query type has no fields.
Args:
query_type: str, name of the query type for the schema
Returns:
Document, representing a nearly blank schema
"""
blank_ast = ast_types.Document(definitions=[
ast_types.SchemaDefinition(
operation_types=[
ast_types.OperationTypeDefinition(
operation='query',
type=ast_types.NamedType(name=ast_types.Name(
value=query_type)),
)
],
directives=[],
),
ast_types.ObjectTypeDefinition(
name=ast_types.Name(value=query_type),
fields=[],
interfaces=[],
directives=[],
),
])
return blank_ast
def test_parses_simple_input_object():
# type: () -> None
body = """
input Hello {
world: String
}"""
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.InputObjectTypeDefinition(
name=ast.Name(value="Hello", loc=loc(7, 12)),
directives=[],
fields=[
ast.InputValueDefinition(
name=ast.Name(value="world", loc=loc(17, 22)),
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(24, 30)),
loc=loc(24, 30),
),
default_value=None,
directives=[],
loc=loc(17, 30),
)
],
loc=loc(1, 32),
)
],
loc=loc(1, 32),
)
assert doc == expected
def test_parse_creates_ast():
source = Source("""{
node(id: 4) {
id,
name
}
}
""")
result = parse(source)
assert result == \
ast.Document(
loc=Loc(start=0, end=41, source=source),
definitions=[ast.OperationDefinition(
loc=Loc(start=0, end=40, source=source),
operation='query',
name=None,
variable_definitions=None,
directives=[],
selection_set=ast.SelectionSet(
loc=Loc(start=0, end=40, source=source),
selections=[ast.Field(
loc=Loc(start=4, end=38, source=source),
alias=None,
name=ast.Name(
loc=Loc(start=4, end=8, source=source),
value='node'),
arguments=[ast.Argument(
name=ast.Name(loc=Loc(start=9, end=11, source=source),
value='id'),
value=ast.IntValue(
loc=Loc(start=13, end=14, source=source),
value='4'),
loc=Loc(start=9, end=14, source=source))],
directives=[],
selection_set=ast.SelectionSet(
loc=Loc(start=16, end=38, source=source),
selections=[ast.Field(
loc=Loc(start=22, end=24, source=source),
alias=None,
name=ast.Name(
loc=Loc(start=22, end=24, source=source),
value='id'),
arguments=[],
directives=[],
selection_set=None),
ast.Field(
loc=Loc(start=30, end=34, source=source),
alias=None,
name=ast.Name(
loc=Loc(start=30, end=34, source=source),
value='name'),
arguments=[],
directives=[],
selection_set=None)]))]))])
def _insert_selection_set_parent_nodes_from_deep_field_name(
self, selection, deep_field_name):
split_field_name = deep_field_name.split(LOOKUP_SEP, 1)
name = to_camel_case(split_field_name[0])
if len(split_field_name) == 1:
return ast.Field(
name=ast.Name(value=name),
selection_set=ast.SelectionSet(
selections=selection.selection_set.selections))
return ast.Field(
name=ast.Name(value=name),
selection_set=ast.SelectionSet(selections=[
self._insert_selection_set_parent_nodes_from_deep_field_name(
selection, split_field_name[1])
]))
def _build_stitch_directive(source_field_name, sink_field_name):
"""Build a Directive node for the stitch directive."""
return ast_types.Directive(
name=ast_types.Name(value='stitch'),
arguments=[
ast_types.Argument(
name=ast_types.Name(value='source_field'),
value=ast_types.StringValue(value=source_field_name),
),
ast_types.Argument(
name=ast_types.Name(value='sink_field'),
value=ast_types.StringValue(value=sink_field_name),
),
],
)
def test_parses_simple_union():
body = 'union Hello = World'
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.UnionTypeDefinition(name=ast.Name(value='Hello', loc=loc(6, 11)),
types=[
ast.NamedType(name=ast.Name(value='World',
loc=loc(
14, 19)),
loc=loc(14, 19))
],
loc=loc(0, 19))
],
loc=loc(0, 19))
assert doc == expected
def test_parses_single_value_enum():
body = 'enum Hello { WORLD }'
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.EnumTypeDefinition(name=ast.Name(value='Hello', loc=loc(5, 10)),
values=[
ast.EnumValueDefinition(name=ast.Name(
value='WORLD', loc=loc(13, 18)),
loc=loc(13, 18))
],
loc=loc(0, 20))
],
loc=loc(0, 20))
assert doc == expected
def _get_field_selection_set(
self,
field: GraphQLField,
include_node: bool = True) -> Optional[graphql_ast.SelectionSet]:
return_type = self.get_return_type(field.type)
if isinstance(return_type, (GraphQLScalarType, GraphQLEnumType)):
return None
elif isinstance(return_type,
(GraphQLObjectType, GrapheneInterfaceType)):
all_selections = []
sub_fields = return_type.fields.items()
if self.is_node_type(return_type):
if include_node is False:
sub_fields = [('id', return_type.fields['id'])]
else:
# disable full rendering of nested nodes to avoid recursion
include_node = False
for name, sub_field in sub_fields:
selection = graphql_ast.Field(
name=graphql_ast.Name(value=name),
selection_set=self._get_field_selection_set(
sub_field, include_node=include_node))
all_selections.append(selection)
return graphql_ast.SelectionSet(selections=all_selections)
raise NotImplementedError
def test_parses_multi_byte_characters():
result = parse(u'''
# This comment has a \u0A0A multi-byte character.
{ field(arg: "Has a \u0A0A multi-byte character.") }
''',
no_location=True,
no_source=True)
assert result == ast.Document(definitions=[
ast.OperationDefinition(
operation='query',
name=None,
variable_definitions=None,
directives=[],
selection_set=ast.SelectionSet(selections=[
ast.Field(
alias=None,
name=ast.Name(value=u'field'),
arguments=[
ast.Argument(
name=ast.
Name(value=u'arg'),
value=ast
.StringValue(
value=u'Has a \u0a0a multi-byte character.'))
],
directives=[],
selection_set=None)
]))
])
def test_parses_simple_field_with_arg_with_default_value():
# type: () -> None
body = """
type Hello {
world(flag: Boolean = true): String
}"""
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value="Hello", loc=loc(6, 11)),
interfaces=[],
directives=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value="world", loc=loc(16, 21)),
arguments=[
ast.InputValueDefinition(
name=ast.Name(value="flag", loc=loc(22, 26)),
type=ast.NamedType(
name=ast.Name(value="Boolean",
loc=loc(28, 35)),
loc=loc(28, 35),
),
default_value=ast.BooleanValue(value=True,
loc=loc(38,
42)),
directives=[],
loc=loc(22, 42),
)
],
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(45, 51)),
loc=loc(45, 51),
),
directives=[],
loc=loc(16, 51),
)
],
loc=loc(1, 53),
)
],
loc=loc(1, 53),
)
assert doc == expected
def _add_edge_field(source_type_node, sink_type_name, source_field_name,
sink_field_name, edge_name, direction):
"""Add one direction of the specified edge as a field of the source type.
Args:
source_type_node: (Interface/Object)TypeDefinition, where a new field representing
one direction of the edge will be added. It is modified by this
function
sink_type_name: str, name of the type that the edge leads to
source_field_name: str, name of the source side field that will be stitched
sink_field_name: str, name of the sink side field that will be stitched
edge_name: str, name of the edge that will be used to name the new field
direction: str, either OUTBOUND_EDGE_DIRECTION or INBOUND_EDGE_DIRECTION ('out'
or 'in')
Raises:
- SchemaNameConflictError if the new cross-schema edge name causes a name conflict with
existing fields, or fields created by previous cross-schema edges
"""
type_fields = source_type_node.fields
if direction not in (OUTBOUND_EDGE_DIRECTION, INBOUND_EDGE_DIRECTION):
raise AssertionError(
u'Input "direction" must be either "{}" or "{}".'.format(
OUTBOUND_EDGE_DIRECTION, INBOUND_EDGE_DIRECTION))
new_edge_field_name = direction + '_' + edge_name
# Error if new edge causes a field name clash
if any(field.name.value == new_edge_field_name for field in type_fields):
raise SchemaNameConflictError(
u'New field "{}" under type "{}" created by the {}bound field of edge named '
u'"{}" clashes with an existing field of the same name. Consider changing the '
u'name of your edge to avoid name conflicts.'.format(
new_edge_field_name, source_type_node.name.value, direction,
edge_name))
new_edge_field_node = ast_types.FieldDefinition(
name=ast_types.Name(value=new_edge_field_name),
arguments=[],
type=ast_types.ListType(type=ast_types.NamedType(
name=ast_types.Name(value=sink_type_name), ), ),
directives=[
_build_stitch_directive(source_field_name, sink_field_name),
],
)
type_fields.append(new_edge_field_node)
def test_parses_simple_field_with_list_arg():
# type: () -> None
body = """
type Hello {
world(things: [String]): String
}"""
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(
definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value="Hello", loc=loc(6, 11)),
interfaces=[],
directives=[],
fields=[
ast.FieldDefinition(
name=ast.Name(value="world", loc=loc(16, 21)),
arguments=[
ast.InputValueDefinition(
name=ast.Name(value="things", loc=loc(22, 28)),
type=ast.ListType(
type=ast.NamedType(
name=ast.Name(value="String",
loc=loc(31, 37)),
loc=loc(31, 37),
),
loc=loc(30, 38),
),
default_value=None,
directives=[],
loc=loc(22, 38),
)
],
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(41, 47)),
loc=loc(41, 47),
),
directives=[],
loc=loc(16, 47),
)
],
loc=loc(1, 49),
)
],
loc=loc(1, 49),
)
assert doc == expected
def test_parses_union_with_two_types():
body = 'union Hello = Wo | Rld'
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.UnionTypeDefinition(
name=ast.Name(value='Hello', loc=loc(6, 11)),
types=[
ast.NamedType(name=ast.Name(value='Wo', loc=loc(14, 16)),
loc=loc(14, 16)),
ast.NamedType(name=ast.Name(value='Rld', loc=loc(19, 22)),
loc=loc(19, 22))
],
loc=loc(0, 22))
],
loc=loc(0, 22))
assert doc == expected
def test_parses_simple_type_inheriting_multiple_interfaces():
body = 'type Hello implements Wo, rld { }'
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.ObjectTypeDefinition(
name=ast.Name(value='Hello', loc=loc(5, 10)),
interfaces=[
ast.NamedType(name=ast.Name(value='Wo', loc=loc(22, 24)),
loc=loc(22, 24)),
ast.NamedType(name=ast.Name(value='rld', loc=loc(26, 29)),
loc=loc(26, 29))
],
fields=[],
loc=loc(0, 33))
],
loc=loc(0, 33))
assert doc == expected
def args(self, **args):
for name, value in args.items():
arg = self.field.args.get(name)
arg_type_serializer = get_arg_serializer(arg.type)
value = arg_type_serializer(value)
self.ast_field.arguments.append(
ast.Argument(name=ast.Name(value=name),
value=get_ast_value(value)))
return self
def test_converts_input_objects():
value = OrderedDict([('foo', 3), ('bar', 'HELLO')])
assert ast_from_value(value) == ast.ObjectValue(fields=[
ast.ObjectField(name=ast.Name('foo'), value=ast.IntValue('3')),
ast.ObjectField(name=ast.Name('bar'), value=ast.StringValue('HELLO'))
])
input_obj = GraphQLInputObjectType(
'MyInputObj', {
'foo': GraphQLInputObjectField(GraphQLFloat),
'bar': GraphQLInputObjectField(my_enum)
})
assert ast_from_value(value, input_obj) == ast.ObjectValue(fields=[
ast.ObjectField(name=ast.Name('foo'), value=ast.FloatValue('3.0')),
ast.ObjectField(name=ast.Name('bar'), value=ast.EnumValue('HELLO'))
])
def test_parses_scalar():
body = 'scalar Hello'
loc = create_loc_fn(body)
doc = parse(body)
expected = ast.Document(definitions=[
ast.ScalarTypeDefinition(name=ast.Name(value='Hello', loc=loc(7, 12)),
loc=loc(0, 12))
],
loc=loc(0, 12))
assert doc == expected
def get_variable_type(self, return_type: GraphQLType):
if isinstance(return_type, GraphQLNonNull):
return graphql_ast.NonNullType(
type=self.get_variable_type(return_type.of_type))
elif isinstance(return_type, GraphQLList):
return graphql_ast.ListType(
type=self.get_variable_type(return_type.of_type))
else:
return graphql_ast.NamedType(name=graphql_ast.Name(
value=return_type.name))
def view_func():
variable_values = self.get_variable_values()
field_selection_set = self._get_field_selection_set(
field, include_node=True)
if hasattr(field.type, 'graphene_type') and issubclass(
field.type.graphene_type, Node):
_type_name, _id = Node.from_global_id(variable_values['id'])
node_type = schema.get_type(_type_name)
inline_selection = graphql_ast.InlineFragment(
type_condition=graphql_ast.NamedType(name=graphql_ast.Name(
value=_type_name)),
selection_set=self._get_field_selection_set(
GraphQLField(node_type), include_node=True))
field_selection_set.selections.append(inline_selection)
document_ast = graphql_ast.Document([
graphql_ast.OperationDefinition(
operation=operation,
variable_definitions=variable_definitions,
selection_set=graphql_ast.SelectionSet(selections=[
graphql_ast.Field(name=graphql_ast.Name(
value=field_name),
arguments=arguments,
selection_set=field_selection_set)
]))
])
execution_results = schema.execute(document_ast,
variable_values=variable_values)
# TODO custom encoder that positions data[field_name] at data
result, status_code = encode_execution_results(
[execution_results],
is_batch=False,
format_error=default_format_error,
encode=json_encode)
return Response(result,
status=status_code,
content_type='application/json')