unittest.mock.patch in PyTest - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of unittest.mock.patch in testing?

unittest.mock.patch temporarily replaces a part of your code (like a function or object) with a mock version during a test. This helps isolate the code you want to test by controlling dependencies.

beginner

How do you use patch as a decorator in pytest?

You add @patch('module_name.object_name') above your test function. The patched object is passed as an argument to your test, letting you control or check its behavior.

beginner

What does patching a function mean in simple terms?

It means swapping the real function with a fake one during a test. This fake function can return controlled results or track how it was called.

intermediate

What is the difference between patching with a decorator and patching with a context manager?

Decorator patching applies for the whole test function automatically. Context manager patching applies only inside a with block, giving more control over the patch duration.

intermediate

Why is it important to patch the object where it is used rather than where it is defined?

You patch where the object is looked up in your code, not where it was created. This ensures your patch replaces the exact reference your code uses during the test.

What does unittest.mock.patch do in a test?

A Compiles the code faster

B Deletes the object from the code

C Replaces a real object with a mock temporarily

D Runs the real function multiple times

patch swaps the real object with a mock during the test to control behavior.

How do you apply patch using a decorator in pytest?

A Inside the test function with <code>with patch()</code>

B @patch('module.object') above the test function

C By importing patch but not using it

D By calling patch after the test runs

Decorator patching uses @patch('module.object') before the test function.

Where should you patch an object to ensure it works correctly?

A Where the object is used in your code

B Where the object is originally defined

C Anywhere in the test file

D In a separate configuration file

Patching must happen where your code looks up the object, not where it was created.

What is a benefit of using patch as a context manager?

A Limits patching to a specific block of code

B Automatically patches all tests

C Makes the patch permanent

D Runs tests faster

Context manager patching applies only inside the with block, giving precise control.

What can you do with the mock object passed by patch decorator?

A Change the source code of the function

B Delete the original function permanently

C Run the original function faster

D Set return values and check how it was called

The mock lets you control return values and verify calls during tests.

Explain how unittest.mock.patch helps isolate code during testing.

Think about how you might replace a noisy part in a machine to test one part clearly.

Describe the difference between patching with a decorator and patching with a context manager.

Consider when you want the patch to start and stop.

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