==================
 Further Examples
==================

.. currentmodule:: mock

.. testsetup::

    import sys, unittest2
    from mock import MagicMock, Mock, patch
    from datetime import date

    BackendProvider = Mock()
    sys.modules['mymodule'] = mymodule = Mock(name='mymodule')

    def grob(val):
        "First frob and then clear val"
        mymodule.frob(val)
        val.clear()

    mymodule.frob = lambda val: val
    mymodule.grob = grob
    mymodule.date = date

    class TestCase(unittest2.TestCase):
        def run(self):
            result = unittest2.TestResult()
            out = unittest2.TestCase.run(self, result)
            assert result.wasSuccessful()

    def configure_mock(mock, **kwargs):
        if mock is None:
            mock = Mock()
        for arg, val in sorted(kwargs.items(), key=lambda entry: len(entry[0].split('.'))):
            args = arg.split('.')
            final = args.pop()
            obj = mock
            for entry in args:
                obj = getattr(obj, entry)
            setattr(obj, final, val)
        return mock

    class Call(object):
        def __init__(self, name=None):
            self.name = name

        def __call__(self, *args, **kwargs):
            if self.name is None:
                return (args, kwargs)
            return (self.name, args, kwargs)

        def __getattr__(self, attr):
            if self.name is None:
                return Call(attr)
            name = '%s.%s' % (self.name, attr)
            return Call(name)

    call = Call()


Here are some more examples for some slightly more advanced scenarios than in
the :ref:`getting started <getting-started>` guide.


Mocking chained calls
=====================

Mocking chained calls is actually straightforward with mock once you
understand the :attr:`Mock.return_value` attribute. When a mock is called for
the first time, or you fetch its `return_value` before it has been called, a
new `Mock` is created.

This means that you can see how the object returned from a call to a mocked
object has been used by interrogating the `return_value` mock:

.. doctest::

    >>> mock = Mock()
    >>> mock().foo(a=2, b=3)
    <mock.Mock object at 0x...>
    >>> mock.return_value.foo.assert_called_with(a=2, b=3)

From here it is a simple step to configure and then make assertions about
chained calls. Of course another alternative is writing your code in a more
testable way in the first place...

So, suppose we have some code that looks a little bit like this:

.. doctest::

    >>> class Something(object):
    ...     def __init__(self):
    ...         self.backend = BackendProvider()
    ...     def method(self):
    ...         response = self.backend.get_endpoint('foobar').create_call('spam', 'eggs').start_call()
    ...         # more code

Assuming that `BackendProvider` is already well tested, how do we test
`method()`? Specifically, we want to test that the code section ``# more
code`` uses the response object in the correct way.

As this chain of calls is made from an instance attribute we can monkey patch
the `backend` attribute on a `Something` instance. In this particular case
we are only interested in the return value from the final call to
`start_call` so we don't have much configuration to do. Let's assume the
object it returns is 'file-like', so we'll ensure that our response object
uses the builtin ``file`` as its `spec`.

To do this we create a mock instance as our mock backend and create a mock
response object for it. To set the response as the return value for that final
`start_call` we could do this:

    ``mock_backend.get_endpoint.return_value.create_call.return_value.start_call.return_value = mock_response``.

Here's how we might do it in a slightly nicer way. We start by creating our
initial mocks:

.. doctest::

    >>> something = Something()
    >>> mock_response = Mock(spec=file)
    >>> mock_backend = Mock()
    >>> get_endpoint = mock_backend.get_endpoint
    >>> create_call = get_endpoint.return_value.create_call
    >>> start_call = create_call.return_value.start_call
    >>> start_call.return_value = mock_response

With these we monkey patch the "mock backend" in place and can make the real
call:

.. doctest::

    >>> something.backend = mock_backend
    >>> something.method()

Keeping references to the intermediate methods makes our assertions easier,
and also makes the code less ugly.

.. doctest::

    >>> get_endpoint.assert_called_with('foobar')
    >>> create_call.assert_called_with('spam', 'eggs')
    >>> start_call.assert_called_with()
    >>> # make assertions on mock_response about how it is used


Partial mocking
===============

