unittest.mock.patch in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to patch the 'requests.get' method in the test.

PyTest

from unittest.mock import patch

@patch('[1]')
def test_fetch_data(mock_get):
    mock_get.return_value.status_code = 200
    assert mock_get.return_value.status_code == 200

Drag options to blanks, or click blank then click option'

Arequests.get

Brequests.post

Cos.path.exists

Djson.load

Attempts:

3 left

💡 Hint

Common Mistakes

Patching the wrong method like 'requests.post'.

Forgetting to patch the method as a string.

The @patch decorator replaces requests.get with a mock object during the test.

2fill in blank

medium

Complete the code to patch 'open' function in the 'builtins' module for the test.

PyTest

from unittest.mock import patch

@patch('[1]')
def test_file_read(mock_open):
    mock_open.return_value.read.return_value = 'data'
    with open('file.txt') as f:
        content = f.read()
    assert content == 'data'

Drag options to blanks, or click blank then click option'

Aio.open

Bos.open

Cbuiltins.open

Dopen.file

Attempts:

3 left

💡 Hint

Common Mistakes

Patching 'os.open' instead of 'builtins.open'.

Using incorrect module names.

To mock the built-in open function, patch builtins.open.

3fill in blank

hard

Fix the error in patching the 'datetime.datetime.now' method correctly.

PyTest

from unittest.mock import patch
import datetime

@patch('[1]')
def test_time(mock_now):
    mock_now.return_value = datetime.datetime(2020, 1, 1)
    assert datetime.datetime.now() == datetime.datetime(2020, 1, 1)

Drag options to blanks, or click blank then click option'

Adatetime.datetime

Bdatetime.datetime.now

Cdatetime.now

Ddatetime.now.now

Attempts:

3 left

💡 Hint

Common Mistakes

Patching 'datetime.now' which does not exist.

Patching the class instead of the method.

You must patch the full path to the method: datetime.datetime.now.

4fill in blank

hard

Fill both blanks to patch 'module.Class.method' and set the mock return value.

PyTest

from unittest.mock import patch

@patch('[1]')
def test_method(mock_method):
    mock_method.return_value = [2]
    result = mock_method()
    assert result == 42

Drag options to blanks, or click blank then click option'

Amodule.Class.method

B42

C100

Dmodule.method

Attempts:

3 left

💡 Hint

Common Mistakes

Patching the wrong method path.

Setting the wrong return value.

Patch the full method path and set the return value to 42 to match the assertion.

5fill in blank

hard

Fill all three blanks to patch 'package.module.func', set return value, and assert call count.

PyTest

from unittest.mock import patch

@patch('[1]')
def test_func(mock_func):
    mock_func.return_value = [2]
    mock_func()
    mock_func()
    assert mock_func.call_count == [3]

Drag options to blanks, or click blank then click option'

Apackage.module.func

BTrue

C2

DFalse

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrect patch path.

Wrong return value type.

Wrong call count assertion.

Patch the correct function, set return value to True, and assert it was called twice.

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