Navigation

unittest.mock is a library for testing in Python. It allows you to
replace parts of your system under test with mock objects and make assertions
about how they have been used.

unittest.mock provides a core Mock class removing the need to
create a host of stubs throughout your test suite. After performing an
action, you can make assertions about which methods / attributes were used
and arguments they were called with. You can also specify return values and
set needed attributes in the normal way.

Additionally, mock provides a patch() decorator that handles patching
module and class level attributes within the scope of a test, along with
sentinel for creating unique objects. See the quick guide for
some examples of how to use Mock, MagicMock and
patch().

Mock is very easy to use and is designed for use with unittest. Mock
is based on the ‘action -> assertion’ pattern instead of ‘record -> replay’
used by many mocking frameworks.

Mock and MagicMock objects create all attributes and
methods as you access them and store details of how they have been used. You
can configure them, to specify return values or limit what attributes are
available, and then make assertions about how they have been used:

Mock has many other ways you can configure it and control its behaviour. For
example the spec argument configures the mock to take its specification
from another object. Attempting to access attributes or methods on the mock
that don’t exist on the spec will fail with an AttributeError.

The patch() decorator / context manager makes it easy to mock classes or
objects in a module under test. The object you specify will be replaced with a
mock (or other object) during the test and restored when the test ends:

When you nest patch decorators the mocks are passed in to the decorated
function in the same order they applied (the normal python order that
decorators are applied). This means from the bottom up, so in the example
above the mock for module.ClassName1 is passed in first.

With patch() it matters that you patch objects in the namespace where they
are looked up. This is normally straightforward, but for a quick guide
read where to patch.

As well as a decorator patch() can be used as a context manager in a with
statement:

Mock allows you to assign functions (or other Mock instances) to magic methods
and they will be called appropriately. The MagicMock class is just a Mock
variant that has all of the magic methods pre-created for you (well, all the
useful ones anyway).

The following is an example of using magic methods with the ordinary Mock
class:

For ensuring that the mock objects in your tests have the same api as the
objects they are replacing, you can use auto-speccing.
Auto-speccing can be done through the autospec argument to patch, or the
create_autospec() function. Auto-speccing creates mock objects that
have the same attributes and methods as the objects they are replacing, and
any functions and methods (including constructors) have the same call
signature as the real object.

This ensures that your mocks will fail in the same way as your production
code if they are used incorrectly:

Mock is a flexible mock object intended to replace the use of stubs and
test doubles throughout your code. Mocks are callable and create attributes as
new mocks when you access them [1]. Accessing the same attribute will always
return the same mock. Mocks record how you use them, allowing you to make
assertions about what your code has done to them.

MagicMock is a subclass of Mock with all the magic methods
pre-created and ready to use. There are also non-callable variants, useful
when you are mocking out objects that aren’t callable:
NonCallableMock and NonCallableMagicMock

The patch() decorators makes it easy to temporarily replace classes
in a particular module with a Mock object. By default patch will create
a MagicMock for you. You can specify an alternative class of Mock using
the new_callable argument to patch.

Create a new Mock object. Mock takes several optional arguments
that specify the behaviour of the Mock object:

spec: This can be either a list of strings or an existing object (a
class or instance) that acts as the specification for the mock object. If
you pass in an object then a list of strings is formed by calling dir on
the object (excluding unsupported magic attributes and methods).
Accessing any attribute not in this list will raise an AttributeError.

If spec is an object (rather than a list of strings) then
__class__ returns the class of the spec object. This
allows mocks to pass isinstance tests.

spec_set: A stricter variant of spec. If used, attempting to set
or get an attribute on the mock that isn’t on the object passed as
spec_set will raise an AttributeError.

side_effect: A function to be called whenever the Mock is called. See
the side_effect attribute. Useful for raising exceptions or
dynamically changing return values. The function is called with the same
arguments as the mock, and unless it returns DEFAULT, the return
value of this function is used as the return value.

Alternatively side_effect can be an exception class or instance. In
this case the exception will be raised when the mock is called.

