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_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 _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_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_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_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_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():
# 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_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 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_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_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_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 query(*fields, **kwargs):
if 'operation' not in kwargs:
kwargs['operation'] = 'query'
return ast.Document(definitions=[
ast.OperationDefinition(operation=kwargs['operation'],
selection_set=ast.SelectionSet(
selections=list(selections(*fields))))
])
def query(*fields):
return ast.Document(
definitions=[ast.OperationDefinition(
operation='query',
selection_set=ast.SelectionSet(
selections=list(selections(*fields))
)
)]
)
def query(*fields, **kwargs):
if "operation" not in kwargs:
kwargs["operation"] = "query"
return ast.Document(definitions=[
ast.OperationDefinition(
operation=kwargs["operation"],
selection_set=ast.SelectionSet(selections=list(selections(
*fields))),
)
])
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 test_parses_simple_field_with_two_args():
# type: () -> None
body = """
type Hello {
world(argOne: Boolean, argTwo: Int): 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="argOne", loc=loc(22, 28)),
type=ast.NamedType(
name=ast.Name(value="Boolean",
loc=loc(30, 37)),
loc=loc(30, 37),
),
default_value=None,
directives=[],
loc=loc(22, 37),
),
ast.InputValueDefinition(
name=ast.Name(value="argTwo", loc=loc(39, 45)),
type=ast.NamedType(
name=ast.Name(value="Int", loc=loc(47,
50)),
loc=loc(47, 50),
),
default_value=None,
directives=[],
loc=loc(39, 50),
),
],
type=ast.NamedType(
name=ast.Name(value="String", loc=loc(53, 59)),
loc=loc(53, 59),
),
directives=[],
loc=loc(16, 59),
)
],
loc=loc(1, 61),
)
],
loc=loc(1, 61),
)
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 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 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_scalar():
# type: () -> None
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)),
directives=[],
loc=loc(0, 12),
)
],
loc=loc(0, 12),
)
assert doc == expected
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 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 test_parses_simple_field_with_two_args():
body = '''
type Hello {
world(argOne: Boolean, argTwo: Int): 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='argOne', loc=loc(22, 28)),
type=ast.NamedType(name=ast.Name(value='Boolean',
loc=loc(30, 37)),
loc=loc(30, 37)),
default_value=None,
directives=[],
loc=loc(22, 37)),
ast.InputValueDefinition(
name=ast.Name(value='argTwo', loc=loc(39, 45)),
type=ast.NamedType(name=ast.Name(value='Int',
loc=loc(47, 50)),
loc=loc(47, 50)),
default_value=None,
directives=[],
loc=loc(39, 50))
],
type=ast.NamedType(name=ast.Name(value='String',
loc=loc(53, 59)),
loc=loc(53, 59)),
directives=[],
loc=loc(16, 59))
],
loc=loc(1, 61))
],
loc=loc(1, 61))
assert doc == expected
def test_parses_null_value_in_list():
result = parse('{ fieldWithObjectInput(input: {b: ["A", null, "C"], c: "C"}) }')
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'fieldWithObjectInput'),
directives=[],
selection_set=None,
arguments=[
ast.Argument(
name=ast.Name(value=u'input'),
value=ast.ObjectValue(
fields=[
ast.ObjectField(
name=ast.Name(value=u'b'),
value=ast.ListValue(
values=[
ast.StringValue(value=u'A'),
ast.NullValue(),
ast.StringValue(value=u'C'),
],
),
),
ast.ObjectField(
name=ast.Name(value=u'c'),
value=ast.StringValue(value=u'C'),
),
]
),
),
],
),
],
),
),
],
)
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')
