unittest.mock.patch in PyTest

Introduction

unittest.mock.patch helps you replace parts of your code during tests. This lets you control what those parts do, so you can test your code easily.

When you want to replace a function that calls an external service to avoid real calls during tests.

When you want to simulate different return values from a function to test how your code reacts.

When you want to replace a class or object temporarily to isolate the part you are testing.

When you want to avoid slow or complex operations during testing by mocking them.

When you want to check if a function was called without running its real code.

Syntax

PyTest

from unittest.mock import patch

@patch('module_name.function_name')
def test_function(mock_function):
    mock_function.return_value = expected_value
    # your test code here

Use the full path to the function or object you want to replace, like 'package.module.function'.

The patched object is replaced only during the test and restored after it finishes.

Examples

This replaces math.sqrt with a mock that always returns 3 during the test.

PyTest

from unittest.mock import patch

@patch('math.sqrt')
def test_sqrt(mock_sqrt):
    mock_sqrt.return_value = 3
    result = mock_sqrt(9)
    assert result == 3

This uses patch as a context manager to mock requests.get only inside the with block.

PyTest

from unittest.mock import patch
import requests

def test_api_call():
    with patch('requests.get') as mock_get:
        mock_get.return_value.status_code = 200
        response = requests.get('http://example.com')
        assert response.status_code == 200

Sample Program

This test replaces requests.get with a mock that returns a response with status_code 404. The test checks if fetch_status returns 404 as expected.

PyTest

from unittest.mock import patch
import requests

def fetch_status(url):
    response = requests.get(url)
    return response.status_code

@patch('requests.get')
def test_fetch_status(mock_get):
    mock_get.return_value.status_code = 404
    status = fetch_status('http://fakeurl.com')
    assert status == 404
    print('Test passed')

if __name__ == '__main__':
    test_fetch_status()

Important Notes

Always patch where the function or object is used, not where it is defined.

Remember to set return_value or side_effect on the mock to control its behavior.

Using patch as a decorator or context manager depends on how long you want the mock to last.

Summary

unittest.mock.patch lets you replace parts of your code during tests to control behavior.

Use patch to avoid real calls and test your code in isolation.

Patch can be used as a decorator or context manager for flexible mocking.

Practice

1. What is the main purpose of using unittest.mock.patch in pytest?

easy

A. To automatically generate test data for functions

B. To speed up the execution of tests by skipping them

C. To check the syntax of the code before running tests

D. To replace parts of the code temporarily during tests to control behavior

Solution

1. Step 1: Understand the role of patch

   unittest.mock.patch is used to replace parts of your code temporarily during tests, so you can control how those parts behave without running the real code.

2. Step 2: Compare with other options

   The other options describe generating test data, speeding up tests by skipping them, or checking syntax, none of which patch performs.

3. Final Answer:

   To replace parts of the code temporarily during tests to control behavior -> Option D

4. Quick Check:

   Patch replaces code parts temporarily [OK]

Hint: Patch replaces code parts temporarily during tests [OK]

Common Mistakes:

• Thinking patch speeds up tests by skipping them
• Confusing patch with test data generation
• Believing patch checks code syntax

2. Which of the following is the correct syntax to patch the function requests.get using a decorator in pytest?

easy

A. @patch(requests.get)

B. @patch('requests.get()')

C. @patch('requests.get')

D. @patch('requests->get')

Solution

1. Step 1: Understand patch decorator syntax

   The patch decorator requires the target as a string with the full path, like 'module.function'. So, '@patch('requests.get')' is correct.

2. Step 2: Identify incorrect syntax

   @patch(requests.get) misses quotes around the target, @patch('requests.get()') adds incorrect parentheses, and @patch('requests->get') uses an invalid arrow symbol.

3. Final Answer:

   @patch('requests.get') -> Option C

4. Quick Check:

   Patch target must be a string path [OK]

Hint: Patch target is always a string path in quotes [OK]

Common Mistakes:

• Omitting quotes around the target string
• Adding parentheses after the function name
• Using invalid symbols like arrows in the target

3. Given the following code, what will be printed when the test runs?

import requests
from unittest.mock import patch

def fetch_data():
    return requests.get('http://example.com').status_code

@patch('requests.get')
def test_fetch(mock_get):
    mock_get.return_value.status_code = 404
    print(fetch_data())

if __name__ == '__main__':
    test_fetch()

medium

A. 404

B. 200

C. None

D. AttributeError

Solution

1. Step 1: Understand patch effect on requests.get

   The decorator replaces requests.get with a mock object. The mock's return_value.status_code is set to 404.

2. Step 2: Trace fetch_data call

   When fetch_data() calls requests.get, it gets the mock, whose status_code is 404, so it returns 404.

3. Final Answer:

   404 -> Option A

4. Quick Check:

   Mock return_value.status_code = 404 means fetch_data() returns 404 [OK]

Hint: Mock return_value sets the function's return object [OK]

Common Mistakes:

• Expecting real HTTP status 200 instead of mocked 404
• Confusing mock object with None
• Thinking patch causes an error here

4. What is wrong with this test code using patch?

from unittest.mock import patch

def test_api_call():
    with patch('api.requests.get') as mock_get:
        mock_get.status_code = 200
        response = api_call()
        assert response == 'success'

medium

A. The assert statement syntax is incorrect

B. mock_get.status_code should be set on mock_get.return_value, not mock_get

C. The patch should be used as a decorator, not a context manager

D. The patch target string is missing quotes

Solution

1. Step 1: Understand mock object structure

   When patching a function, the mock object replaces the function. The function call returns mock_get.return_value. So, attributes like status_code must be set on mock_get.return_value.

2. Step 2: Identify the error in code

   The code sets mock_get.status_code = 200 which is incorrect; it should be mock_get.return_value.status_code = 200.

3. Final Answer:

   mock_get.status_code should be set on mock_get.return_value, not mock_get -> Option B

4. Quick Check:

   Set attributes on return_value, not mock function [OK]

Hint: Set return_value attributes, not mock function attributes [OK]

Common Mistakes:

• Setting attributes directly on the mock function
• Forgetting quotes around patch target
• Thinking patch must be decorator only
• Miswriting assert syntax

5. You want to test a function process_data() that calls fetch_from_api() internally. You want to patch fetch_from_api only during the test to return a fixed value. Which is the best way to do this using unittest.mock.patch?

hard

A. Use @patch('module.fetch_from_api') decorator on the test function and set mock_fetch.return_value

B. Replace fetch_from_api globally in the module before running tests

C. Modify fetch_from_api code to return fixed value during tests

D. Call fetch_from_api directly in the test without patching

Solution

1. Step 1: Understand patch scope and usage

   Using @patch('module.fetch_from_api') decorator temporarily replaces fetch_from_api only during the test, allowing control over its return value.

2. Step 2: Evaluate other options

   Replace fetch_from_api globally in the module before running tests changes global code, which is unsafe. Modify fetch_from_api code to return fixed value during tests modifies production code, which is bad practice. Call fetch_from_api directly in the test without patching does not isolate the test.

3. Final Answer:

   Use @patch('module.fetch_from_api') decorator on the test function and set mock_fetch.return_value -> Option A

4. Quick Check:

   Patch with decorator for safe, temporary replacement [OK]

Hint: Patch with decorator for temporary, safe replacement [OK]

Common Mistakes:

• Changing global code instead of patching
• Modifying production code for tests
• Not patching and calling real function