unittest.mock.patch in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of patching a function with unittest.mock.patch

What is the output of this pytest test when the requests.get method is patched to return a mock with status_code=200?

PyTest

import requests
from unittest.mock import patch

def fetch_status():
    response = requests.get('http://example.com')
    return response.status_code

def test_fetch_status():
    with patch('requests.get') as mock_get:
        mock_get.return_value.status_code = 200
        result = fetch_status()
        assert result == 200
        print(result)

A AttributeError

B 404

C None

D 200

💡 Hint

The patch replaces the requests.get call with a mock object whose status_code attribute is set to 200.

The patch replaces requests.get with a mock object. Setting mock_get.return_value.status_code = 200 means the mocked response has status_code 200. So, fetch_status() returns 200.

❓ assertion

intermediate

Correct assertion to verify a patched method call

Which assertion correctly verifies that the patched open method was called exactly once with the argument 'file.txt'?

PyTest

from unittest.mock import patch

def test_file_open():
    with patch('builtins.open') as mock_open:
        open('file.txt')
        # Which assertion is correct here?

A mock_open.assert_called_once_with('file.txt')

B mock_open.assert_called_with('file.txt', 'r')

C mock_open.assert_called_once('file.txt')

D mock_open.assert_called('file.txt')

💡 Hint

Use the method that checks the call count and arguments exactly once.

The method assert_called_once_with checks that the mock was called exactly once with the specified arguments. Other options either do not check call count or use incorrect method names.

🔧 Debug

advanced

Identify the error in patching a method

What error will occur when running this test code that patches module.Class.method incorrectly?

PyTest

from unittest.mock import patch
import module

def test_method():
    with patch('Class.method') as mock_method:
        module.Class().method()
        mock_method.assert_called_once()

A RuntimeError

B ModuleNotFoundError

C AttributeError

D No error, test passes

💡 Hint

The patch target string must include the full import path.

The patch target 'Class.method' is incomplete and does not specify the module. This causes an AttributeError because patch cannot find 'Class' at the top level.

🧠 Conceptual

advanced

Effect of patching with autospec=True

What is the main effect of using autospec=True in unittest.mock.patch?

A The mock will automatically reset after each test

B The mock will only allow attributes and methods that exist on the original object

C The mock will record all calls without any restrictions

D The mock will patch all instances of the object globally

💡 Hint

Think about how autospec helps catch incorrect method calls.

Using autospec=True makes the mock imitate the original object’s interface, preventing calls to methods or attributes that do not exist, helping catch errors early.

❓ framework

expert

Correct use of patch as a decorator in pytest

Which pytest test function correctly patches os.remove using unittest.mock.patch as a decorator and verifies it was called once?

PyTest

import os
from unittest.mock import patch

def delete_file(filename):
    os.remove(filename)

# Choose the correct test function:

A

@patch('os.remove')
def test_delete_file(mock_remove):
    delete_file('temp.txt')
    mock_remove.assert_called_once_with('temp.txt')

B

@patch('os.remove')
def test_delete_file():
    delete_file('temp.txt')
    os.remove.assert_called_once_with('temp.txt')

C

def test_delete_file():
    with patch('os.remove') as mock_remove:
        delete_file('temp.txt')
    mock_remove.assert_called_once_with('temp.txt')

D

@patch('os.remove')
def test_delete_file(mock_remove):
    delete_file('temp.txt')
    mock_remove.assert_called_once()

💡 Hint

Remember the patched function is passed as an argument to the test when using the decorator.

Option A correctly uses the patch decorator and receives the mock as an argument. It asserts the mock was called once with the correct argument. Option A misses the mock argument. Option A uses context manager, not decorator. Option A asserts call count but not arguments.