Use implicit mock patching instead of explicit DI for cmdline tests

This sets us up for mocking more or different globals without adding
more explicit DI overrides in cmdline.py.

1 files changed, 288 insertions, 280 deletions

diff --git a/tests/test_cmdline.py b/tests/test_cmdline.py
index fec0787b..18702c96 100644
--- a/tests/test_cmdline.py
+++ b/tests/test_cmdline.py
@@ -5,7 +5,6 @@
 
 import os
 import pprint
-import re
 import sys
 import textwrap
 
@@ -30,48 +29,50 @@ class BaseCmdLineTest(CoverageTest):
 
     # Make a dict mapping function names to the default values that cmdline.py
     # uses when calling the function.
-    defaults = mock.Mock()
-    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, context=None,
-    )
-    defaults.annotate(
+    _defaults = mock.Mock()
+    _defaults.Coverage().annotate(
         directory=None, ignore_errors=None, include=None, omit=None, morfs=[],
     )
-    defaults.html_report(
+    _defaults.Coverage().html_report(
         directory=None, ignore_errors=None, include=None, omit=None, morfs=[],
         skip_covered=None, title=None
     )
-    defaults.report(
+    _defaults.Coverage().report(
         ignore_errors=None, include=None, omit=None, morfs=[],
         show_missing=None, skip_covered=None
     )
-    defaults.xml_report(
+    _defaults.Coverage().xml_report(
         ignore_errors=None, include=None, omit=None, morfs=[], outfile=None,
     )
+    _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, context=None,
+    )
 
-    DEFAULT_KWARGS = dict((name, kw) for name, _, kw in defaults.mock_calls)
+    DEFAULT_KWARGS = dict((name, kw) for name, _, kw in _defaults.mock_calls)
 
     def model_object(self):
         """Return a Mock suitable for use in CoverageScript."""
         mk = mock.Mock()
-        # We'll invoke .Coverage as the constructor, and then keep using the
-        # same object as the resulting coverage object.
-        mk.Coverage.return_value = mk
+
+        cov = mk.Coverage.return_value
 
         # The mock needs options.
-        config = CoverageConfig()
-        mk.get_option = config.get_option
-        mk.set_option = config.set_option
+        mk.config = CoverageConfig()
+        cov.get_option = mk.config.get_option
+        cov.set_option = mk.config.set_option
 
         # Get the type right for the result of reporting.
-        mk.report.return_value = 50.0
-        mk.html_report.return_value = 50.0
-        mk.xml_report.return_value = 50.0
+        cov.report.return_value = 50.0
+        cov.html_report.return_value = 50.0
+        cov.xml_report.return_value = 50.0
 
         return mk
 
+    # Global names in cmdline.py that will be mocked during the tests.
+    MOCK_GLOBALS = ['Coverage', 'run_python_file', 'run_python_module']
+
     def mock_command_line(self, args, options=None):
         """Run `args` through the command line, with a Mock.
 
@@ -80,55 +81,64 @@ class BaseCmdLineTest(CoverageTest):
         Returns the Mock it used and the status code returned.
 
         """
-        m = self.model_object()
-
-        for name, value in (options or {}).items():
-            m.set_option(name, value)
-
-        ret = command_line(
-            args,
-            _covpkg=m, _run_python_file=m.run_python_file,
-            _run_python_module=m.run_python_module, _help_fn=m.help_fn,
-            )
-
-        return m, ret
+        mk = self.model_object()
+
+        if options is not None:
+            for name, value in options.items():
+                mk.config.set_option(name, value)
+
+        patchers = [
+            mock.patch("coverage.cmdline."+name, getattr(mk, name))
+            for name in self.MOCK_GLOBALS
+            ]
+        for patcher in patchers:
+            patcher.start()
+        try:
+            ret = command_line(args, _help_fn=mk.help_fn)
+        finally:
+            for patcher in patchers:
+                patcher.stop()
+
+        return mk, ret
 
     def cmd_executes(self, args, code, ret=OK, options=None):
         """Assert that the `args` end up executing the sequence in `code`."""
-        m1, r1 = self.mock_command_line(args, options=options)
-        self.assertEqual(r1, ret, "Wrong status: got %r, wanted %r" % (r1, ret))
-
-        # Remove all indentation, and change ".foo()" to "m2.foo()".
-        code = re.sub(r"(?m)^\s+", "", code)
-        code = re.sub(r"(?m)^\.", "m2.", code)
-        m2 = self.model_object()
+        called, status = self.mock_command_line(args, options=options)
+        self.assertEqual(status, ret, "Wrong status: got %r, wanted %r" % (status, ret))
+
+        # Remove all indentation, and execute with mock globals
+        code = textwrap.dedent(code)
+        expected = self.model_object()
+        globs = {n: getattr(expected, n) for n in self.MOCK_GLOBALS}
+        globs['self'] = expected
         code_obj = compile(code, "<code>", "exec")
-        eval(code_obj, globals(), {'m2': m2})       # pylint: disable=eval-used
+        eval(code_obj, globs, {})                           # pylint: disable=eval-used
 
         # Many of our functions take a lot of arguments, and cmdline.py
         # calls them with many.  But most of them are just the defaults, which
         # we don't want to have to repeat in all tests.  For each call, apply
         # the defaults.  This lets the tests just mention the interesting ones.
-        for name, _, kwargs in m2.method_calls:
+        for name, _, kwargs in expected.mock_calls:
             for k, v in self.DEFAULT_KWARGS.get(name, {}).items():
                 kwargs.setdefault(k, v)
-        self.assert_same_method_calls(m1, m2)
+
+        self.assert_same_mock_calls(expected, called)
 
     def cmd_executes_same(self, args1, args2):
         """Assert that the `args1` executes the same as `args2`."""
         m1, r1 = self.mock_command_line(args1)
         m2, r2 = self.mock_command_line(args2)
         self.assertEqual(r1, r2)
-        self.assert_same_method_calls(m1, m2)
+        self.assert_same_mock_calls(m1, m2)
 
-    def assert_same_method_calls(self, m1, m2):
-        """Assert that `m1.method_calls` and `m2.method_calls` are the same."""
+    def assert_same_mock_calls(self, m1, m2):
+        """Assert that `m1.mock_calls` and `m2.mock_calls` are the same."""
         # Use a real equality comparison, but if it fails, use a nicer assert
         # so we can tell what's going on.  We have to use the real == first due
         # to CmdOptionParser.__eq__
-        if m1.method_calls != m2.method_calls:
-            pp1 = pprint.pformat(m1.method_calls)
-            pp2 = pprint.pformat(m2.method_calls)
+        if m1.mock_calls != m2.mock_calls:
+            pp1 = pprint.pformat(m1.mock_calls)
+            pp2 = pprint.pformat(m2.mock_calls)
             self.assertMultiLineEqual(pp1+'\n', pp2+'\n')
 
     def cmd_help(self, args, help_msg=None, topic=None, ret=ERR):
@@ -138,17 +148,17 @@ class BaseCmdLineTest(CoverageTest):
         help message that we want to see.
 
         """
-        m, r = self.mock_command_line(args)
-        self.assertEqual(r, ret, "Wrong status: got %s, wanted %s" % (r, ret))
+        mk, status = self.mock_command_line(args)
+        self.assertEqual(status, ret, "Wrong status: got %s, wanted %s" % (status, ret))
         if help_msg:
-            self.assertEqual(m.method_calls[-1], ('help_fn', (help_msg,), {}))
+            self.assertEqual(mk.mock_calls[-1], ('help_fn', (help_msg,), {}))
         else:
-            self.assertEqual(m.method_calls[-1], ('help_fn', (), {'topic': topic}))
+            self.assertEqual(mk.mock_calls[-1], ('help_fn', (), {'topic': topic}))
 
 
 class BaseCmdLineTestTest(BaseCmdLineTest):
     """Tests that our BaseCmdLineTest helpers work."""
-    def test_assert_same_method_calls(self):
+    def test_cmd_executes_same(self):
         # All the other tests here use self.cmd_executes_same in successful
         # ways, so here we just check that it fails.
         with self.assertRaises(AssertionError):
@@ -161,73 +171,73 @@ class CmdLineTest(BaseCmdLineTest):
     def test_annotate(self):
         # coverage annotate [-d DIR] [-i] [--omit DIR,...] [FILE1 FILE2 ...]
         self.cmd_executes("annotate", """\
-            .Coverage()
-            .load()
-            .annotate()
+            cov = Coverage()
+            cov.load()
+            cov.annotate()
             """)
         self.cmd_executes("annotate -d dir1", """\
-            .Coverage()
-            .load()
-            .annotate(directory="dir1")
+            cov = Coverage()
+            cov.load()
+            cov.annotate(directory="dir1")
             """)
         self.cmd_executes("annotate -i", """\
-            .Coverage()
-            .load()
-            .annotate(ignore_errors=True)
+            cov = Coverage()
+            cov.load()
+            cov.annotate(ignore_errors=True)
             """)
         self.cmd_executes("annotate --omit fooey", """\
-            .Coverage(omit=["fooey"])
-            .load()
-            .annotate(omit=["fooey"])
+            cov = Coverage(omit=["fooey"])
+            cov.load()
+            cov.annotate(omit=["fooey"])
             """)
         self.cmd_executes("annotate --omit fooey,booey", """\
-            .Coverage(omit=["fooey", "booey"])
-            .load()
-            .annotate(omit=["fooey", "booey"])
+            cov = Coverage(omit=["fooey", "booey"])
+            cov.load()
+            cov.annotate(omit=["fooey", "booey"])
             """)
         self.cmd_executes("annotate mod1", """\
-            .Coverage()
-            .load()
-            .annotate(morfs=["mod1"])
+            cov = Coverage()
+            cov.load()
+            cov.annotate(morfs=["mod1"])
             """)
         self.cmd_executes("annotate mod1 mod2 mod3", """\
-            .Coverage()
-            .load()
-            .annotate(morfs=["mod1", "mod2", "mod3"])
+            cov = Coverage()
+            cov.load()
+            cov.annotate(morfs=["mod1", "mod2", "mod3"])
             """)
 
     def test_combine(self):
         # coverage combine with args
         self.cmd_executes("combine datadir1", """\
-            .Coverage()
-            .combine(["datadir1"], strict=True)
-            .save()
+            cov = Coverage()
+            cov.combine(["datadir1"], strict=True)
+            cov.save()
             """)
         # coverage combine, appending
         self.cmd_executes("combine --append datadir1", """\
-            .Coverage()
-            .load()
-            .combine(["datadir1"], strict=True)
-            .save()
+            cov = Coverage()
+            cov.load()
+            cov.combine(["datadir1"], strict=True)
+            cov.save()
             """)
         # coverage combine without args
         self.cmd_executes("combine", """\
-            .Coverage()
-            .combine(None, strict=True)
-            .save()
+            cov = Coverage()
+            cov.combine(None, strict=True)
+            cov.save()
             """)
 
     def test_combine_doesnt_confuse_options_with_args(self):
         # https://bitbucket.org/ned/coveragepy/issues/385/coverage-combine-doesnt-work-with-rcfile
         self.cmd_executes("combine --rcfile cov.ini", """\
-            .Coverage(config_file='cov.ini')
-            .combine(None, strict=True)
-            .save()
+            cov = Coverage(config_file='cov.ini')
+            cov.combine(None, strict=True)
+            cov.save()
             """)
         self.cmd_executes("combine --rcfile cov.ini data1 data2/more", """\
-            .Coverage(config_file='cov.ini')
-            .combine(["data1", "data2/more"], strict=True)
-            .save()
+            cov = Coverage(config_file='cov.ini')
+            cov.combine(["data1", "data2/more"], strict=True)
+            cov.save()
             """)
 
     def test_debug(self):
@@ -249,8 +259,8 @@ class CmdLineTest(BaseCmdLineTest):
     def test_erase(self):
         # coverage erase
         self.cmd_executes("erase", """\
-            .Coverage()
-            .erase()
+            cov = Coverage()
+            cov.erase()
             """)
 
     def test_version(self):
@@ -263,96 +273,96 @@ class CmdLineTest(BaseCmdLineTest):
         self.cmd_help("--help", topic="help", ret=OK)
 
     def test_help_command(self):
-        self.cmd_executes("help", ".help_fn(topic='help')")
+        self.cmd_executes("help", "self.help_fn(topic='help')")
 
     def test_cmd_help(self):
-        self.cmd_executes("run --help", ".help_fn(parser='<CmdOptionParser:run>')")
+        self.cmd_executes("run --help", "self.help_fn(parser='<CmdOptionParser:run>')")
         self.cmd_executes_same("help run", "run --help")
 
     def test_html(self):
         # coverage html -d DIR [-i] [--omit DIR,...] [FILE1 FILE2 ...]
         self.cmd_executes("html", """\
-            .Coverage()
-            .load()
-            .html_report()
+            cov = Coverage()
+            cov.load()
+            cov.html_report()
             """)
         self.cmd_executes("html -d dir1", """\
-            .Coverage()
-            .load()
-            .html_report(directory="dir1")
+            cov = Coverage()
+            cov.load()
+            cov.html_report(directory="dir1")
             """)
         self.cmd_executes("html -i", """\
-            .Coverage()
-            .load()
-            .html_report(ignore_errors=True)
+            cov = Coverage()
+            cov.load()
+            cov.html_report(ignore_errors=True)
             """)
         self.cmd_executes("html --omit fooey", """\
-            .Coverage(omit=["fooey"])
-            .load()
-            .html_report(omit=["fooey"])
+            cov = Coverage(omit=["fooey"])
+            cov.load()
+            cov.html_report(omit=["fooey"])
             """)
         self.cmd_executes("html --omit fooey,booey", """\
-            .Coverage(omit=["fooey", "booey"])
-            .load()
-            .html_report(omit=["fooey", "booey"])
+            cov = Coverage(omit=["fooey", "booey"])
+            cov.load()
+            cov.html_report(omit=["fooey", "booey"])
             """)
         self.cmd_executes("html mod1", """\
-            .Coverage()
-            .load()
-            .html_report(morfs=["mod1"])
+            cov = Coverage()
+            cov.load()
+            cov.html_report(morfs=["mod1"])
             """)
         self.cmd_executes("html mod1 mod2 mod3", """\
-            .Coverage()
-            .load()
-            .html_report(morfs=["mod1", "mod2", "mod3"])
+            cov = Coverage()
+            cov.load()
+            cov.html_report(morfs=["mod1", "mod2", "mod3"])
             """)
         self.cmd_executes("html --title=Hello_there", """\
-            .Coverage()
-            .load()
-            .html_report(title='Hello_there')
+            cov = Coverage()
+            cov.load()
+            cov.html_report(title='Hello_there')
             """)
 
     def test_report(self):
         # coverage report [-m] [-i] [-o DIR,...] [FILE1 FILE2 ...]
         self.cmd_executes("report", """\
-            .Coverage()
-            .load()
-            .report(show_missing=None)
+            cov = Coverage()
+            cov.load()
+            cov.report(show_missing=None)
             """)
         self.cmd_executes("report -i", """\
-            .Coverage()
-            .load()
-            .report(ignore_errors=True)
+            cov = Coverage()
+            cov.load()
+            cov.report(ignore_errors=True)
             """)
         self.cmd_executes("report -m", """\
-            .Coverage()
-            .load()
-            .report(show_missing=True)
+            cov = Coverage()
+            cov.load()
+            cov.report(show_missing=True)
             """)
         self.cmd_executes("report --omit fooey", """\
-            .Coverage(omit=["fooey"])
-            .load()
-            .report(omit=["fooey"])
+            cov = Coverage(omit=["fooey"])
+            cov.load()
+            cov.report(omit=["fooey"])
             """)
         self.cmd_executes("report --omit fooey,booey", """\
-            .Coverage(omit=["fooey", "booey"])
-            .load()
-            .report(omit=["fooey", "booey"])
+            cov = Coverage(omit=["fooey", "booey"])
+            cov.load()
+            cov.report(omit=["fooey", "booey"])
             """)
         self.cmd_executes("report mod1", """\
-            .Coverage()
-            .load()
-            .report(morfs=["mod1"])
+            cov = Coverage()
+            cov.load()
+            cov.report(morfs=["mod1"])
             """)
         self.cmd_executes("report mod1 mod2 mod3", """\
-            .Coverage()
-            .load()
-            .report(morfs=["mod1", "mod2", "mod3"])
+            cov = Coverage()
+            cov.load()
+            cov.report(morfs=["mod1", "mod2", "mod3"])
             """)
         self.cmd_executes("report --skip-covered", """\
-            .Coverage()
-            .load()
-            .report(skip_covered=True)
+            cov = Coverage()
+            cov.load()
+            cov.report(skip_covered=True)
             """)
 
     def test_run(self):
@@ -360,101 +370,101 @@ class CmdLineTest(BaseCmdLineTest):
 
         # run calls coverage.erase first.
         self.cmd_executes("run foo.py", """\
-            .Coverage()
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         # run -a combines with an existing data file before saving.
         self.cmd_executes("run -a foo.py", """\
-            .Coverage()
-            .load()
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.load()
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         # run -a doesn't combine anything if the data file doesn't exist.
         self.cmd_executes("run -a foo.py", """\
-            .Coverage()
-            .load()
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.load()
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         # --timid sets a flag, and program arguments get passed through.
         self.cmd_executes("run --timid foo.py abc 123", """\
-            .Coverage(timid=True)
-            .start()
-            .run_python_file('foo.py', ['foo.py', 'abc', '123'])
-            .stop()
-            .save()
+            cov = Coverage(timid=True)
+            cov.start()
+            run_python_file('foo.py', ['foo.py', 'abc', '123'])
+            cov.stop()
+            cov.save()
             """)
         # -L sets a flag, and flags for the program don't confuse us.
         self.cmd_executes("run -p -L foo.py -a -b", """\
-            .Coverage(cover_pylib=True, data_suffix=True)
-            .start()
-            .run_python_file('foo.py', ['foo.py', '-a', '-b'])
-            .stop()
-            .save()
+            cov = Coverage(cover_pylib=True, data_suffix=True)
+            cov.start()
+            run_python_file('foo.py', ['foo.py', '-a', '-b'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --branch foo.py", """\
-            .Coverage(branch=True)
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(branch=True)
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --rcfile=myrc.rc foo.py", """\
-            .Coverage(config_file="myrc.rc")
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(config_file="myrc.rc")
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --include=pre1,pre2 foo.py", """\
-            .Coverage(include=["pre1", "pre2"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(include=["pre1", "pre2"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --omit=opre1,opre2 foo.py", """\
-            .Coverage(omit=["opre1", "opre2"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(omit=["opre1", "opre2"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --include=pre1,pre2 --omit=opre1,opre2 foo.py", """\
-            .Coverage(include=["pre1", "pre2"], omit=["opre1", "opre2"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(include=["pre1", "pre2"], omit=["opre1", "opre2"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --source=quux,hi.there,/home/bar foo.py", """\
-            .Coverage(source=["quux", "hi.there", "/home/bar"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(source=["quux", "hi.there", "/home/bar"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --concurrency=gevent foo.py", """\
-            .Coverage(concurrency='gevent')
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(concurrency='gevent')
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --concurrency=multiprocessing foo.py", """\
-            .Coverage(concurrency='multiprocessing')
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(concurrency='multiprocessing')
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
 
     def test_bad_concurrency(self):
@@ -486,41 +496,41 @@ class CmdLineTest(BaseCmdLineTest):
 
     def test_run_debug(self):
         self.cmd_executes("run --debug=opt1 foo.py", """\
-            .Coverage(debug=["opt1"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(debug=["opt1"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --debug=opt1,opt2 foo.py", """\
-            .Coverage(debug=["opt1","opt2"])
-            .start()
-            .run_python_file('foo.py', ['foo.py'])
-            .stop()
-            .save()
+            cov = Coverage(debug=["opt1","opt2"])
+            cov.start()
+            run_python_file('foo.py', ['foo.py'])
+            cov.stop()
+            cov.save()
             """)
 
     def test_run_module(self):
         self.cmd_executes("run -m mymodule", """\
-            .Coverage()
-            .start()
-            .run_python_module('mymodule', ['mymodule'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.start()
+            run_python_module('mymodule', ['mymodule'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run -m mymodule -qq arg1 arg2", """\
-            .Coverage()
-            .start()
-            .run_python_module('mymodule', ['mymodule', '-qq', 'arg1', 'arg2'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.start()
+            run_python_module('mymodule', ['mymodule', '-qq', 'arg1', 'arg2'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes("run --branch -m mymodule", """\
-            .Coverage(branch=True)
-            .start()
-            .run_python_module('mymodule', ['mymodule'])
-            .stop()
-            .save()
+            cov = Coverage(branch=True)
+            cov.start()
+            run_python_module('mymodule', ['mymodule'])
+            cov.stop()
+            cov.save()
             """)
         self.cmd_executes_same("run -m mymodule", "run --module mymodule")
 
@@ -531,30 +541,30 @@ class CmdLineTest(BaseCmdLineTest):
     def test_run_from_config(self):
         options = {"run:command_line": "myprog.py a 123 'a quoted thing' xyz"}
         self.cmd_executes("run", """\
-            .Coverage()
-            .start()
-            .run_python_file('myprog.py', ['myprog.py', 'a', '123', 'a quoted thing', 'xyz'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.start()
+            run_python_file('myprog.py', ['myprog.py', 'a', '123', 'a quoted thing', 'xyz'])
+            cov.stop()
+            cov.save()
             """,
             options=options,
             )
 
     def test_run_module_from_config(self):
         self.cmd_executes("run", """\
-            .Coverage()
-            .start()
-            .run_python_module('mymodule', ['mymodule', 'thing1', 'thing2'])
-            .stop()
-            .save()
+            cov = Coverage()
+            cov.start()
+            run_python_module('mymodule', ['mymodule', 'thing1', 'thing2'])
+            cov.stop()
+            cov.save()
             """,
             options={"run:command_line": "-m mymodule thing1 thing2"},
             )
 
     def test_run_from_config_but_empty(self):
         self.cmd_executes("run", """\
-            .Coverage()
-            .help_fn('Nothing to do.')
+            cov = Coverage()
+            self.help_fn('Nothing to do.')
             """,
             ret=ERR,
             options={"run:command_line": ""},
@@ -562,14 +572,14 @@ class CmdLineTest(BaseCmdLineTest):
 
     def test_run_dashm_only(self):
         self.cmd_executes("run -m", """\
-            .Coverage()
-            .help_fn('No module specified for -m')
+            cov = Coverage()
+            self.help_fn('No module specified for -m')
             """,
             ret=ERR,
             )
         self.cmd_executes("run -m", """\
-            .Coverage()
-            .help_fn('No module specified for -m')
+            cov = Coverage()
+            self.help_fn('No module specified for -m')
             """,
             ret=ERR,
             options={"run:command_line": "myprog.py"}
@@ -582,44 +592,44 @@ class CmdLineTest(BaseCmdLineTest):
     def test_xml(self):
         # coverage xml [-i] [--omit DIR,...] [FILE1 FILE2 ...]
         self.cmd_executes("xml", """\
-            .Coverage()
-            .load()
-            .xml_report()
+            cov = Coverage()
+            cov.load()
+            cov.xml_report()
             """)
         self.cmd_executes("xml -i", """\
-            .Coverage()
-            .load()
-            .xml_report(ignore_errors=True)
+            cov = Coverage()
+            cov.load()
+            cov.xml_report(ignore_errors=True)
             """)
         self.cmd_executes("xml -o myxml.foo", """\
-            .Coverage()
-            .load()
-            .xml_report(outfile="myxml.foo")
+            cov = Coverage()
+            cov.load()
+            cov.xml_report(outfile="myxml.foo")
             """)
         self.cmd_executes("xml -o -", """\
-            .Coverage()
-            .load()
-            .xml_report(outfile="-")
+            cov = Coverage()
+            cov.load()
+            cov.xml_report(outfile="-")
             """)
         self.cmd_executes("xml --omit fooey", """\
-            .Coverage(omit=["fooey"])
-            .load()
-            .xml_report(omit=["fooey"])
+            cov = Coverage(omit=["fooey"])
+            cov.load()
+            cov.xml_report(omit=["fooey"])
             """)
         self.cmd_executes("xml --omit fooey,booey", """\
-            .Coverage(omit=["fooey", "booey"])
-            .load()
-            .xml_report(omit=["fooey", "booey"])
+            cov = Coverage(omit=["fooey", "booey"])
+            cov.load()
+            cov.xml_report(omit=["fooey", "booey"])
             """)
         self.cmd_executes("xml mod1", """\
-            .Coverage()
-            .load()
-            .xml_report(morfs=["mod1"])
+            cov = Coverage()
+            cov.load()
+            cov.xml_report(morfs=["mod1"])
             """)
         self.cmd_executes("xml mod1 mod2 mod3", """\
-            .Coverage()
-            .load()
-            .xml_report(morfs=["mod1", "mod2", "mod3"])
+            cov = Coverage()
+            cov.load()
+            cov.xml_report(morfs=["mod1", "mod2", "mod3"])
             """)
 
     def test_no_arguments_at_all(self):
@@ -800,7 +810,7 @@ class CmdMainTest(CoverageTest):
 
 
 class CoverageReportingFake(object):
-    """A fake Coverage and Coverage.coverage test double."""
+    """A fake Coverage.coverage test double."""
     # pylint: disable=missing-docstring
     def __init__(self, report_result, html_result, xml_result):
         self.config = CoverageConfig()
@@ -808,9 +818,6 @@ class CoverageReportingFake(object):
         self.html_result = html_result
         self.xml_result = xml_result
 
-    def Coverage(self, *args_unused, **kwargs_unused):
-        return self
-
     def set_option(self, optname, optvalue):
         self.config.set_option(optname, optvalue)
 
@@ -852,5 +859,6 @@ def test_fail_under(results, fail_under, cmd, ret):
     cov = CoverageReportingFake(*results)
     if fail_under is not None:
         cov.set_option("report:fail_under", fail_under)
-    ret_actual = command_line(cmd, _covpkg=cov)
+    with mock.patch("coverage.cmdline.Coverage", lambda *a,**kw: cov):
+        ret_actual = command_line(cmd)
     assert ret_actual == ret