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)