How to use coverage - 10 common examples

def html_it():
    """Run coverage and make an HTML report for tabbed."""
    import coverage
    cov = coverage.coverage()
    cov.start()
    import tabbed           # pragma: nested
    cov.stop()              # pragma: nested
    cov.html_report(tabbed, directory="../html_tabbed")

def run():
    if coverage_available:
        cov = coverage(source=['flask_testing'])
        cov.start()

    from tests import suite
    result = unittest.TextTestRunner(verbosity=2).run(suite())
    if not result.wasSuccessful():
        sys.exit(1)

    if coverage_available:
        cov.stop()

        print("\nCode Coverage")
        cov.report()
        cov.html_report(directory='cover')
    else:
        print("\nTipp:\n\tUse 'pip install coverage' to get great code "
              "coverage stats")

def html_it():
    """Run coverage and make an HTML report for partial."""
    import coverage
    cov = coverage.coverage(branch=True)
    cov.start()
    import partial          # pragma: nested
    cov.stop()              # pragma: nested
    cov.html_report(partial, directory="../html_partial")

def html_it():
    """Run coverage.py with branches and make an HTML report for b."""
    import coverage
    cov = coverage.Coverage(branch=True)
    cov.start()
    import b            # pragma: nested
    cov.stop()          # pragma: nested
    cov.html_report(b, directory="../html_b_branch")

def run():
    os.environ['FLACK_CONFIG'] = 'testing'

    # start coverage engine
    cov = coverage.Coverage(branch=True)
    cov.start()

    # run tests
    tests = unittest.TestLoader().discover('.')
    ok = unittest.TextTestRunner(verbosity=2).run(tests).wasSuccessful()

    # print coverage report
    cov.stop()
    print('')
    cov.report(omit=['manage.py', 'tests/*', 'venv*/*'])

    sys.exit(0 if ok else 1)

import coverage
import os
import unittest
import sys

cov = coverage.Coverage()
cov.start()

suite = unittest.defaultTestLoader.discover('.')
if not unittest.TextTestRunner().run(suite).wasSuccessful():
    exit(1)

cov.stop()
cov.xml_report()

if '--save-html-report' in sys.argv:
    cov.html_report()

def merge_coverage(coverage_data, from_path, to_path):
    new_coverage_data = CoverageData()
    assert coverage_data._filename != new_coverage_data._filename

    for filename in coverage_data.measured_files():
        result_filename = filename.split(from_path)[-1]
        if filename != result_filename:
            result_filename = result_filename.lstrip('/')
            result_filename = os.path.join(to_path, result_filename)
            result_filename = os.path.abspath(result_filename)
            assert os.path.exists(result_filename), result_filename

        new_coverage_data.add_arcs(
            {result_filename: coverage_data.arcs(filename)}
        )

    return new_coverage_data

def test_contexts(testdir, opts):
    with open(os.path.join(os.path.dirname(__file__), "contextful.py")) as f:
        contextful_tests = f.read()
    script = testdir.makepyfile(contextful_tests)
    result = testdir.runpytest('-v',
                               '--cov=%s' % script.dirpath(),
                               '--cov-context=test',
                               script,
                               *opts.split()
                               )
    assert result.ret == 0
    result.stdout.fnmatch_lines([
        'test_contexts* 100%*',
    ])

    data = coverage.CoverageData(".coverage")
    data.read()
    assert data.measured_contexts() == set(EXPECTED_CONTEXTS)
    measured = data.measured_files()
    assert len(measured) == 1
    test_context_path = list(measured)[0]
    assert test_context_path.lower() == os.path.abspath("test_contexts.py").lower()

    line_data = find_labels(contextful_tests, r"[crst]\d+(?:-\d+)?")
    for context, label in EXPECTED_CONTEXTS.items():
        if context == '':
            continue
        data.set_query_context(context)
        actual = data.lines(test_context_path)
        assert line_data[label] == actual, "Wrong lines for context {!r}".format(context)

def compute_coverage(branch):
    coverage_data = CoverageData()
    try:
        with project_path.join('.coverage').open() as fp:
            coverage_data.read_file(fp)
    except Exception:
        print("No coverage data found", file=sys.stderr)

    git_proc = subprocess.Popen(['git', 'diff', '-U0', branch],
        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    git_output = git_proc.stdout.read()
    files = git_output.split("diff --git")

    from collections import defaultdict
    file_data = defaultdict(list)

    for the_file in files:
        filenames = re.findall('a/(.*?) b/(.*)', the_file)

options.fork)
        test_suite.addTest(
            filetests.handle_directory(
                os.path.join(sys.prefix, 'lib', 'python'+sys.version[:3], 'test'),
                'pyregr'))

    result = unittest.TextTestRunner(verbosity=options.verbosity).run(test_suite)

    if options.coverage:
        coverage.stop()
        ignored_modules = ('Options', 'Version', 'DebugFlags', 'CmdLine')
        modules = [ module for name, module in sys.modules.items()
                    if module is not None and
                    name.startswith('Cython.Compiler.') and 
                    name[len('Cython.Compiler.'):] not in ignored_modules ]
        coverage.report(modules, show_missing=0)

    if missing_dep_excluder.tests_missing_deps:
        sys.stderr.write("Following tests excluded because of missing dependencies on your system:\n")
        for test in missing_dep_excluder.tests_missing_deps:
            sys.stderr.write("   %s\n" % test)

    if options.with_refnanny:
        import refnanny
        sys.stderr.write("\n".join([repr(x) for x in refnanny.reflog]))

    sys.exit(not result.wasSuccessful())