Mock v0.7.1 documentation

# Further Examples

- Table of Contents
- index
  next
  previous

# Further Examples

Here are some more examples for some slightly more advanced scenarios than in the getting started guide.

## Mocking chained calls

Mocking chained calls is actually straightforward with mock once you understand the `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:

    >>> 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:

    >>> 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:

    >>> 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:

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

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

    >>> 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() 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 `patch decorator` is used here to mock out the date class in the module under test. The `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.

    >>> 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 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 `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`):

    >>> 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:

    >>> 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:

    >>> @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 start and stop methods of patch. These allow you to move the patching into your setUp and tearDown methods.

    >>> 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 cleanup functions make this simpler:

    >>> 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 `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:

    >>> 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, specifically tracking when properties are fetched from objects or even having side effects when properties are fetched.

You can already do this by subclassing `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:

    >>> 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.

    >>> 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 `assert_called_once_with()` method that also asserts that the `call_count` is one.

    >>> 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).

    >>> 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.

    >>> 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.

    >>> 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:

    >>> 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 `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.

    >>> 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.

    >>> 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 `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:

    >>> 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:

    >>> 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:

    >>> 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 start and stop methods 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:

    >>> 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 `MagicMock`, which will behave like a dictionary, and using `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 `Mock.call_args_list` to assert about how the dictionary was used:

    >>> 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:

    >>> 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:

    >>> 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.

    >>> 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:

    >>> 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, 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. 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() 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:

    >>> 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.

    >>> 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:

    >>> 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 `Mock` class allows you to track the order of method calls on your mock objects through the `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:

    >>> 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:

    >>> 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.

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:

    >>> 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:

    >>> 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