unittest.mock.patch in PyTest - Build an Automation Script

Test function behavior using unittest.mock.patch to mock a dependency

Preconditions (2)

Step 1: Use unittest.mock.patch to mock 'requests.get' inside the test

Step 2: Set the mock to return a response object with .json() method returning {'key': 'value'}

Step 3: Call 'process_data' function

Step 4: Verify that 'process_data' returns the expected processed result based on the mocked data

✅ Expected Result: The test passes confirming that 'process_data' correctly processes the mocked API data without making a real HTTP request

Automation Requirements - pytest

Assertions Needed:

Assert that 'process_data' returns the expected processed output

Assert that 'requests.get' was called once with the correct URL

Best Practices:

Use unittest.mock.patch as a context manager or decorator to mock external dependencies

Mock only the external call, not the function under test

Use mock return_value and side_effect properly to simulate responses

Keep tests isolated and independent from real network calls

Automated Solution

PyTest

import pytest
from unittest.mock import patch, Mock

# Assume these are in your module named 'my_module'
import my_module

def test_process_data_with_mocked_get():
    mock_response = Mock()
    mock_response.json.return_value = {'key': 'value'}

    with patch('my_module.requests.get', return_value=mock_response) as mock_get:
        result = my_module.process_data()

        # Assert the processed result is as expected
        assert result == 'Processed value', f"Expected 'Processed value' but got {result}"

        # Assert requests.get was called once with the expected URL
        mock_get.assert_called_once_with('https://api.example.com/data')

This test uses unittest.mock.patch as a context manager to replace requests.get with a mock object during the test. We create a mock response object whose json() method returns a fixed dictionary. This simulates the API response without making a real HTTP call.

We then call process_data(), which internally calls get_data() that uses requests.get. Because of the patch, it receives the mocked response.

We assert that the processed result matches the expected output based on the mocked data. We also verify that requests.get was called exactly once with the correct URL, ensuring our code calls the API as expected.

This approach keeps tests fast, reliable, and independent from external services.

Common Mistakes - 4 Pitfalls

Mocking the function under test instead of its dependencies

{'mistake': "Not setting the mock's return_value or side_effect properly", 'why_bad': 'The function under test may receive None or unexpected values, causing test failures or false positives.', 'correct_approach': 'Always configure the mock to return realistic data matching what the real dependency would return.'}

Using hardcoded patch target strings incorrectly

{'mistake': 'Not asserting that the mock was called', 'why_bad': 'You might miss that the function did not call the dependency as expected.', 'correct_approach': "Use mock's assert_called_once_with or similar methods to verify calls."}

Bonus Challenge

Now add data-driven testing with 3 different mocked API responses and verify process_data handles each correctly

Show Hint

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