Create a JSON report

Author: Bachmann1234

CHANGES.rst

@@ -33,6 +33,9 @@ Unreleased
 - `debug=plugin` didn't properly support configuration or dynamic context
   plugins, but now it does, closing `issue 834`_.
 
+- Added a JSON report `issue 720`_.
+
+.. _issue 720: https://github.com/nedbat/coveragepy/issues/720
 .. _issue 822: https://github.com/nedbat/coveragepy/issues/822
 .. _issue 834: https://github.com/nedbat/coveragepy/issues/834
 .. _issue 829: https://github.com/nedbat/coveragepy/issues/829

CONTRIBUTORS.txt

@@ -79,6 +79,7 @@ Marc Abramowitz
 Marcus Cobden
 Mark van der Wal
 Martin Fuzzey
+Matt Bachmann
 Matthew Boehm
 Matthew Desmarais
 Max Linke

coverage/cmdline.py

@@ -118,6 +118,15 @@ class Opts(object):
         metavar="OUTFILE",
         help="Write the XML report to this file. Defaults to 'coverage.xml'",
     )
+    output_json = optparse.make_option(
+        '-o', '', action='store', dest="outfile",
+        metavar="OUTFILE",
+        help="Write the JSON report to this file. Defaults to 'coverage.json'",
+    )
+    json_pretty_print = optparse.make_option(
+        '', '--pretty-print', action='store_true',
+        help="Print the json formatted for human readers",
+    )
     parallel_mode = optparse.make_option(
         '-p', '--parallel-mode', action='store_true',
         help=(
@@ -402,6 +411,22 @@ def get_prog_name(self):
         usage="[options] [modules]",
         description="Generate an XML report of coverage results."
     ),
+
+    'json': CmdOptionParser(
+        "json",
+        [
+            Opts.fail_under,
+            Opts.ignore_errors,
+            Opts.include,
+            Opts.omit,
+            Opts.output_json,
+            Opts.json_pretty_print,
+            Opts.show_contexts,
+            Opts.contexts,
+            ] + GLOBAL_ARGS,
+        usage="[options] [modules]",
+        description="Generate a JSON report of coverage results."
+    ),
 }
 
 
@@ -565,6 +590,14 @@ def command_line(self, argv):
         elif options.action == "xml":
             outfile = options.outfile
             total = self.coverage.xml_report(outfile=outfile, **report_args)
+        elif options.action == "json":
+            outfile = options.outfile
+            total = self.coverage.json_report(
+                outfile=outfile,
+                pretty_print=options.pretty_print,
+                show_contexts=options.show_contexts,
+                **report_args
+            )
 
         if total is not None:
             # Apply the command line fail-under options, and then use the config
@@ -752,6 +785,7 @@ def unglob_args(args):
             erase       Erase previously collected coverage data.
             help        Get help on using coverage.py.
             html        Create an HTML report.
+            json        Create a JSON report of coverage results.
             report      Report coverage stats on modules.
             run         Run a Python program and measure code execution.
             xml         Create an XML report of coverage results.

coverage/config.py

@@ -215,6 +215,11 @@ def __init__(self):
         self.xml_output = "coverage.xml"
         self.xml_package_depth = 99
 
+        # Defaults for [JSON]
+        self.json_output = "coverage.json"
+        self.json_pretty_print = False
+        self.json_show_contexts = False
+
         # Defaults for [paths]
         self.paths = {}
 
@@ -363,6 +368,11 @@ def from_file(self, filename, our_file):
         # [xml]
         ('xml_output', 'xml:output'),
         ('xml_package_depth', 'xml:package_depth', 'int'),
+
+        # [json]
+        ('json_output', 'json:output'),
+        ('json_pretty_print', 'json:pretty_print', 'boolean'),
+        ('json_show_contexts', 'json:show_contexts', 'boolean'),
     ]
 
     def _set_attr_from_config_option(self, cp, attr, where, type_=''):

coverage/control.py

@@ -22,11 +22,13 @@
 from coverage.files import PathAliases, set_relative_directory, abs_file
 from coverage.html import HtmlReporter
 from coverage.inorout import InOrOut
+from coverage.jsonreport import JsonReporter
 from coverage.misc import CoverageException, bool_or_none, join_regex
-from coverage.misc import ensure_dir_for_file, file_be_gone, isolate_module
+from coverage.misc import ensure_dir_for_file, isolate_module
 from coverage.plugin import FileReporter
 from coverage.plugin_support import Plugins
 from coverage.python import PythonFileReporter
+from coverage.report import render_report
 from coverage.results import Analysis, Numbers
 from coverage.summary import SummaryReporter
 from coverage.xmlreport import XmlReporter
@@ -862,33 +864,29 @@ def xml_report(
             ignore_errors=ignore_errors, report_omit=omit, report_include=include,
             xml_output=outfile, report_contexts=contexts,
             )
-        file_to_close = None
-        delete_file = False
-        if self.config.xml_output:
-            if self.config.xml_output == '-':
-                outfile = sys.stdout
-            else:
-                # Ensure that the output directory is created; done here
-                # because this report pre-opens the output file.
-                # HTMLReport does this using the Report plumbing because
-                # its task is more complex, being multiple files.
-                ensure_dir_for_file(self.config.xml_output)
-                open_kwargs = {}
-                if env.PY3:
-                    open_kwargs['encoding'] = 'utf8'
-                outfile = open(self.config.xml_output, "w", **open_kwargs)
-                file_to_close = outfile
-        try:
-            reporter = XmlReporter(self)
-            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)
+        return render_report(self.config.xml_output, XmlReporter(self), morfs)
+
+    def json_report(
+        self, morfs=None, outfile=None, ignore_errors=None,
+        omit=None, include=None, contexts=None, pretty_print=None,
+        show_contexts=None
+    ):
+        """Generate a JSON report of coverage results.
+
+        Each module in `morfs` is included in the report.  `outfile` is the
+        path to write the file to, "-" will write to stdout.
+
+        See :meth:`report` for other arguments.
+
+        Returns a float, the total percentage covered.
+
+        """
+        self.config.from_args(
+            ignore_errors=ignore_errors, report_omit=omit, report_include=include,
+            json_output=outfile, report_contexts=contexts, json_pretty_print=pretty_print,
+            json_show_contexts=show_contexts
+        )
+        return render_report(self.config.json_output, JsonReporter(self), morfs)
 
     def sys_info(self):
         """Return a list of (key, value) pairs showing internal information."""