If side_effect is an iterable then each call to the mock will return
the next value from the iterable.

A side_effect can be cleared by setting it to None.

return_value: The value returned when the mock is called. By default
this is a new Mock (created on first access). See the
return_value attribute.

wraps: Item for the mock object to wrap. If wraps is not None then
calling the Mock will pass the call through to the wrapped object
(returning the real result). Attribute access on the mock will return a
Mock object that wraps the corresponding attribute of the wrapped
object (so attempting to access an attribute that doesn’t exist will
raise an AttributeError).

If the mock has an explicit return_value set then calls are not passed
to the wrapped object and the return_value is returned instead.

name: If the mock has a name then it will be used in the repr of the
mock. This can be useful for debugging. The name is propagated to child
mocks.

Mocks can also be called with arbitrary keyword arguments. These will be
used to set attributes on the mock after it is created. See the
configure_mock() method for details.

This can be useful where you want to make a series of assertions that
reuse the same object. Note that reset_mock()doesn’t clear the
return value, side_effect or any child attributes you have
set using normal assignment. Child mocks and the return value mock
(if any) are reset as well.

Create the child mocks for attributes and return value.
By default child mocks will be the same type as the parent.
Subclasses of Mock may want to override this to customize the way
child mocks are made.

For non-callable mocks the callable variant will be used (rather than
any custom subclass).

This can either be a function to be called when the mock is called,
an iterable or an exception (class or instance) to be raised.

If you pass in a function it will be called with same arguments as the
mock and unless the function returns the DEFAULT singleton the
call to the mock will then return whatever the function returns. If the
function returns DEFAULT then the mock will return its normal
value (from the return_value).

If you pass in an iterable, it is used to retrieve an iterator which
must yield a value on every call. This value can either be an exception
instance to be raised, or a value to be returned from the call to the
mock (DEFAULT handling is identical to the function case).

An example of a mock that raises an exception (to test exception
handling of an API):

This is either None (if the mock hasn’t been called), or the
arguments that the mock was last called with. This will be in the
form of a tuple: the first member is any ordered arguments the mock
was called with (or an empty tuple) and the second member is any
keyword arguments (or an empty dictionary).

This is a list of all the calls made to the mock object in sequence
(so the length of the list is the number of times it has been
called). Before any calls have been made it is an empty list. The
call object can be used for conveniently constructing lists of
calls to compare with call_args_list.

Normally the __class__ attribute of an object will return its type.
For a mock object with a spec, __class__ returns the spec class
instead. This allows mock objects to pass isinstance() tests for the
object they are replacing / masquerading as:

>>> mock=Mock(spec=3)>>> isinstance(mock,int)True

__class__ is assignable to, this allows a mock to pass an
isinstance() check without forcing you to use a spec:

The Mock classes have support for mocking magic methods. See magic
methods for the full details.

The mock classes and the patch() decorators all take arbitrary keyword
arguments for configuration. For the patch() decorators the keywords are
passed to the constructor of the mock being created. The keyword arguments
are for configuring attributes of the mock:

The return value and side effect of child mocks can be set in the same way,
using dotted notation. As you can’t use dotted names directly in a call you
have to create a dictionary and unpack it using **:

A callable mock which was created with a spec (or a spec_set) will
introspect the specification object’s signature when matching calls to
the mock. Therefore, it can match the actual call’s arguments regardless
of whether they were passed positionally or by name:

Mock objects are callable. The call will return the value set as the
return_value attribute. The default return value is a new Mock
object; it is created the first time the return value is accessed (either
explicitly or by calling the Mock) - but it is stored and the same one
returned each time.

If side_effect is a function then whatever that function returns is what
calls to the mock return. The side_effect function is called with the
same arguments as the mock. This allows you to vary the return value of the
call dynamically, based on the input:

If you want the mock to still return the default return value (a new mock), or
any set return value, then there are two ways of doing this. Either return
mock.return_value from inside side_effect, or return DEFAULT:

Mock objects create attributes on demand. This allows them to pretend to be
objects of any type.

