Another approach to mocking properties in Python
Join the DZone community and get the full member experience.
Join For Free
mock
is a library for testing in python. it allows you to replace parts of your system under test with mock objects. the
main
feature of mock is that it's simple to use, but mock also makes possible more complex mocking scenarios.
this is my philosophy of api design as it happens:
simple things should be simple but complex things should be possible
.
several of these more complex scenarios are shown in the
further examples
section of the documentation. i've just updated one of these, the example of mocking properties.
properties in python are
descriptors
. when they are fetched from the
class
of an object they trigger code that is then executed. the code that is
executed is the method that you have wrapped as the property getter.
note that there is a special rule for attribute lookup on certain
types of descriptors, which include properties. even if an instance
attribute exists, the class attribute will still be used instead. this
is an exception to the normal attribute lookup rule that instance
attributes are fetched in preference to class attributes. this is
important because it means that when you want to mock a property you
have to do it
on the class
and can't simply stick an attribute onto an object.
if you're using mock 0.7, with its support for magic methods , we can patch the property name and add a __get__ method to our mock. the presence of the __get__ method makes it a descriptor, so we can use it as a property:
>>> from mock import mock, patch
>>> class foo(object):
... @property
... def fish(self):
... return 'fish'
...
>>> with patch.object(foo, 'fish') as mock_fish:
... mock_fish.__get__ = mock(return_value='mocked fish')
... foo = foo()
... print foo.fish
...
mocked fish
>>> mock_fish.__get__.assert_called_with(mock_fish, foo, foo)
in this example
mock_fish
replaces the property and the mock we put in place of
__get__
becomes the mocked getter method. as we're patching on the class this affects
all
instances of
foo
.
there's no point in using
magicmock
for this.
magicmock
normallly makes using the python protocol methods simpler by
preconfiguring them. as you can see from the example above, mocking
__get__
is
supported
but it isn't hooked up by default. it wouldn't be helpful if mocking
any
method on a class replaced it with a mock that acted as a descriptor,
so if you want a mock to behave as a descriptor then you have to
configure
__get__
,
__set__
and
__delete__
yourself.
here's an alternative approach that works with all recent-ish versions of mock:
>>> from mock import mock, patch
>>> class propertymock(mock):
... def __get__(self, instance, owner):
... return self()
...
>>> prop_mock = propertymock()
>>> with patch.object(foo, 'fish', prop_mock):
... foo = foo()
... prop_mock.return_value = 'mocked fish'
... print foo.fish
...
mocked fish
>>> prop_mock.assert_called_with()
as an added bonus, both of these examples work even if the
foo
instance
is created outside of the
patch
block. so long as the code using the property is executed whilst the
patch is in place the attribute lookup will find our mocked version.
source:
http://www.voidspace.org.uk/python/weblog/arch_d7_2011_06_04.shtml
Opinions expressed by DZone contributors are their own.
Comments