What Is Mocking in Testing in Odoo 19

Odoo modules have been adding more and more features. With this increase in feature set comes an increase in interaction with other services, which could include special web APIs, email services, payment gateways, and other components that may not always work properly when executing tests. Using these services can lead to tests that are slower than running the test without these services and can cause inconsistencies in your test results.

Mocking lets you isolate your dependencies from your tests by simulating their behaviours as part of your tests. Instead of running the actual implementation, you can define what you expect in terms of responses and test how your code behaves under several conditions.

Why Is Mocking Needed in Odoo Tests?

When developers are writing tests in Odoo 19, they will run into situations where the method they are testing relies upon some external resource or where the work being performed by that method is not needed to validate the logic of the code under test. An example of such a resource might be an API call, an email being sent, an incoming payment processed, or some other method belonging to a different component.

Each time you run a test that relies upon these dependencies, you will likely experience longer test execution times and potentially inconsistent results when testing against these dependencies. Using mocking solutions will alleviate these issues since mocking replaces the actual behavior of the object you are testing with a controlled response for use when executing your tests.

Here are some examples of common scenarios where you can use mocking:

• Preventing calls to external APIs during your tests.
• Preventing emails from being delivered while verifying business logic.
• Simulating how third-party service providers would respond to your request.
• Reducing the total time it takes to execute the test cases.
• Testing edge-case scenarios that would be difficult to reproduce in a live environment.

Understanding unittest.mock

Using Python's built-in testing frameworks, Odoo uses unittest.mock as a way to substitute objects for testing purposes. One of the most commonly used features of unittest.mock is its ability to patch (or temporarily replace) a method or object with a mock version of itself.

The primary benefit of using patching is that it allows you to focus on the part of your code you are testing without worrying about the implementation of other methods in the system.

Some of the most commonly used methods of unittest.mock includes:

• patch() – Temporarily replace a method/object.
• MagicMock() – Create mock objects with configurable behavior.
• return_value – Define what a mocked method will return.
• assert_called_once() – Assert that a mocked method was called only once.

Using patch() in Odoo 19

Mocking can be accomplished using a patch() method either as a decorator or within a context manager. When the tests are executing, the actual implementation of a tested method will be replaced by a mocked version, so it will be reloaded at the completion of the tests.

from unittest.mock import patch
from odoo.tests.common import TransactionCase

class TestPartner(TransactionCase):
    @patch("odoo.addons.my_module.models.partner.some_method")
    def test_some_method(self, mock_method):
        mock_method.return_value = True
        partner = self.env["res.partner"].create({
            "name": "Demo Partner"
        })
        result = partner.some_method()
        self.assertTrue(result)

For the example given, the implementation of some_method() will not be executed during tests but will be used when you request the value from the mock object.

Mocking External API Calls

Many Odoo modules interact with third-party systems. It is not advisable to use real APIs for testing purposes, as services may be down or they will respond in different ways over time.

Consider the following example:

import requests
def get_customer_data():
    response = requests.get(
        "https://api.example.com/customer"
    )
    return response.json()

Instead of making an actual HTTP request, the response can be mocked.

from unittest.mock import patch
@patch("requests.get")
def test_get_customer_data(mock_get):
    mock_get.return_value.json.return_value = {
        "name": "John Doe",
        "email": "john@example.com"
    }
    data = get_customer_data()
    assert data["name"] == "John Doe"

Benefits of Mocking

Mocking Odoo tests has several benefits, including:

• Test cases execute faster.
• Components are more isolated.
• The number of dependencies on external services is reduced.
• Test results will be more consistent across multiple test runs.
• Test failure scenarios are much easier to simulate.
• Test suites will be easier to maintain.

Best Practices for Mocking

While there are many advantages to mocking, it should always be done with caution. If you overmock your tests, they may become difficult to read and maintain.

Some basic guidelines for using mock objects are:

• Only mock external dependencies when necessary.
• Keep the test case focused on a single behavior.
• Use a realistic response when mocking.
• Don't mock every method unnecessarily.
• Use assertions to verify important method calls.
• Keep tests simple and easy to read.

Having a balanced approach to mocking is important for creating reliable and dependable tests without losing trust in how the application will work in the real world. When mocked correctly, mocks will allow developers to create maintainable and predictable Odoo 19 modules.

Mocking is one method of writing effective, reliable tests of Odoo 19. When the developer replaces the external dependencies from the code under test with predefined responses, he/she wants to test the business logic of that code without having to depend upon external services or lengthy processing.

By the use of Python's unittest.mock library, Odoo developers can create different scenarios for testing, check that certain methods have been called, and isolate their test cases, which makes them easier to maintain. Proper use of mocking will lead to a more stable codebase and will simplify the testing of Odoo applications that are complex.

To read more about Overview of Unit Tests in Odoo 19, refer to our blog Overview of Unit Tests in Odoo 19.