def __init__(self, test_case: tc.TestCase) -> None:
"""Create new execution context for the given test case."""
self._local_namespace: Dict[str, Any] = dict()
self._variable_names = NamingScope()
self._modules_aliases = NamingScope(prefix="module")
self._ast_nodes = self._to_ast_nodes(test_case, self._variable_names,
self._modules_aliases)
self._global_namespace = self._prepare_global_namespace(
self._modules_aliases)
def test_statement_to_ast_with_wrap():
var_names = NamingScope()
module_aliases = NamingScope(prefix="module")
statement_to_ast_visitor = stmt_to_ast.StatementToAstVisitor(
module_aliases, var_names, True)
int_stmt = MagicMock(stmt.Statement)
int_stmt.value = 5
statement_to_ast_visitor.visit_int_primitive_statement(int_stmt)
assert (astor.to_source(Module(body=statement_to_ast_visitor.ast_nodes)) ==
"try:\n var0 = 5\nexcept BaseException:\n pass\n")
def visit_default_test_case(self, test_case: dtc.DefaultTestCase) -> None:
statement_visitor = stmt_to_ast.StatementToAstVisitor(
self._module_aliases, NamingScope(), self._wrap_code
)
for statement in test_case.statements:
statement.accept(statement_visitor)
self._test_case_asts.append(statement_visitor.ast_nodes)
def __init__(self, wrap_code: bool = False) -> None:
"""The module aliases are shared between test cases.
Args:
wrap_code: Whether or not exported code shall be wrapped
"""
self._module_aliases = NamingScope("module")
self._test_case_asts: List[List[stmt]] = []
self._wrap_code = wrap_code
def __init__(self, wrap_code: bool = False) -> None:
"""The module aliases are shared between test cases.
Args:
wrap_code: Whether or not exported code shall be wrapped
"""
self._module_aliases = NamingScope("module")
# Common modules (e.g. math) are not aliased.
self._common_modules: Set[str] = set()
self._test_case_asts: List[List[stmt]] = []
self._wrap_code = wrap_code
def visit_default_test_case(self, test_case: dtc.DefaultTestCase) -> None:
variables = NamingScope()
statement_visitor = stmt_to_ast.StatementToAstVisitor(
self._module_aliases, variables, self._wrap_code)
for statement in test_case.statements:
statement.accept(statement_visitor)
# TODO(fk) better way. Nest visitors?
assertion_visitor = ata.AssertionToAstVisitor(
self._common_modules, variables)
for assertion in statement.assertions:
assertion.accept(assertion_visitor)
statement_visitor.append_nodes(assertion_visitor.nodes)
self._test_case_asts.append(statement_visitor.ast_nodes)
def assertion_to_ast() -> ata.AssertionToAstVisitor:
scope = NamingScope()
return ata.AssertionToAstVisitor(set(), scope)
def test_naming_scope_same():
scope = NamingScope()
some_object = "something"
name1 = scope.get_name(some_object)
name2 = scope.get_name(some_object)
assert name1 == name2
def test_naming_scope_known_indices_not_empty():
scope = NamingScope()
some_object = "something"
scope.get_name(some_object)
assert scope.known_name_indices == {some_object: 0}
def test_naming_scope_known_indices_empty():
scope = NamingScope()
assert scope.known_name_indices == {}
def test_naming_scope_different():
scope = NamingScope()
name1 = scope.get_name("one name")
name2 = scope.get_name("another")
assert name1 != name2
def statement_to_ast_visitor() -> stmt_to_ast.StatementToAstVisitor:
var_names = NamingScope()
module_aliases = NamingScope(prefix="module")
return stmt_to_ast.StatementToAstVisitor(module_aliases, var_names)
def __init__(self) -> None:
"""Create new execution context."""
self._local_namespace: Dict[str, Any] = {}
self._variable_names = NamingScope()
self._modules_aliases = NamingScope(prefix="module")
self._global_namespace: Dict[str, ModuleType] = {}
def __init__(self, wrap_code: bool = False) -> None:
"""The module aliases are shared between test cases."""
self._module_aliases = NamingScope("module")
self._test_case_asts: List[List[stmt]] = []
self._wrap_code = wrap_code