def pretend_to_be_pytestcov(self, append):
"""Act like pytest-cov."""
self.make_file("prog.py", """\
a = 1
b = 2
if b == 1:
c = 4
""")
self.make_file(".coveragerc", """\
[run]
parallel = True
source = .
""")
cov = coverage.Coverage(source=None, branch=None, config_file='.coveragerc')
if append:
cov.load()
else:
cov.erase()
self.start_import_stop(cov, "prog")
cov.combine()
cov.save()
report = StringIO()
cov.report(show_missing=None, ignore_errors=True, file=report, skip_covered=None,
skip_empty=None)
assert report.getvalue() == textwrap.dedent("""\
Name Stmts Miss Cover
-----------------------------
prog.py 4 1 75%
-----------------------------
TOTAL 4 1 75%
""")
self.assert_file_count(".coverage", 0)
self.assert_file_count(".coverage.*", 1)
def setUp(self):
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory.
self.old_syspath = sys.path[:]
sys.path.insert(0, '')
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
def setUp(self):
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory.
self.old_syspath = sys.path[:]
sys.path.insert(0, '')
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
def pretend_to_be_pytestcov(self, append):
"""Act like pytest-cov."""
self.make_file("prog.py", """\
a = 1
b = 2
if b == 1:
c = 4
""")
self.make_file(".coveragerc", """\
[run]
parallel = True
source = .
""")
cov = coverage.Coverage(source=None, branch=None, config_file='.coveragerc')
if append:
cov.load()
else:
cov.erase()
self.start_import_stop(cov, "prog")
cov.combine()
cov.save()
report = StringIO()
cov.report(show_missing=None, ignore_errors=True, file=report, skip_covered=None)
self.assertEqual(report.getvalue(), textwrap.dedent("""\
Name Stmts Miss Cover
-----------------------------
prog.py 4 1 75%
"""))
self.assert_file_count(".coverage", 0)
self.assert_file_count(".coverage.*", 1)
def test_plugin_sys_info(self):
self.make_file("plugin_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
def sys_info(self):
return [("hello", "world")]
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_sys_info"])
cov.start()
cov.stop() # pragma: nested
out_lines = [line.strip() for line in debug_out.getvalue().splitlines()]
if env.C_TRACER:
assert 'plugins.file_tracers: plugin_sys_info.Plugin' in out_lines
else:
assert 'plugins.file_tracers: plugin_sys_info.Plugin (disabled)' in out_lines
assert 'plugins.configurers: -none-' in out_lines
expected_end = [
"-- sys: plugin_sys_info.Plugin -------------------------------",
"hello: world",
"-- end -------------------------------------------------------",
]
assert expected_end == out_lines[-len(expected_end):]
def test_plugin_sys_info(self):
self.make_file(
"plugin_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
def sys_info(self):
return [("hello", "world")]
def coverage_init(reg, options):
reg.add_noop(Plugin())
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_sys_info"])
cov.load()
out_lines = debug_out.getvalue().splitlines()
expected_end = [
"-- sys: plugin_sys_info.Plugin -------------------------------",
" hello: world",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
def test_plugin_with_no_sys_info(self):
self.make_file("plugin_no_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_configurer(Plugin())
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_no_sys_info"])
cov.start()
cov.stop() # pragma: nested
out_lines = [line.strip() for line in debug_out.getvalue().splitlines()]
self.assertIn('plugins.file_tracers: -none-', out_lines)
self.assertIn('plugins.configurers: plugin_no_sys_info.Plugin', out_lines)
expected_end = [
"-- sys: plugin_no_sys_info.Plugin ----------------------------",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
def test_plugin_with_no_sys_info(self):
self.make_file("plugin_no_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_configurer(Plugin())
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_no_sys_info"])
cov.start()
cov.stop() # pragma: nested
out_lines = [line.strip() for line in debug_out.getvalue().splitlines()]
self.assertIn('plugins.file_tracers: -none-', out_lines)
self.assertIn('plugins.configurers: plugin_no_sys_info.Plugin', out_lines)
expected_end = [
"-- sys: plugin_no_sys_info.Plugin ----------------------------",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
def test_plugin_with_no_sys_info(self):
self.make_file(
"plugin_no_sys_info.py",
"""\
import coverage
class Plugin(coverage.CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_noop(Plugin())
""",
)
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.config["run:plugins"] = ["plugin_no_sys_info"]
cov.load()
out_lines = debug_out.getvalue().splitlines()
expected_end = [
"-- sys: plugin_no_sys_info.Plugin ----------------------------",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end) :])
def get_report(self, cov):
"""Get the report from `cov`, and canonicalize it."""
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r" +", " ", report)
return report
class StdStreamCapturingMixin(TestCase):
"""A test case mixin that captures stdout and stderr."""
def setUp(self):
super(StdStreamCapturingMixin, self).setUp()
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
self.addCleanup(self.cleanup_std_streams)
def cleanup_std_streams(self):
"""Restore stdout and stderr."""
sys.stdout = self.old_stdout
sys.stderr = self.old_stderr
def stdout(self):
"""Return the data written to stdout during the test."""
return self.captured_stdout.getvalue()
def stderr(self):
"""Return the data written to stderr during the test."""
return self.captured_stderr.getvalue()
def get_report(self, cov):
"""Get the report from `cov`, and canonicalize it."""
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r" +", " ", report)
return report
class StdStreamCapturingMixin(TestCase):
"""A test case mixin that captures stdout and stderr."""
def setUp(self):
super(StdStreamCapturingMixin, self).setUp()
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
self.addCleanup(self.cleanup_std_streams)
def cleanup_std_streams(self):
"""Restore stdout and stderr."""
sys.stdout = self.old_stdout
sys.stderr = self.old_stderr
def stdout(self):
"""Return the data written to stdout during the test."""
return self.captured_stdout.getvalue()
def stderr(self):
"""Return the data written to stderr during the test."""
return self.captured_stderr.getvalue()
def test_plugin_init(self):
self.make_file('coveragerc_test_config', '')
debug_out = StringIO()
cov = Coverage(config_file='coveragerc_test_config', debug=['sys'])
cov._debug_file = debug_out
cov.set_option('run:plugins', ['coverage_config_reload_plugin'])
cov.start()
cov.stop()
out_lines = [
line.strip() for line in debug_out.getvalue().splitlines()
]
self.assertIn('plugins.file_tracers: -none-', out_lines)
expected_end = [
'-- sys: coverage_config_reload_plugin.ConfigReloadPlugin -----',
'configreload: True',
'-- end -------------------------------------------------------',
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
if LooseVersion(coverage_version) >= LooseVersion('4.6'):
self.assertIn(
'plugins.configurers: coverage_config_reload_plugin.ConfigReloadPlugin',
out_lines)
def test_plugin_sys_info(self):
self.make_file(
"plugin_sys_info.py",
"""\
import coverage
class Plugin(coverage.CoveragePlugin):
def sys_info(self):
return [("hello", "world")]
def coverage_init(reg, options):
reg.add_noop(Plugin())
""",
)
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_sys_info"])
cov.load()
out_lines = debug_out.getvalue().splitlines()
expected_end = [
"-- sys: plugin_sys_info.Plugin -------------------------------",
" hello: world",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end) :])
def coverage_usepkgs(self, **kwargs):
"""Try coverage.report()."""
cov = coverage.coverage()
cov.start()
import usepkgs # pragma: nested # pylint: disable=F0401,W0612
cov.stop() # pragma: nested
report = StringIO()
cov.report(file=report, **kwargs)
return report.getvalue()
def coverage_usepkgs(self, **kwargs):
"""Try coverage.report()."""
cov = coverage.coverage()
cov.start()
import usepkgs # pragma: nested # pylint: disable=F0401,W0612
cov.stop() # pragma: nested
report = StringIO()
cov.report(file=report, **kwargs)
return report.getvalue()
def coverage_usepkgs(self, **kwargs):
"""Try coverage.report()."""
cov = coverage.Coverage()
cov.start()
import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
cov.stop() # pragma: nested
report = StringIO()
cov.report(file=report, **kwargs)
return report.getvalue()
def coverage_usepkgs(self, **kwargs):
"""Try coverage.report()."""
cov = coverage.Coverage()
cov.start()
import usepkgs # pragma: nested # pylint: disable=import-error, unused-variable
cov.stop() # pragma: nested
report = StringIO()
cov.report(file=report, **kwargs)
return report.getvalue()
def test_defer_to_python(self):
# A plugin that measures, but then wants built-in python reporting.
self.make_file(
"fairly_odd_plugin.py",
"""\
# A plugin that claims all the odd lines are executed, and none of
# the even lines, and then punts reporting off to the built-in
# Python reporting.
import coverage.plugin
class Plugin(coverage.CoveragePlugin):
def file_tracer(self, filename):
return OddTracer(filename)
def file_reporter(self, filename):
return "python"
class OddTracer(coverage.plugin.FileTracer):
def __init__(self, filename):
self.filename = filename
def source_filename(self):
return self.filename
def line_number_range(self, frame):
lineno = frame.f_lineno
if lineno % 2:
return (lineno, lineno)
else:
return (-1, -1)
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""",
)
self.make_file(
"unsuspecting.py",
"""\
a = 1
b = 2
c = 3
d = 4
e = 5
f = 6
""",
)
cov = coverage.Coverage(include=["unsuspecting.py"])
cov.set_option("run:plugins", ["fairly_odd_plugin"])
self.start_import_stop(cov, "unsuspecting")
repout = StringIO()
total = cov.report(file=repout)
report = repout.getvalue().splitlines()
expected = [
"Name Stmts Miss Cover Missing",
"-----------------------------------------------",
"unsuspecting.py 6 3 50% 2, 4, 6",
]
self.assertEqual(report, expected)
self.assertEqual(total, 50)
def test_read_and_write_are_opposites(self):
covdata1 = CoverageData()
covdata1.add_arcs(ARCS_3)
stringio = StringIO()
covdata1.write_fileobj(stringio)
stringio.seek(0)
covdata2 = CoverageData()
covdata2.read_fileobj(stringio)
self.assert_arcs3_data(covdata2)
def test_read_and_write_are_opposites(self):
covdata1 = CoverageData()
covdata1.add_arcs(ARCS_3)
stringio = StringIO()
covdata1.write_fileobj(stringio)
stringio.seek(0)
covdata2 = CoverageData()
covdata2.read_fileobj(stringio)
self.assert_arcs3_data(covdata2)
def get_summary_text(self, coverage_data, options):
"""Get text output from the SummaryReporter."""
cov = Coverage()
cov.start()
cov.stop() # pragma: nested
cov.data = coverage_data
printer = SummaryReporter(cov, options)
destination = StringIO()
printer.report([], destination)
return destination.getvalue()
def get_summary_text(self, coverage_data, options):
"""Get text output from the SummaryReporter."""
cov = Coverage()
cov.start()
cov.stop() # pragma: nested
cov.data = coverage_data
printer = SummaryReporter(cov, options)
destination = StringIO()
printer.report([], destination)
return destination.getvalue()
def test_report_file(self):
# The file= argument of coverage.report makes the report go there.
self.do_report_work("mycode3")
fout = StringIO()
coverage.report(["mycode3.py"], file=fout)
self.assertEqual(self.stdout(), "")
self.assertEqual(fout.getvalue(), textwrap.dedent("""\
Name Stmts Miss Cover Missing
---------------------------------------
mycode3 7 3 57% 4-6
"""))
def test_report_file(self):
# The file= argument of coverage.report makes the report go there.
self.do_report_work("mycode3")
fout = StringIO()
coverage.report(["mycode3.py"], file=fout)
self.assertEqual(self.stdout(), "")
self.assertEqual(fout.getvalue(), textwrap.dedent("""\
Name Stmts Miss Cover Missing
------------------------------------------
mycode3.py 7 3 57% 4-6
"""))
def test_defer_to_python(self):
# A plugin that measures, but then wants built-in python reporting.
self.make_file(
"fairly_odd_plugin.py", """\
# A plugin that claims all the odd lines are executed, and none of
# the even lines, and then punts reporting off to the built-in
# Python reporting.
import coverage.plugin
class Plugin(coverage.CoveragePlugin):
def file_tracer(self, filename):
return OddTracer(filename)
def file_reporter(self, filename):
return "python"
class OddTracer(coverage.plugin.FileTracer):
def __init__(self, filename):
self.filename = filename
def source_filename(self):
return self.filename
def line_number_range(self, frame):
lineno = frame.f_lineno
if lineno % 2:
return (lineno, lineno)
else:
return (-1, -1)
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.make_file(
"unsuspecting.py", """\
a = 1
b = 2
c = 3
d = 4
e = 5
f = 6
""")
cov = coverage.Coverage(include=["unsuspecting.py"])
cov.set_option("run:plugins", ["fairly_odd_plugin"])
self.start_import_stop(cov, "unsuspecting")
repout = StringIO()
total = cov.report(file=repout, show_missing=True)
report = repout.getvalue().splitlines()
expected = [
'Name Stmts Miss Cover Missing',
'-----------------------------------------------',
'unsuspecting.py 6 3 50% 2, 4, 6',
'-----------------------------------------------',
'TOTAL 6 3 50%',
]
assert expected == report
assert total == 50
def setUp(self):
super(CoverageTest, self).setUp()
if _TEST_NAME_FILE:
f = open(_TEST_NAME_FILE, "w")
f.write("%s_%s" % (self.__class__.__name__, self._testMethodName))
f.close()
# Tell newer unittest implementations to print long helpful messages.
self.longMessage = True
# tearDown will restore the original sys.path
self.old_syspath = sys.path[:]
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory. We don't
# use '' because we make lots of different temp directories and
# nose's caching importer can get confused. The full path prevents
# problems.
sys.path.insert(0, os.getcwd())
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
class_behavior = self.class_behavior()
class_behavior.tests += 1
class_behavior.test_method_made_any_files = False
class_behavior.temp_dir = self.run_in_temp_dir
def setUp(self):
super(CoverageTest, self).setUp()
if _TEST_NAME_FILE:
f = open(_TEST_NAME_FILE, "w")
f.write("%s_%s" % (self.__class__.__name__, self._testMethodName))
f.close()
# Tell newer unittest implementations to print long helpful messages.
self.longMessage = True
# tearDown will restore the original sys.path
self.old_syspath = sys.path[:]
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory. We don't
# use '' because we make lots of different temp directories and
# nose's caching importer can get confused. The full path prevents
# problems.
sys.path.insert(0, os.getcwd())
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
class_behavior = self.class_behavior()
class_behavior.tests += 1
class_behavior.test_method_made_any_files = False
class_behavior.temp_dir = self.run_in_temp_dir
def test_empty_files(self):
# Shows that empty files like __init__.py are listed as having zero
# statements, not one statement.
cov = coverage.coverage()
cov.start()
import usepkgs # pylint: disable=F0401,W0612
cov.stop()
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r"\s+", " ", report)
self.assert_("test/modules/pkg1/__init__ 1 0 100%" in report)
self.assert_("test/modules/pkg2/__init__ 0 0 100%" in report)
def test_empty_files(self):
# Shows that empty files like __init__.py are listed as having zero
# statements, not one statement.
cov = coverage.Coverage(branch=True)
cov.start()
import usepkgs # pragma: nested # pylint: disable=import-error, unused-variable
cov.stop() # pragma: nested
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r"\s+", " ", report)
self.assertIn("tests/modules/pkg1/__init__.py 2 0 0 0 100%", report)
self.assertIn("tests/modules/pkg2/__init__.py 0 0 0 0 100%", report)
def get_summary_text(self, options):
"""Get text output from the SummaryReporter."""
self.make_rigged_file("file1.py", 339, 155)
self.make_rigged_file("file2.py", 13, 3)
self.make_rigged_file("file3.py", 234, 228)
self.make_file("doit.py", "import file1, file2, file3")
cov = Coverage(source=["."], omit=["doit.py"])
cov.start()
import doit # pragma: nested # pylint: disable=import-error, unused-import
cov.stop() # pragma: nested
printer = SummaryReporter(cov, options)
destination = StringIO()
printer.report([], destination)
return destination.getvalue()
def setUp(self):
super(StdStreamCapturingMixin, self).setUp()
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
self.addCleanup(self.cleanup_std_streams)
def setUp(self):
super(StdStreamCapturingMixin, self).setUp()
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
self.addCleanup(self.cleanup_std_streams)
def get_summary_text(self, options):
"""Get text output from the SummaryReporter."""
self.make_rigged_file("file1.py", 339, 155)
self.make_rigged_file("file2.py", 13, 3)
self.make_rigged_file("file3.py", 234, 228)
self.make_file("doit.py", "import file1, file2, file3")
cov = Coverage(source=["."], omit=["doit.py"])
cov.start()
import doit # pragma: nested # pylint: disable=import-error, unused-import
cov.stop() # pragma: nested
printer = SummaryReporter(cov, options)
destination = StringIO()
printer.report([], destination)
return destination.getvalue()
def test_empty_files(self):
# Shows that empty files like __init__.py are listed as having zero
# statements, not one statement.
cov = coverage.coverage()
cov.start()
import usepkgs # pylint: disable=F0401,W0612
cov.stop()
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r"\s+", " ", report)
self.assert_("test/modules/pkg1/__init__ 1 0 100%" in report)
self.assert_("test/modules/pkg2/__init__ 0 0 100%" in report)
def test_empty_files(self):
# Shows that empty files like __init__.py are listed as having zero
# statements, not one statement.
cov = coverage.Coverage()
cov.start()
import usepkgs # pragma: nested # pylint: disable=import-error,unused-variable
cov.stop() # pragma: nested
repout = StringIO()
cov.report(file=repout, show_missing=False)
report = repout.getvalue().replace('\\', '/')
report = re.sub(r"\s+", " ", report)
self.assertIn("tests/modules/pkg1/__init__.py 1 0 100%", report)
self.assertIn("tests/modules/pkg2/__init__.py 0 0 100%", report)
def source_file(self):
if os.path.exists(self.filename):
return open_source(self.filename)
source = self.file_locator.get_zip_data(self.filename)
if source is not None:
return StringIO(source)
raise CoverageException("No source for code '%s'." % self.filename)
def source_token_lines(source):
ws_tokens = [token.INDENT, token.DEDENT, token.NEWLINE, tokenize.NL]
line = []
col = 0
source = source.expandtabs(8).replace('\r\n', '\n')
tokgen = tokenize.generate_tokens(StringIO(source).readline)
for ttype, ttext, (_, scol), (_, ecol), _ in phys_tokens(tokgen):
mark_start = True
for part in re.split('(\n)', ttext):
if part == '\n':
yield line
line = []
col = 0
mark_end = False
elif part == '':
mark_end = False
elif ttype in ws_tokens:
mark_end = False
else:
if mark_start and scol > col:
line.append(('ws', ' ' * (scol - col)))
mark_start = False
tok_class = tokenize.tok_name.get(ttype, 'xx').lower()[:3]
if ttype == token.NAME and keyword.iskeyword(ttext):
tok_class = 'key'
line.append((tok_class, part))
mark_end = True
scol = 0
if mark_end:
col = ecol
if line:
yield line
def _check_config(self, filename, own_rc):
section = 'report' if own_rc else 'coverage:report'
# Force own rc for pre 4.4.1
if LooseVersion(coverage_version) < LooseVersion('4.4.1'):
self.make_file(
filename, """\
[report]
ignore_errors = true
""")
else:
self.make_file(
filename, """\
[{}]
ignore_errors = true
""".format(section))
debug_out = StringIO()
cov = Coverage(config_file=filename, debug=['sys'])
assert cov.config.get_option('report:ignore_errors') is True
cov._debug_file = debug_out
self.make_file(
filename, """\
[{}]
ignore_errors = off
""".format(section))
cov.set_option('run:plugins', ['coverage_config_reload_plugin'])
cov.start()
cov.stop()
assert cov.config.get_option('report:ignore_errors') is False
def test_should_trace_cache(self):
# The tracers should only invoke should_trace once for each file name.
# TODO: Might be better to do this with a mocked _should_trace,
# rather than by examining debug output.
# Make some files that invoke each other.
self.make_file(
"f1.py", """\
def f1(x, f):
return f(x)
""")
self.make_file(
"f2.py", """\
import f1
def func(x):
return f1.f1(x, otherfunc)
def otherfunc(x):
return x*x
for i in range(10):
func(i)
""")
# Trace one file, but not the other, and get the debug output.
debug_out = StringIO()
cov = coverage.coverage(include=["f1.py"],
debug=['trace'],
debug_file=debug_out)
# Import the python file, executing it.
self.start_import_stop(cov, "f2")
# Grab all the filenames mentioned in debug output, there should be no
# duplicates.
trace_lines = [
l for l in debug_out.getvalue().splitlines()
if l.startswith("Tracing ") or l.startswith("Not tracing ")
]
filenames = [re.search(r"'[^']+'", l).group() for l in trace_lines]
self.assertEqual(len(filenames), len(set(filenames)))
# Double-check that the tracing messages are in there somewhere.
self.assertGreater(len(filenames), 5)
def source_file(self):
"""Return an open file for reading the source of the code unit."""
if os.path.exists(self.filename):
return open_source(self.filename)
source = self.file_locator.get_zip_data(self.filename)
if source is not None:
return StringIO(source)
raise CoverageException("No source for code '%s'." % self.filename)
def generate_tokens(self, text):
"""A stand-in for `tokenize.generate_tokens`."""
if text != self.last_text:
self.last_text = text
self.last_tokens = list(
tokenize.generate_tokens(StringIO(text).readline)
)
return self.last_tokens
def f1_debug_output(self, debug):
"""Runs some code with `debug` option, returns the debug output."""
# Make code to run.
self.make_file("f1.py", """\
def f1(x):
return x+1
for i in range(5):
f1(i)
""")
debug_out = StringIO()
cov = coverage.coverage(debug=debug, debug_file=debug_out)
self.start_import_stop(cov, "f1")
out_lines = debug_out.getvalue().splitlines()
return out_lines
def f1_debug_output(self, debug):
"""Runs some code with `debug` option, returns the debug output."""
# Make code to run.
self.make_file("f1.py", """\
def f1(x):
return x+1
for i in range(5):
f1(i)
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=debug)
cov._debug_file = debug_out
self.start_import_stop(cov, "f1")
out_lines = debug_out.getvalue().splitlines()
return out_lines
def test_should_trace_cache(self):
# The tracers should only invoke should_trace once for each file name.
# TODO: Might be better to do this with a mocked _should_trace,
# rather than by examining debug output.
# Make some files that invoke each other.
self.make_file("f1.py", """\
def f1(x, f):
return f(x)
""")
self.make_file("f2.py", """\
import f1
def func(x):
return f1.f1(x, otherfunc)
def otherfunc(x):
return x*x
for i in range(10):
func(i)
""")
# Trace one file, but not the other, and get the debug output.
debug_out = StringIO()
cov = coverage.coverage(
include=["f1.py"], debug=['trace'], debug_file=debug_out
)
# Import the python file, executing it.
self.start_import_stop(cov, "f2")
# Grab all the filenames mentioned in debug output, there should be no
# duplicates.
trace_lines = [
l for l in debug_out.getvalue().splitlines()
if l.startswith(("Tracing ", "Not tracing "))
]
filenames = [re.search(r"'[^']+'", l).group() for l in trace_lines]
self.assertEqual(len(filenames), len(set(filenames)))
# Double-check that the tracing messages are in there somewhere.
self.assertGreater(len(filenames), 5)
def test_reload_plugin_init(self):
self._reset_env()
self.make_file(
'.coveragerc', """\
[run]
plugins = coverage_env_plugin, coverage_config_reload_plugin
[coverage_env_plugin]
markers = True
[report]
exclude_lines =
pragma ${OS_NAME}: no cover
""")
debug_out = StringIO()
cov = Coverage(config_file='.coveragerc', debug=['sys'])
cov._debug_file = debug_out
cov.set_option(
'run:plugins',
['coverage_env_plugin', 'coverage_config_reload_plugin'])
cov.start()
cov.stop()
assert cov.config.get_option('coverage_env_plugin:markers') == 'True'
out_lines = [
line.strip() for line in debug_out.getvalue().splitlines()
]
self.assertIn('plugins.file_tracers: -none-', out_lines)
if LooseVersion(config_reload_version) >= LooseVersion('0.3.0'):
expected_end = [
'-- sys: coverage_config_reload_plugin.ConfigReloadPlugin -----',
'configreload: True',
'-- end -------------------------------------------------------',
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
if LooseVersion(coverage_version) >= LooseVersion('4.6'):
self.assertIn(
'plugins.configurers: coverage_config_reload_plugin.ConfigReloadPlugin',
out_lines)
def test_plugin_with_no_sys_info(self):
self.make_file(
"plugin_no_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
pass
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.config["run:plugins"] = ["plugin_no_sys_info"]
cov.load()
out_lines = debug_out.getvalue().splitlines()
expected_end = [
"-- sys: plugin_no_sys_info -----------------------------------",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
def test_plugin2_with_text_report(self):
self.make_render_and_caller()
cov = coverage.Coverage(branch=True, omit=["*quux*"])
cov.config["run:plugins"] = ["tests.plugin2"]
self.start_import_stop(cov, "caller")
repout = StringIO()
total = cov.report(file=repout, include=["*.html"], omit=["uni*.html"])
report = repout.getvalue().splitlines()
expected = [
"Name Stmts Miss Branch BrPart Cover Missing",
"--------------------------------------------------------",
"bar_4.html 4 2 0 0 50% 1, 4",
"foo_7.html 7 5 0 0 29% 1-3, 6-7",
"--------------------------------------------------------",
"TOTAL 11 7 0 0 36% ",
]
self.assertEqual(report, expected)
self.assertAlmostEqual(total, 36.36, places=2)
def test_plugin_sys_info(self):
self.make_file("plugin_sys_info.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
def sys_info(self):
return [("hello", "world")]
""")
debug_out = StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.config["run:plugins"] = ["plugin_sys_info"]
cov.load()
out_lines = debug_out.getvalue().splitlines()
expected_end = [
"-- sys: plugin_sys_info --------------------------------------",
" hello: world",
"-- end -------------------------------------------------------",
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
def test_plugin2_with_text_report(self):
self.make_render_and_caller()
cov = coverage.Coverage(branch=True, omit=["*quux*"])
cov.set_option("run:plugins", ["tests.plugin2"])
self.start_import_stop(cov, "caller")
repout = StringIO()
total = cov.report(file=repout, include=["*.html"], omit=["uni*.html"], show_missing=True)
report = repout.getvalue().splitlines()
expected = [
'Name Stmts Miss Branch BrPart Cover Missing',
'--------------------------------------------------------',
'bar_4.html 4 2 0 0 50% 1, 4',
'foo_7.html 7 5 0 0 29% 1-3, 6-7',
'--------------------------------------------------------',
'TOTAL 11 7 0 0 36%',
]
self.assertEqual(expected, report)
self.assertAlmostEqual(total, 36.36, places=2)
def test_plugin2_with_text_report(self):
self.make_render_and_caller()
cov = coverage.Coverage(branch=True, omit=["*quux*"])
cov.set_option("run:plugins", ["tests.plugin2"])
self.start_import_stop(cov, "caller")
repout = StringIO()
total = cov.report(file=repout, include=["*.html"], omit=["uni*.html"], show_missing=True)
report = repout.getvalue().splitlines()
expected = [
'Name Stmts Miss Branch BrPart Cover Missing',
'--------------------------------------------------------',
'bar_4.html 4 2 0 0 50% 1, 4',
'foo_7.html 7 5 0 0 29% 1-3, 6-7',
'--------------------------------------------------------',
'TOTAL 11 7 0 0 36%',
]
self.assertEqual(expected, report)
self.assertAlmostEqual(total, 36.36, places=2)
def test_no_reload_plugin(self):
debug_out = StringIO()
cov = Coverage(debug=['sys'])
cov._debug_file = debug_out
cov.set_option('run:plugins', [])
cov.start()
cov.stop()
out_lines = [
line.strip() for line in debug_out.getvalue().splitlines()
]
self.assertIn('plugins.file_tracers: -none-', out_lines)
expected_end = [
'-- end -------------------------------------------------------',
]
self.assertEqual(expected_end, out_lines[-len(expected_end):])
if LooseVersion(coverage_version) >= LooseVersion('4.6'):
self.assertIn('plugins.configurers: -none-', out_lines)
assert cov.config.get_option('report:ignore_errors') is False
class CoverageTest(TestCase):
"""A base class for Coverage test cases."""
run_in_temp_dir = True
def setUp(self):
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory.
self.old_syspath = sys.path[:]
sys.path.insert(0, '')
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
def tearDown(self):
if self.run_in_temp_dir:
# Restore the original sys.path.
sys.path = self.old_syspath
# Get rid of the temporary directory.
os.chdir(self.old_dir)
shutil.rmtree(self.temp_root)
# Restore the environment.
self.undo_environ()
# Restore stdout and stderr
sys.stdout = self.old_stdout
sys.stderr = self.old_stderr
# Remove any new modules imported during the test run. This lets us
# import the same source files for more than one test.
for m in [m for m in sys.modules if m not in self.old_modules]:
del sys.modules[m]
def set_environ(self, name, value):
"""Set an environment variable `name` to be `value`.
The environment variable is set, and record is kept that it was set,
so that `tearDown` can restore its original value.
"""
if name not in self.environ_undos:
self.environ_undos[name] = os.environ.get(name)
os.environ[name] = value
def original_environ(self, name, if_missing=None):
"""The environment variable `name` from when the test started."""
if name in self.environ_undos:
ret = self.environ_undos[name]
else:
ret = os.environ.get(name)
if ret is None:
ret = if_missing
return ret
def undo_environ(self):
"""Undo all the changes made by `set_environ`."""
for name, value in self.environ_undos.items():
if value is None:
del os.environ[name]
else:
os.environ[name] = value
def stdout(self):
"""Return the data written to stdout during the test."""
return self.captured_stdout.getvalue()
def stderr(self):
"""Return the data written to stderr during the test."""
return self.captured_stderr.getvalue()
def make_file(self, filename, text=""):
"""Create a temp file.
`filename` is the path to the file, including directories if desired,
and `text` is the content.
Returns the path to the file.
"""
# Tests that call `make_file` should be run in a temp environment.
assert self.run_in_temp_dir
text = textwrap.dedent(text)
# Make sure the directories are available.
dirs, _ = os.path.split(filename)
if dirs and not os.path.exists(dirs):
os.makedirs(dirs)
# Create the file.
f = open(filename, 'w')
f.write(text)
f.close()
return filename
def import_module(self, modname):
"""Import the module named modname, and return the module object."""
modfile = modname + '.py'
f = open(modfile, 'r')
for suff in imp.get_suffixes():
if suff[0] == '.py':
break
try:
# pylint: disable-msg=W0631
# (Using possibly undefined loop variable 'suff')
mod = imp.load_module(modname, f, modfile, suff)
finally:
f.close()
return mod
def get_module_name(self):
"""Return the module name to use for this test run."""
# We append self.n because otherwise two calls in one test will use the
# same filename and whether the test works or not depends on the
# timestamps in the .pyc file, so it becomes random whether the second
# call will use the compiled version of the first call's code or not!
modname = 'coverage_test_' + self.noise + str(self.n)
self.n += 1
return modname
# Map chars to numbers for arcz_to_arcs
_arcz_map = {'.': -1}
_arcz_map.update(dict([(c, ord(c)-ord('0')) for c in '123456789']))
_arcz_map.update(dict(
[(c, 10+ord(c)-ord('A')) for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
))
def arcz_to_arcs(self, arcz):
"""Convert a compact textual representation of arcs to a list of pairs.
The text has space-separated pairs of letters. Period is -1, 1-9 are
1-9, A-Z are 10 through 36. The resulting list is sorted regardless of
the order of the input pairs.
".1 12 2." --> [(-1,1), (1,2), (2,-1)]
Minus signs can be included in the pairs:
"-11, 12, 2-5" --> [(-1,1), (1,2), (2,-5)]
"""
arcs = []
for pair in arcz.split():
asgn = bsgn = 1
if len(pair) == 2:
a,b = pair
else:
assert len(pair) == 3
if pair[0] == '-':
_,a,b = pair
asgn = -1
else:
assert pair[1] == '-'
a,_,b = pair
bsgn = -1
arcs.append((asgn*self._arcz_map[a], bsgn*self._arcz_map[b]))
return sorted(arcs)
def assertEqualArcs(self, a1, a2, msg=None):
"""Assert that the arc lists `a1` and `a2` are equal."""
# Make them into multi-line strings so we can see what's going wrong.
s1 = "\n".join([repr(a) for a in a1]) + "\n"
s2 = "\n".join([repr(a) for a in a2]) + "\n"
self.assertMultiLineEqual(s1, s2, msg)
def check_coverage(self, text, lines=None, missing="", excludes=None,
report="", arcz=None, arcz_missing="", arcz_unpredicted=""):
"""Check the coverage measurement of `text`.
The source `text` is run and measured. `lines` are the line numbers
that are executable, or a list of possible line numbers, any of which
could match. `missing` are the lines not executed, `excludes` are
regexes to match against for excluding lines, and `report` is the text
of the measurement report.
For arc measurement, `arcz` is a string that can be decoded into arcs
in the code (see `arcz_to_arcs` for the encoding scheme),
`arcz_missing` are the arcs that are not executed, and
`arcs_unpredicted` are the arcs executed in the code, but not deducible
from the code.
"""
# We write the code into a file so that we can import it.
# Coverage wants to deal with things as modules with file names.
modname = self.get_module_name()
self.make_file(modname+".py", text)
arcs = arcs_missing = arcs_unpredicted = None
if arcz is not None:
arcs = self.arcz_to_arcs(arcz)
arcs_missing = self.arcz_to_arcs(arcz_missing or "")
arcs_unpredicted = self.arcz_to_arcs(arcz_unpredicted or "")
# Start up Coverage.
cov = coverage.coverage(branch=(arcs_missing is not None))
cov.erase()
for exc in excludes or []:
cov.exclude(exc)
cov.start()
try: # pragma: recursive coverage
# Import the python file, executing it.
mod = self.import_module(modname)
finally: # pragma: recursive coverage
# Stop Coverage.
cov.stop()
# Clean up our side effects
del sys.modules[modname]
# Get the analysis results, and check that they are right.
analysis = cov._analyze(mod)
if lines is not None:
if type(lines[0]) == type(1):
# lines is just a list of numbers, it must match the statements
# found in the code.
self.assertEqual(analysis.statements, lines)
else:
# lines is a list of possible line number lists, one of them
# must match.
for line_list in lines:
if analysis.statements == line_list:
break
else:
self.fail("None of the lines choices matched %r" %
analysis.statements
)
if type(missing) == type(""):
self.assertEqual(analysis.missing_formatted(), missing)
else:
for missing_list in missing:
if analysis.missing_formatted() == missing_list:
break
else:
self.fail("None of the missing choices matched %r" %
analysis.missing_formatted()
)
if arcs is not None:
self.assertEqualArcs(
analysis.arc_possibilities(), arcs, "Possible arcs differ"
)
if arcs_missing is not None:
self.assertEqualArcs(
analysis.arcs_missing(), arcs_missing,
"Missing arcs differ"
)
if arcs_unpredicted is not None:
self.assertEqualArcs(
analysis.arcs_unpredicted(), arcs_unpredicted,
"Unpredicted arcs differ"
)
if report:
frep = StringIO()
cov.report(mod, file=frep)
rep = " ".join(frep.getvalue().split("\n")[2].split()[1:])
self.assertEqual(report, rep)
def nice_file(self, *fparts):
"""Canonicalize the filename composed of the parts in `fparts`."""
fname = os.path.join(*fparts)
return os.path.normcase(os.path.abspath(os.path.realpath(fname)))
def command_line(self, args, ret=OK, _covpkg=None):
"""Run `args` through the command line.
Use this when you want to run the full coverage machinery, but in the
current process. Exceptions may be thrown from deep in the code.
Asserts that `ret` is returned by `CoverageScript.command_line`.
Compare with `run_command`.
Returns None.
"""
script = coverage.CoverageScript(_covpkg=_covpkg)
ret_actual = script.command_line(shlex.split(args))
self.assertEqual(ret_actual, ret)
def run_command(self, cmd):
"""Run the command-line `cmd` in a subprocess, and print its output.
Use this when you need to test the process behavior of coverage.
Compare with `command_line`.
Returns the process' stdout text.
"""
_, output = self.run_command_status(cmd)
return output
def run_command_status(self, cmd, status=0):
"""Run the command-line `cmd` in a subprocess, 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.
The `status` argument is returned as the status on older Pythons where
we can't get the actual exit status of the process.
"""
# 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, 'test/modules')
zipfile = self.nice_file(here, 'test/zipmods.zip')
pypath = self.original_environ('PYTHONPATH', "")
if pypath:
pypath += os.pathsep
pypath += testmods + os.pathsep + zipfile
self.set_environ('PYTHONPATH', pypath)
status, output = run_command(cmd, status=status)
print(output)
return status, output
def check_coverage(self, text, lines=None, missing="", excludes=None,
report="", arcz=None, arcz_missing="", arcz_unpredicted=""):
"""Check the coverage measurement of `text`.
The source `text` is run and measured. `lines` are the line numbers
that are executable, or a list of possible line numbers, any of which
could match. `missing` are the lines not executed, `excludes` are
regexes to match against for excluding lines, and `report` is the text
of the measurement report.
For arc measurement, `arcz` is a string that can be decoded into arcs
in the code (see `arcz_to_arcs` for the encoding scheme),
`arcz_missing` are the arcs that are not executed, and
`arcs_unpredicted` are the arcs executed in the code, but not deducible
from the code.
"""
# We write the code into a file so that we can import it.
# Coverage wants to deal with things as modules with file names.
modname = self.get_module_name()
self.make_file(modname+".py", text)
arcs = arcs_missing = arcs_unpredicted = None
if arcz is not None:
arcs = self.arcz_to_arcs(arcz)
arcs_missing = self.arcz_to_arcs(arcz_missing or "")
arcs_unpredicted = self.arcz_to_arcs(arcz_unpredicted or "")
# Start up Coverage.
cov = coverage.coverage(branch=(arcs_missing is not None))
cov.erase()
for exc in excludes or []:
cov.exclude(exc)
cov.start()
try: # pragma: recursive coverage
# Import the python file, executing it.
mod = self.import_module(modname)
finally: # pragma: recursive coverage
# Stop Coverage.
cov.stop()
# Clean up our side effects
del sys.modules[modname]
# Get the analysis results, and check that they are right.
analysis = cov._analyze(mod)
if lines is not None:
if type(lines[0]) == type(1):
# lines is just a list of numbers, it must match the statements
# found in the code.
self.assertEqual(analysis.statements, lines)
else:
# lines is a list of possible line number lists, one of them
# must match.
for line_list in lines:
if analysis.statements == line_list:
break
else:
self.fail("None of the lines choices matched %r" %
analysis.statements
)
if type(missing) == type(""):
self.assertEqual(analysis.missing_formatted(), missing)
else:
for missing_list in missing:
if analysis.missing_formatted() == missing_list:
break
else:
self.fail("None of the missing choices matched %r" %
analysis.missing_formatted()
)
if arcs is not None:
self.assertEqualArcs(
analysis.arc_possibilities(), arcs, "Possible arcs differ"
)
if arcs_missing is not None:
self.assertEqualArcs(
analysis.arcs_missing(), arcs_missing,
"Missing arcs differ"
)
if arcs_unpredicted is not None:
self.assertEqualArcs(
analysis.arcs_unpredicted(), arcs_unpredicted,
"Unpredicted arcs differ"
)
if report:
frep = StringIO()
cov.report(mod, file=frep)
rep = " ".join(frep.getvalue().split("\n")[2].split()[1:])
self.assertEqual(report, rep)
class CoverageTest(TestCase):
"""A base class for Coverage test cases."""
# Our own setting: most CoverageTests run in their own temp directory.
run_in_temp_dir = True
# Standard unittest setting: show me diffs even if they are very long.
maxDiff = None
def setUp(self):
super(CoverageTest, self).setUp()
if _TEST_NAME_FILE:
f = open(_TEST_NAME_FILE, "w")
f.write("%s_%s" % (self.__class__.__name__, self._testMethodName))
f.close()
# Tell newer unittest implementations to print long helpful messages.
self.longMessage = True
# tearDown will restore the original sys.path
self.old_syspath = sys.path[:]
if self.run_in_temp_dir:
# Create a temporary directory.
self.noise = str(random.random())[2:]
self.temp_root = os.path.join(tempfile.gettempdir(), 'test_cover')
self.temp_dir = os.path.join(self.temp_root, self.noise)
os.makedirs(self.temp_dir)
self.old_dir = os.getcwd()
os.chdir(self.temp_dir)
# Modules should be importable from this temp directory. We don't
# use '' because we make lots of different temp directories and
# nose's caching importer can get confused. The full path prevents
# problems.
sys.path.insert(0, os.getcwd())
# Keep a counter to make every call to check_coverage unique.
self.n = 0
# Record environment variables that we changed with set_environ.
self.environ_undos = {}
# Capture stdout and stderr so we can examine them in tests.
# nose keeps stdout from littering the screen, so we can safely Tee it,
# but it doesn't capture stderr, so we don't want to Tee stderr to the
# real stderr, since it will interfere with our nice field of dots.
self.old_stdout = sys.stdout
self.captured_stdout = StringIO()
sys.stdout = Tee(sys.stdout, self.captured_stdout)
self.old_stderr = sys.stderr
self.captured_stderr = StringIO()
sys.stderr = self.captured_stderr
# Record sys.modules here so we can restore it in tearDown.
self.old_modules = dict(sys.modules)
class_behavior = self.class_behavior()
class_behavior.tests += 1
class_behavior.test_method_made_any_files = False
class_behavior.temp_dir = self.run_in_temp_dir
def tearDown(self):
super(CoverageTest, self).tearDown()
# Restore the original sys.path.
sys.path = self.old_syspath
if self.run_in_temp_dir:
# Get rid of the temporary directory.
os.chdir(self.old_dir)
shutil.rmtree(self.temp_root)
# Restore the environment.
self.undo_environ()
# Restore stdout and stderr
sys.stdout = self.old_stdout
sys.stderr = self.old_stderr
self.clean_modules()
class_behavior = self.class_behavior()
if class_behavior.test_method_made_any_files:
class_behavior.tests_making_files += 1
def clean_modules(self):
"""Remove any new modules imported during the test run.
This lets us import the same source files for more than one test.
"""
for m in [m for m in sys.modules if m not in self.old_modules]:
del sys.modules[m]
def set_environ(self, name, value):
"""Set an environment variable `name` to be `value`.
The environment variable is set, and record is kept that it was set,
so that `tearDown` can restore its original value.
"""
if name not in self.environ_undos:
self.environ_undos[name] = os.environ.get(name)
os.environ[name] = value
def original_environ(self, name, if_missing=None):
"""The environment variable `name` from when the test started."""
if name in self.environ_undos:
ret = self.environ_undos[name]
else:
ret = os.environ.get(name)
if ret is None:
ret = if_missing
return ret
def undo_environ(self):
"""Undo all the changes made by `set_environ`."""
for name, value in self.environ_undos.items():
if value is None:
del os.environ[name]
else:
os.environ[name] = value
def stdout(self):
"""Return the data written to stdout during the test."""
return self.captured_stdout.getvalue()
def stderr(self):
"""Return the data written to stderr during the test."""
return self.captured_stderr.getvalue()
def make_file(self, filename, text="", newline=None):
"""Create a temp file.
`filename` is the path to the file, including directories if desired,
and `text` is the content. If `newline` is provided, it is a string
that will be used as the line endings in the created file.
Returns the path to the file.
"""
# Tests that call `make_file` should be run in a temp environment.
assert self.run_in_temp_dir
self.class_behavior().test_method_made_any_files = True
text = textwrap.dedent(text)
if newline:
text = text.replace("\n", newline)
# Make sure the directories are available.
dirs, _ = os.path.split(filename)
if dirs and not os.path.exists(dirs):
os.makedirs(dirs)
# Create the file.
f = open(filename, 'wb')
try:
f.write(to_bytes(text))
finally:
f.close()
return filename
def clean_local_file_imports(self):
"""Clean up the results of calls to `import_local_file`.
Use this if you need to `import_local_file` the same file twice in
one test.
"""
# So that we can re-import files, clean them out first.
self.clean_modules()
# Also have to clean out the .pyc file, since the timestamp
# resolution is only one second, a changed file might not be
# picked up.
for pyc in glob.glob('*.pyc'):
os.remove(pyc)
if os.path.exists("__pycache__"):
shutil.rmtree("__pycache__")
def import_local_file(self, modname):
"""Import a local file as a module.
Opens a file in the current directory named `modname`.py, imports it
as `modname`, and returns the module object.
"""
modfile = modname + '.py'
f = open(modfile, 'r')
for suff in imp.get_suffixes():
if suff[0] == '.py':
break
try:
# pylint: disable=W0631
# (Using possibly undefined loop variable 'suff')
mod = imp.load_module(modname, f, modfile, suff)
finally:
f.close()
return mod
def start_import_stop(self, cov, modname):
"""Start coverage, import a file, then stop coverage.
`cov` is started and stopped, with an `import_local_file` of
`modname` in the middle.
The imported module is returned.
"""
cov.start()
try: # pragma: nested
# Import the python file, executing it.
mod = self.import_local_file(modname)
finally: # pragma: nested
# Stop Coverage.
cov.stop()
return mod
def get_module_name(self):
"""Return the module name to use for this test run."""
# We append self.n because otherwise two calls in one test will use the
# same filename and whether the test works or not depends on the
# timestamps in the .pyc file, so it becomes random whether the second
# call will use the compiled version of the first call's code or not!
modname = 'coverage_test_' + self.noise + str(self.n)
self.n += 1
return modname
# Map chars to numbers for arcz_to_arcs
_arcz_map = {'.': -1}
_arcz_map.update(dict([(c, ord(c)-ord('0')) for c in '123456789']))
_arcz_map.update(dict(
[(c, 10+ord(c)-ord('A')) for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ']
))
def arcz_to_arcs(self, arcz):
"""Convert a compact textual representation of arcs to a list of pairs.
The text has space-separated pairs of letters. Period is -1, 1-9 are
1-9, A-Z are 10 through 36. The resulting list is sorted regardless of
the order of the input pairs.
".1 12 2." --> [(-1,1), (1,2), (2,-1)]
Minus signs can be included in the pairs:
"-11, 12, 2-5" --> [(-1,1), (1,2), (2,-5)]
"""
arcs = []
for pair in arcz.split():
asgn = bsgn = 1
if len(pair) == 2:
a,b = pair
else:
assert len(pair) == 3
if pair[0] == '-':
_,a,b = pair
asgn = -1
else:
assert pair[1] == '-'
a,_,b = pair
bsgn = -1
arcs.append((asgn*self._arcz_map[a], bsgn*self._arcz_map[b]))
return sorted(arcs)
def assertEqualArcs(self, a1, a2, msg=None):
"""Assert that the arc lists `a1` and `a2` are equal."""
# Make them into multi-line strings so we can see what's going wrong.
s1 = "\n".join([repr(a) for a in a1]) + "\n"
s2 = "\n".join([repr(a) for a in a2]) + "\n"
self.assertMultiLineEqual(s1, s2, msg)
def check_coverage(self, text, lines=None, missing="", report="",
excludes=None, partials="",
arcz=None, arcz_missing="", arcz_unpredicted=""):
"""Check the coverage measurement of `text`.
The source `text` is run and measured. `lines` are the line numbers
that are executable, or a list of possible line numbers, any of which
could match. `missing` are the lines not executed, `excludes` are
regexes to match against for excluding lines, and `report` is the text
of the measurement report.
For arc measurement, `arcz` is a string that can be decoded into arcs
in the code (see `arcz_to_arcs` for the encoding scheme),
`arcz_missing` are the arcs that are not executed, and
`arcs_unpredicted` are the arcs executed in the code, but not deducible
from the code.
"""
# We write the code into a file so that we can import it.
# Coverage wants to deal with things as modules with file names.
modname = self.get_module_name()
self.make_file(modname+".py", text)
arcs = arcs_missing = arcs_unpredicted = None
if arcz is not None:
arcs = self.arcz_to_arcs(arcz)
arcs_missing = self.arcz_to_arcs(arcz_missing or "")
arcs_unpredicted = self.arcz_to_arcs(arcz_unpredicted or "")
# Start up Coverage.
cov = coverage.coverage(branch=(arcs_missing is not None))
cov.erase()
for exc in excludes or []:
cov.exclude(exc)
for par in partials or []:
cov.exclude(par, which='partial')
mod = self.start_import_stop(cov, modname)
# Clean up our side effects
del sys.modules[modname]
# Get the analysis results, and check that they are right.
analysis = cov._analyze(mod)
statements = sorted(analysis.statements)
if lines is not None:
if type(lines[0]) == type(1):
# lines is just a list of numbers, it must match the statements
# found in the code.
self.assertEqual(statements, lines)
else:
# lines is a list of possible line number lists, one of them
# must match.
for line_list in lines:
if statements == line_list:
break
else:
self.fail("None of the lines choices matched %r" %
statements
)
if type(missing) == type(""):
self.assertEqual(analysis.missing_formatted(), missing)
else:
for missing_list in missing:
if analysis.missing_formatted() == missing_list:
break
else:
self.fail("None of the missing choices matched %r" %
analysis.missing_formatted()
)
if arcs is not None:
self.assertEqualArcs(
analysis.arc_possibilities(), arcs, "Possible arcs differ"
)
if arcs_missing is not None:
self.assertEqualArcs(
analysis.arcs_missing(), arcs_missing,
"Missing arcs differ"
)
if arcs_unpredicted is not None:
self.assertEqualArcs(
analysis.arcs_unpredicted(), arcs_unpredicted,
"Unpredicted arcs differ"
)
if report:
frep = StringIO()
cov.report(mod, file=frep)
rep = " ".join(frep.getvalue().split("\n")[2].split()[1:])
self.assertEqual(report, rep)
def nice_file(self, *fparts):
"""Canonicalize the filename composed of the parts in `fparts`."""
fname = os.path.join(*fparts)
return os.path.normcase(os.path.abspath(os.path.realpath(fname)))
def assert_same_files(self, flist1, flist2):
"""Assert that `flist1` and `flist2` are the same set of file names."""
flist1_nice = [self.nice_file(f) for f in flist1]
flist2_nice = [self.nice_file(f) for f in flist2]
self.assertSameElements(flist1_nice, flist2_nice)
def assert_exists(self, fname):
"""Assert that `fname` is a file that exists."""
msg = "File %r should exist" % fname
self.assert_(os.path.exists(fname), msg)
def assert_doesnt_exist(self, fname):
"""Assert that `fname` is a file that doesn't exist."""
msg = "File %r shouldn't exist" % fname
self.assert_(not os.path.exists(fname), msg)
def command_line(self, args, ret=OK, _covpkg=None):
"""Run `args` through the command line.
Use this when you want to run the full coverage machinery, but in the
current process. Exceptions may be thrown from deep in the code.
Asserts that `ret` is returned by `CoverageScript.command_line`.
Compare with `run_command`.
Returns None.
"""
script = coverage.CoverageScript(_covpkg=_covpkg)
ret_actual = script.command_line(shlex.split(args))
self.assertEqual(ret_actual, ret)
def run_command(self, cmd):
"""Run the command-line `cmd` in a subprocess, and print its output.
Use this when you need to test the process behavior of coverage.
Compare with `command_line`.
Returns the process' stdout text.
"""
# Running Python subprocesses 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.
if cmd.startswith("python "):
cmd = os.path.basename(sys.executable) + cmd[6:]
_, output = self.run_command_status(cmd)
return output
def run_command_status(self, cmd, status=0):
"""Run the command-line `cmd` in a subprocess, 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.
The `status` argument is returned as the status on older Pythons where
we can't get the actual exit status of the process.
"""
# 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)
status, output = run_command(cmd, status=status)
print(output)
return status, output
# We run some tests in temporary directories, because they may need to make
# files for the tests. But this is expensive, so we can change per-class
# whether a temp dir is used or not. It's easy to forget to set that
# option properly, so we track information about what the tests did, and
# then report at the end of the process on test classes that were set
# wrong.
class ClassBehavior(object):
"""A value object to store per-class in CoverageTest."""
def __init__(self):
self.tests = 0
self.temp_dir = True
self.tests_making_files = 0
self.test_method_made_any_files = False
# Map from class to info about how it ran.
class_behaviors = {}
def report_on_class_behavior(cls):
"""Called at process exit to report on class behavior."""
for test_class, behavior in cls.class_behaviors.items():
if behavior.temp_dir and behavior.tests_making_files == 0:
bad = "Inefficient"
elif not behavior.temp_dir and behavior.tests_making_files > 0:
bad = "Unsafe"
else:
bad = ""
if bad:
if behavior.temp_dir:
where = "in a temp directory"
else:
where = "without a temp directory"
print(
"%s: %s ran %d tests, %d made files %s" % (
bad,
test_class.__name__,
behavior.tests,
behavior.tests_making_files,
where,
)
)
report_on_class_behavior = classmethod(report_on_class_behavior)
def class_behavior(self):
"""Get the ClassBehavior instance for this test."""
cls = self.__class__
if cls not in self.class_behaviors:
self.class_behaviors[cls] = self.ClassBehavior()
return self.class_behaviors[cls]
def check_coverage(
self, text, lines=None, missing="", report="",
excludes=None, partials="",
arcz=None, arcz_missing="", arcz_unpredicted="",
arcs=None, arcs_missing=None, arcs_unpredicted=None,
):
"""Check the coverage measurement of `text`.
The source `text` is run and measured. `lines` are the line numbers
that are executable, or a list of possible line numbers, any of which
could match. `missing` are the lines not executed, `excludes` are
regexes to match against for excluding lines, and `report` is the text
of the measurement report.
For arc measurement, `arcz` is a string that can be decoded into arcs
in the code (see `arcz_to_arcs` for the encoding scheme).
`arcz_missing` are the arcs that are not executed, and
`arcz_unpredicted` are the arcs executed in the code, but not deducible
from the code. These last two default to "", meaning we explicitly
check that there are no missing or unpredicted arcs.
Returns the Coverage object, in case you want to poke at it some more.
"""
# We write the code into a file so that we can import it.
# Coverage.py wants to deal with things as modules with file names.
modname = self.get_module_name()
self.make_file(modname + ".py", text)
if arcs is None and arcz is not None:
arcs = self.arcz_to_arcs(arcz)
if arcs_missing is None:
arcs_missing = self.arcz_to_arcs(arcz_missing)
if arcs_unpredicted is None:
arcs_unpredicted = self.arcz_to_arcs(arcz_unpredicted)
# Start up coverage.py.
cov = coverage.Coverage(branch=True)
cov.erase()
for exc in excludes or []:
cov.exclude(exc)
for par in partials or []:
cov.exclude(par, which='partial')
mod = self.start_import_stop(cov, modname)
# Clean up our side effects
del sys.modules[modname]
# Get the analysis results, and check that they are right.
analysis = cov._analyze(mod)
statements = sorted(analysis.statements)
if lines is not None:
if isinstance(lines[0], int):
# lines is just a list of numbers, it must match the statements
# found in the code.
self.assertEqual(statements, lines)
else:
# lines is a list of possible line number lists, one of them
# must match.
for line_list in lines:
if statements == line_list:
break
else:
self.fail("None of the lines choices matched %r" % statements)
missing_formatted = analysis.missing_formatted()
if isinstance(missing, string_class):
self.assertEqual(missing_formatted, missing)
else:
for missing_list in missing:
if missing_formatted == missing_list:
break
else:
self.fail("None of the missing choices matched %r" % missing_formatted)
if arcs is not None:
with self.delayed_assertions():
self.assert_equal_args(
analysis.arc_possibilities(), arcs,
"Possible arcs differ",
)
self.assert_equal_args(
analysis.arcs_missing(), arcs_missing,
"Missing arcs differ"
)
self.assert_equal_args(
analysis.arcs_unpredicted(), arcs_unpredicted,
"Unpredicted arcs differ"
)
if report:
frep = StringIO()
cov.report(mod, file=frep, show_missing=True)
rep = " ".join(frep.getvalue().split("\n")[2].split()[1:])
self.assertEqual(report, rep)
return cov
