Mock call assertions in PyTest

Introduction

Mock call assertions help check if a fake function was called correctly during a test. This makes sure your code talks to other parts as expected.

When you want to test a function that calls another function without running the real one.

When you want to check if a function was called with the right inputs.

When you want to confirm how many times a function was called.

When you want to test error handling by simulating failures in called functions.

Syntax

PyTest

mock_function.assert_called()
mock_function.assert_called_once()
mock_function.assert_called_with(arg1, arg2)
mock_function.assert_called_once_with(arg1, arg2)
mock_function.assert_any_call(arg1)
mock_function.call_count

Use assert_called() to check if the mock was called at least once.

Use assert_called_with() to check the last call's arguments.

Examples

Checks if mock_func was called at least once.

PyTest

mock_func.assert_called()

Checks if mock_func was called exactly once with arguments 5 and 'test'.

PyTest

mock_func.assert_called_once_with(5, 'test')

Checks if mock_func was called at least once with argument 'hello'.

PyTest

mock_func.assert_any_call('hello')

Prints how many times mock_func was called.

PyTest

print(mock_func.call_count)

Sample Program

This test replaces the real greet function with a mock. It calls welcome_user with the mock and checks if the mock was called once with 'Alice'. It also prints how many times the mock was called.

PyTest

from unittest.mock import Mock

def greet(name):
    print(f"Hello, {name}!")

def welcome_user(greet_func, user_name):
    greet_func(user_name)

mock_greet = Mock()
welcome_user(mock_greet, 'Alice')

mock_greet.assert_called_once_with('Alice')
print(f"Call count: {mock_greet.call_count}")

Important Notes

Mock call assertions help test interactions without running real code.

Always check the call arguments to catch mistakes early.

Use call_count to verify how many times a mock was used.

Summary

Mock call assertions check if and how mocks were called.

They help test code interactions safely and clearly.

Common assertions include assert_called_with and assert_called_once_with.

Practice

1. What does the assert_called_with method check in pytest mocks?

easy

A. It checks if the mock was called exactly twice.

B. It checks if the mock was never called.

C. It checks if the mock returned a specific value.

D. It checks if the last call to the mock was with specific arguments.

Solution

1. Step 1: Understand the purpose of assert_called_with

   This method verifies that the last call to the mock was with the exact arguments provided.

2. Step 2: Differentiate from other assertions

   Unlike assert_called_once_with, it does not require the call to be exactly once, just that the last call had those arguments.

3. Final Answer:

   It checks if the last call to the mock was with specific arguments. -> Option D

4. Quick Check:

   assert_called_with = last call with args [OK]

Hint: assert_called_with checks the last call's args [OK]

Common Mistakes:

• Confusing assert_called_with with assert_called_once_with
• Thinking it checks call count exactly
• Assuming it checks return values

2. Which of the following is the correct syntax to assert a mock was called exactly once with arguments 5 and 'test'?

easy

A. mock.assert_called_once_with(5, 'test')

B. mock.assert_called_with(5, 'test')

C. mock.assert_called_once(5, 'test')

D. mock.assert_called(5, 'test')

Solution

1. Step 1: Identify the correct assertion method

   The method to check a single call with specific arguments is assert_called_once_with.

2. Step 2: Verify syntax correctness

   The syntax requires calling this method on the mock object with the expected arguments inside parentheses.

3. Final Answer:

   mock.assert_called_once_with(5, 'test') -> Option A

4. Quick Check:

   assert_called_once_with = exactly one call with args [OK]

Hint: Use assert_called_once_with(args) for exact single call [OK]

Common Mistakes:

• Using assert_called_with instead of assert_called_once_with
• Calling assert_called_once without _with
• Passing arguments to assert_called which takes no args

3. Given the code:

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

What will happen when the last line runs?

medium

A. The assertion passes because the last call was with (3, 4).

B. The assertion fails because the first call was with (1, 2).

C. The assertion fails because assert_called_with checks all calls.

D. The code raises a TypeError.

Solution

1. Step 1: Understand assert_called_with behavior

   This assertion checks that the last call to the mock was with the specified arguments.

2. Step 2: Analyze the calls made

   The mock was called twice: first with (1, 2), then with (3, 4). The last call matches the assertion arguments.

3. Final Answer:

   The assertion passes because the last call was with (3, 4). -> Option A

4. Quick Check:

   assert_called_with checks last call args [OK]

Hint: assert_called_with checks last call args by default [OK]

Common Mistakes:

• Thinking assert_called_with checks all calls
• Confusing call order importance
• Expecting failure due to earlier calls

4. Identify the error in this test code snippet:

from unittest.mock import Mock
mock = Mock()
mock(10)
mock.assert_called_once(10)

medium

A. assert_called_once should be called before the mock call.

B. Mock object was never called, so assertion fails.

C. assert_called_once does not accept arguments; use assert_called_once_with instead.

D. The mock call should use keyword arguments.

Solution

1. Step 1: Check method usage

   assert_called_once checks the call count but does not accept arguments to check call parameters.

2. Step 2: Correct method for argument check

   To check the call arguments and count, assert_called_once_with should be used instead.

3. Final Answer:

   assert_called_once does not accept arguments; use assert_called_once_with instead. -> Option C

4. Quick Check:

   assert_called_once no args; assert_called_once_with with args [OK]

Hint: Use assert_called_once_with(args) to check call count and args [OK]

Common Mistakes:

• Passing arguments to assert_called_once
• Confusing call order
• Assuming assert_called_once checks arguments

5. You have a mock that was called three times with arguments:
(1, 'a'), (2, 'b'), (3, 'c')
Which assertion correctly verifies all calls in order?

hard

A. mock.assert_called()

B. mock.assert_has_calls([call(1, 'a'), call(2, 'b'), call(3, 'c')], any_order=False)

C. mock.assert_called_once_with(3, 'c')

D. mock.assert_called_with(1, 'a') and mock.assert_called_with(3, 'c')

Solution

1. Step 1: Understand verifying multiple calls

   To check multiple calls in order, assert_has_calls with a list of expected calls and any_order=False is used.

2. Step 2: Analyze other options

   mock.assert_called() only checks if it was called at least once without verifying arguments or order. Chaining mock.assert_called_with(1, 'a') and mock.assert_called_with(3, 'c') checks some arguments but not all calls, order, or completeness. mock.assert_called_once_with(3, 'c') checks only that there was exactly one call with those arguments.

3. Final Answer:

   mock.assert_has_calls([call(1, 'a'), call(2, 'b'), call(3, 'c')], any_order=False) -> Option B

4. Quick Check:

   assert_has_calls with any_order=False checks ordered calls [OK]

Hint: Use assert_has_calls with any_order=False for ordered multiple calls [OK]

Common Mistakes:

• Using assert_called_with for multiple calls
• Ignoring call order
• Not importing call from unittest.mock