You may want a mock object to return False to a hasattr() call, or raise an
AttributeError when an attribute is fetched. You can do this by providing
an object as a spec for a mock, but that isn’t always convenient.

You “block” attributes by deleting them. Once deleted, accessing an attribute
will raise an AttributeError.

Since “name” is an argument to the Mock constructor, if you want your
mock object to have a “name” attribute you can’t just pass it in at creation
time. There are two alternatives. One option is to use
configure_mock():

When you attach a mock as an attribute of another mock (or as the return
value) it becomes a “child” of that mock. Calls to the child are recorded in
the method_calls and mock_calls attributes of the
parent. This is useful for configuring child mocks and then attaching them to
the parent, or for attaching mocks to a parent that records all calls to the
children and allows you to make assertions about the order of calls between
mocks:

The only exceptions are magic methods and attributes (those that have
leading and trailing double underscores). Mock doesn’t create these but
instead raises an AttributeError. This is because the interpreter
will often implicitly request these methods, and gets very confused to
get a new Mock object when it expects a magic method. If you need magic
method support see magic methods.

The patch decorators are used for patching objects only within the scope of
the function they decorate. They automatically handle the unpatching for you,
even if exceptions are raised. All of these functions can also be used in with
statements or as class decorators.

patch() acts as a function decorator, class decorator or a context
manager. Inside the body of the function or with statement, the target
is patched with a new object. When the function/with statement exits
the patch is undone.

If new is omitted, then the target is replaced with a
MagicMock. If patch() is used as a decorator and new is
omitted, the created mock is passed in as an extra argument to the
decorated function. If patch() is used as a context manager the created
mock is returned by the context manager.

target should be a string in the form 'package.module.ClassName'. The
target is imported and the specified object replaced with the new
object, so the target must be importable from the environment you are
calling patch() from. The target is imported when the decorated function
is executed, not at decoration time.

The spec and spec_set keyword arguments are passed to the MagicMock
if patch is creating one for you.

In addition you can pass spec=True or spec_set=True, which causes
patch to pass in the object being mocked as the spec/spec_set object.

new_callable allows you to specify a different class, or callable object,
that will be called to create the new object. By default MagicMock is
used.

A more powerful form of spec is autospec. If you set autospec=True
then the mock will be created with a spec from the object being replaced.
All attributes of the mock will also have the spec of the corresponding
attribute of the object being replaced. Methods and functions being mocked
will have their arguments checked and will raise a TypeError if they are
called with the wrong signature. For mocks
replacing a class, their return value (the ‘instance’) will have the same
spec as the class. See the create_autospec() function and
Autospeccing.

Instead of autospec=True you can pass autospec=some_object to use an
arbitrary object as the spec instead of the one being replaced.

By default patch() will fail to replace attributes that don’t exist. If
you pass in create=True, and the attribute doesn’t exist, patch will
create the attribute for you when the patched function is called, and
delete it again afterwards. This is useful for writing tests against
attributes that your production code creates at runtime. It is off by
default because it can be dangerous. With it switched on you can write
passing tests against APIs that don’t actually exist!

Patch can be used as a TestCase class decorator. It works by
decorating each test method in the class. This reduces the boilerplate
code when your test methods share a common patchings set. patch finds
tests by looking for method names that start with patch.TEST_PREFIX.
By default this is test, which matches the way unittest finds tests.
You can specify an alternative prefix by setting patch.TEST_PREFIX.

Patch can be used as a context manager, with the with statement. Here the
patching applies to the indented block after the with statement. If you
use “as” then the patched object will be bound to the name after the
“as”; very useful if patch is creating a mock object for you.

patch takes arbitrary keyword arguments. These will be passed to
the Mock (or new_callable) on construction.

patch.dict(...), patch.multiple(...) and patch.object(...) are
available for alternate use-cases.

patch as function decorator, creating the mock for you and passing it into
the decorated function:

When patch() is creating a mock for you, it is common that the first thing
you need to do is to configure the mock. Some of that configuration can be done
in the call to patch. Any arbitrary keywords you pass into the call will be
used to set attributes on the created mock:

