# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
"""Tests for plugins."""
from __future__ import annotations
import inspect
import io
import math
import os.path
from typing import Any, Iterable
from xml.etree import ElementTree
import pytest
import coverage
from coverage import Coverage
from coverage.plugin_support import Plugins
from coverage.data import line_counts, sorted_lines
from coverage.exceptions import CoverageWarning, NoSource, PluginError
from coverage.misc import import_local_file
from coverage.types import TConfigSectionOut, TLineNo, TPluginConfig
import coverage.plugin
from tests import testenv
from tests.coveragetest import CoverageTest
from tests.helpers import CheckUniqueFilenames, swallow_warnings
class NullConfig(TPluginConfig):
"""A plugin configure thing when we don't really need one."""
def get_plugin_options(self, plugin: str) -> TConfigSectionOut:
return {} # pragma: never called
class FakeConfig(TPluginConfig):
"""A fake config for use in tests."""
def __init__(self, plugin: str, options: dict[str, Any]) -> None:
self.plugin = plugin
self.options = options
self.asked_for: list[str] = []
def get_plugin_options(self, plugin: str) -> TConfigSectionOut:
"""Just return the options for `plugin` if this is the right module."""
self.asked_for.append(plugin)
if plugin == self.plugin:
return self.options
else:
return {}
def make_plugins(
modules: Iterable[str],
config: TPluginConfig,
) -> Plugins:
"""Construct a Plugins and call plugins.load_from_config() for convenience."""
plugins = Plugins()
plugins.load_from_config(modules, config)
return plugins
class LoadPluginsTest(CoverageTest):
"""Test Plugins construction."""
def test_implicit_boolean(self) -> None:
self.make_file("plugin1.py", """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
config = FakeConfig("plugin1", {})
plugins = make_plugins([], config)
assert not plugins
plugins = make_plugins(["plugin1"], config)
assert plugins
def test_importing_and_configuring(self) -> None:
self.make_file("plugin1.py", """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
def __init__(self, options):
self.options = options
self.this_is = "me"
def coverage_init(reg, options):
reg.add_file_tracer(Plugin(options))
""")
config = FakeConfig("plugin1", {'a': 'hello'})
plugins = list(make_plugins(["plugin1"], config))
assert len(plugins) == 1
assert plugins[0].this_is == "me" # type: ignore
assert plugins[0].options == {'a': 'hello'} # type: ignore
assert config.asked_for == ['plugin1']
def test_importing_and_configuring_more_than_one(self) -> None:
self.make_file("plugin1.py", """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
def __init__(self, options):
self.options = options
self.this_is = "me"
def coverage_init(reg, options):
reg.add_file_tracer(Plugin(options))
""")
self.make_file("plugin2.py", """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
def __init__(self, options):
self.options = options
def coverage_init(reg, options):
reg.add_file_tracer(Plugin(options))
""")
config = FakeConfig("plugin1", {'a': 'hello'})
plugins = list(make_plugins(["plugin1", "plugin2"], config))
assert len(plugins) == 2
assert plugins[0].this_is == "me" # type: ignore
assert plugins[0].options == {'a': 'hello'} # type: ignore
assert plugins[1].options == {} # type: ignore
assert config.asked_for == ['plugin1', 'plugin2']
# The order matters...
config = FakeConfig("plugin1", {'a': 'second'})
plugins = list(make_plugins(["plugin2", "plugin1"], config))
assert len(plugins) == 2
assert plugins[0].options == {} # type: ignore
assert plugins[1].this_is == "me" # type: ignore
assert plugins[1].options == {'a': 'second'} # type: ignore
def test_cant_import(self) -> None:
with pytest.raises(ImportError, match="No module named '?plugin_not_there'?"):
_ = make_plugins(["plugin_not_there"], NullConfig())
def test_plugin_must_define_coverage_init(self) -> None:
self.make_file("no_plugin.py", """\
from coverage import CoveragePlugin
Nothing = 0
""")
msg_pat = "Plugin module 'no_plugin' didn't define a coverage_init function"
with pytest.raises(PluginError, match=msg_pat):
list(make_plugins(["no_plugin"], NullConfig()))
class PluginTest(CoverageTest):
"""Test plugins through the Coverage class."""
def test_plugin_imported(self) -> None:
# Prove that a plugin will be imported.
self.make_file("my_plugin.py", """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_noop(Plugin())
with open("evidence.out", "w", encoding="utf-8") as f:
f.write("we are here!")
""")
self.assert_doesnt_exist("evidence.out")
cov = coverage.Coverage()
cov.set_option("run:plugins", ["my_plugin"])
cov.start()
cov.stop() # pragma: nested
with open("evidence.out", encoding="utf-8") as f:
assert f.read() == "we are here!"
def test_missing_plugin_raises_import_error(self) -> None:
# Prove that a missing plugin will raise an ImportError.
with pytest.raises(ImportError, match="No module named '?does_not_exist_woijwoicweo'?"):
cov = coverage.Coverage()
cov.set_option("run:plugins", ["does_not_exist_woijwoicweo"])
cov.start()
cov.stop()
def test_bad_plugin_isnt_hidden(self) -> None:
# Prove that a plugin with an error in it will raise the error.
self.make_file("plugin_over_zero.py", "1/0")
with pytest.raises(ZeroDivisionError):
cov = coverage.Coverage()
cov.set_option("run:plugins", ["plugin_over_zero"])
cov.start()
cov.stop()
def test_plugin_sys_info(self) -> None:
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 = io.StringIO()
cov = coverage.Coverage(debug=["sys"])
cov._debug_file = debug_out
cov.set_option("run:plugins", ["plugin_sys_info"])
with swallow_warnings(
r"Plugin file tracers \(plugin_sys_info.Plugin\) aren't supported with .*",
):
cov.start()
cov.stop() # pragma: nested
out_lines = [line.strip() for line in debug_out.getvalue().splitlines()]
if testenv.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_with_no_sys_info(self) -> None:
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 = io.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()]
assert 'plugins.file_tracers: -none-' in out_lines
assert 'plugins.configurers: plugin_no_sys_info.Plugin' in out_lines
expected_end = [
"-- sys: plugin_no_sys_info.Plugin ----------------------------",
"-- end -------------------------------------------------------",
]
assert expected_end == out_lines[-len(expected_end):]
def test_local_files_are_importable(self) -> None:
self.make_file("importing_plugin.py", """\
from coverage import CoveragePlugin
import local_module
class MyPlugin(CoveragePlugin):
pass
def coverage_init(reg, options):
reg.add_noop(MyPlugin())
""")
self.make_file("local_module.py", "CONST = 1")
self.make_file(".coveragerc", """\
[run]
plugins = importing_plugin
""")
self.make_file("main_file.py", "print('MAIN')")
out = self.run_command("coverage run main_file.py")
assert out == "MAIN\n"
out = self.run_command("coverage html -q") # sneak in a test of -q
assert out == ""
def test_coverage_init_plugins(self) -> None:
called = False
def coverage_init(reg: Plugins) -> None: # pylint: disable=unused-argument
nonlocal called
called = True
cov = coverage.Coverage(plugins=[coverage_init])
# Calls _init() and loads plugins
cov.sys_info()
assert called
@pytest.mark.skipif(testenv.PLUGINS, reason="This core doesn't support plugins.")
class PluginWarningOnPyTracerTest(CoverageTest):
"""Test that we get a controlled exception when plugins aren't supported."""
def test_exception_if_plugins_on_pytracer(self) -> None:
self.make_file("simple.py", "a = 1")
cov = coverage.Coverage()
cov.set_option("run:plugins", ["tests.plugin1"])
if testenv.PY_TRACER:
core = "PyTracer"
else:
assert testenv.SYS_MON
core = "SysMonitor"
expected_warnings = [
fr"Plugin file tracers \(tests.plugin1.Plugin\) aren't supported with {core}",
]
with self.assert_warnings(cov, expected_warnings):
self.start_import_stop(cov, "simple")
@pytest.mark.skipif(not testenv.PLUGINS, reason="Plugins are not supported with this core.")
class FileTracerTest(CoverageTest):
"""Tests of plugins that implement file_tracer."""
class GoodFileTracerTest(FileTracerTest):
"""Tests of file tracer plugin happy paths."""
def test_plugin1(self) -> None:
self.make_file("simple.py", """\
import try_xyz
a = 1
b = 2
""")
self.make_file("try_xyz.py", """\
c = 3
d = 4
""")
cov = coverage.Coverage()
CheckUniqueFilenames.hook(cov, '_should_trace')
CheckUniqueFilenames.hook(cov, '_check_include_omit_etc')
cov.set_option("run:plugins", ["tests.plugin1"])
# Import the Python file, executing it.
self.start_import_stop(cov, "simple")
_, statements, missing, _ = cov.analysis("simple.py")
assert statements == [1, 2, 3]
assert missing == []
zzfile = os.path.abspath(os.path.join("/src", "try_ABC.zz"))
_, statements, _, _ = cov.analysis(zzfile)
assert statements == [105, 106, 107, 205, 206, 207]
def make_render_and_caller(self) -> None:
"""Make the render.py and caller.py files we need."""
# plugin2 emulates a dynamic tracing plugin: the caller's locals
# are examined to determine the source file and line number.
# The plugin is in tests/plugin2.py.
self.make_file("render.py", """\
def render(filename, linenum):
# This function emulates a template renderer. The plugin
# will examine the `filename` and `linenum` locals to
# determine the source file and line number.
fiddle_around = 1 # not used, just chaff.
return "[{} @ {}]".format(filename, linenum)
def helper(x):
# This function is here just to show that not all code in
# this file will be part of the dynamic tracing.
return x+1
""")
self.make_file("caller.py", """\
import sys
from render import helper, render
assert render("foo_7.html", 4) == "[foo_7.html @ 4]"
# Render foo_7.html again to try the CheckUniqueFilenames asserts.
render("foo_7.html", 4)
assert helper(42) == 43
assert render("bar_4.html", 2) == "[bar_4.html @ 2]"
assert helper(76) == 77
# quux_5.html will be omitted from the results.
assert render("quux_5.html", 3) == "[quux_5.html @ 3]"
""")
# will try to read the actual source files, so make some
# source files.
def lines(n: int) -> str:
"""Make a string with n lines of text."""
return "".join("line %d\n" % i for i in range(n))
self.make_file("bar_4.html", lines(4))
self.make_file("foo_7.html", lines(7))
def test_plugin2(self) -> None:
self.make_render_and_caller()
cov = coverage.Coverage(omit=["*quux*"])
CheckUniqueFilenames.hook(cov, '_should_trace')
CheckUniqueFilenames.hook(cov, '_check_include_omit_etc')
cov.set_option("run:plugins", ["tests.plugin2"])
self.start_import_stop(cov, "caller")
# The way plugin2 works, a file named foo_7.html will be claimed to
# have 7 lines in it. If render() was called with line number 4,
# then the plugin will claim that lines 4 and 5 were executed.
_, statements, missing, _ = cov.analysis("foo_7.html")
assert statements == [1, 2, 3, 4, 5, 6, 7]
assert missing == [1, 2, 3, 6, 7]
assert "foo_7.html" in line_counts(cov.get_data())
_, statements, missing, _ = cov.analysis("bar_4.html")
assert statements == [1, 2, 3, 4]
assert missing == [1, 4]
assert "bar_4.html" in line_counts(cov.get_data())
assert "quux_5.html" not in line_counts(cov.get_data())
def test_plugin2_with_branch(self) -> None:
self.make_render_and_caller()
cov = coverage.Coverage(branch=True, omit=["*quux*"])
CheckUniqueFilenames.hook(cov, '_should_trace')
CheckUniqueFilenames.hook(cov, '_check_include_omit_etc')
cov.set_option("run:plugins", ["tests.plugin2"])
self.start_import_stop(cov, "caller")
# The way plugin2 works, a file named foo_7.html will be claimed to
# have 7 lines in it. If render() was called with line number 4,
# then the plugin will claim that lines 4 and 5 were executed.
analysis = cov._analyze("foo_7.html")
assert analysis.statements == {1, 2, 3, 4, 5, 6, 7}
# Plugins don't do branch coverage yet.
assert analysis.has_arcs is True
assert analysis.arc_possibilities == []
assert analysis.missing == {1, 2, 3, 6, 7}
def test_plugin2_with_text_report(self) -> None:
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 = io.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%',
]
assert expected == report
assert math.isclose(total, 4 / 11 * 100)
def test_plugin2_with_html_report(self) -> None:
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")
total = cov.html_report(include=["*.html"], omit=["uni*.html"])
assert math.isclose(total, 4 / 11 * 100)
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/bar_4_html.html")
self.assert_exists("htmlcov/foo_7_html.html")
def test_plugin2_with_xml_report(self) -> None:
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")
total = cov.xml_report(include=["*.html"], omit=["uni*.html"])
assert math.isclose(total, 4 / 11 * 100)
dom = ElementTree.parse("coverage.xml")
classes = {}
for elt in dom.findall(".//class"):
classes[elt.get('name')] = elt
assert classes['bar_4.html'].attrib == {
'branch-rate': '1',
'complexity': '0',
'filename': 'bar_4.html',
'line-rate': '0.5',
'name': 'bar_4.html',
}
assert classes['foo_7.html'].attrib == {
'branch-rate': '1',
'complexity': '0',
'filename': 'foo_7.html',
'line-rate': '0.2857',
'name': 'foo_7.html',
}
def test_defer_to_python(self) -> None:
# 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 = io.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 test_find_unexecuted(self) -> None:
self.make_file("unexecuted_plugin.py", """\
import os
import coverage.plugin
class Plugin(coverage.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("foo.py"):
return MyTracer(filename)
def file_reporter(self, filename):
return MyReporter(filename)
def find_executable_files(self, src_dir):
# Check that src_dir is the right value
files = os.listdir(src_dir)
assert "foo.py" in files
assert "unexecuted_plugin.py" in files
return ["chimera.py"]
class MyTracer(coverage.plugin.FileTracer):
def __init__(self, filename):
self.filename = filename
def source_filename(self):
return self.filename
def line_number_range(self, frame):
return (999, 999)
class MyReporter(coverage.FileReporter):
def lines(self):
return {99, 999, 9999}
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.make_file("foo.py", "a = 1")
cov = coverage.Coverage(source=['.'])
cov.set_option("run:plugins", ["unexecuted_plugin"])
self.start_import_stop(cov, "foo")
# The file we executed claims to have run line 999.
_, statements, missing, _ = cov.analysis("foo.py")
assert statements == [99, 999, 9999]
assert missing == [99, 9999]
# The completely missing file is in the results.
_, statements, missing, _ = cov.analysis("chimera.py")
assert statements == [99, 999, 9999]
assert missing == [99, 999, 9999]
# But completely new filenames are not in the results.
assert len(cov.get_data().measured_files()) == 3
with pytest.raises(NoSource):
cov.analysis("fictional.py")
class BadFileTracerTest(FileTracerTest):
"""Test error handling around file tracer plugins."""
def run_plugin(self, module_name: str) -> Coverage:
"""Run a plugin with the given module_name.
Uses a few fixed Python files.
Returns the Coverage object.
"""
self.make_file("simple.py", """\
import other, another
a = other.f(2)
b = other.f(3)
c = another.g(4)
d = another.g(5)
""")
# The names of these files are important: some plugins apply themselves
# to "*other.py".
self.make_file("other.py", """\
def f(x):
return x+1
""")
self.make_file("another.py", """\
def g(x):
return x-1
""")
cov = coverage.Coverage()
cov.set_option("run:plugins", [module_name])
self.start_import_stop(cov, "simple")
cov.save() # pytest-cov does a save after stop, so we'll do it too.
return cov
def run_bad_plugin(
self,
module_name: str,
plugin_name: str,
our_error: bool = True,
excmsg: str | None = None,
excmsgs: list[str] | None = None,
) -> None:
"""Run a file, and see that the plugin failed.
`module_name` and `plugin_name` is the module and name of the plugin to
use.
`our_error` is True if the error reported to the user will be an
explicit error in our test code, marked with an '# Oh noes!' comment.
`excmsg`, if provided, is text that must appear in the stderr.
`excmsgs`, if provided, is a list of messages, one of which must
appear in the stderr.
The plugin will be disabled, and we check that a warning is output
explaining why.
"""
with pytest.warns(Warning) as warns:
self.run_plugin(module_name)
stderr = self.stderr()
stderr += "".join(str(w.message) for w in warns)
if our_error:
# The exception we're causing should only appear once.
assert stderr.count("# Oh noes!") == 1
# There should be a warning explaining what's happening, but only one.
# The message can be in two forms:
# Disabling plug-in '...' due to previous exception
# or:
# Disabling plug-in '...' due to an exception:
print([str(w) for w in warns.list])
warnings = [w for w in warns.list if issubclass(w.category, CoverageWarning)]
assert len(warnings) == 1
warnmsg = str(warnings[0].message)
assert f"Disabling plug-in '{module_name}.{plugin_name}' due to " in warnmsg
if excmsg:
assert excmsg in stderr
if excmsgs:
found_exc = any(em in stderr for em in excmsgs) # pragma: part covered
assert found_exc, f"expected one of {excmsgs} in stderr"
def test_file_tracer_has_no_file_tracer_method(self) -> None:
self.make_file("bad_plugin.py", """\
class Plugin(object):
pass
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin", our_error=False)
def test_file_tracer_has_inherited_sourcefilename_method(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
def file_tracer(self, filename):
# Just grab everything.
return FileTracer()
class FileTracer(coverage.FileTracer):
pass
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False,
excmsg="Class 'bad_plugin.FileTracer' needs to implement source_filename()",
)
def test_plugin_has_inherited_filereporter_method(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage
class Plugin(coverage.CoveragePlugin):
def file_tracer(self, filename):
# Just grab everything.
return FileTracer()
class FileTracer(coverage.FileTracer):
def source_filename(self):
return "foo.xxx"
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
cov = self.run_plugin("bad_plugin")
expected_msg = "Plugin 'bad_plugin.Plugin' needs to implement file_reporter()"
with pytest.raises(NotImplementedError, match=expected_msg):
cov.report()
def test_file_tracer_fails(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
17/0 # Oh noes!
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin")
def test_file_tracer_fails_eventually(self) -> None:
# Django coverage plugin can report on a few files and then fail.
# https://github.com/nedbat/coveragepy/issues/1011
self.make_file("bad_plugin.py", """\
import os.path
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def __init__(self):
self.calls = 0
def file_tracer(self, filename):
print(filename)
self.calls += 1
if self.calls <= 2:
return FileTracer(filename)
else:
17/0 # Oh noes!
class FileTracer(coverage.FileTracer):
def __init__(self, filename):
self.filename = filename
def source_filename(self):
return os.path.basename(self.filename).replace(".py", ".foo")
def line_number_range(self, frame):
return -1, -1
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin")
def test_file_tracer_returns_wrong(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
return 3.14159
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False, excmsg="'float' object has no attribute",
)
def test_has_dynamic_source_filename_fails(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def has_dynamic_source_filename(self):
23/0 # Oh noes!
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin")
def test_source_filename_fails(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
42/0 # Oh noes!
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin")
def test_source_filename_returns_wrong(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
return 17.3
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False,
excmsgs=[
"expected str, bytes or os.PathLike object, not float",
"'float' object has no attribute",
"object of type 'float' has no len()",
"'float' object is unsubscriptable",
],
)
def test_dynamic_source_filename_fails(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("other.py"):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def has_dynamic_source_filename(self):
return True
def dynamic_source_filename(self, filename, frame):
101/0 # Oh noes!
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin("bad_plugin", "Plugin")
def test_line_number_range_raises_error(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("other.py"):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
return "something.foo"
def line_number_range(self, frame):
raise Exception("borked!")
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False, excmsg="borked!",
)
def test_line_number_range_returns_non_tuple(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("other.py"):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
return "something.foo"
def line_number_range(self, frame):
return 42.23
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False, excmsg="line_number_range must return 2-tuple",
)
def test_line_number_range_returns_triple(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("other.py"):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
return "something.foo"
def line_number_range(self, frame):
return (1, 2, 3)
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False, excmsg="line_number_range must return 2-tuple",
)
def test_line_number_range_returns_pair_of_strings(self) -> None:
self.make_file("bad_plugin.py", """\
import coverage.plugin
class Plugin(coverage.plugin.CoveragePlugin):
def file_tracer(self, filename):
if filename.endswith("other.py"):
return BadFileTracer()
class BadFileTracer(coverage.plugin.FileTracer):
def source_filename(self):
return "something.foo"
def line_number_range(self, frame):
return ("5", "7")
def coverage_init(reg, options):
reg.add_file_tracer(Plugin())
""")
self.run_bad_plugin(
"bad_plugin", "Plugin", our_error=False,
excmsgs=[
"an integer is required",
"cannot be interpreted as an integer",
],
)
class ConfigurerPluginTest(CoverageTest):
"""Test configuring plugins."""
run_in_temp_dir = False
def test_configurer_plugin(self) -> None:
cov = coverage.Coverage()
cov.set_option("run:plugins", ["tests.plugin_config"])
cov.start()
cov.stop() # pragma: nested
excluded = cov.get_option("report:exclude_lines")
assert isinstance(excluded, list)
assert "pragma: custom" in excluded
assert "pragma: or whatever" in excluded
@pytest.mark.skipif(not testenv.DYN_CONTEXTS, reason="No dynamic contexts with this core")
class DynamicContextPluginTest(CoverageTest):
"""Tests of plugins that implement `dynamic_context`."""
def make_plugin_capitalized_testnames(self, filename: str) -> None:
"""Create a dynamic context plugin that capitalizes the part after 'test_'."""
self.make_file(filename, """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
def dynamic_context(self, frame):
name = frame.f_code.co_name
if name.startswith(("test_", "doctest_")):
parts = name.split("_", 1)
return "%s:%s" % (parts[0], parts[1].upper())
return None
def coverage_init(reg, options):
reg.add_dynamic_context(Plugin())
""")
def make_plugin_track_render(self, filename: str) -> None:
"""Make a dynamic context plugin that tracks 'render_' functions."""
self.make_file(filename, """\
from coverage import CoveragePlugin
class Plugin(CoveragePlugin):
def dynamic_context(self, frame):
name = frame.f_code.co_name
if name.startswith("render_"):
return 'renderer:' + name[7:]
return None
def coverage_init(reg, options):
reg.add_dynamic_context(Plugin())
""")
def make_test_files(self) -> None:
"""Make some files to use while testing dynamic context plugins."""
self.make_file("rendering.py", """\
def html_tag(tag, content):
return f'<{tag}>{content}'
def render_paragraph(text):
return html_tag('p', text)
def render_span(text):
return html_tag('span', text)
def render_bold(text):
return html_tag('b', text)
""")
self.make_file("testsuite.py", """\
import rendering
def test_html_tag() -> None:
assert rendering.html_tag('b', 'hello') == 'hello'
def doctest_html_tag():
assert eval('''
rendering.html_tag('i', 'text') == 'text'
'''.strip())
def test_renderers() -> None:
assert rendering.render_paragraph('hello') == 'hello
'
assert rendering.render_bold('wide') == 'wide'
assert rendering.render_span('world') == 'world'
def build_full_html():
html = '%s' % (
rendering.render_paragraph(
rendering.render_span('hello')))
return html
""")
def run_all_functions(self, cov: Coverage, suite_name: str) -> None: # pragma: nested
"""Run all functions in `suite_name` under coverage."""
cov.start()
suite = import_local_file(suite_name)
try:
# Call all functions in this module
for name in dir(suite):
variable = getattr(suite, name)
if inspect.isfunction(variable):
variable()
finally:
cov.stop()
def test_plugin_standalone(self) -> None:
self.make_plugin_capitalized_testnames('plugin_tests.py')
self.make_test_files()
# Enable dynamic context plugin
cov = coverage.Coverage()
cov.set_option("run:plugins", ['plugin_tests'])
# Run the tests
self.run_all_functions(cov, 'testsuite')
# Labeled coverage is collected
data = cov.get_data()
filenames = self.get_measured_filenames(data)
expected = ['', 'doctest:HTML_TAG', 'test:HTML_TAG', 'test:RENDERERS']
assert expected == sorted(data.measured_contexts())
data.set_query_context("doctest:HTML_TAG")
assert [2] == sorted_lines(data, filenames['rendering.py'])
data.set_query_context("test:HTML_TAG")
assert [2] == sorted_lines(data, filenames['rendering.py'])
data.set_query_context("test:RENDERERS")
assert [2, 5, 8, 11] == sorted_lines(data, filenames['rendering.py'])
def test_static_context(self) -> None:
self.make_plugin_capitalized_testnames('plugin_tests.py')
self.make_test_files()
# Enable dynamic context plugin for coverage with named context
cov = coverage.Coverage(context='mytests')
cov.set_option("run:plugins", ['plugin_tests'])
# Run the tests
self.run_all_functions(cov, 'testsuite')
# Static context prefix is preserved
data = cov.get_data()
expected = [
'mytests',
'mytests|doctest:HTML_TAG',
'mytests|test:HTML_TAG',
'mytests|test:RENDERERS',
]
assert expected == sorted(data.measured_contexts())
def test_plugin_with_test_function(self) -> None:
self.make_plugin_capitalized_testnames('plugin_tests.py')
self.make_test_files()
# Enable both a plugin and test_function dynamic context
cov = coverage.Coverage()
cov.set_option("run:plugins", ['plugin_tests'])
cov.set_option("run:dynamic_context", "test_function")
# Run the tests
self.run_all_functions(cov, 'testsuite')
# test_function takes precedence over plugins - only
# functions that are not labeled by test_function are
# labeled by plugin_tests.
data = cov.get_data()
filenames = self.get_measured_filenames(data)
expected = [
'',
'doctest:HTML_TAG',
'testsuite.test_html_tag',
'testsuite.test_renderers',
]
assert expected == sorted(data.measured_contexts())
def assert_context_lines(context: str, lines: list[TLineNo]) -> None:
data.set_query_context(context)
assert lines == sorted_lines(data, filenames['rendering.py'])
assert_context_lines("doctest:HTML_TAG", [2])
assert_context_lines("testsuite.test_html_tag", [2])
assert_context_lines("testsuite.test_renderers", [2, 5, 8, 11])
def test_multiple_plugins(self) -> None:
self.make_plugin_capitalized_testnames('plugin_tests.py')
self.make_plugin_track_render('plugin_renderers.py')
self.make_test_files()
# Enable two plugins
cov = coverage.Coverage()
cov.set_option("run:plugins", ['plugin_renderers', 'plugin_tests'])
self.run_all_functions(cov, 'testsuite')
# It is important to note, that line 11 (render_bold function) is never
# labeled as renderer:bold context, because it is only called from
# test_renderers function - so it already falls under test:RENDERERS
# context.
#
# render_paragraph and render_span (lines 5, 8) are directly called by
# testsuite.build_full_html, so they get labeled by renderers plugin.
data = cov.get_data()
filenames = self.get_measured_filenames(data)
expected = [
'',
'doctest:HTML_TAG',
'renderer:paragraph',
'renderer:span',
'test:HTML_TAG',
'test:RENDERERS',
]
assert expected == sorted(data.measured_contexts())
def assert_context_lines(context: str, lines: list[TLineNo]) -> None:
data.set_query_context(context)
assert lines == sorted_lines(data, filenames['rendering.py'])
assert_context_lines("test:HTML_TAG", [2])
assert_context_lines("test:RENDERERS", [2, 5, 8, 11])
assert_context_lines("doctest:HTML_TAG", [2])
assert_context_lines("renderer:paragraph", [2, 5])
assert_context_lines("renderer:span", [2, 8])