In some tests I wanted to mock out a call to `datetime.date.today()
<http://docs.python.org/library/datetime.html#datetime.date.today>`_ to return
a known date, but I didn't want to prevent the code under test from
creating new date objects. Unfortunately `datetime.date` is written in C, and
so I couldn't just monkey-patch out the static `date.today` method.

I found a simple way of doing this that involved effectively wrapping the date
class with a mock, but passing through calls to the constructor to the real
class (and returning real instances).

The :func:`patch decorator <patch>` is used here to
mock out the `date` class in the module under test. The :attr:`side_effect`
attribute on the mock date class is then set to a lambda function that returns
a real date. When the mock date class is called a real date will be
constructed and returned by `side_effect`.

.. doctest::

    >>> from datetime import date
    >>> with patch('mymodule.date') as mock_date:
    ...     mock_date.today.return_value = date(2010, 10, 8)
    ...     mock_date.side_effect = lambda *args, **kw: date(*args, **kw)
    ...
    ...     assert mymodule.date.today() == date(2010, 10, 8)
    ...     assert mymodule.date(2009, 6, 8) == date(2009, 6, 8)
    ...

Note that we don't patch `datetime.date` globally, we patch `date` in the
module that *uses* it. See :ref:`where to patch <where-to-patch>`.

When `date.today()` is called a known date is returned, but calls to the
`date(...)` constructor still return normal dates. Without this you can find
yourself having to calculate an expected result using exactly the same
algorithm as the code under test, which is a classic testing anti-pattern.

Calls to the date constructor are recorded in the `mock_date` attributes
(`call_count` and friends) which may also be useful for your tests.


Mocking open
============

Using `open` as a context manager is a great way to ensure your file handles are
closed properly and is becoming common::

    with open('/some/path', 'w') as f:
        f.write('something')

The issue is that even if you mock out the call to `open` it is the
*returned object* that is used as a context manager (and has `__enter__` and
`__exit__` called).

So first the topic of creating a mock object that can be called, with the
return value able to act as a context manager. The easiest way of doing this
is to use the new :class:`MagicMock`, which
is preconfigured to be able to act as a context manger. As an added bonus
we'll use the spec argument to ensure that the mocked object can only be used
in the same ways a real file could be used (attempting to access a method or
attribute not on the `file` will raise an ``AttributeError``):

.. doctest::

    >>> mock_open = Mock()
    >>> mock_open.return_value = MagicMock(spec=file)

In terms of configuring our mock this is all that needs to be done. In fact it
could be constructed with a one liner: ``mock_open =
Mock(return_value=MagicMock(spec=file))``.

So what is the best way of patching the builtin ``open`` function? One way
would be to globally patch ``__builtin__.open``. So long as you are sure that
none of the other code being called also accesses ``open`` this is perfectly
reasonable. It does make some people nervous however. By default we can't
patch the ``open`` name in the module where it is used, because ``open``
doesn't exist as an attribute in that namespace. ``patch`` refuses to patch
attributes that don't exist because that is a great way of having tests that
pass but code that is horribly broken (your code can access attributes that
only exist during your tests!). ``patch`` *will* however create (and then
remove again) non-existent attributes if you tell it that you are really sure
you know what you're doing.

By passing ``create=True`` into ``patch`` we can just patch the ``open``
function in the module under test instead of patching it globally:

.. doctest::

    >>> open_name = '%s.open' % __name__
    >>> with patch(open_name, create=True) as mock_open:
    ...     mock_open.return_value = MagicMock(spec=file)
    ...
    ...     with open('/some/path', 'w') as f:
    ...         f.write('something')
    ...
    <mock.Mock object at 0x...>
    >>> file_handle = mock_open.return_value.__enter__.return_value
    >>> file_handle.write.assert_called_with('something')


Applying the same patch to every test method
============================================

If you want several patches in place for multiple test methods the obvious way
is to apply the patch decorators to every method. This can feel like unnecessary
repetition. For Python 2.6 or more recent you can use `patch` (in all its
various forms) as a class decorator. This applies the patches to all test
methods on the class. A test method is identified by methods whose names start
with `test`:

