You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
777 lines
29 KiB
Python
777 lines
29 KiB
Python
"""Core control stuff for Coverage."""
|
|
|
|
import atexit, os, random, socket, sys
|
|
|
|
from coverage.annotate import AnnotateReporter
|
|
from coverage.backward import string_class, iitems, sorted # pylint: disable=W0622
|
|
from coverage.codeunit import code_unit_factory, CodeUnit
|
|
from coverage.collector import Collector
|
|
from coverage.config import CoverageConfig
|
|
from coverage.data import CoverageData
|
|
from coverage.debug import DebugControl
|
|
from coverage.files import FileLocator, TreeMatcher, FnmatchMatcher
|
|
from coverage.files import PathAliases, find_python_files, prep_patterns
|
|
from coverage.html import HtmlReporter
|
|
from coverage.misc import CoverageException, bool_or_none, join_regex
|
|
from coverage.misc import file_be_gone
|
|
from coverage.results import Analysis, Numbers
|
|
from coverage.summary import SummaryReporter
|
|
from coverage.xmlreport import XmlReporter
|
|
|
|
# Pypy has some unusual stuff in the "stdlib". Consider those locations
|
|
# when deciding where the stdlib is.
|
|
try:
|
|
import _structseq # pylint: disable=F0401
|
|
except ImportError:
|
|
_structseq = None
|
|
|
|
|
|
class coverage(object):
|
|
"""Programmatic access to coverage.py.
|
|
|
|
To use::
|
|
|
|
from coverage import coverage
|
|
|
|
cov = coverage()
|
|
cov.start()
|
|
#.. call your code ..
|
|
cov.stop()
|
|
cov.html_report(directory='covhtml')
|
|
|
|
"""
|
|
def __init__(self, data_file=None, data_suffix=None, cover_pylib=None,
|
|
auto_data=False, timid=None, branch=None, config_file=True,
|
|
source=None, omit=None, include=None, debug=None,
|
|
debug_file=None):
|
|
"""
|
|
`data_file` is the base name of the data file to use, defaulting to
|
|
".coverage". `data_suffix` is appended (with a dot) to `data_file` to
|
|
create the final file name. If `data_suffix` is simply True, then a
|
|
suffix is created with the machine and process identity included.
|
|
|
|
`cover_pylib` is a boolean determining whether Python code installed
|
|
with the Python interpreter is measured. This includes the Python
|
|
standard library and any packages installed with the interpreter.
|
|
|
|
If `auto_data` is true, then any existing data file will be read when
|
|
coverage measurement starts, and data will be saved automatically when
|
|
measurement stops.
|
|
|
|
If `timid` is true, then a slower and simpler trace function will be
|
|
used. This is important for some environments where manipulation of
|
|
tracing functions breaks the faster trace function.
|
|
|
|
If `branch` is true, then branch coverage will be measured in addition
|
|
to the usual statement coverage.
|
|
|
|
`config_file` determines what config file to read. If it is a string,
|
|
it is the name of the config file to read. If it is True, then a
|
|
standard file is read (".coveragerc"). If it is False, then no file is
|
|
read.
|
|
|
|
`source` is a list of file paths or package names. Only code located
|
|
in the trees indicated by the file paths or package names will be
|
|
measured.
|
|
|
|
`include` and `omit` are lists of filename patterns. Files that match
|
|
`include` will be measured, files that match `omit` will not. Each
|
|
will also accept a single string argument.
|
|
|
|
`debug` is a list of strings indicating what debugging information is
|
|
desired. `debug_file` is the file to write debug messages to,
|
|
defaulting to stderr.
|
|
|
|
"""
|
|
from coverage import __version__
|
|
|
|
# A record of all the warnings that have been issued.
|
|
self._warnings = []
|
|
|
|
# Build our configuration from a number of sources:
|
|
# 1: defaults:
|
|
self.config = CoverageConfig()
|
|
|
|
# 2: from the coveragerc file:
|
|
if config_file:
|
|
if config_file is True:
|
|
config_file = ".coveragerc"
|
|
try:
|
|
self.config.from_file(config_file)
|
|
except ValueError:
|
|
_, err, _ = sys.exc_info()
|
|
raise CoverageException(
|
|
"Couldn't read config file %s: %s" % (config_file, err)
|
|
)
|
|
|
|
# 3: from environment variables:
|
|
self.config.from_environment('COVERAGE_OPTIONS')
|
|
env_data_file = os.environ.get('COVERAGE_FILE')
|
|
if env_data_file:
|
|
self.config.data_file = env_data_file
|
|
|
|
# 4: from constructor arguments:
|
|
self.config.from_args(
|
|
data_file=data_file, cover_pylib=cover_pylib, timid=timid,
|
|
branch=branch, parallel=bool_or_none(data_suffix),
|
|
source=source, omit=omit, include=include, debug=debug,
|
|
)
|
|
|
|
# Create and configure the debugging controller.
|
|
self.debug = DebugControl(self.config.debug, debug_file or sys.stderr)
|
|
|
|
self.auto_data = auto_data
|
|
|
|
# _exclude_re is a dict mapping exclusion list names to compiled
|
|
# regexes.
|
|
self._exclude_re = {}
|
|
self._exclude_regex_stale()
|
|
|
|
self.file_locator = FileLocator()
|
|
|
|
# The source argument can be directories or package names.
|
|
self.source = []
|
|
self.source_pkgs = []
|
|
for src in self.config.source or []:
|
|
if os.path.exists(src):
|
|
self.source.append(self.file_locator.canonical_filename(src))
|
|
else:
|
|
self.source_pkgs.append(src)
|
|
|
|
self.omit = prep_patterns(self.config.omit)
|
|
self.include = prep_patterns(self.config.include)
|
|
|
|
self.collector = Collector(
|
|
self._should_trace, timid=self.config.timid,
|
|
branch=self.config.branch, warn=self._warn
|
|
)
|
|
|
|
# Suffixes are a bit tricky. We want to use the data suffix only when
|
|
# collecting data, not when combining data. So we save it as
|
|
# `self.run_suffix` now, and promote it to `self.data_suffix` if we
|
|
# find that we are collecting data later.
|
|
if data_suffix or self.config.parallel:
|
|
if not isinstance(data_suffix, string_class):
|
|
# if data_suffix=True, use .machinename.pid.random
|
|
data_suffix = True
|
|
else:
|
|
data_suffix = None
|
|
self.data_suffix = None
|
|
self.run_suffix = data_suffix
|
|
|
|
# Create the data file. We do this at construction time so that the
|
|
# data file will be written into the directory where the process
|
|
# started rather than wherever the process eventually chdir'd to.
|
|
self.data = CoverageData(
|
|
basename=self.config.data_file,
|
|
collector="coverage v%s" % __version__,
|
|
debug=self.debug,
|
|
)
|
|
|
|
# The dirs for files considered "installed with the interpreter".
|
|
self.pylib_dirs = []
|
|
if not self.config.cover_pylib:
|
|
# Look at where some standard modules are located. That's the
|
|
# indication for "installed with the interpreter". In some
|
|
# environments (virtualenv, for example), these modules may be
|
|
# spread across a few locations. Look at all the candidate modules
|
|
# we've imported, and take all the different ones.
|
|
for m in (atexit, os, random, socket, _structseq):
|
|
if m is not None and hasattr(m, "__file__"):
|
|
m_dir = self._canonical_dir(m)
|
|
if m_dir not in self.pylib_dirs:
|
|
self.pylib_dirs.append(m_dir)
|
|
|
|
# To avoid tracing the coverage code itself, we skip anything located
|
|
# where we are.
|
|
self.cover_dir = self._canonical_dir(__file__)
|
|
|
|
# The matchers for _should_trace.
|
|
self.source_match = None
|
|
self.pylib_match = self.cover_match = None
|
|
self.include_match = self.omit_match = None
|
|
|
|
# Set the reporting precision.
|
|
Numbers.set_precision(self.config.precision)
|
|
|
|
# Is it ok for no data to be collected?
|
|
self._warn_no_data = True
|
|
self._warn_unimported_source = True
|
|
|
|
# State machine variables:
|
|
# Have we started collecting and not stopped it?
|
|
self._started = False
|
|
# Have we measured some data and not harvested it?
|
|
self._measured = False
|
|
|
|
atexit.register(self._atexit)
|
|
|
|
def _canonical_dir(self, morf):
|
|
"""Return the canonical directory of the module or file `morf`."""
|
|
return os.path.split(CodeUnit(morf, self.file_locator).filename)[0]
|
|
|
|
def _source_for_file(self, filename):
|
|
"""Return the source file for `filename`."""
|
|
if not filename.endswith(".py"):
|
|
if filename[-4:-1] == ".py":
|
|
filename = filename[:-1]
|
|
elif filename.endswith("$py.class"): # jython
|
|
filename = filename[:-9] + ".py"
|
|
return filename
|
|
|
|
def _should_trace_with_reason(self, filename, frame):
|
|
"""Decide whether to trace execution in `filename`, with a reason.
|
|
|
|
This function is called from the trace function. As each new file name
|
|
is encountered, this function determines whether it is traced or not.
|
|
|
|
Returns a pair of values: the first indicates whether the file should
|
|
be traced: it's a canonicalized filename if it should be traced, None
|
|
if it should not. The second value is a string, the resason for the
|
|
decision.
|
|
|
|
"""
|
|
if not filename:
|
|
# Empty string is pretty useless
|
|
return None, "empty string isn't a filename"
|
|
|
|
if filename.startswith('<'):
|
|
# Lots of non-file execution is represented with artificial
|
|
# filenames like "<string>", "<doctest readme.txt[0]>", or
|
|
# "<exec_function>". Don't ever trace these executions, since we
|
|
# can't do anything with the data later anyway.
|
|
return None, "not a real filename"
|
|
|
|
self._check_for_packages()
|
|
|
|
# Compiled Python files have two filenames: frame.f_code.co_filename is
|
|
# the filename at the time the .pyc was compiled. The second name is
|
|
# __file__, which is where the .pyc was actually loaded from. Since
|
|
# .pyc files can be moved after compilation (for example, by being
|
|
# installed), we look for __file__ in the frame and prefer it to the
|
|
# co_filename value.
|
|
dunder_file = frame.f_globals.get('__file__')
|
|
if dunder_file:
|
|
filename = self._source_for_file(dunder_file)
|
|
|
|
# Jython reports the .class file to the tracer, use the source file.
|
|
if filename.endswith("$py.class"):
|
|
filename = filename[:-9] + ".py"
|
|
|
|
canonical = self.file_locator.canonical_filename(filename)
|
|
|
|
# If the user specified source or include, then that's authoritative
|
|
# about the outer bound of what to measure and we don't have to apply
|
|
# any canned exclusions. If they didn't, then we have to exclude the
|
|
# stdlib and coverage.py directories.
|
|
if self.source_match:
|
|
if not self.source_match.match(canonical):
|
|
return None, "falls outside the --source trees"
|
|
elif self.include_match:
|
|
if not self.include_match.match(canonical):
|
|
return None, "falls outside the --include trees"
|
|
else:
|
|
# If we aren't supposed to trace installed code, then check if this
|
|
# is near the Python standard library and skip it if so.
|
|
if self.pylib_match and self.pylib_match.match(canonical):
|
|
return None, "is in the stdlib"
|
|
|
|
# We exclude the coverage code itself, since a little of it will be
|
|
# measured otherwise.
|
|
if self.cover_match and self.cover_match.match(canonical):
|
|
return None, "is part of coverage.py"
|
|
|
|
# Check the file against the omit pattern.
|
|
if self.omit_match and self.omit_match.match(canonical):
|
|
return None, "is inside an --omit pattern"
|
|
|
|
return canonical, "because we love you"
|
|
|
|
def _should_trace(self, filename, frame):
|
|
"""Decide whether to trace execution in `filename`.
|
|
|
|
Calls `_should_trace_with_reason`, and returns just the decision.
|
|
|
|
"""
|
|
canonical, reason = self._should_trace_with_reason(filename, frame)
|
|
if self.debug.should('trace'):
|
|
if not canonical:
|
|
msg = "Not tracing %r: %s" % (filename, reason)
|
|
else:
|
|
msg = "Tracing %r" % (filename,)
|
|
self.debug.write(msg)
|
|
return canonical
|
|
|
|
def _warn(self, msg):
|
|
"""Use `msg` as a warning."""
|
|
self._warnings.append(msg)
|
|
sys.stderr.write("Coverage.py warning: %s\n" % msg)
|
|
|
|
def _check_for_packages(self):
|
|
"""Update the source_match matcher with latest imported packages."""
|
|
# Our self.source_pkgs attribute is a list of package names we want to
|
|
# measure. Each time through here, we see if we've imported any of
|
|
# them yet. If so, we add its file to source_match, and we don't have
|
|
# to look for that package any more.
|
|
if self.source_pkgs:
|
|
found = []
|
|
for pkg in self.source_pkgs:
|
|
try:
|
|
mod = sys.modules[pkg]
|
|
except KeyError:
|
|
continue
|
|
|
|
found.append(pkg)
|
|
|
|
try:
|
|
pkg_file = mod.__file__
|
|
except AttributeError:
|
|
pkg_file = None
|
|
else:
|
|
d, f = os.path.split(pkg_file)
|
|
if f.startswith('__init__'):
|
|
# This is actually a package, return the directory.
|
|
pkg_file = d
|
|
else:
|
|
pkg_file = self._source_for_file(pkg_file)
|
|
pkg_file = self.file_locator.canonical_filename(pkg_file)
|
|
if not os.path.exists(pkg_file):
|
|
pkg_file = None
|
|
|
|
if pkg_file:
|
|
self.source.append(pkg_file)
|
|
self.source_match.add(pkg_file)
|
|
else:
|
|
self._warn("Module %s has no Python source." % pkg)
|
|
|
|
for pkg in found:
|
|
self.source_pkgs.remove(pkg)
|
|
|
|
def use_cache(self, usecache):
|
|
"""Control the use of a data file (incorrectly called a cache).
|
|
|
|
`usecache` is true or false, whether to read and write data on disk.
|
|
|
|
"""
|
|
self.data.usefile(usecache)
|
|
|
|
def load(self):
|
|
"""Load previously-collected coverage data from the data file."""
|
|
self.collector.reset()
|
|
self.data.read()
|
|
|
|
def start(self):
|
|
"""Start measuring code coverage.
|
|
|
|
Coverage measurement actually occurs in functions called after `start`
|
|
is invoked. Statements in the same scope as `start` won't be measured.
|
|
|
|
Once you invoke `start`, you must also call `stop` eventually, or your
|
|
process might not shut down cleanly.
|
|
|
|
"""
|
|
if self.run_suffix:
|
|
# Calling start() means we're running code, so use the run_suffix
|
|
# as the data_suffix when we eventually save the data.
|
|
self.data_suffix = self.run_suffix
|
|
if self.auto_data:
|
|
self.load()
|
|
|
|
# Create the matchers we need for _should_trace
|
|
if self.source or self.source_pkgs:
|
|
self.source_match = TreeMatcher(self.source)
|
|
else:
|
|
if self.cover_dir:
|
|
self.cover_match = TreeMatcher([self.cover_dir])
|
|
if self.pylib_dirs:
|
|
self.pylib_match = TreeMatcher(self.pylib_dirs)
|
|
if self.include:
|
|
self.include_match = FnmatchMatcher(self.include)
|
|
if self.omit:
|
|
self.omit_match = FnmatchMatcher(self.omit)
|
|
|
|
# The user may want to debug things, show info if desired.
|
|
if self.debug.should('config'):
|
|
self.debug.write("Configuration values:")
|
|
config_info = sorted(self.config.__dict__.items())
|
|
self.debug.write_formatted_info(config_info)
|
|
|
|
if self.debug.should('sys'):
|
|
self.debug.write("Debugging info:")
|
|
self.debug.write_formatted_info(self.sysinfo())
|
|
|
|
self.collector.start()
|
|
self._started = True
|
|
self._measured = True
|
|
|
|
def stop(self):
|
|
"""Stop measuring code coverage."""
|
|
self._started = False
|
|
self.collector.stop()
|
|
|
|
def _atexit(self):
|
|
"""Clean up on process shutdown."""
|
|
if self._started:
|
|
self.stop()
|
|
if self.auto_data:
|
|
self.save()
|
|
|
|
def erase(self):
|
|
"""Erase previously-collected coverage data.
|
|
|
|
This removes the in-memory data collected in this session as well as
|
|
discarding the data file.
|
|
|
|
"""
|
|
self.collector.reset()
|
|
self.data.erase()
|
|
|
|
def clear_exclude(self, which='exclude'):
|
|
"""Clear the exclude list."""
|
|
setattr(self.config, which + "_list", [])
|
|
self._exclude_regex_stale()
|
|
|
|
def exclude(self, regex, which='exclude'):
|
|
"""Exclude source lines from execution consideration.
|
|
|
|
A number of lists of regular expressions are maintained. Each list
|
|
selects lines that are treated differently during reporting.
|
|
|
|
`which` determines which list is modified. The "exclude" list selects
|
|
lines that are not considered executable at all. The "partial" list
|
|
indicates lines with branches that are not taken.
|
|
|
|
`regex` is a regular expression. The regex is added to the specified
|
|
list. If any of the regexes in the list is found in a line, the line
|
|
is marked for special treatment during reporting.
|
|
|
|
"""
|
|
excl_list = getattr(self.config, which + "_list")
|
|
excl_list.append(regex)
|
|
self._exclude_regex_stale()
|
|
|
|
def _exclude_regex_stale(self):
|
|
"""Drop all the compiled exclusion regexes, a list was modified."""
|
|
self._exclude_re.clear()
|
|
|
|
def _exclude_regex(self, which):
|
|
"""Return a compiled regex for the given exclusion list."""
|
|
if which not in self._exclude_re:
|
|
excl_list = getattr(self.config, which + "_list")
|
|
self._exclude_re[which] = join_regex(excl_list)
|
|
return self._exclude_re[which]
|
|
|
|
def get_exclude_list(self, which='exclude'):
|
|
"""Return a list of excluded regex patterns.
|
|
|
|
`which` indicates which list is desired. See `exclude` for the lists
|
|
that are available, and their meaning.
|
|
|
|
"""
|
|
return getattr(self.config, which + "_list")
|
|
|
|
def save(self):
|
|
"""Save the collected coverage data to the data file."""
|
|
data_suffix = self.data_suffix
|
|
if data_suffix is True:
|
|
# If data_suffix was a simple true value, then make a suffix with
|
|
# plenty of distinguishing information. We do this here in
|
|
# `save()` at the last minute so that the pid will be correct even
|
|
# if the process forks.
|
|
extra = ""
|
|
if _TEST_NAME_FILE:
|
|
f = open(_TEST_NAME_FILE)
|
|
test_name = f.read()
|
|
f.close()
|
|
extra = "." + test_name
|
|
data_suffix = "%s%s.%s.%06d" % (
|
|
socket.gethostname(), extra, os.getpid(),
|
|
random.randint(0, 999999)
|
|
)
|
|
|
|
self._harvest_data()
|
|
self.data.write(suffix=data_suffix)
|
|
|
|
def combine(self):
|
|
"""Combine together a number of similarly-named coverage data files.
|
|
|
|
All coverage data files whose name starts with `data_file` (from the
|
|
coverage() constructor) will be read, and combined together into the
|
|
current measurements.
|
|
|
|
"""
|
|
aliases = None
|
|
if self.config.paths:
|
|
aliases = PathAliases(self.file_locator)
|
|
for paths in self.config.paths.values():
|
|
result = paths[0]
|
|
for pattern in paths[1:]:
|
|
aliases.add(pattern, result)
|
|
self.data.combine_parallel_data(aliases=aliases)
|
|
|
|
def _harvest_data(self):
|
|
"""Get the collected data and reset the collector.
|
|
|
|
Also warn about various problems collecting data.
|
|
|
|
"""
|
|
if not self._measured:
|
|
return
|
|
|
|
self.data.add_line_data(self.collector.get_line_data())
|
|
self.data.add_arc_data(self.collector.get_arc_data())
|
|
self.collector.reset()
|
|
|
|
# If there are still entries in the source_pkgs list, then we never
|
|
# encountered those packages.
|
|
if self._warn_unimported_source:
|
|
for pkg in self.source_pkgs:
|
|
self._warn("Module %s was never imported." % pkg)
|
|
|
|
# Find out if we got any data.
|
|
summary = self.data.summary()
|
|
if not summary and self._warn_no_data:
|
|
self._warn("No data was collected.")
|
|
|
|
# Find files that were never executed at all.
|
|
for src in self.source:
|
|
for py_file in find_python_files(src):
|
|
py_file = self.file_locator.canonical_filename(py_file)
|
|
|
|
if self.omit_match and self.omit_match.match(py_file):
|
|
# Turns out this file was omitted, so don't pull it back
|
|
# in as unexecuted.
|
|
continue
|
|
|
|
self.data.touch_file(py_file)
|
|
|
|
self._measured = False
|
|
|
|
# Backward compatibility with version 1.
|
|
def analysis(self, morf):
|
|
"""Like `analysis2` but doesn't return excluded line numbers."""
|
|
f, s, _, m, mf = self.analysis2(morf)
|
|
return f, s, m, mf
|
|
|
|
def analysis2(self, morf):
|
|
"""Analyze a module.
|
|
|
|
`morf` is a module or a filename. It will be analyzed to determine
|
|
its coverage statistics. The return value is a 5-tuple:
|
|
|
|
* The filename for the module.
|
|
* A list of line numbers of executable statements.
|
|
* A list of line numbers of excluded statements.
|
|
* A list of line numbers of statements not run (missing from
|
|
execution).
|
|
* A readable formatted string of the missing line numbers.
|
|
|
|
The analysis uses the source file itself and the current measured
|
|
coverage data.
|
|
|
|
"""
|
|
analysis = self._analyze(morf)
|
|
return (
|
|
analysis.filename, analysis.statements, analysis.excluded,
|
|
analysis.missing, analysis.missing_formatted()
|
|
)
|
|
|
|
def _analyze(self, it):
|
|
"""Analyze a single morf or code unit.
|
|
|
|
Returns an `Analysis` object.
|
|
|
|
"""
|
|
self._harvest_data()
|
|
if not isinstance(it, CodeUnit):
|
|
it = code_unit_factory(it, self.file_locator)[0]
|
|
|
|
return Analysis(self, it)
|
|
|
|
def report(self, morfs=None, show_missing=True, ignore_errors=None,
|
|
file=None, # pylint: disable=W0622
|
|
omit=None, include=None
|
|
):
|
|
"""Write a summary report to `file`.
|
|
|
|
Each module in `morfs` is listed, with counts of statements, executed
|
|
statements, missing statements, and a list of lines missed.
|
|
|
|
`include` is a list of filename patterns. Modules whose filenames
|
|
match those patterns will be included in the report. Modules matching
|
|
`omit` will not be included in the report.
|
|
|
|
Returns a float, the total percentage covered.
|
|
|
|
"""
|
|
self._harvest_data()
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include,
|
|
show_missing=show_missing,
|
|
)
|
|
reporter = SummaryReporter(self, self.config)
|
|
return reporter.report(morfs, outfile=file)
|
|
|
|
def annotate(self, morfs=None, directory=None, ignore_errors=None,
|
|
omit=None, include=None):
|
|
"""Annotate a list of modules.
|
|
|
|
Each module in `morfs` is annotated. The source is written to a new
|
|
file, named with a ",cover" suffix, with each line prefixed with a
|
|
marker to indicate the coverage of the line. Covered lines have ">",
|
|
excluded lines have "-", and missing lines have "!".
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
"""
|
|
self._harvest_data()
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include
|
|
)
|
|
reporter = AnnotateReporter(self, self.config)
|
|
reporter.report(morfs, directory=directory)
|
|
|
|
def html_report(self, morfs=None, directory=None, ignore_errors=None,
|
|
omit=None, include=None, extra_css=None, title=None):
|
|
"""Generate an HTML report.
|
|
|
|
The HTML is written to `directory`. The file "index.html" is the
|
|
overview starting point, with links to more detailed pages for
|
|
individual modules.
|
|
|
|
`extra_css` is a path to a file of other CSS to apply on the page.
|
|
It will be copied into the HTML directory.
|
|
|
|
`title` is a text string (not HTML) to use as the title of the HTML
|
|
report.
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
Returns a float, the total percentage covered.
|
|
|
|
"""
|
|
self._harvest_data()
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include,
|
|
html_dir=directory, extra_css=extra_css, html_title=title,
|
|
)
|
|
reporter = HtmlReporter(self, self.config)
|
|
return reporter.report(morfs)
|
|
|
|
def xml_report(self, morfs=None, outfile=None, ignore_errors=None,
|
|
omit=None, include=None):
|
|
"""Generate an XML report of coverage results.
|
|
|
|
The report is compatible with Cobertura reports.
|
|
|
|
Each module in `morfs` is included in the report. `outfile` is the
|
|
path to write the file to, "-" will write to stdout.
|
|
|
|
See `coverage.report()` for other arguments.
|
|
|
|
Returns a float, the total percentage covered.
|
|
|
|
"""
|
|
self._harvest_data()
|
|
self.config.from_args(
|
|
ignore_errors=ignore_errors, omit=omit, include=include,
|
|
xml_output=outfile,
|
|
)
|
|
file_to_close = None
|
|
delete_file = False
|
|
if self.config.xml_output:
|
|
if self.config.xml_output == '-':
|
|
outfile = sys.stdout
|
|
else:
|
|
outfile = open(self.config.xml_output, "w")
|
|
file_to_close = outfile
|
|
try:
|
|
try:
|
|
reporter = XmlReporter(self, self.config)
|
|
return reporter.report(morfs, outfile=outfile)
|
|
except CoverageException:
|
|
delete_file = True
|
|
raise
|
|
finally:
|
|
if file_to_close:
|
|
file_to_close.close()
|
|
if delete_file:
|
|
file_be_gone(self.config.xml_output)
|
|
|
|
def sysinfo(self):
|
|
"""Return a list of (key, value) pairs showing internal information."""
|
|
|
|
import coverage as covmod
|
|
import platform, re
|
|
|
|
try:
|
|
implementation = platform.python_implementation()
|
|
except AttributeError:
|
|
implementation = "unknown"
|
|
|
|
info = [
|
|
('version', covmod.__version__),
|
|
('coverage', covmod.__file__),
|
|
('cover_dir', self.cover_dir),
|
|
('pylib_dirs', self.pylib_dirs),
|
|
('tracer', self.collector.tracer_name()),
|
|
('config_files', self.config.attempted_config_files),
|
|
('configs_read', self.config.config_files),
|
|
('data_path', self.data.filename),
|
|
('python', sys.version.replace('\n', '')),
|
|
('platform', platform.platform()),
|
|
('implementation', implementation),
|
|
('executable', sys.executable),
|
|
('cwd', os.getcwd()),
|
|
('path', sys.path),
|
|
('environment', sorted([
|
|
("%s = %s" % (k, v)) for k, v in iitems(os.environ)
|
|
if re.search(r"^COV|^PY", k)
|
|
])),
|
|
('command_line', " ".join(getattr(sys, 'argv', ['???']))),
|
|
]
|
|
if self.source_match:
|
|
info.append(('source_match', self.source_match.info()))
|
|
if self.include_match:
|
|
info.append(('include_match', self.include_match.info()))
|
|
if self.omit_match:
|
|
info.append(('omit_match', self.omit_match.info()))
|
|
if self.cover_match:
|
|
info.append(('cover_match', self.cover_match.info()))
|
|
if self.pylib_match:
|
|
info.append(('pylib_match', self.pylib_match.info()))
|
|
|
|
return info
|
|
|
|
|
|
def process_startup():
|
|
"""Call this at Python startup to perhaps measure coverage.
|
|
|
|
If the environment variable COVERAGE_PROCESS_START is defined, coverage
|
|
measurement is started. The value of the variable is the config file
|
|
to use.
|
|
|
|
There are two ways to configure your Python installation to invoke this
|
|
function when Python starts:
|
|
|
|
#. Create or append to sitecustomize.py to add these lines::
|
|
|
|
import coverage
|
|
coverage.process_startup()
|
|
|
|
#. Create a .pth file in your Python installation containing::
|
|
|
|
import coverage; coverage.process_startup()
|
|
|
|
"""
|
|
cps = os.environ.get("COVERAGE_PROCESS_START")
|
|
if cps:
|
|
cov = coverage(config_file=cps, auto_data=True)
|
|
cov.start()
|
|
cov._warn_no_data = False
|
|
cov._warn_unimported_source = False
|
|
|
|
|
|
# A hack for debugging testing in subprocesses.
|
|
_TEST_NAME_FILE = "" #"/tmp/covtest.txt"
|