pytest-mock for enhanced mocking - Build an Automation Script

Mock a function call using pytest-mock and verify it was called with expected arguments

Preconditions (2)

Step 1: Use pytest-mock's 'mocker' fixture to mock 'fetch_data' function

Step 2: Set the mock to return a fixed dictionary {'id': 1, 'value': 'test'}

Step 3: Call the function under test that uses 'fetch_data'

Step 4: Verify that 'fetch_data' was called exactly once

Step 5: Verify that 'fetch_data' was called with no arguments

Step 6: Assert that the function under test returns the mocked data

✅ Expected Result: The test passes confirming the mock was called correctly and the function under test returns the mocked data

Automation Requirements - pytest with pytest-mock plugin

Assertions Needed:

'fetch_data' was called once

'fetch_data' was called with expected arguments

Function under test returns mocked data

Best Practices:

Use pytest fixtures for setup

Use mocker.patch to replace functions

Avoid hardcoding side effects inside the test

Keep tests isolated and independent

Automated Solution

PyTest

import pytest
from data_source import fetch_data

# Function under test that calls fetch_data

def process_data():
    data = fetch_data()
    # Imagine some processing here
    return data


def test_process_data_calls_fetch_data_once_and_returns_mocked_data(mocker):
    # Mock fetch_data to return fixed data
    mock_fetch = mocker.patch('data_source.fetch_data', return_value={'id': 1, 'value': 'test'})

    result = process_data()

    # Assert fetch_data was called once
    mock_fetch.assert_called_once()

    # Assert fetch_data was called with no arguments
    mock_fetch.assert_called_with()

    # Assert the function under test returns the mocked data
    assert result == {'id': 1, 'value': 'test'}

The test uses the mocker fixture from pytest-mock to replace the fetch_data function with a mock that returns a fixed dictionary.

We call the process_data function which internally calls fetch_data. The mock ensures no real API call happens.

Assertions check that fetch_data was called exactly once and with no arguments, matching the manual test case steps.

Finally, we assert that process_data returns the mocked data, confirming the mock worked as expected.

Common Mistakes - 3 Pitfalls

{'mistake': "Not using the 'mocker' fixture and trying to patch directly with 'unittest.mock.patch'", 'why_bad': "This can cause issues with pytest's test discovery and fixture management.", 'correct_approach': "Always use the 'mocker' fixture provided by pytest-mock for patching in pytest tests."}

{'mistake': 'Mocking the wrong import path of the function', 'why_bad': 'Mocking the function where it is defined instead of where it is used will not replace the call in the function under test.', 'correct_approach': "Patch the function at the import location used by the function under test (e.g., 'data_source.fetch_data')."}

{'mistake': 'Not asserting the mock call count or arguments', 'why_bad': 'Without these assertions, the test might pass even if the function was not called or called incorrectly.', 'correct_approach': "Use 'assert_called_once()' and 'assert_called_with()' to verify correct usage."}

Bonus Challenge

Now add data-driven testing with 3 different mocked return values for 'fetch_data' and verify 'process_data' returns each correctly

Show Hint

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