Mock call assertions in PyTest - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to assert the mock was called exactly once.

PyTest

mock_function.[1]()

Drag options to blanks, or click blank then click option'

Aassert_called

Bassert_called_once

Cassert_called_once_with

Dassert_not_called

Attempts:

3 left

💡 Hint

Common Mistakes

Using assert_called_once_with without specifying arguments

Using assert_called which only checks if called at least once

The assert_called_once() method checks that the mock was called exactly one time.

2fill in blank

medium

Complete the code to assert the mock was called with specific arguments.

PyTest

mock_function.[1](42, 'test')

Drag options to blanks, or click blank then click option'

Aassert_not_called

Bassert_called

Cassert_called_with

Dassert_called_once_with

Attempts:

3 left

💡 Hint

Common Mistakes

Using assert_called_with which allows multiple calls

Using assert_called which ignores arguments

The assert_called_once_with() method asserts the mock was called exactly once with the given arguments.

3fill in blank

hard

Fix the error in the assertion to check the mock was never called.

PyTest

mock_function.[1]()

Drag options to blanks, or click blank then click option'

Aassert_not_called

Bassert_called

Cassert_called_once

Dassert_called_once_with

Attempts:

3 left

💡 Hint

Common Mistakes

Using assert_called which expects at least one call

Using assert_called_once which expects exactly one call

The assert_not_called() method asserts the mock was never called.

4fill in blank

hard

Fill both blanks to assert the mock was called twice and with specific arguments on the second call.

PyTest

assert mock_function.call_count == [1]
mock_function.[2](100, key='value')

Drag options to blanks, or click blank then click option'

A2

Bassert_called_once_with

Cassert_any_call

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using assert_called_once_with which only checks one call

Checking call_count equals 3 instead of 2

First, we check the call count equals 2. Then, assert_any_call() checks if the mock was called with the given arguments at least once (e.g., the second call).

5fill in blank

hard

Fill all three blanks to assert the mock was called with specific arguments and check the first call's arguments.

PyTest

mock_function.[1](5, 10)
assert mock_function.call_args == [2]
assert mock_function.call_args_list[0] == [3]

Drag options to blanks, or click blank then click option'

Aassert_called_with

B(5, 10)

C((5, 10), {})

Dassert_called_once_with

Attempts:

3 left

💡 Hint

Common Mistakes

Using assert_called_with which allows multiple calls

Using (5, 10) instead of ((5, 10), {}) for the Call object

assert_called_once_with asserts the mock was called once with the arguments (5, 10). call_args holds the last call's Call ((5, 10), {}). call_args_list[0] holds the first call's Call ((5, 10), {}).

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