Mock call assertions in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ assertion

intermediate

Identify the correct mock call assertion

Given a mock object mock_func called twice with arguments (1, 2) and (3, 4), which assertion correctly verifies these calls in order?

PyTest

from unittest.mock import Mock, call
mock_func = Mock()
mock_func(1, 2)
mock_func(3, 4)

A

mock_func.assert_called_once_with(1, 2)
mock_func.assert_called_once_with(3, 4)

B

mock_func.assert_called_with(1, 2)
mock_func.assert_called_with(3, 4)

C mock_func.assert_has_calls([call(1, 2), call(3, 4)], any_order=False)

D

mock_func.assert_any_call(1, 2)
mock_func.assert_any_call(3, 4)

💡 Hint

Use assert_has_calls with any_order=False to check call order.

assert_has_calls with any_order=False checks that the calls happened in the exact order given. assert_called_with only checks the last call. assert_called_once_with expects exactly one call, so it fails if called multiple times. assert_any_call checks calls but ignores order.

❓ Predict Output

intermediate

What is the output of this mock call count check?

What will be the value of mock_func.call_count after running this code?

PyTest

from unittest.mock import Mock
mock_func = Mock()
mock_func('a')
mock_func('b')
mock_func('c')
print(mock_func.call_count)

A Raises AttributeError

B 1

C 0

D 3

💡 Hint

Each call to the mock increments call_count by one.

The call_count attribute counts how many times the mock was called. Here, it is called three times, so the value is 3.

🔧 Debug

advanced

Find the error in this mock call assertion

Why does this assertion fail even though the mock was called with (5, 6)?

PyTest

from unittest.mock import Mock
mock_func = Mock()
mock_func(5, 6)
mock_func.assert_called_with(6, 5)

A The arguments order is wrong; assert_called_with expects exact order.

B The mock was never called, so assertion fails.

C assert_called_with requires keyword arguments, not positional.

D assert_called_with only checks the first argument, so it fails.

💡 Hint

Check the order of arguments in the assertion versus the call.

assert_called_with checks that the last call to the mock matches the arguments exactly in order and value. Here, the call was (5, 6) but the assertion checks (6, 5), so it fails.

❓ framework

advanced

Which pytest-mock assertion verifies a mock was never called?

Using pytest-mock, which assertion correctly checks that a mock function mock_func was never called?

A mock_func.assert_not_called()

B mock_func.assert_called_once()

C mock_func.assert_any_call()

D mock_func.assert_called()

💡 Hint

Look for the assertion that confirms zero calls.

assert_not_called() checks that the mock was never called. assert_called_once() expects exactly one call. assert_any_call() checks if called with specific args. assert_called() checks if called at least once.

🧠 Conceptual

expert

Understanding mock call argument matching

You have a mock called with keyword arguments mock_func(a=1, b=2). Which assertion will fail to verify this call correctly?

PyTest

from unittest.mock import Mock
mock_func = Mock()
mock_func(a=1, b=2)

A mock_func.assert_called_with(a=1, b=2)

B mock_func.assert_called_with(1, 2)

C mock_func.assert_called_with(b=2, a=1)

D mock_func.assert_any_call(a=1, b=2)

💡 Hint

Check how positional vs keyword arguments are matched in assertions.

When a mock is called with keyword arguments, assert_called_with must use the same keywords. Option B uses positional arguments which do not match the call, so it fails. Options A, C, and D correctly match keyword arguments regardless of order.