Skip to content

Effortlessly Mastering Unit Tests with Python's Unittest Mock


Understanding the Python Mock Object Library

By Alex Ronquillo

When it comes to writing robust and reliable code, testing is essential. However, writing valuable tests can be challenging, especially when dealing with complex logic and unpredictable dependencies. This is where the Python mock object library, unittest.mock, comes in handy.

In this article, we will explore how the Python mock object library can help us overcome these challenges and write effective tests. By the end of this article, you will learn how to create mock objects, assert their usage, inspect data, configure them, substitute mocks for real objects, and avoid common problems in Python mocking.

What Is Mocking?

Mocking is a technique used to substitute and imitate real objects in a testing environment. It allows us to control the behavior of our code during tests, making them more reliable and predictable.

One common use case for mocking is when our code interacts with external services, such as making HTTP requests. By using mock objects, we can simulate the behavior of these external services, allowing us to test our code in a controlled environment. This way, we can easily handle different response scenarios, such as service outages or successful responses.

Mocking also helps us test areas of our code that are hard to reach, such as exceptions or conditional statements. By controlling the execution path of our code using mock objects, we can improve code coverage and ensure that all parts of our code are thoroughly tested.

The Python Mock Library

In Python, the unittest.mock library provides a powerful set of tools for creating and managing mock objects. It allows us to create mock objects using the Mock class, assert their usage, inspect the data stored on mocks, configure their behavior, and substitute them for real objects using the patch() function.

Let’s explore some of the key features and functionalities of the Python mock library:

The Mock Object

The Mock class is the fundamental building block of mock objects in Python. It allows us to create mock objects with customizable behavior and attributes. Some key features of the Mock object include:

  • Lazy Attributes and Methods: We can specify attributes and methods on the mock object as needed, and they will be created when accessed.
  • Assertions and Inspection: We can assert that certain calls or attributes were made on the mock object and inspect the data stored on the mock.
  • Managing Return Values: We can configure the mock object to return specific values when called.
  • Managing Side Effects: We can define side effects for the mock object, such as raising exceptions or modifying external state.
  • Configuring the Mock: We can set various properties and behaviors of the mock object, such as its name, spec, and return value.


The patch() function is a convenient way to substitute real objects with mock objects during tests. It allows us to replace objects, functions, or attributes with mock versions, ensuring that our tests run in a controlled environment. Some key functionalities of patch() include:

  • As a Decorator: We can use patch() as a decorator to automatically patch the specified objects for the duration of a test function.
  • As a Context Manager: We can use patch() as a context manager to patch the objects within a specific code block.
  • Patching Object Attributes: We can use patch() to patch specific attributes of an object instead of replacing the entire object.
  • Choosing Where to Patch: We can specify the target objects to patch using a dotted path, allowing us to patch objects in different modules or packages.

Common Mocking Problems

While mocking can simplify our testing process, it also comes with its own set of challenges. Some common problems we may encounter when using mocks include changes to object interfaces and misspellings, as well as changes to external dependencies. To overcome these problems, we can use specifications, which provide a set of rules and constraints for our mock objects, ensuring that they adhere to the expected interface.


The Python mock object library, unittest.mock, is a powerful tool for improving the quality of our tests. By allowing us to create and manage mock objects, assert their usage, inspect data, configure behavior, and substitute mocks for real objects, the library helps us overcome challenges in testing complex code with unpredictable dependencies.

In this article, we explored the basics of mocking, the functionalities of the Python mock library, and how to avoid common mocking problems. Armed with this knowledge, you can now write more effective and reliable tests for your Python applications.

Remember, testing is a crucial part of the development process, and with the Python mock library, you can take your testing game to the next level!