def test_inline_item_type(self):
"""Make sure we can get the type of the item in its definition."""
node = parse_item(
Peaker(lex(':param int x: A number.\n'), lookahead=2)
)
self.assertEqual(
node.node_type,
NodeType.ARGS_SECTION,
)
node_types = [x.node_type for x in node.walk()]
self.assertEqual(node_types, [
NodeType.COLON,
NodeType.ARGUMENTS,
NodeType.WORD,
NodeType.TYPE,
NodeType.WORD,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.ARGS_SECTION,
])
def test_item_name_with_return_can_have_type_but_not_argument(self):
"""Make sure the return item can can a type."""
node = parse_item(
Peaker(lex(
':returns int: Whoa.'
), lookahead=2)
)
self.assertEqual(node.node_type, NodeType.RETURNS_SECTION)
node_types = [x.node_type for x in node.walk()]
print('\n'.join(map(str, node_types)))
self.assertEqual(
node_types,
[
NodeType.COLON,
NodeType.RETURNS,
NodeType.WORD,
NodeType.TYPE,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.RETURNS_SECTION,
]
)
def test_item_without_argument(self):
"""Test that we can parse an item without an argument."""
node = parse_item(
Peaker(lex(':returns: A value.\n'), lookahead=2)
)
self.assertEqual(
node.node_type,
NodeType.RETURNS_SECTION,
)
node_types = [x.node_type for x in node.walk()]
self.assertEqual(
node_types,
[
NodeType.COLON,
NodeType.RETURNS,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.RETURNS_SECTION,
],
'Incorrect node types. Got: \n\t{}'.format('\n\t'.join([
str(x) for x in node_types
]))
)
def test_definition_with_colon_not_mistaken_for_inline_type(self):
node = parse_item(
Peaker(lex(':param x: : That shouldn\'t be there.\n'),
lookahead=2))
self.assertEqual(node.node_type, NodeType.ARGS_SECTION)
self.assertTrue(
not any([x.node_type == NodeType.TYPE for x in node.walk()]))
def test_parse_vartype_item(self):
"""Ensure we can parse a variable type description."""
node = parse_item(
Peaker(lex(':vartype foo: Dict[str][str]\n'), lookahead=2))
self.assertEqual(
node.node_type,
NodeType.VARIABLES_SECTION,
)
node_types = [x.node_type for x in node.walk()]
self.assertEqual(node_types, [
NodeType.COLON,
NodeType.TYPE,
NodeType.WORD,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.VARIABLES_SECTION,
])
def test_parse_type_item(self):
"""Ensure we can parse a type item correctly."""
node = parse_item(
Peaker(lex(':type priorities: List[int]\n'), lookahead=2))
self.assertEqual(
node.node_type,
NodeType.ARGS_SECTION,
)
node_types = [x.node_type for x in node.walk()]
self.assertEqual(node_types, [
NodeType.COLON,
NodeType.TYPE,
NodeType.WORD,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.ARGS_SECTION,
])
def test_parse_argument_item(self):
"""Make sure we can parse an item with an arity of 1."""
node = parse_item(Peaker(lex(':param x: A vector.\n'), lookahead=2))
self.assertEqual(
node.node_type,
NodeType.ARGS_SECTION,
)
node_types = [x.node_type for x in node.walk()]
self.assertEqual(node_types, [
NodeType.COLON,
NodeType.ARGUMENTS,
NodeType.WORD,
NodeType.COLON,
NodeType.ITEM_NAME,
NodeType.WORD,
NodeType.WORD,
NodeType.LINE,
NodeType.ITEM_DEFINITION,
NodeType.ITEM,
NodeType.ARGS_SECTION,
])
def test_missing_vartype_target_raises_exception(self):
"""Make sure that vartype has an argument, or raises an exception."""
content = ':vartype: List[T]'
peaker = Peaker(lex(content), lookahead=2)
with self.assertRaises(ParserException):
parse_item(peaker)