.. doctest::

    >>> @patch('mymodule.SomeClass')
    ... class MyTest(TestCase):
    ...
    ...     def test_one(self, MockSomeClass):
    ...         self.assertTrue(mymodule.SomeClass is MockSomeClass)
    ...
    ...     def test_two(self, MockSomeClass):
    ...         self.assertTrue(mymodule.SomeClass is MockSomeClass)
    ...
    ...     def not_a_test(self):
    ...         return 'something'
    ...
    >>> MyTest('test_one').test_one()
    >>> MyTest('test_two').test_two()
    >>> MyTest('test_two').not_a_test()
    'something'

An alternative way of managing patches is to use the
:ref:`start and stop <start-and-stop>` methods of patch. These allow
you to move the patching into your `setUp` and `tearDown` methods.

.. doctest::

    >>> class MyTest(TestCase):
    ...     def setUp(self):
    ...         self.patcher = patch('mymodule.foo')
    ...         self.mock_foo = self.patcher.start()
    ...
    ...     def test_foo(self):
    ...         self.assertTrue(mymodule.foo is self.mock_foo)
    ...
    ...     def tearDown(self):
    ...         self.patcher.stop()
    ...
    >>> MyTest('test_foo').run()

If you use this technique you must ensure that the patching is "undone" by
calling `stop`. This can be fiddlier than you might think, because if an
exception is raised in the setUp then tearDown is not called. `unittest2
<http://pypi.python.org/pypi/unittest2>`_ cleanup functions make this simpler:


.. doctest::

    >>> class MyTest(TestCase):
    ...     def setUp(self):
    ...         patcher = patch('mymodule.foo')
    ...         self.addCleanup(patcher.stop)
    ...         self.mock_foo = patcher.start()
    ...
    ...     def test_foo(self):
    ...         self.assertTrue(mymodule.foo is self.mock_foo)
    ...
    >>> MyTest('test_foo').run()


Mocking Unbound Methods
=======================

Whilst writing tests today I needed to patch an *unbound method* (patching the
method on the class rather than on the instance). I needed self to be passed
in as the first argument because I want to make asserts about which objects
were calling this particular method. The issue is that you can't patch with a
mock for this, because if you replace an unbound method with a mock it doesn't
become a bound method when fetched from the instance, and so it doesn't get
self passed in. The workaround is to patch the unbound method with a real
function instead. The :func:`patch` decorator makes it so simple to
patch out methods with a mock that having to create a real function becomes a
nuisance.

If you pass ``mocksignature=True`` to patch then it does the patching with a
*real* function object. This function object has the same signature as the one
it is replacing, but delegates to a mock under the hood. You still get your
mock auto-created in exactly the same way as before. What it means though, is
that if you use it to patch out an unbound method on a class the mocked
function will be turned into a bound method if it is fetched from an instance.
It will have `self` passed in as the first argument, which is exactly what I
wanted:

.. doctest::

    >>> class Foo(object):
    ...   def foo(self):
    ...     pass
    ...
    >>> with patch.object(Foo, 'foo', mocksignature=True) as mock_foo:
    ...   mock_foo.return_value = 'foo'
    ...   foo = Foo()
    ...   foo.foo()
    ...
    'foo'
    >>> mock_foo.assert_called_once_with(foo)

If we don't use `mocksignature=True` then the unbound method is patched out
with a Mock instance instead, and isn't called with `self`.


Mocking Properties
==================

A few people have asked about `mocking properties
<https://code.google.com/p/mock/issues/detail?id=38&can=1>`_, specifically
tracking when properties are fetched from objects or even having side effects
when properties are fetched.

You can already do this by subclassing :class:`Mock` and providing your own
property. Delegating to another mock is one way to record the property being
accessed whilst still able to control things like return values:

.. doctest::

    >>> mock_foo = Mock(return_value='fish')
    >>> class MyMock(Mock):
    ...     @property
    ...     def foo(self):
    ...         return mock_foo()
    ...
    >>> mock = MyMock()
    >>> mock.foo
    'fish'
    >>> mock_foo.assert_called_once_with()


Checking multiple calls with mock
=================================

mock has a nice API for making assertions about how your mock objects are used.

.. doctest::

    >>> mock = Mock()
    >>> mock.foo_bar.return_value = None
    >>> mock.foo_bar('baz', spam='eggs')
    >>> mock.foo_bar.assert_called_with('baz', spam='eggs')

If your mock is only being called once you can use the
:meth:`assert_called_once_with` method that also asserts that the
:attr:`call_count` is one.

