class YieldConstructionTest(CSTNodeTest):
@data_provider((
# Simple yield
(cst.Yield(), "yield"),
# yield expression
(cst.Yield(cst.Name("a")), "yield a"),
# yield from expression
(cst.Yield(cst.From(cst.Call(cst.Name("a")))), "yield from a()"),
# Parenthesizing tests
(
cst.Yield(
lpar=(cst.LeftParen(), ),
value=cst.Integer("5"),
rpar=(cst.RightParen(), ),
),
"(yield 5)",
),
# Whitespace oddities tests
(
cst.Yield(
cst.Name("a",
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), )),
whitespace_after_yield=cst.SimpleWhitespace(""),
),
"yield(a)",
CodeRange((1, 0), (1, 8)),
),
(
cst.Yield(
cst.From(
cst.Call(
cst.Name("a"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
whitespace_after_from=cst.SimpleWhitespace(""),
)),
"yield from(a())",
),
# Whitespace rendering/parsing tests
(
cst.Yield(
lpar=(cst.LeftParen(
whitespace_after=cst.SimpleWhitespace(" ")), ),
value=cst.Integer("5"),
whitespace_after_yield=cst.SimpleWhitespace(" "),
rpar=(cst.RightParen(
whitespace_before=cst.SimpleWhitespace(" ")), ),
),
"( yield 5 )",
),
(
cst.Yield(
lpar=(cst.LeftParen(
whitespace_after=cst.SimpleWhitespace(" ")), ),
value=cst.From(
cst.Call(cst.Name("bla")),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_yield=cst.SimpleWhitespace(" "),
rpar=(cst.RightParen(
whitespace_before=cst.SimpleWhitespace(" ")), ),
),
"( yield from bla() )",
CodeRange((1, 2), (1, 20)),
),
# From expression position tests
(
cst.From(cst.Integer("5"),
whitespace_after_from=cst.SimpleWhitespace(" ")),
"from 5",
CodeRange((1, 0), (1, 6)),
),
))
def test_valid(self,
node: cst.CSTNode,
code: str,
position: Optional[CodeRange] = None) -> None:
self.validate_node(node, code, expected_position=position)
@data_provider((
# Paren validation
(
lambda: cst.Yield(lpar=(cst.LeftParen(), )),
"left paren without right paren",
),
(
lambda: cst.Yield(rpar=(cst.RightParen(), )),
"right paren without left paren",
),
# Make sure we have adequate space after yield
(
lambda: cst.Yield(cst.Name("a"),
whitespace_after_yield=cst.SimpleWhitespace("")),
"Must have at least one space after 'yield' keyword",
),
(
lambda: cst.Yield(
cst.From(cst.Call(cst.Name("a"))),
whitespace_after_yield=cst.SimpleWhitespace(""),
),
"Must have at least one space after 'yield' keyword",
),
# MAke sure we have adequate space after from
(
lambda: cst.Yield(
cst.From(
cst.Call(cst.Name("a")),
whitespace_after_from=cst.SimpleWhitespace(""),
)),
"Must have at least one space after 'from' keyword",
),
))
def test_invalid(self, get_node: Callable[[], cst.CSTNode],
expected_re: str) -> None:
self.assert_invalid(get_node, expected_re)
class RaiseConstructionTest(CSTNodeTest):
@data_provider((
# Simple raise
{
"node": cst.Raise(),
"code": "raise"
},
# Raise exception
{
"node": cst.Raise(cst.Call(cst.Name("Exception"))),
"code": "raise Exception()",
"expected_position": CodeRange((1, 0), (1, 17)),
},
# Raise exception from cause
{
"node":
cst.Raise(cst.Call(cst.Name("Exception")),
cst.From(cst.Name("cause"))),
"code":
"raise Exception() from cause",
},
# Whitespace oddities test
{
"node":
cst.Raise(
cst.Call(
cst.Name("Exception"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
cst.From(
cst.Name("cause",
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), )),
whitespace_before_from=cst.SimpleWhitespace(""),
whitespace_after_from=cst.SimpleWhitespace(""),
),
whitespace_after_raise=cst.SimpleWhitespace(""),
),
"code":
"raise(Exception())from(cause)",
"expected_position":
CodeRange((1, 0), (1, 29)),
},
{
"node":
cst.Raise(
cst.Call(cst.Name("Exception")),
cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(""),
),
),
"code":
"raise Exception()from cause",
"expected_position":
CodeRange((1, 0), (1, 27)),
},
# Whitespace rendering test
{
"node":
cst.Raise(
exc=cst.Call(cst.Name("Exception")),
cause=cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(" "),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_raise=cst.SimpleWhitespace(" "),
),
"code":
"raise Exception() from cause",
"expected_position":
CodeRange((1, 0), (1, 31)),
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(**kwargs)
@data_provider((
# Validate construction
{
"get_node": lambda: cst.Raise(cause=cst.From(cst.Name("cause"))),
"expected_re":
"Must have an 'exc' when specifying 'clause'. on Raise",
},
# Validate whitespace handling
{
"get_node":
lambda: cst.Raise(
cst.Call(cst.Name("Exception")),
whitespace_after_raise=cst.SimpleWhitespace(""),
),
"expected_re":
"Must have at least one space after 'raise'",
},
{
"get_node":
lambda: cst.Raise(
cst.Name("exc"),
cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(""),
),
),
"expected_re":
"Must have at least one space before 'from'",
},
{
"get_node":
lambda: cst.Raise(
cst.Name("exc"),
cst.From(
cst.Name("cause"),
whitespace_after_from=cst.SimpleWhitespace(""),
),
),
"expected_re":
"Must have at least one space after 'from'",
},
))
def test_invalid(self, **kwargs: Any) -> None:
self.assert_invalid(**kwargs)
class YieldParsingTest(CSTNodeTest):
@data_provider((
# Simple yield
(cst.Yield(), "yield"),
# yield expression
(
cst.Yield(cst.Name("a"),
whitespace_after_yield=cst.SimpleWhitespace(" ")),
"yield a",
),
# yield from expression
(
cst.Yield(
cst.From(
cst.Call(cst.Name("a")),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_yield=cst.SimpleWhitespace(" "),
),
"yield from a()",
),
# Parenthesizing tests
(
cst.Yield(
lpar=(cst.LeftParen(), ),
whitespace_after_yield=cst.SimpleWhitespace(" "),
value=cst.Integer("5"),
rpar=(cst.RightParen(), ),
),
"(yield 5)",
),
# Whitespace oddities tests
(
cst.Yield(
cst.Name("a",
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), )),
whitespace_after_yield=cst.SimpleWhitespace(""),
),
"yield(a)",
),
(
cst.Yield(
cst.From(
cst.Call(
cst.Name("a"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
whitespace_after_from=cst.SimpleWhitespace(""),
),
whitespace_after_yield=cst.SimpleWhitespace(" "),
),
"yield from(a())",
),
# Whitespace rendering/parsing tests
(
cst.Yield(
lpar=(cst.LeftParen(
whitespace_after=cst.SimpleWhitespace(" ")), ),
value=cst.Integer("5"),
whitespace_after_yield=cst.SimpleWhitespace(" "),
rpar=(cst.RightParen(
whitespace_before=cst.SimpleWhitespace(" ")), ),
),
"( yield 5 )",
),
(
cst.Yield(
lpar=(cst.LeftParen(
whitespace_after=cst.SimpleWhitespace(" ")), ),
value=cst.From(
cst.Call(cst.Name("bla")),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_yield=cst.SimpleWhitespace(" "),
rpar=(cst.RightParen(
whitespace_before=cst.SimpleWhitespace(" ")), ),
),
"( yield from bla() )",
),
))
def test_valid(self,
node: cst.CSTNode,
code: str,
position: Optional[CodeRange] = None) -> None:
self.validate_node(
node,
code,
lambda code: ensure_type(
ensure_type(parse_statement(code), cst.SimpleStatementLine).
body[0],
cst.Expr,
).value,
)
@data_provider((
{
"code": "yield from x",
"parser": parse_statement_as(python_version="3.3"),
"expect_success": True,
},
{
"code": "yield from x",
"parser": parse_statement_as(python_version="3.1"),
"expect_success": False,
},
))
def test_versions(self, **kwargs: Any) -> None:
self.assert_parses(**kwargs)
class RaiseParsingTest(CSTNodeTest):
@data_provider((
# Simple raise
{
"node": cst.Raise(),
"code": "raise"
},
# Raise exception
{
"node":
cst.Raise(
cst.Call(cst.Name("Exception")),
whitespace_after_raise=cst.SimpleWhitespace(" "),
),
"code":
"raise Exception()",
},
# Raise exception from cause
{
"node":
cst.Raise(
cst.Call(cst.Name("Exception")),
cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(" "),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_raise=cst.SimpleWhitespace(" "),
),
"code":
"raise Exception() from cause",
},
# Whitespace oddities test
{
"node":
cst.Raise(
cst.Call(
cst.Name("Exception"),
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), ),
),
cst.From(
cst.Name("cause",
lpar=(cst.LeftParen(), ),
rpar=(cst.RightParen(), )),
whitespace_before_from=cst.SimpleWhitespace(""),
whitespace_after_from=cst.SimpleWhitespace(""),
),
whitespace_after_raise=cst.SimpleWhitespace(""),
),
"code":
"raise(Exception())from(cause)",
},
{
"node":
cst.Raise(
cst.Call(cst.Name("Exception")),
cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(""),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_raise=cst.SimpleWhitespace(" "),
),
"code":
"raise Exception()from cause",
},
# Whitespace rendering test
{
"node":
cst.Raise(
exc=cst.Call(cst.Name("Exception")),
cause=cst.From(
cst.Name("cause"),
whitespace_before_from=cst.SimpleWhitespace(" "),
whitespace_after_from=cst.SimpleWhitespace(" "),
),
whitespace_after_raise=cst.SimpleWhitespace(" "),
),
"code":
"raise Exception() from cause",
},
))
def test_valid(self, **kwargs: Any) -> None:
self.validate_node(
parser=lambda code: ensure_type(parse_statement(code), cst.
SimpleStatementLine).body[0],
**kwargs,
)
