475 lines
16 KiB
Python
475 lines
16 KiB
Python
"""Coverage plugin for pytest."""
|
|
|
|
import argparse
|
|
import os
|
|
import re
|
|
import warnings
|
|
from io import StringIO
|
|
from pathlib import Path
|
|
from typing import TYPE_CHECKING
|
|
|
|
import coverage
|
|
import pytest
|
|
from coverage.exceptions import CoverageWarning
|
|
from coverage.results import display_covered
|
|
from coverage.results import should_fail_under
|
|
|
|
from . import CovDisabledWarning
|
|
from . import CovReportWarning
|
|
from . import PytestCovWarning
|
|
from . import compat
|
|
from . import embed
|
|
|
|
if TYPE_CHECKING:
|
|
from .engine import CovController
|
|
|
|
COVERAGE_SQLITE_WARNING_RE = re.compile('unclosed database in <sqlite3.Connection object at', re.I)
|
|
|
|
|
|
def validate_report(arg):
|
|
file_choices = ['annotate', 'html', 'xml', 'json', 'lcov']
|
|
term_choices = ['term', 'term-missing']
|
|
term_modifier_choices = ['skip-covered']
|
|
all_choices = term_choices + file_choices
|
|
values = arg.split(':', 1)
|
|
report_type = values[0]
|
|
if report_type not in [*all_choices, '']:
|
|
msg = f'invalid choice: "{arg}" (choose from "{all_choices}")'
|
|
raise argparse.ArgumentTypeError(msg)
|
|
|
|
if report_type == 'lcov' and coverage.version_info <= (6, 3):
|
|
raise argparse.ArgumentTypeError('LCOV output is only supported with coverage.py >= 6.3')
|
|
|
|
if len(values) == 1:
|
|
return report_type, None
|
|
|
|
report_modifier = values[1]
|
|
if report_type in term_choices and report_modifier in term_modifier_choices:
|
|
return report_type, report_modifier
|
|
|
|
if report_type not in file_choices:
|
|
msg = f'output specifier not supported for: "{arg}" (choose from "{file_choices}")'
|
|
raise argparse.ArgumentTypeError(msg)
|
|
|
|
return values
|
|
|
|
|
|
def validate_fail_under(num_str):
|
|
try:
|
|
value = int(num_str)
|
|
except ValueError:
|
|
try:
|
|
value = float(num_str)
|
|
except ValueError:
|
|
raise argparse.ArgumentTypeError('An integer or float value is required.') from None
|
|
if value > 100:
|
|
raise argparse.ArgumentTypeError(
|
|
'Your desire for over-achievement is admirable but misplaced. The maximum value is 100. Perhaps write more integration tests?'
|
|
)
|
|
return value
|
|
|
|
|
|
def validate_context(arg):
|
|
if coverage.version_info <= (5, 0):
|
|
raise argparse.ArgumentTypeError('Contexts are only supported with coverage.py >= 5.x')
|
|
if arg != 'test':
|
|
raise argparse.ArgumentTypeError('The only supported value is "test".')
|
|
return arg
|
|
|
|
|
|
class StoreReport(argparse.Action):
|
|
def __call__(self, parser, namespace, values, option_string=None):
|
|
report_type, file = values
|
|
namespace.cov_report[report_type] = file
|
|
|
|
|
|
def pytest_addoption(parser):
|
|
"""Add options to control coverage."""
|
|
|
|
group = parser.getgroup('cov', 'coverage reporting with distributed testing support')
|
|
group.addoption(
|
|
'--cov',
|
|
action='append',
|
|
default=[],
|
|
metavar='SOURCE',
|
|
nargs='?',
|
|
const=True,
|
|
dest='cov_source',
|
|
help='Path or package name to measure during execution (multi-allowed). '
|
|
'Use --cov= to not do any source filtering and record everything.',
|
|
)
|
|
group.addoption(
|
|
'--cov-reset',
|
|
action='store_const',
|
|
const=[],
|
|
dest='cov_source',
|
|
help='Reset cov sources accumulated in options so far. ',
|
|
)
|
|
group.addoption(
|
|
'--cov-report',
|
|
action=StoreReport,
|
|
default={},
|
|
metavar='TYPE',
|
|
type=validate_report,
|
|
help='Type of report to generate: term, term-missing, '
|
|
'annotate, html, xml, json, lcov (multi-allowed). '
|
|
'term, term-missing may be followed by ":skip-covered". '
|
|
'annotate, html, xml, json and lcov may be followed by ":DEST" '
|
|
'where DEST specifies the output location. '
|
|
'Use --cov-report= to not generate any output.',
|
|
)
|
|
group.addoption(
|
|
'--cov-config',
|
|
action='store',
|
|
default='.coveragerc',
|
|
metavar='PATH',
|
|
help='Config file for coverage. Default: .coveragerc',
|
|
)
|
|
group.addoption(
|
|
'--no-cov-on-fail',
|
|
action='store_true',
|
|
default=False,
|
|
help='Do not report coverage if test run fails. Default: False',
|
|
)
|
|
group.addoption(
|
|
'--no-cov',
|
|
action='store_true',
|
|
default=False,
|
|
help='Disable coverage report completely (useful for debuggers). Default: False',
|
|
)
|
|
group.addoption(
|
|
'--cov-fail-under',
|
|
action='store',
|
|
metavar='MIN',
|
|
type=validate_fail_under,
|
|
help='Fail if the total coverage is less than MIN.',
|
|
)
|
|
group.addoption(
|
|
'--cov-append',
|
|
action='store_true',
|
|
default=False,
|
|
help='Do not delete coverage but append to current. Default: False',
|
|
)
|
|
group.addoption(
|
|
'--cov-branch',
|
|
action='store_true',
|
|
default=None,
|
|
help='Enable branch coverage.',
|
|
)
|
|
group.addoption(
|
|
'--cov-precision',
|
|
type=int,
|
|
default=None,
|
|
help='Override the reporting precision.',
|
|
)
|
|
group.addoption(
|
|
'--cov-context',
|
|
action='store',
|
|
metavar='CONTEXT',
|
|
type=validate_context,
|
|
help='Dynamic contexts to use. "test" for now.',
|
|
)
|
|
|
|
|
|
def _prepare_cov_source(cov_source):
|
|
"""
|
|
Prepare cov_source so that:
|
|
|
|
--cov --cov=foobar is equivalent to --cov (cov_source=None)
|
|
--cov=foo --cov=bar is equivalent to cov_source=['foo', 'bar']
|
|
"""
|
|
return None if True in cov_source else [path for path in cov_source if path is not True]
|
|
|
|
|
|
@pytest.hookimpl(tryfirst=True)
|
|
def pytest_load_initial_conftests(early_config, parser, args):
|
|
options = early_config.known_args_namespace
|
|
no_cov = options.no_cov_should_warn = False
|
|
for arg in args:
|
|
arg = str(arg)
|
|
if arg == '--no-cov':
|
|
no_cov = True
|
|
elif arg.startswith('--cov') and no_cov:
|
|
options.no_cov_should_warn = True
|
|
break
|
|
|
|
if early_config.known_args_namespace.cov_source:
|
|
plugin = CovPlugin(options, early_config.pluginmanager)
|
|
early_config.pluginmanager.register(plugin, '_cov')
|
|
|
|
|
|
class CovPlugin:
|
|
"""Use coverage package to produce code coverage reports.
|
|
|
|
Delegates all work to a particular implementation based on whether
|
|
this test process is centralised, a distributed master or a
|
|
distributed worker.
|
|
"""
|
|
|
|
def __init__(self, options: argparse.Namespace, pluginmanager, start=True, no_cov_should_warn=False):
|
|
"""Creates a coverage pytest plugin.
|
|
|
|
We read the rc file that coverage uses to get the data file
|
|
name. This is needed since we give coverage through it's API
|
|
the data file name.
|
|
"""
|
|
|
|
# Our implementation is unknown at this time.
|
|
self.pid = None
|
|
self.cov_controller = None
|
|
self.cov_report = StringIO()
|
|
self.cov_total = None
|
|
self.failed = False
|
|
self._started = False
|
|
self._start_path = None
|
|
self._disabled = False
|
|
self.options = options
|
|
self._wrote_heading = False
|
|
|
|
is_dist = getattr(options, 'numprocesses', False) or getattr(options, 'distload', False) or getattr(options, 'dist', 'no') != 'no'
|
|
if getattr(options, 'no_cov', False):
|
|
self._disabled = True
|
|
return
|
|
|
|
if not self.options.cov_report:
|
|
self.options.cov_report = ['term']
|
|
elif len(self.options.cov_report) == 1 and '' in self.options.cov_report:
|
|
self.options.cov_report = {}
|
|
self.options.cov_source = _prepare_cov_source(self.options.cov_source)
|
|
|
|
# import engine lazily here to avoid importing
|
|
# it for unit tests that don't need it
|
|
from . import engine
|
|
|
|
if is_dist and start:
|
|
self.start(engine.DistMaster)
|
|
elif start:
|
|
self.start(engine.Central)
|
|
|
|
# worker is started in pytest hook
|
|
|
|
def start(self, controller_cls: type['CovController'], config=None, nodeid=None):
|
|
if config is None:
|
|
# fake config option for engine
|
|
class Config:
|
|
option = self.options
|
|
|
|
config = Config()
|
|
|
|
self.cov_controller = controller_cls(self.options, config, nodeid)
|
|
self.cov_controller.start()
|
|
self._started = True
|
|
self._start_path = Path.cwd()
|
|
cov_config = self.cov_controller.cov.config
|
|
if self.options.cov_fail_under is None and hasattr(cov_config, 'fail_under'):
|
|
self.options.cov_fail_under = cov_config.fail_under
|
|
if self.options.cov_precision is None:
|
|
self.options.cov_precision = getattr(cov_config, 'precision', 0)
|
|
|
|
def _is_worker(self, session):
|
|
return getattr(session.config, 'workerinput', None) is not None
|
|
|
|
def pytest_sessionstart(self, session):
|
|
"""At session start determine our implementation and delegate to it."""
|
|
|
|
if self.options.no_cov:
|
|
# Coverage can be disabled because it does not cooperate with debuggers well.
|
|
self._disabled = True
|
|
return
|
|
|
|
# import engine lazily here to avoid importing
|
|
# it for unit tests that don't need it
|
|
from . import engine
|
|
|
|
self.pid = os.getpid()
|
|
if self._is_worker(session):
|
|
nodeid = session.config.workerinput.get('workerid', session.nodeid)
|
|
self.start(engine.DistWorker, session.config, nodeid)
|
|
elif not self._started:
|
|
self.start(engine.Central)
|
|
|
|
if self.options.cov_context == 'test':
|
|
session.config.pluginmanager.register(TestContextPlugin(self.cov_controller), '_cov_contexts')
|
|
|
|
@pytest.hookimpl(optionalhook=True)
|
|
def pytest_configure_node(self, node):
|
|
"""Delegate to our implementation.
|
|
|
|
Mark this hook as optional in case xdist is not installed.
|
|
"""
|
|
if not self._disabled:
|
|
self.cov_controller.configure_node(node)
|
|
|
|
@pytest.hookimpl(optionalhook=True)
|
|
def pytest_testnodedown(self, node, error):
|
|
"""Delegate to our implementation.
|
|
|
|
Mark this hook as optional in case xdist is not installed.
|
|
"""
|
|
if not self._disabled:
|
|
self.cov_controller.testnodedown(node, error)
|
|
|
|
def _should_report(self):
|
|
needed = self.options.cov_report or self.options.cov_fail_under
|
|
return needed and not (self.failed and self.options.no_cov_on_fail)
|
|
|
|
# we need to wrap pytest_runtestloop. by the time pytest_sessionfinish
|
|
# runs, it's too late to set testsfailed
|
|
@pytest.hookimpl(wrapper=True)
|
|
def pytest_runtestloop(self, session):
|
|
if self._disabled:
|
|
return (yield)
|
|
|
|
# we add default warning configuration to prevent certain warnings to bubble up as errors due to rigid filterwarnings configuration
|
|
for _, message, category, _, _ in warnings.filters:
|
|
if category is ResourceWarning and message == COVERAGE_SQLITE_WARNING_RE:
|
|
break
|
|
else:
|
|
warnings.filterwarnings('default', 'unclosed database in <sqlite3.Connection object at', ResourceWarning)
|
|
for _, _, category, _, _ in warnings.filters:
|
|
if category is PytestCovWarning:
|
|
break
|
|
else:
|
|
warnings.simplefilter('once', PytestCovWarning)
|
|
for _, _, category, _, _ in warnings.filters:
|
|
if category is CoverageWarning:
|
|
break
|
|
else:
|
|
warnings.simplefilter('once', CoverageWarning)
|
|
|
|
result = yield
|
|
|
|
compat_session = compat.SessionWrapper(session)
|
|
|
|
self.failed = bool(compat_session.testsfailed)
|
|
if self.cov_controller is not None:
|
|
self.cov_controller.finish()
|
|
|
|
if not self._is_worker(session) and self._should_report():
|
|
# import coverage lazily here to avoid importing
|
|
# it for unit tests that don't need it
|
|
from coverage.misc import CoverageException
|
|
|
|
try:
|
|
self.cov_total = self.cov_controller.summary(self.cov_report)
|
|
except CoverageException as exc:
|
|
message = f'Failed to generate report: {exc}\n'
|
|
session.config.pluginmanager.getplugin('terminalreporter').write(f'\nWARNING: {message}\n', red=True, bold=True)
|
|
warnings.warn(CovReportWarning(message), stacklevel=1)
|
|
self.cov_total = 0
|
|
assert self.cov_total is not None, 'Test coverage should never be `None`'
|
|
cov_fail_under = self.options.cov_fail_under
|
|
cov_precision = self.options.cov_precision
|
|
if cov_fail_under is None or self.options.collectonly:
|
|
return
|
|
if should_fail_under(self.cov_total, cov_fail_under, cov_precision):
|
|
message = 'Coverage failure: total of {total} is less than fail-under={fail_under:.{p}f}'.format(
|
|
total=display_covered(self.cov_total, cov_precision),
|
|
fail_under=cov_fail_under,
|
|
p=cov_precision,
|
|
)
|
|
session.config.pluginmanager.getplugin('terminalreporter').write(f'\nERROR: {message}\n', red=True, bold=True)
|
|
# make sure we get the EXIT_TESTSFAILED exit code
|
|
compat_session.testsfailed += 1
|
|
|
|
return result
|
|
|
|
def write_heading(self, terminalreporter):
|
|
if not self._wrote_heading:
|
|
terminalreporter.write_sep('=', 'tests coverage')
|
|
self._wrote_heading = True
|
|
|
|
def pytest_terminal_summary(self, terminalreporter):
|
|
if self._disabled:
|
|
if self.options.no_cov_should_warn:
|
|
self.write_heading(terminalreporter)
|
|
message = 'Coverage disabled via --no-cov switch!'
|
|
terminalreporter.write(f'WARNING: {message}\n', red=True, bold=True)
|
|
warnings.warn(CovDisabledWarning(message), stacklevel=1)
|
|
return
|
|
if self.cov_controller is None:
|
|
return
|
|
|
|
if self.cov_total is None:
|
|
# we shouldn't report, or report generation failed (error raised above)
|
|
return
|
|
|
|
report = self.cov_report.getvalue()
|
|
|
|
if report:
|
|
self.write_heading(terminalreporter)
|
|
terminalreporter.write(report)
|
|
|
|
if self.options.cov_fail_under is not None and self.options.cov_fail_under > 0:
|
|
self.write_heading(terminalreporter)
|
|
failed = self.cov_total < self.options.cov_fail_under
|
|
markup = {'red': True, 'bold': True} if failed else {'green': True}
|
|
message = '{fail}Required test coverage of {required}% {reached}. Total coverage: {actual:.2f}%\n'.format(
|
|
required=self.options.cov_fail_under,
|
|
actual=self.cov_total,
|
|
fail='FAIL ' if failed else '',
|
|
reached='not reached' if failed else 'reached',
|
|
)
|
|
terminalreporter.write(message, **markup)
|
|
|
|
def pytest_runtest_setup(self, item):
|
|
if os.getpid() != self.pid:
|
|
# test is run in another process than session, run
|
|
# coverage manually
|
|
embed.init()
|
|
|
|
def pytest_runtest_teardown(self, item):
|
|
embed.cleanup()
|
|
|
|
@pytest.hookimpl(hookwrapper=True)
|
|
def pytest_runtest_call(self, item):
|
|
if item.get_closest_marker('no_cover') or 'no_cover' in getattr(item, 'fixturenames', ()):
|
|
self.cov_controller.pause()
|
|
yield
|
|
self.cov_controller.resume()
|
|
else:
|
|
yield
|
|
|
|
|
|
class TestContextPlugin:
|
|
cov_controller: 'CovController'
|
|
|
|
def __init__(self, cov_controller):
|
|
self.cov_controller = cov_controller
|
|
|
|
def pytest_runtest_setup(self, item):
|
|
self.switch_context(item, 'setup')
|
|
|
|
def pytest_runtest_teardown(self, item):
|
|
self.switch_context(item, 'teardown')
|
|
|
|
def pytest_runtest_call(self, item):
|
|
self.switch_context(item, 'run')
|
|
|
|
def switch_context(self, item, when):
|
|
if self.cov_controller.started:
|
|
context = f'{item.nodeid}|{when}'
|
|
self.cov_controller.cov.switch_context(context)
|
|
os.environ['COV_CORE_CONTEXT'] = context
|
|
|
|
|
|
@pytest.fixture
|
|
def no_cover():
|
|
"""A pytest fixture to disable coverage."""
|
|
|
|
|
|
@pytest.fixture
|
|
def cov(request):
|
|
"""A pytest fixture to provide access to the underlying coverage object."""
|
|
|
|
# Check with hasplugin to avoid getplugin exception in older pytest.
|
|
if request.config.pluginmanager.hasplugin('_cov'):
|
|
plugin = request.config.pluginmanager.getplugin('_cov')
|
|
if plugin.cov_controller:
|
|
return plugin.cov_controller.cov
|
|
return None
|
|
|
|
|
|
def pytest_configure(config):
|
|
config.addinivalue_line('markers', 'no_cover: disable coverage for this test.')
|