.. doctest::

    >>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
    >>> mock.foo_bar()
    >>> mock.foo_bar.assert_called_once_with('baz', spam='eggs')
    Traceback (most recent call last):
        ...
    AssertionError: Expected to be called once. Called 2 times.

Both `assert_called_with` and `assert_called_once_with` make assertions about
the *most recent* call. If your mock is going to be called several times, and
you want to make assertions about *all* those calls, the API is not quite so
nice.

All of the calls, in order, are stored in `call_args_list` as tuples of
(positional args, keyword args).

.. doctest::

    >>> mock = Mock(return_value=None)
    >>> mock(1, 2, 3)
    >>> mock(4, 5, 6)
    >>> mock()
    >>> mock.call_args_list
    [((1, 2, 3), {}), ((4, 5, 6), {}), ((), {})]


Because it stores positional args *and* keyword args, even if they are empty,
the list is overly verbose which makes for ugly tests. It turns out that I do
this rarely enough that I've never got around to improving it. One of the new
features in 0.7.0 helps with this. The tuples of (positional, keyword)
arguments are now custom objects that allow for 'soft comparisons'
(implemented by Konrad Delong). This allows you to omit empty positional or
keyword arguments from tuples you compare against.

.. doctest::

    >>> mock.call_args_list
    [((1, 2, 3), {}), ((4, 5, 6), {}), ((), {})]
    >>> expected = [((1, 2, 3),), ((4, 5, 6),), ()]
    >>> mock.call_args_list == expected
    True

This is an improvement, but still not as nice as `assert_called_with`. Here's
a helper function that pops the last argument of the call args list and
decrements the call count. This allows you to make asserts as a series of
calls to `assert_called_with` followed by a `pop_last_call`.

.. doctest::

    >>> def pop_last_call(mock):
    ...     if not mock.call_count:
    ...         raise AssertionError("Cannot pop last call: call_count is 0")
    ...     mock.call_args_list.pop()
    ...     try:
    ...         mock.call_args = mock.call_args_list[-1]
    ...     except IndexError:
    ...         mock.call_args = None
    ...         mock.called = False
    ...     mock.call_count -=1
    ...
    >>> mock = Mock(return_value=None)
    >>> mock(1, foo='bar')
    >>> mock(2, foo='baz')
    >>> mock(3, foo='spam')
    >>> mock.assert_called_with(3, foo='spam')
    >>> pop_last_call(mock)
    >>> mock.assert_called_with(2, foo='baz')
    >>> pop_last_call(mock)
    >>> mock.assert_called_once_with(1, foo='bar')

The calls to `assert_called_with` are made in reverse order to the actual
calls. Your final call can be a call to `assert_called_once_with`, that
ensures there were no extra calls you weren't expecting. You could, if you
wanted, extend the function to take args and kwargs and do the assert for you.


Coping with mutable arguments
=============================

Another situation is rare, but can bite you, is when your mock is called with
mutable arguments. `call_args` and `call_args_list` store *references* to the
arguments. If the arguments are mutated by the code under test then you can no
longer make assertions about what the values were when the mock was called.

Here's some example code that shows the problem. Imagine the following functions
defined in 'mymodule'::

    def frob(val):
        pass

    def grob(val):
        "First frob and then clear val"
        frob(val)
        val.clear()

When we try to test that `grob` calls `frob` with the correct argument look
what happens:

.. doctest::

    >>> with patch('mymodule.frob') as mock_frob:
    ...     val = set([6])
    ...     mymodule.grob(val)
    ...
    >>> val
    set([])
    >>> mock_frob.assert_called_with(set([6]))
    Traceback (most recent call last):
        ...
    AssertionError: Expected: ((set([6]),), {})
    Called with: ((set([]),), {})

One possibility would be for mock to copy the arguments you pass in. This
could then cause problems if you do assertions that rely on object identity
for equality.

Here's one solution that uses the :attr:`side_effect`
functionality. If you provide a `side_effect` function for a mock then
`side_effect` will be called with the same args as the mock. This gives us an
opportunity to copy the arguments and store them for later assertions. In this
example I'm using *another* mock to store the arguments so that I can use the
mock methods for doing the assertion. Again a helper function sets this up for
me.

