Merge branch 'nedbat/contexts'

4 files changed, 136 insertions, 32 deletions

diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index 59c76c73..db89137b 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -33,7 +33,7 @@ class BaseCmdLineTest(CoverageTest):
     defaults.Coverage(
         cover_pylib=None, data_suffix=None, timid=None, branch=None,
         config_file=True, source=None, include=None, omit=None, debug=None,
-        concurrency=None, check_preimported=True,
+        concurrency=None, check_preimported=True, context=None,
     )
     defaults.annotate(
         directory=None, ignore_errors=None, include=None, omit=None, morfs=[],
diff --git a/tests/test_context.py b/tests/test_context.py
new file mode 100644
index 00000000..a6be922d
--- /dev/null
+++ b/tests/test_context.py
@@ -0,0 +1,104 @@
+# 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 for context support."""
+
+import os.path
+
+import coverage
+from coverage.data import CoverageData
+
+from tests.coveragetest import CoverageTest
+
+
+class GlobalContextTest(CoverageTest):
+    """Tests of the global context."""
+
+    def setUp(self):
+        super(GlobalContextTest, self).setUp()
+        self.skip_unless_data_storage_is("sql")
+
+    def test_no_context(self):
+        self.make_file("main.py", "a = 1")
+        cov = coverage.Coverage()
+        self.start_import_stop(cov, "main")
+        data = cov.get_data()
+        self.assertCountEqual(data.measured_contexts(), [""])
+
+    def test_global_context(self):
+        self.make_file("main.py", "a = 1")
+        cov = coverage.Coverage(context="gooey")
+        self.start_import_stop(cov, "main")
+        data = cov.get_data()
+        self.assertCountEqual(data.measured_contexts(), ["gooey"])
+
+    SOURCE = """\
+        a = 1
+        if a > 2:
+            a = 3
+        assert a == 1
+        """
+
+    LINES = [1, 2, 4]
+    ARCS = [(-1, 1), (1, 2), (2, 4), (4, -1)]
+
+    def run_red_blue(self, **options):
+        """Run red.py and blue.py, and return their CoverageData objects."""
+        self.make_file("red.py", self.SOURCE)
+        red_cov = coverage.Coverage(context="red", data_suffix="r", source=["."], **options)
+        self.start_import_stop(red_cov, "red")
+        red_cov.save()
+        red_data = red_cov.get_data()
+
+        self.make_file("blue.py", self.SOURCE)
+        blue_cov = coverage.Coverage(context="blue", data_suffix="b", source=["."], **options)
+        self.start_import_stop(blue_cov, "blue")
+        blue_cov.save()
+        blue_data = blue_cov.get_data()
+
+        return red_data, blue_data
+
+    def test_combining_line_contexts(self):
+        red_data, blue_data = self.run_red_blue()
+        for datas in [[red_data, blue_data], [blue_data, red_data]]:
+            combined = CoverageData(suffix="combined")
+            for data in datas:
+                combined.update(data)
+
+            self.assertEqual(combined.measured_contexts(), {'red', 'blue'})
+
+            full_names = {os.path.basename(f): f for f in combined.measured_files()}
+            self.assertCountEqual(full_names, ['red.py', 'blue.py'])
+
+            fred = full_names['red.py']
+            fblue = full_names['blue.py']
+
+            self.assertEqual(combined.lines(fred, context='red'), self.LINES)
+            self.assertEqual(combined.lines(fred, context='blue'), [])
+            self.assertEqual(combined.lines(fblue, context='red'), [])
+            self.assertEqual(combined.lines(fblue, context='blue'), self.LINES)
+
+    def test_combining_arc_contexts(self):
+        red_data, blue_data = self.run_red_blue(branch=True)
+        for datas in [[red_data, blue_data], [blue_data, red_data]]:
+            combined = CoverageData(suffix="combined")
+            for data in datas:
+                combined.update(data)
+
+            self.assertEqual(combined.measured_contexts(), {'red', 'blue'})
+
+            full_names = {os.path.basename(f): f for f in combined.measured_files()}
+            self.assertCountEqual(full_names, ['red.py', 'blue.py'])
+
+            fred = full_names['red.py']
+            fblue = full_names['blue.py']
+
+            self.assertEqual(combined.lines(fred, context='red'), self.LINES)
+            self.assertEqual(combined.lines(fred, context='blue'), [])
+            self.assertEqual(combined.lines(fblue, context='red'), [])
+            self.assertEqual(combined.lines(fblue, context='blue'), self.LINES)
+
+            self.assertEqual(combined.arcs(fred, context='red'), self.ARCS)
+            self.assertEqual(combined.arcs(fred, context='blue'), [])
+            self.assertEqual(combined.arcs(fblue, context='red'), [])
+            self.assertEqual(combined.arcs(fblue, context='blue'), self.ARCS)
diff --git a/tests/test_debug.py b/tests/test_debug.py
index 284d9567..63edc84f 100644
--- a/tests/test_debug.py
+++ b/tests/test_debug.py
@@ -144,8 +144,8 @@ class DebugTraceTest(CoverageTest):
             self.assertRegex(real_messages[-1], r"^\s*\d+\.\w{4}: Writing data")
             self.assertRegex(last_line, r"\s+_write_file : .*coverage[/\\]data.py @\d+$")
         else:
-            self.assertRegex(real_messages[-1], r"^\s*\d+\.\w{4}: Creating data file")
-            self.assertRegex(last_line, r"\s+_create_db : .*coverage[/\\]sqldata.py @\d+$")
+            self.assertRegex(real_messages[-1], r"^\s*\d+\.\w{4}: Adding lines")
+            self.assertRegex(last_line, r"\s+add_lines : .*coverage[/\\]sqldata.py @\d+$")
 
     def test_debug_config(self):
         out_lines = self.f1_debug_output(["config"])
diff --git a/tests/test_summary.py b/tests/test_summary.py
index 936df7fa..c3b572d2 100644
--- a/tests/test_summary.py
+++ b/tests/test_summary.py
@@ -750,24 +750,31 @@ class ReportingReturnValueTest(CoverageTest):
 class TestSummaryReporterConfiguration(CoverageTest):
     """Tests of SummaryReporter."""
 
-    LINES_1 = {
-        os.path.join(TESTS_DIR, "test_api.py"): dict.fromkeys(range(400)),
-        os.path.join(TESTS_DIR, "test_backward.py"): dict.fromkeys(range(20)),
-        os.path.join(TESTS_DIR, "test_coverage.py"): dict.fromkeys(range(15)),
-    }
-
-    def get_coverage_data(self, lines):
-        """Get a CoverageData object that includes the requested lines."""
-        data = CoverageData()
-        data.add_lines(lines)
-        return data
-
-    def get_summary_text(self, coverage_data, options):
+    def make_rigged_file(self, filename, stmts, miss):
+        """Create a file that will have specific results.
+
+        `stmts` and `miss` are ints, the number of statements, and
+        missed statements that should result.
+        """
+        run = stmts - miss - 1
+        dont_run = miss
+        source = ""
+        source += "a = 1\n" * run
+        source += "if a == 99:\n"
+        source += "    a = 2\n" * dont_run
+        self.make_file(filename, source)
+
+    def get_summary_text(self, options):
         """Get text output from the SummaryReporter."""
-        cov = Coverage()
+        self.make_rigged_file("file1.py", 339, 155)
+        self.make_rigged_file("file2.py", 13, 3)
+        self.make_rigged_file("file3.py", 234, 228)
+        self.make_file("doit.py", "import file1, file2, file3")
+
+        cov = Coverage(source=["."], omit=["doit.py"])
         cov.start()
+        import doit             # pragma: nested # pylint: disable=import-error, unused-variable
         cov.stop()              # pragma: nested
-        cov._data = coverage_data
         printer = SummaryReporter(cov, options)
         destination = StringIO()
         printer.report([], destination)
@@ -777,8 +784,7 @@ class TestSummaryReporterConfiguration(CoverageTest):
         # We use our own test files as test data. Check that our assumptions
         # about them are still valid.  We want the three columns of numbers to
         # sort in three different orders.
-        data = self.get_coverage_data(self.LINES_1)
-        report = self.get_summary_text(data, CoverageConfig())
+        report = self.get_summary_text(CoverageConfig())
         print(report)
         # Name                     Stmts   Miss  Cover
         # --------------------------------------------
@@ -802,18 +808,16 @@ class TestSummaryReporterConfiguration(CoverageTest):
 
     def test_defaults(self):
         """Run the report with no configuration options."""
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
-        report = self.get_summary_text(data, opts)
+        report = self.get_summary_text(opts)
         self.assertNotIn('Missing', report)
         self.assertNotIn('Branch', report)
 
     def test_print_missing(self):
         """Run the report printing the missing lines."""
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
         opts.from_args(show_missing=True)
-        report = self.get_summary_text(data, opts)
+        report = self.get_summary_text(opts)
         self.assertIn('Missing', report)
         self.assertNotIn('Branch', report)
 
@@ -827,33 +831,29 @@ class TestSummaryReporterConfiguration(CoverageTest):
 
     def test_sort_report_by_stmts(self):
         # Sort the text report by the Stmts column.
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
         opts.from_args(sort='Stmts')
-        report = self.get_summary_text(data, opts)
+        report = self.get_summary_text(opts)
         self.assert_ordering(report, "test_backward.py", "test_coverage.py", "test_api.py")
 
     def test_sort_report_by_missing(self):
         # Sort the text report by the Missing column.
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
         opts.from_args(sort='Miss')
-        report = self.get_summary_text(data, opts)
+        report = self.get_summary_text(opts)
         self.assert_ordering(report, "test_backward.py", "test_api.py", "test_coverage.py")
 
     def test_sort_report_by_cover(self):
         # Sort the text report by the Cover column.
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
         opts.from_args(sort='Cover')
-        report = self.get_summary_text(data, opts)
+        report = self.get_summary_text(opts)
         self.assert_ordering(report, "test_coverage.py", "test_api.py", "test_backward.py")
 
     def test_sort_report_by_invalid_option(self):
         # Sort the text report by a nonsense column.
-        data = self.get_coverage_data(self.LINES_1)
         opts = CoverageConfig()
         opts.from_args(sort='Xyzzy')
         msg = "Invalid sorting option: 'Xyzzy'"
         with self.assertRaisesRegex(CoverageException, msg):
-            self.get_summary_text(data, opts)
+            self.get_summary_text(opts)