def unknown_future_import_is_parser_error(): source = """#!/usr/bin/env python from __future__ import blah """ try: parser.parse(source) assert False except SyntaxError as error: assert_equal("Unknown __future__ import: 'blah'", error.msg)
def test_error_if_signature_is_not_consumed(): source = """ #:: int -> int """ try: parser.parse(source) assert False, "Expected SyntaxError" except SyntaxError as error: assert_equal("explicit type is not valid here", error.msg) assert_equal(2, error.lineno) assert_equal(0, error.offset)
def custom_syntax_errors_have_position(): source = """ class(**bases): pass """ try: parser.parse(source, filename="breathing-underwater.py") assert False, "Expected SyntaxError" except SyntaxError as error: assert_equal("breathing-underwater.py", error.filename) assert_equal(2, error.lineno) assert_equal(6, error.offset)
def module_is_executable_if_it_has_shebang(): source = """#!/usr/bin/env python print(1) """ module_node = parser.parse(source) assert module_node.is_executable
def can_parse_import_from_in_current_package_and_one_name(): source = """ from . import message """ module_node = parser.parse(source) expected_node = nodes.import_from(["."], [nodes.import_alias("message", None)]) assert_equal(expected_node, module_node.body[0])
def can_parse_import_package(): source = """ import messages """ module_node = parser.parse(source) expected_node = nodes.Import([nodes.import_alias("messages", None)]) assert_equal(expected_node, module_node.body[0])
def known_future_import_is_ignored(): # As of Python 3.4, all valid future imports are mandatory source = """#!/usr/bin/env python from __future__ import unicode_literals """ module_node = parser.parse(source) assert_equal([], module_node.body)
def can_parse_import_alias(): source = """ from . import message as m """ module_node = parser.parse(source) expected_node = nodes.import_from(["."], [nodes.import_alias("message", "m")]) assert_equal(expected_node, module_node.body[0])
def _parse_expression(source, filename=None): module = parser.parse(source, filename=filename) assert isinstance(module, nodes.Module) expression_statement = module.body[0] assert isinstance(expression_statement, nodes.ExpressionStatement) return expression_statement.value
def function_can_have_no_signature_if_it_takes_no_args(): source = """ def f(): pass """ module_node = parser.parse(source) expected = nodes.func("f", nodes.args([]), [], type=None) assert_equal(expected, module_node.body[0])
def module_is_treated_as_empty_if_empty_directive_is_at_top(): source = """#:nope treat-as-empty x = 1 """ module_node = parser.parse(source) assert not module_node.is_executable assert_equal([], module_node.body)
def optional_arg_can_have_default_value_of_none(self): source = """ #:: ?str -> str def f(x=None): pass """ module_node = parser.parse(source) expected = nodes.args([nodes.arg("x", optional=True)]) assert_equal(expected, module_node.body[0].args)
def can_parse_import_from_with_relative_import_of_child_module(): source = """ from .x.y import message """ module_node = parser.parse(source) expected_node = nodes.import_from([".", "x", "y"], [ nodes.import_alias("message", None), ]) assert_equal(expected_node, module_node.body[0])
def can_parse_absolute_import_from(): source = """ from x.y import message """ module_node = parser.parse(source) expected_node = nodes.import_from(["x", "y"], [ nodes.import_alias("message", None), ]) assert_equal(expected_node, module_node.body[0])
def test_type_definitions_can_appear_between_statements(): source = """ #:type Identifier = int | str Identifier = None """ module_node = parser.parse(source) expected_node = nodes.TypeDefinition( "Identifier", nodes.type_union([nodes.ref("int"), nodes.ref("str")]) ) assert_equal(expected_node, module_node.body[0]) assert_equal(1, len(module_node.body))
def can_parse_signature_comment_with_no_args_for_function_after_indent(): source = """ #:: -> str def f(): #:: -> int def g(): pass """ module_node = parser.parse(source) signature = nodes.signature(returns=nodes.ref("int")) expected = nodes.func("g", nodes.args([]), [], type=signature) assert_equal(expected, module_node.body[0].body[0])
def can_have_required_arguments_before_optional_arguments(self): source = """ #:: str, str, ?str, ?str -> str def f(a, b, c=None, d=None): pass """ module_node = parser.parse(source) expected = nodes.args([ nodes.arg("a"), nodes.arg("b"), nodes.arg("c", optional=True), nodes.arg("d", optional=True), ]) assert_equal(expected, module_node.body[0].args)
def _assert_syntax_error(description, source): try: parser.parse(source) assert False, "Expected SyntaxError" except SyntaxError as error: assert_equal(description, error.msg)
def _assert_statement_parse(expected, source): module = parser.parse(source) assert isinstance(module, nodes.Module) assert_equal(expected, module.body[0])
def module_is_not_executable_if_it_is_missing_shebang(): source = """print(1) """ module_node = parser.parse(source) assert not module_node.is_executable