coverage/jsonreport.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+# Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
+# For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
+
+"""Json reporting for coverage.py"""
+import datetime
+import json
+import sys
+
+from coverage import __version__
+from coverage.report import get_analysis_to_report
+from coverage.results import Numbers
+
+
+class JsonReporter(object):
+    """A reporter for writing JSON coverage results."""
+
+    def __init__(self, coverage):
+        self.coverage = coverage
+        self.config = self.coverage.config
+        self.total = Numbers()
+        self.report_data = {}
+
+    def report(self, morfs, outfile=None):
+        """Generate a json report for `morfs`.
+
+        `morfs` is a list of modules or file names.
+
+        `outfile` is a file object to write the json to
+
+        """
+        outfile = outfile or sys.stdout
+        coverage_data = self.coverage.get_data()
+        coverage_data.set_query_contexts(self.config.report_contexts)
+        self.report_data["meta"] = {
+            "version": __version__,
+            "timestamp": datetime.datetime.now().isoformat(),
+            "branch_coverage": coverage_data.has_arcs(),
+            "show_contexts": self.config.json_show_contexts,
+        }
+
+        measured_files = {}
+        for file_reporter, analysis in get_analysis_to_report(self.coverage, morfs):
+            measured_files[file_reporter.relative_filename()] = self.report_one_file(
+                coverage_data,
+                file_reporter,
+                analysis
+            )
+
+        self.report_data["files"] = measured_files
+
+        self.report_data["totals"] = {
+            'covered_lines': self.total.n_executed,
+            'num_statements': self.total.n_statements,
+            'percent_covered': self.total.pc_covered,
+            'missing_lines': self.total.n_missing,
+            'excluded_lines': self.total.n_excluded,
+        }
+
+        if coverage_data.has_arcs():
+            self.report_data["totals"].update({
+                'num_branches': self.total.n_branches,
+                'num_partial_branches': self.total.n_partial_branches,
+            })
+
+        json.dump(
+            self.report_data,
+            outfile,
+            indent=4 if self.config.json_pretty_print else None
+        )
+
+        return self.total.n_statements and self.total.pc_covered
+
+    def report_one_file(self, coverage_data, file_reporter, analysis):
+        """Extract the relevant report data for a single file"""
+        nums = analysis.numbers
+        self.total += nums
+        summary = {
+            'covered_lines': nums.n_executed,
+            'num_statements': nums.n_statements,
+            'percent_covered': nums.pc_covered,
+            'missing_lines': nums.n_missing,
+            'excluded_lines': nums.n_excluded,
+        }
+        reported_file = {
+            'executed_lines': sorted(analysis.executed),
+            'summary': summary,
+            'missing_lines': sorted(analysis.missing),
+            'excluded_lines': sorted(analysis.excluded)
+        }
+        if self.config.json_show_contexts:
+            reported_file['contexts'] = analysis.data.contexts_by_lineno(
+                file_reporter.filename
+            )
+        if coverage_data.has_arcs():
+            reported_file['summary'].update({
+                'num_branches': nums.n_branches,
+                'num_partial_branches': nums.n_partial_branches,
+            })
+        return reported_file

coverage/report.py

@@ -2,9 +2,45 @@
 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
 
 """Reporter foundation for coverage.py."""
+import sys
 
+from coverage import env
 from coverage.files import prep_patterns, FnmatchMatcher
-from coverage.misc import CoverageException, NoSource, NotPython
+from coverage.misc import CoverageException, NoSource, NotPython, ensure_dir_for_file, file_be_gone
+
+
+def render_report(output_path, reporter, morfs):
+    """Run the provided reporter ensuring any required setup and cleanup is done
+
+    At a high level this method ensures the output file is ready to be written to. Then writes the
+    report to it. Then closes the file and deletes any garbage created if necessary.
+    """
+    file_to_close = None
+    delete_file = False
+    if output_path:
+        if output_path == '-':
+            outfile = sys.stdout
+        else:
+            # Ensure that the output directory is created; done here
+            # because this report pre-opens the output file.
+            # HTMLReport does this using the Report plumbing because
+            # its task is more complex, being multiple files.
+            ensure_dir_for_file(output_path)
+            open_kwargs = {}
+            if env.PY3:
+                open_kwargs['encoding'] = 'utf8'
+            outfile = open(output_path, "w", **open_kwargs)
+            file_to_close = outfile
+    try:
+        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(output_path)
 
 
 def get_analysis_to_report(coverage, morfs):

coverage/results.py

@@ -23,7 +23,8 @@ def __init__(self, data, file_reporter):
         # Identify missing statements.
         executed = self.data.lines(self.filename) or []
         executed = self.file_reporter.translate_lines(executed)
-        self.missing = self.statements - executed
+        self.executed = executed
+        self.missing = self.statements - self.executed
 
         if self.data.has_arcs():
             self._arc_possibilities = sorted(self.file_reporter.arcs())