As well as attributes on the created mock attributes, like the
return_value and side_effect, of child mocks can
also be configured. These aren’t syntactically valid to pass in directly as
keyword arguments, but a dictionary with these as keys can still be expanded
into a patch() call using **:

patch the named member (attribute) on an object (target) with a mock
object.

patch.object() can be used as a decorator, class decorator or a context
manager. Arguments new, spec, create, spec_set, autospec and
new_callable have the same meaning as for patch(). Like patch(),
patch.object() takes arbitrary keyword arguments for configuring the mock
object it creates.

When used as a class decorator patch.object() honours patch.TEST_PREFIX
for choosing which methods to wrap.

You can either call patch.object() with three arguments or two arguments. The
three argument form takes the object to be patched, the attribute name and the
object to replace the attribute with.

When calling with the two argument form you omit the replacement object, and a
mock is created for you and passed in as an extra argument to the decorated
function:

Perform multiple patches in a single call. It takes the object to be
patched (either as an object or a string to fetch the object by importing)
and keyword arguments for the patches:

withpatch.multiple(settings,FIRST_PATCH='one',SECOND_PATCH='two'):...

Use DEFAULT as the value if you want patch.multiple() to create
mocks for you. In this case the created mocks are passed into a decorated
function by keyword, and a dictionary is returned when patch.multiple() is
used as a context manager.

patch.multiple() can be used as a decorator, class decorator or a context
manager. The arguments spec, spec_set, create, autospec and
new_callable have the same meaning as for patch(). These arguments will
be applied to all patches done by patch.multiple().

When used as a class decorator patch.multiple() honours patch.TEST_PREFIX
for choosing which methods to wrap.

If you want patch.multiple() to create mocks for you, then you can use
DEFAULT as the value. If you use patch.multiple() as a decorator
then the created mocks are passed into the decorated function by keyword.

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.
unittest.TestCase.addCleanup() makes this easier:

All of the patchers can be used as class decorators. When used in this way
they wrap every test method on the class. The patchers recognise methods that
start with 'test' as being test methods. This is the same way that the
unittest.TestLoader finds test methods by default.

It is possible that you want to use a different prefix for your tests. You can
inform the patchers of the different prefix by setting patch.TEST_PREFIX:

patch() works by (temporarily) changing the object that a name points to with
another one. There can be many names pointing to any individual object, so
for patching to work you must ensure that you patch the name used by the system
under test.

The basic principle is that you patch where an object is looked up, which
is not necessarily the same place as where it is defined. A couple of
examples will help to clarify this.

Imagine we have a project that we want to test with the following structure:

Now we want to test some_function but we want to mock out SomeClass using
patch(). The problem is that when we import module b, which we will have to
do then it imports SomeClass from module a. If we use patch() to mock out
a.SomeClass then it will have no effect on our test; module b already has a
reference to the realSomeClass and it looks like our patching had no
effect.

The key is to patch out SomeClass where it is used (or where it is looked up
). In this case some_function will actually look up SomeClass in module b,
where we have imported it. The patching should look like:

@patch('b.SomeClass')

However, consider the alternative scenario where instead of fromaimportSomeClass module b does importa and some_function uses a.SomeClass. Both
of these import forms are common. In this case the class we want to patch is
being looked up in the module and so we have to patch a.SomeClass instead:

Both patch and patch.object correctly patch and restore descriptors: class
methods, static methods and properties. You should patch these on the class
rather than an instance. They also work with some objects
that proxy attribute access, like the django settings object.

Mock supports mocking the Python protocol methods, also known as
“magic methods”. This allows mock objects to replace containers or other
objects that implement Python protocols.

Because magic methods are looked up differently from normal methods [2], this
support has been specially implemented. This means that only specific magic
methods are supported. The supported list includes almost all of them. If
there are any missing that you need please let us know.

You mock magic methods by setting the method you are interested in to a function
or a mock instance. If you are using a function then it must take self as
the first argument [3].

