def run_command_status(self, cmd): """Run the command-line `cmd` in a sub-process, and print its output. Use this when you need to test the process behavior of coverage. Compare with `command_line`. Returns a pair: the process' exit status and stdout text, which are also stored as self.last_command_status and self.last_command_output. """ # Add our test modules directory to PYTHONPATH. I'm sure there's too # much path munging here, but... here = os.path.dirname(self.nice_file(coverage.__file__, "..")) testmods = self.nice_file(here, 'tests/modules') zipfile = self.nice_file(here, 'tests/zipmods.zip') pypath = os.getenv('PYTHONPATH', '') if pypath: pypath += os.pathsep pypath += testmods + os.pathsep + zipfile self.set_environ('PYTHONPATH', pypath) self.last_command_status, self.last_command_output = run_command(cmd) print(self.last_command_output) return self.last_command_status, self.last_command_output
def run(cmds, rundir="src", outfile=None): """Run a list of commands. `cmds` is a string, commands separated by newlines. `rundir` is the directory in which to run the commands. `outfile` is a file name to redirect stdout to. """ with change_dir(rundir): if outfile: fout = open(outfile, "a+") try: for cmd in cmds.split("\n"): cmd = cmd.strip() if not cmd: continue retcode, output = run_command(cmd) print(output.rstrip()) if outfile: fout.write(output) if retcode: raise Exception("command exited abnormally") # pragma: only failure finally: if outfile: fout.close()
def run(self, cmds, rundir="src", outfile=None): """Run a list of commands. `cmds` is a string, commands separated by newlines. `rundir` is the directory in which to run the commands. `outfile` is a filename to redirect stdout to. """ cwd = self.cd(rundir) if outfile: fout = open(outfile, "a+") try: for cmd in cmds.split("\n"): cmd = cmd.strip() if not cmd: continue retcode, output = run_command(cmd) print(output.rstrip()) if outfile: fout.write(output) if retcode: raise Exception("command exited abnormally") finally: if outfile: fout.close() self.cd(cwd)
def run_command_status(self, cmd): """Run the command-line `cmd` in a sub-process, and print its output. Use this when you need to test the process behavior of coverage. Compare with `command_line`. Handles the following command names specially: * "python" is replaced with the command name of the current Python interpreter. * "coverage" is replaced with the command name for the main Coverage.py program. Returns a pair: the process' exit status and its stdout/stderr text, which are also stored as `self.last_command_status` and `self.last_command_output`. """ # Make sure "python" and "coverage" mean specifically what we want # them to mean. split_commandline = cmd.split(" ", 1) command_name = split_commandline[0] command_args = split_commandline[1:] if command_name == "python": # Running a Python interpreter in a sub-processes can be tricky. # Use the real name of our own executable. So "python foo.py" might # get executed as "python3.3 foo.py". This is important because # Python 3.x doesn't install as "python", so you might get a Python # 2 executable instead if you don't use the executable's basename. command_name = os.path.basename(sys.executable) if command_name == "coverage": # The invocation requests the Coverage.py program. Substitute the # actual Coverage.py main command name. command_name = self.coverage_command cmd = " ".join([shlex_quote(command_name)] + command_args) # Add our test modules directory to PYTHONPATH. I'm sure there's too # much path munging here, but... here = os.path.dirname(self.nice_file(coverage.__file__, "..")) testmods = self.nice_file(here, 'tests/modules') zipfile = self.nice_file(here, 'tests/zipmods.zip') pypath = os.getenv('PYTHONPATH', '') if pypath: pypath += os.pathsep pypath += testmods + os.pathsep + zipfile self.set_environ('PYTHONPATH', pypath) self.last_command_status, self.last_command_output = run_command(cmd) print(self.last_command_output) return self.last_command_status, self.last_command_output
def run_in_venv(cmd): r"""Run `cmd` in the virtualenv at `venv`. The first word of the command will be adjusted to run it from the venv/bin or venv\Scripts directory. Returns the text output of the command. """ words = cmd.split() if env.WINDOWS: words[0] = fr"venv\Scripts\{words[0]}.exe" else: words[0] = fr"venv/bin/{words[0]}" status, output = run_command(" ".join(words)) assert status == 0 return output
def run_command_status(self, cmd): """Run the command-line `cmd` in a sub-process, and print its output. Use this when you need to test the process behavior of coverage. Compare with `command_line`. Handles the following command names specially: * "python" is replaced with the command name of the current Python interpreter. * "coverage" is replaced with the command name for the main coverage.py program. Returns a pair: the process' exit status and its stdout/stderr text, which are also stored as `self.last_command_status` and `self.last_command_output`. """ # Make sure "python" and "coverage" mean specifically what we want # them to mean. split_commandline = cmd.split() command_name = split_commandline[0] command_args = split_commandline[1:] if command_name == "python": # Running a Python interpreter in a sub-processes can be tricky. # Use the real name of our own executable. So "python foo.py" might # get executed as "python3.3 foo.py". This is important because # Python 3.x doesn't install as "python", so you might get a Python # 2 executable instead if you don't use the executable's basename. command_words = [os.path.basename(sys.executable)] elif command_name == "coverage": if env.JYTHON: # pragma: only jython # Jython can't do reporting, so let's skip the test now. if command_args and command_args[0] in ('report', 'html', 'xml', 'annotate'): pytest.skip("Can't run reporting commands in Jython") # Jython can't run "coverage" as a command because the shebang # refers to another shebang'd Python script. So run them as # modules. command_words = "jython -m coverage".split() else: # The invocation requests the coverage.py program. Substitute the # actual coverage.py main command name. command_words = [self.coverage_command] else: command_words = [command_name] cmd = " ".join([shlex_quote(w) for w in command_words] + command_args) # Add our test modules directory to PYTHONPATH. I'm sure there's too # much path munging here, but... pythonpath_name = "PYTHONPATH" if env.JYTHON: pythonpath_name = "JYTHONPATH" # pragma: only jython testmods = self.nice_file(self.working_root(), 'tests/modules') zipfile = self.nice_file(self.working_root(), 'tests/zipmods.zip') pypath = os.getenv(pythonpath_name, '') if pypath: pypath += os.pathsep pypath += testmods + os.pathsep + zipfile self.set_environ(pythonpath_name, pypath) self.last_command_status, self.last_command_output = run_command(cmd) print(self.last_command_output) return self.last_command_status, self.last_command_output
def venv_world_fixture(tmp_path_factory): """Create a virtualenv with a few test packages for VirtualenvTest to use. Returns the directory containing the "venv" virtualenv. """ venv_world = tmp_path_factory.mktemp("venv_world") with change_dir(venv_world): # Create a virtualenv. run_command("python -m venv venv") # A third-party package that installs a few different packages. make_file( "third_pkg/third/__init__.py", """\ import fourth def third(x): return 3 * x """) # Use plugin2.py as third.plugin with open(os.path.join(os.path.dirname(__file__), "plugin2.py")) as f: make_file("third_pkg/third/plugin.py", f.read()) # A render function for plugin2 to use for dynamic file names. make_file( "third_pkg/third/render.py", """\ def render(filename, linenum): return "HTML: {}@{}".format(filename, linenum) """) # Another package that third can use. make_file( "third_pkg/fourth/__init__.py", """\ def fourth(x): return 4 * x """) # Some namespace packages. make_file( "third_pkg/nspkg/fifth/__init__.py", """\ def fifth(x): return 5 * x """) # The setup.py to install everything. make_file( "third_pkg/setup.py", """\ import setuptools setuptools.setup( name="third", packages=["third", "fourth", "nspkg.fifth"], ) """) # Some namespace packages. make_file( "another_pkg/nspkg/sixth/__init__.py", """\ def sixth(x): return 6 * x """) make_file( "another_pkg/setup.py", """\ import setuptools setuptools.setup( name="another", packages=["nspkg.sixth"], ) """) # Bug888 code. make_file( "bug888/app/setup.py", """\ from setuptools import setup setup( name='testcov', packages=['testcov'], namespace_packages=['testcov'], ) """) make_file( "bug888/app/testcov/__init__.py", """\ try: # pragma: no cover __import__('pkg_resources').declare_namespace(__name__) except ImportError: # pragma: no cover from pkgutil import extend_path __path__ = extend_path(__path__, __name__) """) make_file( "bug888/app/testcov/main.py", """\ import pkg_resources for entry_point in pkg_resources.iter_entry_points('plugins'): entry_point.load()() """) make_file( "bug888/plugin/setup.py", """\ from setuptools import setup setup( name='testcov-plugin', packages=['testcov'], namespace_packages=['testcov'], entry_points={'plugins': ['testp = testcov.plugin:testp']}, ) """) make_file( "bug888/plugin/testcov/__init__.py", """\ try: # pragma: no cover __import__('pkg_resources').declare_namespace(__name__) except ImportError: # pragma: no cover from pkgutil import extend_path __path__ = extend_path(__path__, __name__) """) make_file( "bug888/plugin/testcov/plugin.py", """\ def testp(): print("Plugin here") """) # Install everything. coverage_src = nice_file(TESTS_DIR, "..") run_in_venv("python -m pip install --no-index " + "./third_pkg " + "-e ./another_pkg " + "-e ./bug888/app -e ./bug888/plugin " + coverage_src) shutil.rmtree("third_pkg") return venv_world