# 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 that HTML generation is awesome."""
from __future__ import annotations
import collections
import datetime
import glob
import json
import os
import os.path
import re
import sys
from unittest import mock
from typing import Any, IO
import pytest
import coverage
from coverage import env, Coverage
from coverage.exceptions import NoDataError, NotPython, NoSource
from coverage.files import abs_file, flat_rootname
import coverage.html
from coverage.report_core import get_analysis_to_report
from coverage.types import TLineNo, TMorf
from tests import testenv
from tests.coveragetest import CoverageTest, TESTS_DIR
from tests.goldtest import gold_path
from tests.goldtest import compare, contains, contains_rx, doesnt_contain, contains_any
from tests.helpers import assert_coverage_warnings, change_dir
class HtmlTestHelpers(CoverageTest):
"""Methods that help with HTML tests."""
def create_initial_files(self) -> None:
"""Create the source files we need to run these tests."""
self.make_file("main_file.py", """\
import helper1, helper2
helper1.func1(12)
helper2.func2(12)
""")
self.make_file("helper1.py", """\
def func1(x):
if x % 2:
print("odd")
""")
self.make_file("helper2.py", """\
def func2(x):
print("x is %d" % x)
""")
def run_coverage(
self,
covargs: dict[str, Any] | None = None,
htmlargs: dict[str, Any] | None = None,
) -> float:
"""Run coverage.py on main_file.py, and create an HTML report."""
self.clean_local_file_imports()
cov = coverage.Coverage(**(covargs or {}))
self.start_import_stop(cov, "main_file")
ret = cov.html_report(**(htmlargs or {}))
self.assert_valid_hrefs()
return ret
def get_html_report_content(self, module: str) -> str:
"""Return the content of the HTML report for `module`."""
filename = flat_rootname(module) + ".html"
filename = os.path.join("htmlcov", filename)
with open(filename) as f:
return f.read()
def get_html_index_content(self) -> str:
"""Return the content of index.html.
Time stamps are replaced with a placeholder so that clocks don't matter.
"""
with open("htmlcov/index.html") as f:
index = f.read()
index = re.sub(
r"created at \d{4}-\d{2}-\d{2} \d{2}:\d{2} \+\d{4}",
r"created at YYYY-MM-DD HH:MM +ZZZZ",
index,
)
index = re.sub(
r"created at \d{4}-\d{2}-\d{2} \d{2}:\d{2}",
r"created at YYYY-MM-DD HH:MM",
index,
)
return index
def assert_correct_timestamp(self, html: str) -> None:
"""Extract the time stamp from `html`, and assert it is recent."""
timestamp_pat = r"created at (\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})"
m = re.search(timestamp_pat, html)
assert m, "Didn't find a time stamp!"
timestamp = datetime.datetime(*[int(v) for v in m.groups()]) # type: ignore[arg-type]
# The time stamp only records the minute, so the delta could be from
# 12:00 to 12:01:59, or two minutes.
self.assert_recent_datetime(
timestamp,
seconds=120,
msg=f"Time stamp is wrong: {timestamp}",
)
def assert_valid_hrefs(self, directory: str = "htmlcov") -> None:
"""Assert that the hrefs in htmlcov/*.html are valid.
Doesn't check external links (those with a protocol).
"""
hrefs = collections.defaultdict(set)
for fname in glob.glob(f"{directory}/*.html"):
with open(fname) as fhtml:
html = fhtml.read()
for href in re.findall(r""" href=['"]([^'"]*)['"]""", html):
if href.startswith("#"):
assert re.search(fr""" id=['"]{href[1:]}['"]""", html), (
f"Fragment {href!r} in {fname} has no anchor"
)
continue
if "://" in href:
continue
href = href.partition("#")[0] # ignore fragment in URLs.
hrefs[href].add(fname)
for href, sources in hrefs.items():
assert os.path.exists(f"{directory}/{href}"), (
f"These files link to {href!r}, which doesn't exist: {', '.join(sources)}"
)
class FileWriteTracker:
"""A fake object to track how `open` is used to write files."""
def __init__(self, written: set[str]) -> None:
self.written = written
def open(self, filename: str, mode: str = "r") -> IO[str]:
"""Be just like `open`, but write written file names to `self.written`."""
if mode.startswith("w"):
self.written.add(filename.replace('\\', '/'))
return open(filename, mode)
class HtmlDeltaTest(HtmlTestHelpers, CoverageTest):
"""Tests of the HTML delta speed-ups."""
def setUp(self) -> None:
super().setUp()
# At least one of our tests monkey-patches the version of coverage.py,
# so grab it here to restore it later.
self.real_coverage_version = coverage.__version__
self.addCleanup(setattr, coverage, "__version__", self.real_coverage_version)
self.files_written: set[str]
def run_coverage(
self,
covargs: dict[str, Any] | None = None,
htmlargs: dict[str, Any] | None = None,
) -> float:
"""Run coverage in-process for the delta tests.
For the delta tests, we always want `source=.` and we want to track
which files are written. `self.files_written` will be the file names
that were opened for writing in html.py.
"""
covargs = covargs or {}
covargs['source'] = "."
self.files_written = set()
mock_open = FileWriteTracker(self.files_written).open
with mock.patch("coverage.html.open", mock_open):
return super().run_coverage(covargs=covargs, htmlargs=htmlargs)
def assert_htmlcov_files_exist(self) -> None:
"""Assert that all the expected htmlcov files exist."""
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/function_index.html")
self.assert_exists("htmlcov/class_index.html")
self.assert_exists("htmlcov/main_file_py.html")
self.assert_exists("htmlcov/helper1_py.html")
self.assert_exists("htmlcov/helper2_py.html")
self.assert_exists("htmlcov/.gitignore")
# Cache-busted files have random data in the name, but they should all
# be there, and there should only be one of each.
statics = ["style.css", "coverage_html.js", "keybd_closed.png", "favicon_32.png"]
files = os.listdir("htmlcov")
for static in statics:
base, ext = os.path.splitext(static)
busted_file_pattern = fr"{base}_cb_\w{{8}}{ext}"
matches = [m for f in files if (m := re.fullmatch(busted_file_pattern, f))]
assert len(matches) == 1, f"Found {len(matches)} files for {static}"
def test_html_created(self) -> None:
# Test basic HTML generation: files should be created.
self.create_initial_files()
self.run_coverage()
self.assert_htmlcov_files_exist()
def test_html_delta_from_source_change(self) -> None:
# HTML generation can create only the files that have changed.
# In this case, helper1 changes because its source is different.
self.create_initial_files()
self.run_coverage()
index1 = self.get_html_index_content()
# Now change a file (but only in a comment) and do it again.
self.make_file("helper1.py", """\
def func1(x): # A nice function
if x % 2:
print("odd")
""")
self.run_coverage()
# Only the changed files should have been created.
self.assert_htmlcov_files_exist()
assert "htmlcov/index.html" in self.files_written
assert "htmlcov/helper1_py.html" in self.files_written
assert "htmlcov/helper2_py.html" not in self.files_written
assert "htmlcov/main_file_py.html" not in self.files_written
# Because the source change was only a comment, the index is the same.
index2 = self.get_html_index_content()
assert index1 == index2
def test_html_delta_from_coverage_change(self) -> None:
# HTML generation can create only the files that have changed.
# In this case, helper1 changes because its coverage is different.
self.create_initial_files()
self.run_coverage()
# Now change a file and do it again. main_file is different, and calls
# helper1 differently.
self.make_file("main_file.py", """\
import helper1, helper2
helper1.func1(23)
helper2.func2(23)
""")
self.run_coverage()
# Only the changed files should have been created.
self.assert_htmlcov_files_exist()
assert "htmlcov/index.html" in self.files_written
assert "htmlcov/helper1_py.html" in self.files_written
assert "htmlcov/helper2_py.html" not in self.files_written
assert "htmlcov/main_file_py.html" in self.files_written
def test_html_delta_from_settings_change(self) -> None:
# HTML generation can create only the files that have changed.
# In this case, everything changes because the coverage.py settings
# have changed.
self.create_initial_files()
self.run_coverage(covargs=dict(omit=[]))
index1 = self.get_html_index_content()
self.run_coverage(covargs=dict(omit=['xyzzy*']))
# All the files have been reported again.
self.assert_htmlcov_files_exist()
assert "htmlcov/index.html" in self.files_written
assert "htmlcov/helper1_py.html" in self.files_written
assert "htmlcov/helper2_py.html" in self.files_written
assert "htmlcov/main_file_py.html" in self.files_written
index2 = self.get_html_index_content()
assert index1 == index2
def test_html_delta_from_coverage_version_change(self) -> None:
# HTML generation can create only the files that have changed.
# In this case, everything changes because the coverage.py version has
# changed.
self.create_initial_files()
self.run_coverage()
index1 = self.get_html_index_content()
# "Upgrade" coverage.py!
coverage.__version__ = "XYZZY"
self.run_coverage()
# All the files have been reported again.
self.assert_htmlcov_files_exist()
assert "htmlcov/index.html" in self.files_written
assert "htmlcov/helper1_py.html" in self.files_written
assert "htmlcov/helper2_py.html" in self.files_written
assert "htmlcov/main_file_py.html" in self.files_written
index2 = self.get_html_index_content()
fixed_index2 = index2.replace("XYZZY", self.real_coverage_version)
assert index1 == fixed_index2
def test_file_becomes_100(self) -> None:
self.create_initial_files()
self.run_coverage()
# Now change a file and do it again
self.make_file("main_file.py", """\
import helper1, helper2
# helper1 is now 100%
helper1.func1(12)
helper1.func1(23)
""")
self.run_coverage(htmlargs=dict(skip_covered=True))
# The 100% file, skipped, shouldn't be here.
self.assert_doesnt_exist("htmlcov/helper1_py.html")
def test_status_format_change(self) -> None:
self.create_initial_files()
self.run_coverage()
with open("htmlcov/status.json") as status_json:
status_data = json.load(status_json)
assert status_data['format'] == 5
status_data['format'] = 99
with open("htmlcov/status.json", "w") as status_json:
json.dump(status_data, status_json)
self.run_coverage()
# All the files have been reported again.
self.assert_htmlcov_files_exist()
assert "htmlcov/index.html" in self.files_written
assert "htmlcov/helper1_py.html" in self.files_written
assert "htmlcov/helper2_py.html" in self.files_written
assert "htmlcov/main_file_py.html" in self.files_written
def test_dont_overwrite_gitignore(self) -> None:
self.create_initial_files()
self.make_file("htmlcov/.gitignore", "# ignore nothing")
self.run_coverage()
with open("htmlcov/.gitignore") as fgi:
assert fgi.read() == "# ignore nothing"
def test_dont_write_gitignore_into_existing_directory(self) -> None:
self.create_initial_files()
self.make_file("htmlcov/README", "My files: don't touch!")
self.run_coverage()
self.assert_doesnt_exist("htmlcov/.gitignore")
self.assert_exists("htmlcov/index.html")
class HtmlTitleTest(HtmlTestHelpers, CoverageTest):
"""Tests of the HTML title support."""
def test_default_title(self) -> None:
self.create_initial_files()
self.run_coverage()
index = self.get_html_index_content()
assert "Coverage report" in index
assert "
Coverage report:" in index
def test_title_set_in_config_file(self) -> None:
self.create_initial_files()
self.make_file(".coveragerc", "[html]\ntitle = Metrics & stuff!\n")
self.run_coverage()
index = self.get_html_index_content()
assert "Metrics & stuff!" in index
assert "
Metrics & stuff!:" in index
def test_non_ascii_title_set_in_config_file(self) -> None:
self.create_initial_files()
self.make_file(".coveragerc", "[html]\ntitle = «ταБЬℓσ» numbers")
self.run_coverage()
index = self.get_html_index_content()
assert "«ταБЬℓσ» numbers" in index
assert "<h1>«ταБЬℓσ» numbers" in index
def test_title_set_in_args(self) -> None:
self.create_initial_files()
self.make_file(".coveragerc", "[html]\ntitle = Good title\n")
self.run_coverage(htmlargs=dict(title="«ταБЬℓσ» & stüff!"))
index = self.get_html_index_content()
expected = (
"<title>«ταБЬℓσ» " +
"& stüff!"
)
assert expected in index
assert "
«ταБЬℓσ» & stüff!:" in index
class HtmlWithUnparsableFilesTest(HtmlTestHelpers, CoverageTest):
"""Test the behavior when measuring unparsable files."""
def test_dotpy_not_python(self) -> None:
self.make_file("main.py", "import innocuous")
self.make_file("innocuous.py", "a = 1")
cov = coverage.Coverage()
self.start_import_stop(cov, "main")
self.make_file("innocuous.py", "
This isn't python!
")
msg = "Couldn't parse '.*innocuous.py' as Python source: .* at line 1"
with pytest.raises(NotPython, match=msg):
cov.html_report()
def test_dotpy_not_python_ignored(self) -> None:
self.make_file("main.py", "import innocuous")
self.make_file("innocuous.py", "a = 2")
cov = coverage.Coverage()
self.start_import_stop(cov, "main")
self.make_file("innocuous.py", "
This isn't python!
")
with pytest.warns(Warning) as warns:
cov.html_report(ignore_errors=True)
assert_coverage_warnings(
warns,
re.compile(r"Couldn't parse Python file '.*innocuous.py' \(couldnt-parse\)"),
)
self.assert_exists("htmlcov/index.html")
# This would be better as a glob, if the HTML layout changes:
self.assert_doesnt_exist("htmlcov/innocuous.html")
def test_dothtml_not_python(self) -> None:
# Run an "HTML" file
self.make_file("innocuous.html", "a = 3")
self.make_data_file(lines={abs_file("innocuous.html"): [1]})
# Before reporting, change it to be an HTML file.
self.make_file("innocuous.html", "
This isn't python at all!
")
cov = coverage.Coverage()
cov.load()
with pytest.raises(NoDataError, match="No data to report."):
cov.html_report()
def test_execed_liar_ignored(self) -> None:
# Jinja2 sets __file__ to be a non-Python file, and then execs code.
# If that file contains non-Python code, a TokenError shouldn't
# have been raised when writing the HTML report.
source = "exec(compile('','','exec'), {'__file__': 'liar.html'})"
self.make_file("liar.py", source)
self.make_file("liar.html", "{# Whoops, not python code #}")
cov = coverage.Coverage()
self.start_import_stop(cov, "liar")
cov.html_report()
self.assert_exists("htmlcov/index.html")
def test_execed_liar_ignored_indentation_error(self) -> None:
# Jinja2 sets __file__ to be a non-Python file, and then execs code.
# If that file contains untokenizable code, we shouldn't get an
# exception.
source = "exec(compile('','','exec'), {'__file__': 'liar.html'})"
self.make_file("liar.py", source)
# Tokenize will raise an IndentationError if it can't dedent.
self.make_file("liar.html", "0\n 2\n 1\n")
cov = coverage.Coverage()
self.start_import_stop(cov, "liar")
cov.html_report()
self.assert_exists("htmlcov/index.html")
def test_decode_error(self) -> None:
# https://github.com/nedbat/coveragepy/issues/351
# imp.load_module won't load a file with an undecodable character
# in a comment, though Python will run them. So we'll change the
# file after running.
self.make_file("main.py", "import sub.not_ascii")
self.make_file("sub/__init__.py")
self.make_file("sub/not_ascii.py", """\
# coding: utf-8
a = 1 # Isn't this great?!
""")
cov = coverage.Coverage()
self.start_import_stop(cov, "main")
# Create the undecodable version of the file. make_file is too helpful,
# so get down and dirty with bytes.
with open("sub/not_ascii.py", "wb") as f:
f.write(b"# coding: utf-8\na = 1 # Isn't this great?\xcb!\n")
with open("sub/not_ascii.py", "rb") as f:
undecodable = f.read()
assert b"?\xcb!" in undecodable
cov.html_report()
html_report = self.get_html_report_content("sub/not_ascii.py")
expected = "# Isn't this great?�!"
assert expected in html_report
def test_formfeeds(self) -> None:
# https://github.com/nedbat/coveragepy/issues/360
self.make_file("formfeed.py", "line_one = 1\n\f\nline_two = 2\n")
cov = coverage.Coverage()
self.start_import_stop(cov, "formfeed")
cov.html_report()
formfeed_html = self.get_html_report_content("formfeed.py")
assert "line_two" in formfeed_html
def test_splitlines_special_chars(self) -> None:
# https://github.com/nedbat/coveragepy/issues/1512
# See https://docs.python.org/3/library/stdtypes.html#str.splitlines for
# the characters splitlines treats specially that readlines does not.
# I'm not exactly sure why we need the "a" strings here, but the old
# code wasn't failing without them.
self.make_file("splitlines_is_weird.py", """\
test = {
"0b": ["\x0b0"], "a1": "this is line 2",
"0c": ["\x0c0"], "a2": "this is line 3",
"1c": ["\x1c0"], "a3": "this is line 4",
"1d": ["\x1d0"], "a4": "this is line 5",
"1e": ["\x1e0"], "a5": "this is line 6",
"85": ["\x850"], "a6": "this is line 7",
"2028": ["\u20280"], "a7": "this is line 8",
"2029": ["\u20290"], "a8": "this is line 9",
}
DONE = 1
""")
cov = coverage.Coverage()
self.start_import_stop(cov, "splitlines_is_weird")
cov.html_report()
the_html = self.get_html_report_content("splitlines_is_weird.py")
assert "DONE" in the_html
# Check that the lines are properly decoded and reported...
html_lines = the_html.split("\n")
assert any(re.search(r'id="t2".*"this is line 2"', line) for line in html_lines)
assert any(re.search(r'id="t9".*"this is line 9"', line) for line in html_lines)
class HtmlTest(HtmlTestHelpers, CoverageTest):
"""Moar HTML tests."""
def test_missing_source_file_incorrect_message(self) -> None:
# https://github.com/nedbat/coveragepy/issues/60
self.make_file("thefile.py", "import sub.another\n")
self.make_file("sub/__init__.py", "")
self.make_file("sub/another.py", "print('another')\n")
cov = coverage.Coverage()
self.start_import_stop(cov, 'thefile')
os.remove("sub/another.py")
missing_file = os.path.join(self.temp_dir, "sub", "another.py")
missing_file = os.path.realpath(missing_file)
msg = "(?i)No source for code: '%s'" % re.escape(missing_file)
with pytest.raises(NoSource, match=msg):
cov.html_report()
def test_extensionless_file_collides_with_extension(self) -> None:
# It used to be that "program" and "program.py" would both be reported
# to "program.html". Now they are not.
# https://github.com/nedbat/coveragepy/issues/69
self.make_file("program", "import program\n")
self.make_file("program.py", "a = 1\n")
self.make_data_file(lines={
abs_file("program"): [1],
abs_file("program.py"): [1],
})
cov = coverage.Coverage()
cov.load()
cov.html_report()
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/program.html")
self.assert_exists("htmlcov/program_py.html")
def test_has_date_stamp_in_files(self) -> None:
self.create_initial_files()
self.run_coverage()
with open("htmlcov/index.html") as f:
self.assert_correct_timestamp(f.read())
with open("htmlcov/main_file_py.html") as f:
self.assert_correct_timestamp(f.read())
def test_reporting_on_unmeasured_file(self) -> None:
# It should be ok to ask for an HTML report on a file that wasn't even
# measured at all. https://github.com/nedbat/coveragepy/issues/403
self.create_initial_files()
self.make_file("other.py", "a = 1\n")
self.run_coverage(htmlargs=dict(morfs=['other.py']))
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/other_py.html")
def make_main_and_not_covered(self) -> None:
"""Helper to create files for skip_covered scenarios."""
self.make_file("main_file.py", """\
import not_covered
def normal():
print("z")
normal()
""")
self.make_file("not_covered.py", """\
def not_covered():
print("n")
""")
def test_report_skip_covered(self) -> None:
self.make_main_and_not_covered()
self.run_coverage(htmlargs=dict(skip_covered=True))
self.assert_exists("htmlcov/index.html")
self.assert_doesnt_exist("htmlcov/main_file_py.html")
self.assert_exists("htmlcov/not_covered_py.html")
def test_html_skip_covered(self) -> None:
self.make_main_and_not_covered()
self.make_file(".coveragerc", "[html]\nskip_covered = True")
self.run_coverage()
self.assert_exists("htmlcov/index.html")
self.assert_doesnt_exist("htmlcov/main_file_py.html")
self.assert_exists("htmlcov/not_covered_py.html")
index = self.get_html_index_content()
assert "1 file skipped due to complete coverage." in index
def test_report_skip_covered_branches(self) -> None:
self.make_main_and_not_covered()
self.run_coverage(covargs=dict(branch=True), htmlargs=dict(skip_covered=True))
self.assert_exists("htmlcov/index.html")
self.assert_doesnt_exist("htmlcov/main_file_py.html")
self.assert_exists("htmlcov/not_covered_py.html")
def test_report_skip_covered_100(self) -> None:
self.make_file("main_file.py", """\
def normal():
print("z")
normal()
""")
res = self.run_coverage(covargs=dict(source="."), htmlargs=dict(skip_covered=True))
assert res == 100.0
self.assert_doesnt_exist("htmlcov/main_file_py.html")
# Since there are no files to report, we can't collect any region
# information, so there are no region-based index pages.
self.assert_doesnt_exist("htmlcov/function_index.html")
self.assert_doesnt_exist("htmlcov/class_index.html")
def test_report_skip_covered_100_functions(self) -> None:
self.make_file("main_file.py", """\
def normal():
print("z")
def abnormal():
print("a")
normal()
""")
res = self.run_coverage(covargs=dict(source="."), htmlargs=dict(skip_covered=True))
assert res == 80.0
self.assert_exists("htmlcov/main_file_py.html")
# We have a file to report, so we get function and class index pages,
# even though there are no classes.
self.assert_exists("htmlcov/function_index.html")
self.assert_exists("htmlcov/class_index.html")
def make_init_and_main(self) -> None:
"""Helper to create files for skip_empty scenarios."""
self.make_file("submodule/__init__.py", "")
self.make_file("main_file.py", """\
import submodule
def normal():
print("z")
normal()
""")
def test_report_skip_empty(self) -> None:
self.make_init_and_main()
self.run_coverage(htmlargs=dict(skip_empty=True))
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/main_file_py.html")
self.assert_doesnt_exist("htmlcov/submodule___init___py.html")
index = self.get_html_index_content()
assert "1 empty file skipped." in index
def test_html_skip_empty(self) -> None:
self.make_init_and_main()
self.make_file(".coveragerc", "[html]\nskip_empty = True")
self.run_coverage()
self.assert_exists("htmlcov/index.html")
self.assert_exists("htmlcov/main_file_py.html")
self.assert_doesnt_exist("htmlcov/submodule___init___py.html")
def filepath_to_regex(path: str) -> str:
"""Create a regex for scrubbing a file path."""
regex = re.escape(path)
# If there's a backslash, let it match either slash.
regex = regex.replace(r"\\", r"[\\/]")
if env.WINDOWS:
regex = "(?i)" + regex
return regex
def compare_html(
expected: str,
actual: str,
extra_scrubs: list[tuple[str, str]] | None = None,
) -> None:
"""Specialized compare function for our HTML files."""
__tracebackhide__ = True # pytest, please don't show me this function.
scrubs = [
(r'/coverage\.readthedocs\.io/?[-.\w/]*', '/coverage.readthedocs.io/VER'),
(r'coverage\.py v[\d.abcdev]+', 'coverage.py vVER'),
(r'created at \d\d\d\d-\d\d-\d\d \d\d:\d\d [-+]\d\d\d\d', 'created at DATE'),
(r'created at \d\d\d\d-\d\d-\d\d \d\d:\d\d', 'created at DATE'),
# Static files have cache busting.
(r'_cb_\w{8}\.', '_CB.'),
# Occasionally an absolute path is in the HTML report.
(filepath_to_regex(TESTS_DIR), 'TESTS_DIR'),
(filepath_to_regex(flat_rootname(str(TESTS_DIR))), '_TESTS_DIR'),
# The temp dir the tests make.
(filepath_to_regex(os.getcwd()), 'TEST_TMPDIR'),
(filepath_to_regex(flat_rootname(str(os.getcwd()))), '_TEST_TMPDIR'),
(filepath_to_regex(abs_file(os.getcwd())), 'TEST_TMPDIR'),
(filepath_to_regex(flat_rootname(str(abs_file(os.getcwd())))), '_TEST_TMPDIR'),
(r'/private/var/[\w/]+/pytest-of-\w+/pytest-\d+/(popen-gw\d+/)?t\d+', 'TEST_TMPDIR'),
# If the gold files were created on Windows, we need to scrub Windows paths also:
(r'[A-Z]:\\Users\\[\w\\]+\\pytest-of-\w+\\pytest-\d+\\(popen-gw\d+\\)?t\d+', 'TEST_TMPDIR'),
]
if extra_scrubs:
scrubs += extra_scrubs
compare(expected, actual, file_pattern="*.html", scrubs=scrubs)
def unbust(directory: str) -> None:
"""Find files with cache busting, and rename them to simple names.
This makes it possible for us to compare gold files.
"""
with change_dir(directory):
for fname in os.listdir("."):
base, ext = os.path.splitext(fname)
base, _, _ = base.partition("_cb_")
if base != fname:
os.rename(fname, base + ext)
class HtmlGoldTest(HtmlTestHelpers, CoverageTest):
"""Tests of HTML reporting that use gold files."""
def test_a(self) -> None:
self.make_file("a.py", """\
if 1 < 2:
# Needed a < to look at HTML entities.
a = 3
else:
a = 4
""")
cov = coverage.Coverage()
a = self.start_import_stop(cov, "a")
cov.html_report(a, directory='out/a')
compare_html(gold_path("html/a"), "out/a")
contains(
"out/a/a_py.html",
('if1 ' +
'<2'),
(' a ' +
'=3'),
'67%',
)
contains(
"out/a/index.html",
'a.py',
'67%',
'
67%
',
)
@pytest.mark.skipif(
env.PYPY and env.PYVERSION[:2] == (3, 8),
reason="PyPy 3.8 produces different results!?",
)
def test_b_branch(self) -> None:
self.make_file("b.py", """\
def one(x):
# This will be a branch that misses the else.
if x < 2:
a = 3
else:
a = 4
one(1)
def two(x):
# A missed else that branches to "exit"
if x:
a = 5
two(1)
def three():
try:
# This if has two branches, *neither* one taken.
if name_error_this_variable_doesnt_exist:
a = 1
else:
a = 2
except:
pass
three()
""")
cov = coverage.Coverage(branch=True)
b = self.start_import_stop(cov, "b")
cov.html_report(b, directory="out/b_branch")
compare_html(gold_path("html/b_branch"), "out/b_branch")
contains(
"out/b_branch/b_py.html",
('ifx ' +
'<2'),
(' a= ' +
'3'),
'70%',
('3 ↛ 6' +
'line 3 didn\'t jump to line 6 ' +
'because the condition on line 3 was always true'),
('12 ↛ exit' +
'line 12 didn\'t return from function \'two\' ' +
'because the condition on line 12 was always true'),
('20 ↛ 21, ' +
'20 ↛ 23' +
'2 missed branches: ' +
'1) line 20 didn\'t jump to line 21 ' +
'because the condition on line 20 was never true, ' +
'2) line 20 didn\'t jump to line 23 ' +
'because the condition on line 20 was always true'),
)
contains(
"out/b_branch/index.html",
'b.py',
'70%',
'
70%
',
)
def test_bom(self) -> None:
self.make_file("bom.py", bytes=b"""\
\xef\xbb\xbf# A Python source file in utf-8, with BOM.
math = "3\xc3\x974 = 12, \xc3\xb72 = 6\xc2\xb10"
assert len(math) == 18
assert len(math.encode('utf-8')) == 21
""".replace(b"\n", b"\r\n"))
# It's important that the source file really have a BOM, which can
# get lost, so check that it's really there, and that we have \r\n
# line endings.
with open("bom.py", "rb") as f:
data = f.read()
assert data[:3] == b"\xef\xbb\xbf"
assert data.count(b"\r\n") == 5
cov = coverage.Coverage()
bom = self.start_import_stop(cov, "bom")
cov.html_report(bom, directory="out/bom")
compare_html(gold_path("html/bom"), "out/bom")
contains(
"out/bom/bom_py.html",
'"3×4 = 12, ÷2 = 6±0"',
)
def test_isolatin1(self) -> None:
self.make_file("isolatin1.py", bytes=b"""\
# -*- coding: iso8859-1 -*-
# A Python source file in another encoding.
math = "3\xd74 = 12, \xf72 = 6\xb10"
assert len(math) == 18
""")
cov = coverage.Coverage()
isolatin1 = self.start_import_stop(cov, "isolatin1")
cov.html_report(isolatin1, directory="out/isolatin1")
compare_html(gold_path("html/isolatin1"), "out/isolatin1")
contains(
"out/isolatin1/isolatin1_py.html",
'"3×4 = 12, ÷2 = 6±0"',
)
def make_main_etc(self) -> None:
"""Make main.py and m1-m3.py for other tests."""
self.make_file("main.py", """\
import m1
import m2
import m3
a = 5
b = 6
assert m1.m1a == 1
assert m2.m2a == 1
assert m3.m3a == 1
""")
self.make_file("m1.py", """\
m1a = 1
m1b = 2
""")
self.make_file("m2.py", """\
m2a = 1
m2b = 2
""")
self.make_file("m3.py", """\
m3a = 1
m3b = 2
""")
def test_omit_1(self) -> None:
self.make_main_etc()
cov = coverage.Coverage(include=["./*"])
self.start_import_stop(cov, "main")
cov.html_report(directory="out/omit_1")
compare_html(gold_path("html/omit_1"), "out/omit_1")
def test_omit_2(self) -> None:
self.make_main_etc()
cov = coverage.Coverage(include=["./*"])
self.start_import_stop(cov, "main")
cov.html_report(directory="out/omit_2", omit=["m1.py"])
compare_html(gold_path("html/omit_2"), "out/omit_2")
def test_omit_3(self) -> None:
self.make_main_etc()
cov = coverage.Coverage(include=["./*"])
self.start_import_stop(cov, "main")
cov.html_report(directory="out/omit_3", omit=["m1.py", "m2.py"])
compare_html(gold_path("html/omit_3"), "out/omit_3")
def test_omit_4(self) -> None:
self.make_main_etc()
self.make_file("omit4.ini", """\
[report]
omit = m2.py
""")
cov = coverage.Coverage(config_file="omit4.ini", include=["./*"])
self.start_import_stop(cov, "main")
cov.html_report(directory="out/omit_4")
compare_html(gold_path("html/omit_4"), "out/omit_4")
def test_omit_5(self) -> None:
self.make_main_etc()
self.make_file("omit5.ini", """\
[report]
omit =
fooey
gooey, m[23]*, kablooey
helloworld
[html]
directory = out/omit_5
""")
cov = coverage.Coverage(config_file="omit5.ini", include=["./*"])
self.start_import_stop(cov, "main")
cov.html_report()
compare_html(gold_path("html/omit_5"), "out/omit_5")
def test_other(self) -> None:
self.make_file("src/here.py", """\
import other
if 1 < 2:
h = 3
else:
h = 4
""")
self.make_file("othersrc/other.py", """\
# A file in another directory. We're checking that it ends up in the
# HTML report.
print("This is the other src!")
""")
with change_dir("src"):
sys.path.insert(0, "../othersrc")
cov = coverage.Coverage(include=["./*", "../othersrc/*"])
self.start_import_stop(cov, "here")
cov.html_report(directory="../out/other")
# Different platforms will name the "other" file differently. Rename it
actual_file = list(glob.glob("out/other/*_other_py.html"))
assert len(actual_file) == 1
os.rename(actual_file[0], "out/other/blah_blah_other_py.html")
compare_html(
gold_path("html/other"), "out/other",
extra_scrubs=[
(r'href="z_[0-9a-z]{16}_other_', 'href="_TEST_TMPDIR_other_othersrc_'),
(r'TEST_TMPDIR\\othersrc\\other.py', 'TEST_TMPDIR/othersrc/other.py'),
],
)
contains(
'out/other/index.html',
'here.py',
'other_py.html">',
'other.py',
)
def test_partial(self) -> None:
self.make_file("partial.py", """\
# partial branches and excluded lines
a = 2
while "no peephole".upper(): # t4
break
while a: # pragma: no branch
break
if 0:
never_happen()
if 13:
a = 14
if a == 16:
raise ZeroDivisionError("17")
""")
self.make_file("partial.ini", """\
[run]
branch = True
[report]
exclude_lines =
raise ZeroDivisionError
""")
cov = coverage.Coverage(config_file="partial.ini")
partial = self.start_import_stop(cov, "partial")
if env.PYBEHAVIOR.pep626:
cov.html_report(partial, directory="out/partial_626")
compare_html(gold_path("html/partial_626"), "out/partial_626")
contains_rx(
"out/partial_626/partial_py.html",
r'
.* id="t4"',
r'
.* id="t7"',
# The "if 0" and "if 1" statements are marked as run.
r'
.* id="t10"',
# The "raise ZeroDivisionError" is excluded by regex in the .ini.
r'