.. doctest::

    >>> from copy import deepcopy
    >>> from mock import Mock, patch, DEFAULT
    >>> def copy_call_args(mock):
    ...     new_mock = Mock()
    ...     def side_effect(*args, **kwargs):
    ...         args = deepcopy(args)
    ...         kwargs = deepcopy(kwargs)
    ...         new_mock(*args, **kwargs)
    ...         return DEFAULT
    ...     mock.side_effect = side_effect
    ...     return new_mock
    ...
    >>> with patch('mymodule.frob') as mock_frob:
    ...     new_mock = copy_call_args(mock_frob)
    ...     val = set([6])
    ...     mymodule.grob(val)
    ...
    >>> new_mock.assert_called_with(set([6]))
    >>> new_mock.call_args
    ((set([6]),), {})

`copy_call_args` is called with the mock that will be called. It returns a new
mock that we do the assertion on. The `side_effect` function makes a copy of
the args and calls our `new_mock` with the copy.

.. note::

    If your mock is only going to be used once there is an easier way of
    checking arguments at the point they are called. You can simply do the
    checking inside a `side_effect` function.

    .. doctest::

        >>> def side_effect(arg):
        ...     assert arg == set([6])
        ...
        >>> mock = Mock(side_effect=side_effect)
        >>> mock(set([6]))
        >>> mock(set())
        Traceback (most recent call last):
         ...
        AssertionError


Multiple calls with different effects
=====================================

Handling code that needs to behave differently on subsequent calls during the
test can be tricky. For example you may have a function that needs to raise
an exception the first time it is called but returns a response on the second
call (testing retry behaviour).

One approach is to use a :attr:`side_effect` function that replaces itself. The
first time it is called the `side_effect` sets a new `side_effect` that will
be used for the second call. It then raises an exception:

.. doctest::

    >>> def side_effect(*args):
    ...   def second_call(*args):
    ...     return 'response'
    ...   mock.side_effect = second_call
    ...   raise Exception('boom')
    ...
    >>> mock = Mock(side_effect=side_effect)
    >>> mock('first')
    Traceback (most recent call last):
      ...
    Exception: boom
    >>> mock('second')
    'response'
    >>> mock.assert_called_with('second')

Another perfectly valid way would be to pop return values from a list. If the
return value is an exception, raise it instead of returning it:

.. doctest::

    >>> returns = [Exception('boom'), 'response']
    >>> def side_effect(*args):
    ...   result = returns.pop(0)
    ...   if isinstance(result, Exception):
    ...     raise result
    ...   return result
    ...
    >>> mock = Mock(side_effect=side_effect)
    >>> mock('first')
    Traceback (most recent call last):
      ...
    Exception: boom
    >>> mock('second')
    'response'
    >>> mock.assert_called_with('second')

Which approach you prefer is a matter of taste. The first approach is actually
a line shorter but maybe the second approach is more readable.


Nesting Patches
===============

Using patch as a context manager is nice, but if you do multiple patches you
can end up with nested with statements indenting further and further to the
right:

.. doctest::

    >>> class MyTest(TestCase):
    ...
    ...     def test_foo(self):
    ...         with patch('mymodule.Foo') as mock_foo:
    ...             with patch('mymodule.Bar') as mock_bar:
    ...                 with patch('mymodule.Spam') as mock_spam:
    ...                     assert mymodule.Foo is mock_foo
    ...                     assert mymodule.Bar is mock_bar
    ...                     assert mymodule.Spam is mock_spam
    ...
    >>> original = mymodule.Foo
    >>> MyTest('test_foo').test_foo()
    >>> assert mymodule.Foo is original

With unittest2_ `cleanup` functions and the patch :ref:`start and stop methods
<start-and-stop>` we can achieve the same effect without the nested
indentation. A simple helper method, `create_patch`, puts the patch in place
and returns the created mock for us:

.. doctest::

    >>> class MyTest(TestCase):
    ...
    ...     def create_patch(self, name):
    ...         patcher = patch(name)
    ...         thing = patcher.start()
    ...         self.addCleanup(patcher.stop)
    ...         return thing
    ...
    ...     def test_foo(self):
    ...         mock_foo = self.create_patch('mymodule.Foo')
    ...         mock_bar = self.create_patch('mymodule.Bar')
    ...         mock_spam = self.create_patch('mymodule.Spam')
    ...
    ...         assert mymodule.Foo is mock_foo
    ...         assert mymodule.Bar is mock_bar
    ...         assert mymodule.Spam is mock_spam
    ...
    >>> original = mymodule.Foo
    >>> MyTest('test_foo').run()
    >>> assert mymodule.Foo is original



