diff options
| -rw-r--r-- | coverage/cmdline.py | 24 | ||||
| -rw-r--r-- | tests/test_cmdline.py | 568 |
2 files changed, 295 insertions, 297 deletions
diff --git a/coverage/cmdline.py b/coverage/cmdline.py index e41a0597..be258b5e 100644 --- a/coverage/cmdline.py +++ b/coverage/cmdline.py @@ -13,6 +13,8 @@ import sys import textwrap import traceback +import coverage +from coverage import Coverage from coverage import env from coverage.collector import CTracer from coverage.data import line_counts @@ -398,20 +400,8 @@ OK, ERR, FAIL_UNDER = 0, 1, 2 class CoverageScript(object): """The command-line interface to coverage.py.""" - def __init__( - self, _covpkg=None, _run_python_file=None, - _run_python_module=None, _help_fn=None, - ): - # _covpkg is for dependency injection, so we can test this code. - if _covpkg: - self.covpkg = _covpkg - else: - import coverage - self.covpkg = coverage - + def __init__(self, _help_fn=None): # For dependency injection: - self.run_python_file = _run_python_file or run_python_file - self.run_python_module = _run_python_module or run_python_module self.help_fn = _help_fn or self.help self.global_option = False @@ -473,7 +463,7 @@ class CoverageScript(object): debug = unshell_list(options.debug) # Do something. - self.coverage = self.covpkg.Coverage( + self.coverage = Coverage( data_suffix=options.parallel_mode, cover_pylib=options.pylib, timid=options.timid, @@ -553,7 +543,7 @@ class CoverageScript(object): """Display an error message, or the named topic.""" assert error or topic or parser - help_params = dict(self.covpkg.__dict__) + help_params = dict(coverage.__dict__) help_params['program_name'] = self.program_name if CTracer is not None: help_params['extension_modifier'] = 'with C extension' @@ -651,9 +641,9 @@ class CoverageScript(object): code_ran = True try: if options.module: - self.run_python_module(args[0], args) + run_python_module(args[0], args) else: - self.run_python_file(args[0], args) + run_python_file(args[0], args) except NoSource: code_ran = False raise 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 |