Testing Like a Professional: A Step-by-Step Information to Python’s Mock Library

Picture by Creator | DALLE-3 & Canva

Testing software program is essential for guaranteeing reliability and performance throughout completely different eventualities. Nonetheless, if the code implementation relies on exterior companies, it turns into fairly a problem. That is the place mocking is available in. Python’s mock library offers instruments to create mock objects to exchange actual objects, making your exams simpler to take care of. Mocking facilitates targeted testing of parts and faster testing cycles.

What’s Mocking?

Mocking is a way utilized in software program testing to simulate actual objects. Actual objects are changed by mock objects to simulate their performance, permitting you to check code in numerous eventualities and isolation. Mocking is very helpful to check particular components of the codebase with out counting on the interplay with exterior programs, databases, or different advanced companies.

Let me clarify this idea with an instance. Contemplate that you’ve got an online utility that makes use of an exterior API to retrieve knowledge. To check with out relying on the actual API, you may make a mock object that mimics the solutions of the API. This manner, you’ll be able to check your utility’s performance with out being depending on the actual API, which may be sluggish, unreliable, or not even accessible throughout improvement.

Sounds fascinating, proper? Let’s now go over an in depth how-to for truly utilizing this library.

Step-by-Step Information to Utilizing Mock

Step 1: Importing the Mock Library

The unittest.mock is the usual library in Python (3.3 and in all newer variations) that gives mock objects to manage the conduct of actual objects. First it’s worthwhile to import it the unittest.mock library.

from unittest.mock import Mock, patch

Step 2: Making a Mock Object

Making a mock object is simple. As soon as imported, you’ll be able to instantiate a mock object like this:

Now, my_mock is a mock object which you can configure to simulate the conduct of an actual object.

Step 3: Setting Return Values

The Mock library offers varied methods to configure mock objects and management their conduct. For example, you’ll be able to specify what a technique ought to return when referred to as:

my_mock.some_method.return_value="Hey, World!"
print(my_mock.some_method())

Output:

Step 4: Setting Aspect Results

Unintended effects are extra actions or behaviors triggered when a technique of a mock object is known as, reminiscent of elevating exceptions or executing features. Moreover return values, you too can outline attributes or specify uncomfortable side effects like this:

def raise_exception():
    increase ValueError("An error occurred")

my_mock.some_method.side_effect = raise_exception

# This can increase a ValueError
strive:
    my_mock.some_method()
besides ValueError as e:
    print(e)  

Output:

On this instance, ValueError raises at any time when some_method() is known as.

Step 5: Asserting Calls

Verifying the tactic calls is essential for thorough testing. You should utilize assertions to specify whether or not a technique was referred to as, when, and with what arguments.

my_mock.calculate_length('foo', 'bar')
my_mock.calculate_length.assert_called()
my_mock.calculate_length.assert_called_once()
my_mock.calculate_length.assert_called_with('foo', 'bar')
my_mock.calculate_length.assert_called_once_with('foo', 'bar')

• assert_called(): Returns True if calculate_length was referred to as no less than as soon as
• assert_called_once(): Returns True if calculate_length was referred to as precisely as soon as
• assert_called_with('foo', 'bar'): Returns True if calculate_length was referred to as with the identical arguments
• assert_called_once_with('foo', 'bar'): Returns True if calculate_length was referred to as precisely as soon as with the identical arguments

If any of those assertions fail on the mock object, an AssertionError shall be raised, indicating that the anticipated conduct didn’t match the precise conduct of the mock.

Step 6: Utilizing Patch

The patch operate lets you exchange actual objects with mock objects throughout exams. As mentioned earlier, that is significantly helpful for simulating third-party libraries or APIs, guaranteeing your exams stay remoted from precise implementations. To reveal patching, take into account the next instance operate that fetches knowledge from the URL.

# my_module.py
import requests

def fetch_data(url):
    response = requests.get(url)
    return response.json()

You’ll be able to keep away from making actual HTTP requests by patching the ‘requests.get’ like this:

# test_my_module.py
import unittest
from unittest.mock import patch
import my_module

class TestFetchData(unittest.TestCase):
    @patch('my_module.requests.get')

    def test_fetch_data(self, mock_get):
        # Arrange the mock to return a selected response
        mock_get.return_value.json.return_value = {'key': 'worth'}
       
        # Name the operate to check
        consequence = my_module.fetch_data('http://instance.com')
       
        # Verify the consequence
        self.assertEqual(consequence, {'key': 'worth'})
       
        # Confirm that requests.get was referred to as appropriately
        mock_get.assert_called_once_with('http://instance.com')

if __name__ == '__main__':
    unittest.primary()

The patch decorator is added simply above the test_fetch_data operate to exchange the requests.get operate with a mock.

Step 7: Mocking Lessons

You’ll be able to mock whole courses and their strategies to simulate interactions between objects. For example, you’ll be able to mock a database class to check your utility’s interplay with the database with out the necessity to arrange an actual database connection like this:

# database.py
class Database:
    def join(self):
        cross

    def save_user(self, consumer):
        cross

    def get_user(self, user_id):
        cross


# test_database.py
from unittest.mock import Mock

# Making a mock database object
mock_db = Mock(spec=Database)

# Simulating technique calls
mock_db.join()
mock_db.save_user({"id": 1, "title": "Alice"})
mock_db.get_user(1)

# Verifying that the strategies had been referred to as
mock_db.join.assert_called_once()
mock_db.save_user.assert_called_once_with({"id": 1, "title": "Alice"})
mock_db.get_user.assert_called_once_with(1)

Wrapping Up

 
That is it for at present’s article on unittest.mock, a strong library for testing in Python. It permits builders to check code, guaranteeing clean interactions between objects. With superior options like specifying uncomfortable side effects, asserting calls, mocking courses, and utilizing context managers, testing varied eventualities turns into simpler. Begin utilizing mocks in your exams at present to make sure higher-quality code and smoother deployments.

Kanwal Mehreen Kanwal is a machine studying engineer and a technical author with a profound ardour for knowledge science and the intersection of AI with medication. She co-authored the e book “Maximizing Productiveness with ChatGPT”. As a Google Technology Scholar 2022 for APAC, she champions variety and educational excellence. She’s additionally acknowledged as a Teradata Range in Tech Scholar, Mitacs Globalink Analysis Scholar, and Harvard WeCode Scholar. Kanwal is an ardent advocate for change, having based FEMCodes to empower ladies in STEM fields.