| # 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.5.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', | |
| 'MakeMock', | |
| 'patch', | |
| 'patch_object', | |
| 'sentinel', | |
| 'DEFAULT' | |
| ) | |
| __version__ = '0.5.0 alpha' | |
| class SentinelObject(object): | |
| def __init__(self, name): | |
| self.name = name | |
| def __repr__(self): | |
| return '<SentinelObject "%s">' % 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 __new__(cls, spec=None, magics=None, *args, **kwargs): | |
| if isinstance(spec, list): | |
| magics = [method[2:-2] for method in spec if (_is_magic(method) and method[2:-2] in magic_methods)] | |
| elif spec is not None: | |
| magics = [method for method in magic_methods if hasattr(spec, '__%s__' % method)] | |
| elif isinstance(magics, basestring): | |
| magics = magics.split() | |
| if magics: | |
| # It might be magic, but I like it | |
| cls = MakeMock(magics) | |
| return object.__new__(cls) | |
| def __init__(self, spec=None, magics=None, side_effect=None, | |
| return_value=DEFAULT, name=None, parent=None, | |
| items=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.__items = None | |
| self.reset_mock() | |
| if self._has_items(): | |
| if items is None: | |
| items = {} | |
| self._items = items | |
| self.__items = _copy(items) | |
| 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() | |
| if self._has_items(): | |
| self._items = _copy(self.__items) | |
| def _has_items(self): | |
| # Overriden in MagicMock | |
| return False | |
| 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 = self.return_value | |
| if self.side_effect is not None: | |
| ret_val = self.side_effect(*args, **kwargs) | |
| if ret_val is DEFAULT: | |
| ret_val = self.return_value | |
| if self._wraps is not None: | |
| return self._wraps(*args, **kwargs) | |
| 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 _args(name, *args): | |
| return (name, args, {}) | |
| def __getitem__(self, key): | |
| val = self._items[key] | |
| self.method_calls.append(_args('__getitem__', key)) | |
| return val | |
| def __setitem__(self, key, value): | |
| self.method_calls.append(_args('__setitem__', key, value)) | |
| self._items[key] = value | |
| def __delitem__(self, key): | |
| self.method_calls.append(_args('__delitem__', key)) | |
| del self._items[key] | |
| def __iter__(self): | |
| self.method_calls.append(_args('__iter__')) | |
| for item in list(self._items): | |
| yield item | |
| def __len__(self): | |
| self.method_calls.append(_args('__len__')) | |
| return len(self._items) | |
| def __contains__(self, key): | |
| self.method_calls.append(_args('__contains__', key)) | |
| return key in self._items | |
| def __nonzero__(self): | |
| self.method_calls.append(_args('__nonzero__')) | |
| return bool(self._items) | |
| magic_methods = { | |
| 'delitem': __delitem__, | |
| 'getitem': __getitem__, | |
| 'setitem': __setitem__, | |
| 'iter': __iter__, | |
| 'len': __len__, | |
| 'contains': __contains__, | |
| 'nonzero': __nonzero__ | |
| } | |
| def MakeMock(members): | |
| class MagicMock(Mock): | |
| def _has_items(self): | |
| return True | |
| if 'all' in members: | |
| members = magic_methods.keys() | |
| for method in members: | |
| if method not in magic_methods: | |
| raise NameError("Unknown magic method %r" % method) | |
| impl = magic_methods[method] | |
| name = '__%s__' % method | |
| setattr(MagicMock, name, impl) | |
| return MagicMock | |
| 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, magics, create): | |
| self.target = target | |
| self.attribute = attribute | |
| self.new = new | |
| self.spec = spec | |
| self.magics = magics | |
| self.create = create | |
| 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): | |
| try: | |
| return getattr(self.target, self.attribute) | |
| except AttributeError: | |
| if not self.create: | |
| raise | |
| return DEFAULT | |
| def __enter__(self): | |
| new, spec, magics = self.new, self.spec, self.magics | |
| original = self.get_original() | |
| if new is DEFAULT: | |
| 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, magics=magics) | |
| if inherit: | |
| # deliberately ignoring magics as we are using spec | |
| 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, magics=None, create=False): | |
| return _patch(target, attribute, new, spec, magics, create) | |
| def patch(target, new=DEFAULT, spec=None, magics=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, magics, create) | |