Why mocking isolates code under test in PyTest

Introduction

Mocking helps test one part of code by pretending other parts work correctly. This way, you focus only on what you want to check.

When a function depends on a slow database or network call.

When a part of code uses an external service you cannot control.

When you want to test error handling without causing real errors.

When the real code changes data and you want to avoid side effects.

When you want to test a small piece of code without running the whole system.

Syntax

PyTest

from unittest.mock import Mock

mock_object = Mock()
mock_object.method.return_value = expected_value

result = code_under_test(mock_object)
assert result == expected_result

Use Mock() to create a fake object.

Set return values or side effects to control behavior.

Examples

This example mocks an API call to return fixed data.

PyTest

from unittest.mock import Mock

mock_api = Mock()
mock_api.get_data.return_value = {'id': 1, 'name': 'Test'}

response = mock_api.get_data()
assert response['name'] == 'Test'

This example mocks a database save method to raise an error for testing error handling.

PyTest

from unittest.mock import Mock

mock_db = Mock()
mock_db.save.side_effect = Exception('DB error')

try:
    mock_db.save()
except Exception as e:
    assert str(e) == 'DB error'

Sample Program

This test uses a mock API client to isolate and test the fetch_user_name function without calling a real API.

PyTest

from unittest.mock import Mock

def fetch_user_name(api_client, user_id):
    user = api_client.get_user(user_id)
    return user['name']

# Create a mock API client
mock_api = Mock()
mock_api.get_user.return_value = {'id': 42, 'name': 'Alice'}

# Test fetch_user_name with the mock
result = fetch_user_name(mock_api, 42)
assert result == 'Alice'
print('Test passed')

Important Notes

Mocking avoids slow or unreliable external calls during tests.

It helps test only the code you want, making tests simpler and faster.

Remember to set expected return values or side effects on mocks.

Summary

Mocking replaces real parts with fake ones to isolate code under test.

This makes tests faster, more reliable, and focused.

Use mocks to control dependencies and test different scenarios easily.

Practice

1. Why do we use mocking in pytest when testing a function that depends on an external API?

easy

A. To make the test code longer and more complex

B. To replace the external API with a fake version so tests run faster and are reliable

C. To avoid writing any assertions in the test

D. To connect to the real API every time the test runs

Solution

1. Step 1: Understand the purpose of mocking

   Mocking replaces real parts like external APIs with fake versions to isolate the code under test.

2. Step 2: Identify benefits in testing context

   This makes tests faster and more reliable because they don't depend on the real API's availability or speed.

3. Final Answer:

   To replace the external API with a fake version so tests run faster and are reliable -> Option B

4. Quick Check:

   Mocking isolates code = Replace real parts with fakes [OK]

Hint: Mocking swaps real parts with fakes for fast, reliable tests [OK]

Common Mistakes:

• Thinking mocking makes tests more complex
• Believing mocking skips assertions
• Assuming mocking calls the real API

2. Which of the following is the correct way to mock a function get_data in pytest using the monkeypatch fixture?

easy

A. monkeypatch.setattr('module.get_data', lambda: 'mocked')

B. monkeypatch.mock('module.get_data', 'mocked')

C. monkeypatch.patch('module.get_data', lambda: 'mocked')

D. monkeypatch.replace('module.get_data', 'mocked')

Solution

1. Step 1: Recall monkeypatch syntax

   The correct method to replace an attribute is setattr with the target path and replacement function.

2. Step 2: Verify the correct usage

   monkeypatch.setattr('module.get_data', lambda: 'mocked') uses monkeypatch.setattr('module.get_data', lambda: 'mocked'), which correctly mocks the function.

3. Final Answer:

   monkeypatch.setattr('module.get_data', lambda: 'mocked') -> Option A

4. Quick Check:

   Use monkeypatch.setattr to mock functions [OK]

Hint: Use monkeypatch.setattr to replace functions in pytest [OK]

Common Mistakes:

• Using non-existent monkeypatch methods like mock or patch
• Passing string instead of a callable for function replacement
• Confusing monkeypatch with unittest.mock syntax

3. Given the code below, what will be the output of the test?

import pytest

def fetch_data():
    return 'real data'

def process():
    return fetch_data()

def test_process(monkeypatch):
    monkeypatch.setattr('__main__.fetch_data', lambda: 'mocked data')
    result = process()
    assert result == 'mocked data'
    print(result)

medium

A. real data

B. AssertionError

C. mocked data

D. NameError

Solution

1. Step 1: Understand monkeypatch effect on fetch_data

   The monkeypatch replaces fetch_data with a lambda returning 'mocked data'.

2. Step 2: Trace the process function call

   When process() calls fetch_data(), it gets 'mocked data' instead of 'real data'.

3. Final Answer:

   mocked data -> Option C

4. Quick Check:

   Mocked function returns mocked data [OK]

Hint: Monkeypatch changes function output to mocked value [OK]

Common Mistakes:

• Expecting original function output despite mocking
• Confusing assertion failure with output
• Assuming NameError due to monkeypatch

4. In the following test, what is the main reason the assertion fails?

def get_value():
    return 10

def test_value(monkeypatch):
    monkeypatch.setattr('__main__.get_value', lambda: 20)
    assert get_value() == 10

medium

A. The assertion expects the original value, but mocking changed it to 20

B. The monkeypatch syntax is incorrect

C. The function get_value is not defined

D. The test is missing a return statement

Solution

1. Step 1: Analyze the monkeypatch effect

   The monkeypatch replaces get_value to return 20 instead of 10.

2. Step 2: Check the assertion

   The assertion expects 10, but the mocked function returns 20, causing failure.

3. Final Answer:

   The assertion expects the original value, but mocking changed it to 20 -> Option A

4. Quick Check:

   Mock changes output, assertion expects old value [OK]

Hint: Assertion fails if expected value ignores mocking effect [OK]

Common Mistakes:

• Thinking monkeypatch syntax is wrong
• Assuming function is undefined
• Believing test needs a return statement

5. You have a function send_email() that sends real emails. You want to test notify_user() which calls send_email()</>. How does mocking send_email() help isolate notify_user() in pytest?

hard

A. It disables notify_user completely

B. It makes notify_user send multiple emails automatically

C. It connects notify_user to the real email server faster

D. It prevents real emails from sending and lets you test notify_user's logic only

Solution

1. Step 1: Identify the problem with real send_email

   Calling real send_email() during tests can send unwanted emails and slow tests.

2. Step 2: Understand mocking benefit

   Mocking send_email() replaces it with a fake that does nothing or simulates success, isolating notify_user() logic.

3. Final Answer:

   It prevents real emails from sending and lets you test notify_user's logic only -> Option D

4. Quick Check:

   Mocking avoids side effects, isolates tested code [OK]

Hint: Mock side-effect functions to isolate main logic in tests [OK]

Common Mistakes:

• Thinking mocking triggers real side effects
• Assuming mocking disables the tested function
• Believing mocking speeds up real connections