pytest-mock for enhanced mocking - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a pytest-mock patch usage

What is the output of this pytest test when run with pytest-mock?

PyTest

import requests

def fetch_data():
    response = requests.get('https://api.example.com/data')
    return response.status_code

def test_fetch_data(mocker):
    mock_get = mocker.patch('requests.get')
    mock_get.return_value.status_code = 404
    result = fetch_data()
    print(result)

A 404

B 200

C AttributeError

D None

💡 Hint

The mock replaces requests.get and sets the status_code attribute.

The mocker.patch replaces requests.get with a mock object. Setting return_value.status_code to 404 means fetch_data returns 404.

❓ assertion

intermediate

Correct assertion to verify mock call count

Which assertion correctly verifies that the mocked function was called exactly twice?

PyTest

def test_calls(mocker):
    mock_func = mocker.Mock()
    mock_func()
    mock_func()
    # Which assertion below is correct?

A assert mock_func.call_count() == 2

B assert mock_func.called == 2

C assert mock_func.call_args == 2

D assert mock_func.call_count == 2

💡 Hint

Check the attribute that counts calls on a mock object.

The call_count attribute holds the number of times the mock was called. It is an integer, so assert mock_func.call_count == 2 is correct.

🔧 Debug

advanced

Identify the error in mock patching

Why does this test raise an AttributeError when run?

PyTest

import mymodule

def test_func(mocker):
    mocker.patch('mymodule.nonexistent_function')
    mymodule.nonexistent_function()

A AttributeError because 'nonexistent_function' does not exist in mymodule

B SyntaxError due to missing colon

C TypeError because patch requires a callable

D No error, test passes

💡 Hint

Check if the target to patch exists in the module.

Patching a non-existing attribute causes AttributeError because the patch target must exist.

❓ framework

advanced

pytest-mock fixture usage in test functions

Which statement about the pytest-mock fixture 'mocker' is true?

A The 'mocker' fixture automatically patches all functions without explicit use

B The 'mocker' fixture must be included as a test function argument to use it

C The 'mocker' fixture can only patch functions in the standard library

D The 'mocker' fixture requires manual import in each test file

💡 Hint

Think about how pytest fixtures are injected.

pytest fixtures like 'mocker' are injected by including them as parameters in test functions.

🧠 Conceptual

expert

Best practice for mocking external API calls with pytest-mock

Which approach best ensures tests using pytest-mock remain reliable and isolated when mocking external API calls?

A Patch the external API URL string to a local server address

B Avoid mocking and always make real HTTP requests during tests for accuracy

C Patch the exact function that makes the HTTP request in the module under test, not the external library directly

D Patch the external library's HTTP request function globally in conftest.py for all tests

💡 Hint

Consider test isolation and minimizing side effects.

Patching the function in the module under test avoids affecting other tests and keeps mocks focused and reliable.

Practice

1. What is the main purpose of using pytest-mock in tests?

easy

A. To replace parts of code with mock objects during testing

B. To speed up test execution by skipping tests

C. To automatically generate test data

D. To format test output for better readability

Solution

1. Step 1: Understand pytest-mock functionality

   pytest-mock is a plugin that helps replace parts of your code with mock objects during tests.

2. Step 2: Identify the main use case

   This replacement allows you to control and verify behavior without running actual code parts.

3. Final Answer:

   To replace parts of code with mock objects during testing -> Option A

4. Quick Check:

   pytest-mock = mocking code parts [OK]

Hint: Remember pytest-mock is for replacing code parts with mocks [OK]

Common Mistakes:

• Confusing mocking with test skipping
• Thinking pytest-mock generates test data
• Assuming pytest-mock formats output

2. Which of the following is the correct way to mock a function get_data in module my_module using pytest-mock?

easy

A. mocker.patch('my_module.get_data')

B. mocker.patch(get_data)

C. mocker.mock('my_module.get_data')

D. mocker.replace('my_module.get_data')

Solution

1. Step 1: Recall pytest-mock patch syntax

   The correct syntax uses a string with the full path: mocker.patch('module.function').

2. Step 2: Identify correct option

   mocker.patch('my_module.get_data') uses the correct string path format. Options A, B, and D use incorrect methods or arguments.

3. Final Answer:

   mocker.patch('my_module.get_data') -> Option A

4. Quick Check:

   Use string path in mocker.patch() [OK]

Hint: Use string 'module.function' in mocker.patch() [OK]

Common Mistakes:

• Passing function object instead of string path
• Using mocker.mock instead of patch
• Using mocker.replace which doesn't exist

3. Given the code below, what will be the output of the test?

def fetch_data():
    return 'real data'

def test_fetch(mocker):
    mocker.patch('__main__.fetch_data', return_value='mocked data')
    result = fetch_data()
    assert result == 'mocked data'
    print(result)

medium

A. real data

B. Test fails with AssertionError

C. mocked data

D. None

Solution

1. Step 1: Understand patch effect on fetch_data

   The patch replaces fetch_data to always return 'mocked data'.

2. Step 2: Analyze test assertions and print

   The assertion checks for 'mocked data' and passes. The print outputs 'mocked data'.

3. Final Answer:

   mocked data -> Option C

4. Quick Check:

   Patched function returns mocked data [OK]

Hint: Patched functions return mocked values, not real ones [OK]

Common Mistakes:

• Expecting original function output
• Confusing patch target string
• Assuming patch does not affect print

4. Identify the error in the following test code using pytest-mock:

def test_api_call(mocker):
    mocker.patch('api.call', return_value=200)
    response = api.call()
    assert response == 200

medium

A. The return_value should be a string, not an integer

B. assert statement syntax is wrong

C. mocker.patch should be called after the function call

D. The patch target string 'api.call' is incorrect or incomplete

Solution

1. Step 1: Check patch target correctness

   The patch target 'api.call' must be the full import path. If 'api' is not imported or incomplete, patch fails.

2. Step 2: Validate other parts

   Return value as integer is valid, patch before call is correct, and assert syntax is fine.

3. Final Answer:

   The patch target string 'api.call' is incorrect or incomplete -> Option D

4. Quick Check:

   Patch target must be full import path [OK]

Hint: Always use full import path in patch target string [OK]

Common Mistakes:

• Using partial or wrong patch target strings
• Thinking return_value must be string
• Calling patch after function call

5. You want to test a function process_data() that calls fetch_from_api(). Using pytest-mock, how do you mock fetch_from_api to return different values on consecutive calls: first 'data1', then 'data2'?

hard

A. mocker.patch('module.fetch_from_api', return_value=['data1', 'data2'])

B. mocker.patch('module.fetch_from_api', side_effect=['data1', 'data2'])

C. mocker.patch('module.fetch_from_api', side_effect='data1', 'data2')

D. mocker.patch('module.fetch_from_api', return_values=['data1', 'data2'])

Solution

1. Step 1: Understand side_effect usage

   To return different values on consecutive calls, use side_effect with a list of return values.

2. Step 2: Identify correct syntax

   mocker.patch('module.fetch_from_api', side_effect=['data1', 'data2']) correctly uses side_effect=['data1', 'data2']. Options B, C, and D use incorrect parameters or syntax.

3. Final Answer:

   mocker.patch('module.fetch_from_api', side_effect=['data1', 'data2']) -> Option B

4. Quick Check:

   Use side_effect list for multiple return values [OK]

Hint: Use side_effect list to mock multiple return values [OK]

Common Mistakes:

• Using return_value with a list instead of side_effect
• Incorrect side_effect syntax with multiple arguments
• Using non-existent return_values parameter