Mocking a dictionary with MagicMock
===================================

You may want to mock a dictionary, or other container object, recording all
access to it whilst having it still behave like a dictionary.

We can do this with :class:`MagicMock`, which will behave like a dictionary,
and using :data:`Mock.side_effect` to delegate dictionary access to a real underlying
dictionary that is under our control.

When the `__getitem__` and `__setitem__` methods of our `MagicMock` are called
(normal dictionary access) then `side_effect` is called with the key (and in
the case of `__setitem__` the value too). We can also control what is returned.

After the `MagicMock` has been used we can use attributes like
:data:`Mock.call_args_list` to assert about how the dictionary was used:

.. doctest::

    >>> my_dict = {'a': 1, 'b': 2, 'c': 3}
    >>> def getitem(name):
    ...      return my_dict[name]
    ...
    >>> def setitem(name, val):
    ...     my_dict[name] = val
    ...
    >>> mock = MagicMock()
    >>> mock.__getitem__.side_effect = getitem
    >>> mock.__setitem__.side_effect = setitem

.. note::

    An alternative to using `MagicMock` is to use `Mock` and *only* provide
    the magic methods you specifically want:

    .. doctest::

        >>> mock = Mock()
        >>> mock.__setitem__ = Mock(side_effect=getitem)
        >>> mock.__getitem__ = Mock(side_effect=setitem)

    A *third* option is to use `MagicMock` but passing in `dict` as the `spec`
    (or `spec_set`) argument so that the `MagicMock` created only has
    dictionary magic methods available:

    .. doctest::

        >>> mock = MagicMock(spec_set=dict)
        >>> mock.__getitem__.side_effect = getitem
        >>> mock.__setitem__.side_effect = setitem

With these side effect functions in place, the `mock` will behave like a normal
dictionary but recording the access. It even raises a `KeyError` if you try
to access a key that doesn't exist.

.. doctest::

    >>> mock['a']
    1
    >>> mock['c']
    3
    >>> mock['d']
    Traceback (most recent call last):
      ...
    KeyError: 'd'
    >>> mock['b'] = 'fish'
    >>> mock['d'] = 'eggs'
    >>> mock['b']
    'fish'
    >>> mock['d']
    'eggs'

After it has been used you can make assertions about the access using the normal
mock methods and attributes:

.. doctest::

    >>> mock.__getitem__.call_args_list
    [(('a',), {}), (('c',), {}), (('d',), {}), (('b',), {}), (('d',), {})]
    >>> mock.__setitem__.call_args_list
    [(('b', 'fish'), {}), (('d', 'eggs'), {})]
    >>> my_dict
    {'a': 1, 'c': 3, 'b': 'fish', 'd': 'eggs'}


Less verbose configuration of mock objects
==========================================

If you have a mock object, particularly one created for you by `patch
<http://www.voidspace.org.uk/python/mock/getting-started.html#patch-decorators>`_,
setting up attributes and return values for methods takes one line for every
aspect of configuration.

A feature I'm considering for mock 0.8.0 is an api for `making configuring
mocks less verbose <https://code.google.com/p/mock/issues/detail?id=80>`_. As
is the way of these things, it is easy to prototype this first with a function
that you can use right now.

`configure_mock` is a function that takes a `Mock()
<http://www.voidspace.org.uk/python/mock/getting-started.html#using-mock>`_
instance along with keyword arguments for attributes of the mock you want to
set. For example, to set `mock.foo` to 3 and `mock.bar` to None, you call:

.. doctest::

    >>> mock = Mock()
    >>> configure_mock(mock, foo=3, bar=None)
    <mock.Mock object at 0x...>
    >>> mock.foo
    3
    >>> print mock.bar
    None

`return_value` and `side_effect` can be used to set them directly on the main
mock *anyway* as they are just attributes.

