1 # mock.py 2 # Test tools for mocking and patching. 3 # Copyright (C) 2007-2009 Michael Foord 4 # E-mail: fuzzyman AT voidspace DOT org DOT uk 5 6 # mock 0.6.0 7 # http://www.voidspace.org.uk/python/mock/ 8 9 # Released subject to the BSD License 10 # Please see http://www.voidspace.org.uk/python/license.shtml 11 12 # 2009-11-25: Licence downloaded from above URL. 13 # BEGIN DOWNLOADED LICENSE 14 # 15 # Copyright (c) 2003-2009, Michael Foord 16 # All rights reserved. 17 # E-mail : fuzzyman AT voidspace DOT org DOT uk 18 # 19 # Redistribution and use in source and binary forms, with or without 20 # modification, are permitted provided that the following conditions are 21 # met: 22 # 23 # 24 # * Redistributions of source code must retain the above copyright 25 # notice, this list of conditions and the following disclaimer. 26 # 27 # * Redistributions in binary form must reproduce the above 28 # copyright notice, this list of conditions and the following 29 # disclaimer in the documentation and/or other materials provided 30 # with the distribution. 31 # 32 # * Neither the name of Michael Foord nor the name of Voidspace 33 # may be used to endorse or promote products derived from this 34 # software without specific prior written permission. 35 # 36 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 37 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 38 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 39 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 40 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 41 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 42 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 43 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 44 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 45 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 46 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 47 # 48 # END DOWNLOADED LICENSE 49 50 # Scripts maintained at http://www.voidspace.org.uk/python/index.shtml 51 # Comments, suggestions and bug reports welcome. 52 53 54 __all__ = ( 55 'Mock', 56 'patch', 57 'patch_object', 58 'sentinel', 59 'DEFAULT' 60 ) 61 62 __version__ = '0.6.0' 63 64 class SentinelObject(object): 65 def __init__(self, name): 66 self.name = name 67 68 def __repr__(self): 69 return '<SentinelObject "%s">' % self.name 70 71 72 class Sentinel(object): 73 def __init__(self): 74 self._sentinels = {} 75 76 def __getattr__(self, name): 77 return self._sentinels.setdefault(name, SentinelObject(name)) 78 79 80 sentinel = Sentinel() 81 82 DEFAULT = sentinel.DEFAULT 83 84 class OldStyleClass: 85 pass 86 ClassType = type(OldStyleClass) 87 88 def _is_magic(name): 89 return '__%s__' % name[2:-2] == name 90 91 def _copy(value): 92 if type(value) in (dict, list, tuple, set): 93 return type(value)(value) 94 return value 95 96 97 class Mock(object): 98 99 def __init__(self, spec=None, side_effect=None, return_value=DEFAULT, 100 name=None, parent=None, wraps=None): 101 self._parent = parent 102 self._name = name 103 if spec is not None and not isinstance(spec, list): 104 spec = [member for member in dir(spec) if not _is_magic(member)] 105 106 self._methods = spec 107 self._children = {} 108 self._return_value = return_value 109 self.side_effect = side_effect 110 self._wraps = wraps 111 112 self.reset_mock() 113 114 115 def reset_mock(self): 116 self.called = False 117 self.call_args = None 118 self.call_count = 0 119 self.call_args_list = [] 120 self.method_calls = [] 121 for child in self._children.itervalues(): 122 child.reset_mock() 123 if isinstance(self._return_value, Mock): 124 self._return_value.reset_mock() 125 126 127 def __get_return_value(self): 128 if self._return_value is DEFAULT: 129 self._return_value = Mock() 130 return self._return_value 131 132 def __set_return_value(self, value): 133 self._return_value = value 134 135 return_value = property(__get_return_value, __set_return_value) 136 137 138 def __call__(self, *args, **kwargs): 139 self.called = True 140 self.call_count += 1 141 self.call_args = (args, kwargs) 142 self.call_args_list.append((args, kwargs)) 143 144 parent = self._parent 145 name = self._name 146 while parent is not None: 147 parent.method_calls.append((name, args, kwargs)) 148 if parent._parent is None: 149 break 150 name = parent._name + '.' + name 151 parent = parent._parent 152 153 ret_val = DEFAULT 154 if self.side_effect is not None: 155 if (isinstance(self.side_effect, Exception) or 156 isinstance(self.side_effect, (type, ClassType)) and 157 issubclass(self.side_effect, Exception)): 158 raise self.side_effect 159 160 ret_val = self.side_effect(*args, **kwargs) 161 if ret_val is DEFAULT: 162 ret_val = self.return_value 163 164 if self._wraps is not None and self._return_value is DEFAULT: 165 return self._wraps(*args, **kwargs) 166 if ret_val is DEFAULT: 167 ret_val = self.return_value 168 return ret_val 169 170 171 def __getattr__(self, name): 172 if self._methods is not None: 173 if name not in self._methods: 174 raise AttributeError("Mock object has no attribute '%s'" % name) 175 elif _is_magic(name): 176 raise AttributeError(name) 177 178 if name not in self._children: 179 wraps = None 180 if self._wraps is not None: 181 wraps = getattr(self._wraps, name) 182 self._children[name] = Mock(parent=self, name=name, wraps=wraps) 183 184 return self._children[name] 185 186 187 def assert_called_with(self, *args, **kwargs): 188 assert self.call_args == (args, kwargs), 'Expected: %s\nCalled with: %s' % ((args, kwargs), self.call_args) 189 190 191 def _dot_lookup(thing, comp, import_path): 192 try: 193 return getattr(thing, comp) 194 except AttributeError: 195 __import__(import_path) 196 return getattr(thing, comp) 197 198 199 def _importer(target): 200 components = target.split('.') 201 import_path = components.pop(0) 202 thing = __import__(import_path) 203 204 for comp in components: 205 import_path += ".%s" % comp 206 thing = _dot_lookup(thing, comp, import_path) 207 return thing 208 209 210 class _patch(object): 211 def __init__(self, target, attribute, new, spec, create): 212 self.target = target 213 self.attribute = attribute 214 self.new = new 215 self.spec = spec 216 self.create = create 217 self.has_local = False 218 219 220 def __call__(self, func): 221 if hasattr(func, 'patchings'): 222 func.patchings.append(self) 223 return func 224 225 def patched(*args, **keywargs): 226 # don't use a with here (backwards compatability with 2.5) 227 extra_args = [] 228 for patching in patched.patchings: 229 arg = patching.__enter__() 230 if patching.new is DEFAULT: 231 extra_args.append(arg) 232 args += tuple(extra_args) 233 try: 234 return func(*args, **keywargs) 235 finally: 236 for patching in getattr(patched, 'patchings', []): 237 patching.__exit__() 238 239 patched.patchings = [self] 240 patched.__name__ = func.__name__ 241 patched.compat_co_firstlineno = getattr(func, "compat_co_firstlineno", 242 func.func_code.co_firstlineno) 243 return patched 244 245 246 def get_original(self): 247 target = self.target 248 name = self.attribute 249 create = self.create 250 251 original = DEFAULT 252 if _has_local_attr(target, name): 253 try: 254 original = target.__dict__[name] 255 except AttributeError: 256 # for instances of classes with slots, they have no __dict__ 257 original = getattr(target, name) 258 elif not create and not hasattr(target, name): 259 raise AttributeError("%s does not have the attribute %r" % (target, name)) 260 return original 261 262 263 def __enter__(self): 264 new, spec, = self.new, self.spec 265 original = self.get_original() 266 if new is DEFAULT: 267 # XXXX what if original is DEFAULT - shouldn't use it as a spec 268 inherit = False 269 if spec == True: 270 # set spec to the object we are replacing 271 spec = original 272 if isinstance(spec, (type, ClassType)): 273 inherit = True 274 new = Mock(spec=spec) 275 if inherit: 276 new.return_value = Mock(spec=spec) 277 self.temp_original = original 278 setattr(self.target, self.attribute, new) 279 return new 280 281 282 def __exit__(self, *_): 283 if self.temp_original is not DEFAULT: 284 setattr(self.target, self.attribute, self.temp_original) 285 else: 286 delattr(self.target, self.attribute) 287 del self.temp_original 288 289 290 def patch_object(target, attribute, new=DEFAULT, spec=None, create=False): 291 return _patch(target, attribute, new, spec, create) 292 293 294 def patch(target, new=DEFAULT, spec=None, create=False): 295 try: 296 target, attribute = target.rsplit('.', 1) 297 except (TypeError, ValueError): 298 raise TypeError("Need a valid target to patch. You supplied: %r" % (target,)) 299 target = _importer(target) 300 return _patch(target, attribute, new, spec, create) 301 302 303 304 def _has_local_attr(obj, name): 305 try: 306 return name in vars(obj) 307 except TypeError: 308 # objects without a __dict__ 309 return hasattr(obj, name) 310
