871 lines
28 KiB
Python
871 lines
28 KiB
Python
import unittest
|
|
import textwrap
|
|
|
|
from pygments.lexers import GraphQLLexer
|
|
from pygments.token import (
|
|
Error,
|
|
Keyword,
|
|
Name,
|
|
Number,
|
|
Punctuation,
|
|
String,
|
|
Whitespace
|
|
)
|
|
|
|
|
|
def assert_tokens_equal(self, text, expected, stack=("root",)):
|
|
text = textwrap.dedent(text)
|
|
lexer = GraphQLLexer()
|
|
tokens_itr = lexer.get_tokens_unprocessed(text, stack=stack)
|
|
self.assertEqual(list(tokens_itr), expected)
|
|
|
|
|
|
def assert_value_equal(self, text, expected):
|
|
if not isinstance(expected, list):
|
|
expected = [expected]
|
|
assert_tokens_equal(self, text, expected, stack=("value",))
|
|
|
|
|
|
def assert_string_equal(self, text, tokens):
|
|
start = (0, String, '"')
|
|
end = (len(text) - 1, String, '"')
|
|
expected = [start, *tokens, end]
|
|
assert_tokens_equal(self, text, expected, stack=("value",))
|
|
|
|
|
|
class TestValue(unittest.TestCase):
|
|
|
|
maxDiff = None
|
|
|
|
def test_float(self):
|
|
assert_value_equal(self, "5.5", (0, Number.Float, "5.5"))
|
|
assert_value_equal(self, "5e3", (0, Number.Float, "5e3"))
|
|
assert_value_equal(self, "5E3", (0, Number.Float, "5E3"))
|
|
assert_value_equal(self, "5e-3", (0, Number.Float, "5e-3"))
|
|
assert_value_equal(self, "5E-3", (0, Number.Float, "5E-3"))
|
|
assert_value_equal(self, "5e+3", (0, Number.Float, "5e+3"))
|
|
assert_value_equal(self, "5E+3", (0, Number.Float, "5E+3"))
|
|
assert_value_equal(self, "5.1e3", (0, Number.Float, "5.1e3"))
|
|
assert_value_equal(self, "5.1E3", (0, Number.Float, "5.1E3"))
|
|
assert_value_equal(self, "5.1e-3", (0, Number.Float, "5.1e-3"))
|
|
assert_value_equal(self, "5.1E-3", (0, Number.Float, "5.1E-3"))
|
|
assert_value_equal(self, "5.1e+3", (0, Number.Float, "5.1e+3"))
|
|
assert_value_equal(self, "5.1E+3", (0, Number.Float, "5.1E+3"))
|
|
|
|
def test_integer(self):
|
|
assert_value_equal(self, "5", (0, Number.Integer, "5"))
|
|
assert_value_equal(self, "-0", (0, Number.Integer, "-0"))
|
|
# Not really following the specifications
|
|
assert_value_equal(self, "-02", (0, Number.Integer, "-02"))
|
|
|
|
def test_string(self):
|
|
assert_string_equal(self, '"asdf"', [(1, String, "asdf")])
|
|
assert_string_equal(
|
|
self,
|
|
r'"asdf\""',
|
|
[
|
|
(1, String, "asdf"),
|
|
(5, String.Escape, r"\""),
|
|
],
|
|
)
|
|
assert_string_equal(
|
|
self, r'"asdf\m"', [(1, String, "asdf"), (5, Error, "\\"), (6, String, "m")]
|
|
)
|
|
assert_string_equal(
|
|
self,
|
|
r'"asdf\u00E8"',
|
|
[
|
|
(1, String, "asdf"),
|
|
(5, String.Escape, r"\u00E8"),
|
|
],
|
|
)
|
|
|
|
def test_boolean(self):
|
|
assert_value_equal(self, "true", (0, Name.Builtin, "true"))
|
|
assert_value_equal(self, "false", (0, Name.Builtin, "false"))
|
|
|
|
def test_variable(self):
|
|
assert_value_equal(self, "$hello", (0, Name.Variable, "$hello"))
|
|
assert_value_equal(
|
|
self,
|
|
"$0hello",
|
|
[
|
|
(0, Error, "$"),
|
|
(1, Number.Integer, "0"),
|
|
(2, Name.Constant, "hello"),
|
|
],
|
|
)
|
|
|
|
def test_list_value(self):
|
|
assert_value_equal(
|
|
self,
|
|
'[1, 1.1, "abc"]',
|
|
[
|
|
(0, Punctuation, "["),
|
|
(1, Number.Integer, "1"),
|
|
(2, Punctuation, ","),
|
|
(3, Whitespace, " "),
|
|
(4, Number.Float, "1.1"),
|
|
(7, Punctuation, ","),
|
|
(8, Whitespace, " "),
|
|
(9, String, '"'),
|
|
(10, String, "abc"),
|
|
(13, String, '"'),
|
|
(14, Punctuation, "]"),
|
|
],
|
|
)
|
|
assert_value_equal(
|
|
self,
|
|
'[1, 1.1, ["abc"]]',
|
|
[
|
|
(0, Punctuation, "["),
|
|
(1, Number.Integer, "1"),
|
|
(2, Punctuation, ","),
|
|
(3, Whitespace, " "),
|
|
(4, Number.Float, "1.1"),
|
|
(7, Punctuation, ","),
|
|
(8, Whitespace, " "),
|
|
(9, Punctuation, "["),
|
|
(10, String, '"'),
|
|
(11, String, "abc"),
|
|
(14, String, '"'),
|
|
(15, Punctuation, "]"),
|
|
(16, Punctuation, "]"),
|
|
],
|
|
)
|
|
|
|
|
|
class TestGraphqlLexer(unittest.TestCase):
|
|
|
|
maxDiff = None
|
|
|
|
def assert_builtin(self, text):
|
|
assert_tokens_equal(self, text, [(0, Name.Builtin, text)], stack=("builtins",))
|
|
|
|
def test_keyworkd(self):
|
|
assert_tokens_equal(self, "type", [(0, Keyword, "type")])
|
|
assert_tokens_equal(self, "schema", [(0, Keyword, "schema")])
|
|
assert_tokens_equal(self, "extend", [(0, Keyword, "extend")])
|
|
assert_tokens_equal(self, "enum", [(0, Keyword, "enum")])
|
|
assert_tokens_equal(self, "scalar", [(0, Keyword, "scalar")])
|
|
assert_tokens_equal(self, "implements", [(0, Keyword, "implements")])
|
|
assert_tokens_equal(self, "interface", [(0, Keyword, "interface")])
|
|
assert_tokens_equal(self, "union", [(0, Keyword, "union")])
|
|
assert_tokens_equal(self, "input", [(0, Keyword, "input")])
|
|
assert_tokens_equal(self, "directive", [(0, Keyword, "directive")])
|
|
|
|
def test_arguments_integer(self):
|
|
text = """\
|
|
{
|
|
field(arg: 24)
|
|
field
|
|
}
|
|
"""
|
|
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "field"),
|
|
(9, Punctuation, "("),
|
|
(10, Name, "arg"),
|
|
# (10, Name.Attribute, 'arg'),
|
|
(13, Punctuation, ":"),
|
|
(14, Whitespace, " "),
|
|
(15, Number.Integer, "24"),
|
|
(17, Punctuation, ")"),
|
|
(18, Whitespace, "\n "),
|
|
(21, Name, "field"),
|
|
(26, Whitespace, "\n"),
|
|
(27, Punctuation, "}"),
|
|
(28, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_arguments(self):
|
|
text = """\
|
|
{
|
|
human(id: "1000") {
|
|
name
|
|
height
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "human"),
|
|
(9, Punctuation, "("),
|
|
# (10, Name.Attribute, 'id'),
|
|
(10, Name, "id"),
|
|
(12, Punctuation, ":"),
|
|
(13, Whitespace, " "),
|
|
(14, String, '"'),
|
|
(15, String, "1000"),
|
|
(19, String, '"'),
|
|
(20, Punctuation, ")"),
|
|
(21, Whitespace, " "),
|
|
(22, Punctuation, "{"),
|
|
(23, Whitespace, "\n "),
|
|
(28, Name, "name"),
|
|
(32, Whitespace, "\n "),
|
|
(37, Name, "height"),
|
|
(43, Whitespace, "\n "),
|
|
(46, Punctuation, "}"),
|
|
(47, Whitespace, "\n"),
|
|
(48, Punctuation, "}"),
|
|
(49, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_argument_scalar(self):
|
|
text = """\
|
|
{
|
|
human(id: "1000") {
|
|
name
|
|
height(unit: FOOT)
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "human"),
|
|
(9, Punctuation, "("),
|
|
# (10, Name.Attribute, 'id'),
|
|
(10, Name, "id"),
|
|
(12, Punctuation, ":"),
|
|
(13, Whitespace, " "),
|
|
(14, String, '"'),
|
|
(15, String, "1000"),
|
|
(19, String, '"'),
|
|
(20, Punctuation, ")"),
|
|
(21, Whitespace, " "),
|
|
(22, Punctuation, "{"),
|
|
(23, Whitespace, "\n "),
|
|
(28, Name, "name"),
|
|
(32, Whitespace, "\n "),
|
|
(37, Name, "height"),
|
|
(43, Punctuation, "("),
|
|
# (44, Name.Attribute, 'unit'),
|
|
(44, Name, "unit"),
|
|
(48, Punctuation, ":"),
|
|
(49, Whitespace, " "),
|
|
(50, Name.Constant, "FOOT"),
|
|
(54, Punctuation, ")"),
|
|
(55, Whitespace, "\n "),
|
|
(58, Punctuation, "}"),
|
|
(59, Whitespace, "\n"),
|
|
(60, Punctuation, "}"),
|
|
(61, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_alias(self):
|
|
text = """\
|
|
{
|
|
empireHero: hero(episode: EMPIRE) {
|
|
name
|
|
}
|
|
jediHero: hero(episode: JEDI) {
|
|
name
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name.Label, "empireHero"),
|
|
(14, Punctuation, ":"),
|
|
(15, Whitespace, " "),
|
|
(16, Name, "hero"),
|
|
(20, Punctuation, "("),
|
|
# (21, Name.Attribute, 'episode'),
|
|
(21, Name, "episode"),
|
|
(28, Punctuation, ":"),
|
|
(29, Whitespace, " "),
|
|
(30, Name.Constant, "EMPIRE"),
|
|
(36, Punctuation, ")"),
|
|
(37, Whitespace, " "),
|
|
(38, Punctuation, "{"),
|
|
(39, Whitespace, "\n "),
|
|
(44, Name, "name"),
|
|
(48, Whitespace, "\n "),
|
|
(51, Punctuation, "}"),
|
|
(52, Whitespace, "\n "),
|
|
(55, Name.Label, "jediHero"),
|
|
(63, Punctuation, ":"),
|
|
(64, Whitespace, " "),
|
|
(65, Name, "hero"),
|
|
(69, Punctuation, "("),
|
|
# (70, Name.Attribute, 'episode'),
|
|
(70, Name, "episode"),
|
|
(77, Punctuation, ":"),
|
|
(78, Whitespace, " "),
|
|
(79, Name.Constant, "JEDI"),
|
|
(83, Punctuation, ")"),
|
|
(84, Whitespace, " "),
|
|
(85, Punctuation, "{"),
|
|
(86, Whitespace, "\n "),
|
|
(91, Name, "name"),
|
|
(95, Whitespace, "\n "),
|
|
(98, Punctuation, "}"),
|
|
(99, Whitespace, "\n"),
|
|
(100, Punctuation, "}"),
|
|
(101, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_variables(self):
|
|
text = """\
|
|
mutation testVar($int: Int, $myType: MyType,
|
|
$required: String!, $list: [Int!]!)
|
|
{
|
|
doSomenthing(int: $int, myType: $myType,
|
|
required: $required, list: $list)
|
|
{
|
|
response
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Keyword, "mutation"),
|
|
(8, Whitespace, " "),
|
|
(9, Name.Function, "testVar"),
|
|
(16, Punctuation, "("),
|
|
(17, Name.Variable, "$int"),
|
|
(21, Punctuation, ":"),
|
|
(22, Whitespace, " "),
|
|
(23, Name.Builtin, "Int"),
|
|
(26, Punctuation, ","),
|
|
(27, Whitespace, " "),
|
|
(28, Name.Variable, "$myType"),
|
|
(35, Punctuation, ":"),
|
|
(36, Whitespace, " "),
|
|
(37, Name.Class, "MyType"),
|
|
(43, Punctuation, ","),
|
|
(44, Whitespace, "\n "),
|
|
(49, Name.Variable, "$required"),
|
|
(58, Punctuation, ":"),
|
|
(59, Whitespace, " "),
|
|
(60, Name.Builtin, "String"),
|
|
(66, Punctuation, "!"),
|
|
(67, Punctuation, ","),
|
|
(68, Whitespace, " "),
|
|
(69, Name.Variable, "$list"),
|
|
(74, Punctuation, ":"),
|
|
(75, Whitespace, " "),
|
|
(76, Punctuation, "["),
|
|
(77, Name.Builtin, "Int"),
|
|
(80, Punctuation, "!"),
|
|
(81, Punctuation, "]"),
|
|
(82, Punctuation, "!"),
|
|
(83, Punctuation, ")"),
|
|
(84, Whitespace, "\n"),
|
|
(85, Punctuation, "{"),
|
|
(86, Whitespace, "\n "),
|
|
(89, Name, "doSomenthing"),
|
|
(101, Punctuation, "("),
|
|
(102, Name, "int"),
|
|
(105, Punctuation, ":"),
|
|
(106, Whitespace, " "),
|
|
(107, Name.Variable, "$int"),
|
|
(111, Punctuation, ","),
|
|
(112, Whitespace, " "),
|
|
(113, Name, "myType"),
|
|
(119, Punctuation, ":"),
|
|
(120, Whitespace, " "),
|
|
(121, Name.Variable, "$myType"),
|
|
(128, Punctuation, ","),
|
|
(129, Whitespace, "\n "),
|
|
(136, Name, "required"),
|
|
(144, Punctuation, ":"),
|
|
(145, Whitespace, " "),
|
|
(146, Name.Variable, "$required"),
|
|
(155, Punctuation, ","),
|
|
(156, Whitespace, " "),
|
|
(157, Name, "list"),
|
|
(161, Punctuation, ":"),
|
|
(162, Whitespace, " "),
|
|
(163, Name.Variable, "$list"),
|
|
(168, Punctuation, ")"),
|
|
(169, Whitespace, "\n "),
|
|
(172, Punctuation, "{"),
|
|
(173, Whitespace, "\n "),
|
|
(178, Name, "response"),
|
|
(186, Whitespace, "\n "),
|
|
(189, Punctuation, "}"),
|
|
(190, Whitespace, "\n"),
|
|
(191, Punctuation, "}"),
|
|
(192, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_operation_definition_directives(self):
|
|
text = """\
|
|
query ($foo: Boolean = true, $bar: Boolean = false) {
|
|
field @skip(if: $foo) {
|
|
subfieldA
|
|
}
|
|
field @skip(if: $bar) {
|
|
subfieldB
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Keyword, "query"),
|
|
(5, Whitespace, " "),
|
|
(6, Punctuation, "("),
|
|
(7, Name.Variable, "$foo"),
|
|
(11, Punctuation, ":"),
|
|
(12, Whitespace, " "),
|
|
(13, Name.Builtin, "Boolean"),
|
|
(20, Whitespace, " "),
|
|
(21, Punctuation, "="),
|
|
(22, Whitespace, " "),
|
|
(23, Name.Builtin, "true"),
|
|
(27, Punctuation, ","),
|
|
(28, Whitespace, " "),
|
|
(29, Name.Variable, "$bar"),
|
|
(33, Punctuation, ":"),
|
|
(34, Whitespace, " "),
|
|
(35, Name.Builtin, "Boolean"),
|
|
(42, Whitespace, " "),
|
|
(43, Punctuation, "="),
|
|
(44, Whitespace, " "),
|
|
(45, Name.Builtin, "false"),
|
|
(50, Punctuation, ")"),
|
|
(51, Whitespace, " "),
|
|
(52, Punctuation, "{"),
|
|
(53, Whitespace, "\n "),
|
|
(56, Name, "field"),
|
|
(61, Whitespace, " "),
|
|
(62, Name.Decorator, "@skip"),
|
|
(67, Punctuation, "("),
|
|
(68, Name, "if"),
|
|
(70, Punctuation, ":"),
|
|
(71, Whitespace, " "),
|
|
(72, Name.Variable, "$foo"),
|
|
(76, Punctuation, ")"),
|
|
(77, Whitespace, " "),
|
|
(78, Punctuation, "{"),
|
|
(79, Whitespace, "\n "),
|
|
(84, Name, "subfieldA"),
|
|
(93, Whitespace, "\n "),
|
|
(96, Punctuation, "}"),
|
|
(97, Whitespace, "\n "),
|
|
(100, Name, "field"),
|
|
(105, Whitespace, " "),
|
|
(106, Name.Decorator, "@skip"),
|
|
(111, Punctuation, "("),
|
|
(112, Name, "if"),
|
|
(114, Punctuation, ":"),
|
|
(115, Whitespace, " "),
|
|
(116, Name.Variable, "$bar"),
|
|
(120, Punctuation, ")"),
|
|
(121, Whitespace, " "),
|
|
(122, Punctuation, "{"),
|
|
(123, Whitespace, "\n "),
|
|
(128, Name, "subfieldB"),
|
|
(137, Whitespace, "\n "),
|
|
(140, Punctuation, "}"),
|
|
(141, Whitespace, "\n"),
|
|
(142, Punctuation, "}"),
|
|
(143, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_operation_definition_multi_directives(self):
|
|
text = """\
|
|
query ($foo: Boolean = true, $bar: Boolean = false) {
|
|
field @skip(if: $foo) @skip(if: $bar)
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Keyword, "query"),
|
|
(5, Whitespace, " "),
|
|
(6, Punctuation, "("),
|
|
(7, Name.Variable, "$foo"),
|
|
(11, Punctuation, ":"),
|
|
(12, Whitespace, " "),
|
|
(13, Name.Builtin, "Boolean"),
|
|
(20, Whitespace, " "),
|
|
(21, Punctuation, "="),
|
|
(22, Whitespace, " "),
|
|
(23, Name.Builtin, "true"),
|
|
(27, Punctuation, ","),
|
|
(28, Whitespace, " "),
|
|
(29, Name.Variable, "$bar"),
|
|
(33, Punctuation, ":"),
|
|
(34, Whitespace, " "),
|
|
(35, Name.Builtin, "Boolean"),
|
|
(42, Whitespace, " "),
|
|
(43, Punctuation, "="),
|
|
(44, Whitespace, " "),
|
|
(45, Name.Builtin, "false"),
|
|
(50, Punctuation, ")"),
|
|
(51, Whitespace, " "),
|
|
(52, Punctuation, "{"),
|
|
(53, Whitespace, "\n "),
|
|
(56, Name, "field"),
|
|
(61, Whitespace, " "),
|
|
(62, Name.Decorator, "@skip"),
|
|
(67, Punctuation, "("),
|
|
(68, Name, "if"),
|
|
(70, Punctuation, ":"),
|
|
(71, Whitespace, " "),
|
|
(72, Name.Variable, "$foo"),
|
|
(76, Punctuation, ")"),
|
|
(77, Whitespace, " "),
|
|
(78, Name.Decorator, "@skip"),
|
|
(83, Punctuation, "("),
|
|
(84, Name, "if"),
|
|
(86, Punctuation, ":"),
|
|
(87, Whitespace, " "),
|
|
(88, Name.Variable, "$bar"),
|
|
(92, Punctuation, ")"),
|
|
(93, Whitespace, "\n"),
|
|
(94, Punctuation, "}"),
|
|
(95, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_fragment_spread(self):
|
|
text = """\
|
|
query withNestedFragments {
|
|
user(id: 4) {
|
|
friends(first: 10) {
|
|
...friendFields
|
|
}
|
|
mutualFriends(first: 10) {
|
|
...friendFields @skip(if: true)
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Keyword, "query"),
|
|
(5, Whitespace, " "),
|
|
(6, Name.Function, "withNestedFragments"),
|
|
(25, Whitespace, " "),
|
|
(26, Punctuation, "{"),
|
|
(27, Whitespace, "\n "),
|
|
(30, Name, "user"),
|
|
(34, Punctuation, "("),
|
|
(35, Name, "id"),
|
|
(37, Punctuation, ":"),
|
|
(38, Whitespace, " "),
|
|
(39, Number.Integer, "4"),
|
|
(40, Punctuation, ")"),
|
|
(41, Whitespace, " "),
|
|
(42, Punctuation, "{"),
|
|
(43, Whitespace, "\n "),
|
|
(48, Name, "friends"),
|
|
(55, Punctuation, "("),
|
|
(56, Name, "first"),
|
|
(61, Punctuation, ":"),
|
|
(62, Whitespace, " "),
|
|
(63, Number.Integer, "10"),
|
|
(65, Punctuation, ")"),
|
|
(66, Whitespace, " "),
|
|
(67, Punctuation, "{"),
|
|
(68, Whitespace, "\n "),
|
|
(75, Punctuation, "..."),
|
|
(78, Name, "friendFields"),
|
|
(90, Whitespace, "\n "),
|
|
(95, Punctuation, "}"),
|
|
(96, Whitespace, "\n "),
|
|
(101, Name, "mutualFriends"),
|
|
(114, Punctuation, "("),
|
|
(115, Name, "first"),
|
|
(120, Punctuation, ":"),
|
|
(121, Whitespace, " "),
|
|
(122, Number.Integer, "10"),
|
|
(124, Punctuation, ")"),
|
|
(125, Whitespace, " "),
|
|
(126, Punctuation, "{"),
|
|
(127, Whitespace, "\n "),
|
|
(134, Punctuation, "..."),
|
|
(137, Name, "friendFields"),
|
|
(149, Whitespace, " "),
|
|
(150, Name.Decorator, "@skip"),
|
|
(155, Punctuation, "("),
|
|
(156, Name, "if"),
|
|
(158, Punctuation, ":"),
|
|
(159, Whitespace, " "),
|
|
(160, Name.Builtin, "true"),
|
|
(164, Punctuation, ")"),
|
|
(165, Whitespace, "\n "),
|
|
(170, Punctuation, "}"),
|
|
(171, Whitespace, "\n "),
|
|
(174, Punctuation, "}"),
|
|
(175, Whitespace, "\n"),
|
|
(176, Punctuation, "}"),
|
|
(177, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_inline_fragment(self):
|
|
text = """\
|
|
query inlineFragmentTyping {
|
|
profiles(handles: ["zuck", "cocacola"]) {
|
|
handle
|
|
... on User {
|
|
friends {
|
|
count
|
|
}
|
|
}
|
|
... on Page {
|
|
likers {
|
|
count
|
|
}
|
|
}
|
|
}
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Keyword, "query"),
|
|
(5, Whitespace, " "),
|
|
(6, Name.Function, "inlineFragmentTyping"),
|
|
(26, Whitespace, " "),
|
|
(27, Punctuation, "{"),
|
|
(28, Whitespace, "\n "),
|
|
(31, Name, "profiles"),
|
|
(39, Punctuation, "("),
|
|
(40, Name, "handles"),
|
|
(47, Punctuation, ":"),
|
|
(48, Whitespace, " "),
|
|
(49, Punctuation, "["),
|
|
(50, String, '"'),
|
|
(51, String, "zuck"),
|
|
(55, String, '"'),
|
|
(56, Punctuation, ","),
|
|
(57, Whitespace, " "),
|
|
(58, String, '"'),
|
|
(59, String, "cocacola"),
|
|
(67, String, '"'),
|
|
(68, Punctuation, "]"),
|
|
(69, Punctuation, ")"),
|
|
(70, Whitespace, " "),
|
|
(71, Punctuation, "{"),
|
|
(72, Whitespace, "\n "),
|
|
(77, Name, "handle"),
|
|
(83, Whitespace, "\n "),
|
|
(88, Punctuation, "..."),
|
|
(91, Whitespace, " "),
|
|
(92, Keyword, "on"),
|
|
(94, Whitespace, " "),
|
|
(95, Name.Class, "User"),
|
|
(99, Whitespace, " "),
|
|
(100, Punctuation, "{"),
|
|
(101, Whitespace, "\n "),
|
|
(108, Name, "friends"),
|
|
(115, Whitespace, " "),
|
|
(116, Punctuation, "{"),
|
|
(117, Whitespace, "\n "),
|
|
(126, Name, "count"),
|
|
(131, Whitespace, "\n "),
|
|
(138, Punctuation, "}"),
|
|
(139, Whitespace, "\n "),
|
|
(144, Punctuation, "}"),
|
|
(145, Whitespace, "\n "),
|
|
(150, Punctuation, "..."),
|
|
(153, Whitespace, " "),
|
|
(154, Keyword, "on"),
|
|
(156, Whitespace, " "),
|
|
(157, Name.Class, "Page"),
|
|
(161, Whitespace, " "),
|
|
(162, Punctuation, "{"),
|
|
(163, Whitespace, "\n "),
|
|
(170, Name, "likers"),
|
|
(176, Whitespace, " "),
|
|
(177, Punctuation, "{"),
|
|
(178, Whitespace, "\n "),
|
|
(187, Name, "count"),
|
|
(192, Whitespace, "\n "),
|
|
(199, Punctuation, "}"),
|
|
(200, Whitespace, "\n "),
|
|
(205, Punctuation, "}"),
|
|
(206, Whitespace, "\n "),
|
|
(209, Punctuation, "}"),
|
|
(210, Whitespace, "\n"),
|
|
(211, Punctuation, "}"),
|
|
(212, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_input_value_nested_array(self):
|
|
text = """\
|
|
{
|
|
node(arg: [1, [2, 3]])
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "node"),
|
|
(8, Punctuation, "("),
|
|
(9, Name, "arg"),
|
|
(12, Punctuation, ":"),
|
|
(13, Whitespace, " "),
|
|
(14, Punctuation, "["),
|
|
(15, Number.Integer, "1"),
|
|
(16, Punctuation, ","),
|
|
(17, Whitespace, " "),
|
|
(18, Punctuation, "["),
|
|
(19, Number.Integer, "2"),
|
|
(20, Punctuation, ","),
|
|
(21, Whitespace, " "),
|
|
(22, Number.Integer, "3"),
|
|
(23, Punctuation, "]"),
|
|
(24, Punctuation, "]"),
|
|
(25, Punctuation, ")"),
|
|
(26, Whitespace, "\n"),
|
|
(27, Punctuation, "}"),
|
|
(28, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_input_value_object(self):
|
|
text = """\
|
|
{
|
|
node(arg: {a: "a", b: "b"})
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "node"),
|
|
(8, Punctuation, "("),
|
|
(9, Name, "arg"),
|
|
(12, Punctuation, ":"),
|
|
(13, Whitespace, " "),
|
|
(14, Punctuation, "{"),
|
|
(15, Name, "a"),
|
|
(16, Punctuation, ":"),
|
|
(17, Whitespace, " "),
|
|
(18, String, '"'),
|
|
(19, String, "a"),
|
|
(20, String, '"'),
|
|
(21, Punctuation, ","),
|
|
(22, Whitespace, " "),
|
|
(23, Name, "b"),
|
|
(24, Punctuation, ":"),
|
|
(25, Whitespace, " "),
|
|
(26, String, '"'),
|
|
(27, String, "b"),
|
|
(28, String, '"'),
|
|
(29, Punctuation, "}"),
|
|
(30, Punctuation, ")"),
|
|
(31, Whitespace, "\n"),
|
|
(32, Punctuation, "}"),
|
|
(33, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_input_nested_value_object(self):
|
|
text = """\
|
|
{
|
|
node(arg: {a: "a", b: {c: "c", d: {e: "e"}}})
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "node"),
|
|
(8, Punctuation, "("),
|
|
(9, Name, "arg"),
|
|
(12, Punctuation, ":"),
|
|
(13, Whitespace, " "),
|
|
(14, Punctuation, "{"),
|
|
(15, Name, "a"),
|
|
(16, Punctuation, ":"),
|
|
(17, Whitespace, " "),
|
|
(18, String, '"'),
|
|
(19, String, "a"),
|
|
(20, String, '"'),
|
|
(21, Punctuation, ","),
|
|
(22, Whitespace, " "),
|
|
(23, Name, "b"),
|
|
(24, Punctuation, ":"),
|
|
(25, Whitespace, " "),
|
|
(26, Punctuation, "{"),
|
|
(27, Name, "c"),
|
|
(28, Punctuation, ":"),
|
|
(29, Whitespace, " "),
|
|
(30, String, '"'),
|
|
(31, String, "c"),
|
|
(32, String, '"'),
|
|
(33, Punctuation, ","),
|
|
(34, Whitespace, " "),
|
|
(35, Name, "d"),
|
|
(36, Punctuation, ":"),
|
|
(37, Whitespace, " "),
|
|
(38, Punctuation, "{"),
|
|
(39, Name, "e"),
|
|
(40, Punctuation, ":"),
|
|
(41, Whitespace, " "),
|
|
(42, String, '"'),
|
|
(43, String, "e"),
|
|
(44, String, '"'),
|
|
(45, Punctuation, "}"),
|
|
(46, Punctuation, "}"),
|
|
(47, Punctuation, "}"),
|
|
(48, Punctuation, ")"),
|
|
(49, Whitespace, "\n"),
|
|
(50, Punctuation, "}"),
|
|
(51, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|
|
|
|
def test_input_value_mixed(self):
|
|
text = """\
|
|
{
|
|
node1(arg: {a: [1, 2]})
|
|
node2(arg: [1, {a: "a"}])
|
|
}
|
|
"""
|
|
expected = [
|
|
(0, Punctuation, "{"),
|
|
(1, Whitespace, "\n "),
|
|
(4, Name, "node1"),
|
|
(9, Punctuation, "("),
|
|
(10, Name, "arg"),
|
|
(13, Punctuation, ":"),
|
|
(14, Whitespace, " "),
|
|
(15, Punctuation, "{"),
|
|
(16, Name, "a"),
|
|
(17, Punctuation, ":"),
|
|
(18, Whitespace, " "),
|
|
(19, Punctuation, "["),
|
|
(20, Number.Integer, "1"),
|
|
(21, Punctuation, ","),
|
|
(22, Whitespace, " "),
|
|
(23, Number.Integer, "2"),
|
|
(24, Punctuation, "]"),
|
|
(25, Punctuation, "}"),
|
|
(26, Punctuation, ")"),
|
|
(27, Whitespace, "\n "),
|
|
(30, Name, "node2"),
|
|
(35, Punctuation, "("),
|
|
(36, Name, "arg"),
|
|
(39, Punctuation, ":"),
|
|
(40, Whitespace, " "),
|
|
(41, Punctuation, "["),
|
|
(42, Number.Integer, "1"),
|
|
(43, Punctuation, ","),
|
|
(44, Whitespace, " "),
|
|
(45, Punctuation, "{"),
|
|
(46, Name, "a"),
|
|
(47, Punctuation, ":"),
|
|
(48, Whitespace, " "),
|
|
(49, String, '"'),
|
|
(50, String, "a"),
|
|
(51, String, '"'),
|
|
(52, Punctuation, "}"),
|
|
(53, Punctuation, "]"),
|
|
(54, Punctuation, ")"),
|
|
(55, Whitespace, "\n"),
|
|
(56, Punctuation, "}"),
|
|
(57, Whitespace, "\n"),
|
|
]
|
|
assert_tokens_equal(self, text, expected)
|