1. Why We Need Mock

When writing unit tests, the function under test is sometimes not a self-contained executable unit. It depends on external resources, such as the return value of another function or a value in a row of a database.

To shield the test from interference from external dependencies, we use Mock techniques. By simulating the test resources, we satisfy the dependency conditions.

From the perspective of design patterns, for functions and classes that satisfy the single responsibility principle, it is also reasonable to use Mock to ignore external dependencies during testing. This is because testing external dependencies should be done inside those dependencies themselves, and should not be shifted onto the caller.

By the same reasoning, if unit tests are hard to write, it is quite likely that the software has not followed a certain design pattern in practice. In that case, the most important thing is to make the software conform to the conventions of design patterns, rather than rushing into unit tests.

2. Differences Between Stub, Fake, and Mock

In fact, Mock is not the only way to simulate test resources; there are similar approaches such as Stub and Fake.

A Stub provides a set of method interfaces for the test object, simulating the real test resource. When the test object calls a Stub method, the Stub responds with a predetermined result and may also produce a predetermined error or exception. A Stub can track the interactions with the test object, but it does not process the incoming or outgoing data.

A Fake also provides a set of method interfaces for tracking the interactions with the test object, but unlike a Stub, a Fake processes the input data and produces results based on it.

Using either Stub or Fake, you can perform state verification on the test object. However, if you want to know whether the test object called the methods in the correct order, you need behavior verification.

Mock can be used for behavior verification of the test object.

3. Mock in Python

Before Python 3.3, using Mock required installing it from a third party first:

1

pip install mock

Starting with Python 3.3, Mock was introduced into the standard library under the name unittest.mock.

Let us look at a simple example (the following all use Python 2.7 as an example):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from mock import MagicMock, patch

m = MagicMock()
# mock test 函数，返回值 1
m.test = MagicMock(return_value=1)
# 调用 test 函数
m.test()
# 输出：1
class MyObj(object):
    value = 'old_value'

my = MyObj()
with patch.object(my, 'value', 'new_value'):
    print my.value
# 输出：new_value

The approach to testing with Mock:

1. Find the external dependencies of the object under test. These may be a function, object, class, and so on.
2. Instantiate the Mock class to get a Mock object, and set the Mock object’s behavior to match the dependency. For example, its return value, object value, and so on.
3. Use the Mock object to replace the external dependency.
4. Write the test code and the assertions that check whether the result matches expectations.

4. Using Mock, MagicMock, and patch

4.1 Mock

The Mock class definition:

1

class unittest.mock.Mock(spec=None, side_effect=None, return_value=DEFAULT, wraps=None, name=None, spec_set=None, unsafe=False, **kwargs)

Important parameters:

• return_value, the value returned when the mock object is called and the side_effect function returns DEFAULT.
• side_effect, this parameter points to a callable or iterable object. When the mock object is called, if the function’s return value is not DEFAULT, then that function’s return value is used as the return value of the mock object call.

side_effect has three usages:

1, Return values in sequence

1
2
3
4
5
6
7
8

m = Mock()
m.get_num = Mock(side_effect=[1, 2, 3])
p.get_num()
# 输出：1
p.get_num()
# 输出：2
p.get_num()
# 输出：3

2, Call a function to process the return value

1
2
3
4

m = Mock()
m.get_x = Mock(side_effect=lambda x: x*2)
m.get_x('123')
# 输出：'123123'

3, Actively raise an exception

1
2
3
4

m = Mock()
m.get_exp = Mock(side_effect=TypeError('type error msg'))
m.get_exp()
# 输出：TypeError: type error msg

4.2 MagicMock

The MagicMock class definition:

1

class unittest.mock.MagicMock(MagicMixin, Mock)

MagicMock is a subclass of the Mock class, implementing many magic methods and attributes.

Look at an example:

1
2
3
4
5
6

m = Mock()
list(m)
# 输出： 'Mock' object is not iterable
mg = MagicMock()
list(mg)
# 输出：[]

When creating a Mock object, the __iter__ function is not implemented by default, so it raises an error. But the MagicMock object adds this magic method.

Normally, unless you are mocking an iterable object, you will not notice the difference between Mock and MagicMock.

4.3 patch

patch is a method provided by Mock for replacing certain functions and attributes.

patch definition:

1

unittest.mock.patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs)

Important parameters:

• target, the string name of the function being replaced; you need to provide the full path
• new, the Mock instance to replace it with, MagicMock by default

There are usually two ways to write it:

1. Use with to control the scope of the context in which the replacement happens

1
2
3
4
5
6
7
8

import requests
from mock import patch

def request_get(url):
    return {'status':200}
with patch('requests.get', request_get):
    print requests.get('https://api.com')
# 输出：{'status': 200}

2. Use a decorator to replace the specified attribute or function

1
2
3
4
5
6
7
8
9

import requests
from mock import patch

@patch('requests.get', request_get)
def get_data():
    return requests.get('https://api.com')

get_data()
# 输出：{'status': 200}

patch also has three very useful extensions:

1. patch.dict for replacing dictionaries

1

patch.dict(foo, {'newkey': 'newvalue'})

2. patch.multiple for multiple replacements

1

@patch.multiple('__main__', thing=DEFAULT, other=DEFAULT)

3. patch.object for replacing instances

1

@patch.object(SomeClass, 'class_method')

5. Assertions

Assertions are used to check whether the test meets expectations. Mock-related assertions:

• assert_not_called, was never called
• assert_called_with, was called
• assert_called_once_with, was called only once
• aseert_has_calls, was called in the specified order
• assert_any_calls, was called at any point
• reset_mock, resets the call records

Usage example:

1
2
3

m = Mock()
m.get_a.assert_called_once()
# 输出：AssertionError: Expected 'get_a' to have been called once. Called 0 times.

6. References

• https://docs.python.org/3/library/unittest.mock.html#quick-guide