.. doctest::

    >>> mock = Mock()
    >>> configure_mock(mock, side_effect=KeyError)
    <mock.Mock object at 0x...>
    >>> mock()
    Traceback (most recent call last):
      ...
    KeyError

This is fine for directly setting attributes, but what if you want to
configure the return values or side effects of child mocks? How about using
standard dotted notation to specify these. Instead of normal keyword arguments
you'll need to build a dictionary of arguments and pass them in with `**`. The
function could also create a mock for us if we pass in `None`:

.. doctest::

    >>> args = {'foo.baz.return_value': 'fish', 'foo.side_effect':
    ... RuntimeError, 'side_effect': KeyError, 'foo.bar': 3}
    ...
    >>> mock = configure_mock(None, **args)
    >>> mock.foo.bar
    3
    >>> mock()
    Traceback (most recent call last):
      ...
    KeyError
    >>> mock.foo.baz()
    'fish'
    >>> mock.foo()
    Traceback (most recent call last):
      ...
    RuntimeError

If you have any opinions on this then please comment on the issue.

A minimal implementation of `configure_mock` that you can start using now is::

    def configure_mock(mock, **kwargs):
        if mock is None:
            mock = Mock()
        for arg, val in sorted(kwargs.items(),
                               key=lambda entry: len(entry[0].split('.'))):
            args = arg.split('.')
            final = args.pop()
            obj = mock
            for entry in args:
                obj = getattr(obj, entry)
            setattr(obj, final, val)
        return mock


Tracking order of calls and less verbose call assertions
========================================================

The :class:`Mock` class allows you to track the *order* of method calls on
your mock objects through the :attr:`Mock.method_calls` attribute. This
doesn't allow you to track the order of calls between separate mock objects,
however we can use `method_calls` to achieve the same effect.

Because mocks track calls to child mocks in `method_calls`, and accessing an
arbitrary attribute of a mock creates a child mock, we can create our separate
mocks from a parent one. Calls to those child mock will then all be recorded,
in order, in the `method_calls` of the parent:

.. doctest::

    >>> manager = Mock()

    >>> mock_foo = manager.foo
    >>> mock_bar = manager.bar

    >>> mock_foo.something()
    <mock.Mock object at 0x...>
    >>> mock_bar.other.thing()
    <mock.Mock object at 0x...>

    >>> manager.method_calls
    [('foo.something', (), {}), ('bar.other.thing', (), {})]

Using the "soft comparisons" feature of mock 0.7.0 we can make the final
assertion about the expected calls less verbose:

.. doctest::

    >>> expected_calls = [('foo.something',), ('bar.other.thing',)]
    >>> manager.method_calls == expected_calls
    True

To make them even less verbose I would like to add a new `call` object to mock
0.8.0. You can see the issues I expect to work on for 0.8.0 in the `issues
list <https://code.google.com/p/mock/issues/list>`_.

`call` would look something like this::

    class Call(object):
        def __init__(self, name=None):
            self.name = name

        def __call__(self, *args, **kwargs):
            if self.name is None:
                return (args, kwargs)
            return (self.name, args, kwargs)

        def __getattr__(self, attr):
            if self.name is None:
                return Call(attr)
            name = '%s.%s' % (self.name, attr)
            return Call(name)

    call = Call()

You can then use it like this:

.. doctest::

    >>> mock = Mock(return_value=None)
    >>> mock(1, 2, 3)
    >>> mock(a=3, b=6)
    >>> mock.call_args_list == [call(1, 2, 3), call(a=3, b=6)]
    True

    >>> mock = Mock()
    >>> mock.foo(1, 2 ,3)
    <mock.Mock object at 0x...>
    >>> mock.bar.baz(a=3, b=6)
    <mock.Mock object at 0x...>
    >>> mock.method_calls == [call.foo(1, 2, 3), call.bar.baz(a=3, b=6)]
    True

And for good measure, the first example (tracking order of calls between
mocks) using the new `call` object for assertions:

.. doctest::

    >>> manager = Mock()

    >>> mock_foo = manager.foo
    >>> mock_bar = manager.bar

    >>> mock_foo.something()
    <mock.Mock object at 0x...>
    >>> mock_bar.other.thing()
    <mock.Mock object at 0x...>

    >>> manager.method_calls == [call.foo.something(), call.bar.other.thing()]
    True