By default many of the protocol methods are required to return objects of a
specific type. These methods are preconfigured with a default return value, so
that they can be used without you having to do anything if you aren’t interested
in the return value. You can still set the return value manually if you want
to change the default.

The two equality methods, __eq__() and __ne__(), are special.
They do the default equality comparison on identity, using the
side_effect attribute, unless you change their return value to
return something else:

Magic methods should be looked up on the class rather than the
instance. Different versions of Python are inconsistent about applying this
rule. The supported protocol methods should work with all supported versions
of Python.

The sentinel object provides a convenient way of providing unique
objects for your tests.

Attributes are created on demand when you access them by name. Accessing
the same attribute will always return the same object. The objects
returned have a sensible repr so that test failure messages are readable.

Sometimes when testing you need to test that a specific object is passed as an
argument to another method, or returned. It can be common to create named
sentinel objects to test this. sentinel provides a convenient way of
creating and testing the identity of objects like this.

In this example we monkey patch method to return sentinel.some_object:

For a call object that represents multiple calls, call_list()
returns a list of all the intermediate calls as well as the
final call.

call_list is particularly useful for making assertions on “chained calls”. A
chained call is multiple calls on a single line of code. This results in
multiple entries in mock_calls on a mock. Manually constructing
the sequence of calls can be tedious.

call_list() can construct the sequence of calls from the same
chained call:

A call object is either a tuple of (positional args, keyword args) or
(name, positional args, keyword args) depending on how it was constructed. When
you construct them yourself this isn’t particularly interesting, but the call
objects that are in the Mock.call_args, Mock.call_args_list and
Mock.mock_calls attributes can be introspected to get at the individual
arguments they contain.

The call objects in Mock.call_args and Mock.call_args_list
are two-tuples of (positional args, keyword args) whereas the call objects
in Mock.mock_calls, along with ones you construct yourself, are
three-tuples of (name, positional args, keyword args).

You can use their “tupleness” to pull out the individual arguments for more
complex introspection and assertions. The positional arguments are a tuple
(an empty tuple if there are no positional arguments) and the keyword
arguments are a dictionary:

Create a mock object using another object as a spec. Attributes on the
mock will use the corresponding attribute on the spec object as their
spec.

Functions or methods being mocked will have their arguments checked to
ensure that they are called with the correct signature.

If spec_set is True then attempting to set attributes that don’t exist
on the spec object will raise an AttributeError.

If a class is used as a spec then the return value of the mock (the
instance of the class) will have the same spec. You can use a class as the
spec for an instance object by passing instance=True. The returned mock
will only be callable if instances of the mock are callable.

create_autospec() also takes arbitrary keyword arguments that are passed to
the constructor of the created mock.

Sometimes you may need to make assertions about some of the arguments in a
call to mock, but either not care about some of the arguments or want to pull
them individually out of call_args and make more complex
assertions on them.

FILTER_DIR is a module level variable that controls the way mock objects
respond to dir() (only for Python 2.6 or more recent). The default is True,
which uses the filtering described below, to only show useful members. If you
dislike this filtering, or need to switch it off for diagnostic purposes, then
set mock.FILTER_DIR=False.

With filtering on, dir(some_mock) shows only useful attributes and will
include any dynamically created attributes that wouldn’t normally be shown.
If the mock was created with a spec (or autospec of course) then all the
attributes from the original are shown, even if they haven’t been accessed
yet:

Many of the not-very-useful (private to Mock rather than the thing being
mocked) underscore and double underscore prefixed attributes have been
filtered from the result of calling dir() on a Mock. If you dislike this
behaviour you can switch it off by setting the module level switch
FILTER_DIR:

A helper function to create a mock to replace the use of open(). It works
for open() called directly or used as a context manager.

The mock argument is the mock object to configure. If None (the
default) then a MagicMock will be created for you, with the API limited
to methods or attributes available on standard file handles.

read_data is a string for the read(),
readline(), and readlines() methods
of the file handle to return. Calls to those methods will take data from
read_data until it is depleted. The mock of these methods is pretty
simplistic. If you need more control over the data that you are feeding to
the tested code you will need to customize this mock for yourself.
read_data is an empty string by default.

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

