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_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(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_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
