From 1810d5e6e911cb3dbb3e971f2cc2a081134c6ee2 Mon Sep 17 00:00:00 2001 From: Ned Batchelder Date: Wed, 9 Sep 2009 08:31:57 -0400 Subject: Start using Mock to test the command-line code. --- coverage/cmdline.py | 16 ++- mock.py | 271 +++++++++++++++++++++++++++++++++++++++++++++++++++ test/test_cmdline.py | 51 +++++++++- 3 files changed, 330 insertions(+), 8 deletions(-) create mode 100644 mock.py diff --git a/coverage/cmdline.py b/coverage/cmdline.py index b353efa1..90a5a45e 100644 --- a/coverage/cmdline.py +++ b/coverage/cmdline.py @@ -57,9 +57,17 @@ COVERAGE_FILE environment variable to save it somewhere else. class CoverageScript: """The command-line interface to Coverage.""" - def __init__(self): - import coverage - self.covpkg = coverage + def __init__(self, _covpkg=None, _run_python_file=None): + # _covpkg is for dependency injection, so we can test this code. + if _covpkg: + self.covpkg = _covpkg + else: + import coverage + self.covpkg = coverage + + # _run_python_file is for dependency injection also. + self.run_python_file = _run_python_file or run_python_file + self.coverage = None def help(self, error=None): @@ -160,7 +168,7 @@ class CoverageScript: # Run the script. self.coverage.start() try: - run_python_file(args[0], args) + self.run_python_file(args[0], args) finally: self.coverage.stop() self.coverage.save() diff --git a/mock.py b/mock.py new file mode 100644 index 00000000..03871d6c --- /dev/null +++ b/mock.py @@ -0,0 +1,271 @@ +# mock.py +# Test tools for mocking and patching. +# Copyright (C) 2007-2009 Michael Foord +# E-mail: fuzzyman AT voidspace DOT org DOT uk + +# mock 0.6.0 +# http://www.voidspace.org.uk/python/mock/ + +# Released subject to the BSD License +# Please see http://www.voidspace.org.uk/python/license.shtml + +# Scripts maintained at http://www.voidspace.org.uk/python/index.shtml +# Comments, suggestions and bug reports welcome. + + +__all__ = ( + 'Mock', + 'patch', + 'patch_object', + 'sentinel', + 'DEFAULT' +) + +__version__ = '0.6.0' + +class SentinelObject(object): + def __init__(self, name): + self.name = name + + def __repr__(self): + return '' % self.name + + +class Sentinel(object): + def __init__(self): + self._sentinels = {} + + def __getattr__(self, name): + return self._sentinels.setdefault(name, SentinelObject(name)) + + +sentinel = Sentinel() + +DEFAULT = sentinel.DEFAULT + +class OldStyleClass: + pass +ClassType = type(OldStyleClass) + +def _is_magic(name): + return '__%s__' % name[2:-2] == name + +def _copy(value): + if type(value) in (dict, list, tuple, set): + return type(value)(value) + return value + + +class Mock(object): + + def __init__(self, spec=None, side_effect=None, return_value=DEFAULT, + name=None, parent=None, wraps=None): + self._parent = parent + self._name = name + if spec is not None and not isinstance(spec, list): + spec = [member for member in dir(spec) if not _is_magic(member)] + + self._methods = spec + self._children = {} + self._return_value = return_value + self.side_effect = side_effect + self._wraps = wraps + + self.reset_mock() + + + def reset_mock(self): + self.called = False + self.call_args = None + self.call_count = 0 + self.call_args_list = [] + self.method_calls = [] + for child in self._children.itervalues(): + child.reset_mock() + if isinstance(self._return_value, Mock): + self._return_value.reset_mock() + + + def __get_return_value(self): + if self._return_value is DEFAULT: + self._return_value = Mock() + return self._return_value + + def __set_return_value(self, value): + self._return_value = value + + return_value = property(__get_return_value, __set_return_value) + + + def __call__(self, *args, **kwargs): + self.called = True + self.call_count += 1 + self.call_args = (args, kwargs) + self.call_args_list.append((args, kwargs)) + + parent = self._parent + name = self._name + while parent is not None: + parent.method_calls.append((name, args, kwargs)) + if parent._parent is None: + break + name = parent._name + '.' + name + parent = parent._parent + + ret_val = DEFAULT + if self.side_effect is not None: + if (isinstance(self.side_effect, Exception) or + isinstance(self.side_effect, (type, ClassType)) and + issubclass(self.side_effect, Exception)): + raise self.side_effect + + ret_val = self.side_effect(*args, **kwargs) + if ret_val is DEFAULT: + ret_val = self.return_value + + if self._wraps is not None and self._return_value is DEFAULT: + return self._wraps(*args, **kwargs) + if ret_val is DEFAULT: + ret_val = self.return_value + return ret_val + + + def __getattr__(self, name): + if self._methods is not None: + if name not in self._methods: + raise AttributeError("Mock object has no attribute '%s'" % name) + elif _is_magic(name): + raise AttributeError(name) + + if name not in self._children: + wraps = None + if self._wraps is not None: + wraps = getattr(self._wraps, name) + self._children[name] = Mock(parent=self, name=name, wraps=wraps) + + return self._children[name] + + + def assert_called_with(self, *args, **kwargs): + assert self.call_args == (args, kwargs), 'Expected: %s\nCalled with: %s' % ((args, kwargs), self.call_args) + + +def _dot_lookup(thing, comp, import_path): + try: + return getattr(thing, comp) + except AttributeError: + __import__(import_path) + return getattr(thing, comp) + + +def _importer(target): + components = target.split('.') + import_path = components.pop(0) + thing = __import__(import_path) + + for comp in components: + import_path += ".%s" % comp + thing = _dot_lookup(thing, comp, import_path) + return thing + + +class _patch(object): + def __init__(self, target, attribute, new, spec, create): + self.target = target + self.attribute = attribute + self.new = new + self.spec = spec + self.create = create + self.has_local = False + + + def __call__(self, func): + if hasattr(func, 'patchings'): + func.patchings.append(self) + return func + + def patched(*args, **keywargs): + # don't use a with here (backwards compatability with 2.5) + extra_args = [] + for patching in patched.patchings: + arg = patching.__enter__() + if patching.new is DEFAULT: + extra_args.append(arg) + args += tuple(extra_args) + try: + return func(*args, **keywargs) + finally: + for patching in getattr(patched, 'patchings', []): + patching.__exit__() + + patched.patchings = [self] + patched.__name__ = func.__name__ + patched.compat_co_firstlineno = getattr(func, "compat_co_firstlineno", + func.func_code.co_firstlineno) + return patched + + + def get_original(self): + target = self.target + name = self.attribute + create = self.create + + original = DEFAULT + if _has_local_attr(target, name): + try: + original = target.__dict__[name] + except AttributeError: + # for instances of classes with slots, they have no __dict__ + original = getattr(target, name) + elif not create and not hasattr(target, name): + raise AttributeError("%s does not have the attribute %r" % (target, name)) + return original + + + def __enter__(self): + new, spec, = self.new, self.spec + original = self.get_original() + if new is DEFAULT: + # XXXX what if original is DEFAULT - shouldn't use it as a spec + inherit = False + if spec == True: + # set spec to the object we are replacing + spec = original + if isinstance(spec, (type, ClassType)): + inherit = True + new = Mock(spec=spec) + if inherit: + new.return_value = Mock(spec=spec) + self.temp_original = original + setattr(self.target, self.attribute, new) + return new + + + def __exit__(self, *_): + if self.temp_original is not DEFAULT: + setattr(self.target, self.attribute, self.temp_original) + else: + delattr(self.target, self.attribute) + del self.temp_original + + +def patch_object(target, attribute, new=DEFAULT, spec=None, create=False): + return _patch(target, attribute, new, spec, create) + + +def patch(target, new=DEFAULT, spec=None, create=False): + try: + target, attribute = target.rsplit('.', 1) + except (TypeError, ValueError): + raise TypeError("Need a valid target to patch. You supplied: %r" % (target,)) + target = _importer(target) + return _patch(target, attribute, new, spec, create) + + + +def _has_local_attr(obj, name): + try: + return name in vars(obj) + except TypeError: + # objects without a __dict__ + return hasattr(obj, name) diff --git a/test/test_cmdline.py b/test/test_cmdline.py index 38f2121d..abe8653d 100644 --- a/test/test_cmdline.py +++ b/test/test_cmdline.py @@ -1,13 +1,11 @@ """Test cmdline.py for coverage.""" -import unittest - +import re, shlex, textwrap, unittest import coverage - from coveragetest import CoverageTest -class CmdLineTest(CoverageTest): +class CmdLineParserTest(CoverageTest): """Tests of command-line processing for Coverage.""" def help_fn(self, error=None): @@ -65,5 +63,50 @@ class CmdLineTest(CoverageTest): self.command_line, ['-c', 'baz', 'quux']) +class CmdLineActionTest(CoverageTest): + """Tests of execution paths through the command line interpreter.""" + + def model_object(self): + """Return a Mock suitable for use in CoverageScript.""" + import mock + mk = mock.Mock() + mk.coverage.return_value = mk + return mk + + def cmd_executes(self, args, code): + """Assert that the `args` end up executing the sequence in `code`.""" + argv = shlex.split(args) + m1 = self.model_object() + + coverage.CoverageScript( + _covpkg=m1, _run_python_file=m1.run_python_file + ).command_line(argv) + + code = textwrap.dedent(code) + code = re.sub(r"(?m)^\.", "m2.", code) + m2 = self.model_object() + code_obj = compile(code, "", "exec") + eval(code_obj, globals(), { 'm2': m2 }) + self.assertEqual(m1.method_calls, m2.method_calls) + + def testExecution(self): + self.cmd_executes("-x foo.py", """\ + .coverage(cover_pylib=None, data_suffix=False, timid=None) + .load() + .start() + .run_python_file('foo.py', ['foo.py']) + .stop() + .save() + """) + self.cmd_executes("-e -x foo.py", """\ + .coverage(cover_pylib=None, data_suffix=False, timid=None) + .erase() + .start() + .run_python_file('foo.py', ['foo.py']) + .stop() + .save() + """) + + if __name__ == '__main__': unittest.main() -- cgit v1.2.1