withopen('/some/path','w')asf: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).

Mocking context managers with a MagicMock is common enough and fiddly
enough that a helper function is useful.

Autospeccing is based on the existing spec feature of mock. It limits the
api of mocks to the api of an original object (the spec), but it is recursive
(implemented lazily) so that attributes of mocks only have the same api as
the attributes of the spec. In addition mocked functions / methods have the
same call signature as the original so they raise a TypeError if they are
called incorrectly.

Before I explain how auto-speccing works, here’s why it is needed.

Mock is a very powerful and flexible object, but it suffers from two flaws
when used to mock out objects from a system under test. One of these flaws is
specific to the Mock api and the other is a more general problem with using
mock objects.

The second issue is more general to mocking. If you refactor some of your
code, rename members and so on, any tests for code that is still using the
old api but uses mocks instead of the real objects will still pass. This
means your tests can all pass even though your code is broken.

Note that this is another reason why you need integration tests as well as
unit tests. Testing everything in isolation is all fine and dandy, but if you
don’t test how your units are “wired together” there is still lots of room
for bugs that tests might have caught.

mock already provides a feature to help with this, called speccing. If you
use a class or instance as the spec for a mock then you can only access
attributes on the mock that exist on the real class:

Auto-speccing solves this problem. You can either pass autospec=True to
patch() / patch.object() or use the create_autospec() function to create a
mock with a spec. If you use the autospec=True argument to patch() then the
object that is being replaced will be used as the spec object. Because the
speccing is done “lazily” (the spec is created as attributes on the mock are
accessed) you can use it with very complex or deeply nested objects (like
modules that import modules that import modules) without a big performance
hit.

Request objects are not callable, so the return value of instantiating our
mocked out request.Request is a non-callable mock. With the spec in place
any typos in our asserts will raise the correct error:

This isn’t without caveats and limitations however, which is why it is not
the default behaviour. In order to know what attributes are available on the
spec object, autospec has to introspect (access attributes) the spec. As you
traverse attributes on the mock a corresponding traversal of the original
object is happening under the hood. If any of your specced objects have
properties or descriptors that can trigger code execution then you may not be
able to use autospec. On the other hand it is much better to design your
objects so that introspection is safe [4].

A more serious problem is that it is common for instance attributes to be
created in the __init__() method and not to exist on the class at all.
autospec can’t know about any dynamically created attributes and restricts
the api to visible attributes.

There are a few different ways of resolving this problem. The easiest, but
not necessarily the least annoying, way is to simply set the required
attributes on the mock after creation. Just because autospec doesn’t allow
you to fetch attributes that don’t exist on the spec it doesn’t prevent you
setting them:

There is a more aggressive version of both spec and autospec that does
prevent you setting non-existent attributes. This is useful if you want to
ensure your code only sets valid attributes too, but obviously it prevents
this particular scenario:

Probably the best way of solving the problem is to add class attributes as
default values for instance members initialised in __init__(). Note that if
you are only setting default attributes in __init__() then providing them via
class attributes (shared between instances of course) is faster too. e.g.

classSomething:a=33

This brings up another issue. It is relatively common to provide a default
value of None for members that will later be an object of a different type.
None would be useless as a spec because it wouldn’t let you access any
attributes or methods on it. As None is never going to be useful as a
spec, and probably indicates a member that will normally of some other type,
autospec doesn’t use a spec for members that are set to None. These will
just be ordinary mocks (well - MagicMocks):

If modifying your production classes to add defaults isn’t to your liking
then there are more options. One of these is simply to use an instance as the
spec rather than the class. The other is to create a subclass of the
production class and add the defaults to the subclass without affecting the
production class. Both of these require you to use an alternative object as
the spec. Thankfully patch() supports this - you can simply pass the
alternative object as the autospec argument:

This only applies to classes or already instantiated objects. Calling
a mocked class to create a mock instance does not create a real instance.
It is only attribute lookups - along with calls to dir() - that are done.