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_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=[],
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)),
loc=loc(16, 30))
],
loc=loc(1, 32))
],
loc=loc(1, 32))
assert doc == expected
def test_parses_double_value_enum():
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)
),
values=[
ast.EnumValueDefinition(
name=ast.Name(
value='WO',
loc=loc(13, 15)
),
loc=loc(13, 15)
),
ast.EnumValueDefinition(
name=ast.Name(
value='RLD',
loc=loc(17, 20)
),
loc=loc(17, 20)
)
],
loc=loc(0, 22)
)
],
loc=loc(0, 22)
)
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=[],
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)),
loc=loc(23, 36))
],
loc=loc(8, 38)),
loc=loc(1, 38))
],
loc=loc(1, 38))
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_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_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_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_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)),
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)),
loc=loc(21, 34))
],
loc=loc(1, 36))
],
loc=loc(1, 37))
assert doc == expected
def test_parse_creates_ast():
source = Source("""{
node(id: 4) {
id,
name
}
}
""")
result = parse(source)
assert result == \
ast.Document(
loc={'start': 0, 'end': 41, 'source': source},
definitions=
[ast.OperationDefinition(
loc={'start': 0, 'end': 40, 'source': source},
operation='query',
name=None,
variable_definitions=None,
directives=[],
selection_set=ast.SelectionSet(
loc={'start': 0, 'end': 40, 'source': source},
selections=
[ast.Field(
loc={'start': 4, 'end': 38, 'source': source},
alias=None,
name=ast.Name(
loc={'start': 4, 'end': 8, 'source': source},
value='node'),
arguments=[ast.Argument(
name=ast.Name(loc={'start': 9, 'end': 11, 'source': source},
value='id'),
value=ast.IntValue(
loc={'start': 13, 'end': 14, 'source': source},
value='4'),
loc={'start': 9, 'end': 14, 'source': source})],
directives=[],
selection_set=ast.SelectionSet(
loc={'start': 16, 'end': 38, 'source': source},
selections=
[ast.Field(
loc={'start': 22, 'end': 24, 'source': source},
alias=None,
name=ast.Name(
loc={'start': 22, 'end': 24, 'source': source},
value='id'),
arguments=[],
directives=[],
selection_set=None),
ast.Field(
loc={'start': 30, 'end': 34, 'source': source},
alias=None,
name=ast.Name(
loc={'start': 30, 'end': 34, 'source': source},
value='name'),
arguments=[],
directives=[],
selection_set=None)]))]))])
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_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_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 test_converts_simple_ast_to_dict():
node = ast.Name(value='test', loc=Loc(start=5, end=10))
assert ast_to_dict(node) == {'kind': 'Name', 'value': 'test'}
assert ast_to_dict(node, include_loc=True) == {
'kind': 'Name',
'value': 'test',
'loc': {
'start': 5,
'end': 10
}
}
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)),
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,
loc=loc(17, 30))
],
loc=loc(1, 32))
],
loc=loc(1, 32))
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=[],
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,
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,
loc=loc(39, 50))
],
type=ast.NamedType(name=ast.Name(value='String',
loc=loc(53, 59)),
loc=loc(53, 59)),
loc=loc(16, 59))
],
loc=loc(1, 61))
],
loc=loc(1, 61))
assert doc == expected
def test_prints_minimal_ast():
node = ast.ScalarTypeDefinition(name=ast.Name('foo'))
assert print_ast(node) == 'scalar foo'
