def test_rst(path): with open(path) as f: rst = f.read() doctree = publish_doctree(rst) ast_parts = [] for block in doctree.traverse(condition=is_code_block): raw_text = block.astext() num_lines = raw_text.count("\n") + 1 node = ast.parse(raw_text, path) ast.increment_lineno(node, block.line - num_lines - 1) ast_parts.extend(node.body) if sys.version_info >= (3, 8): mod = ast.Module(body=ast_parts, type_ignores=[]) else: mod = ast.Module(body=ast_parts) # Pytest 5 is Python 3 only and there are some API differences we need to # consider if get_pytest_version_info() < (5,): rewrite_asserts(mod, None) else: rewrite_asserts(mod, rst) exec(compile(mod, path, "exec"), {})
def rewrite_asserts(self, line, cell): """Rewrite asserts with pytest. Usage:: %%rewrite_asserts ... # new cell: from ipytest import run_pytest run_pytest() """ emit_deprecation_warning( "Assertion rewriting via magics is deprecated. " "Use iyptest.config.rewrite_asserts = True instead." ) # follow InteractiveShell._run_cell cell_name = self.shell.compile.cache(cell, self.shell.execution_count) mod = self.shell.compile.ast_parse(cell, filename=cell_name) # rewrite assert statements from _pytest.assertion.rewrite import rewrite_asserts rewrite_asserts(mod) # follow InteractiveShell.run_ast_nodes code = self.shell.compile(mod, cell_name, "exec") self.shell.run_code(code)
def _rewrite_test(config, name): """Try to read and rewrite *fn* and return the code object.""" state = config._assertstate source = importer.get_source(name) if source is None: return None path = importer.get_filename(name) try: tree = ast.parse(source, filename=path) except SyntaxError: # Let this pop up again in the real import. state.trace("failed to parse: %r" % (path, )) return None rewrite.rewrite_asserts(tree, path, config) try: co = compile(tree, path, "exec", dont_inherit=True) except SyntaxError: # It's possible that this error is from some bug in the # assertion rewriting, but I don't know of a fast way to tell. state.trace("failed to compile: %r" % (path, )) return None return co
def pytest_rewrite_asserts(code, module_name=reserved_prefix + "_pytest_module"): """Uses pytest to rewrite the assert statements in the given code.""" from _pytest.assertion.rewrite import rewrite_asserts # hidden since it's not always available module_name = module_name.encode("utf-8") tree = ast.parse(code) rewrite_asserts(tree, module_name) fixed_tree = ast.fix_missing_locations(FixPytestNames().visit(tree)) return ast.unparse(fixed_tree)
def pytest_pycollect_makemodule(module_path: pathlib.Path, path: Any, parent: Any) -> None: source = module_path.read_bytes() strfn = str(module_path) tree = ast.parse(source, filename=strfn) ORIGINAL_MODULE_ASTS[strfn] = tree tree2 = deepcopy(tree) rewrite_asserts(tree2, source, strfn, REWRITE_CONFIG) REWRITTEN_MODULE_ASTS[strfn] = tree2 orig_pytest_pycollect_makemodule(module_path, parent)
def visit(self, node): from _pytest.assertion.rewrite import rewrite_asserts pytest_version = get_pytest_version() if pytest_version.release[0] >= 5: # TODO: re-create a pseudo code to include the asserts? rewrite_asserts(node, b"") else: rewrite_asserts(node) return node
def before_module_import(mod): if mod.config._assertstate.mode != "on": return # Some deep magic: load the source, rewrite the asserts, and write a # fake pyc, so that it'll be loaded when the module is imported. source = mod.fspath.read() try: tree = ast.parse(source) except SyntaxError: # Let this pop up again in the real import. mod.config._assertstate.trace("failed to parse: %r" % (mod.fspath,)) return rewrite_asserts(tree) try: co = compile(tree, str(mod.fspath), "exec") except SyntaxError: # It's possible that this error is from some bug in the assertion # rewriting, but I don't know of a fast way to tell. mod.config._assertstate.trace("failed to compile: %r" % (mod.fspath,)) return mod._pyc = _write_pyc(co, mod.fspath) mod.config._assertstate.trace("wrote pyc: %r" % (mod._pyc,))
def before_module_import(mod): if mod.config._assertstate.mode != "on": return # Some deep magic: load the source, rewrite the asserts, and write a # fake pyc, so that it'll be loaded when the module is imported. source = mod.fspath.read() try: tree = ast.parse(source) except SyntaxError: # Let this pop up again in the real import. mod.config._assertstate.trace("failed to parse: %r" % (mod.fspath, )) return rewrite_asserts(tree) try: co = compile(tree, str(mod.fspath), "exec") except SyntaxError: # It's possible that this error is from some bug in the assertion # rewriting, but I don't know of a fast way to tell. mod.config._assertstate.trace("failed to compile: %r" % (mod.fspath, )) return mod._pyc = _write_pyc(co, mod.fspath) mod.config._assertstate.trace("wrote pyc: %r" % (mod._pyc, ))
def create_pytest_module(name, path, source, config): """Return a Module from source string with its assertions rewritten""" try: tree = ast.parse(source) except SyntaxError: return None rewrite_asserts(tree, py.path.local(path), config) try: co = compile(tree, path, "exec", dont_inherit=True) except SyntaxError: return mod = types.ModuleType(name) exec(co, mod.__dict__) # Also, seed the line cache, so pytest can show source code def getsource(): return source cache[path] = (getsource, ) return mod
def visit(self, node): from _pytest.assertion.rewrite import rewrite_asserts rewrite_asserts(node) return node
def rewrite(src): tree = ast.parse(src) rewrite_asserts(tree) return tree
def rewrite(src: str) -> ast.Module: tree = ast.parse(src) rewrite_asserts(tree, src.encode()) return tree
def replacement_rewrite_asserts(mod, module_path=None, config=None): rewrite_asserts(mod, module_path, config) store.append(codegen.to_source(mod))
from _pytest.assertion.rewrite import rewrite_asserts import ast, astunparse, sys with open(sys.argv[1], 'r') as open_file: ast_tree = ast.parse(open_file.read()) rewrite_asserts(ast_tree) print astunparse.unparse(ast_tree)
def replacement_rewrite_asserts(tree): rewrite_asserts(tree) store.append(codegen.to_source(tree))
def replacement_rewrite_asserts(mod, *args, **kwargs): rewrite_asserts(mod, *args, **kwargs) store.append(codegen.to_source(mod))
def rewrite(src): tree = ast.parse(src) rewrite_asserts(tree, src.encode()) return tree
def transform_ast(self, node: ast.AST) -> ast.AST: rewrite_asserts(node, self.source, self.filename, _PYTEST_CONFIG) return node