Why Mock call assertions in PyTest? - Purpose & Use Cases

The Big Idea

What if you could catch hidden bugs by watching how your code talks to others, without running the whole system?

The Scenario

Imagine you have a program that talks to a website to get data. You want to check if your program asks the website correctly every time. Doing this by running the real website each time is slow and tricky.

The Problem

Manually checking if your program called the website right means watching logs or printing messages. This is slow, easy to miss mistakes, and you can't test all cases quickly. It's like trying to catch a fast ball with your eyes closed.

The Solution

Mock call assertions let you pretend the website is there and watch exactly how your program talks to it. You can check if it called the right address, with the right data, and how many times. This makes testing fast, clear, and safe.

Before vs After

✗ Before

print('Did we call API?')
# Manually check output

✓ After

mock_api.assert_called_once_with(expected_url, data)

What It Enables

It lets you catch mistakes early by automatically checking how your code talks to other parts, without needing the real parts to be ready.

Real Life Example

When building a weather app, you can mock the weather service calls and assert your app asks for the right city's weather, without calling the real service every time you test.

Key Takeaways

Manual checks are slow and error-prone.

Mock call assertions watch interactions automatically.

This makes tests faster, clearer, and safer.

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