Mock and MagicMock in PyTest - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of MagicMock call count

What is the output of the following pytest code snippet?

PyTest

from unittest.mock import MagicMock

def test_func():
    mock_obj = MagicMock()
    mock_obj.method()
    mock_obj.method()
    return mock_obj.method.call_count

result = test_func()
print(result)

A 2

B 1

C 0

D Raises AttributeError

💡 Hint

MagicMock tracks how many times a mocked method is called.

The MagicMock object tracks calls to its methods. Calling mock_obj.method() twice increments call_count to 2.

❓ assertion

intermediate

Correct assertion for mock call arguments

Which assertion correctly verifies that a MagicMock method was called with arguments (5, 10)?

PyTest

from unittest.mock import MagicMock
mock_obj = MagicMock()
mock_obj.method(5, 10)

A assert mock_obj.method.assert_called_with(5, 10)

B assert mock_obj.method.called_with(5, 10)

C assert mock_obj.method.call_args == (5, 10)

D assert mock_obj.method.call_args_list == [(5, 10)]

💡 Hint

Use the built-in MagicMock method to check call arguments.

assert_called_with is the correct method to assert the last call had specific arguments. called_with does not exist. call_args is a tuple with args and kwargs, so direct comparison to (5, 10) fails. call_args_list contains call objects, not tuples.

🔧 Debug

advanced

Identify the error in mocking a class method

What error will this pytest code raise when run?

PyTest

from unittest.mock import MagicMock

class MyClass:
    def greet(self):
        return 'Hello'

mock_instance = MagicMock(spec=MyClass)
mock_instance.greet.return_value = 'Hi'
print(mock_instance.greet())
print(mock_instance.nonexistent())

A NameError: name 'nonexistent' is not defined

B TypeError: 'MagicMock' object is not callable

C No error, prints 'Hi' and then another MagicMock object

D AttributeError: 'MagicMock' object has no attribute 'nonexistent'

💡 Hint

Spec limits attributes to those on the original class.

Using spec=MyClass restricts MagicMock to only attributes of MyClass. Calling mock_instance.nonexistent() raises AttributeError because 'nonexistent' is not defined in MyClass.

🧠 Conceptual

advanced

Purpose of using spec in MagicMock

Why is it useful to pass the 'spec' argument when creating a MagicMock object?

A It makes the mock object behave exactly like the original object including internal state

B It automatically records all calls and arguments without needing extra setup

C It restricts the mock to only allow attributes and methods that exist on the original object

D It converts the mock into a real instance of the original class

💡 Hint

Think about how spec helps catch mistakes in tests.

Passing spec limits the mock to only have attributes and methods of the original object, preventing typos and incorrect usage in tests.

❓ framework

expert

Mock patching order and effect in pytest

Given the following pytest test with patch decorators, what will be the output printed?

PyTest

from unittest.mock import patch

def get_data():
    return 'real data'

def process():
    return get_data()

@patch('__main__.get_data', return_value='mocked data 1')
@patch('__main__.get_data', return_value='mocked data 2')
def test_process(mock2, mock1):
    print(process())

test_process()

A Raises RuntimeError due to patch conflict

B mocked data 1

C real data

D mocked data 2

💡 Hint

Remember the order of patch decorators and which mock is applied last.

The outer patch decorator is applied last and overrides the inner one. The first argument mock2 corresponds to the inner patch, and mock1 to the outer patch, which returns 'mocked data 1'. So process() returns 'mocked data 1'.

Practice

1. What is the main difference between Mock and MagicMock in pytest?

easy

A. MagicMock supports special methods like __len__ and __getitem__, Mock does not.

B. Mock can only mock functions, while MagicMock can mock classes.

C. Mock is used for asynchronous code, MagicMock is not.

D. MagicMock is slower and less flexible than Mock.

Solution

1. Step 1: Understand the purpose of Mock and MagicMock

   Mock creates fake objects for testing, but does not automatically support Python's special methods like __len__ or __getitem__.

2. Step 2: Recognize MagicMock's special feature

   MagicMock extends Mock by including default implementations for many special methods, making it useful when those methods are called during tests.

3. Final Answer:

   MagicMock supports special methods like __len__ and __getitem__, Mock does not. -> Option A

4. Quick Check:

   Special methods = MagicMock [OK]

Hint: MagicMock handles special methods automatically [OK]

Common Mistakes:

• Thinking Mock supports special methods by default
• Confusing MagicMock as only for classes
• Believing Mock is for async only

2. Which of the following is the correct way to create a MagicMock object in pytest?

easy

A. mock = MagicMock[]

B. mock = MagicMock()

C. mock = MagicMock

D. mock = MagicMock{}

Solution

1. Step 1: Recall the syntax for creating instances in Python

   To create an instance of a class, you call it with parentheses, e.g., MagicMock().

2. Step 2: Identify the correct syntax for MagicMock

   MagicMock is a class, so MagicMock() creates a new mock object. The other options use invalid syntax for instantiation.

3. Final Answer:

   mock = MagicMock() -> Option B

4. Quick Check:

   Instance creation uses parentheses () [OK]

Hint: Use parentheses () to create MagicMock instances [OK]

Common Mistakes:

• Forgetting parentheses when creating mock objects
• Using square or curly brackets instead of parentheses
• Assigning class without instantiation

3. What will be the output of this pytest code snippet?

from unittest.mock import MagicMock
mock = MagicMock()
mock.__len__.return_value = 5
print(len(mock))

medium

A. 0

B. TypeError

C. 5

D. AttributeError

Solution

1. Step 1: Understand MagicMock and special methods

   Setting mock.__len__.return_value = 5 tells the mock to return 5 when len() is called on it, because len() calls the __len__ method.

2. Step 2: Predict the output of print(len(mock))

   Since __len__ is mocked to return 5, len(mock) will print 5.

3. Final Answer:

   5 -> Option C

4. Quick Check:

   len(mock) returns mocked __len__ value [OK]

Hint: Set __len__.return_value to mock len() calls [OK]

Common Mistakes:

• Expecting default length 0 instead of mocked value
• Confusing len(mock) with attribute access
• Thinking TypeError occurs without __len__

4. Identify the error in this pytest mocking code:

from unittest.mock import Mock
mock = Mock()
mock.__getitem__.return_value = 'value'
print(mock[0])

medium

A. Mock does not support special methods like __getitem__ by default.

B. The syntax for setting return_value is incorrect.

C. You cannot use indexing on mock objects.

D. Missing import for MagicMock.

Solution

1. Step 1: Check support for special methods in Mock

   Mock does not implement special methods like __getitem__ automatically, so setting mock.__getitem__.return_value has no effect on indexing.

2. Step 2: Understand why the code fails

   Using mock[0] calls __getitem__, but since Mock does not handle it, this raises a TypeError. To mock indexing, use MagicMock.

3. Final Answer:

   Mock does not support special methods like __getitem__ by default. -> Option A

4. Quick Check:

   Special methods need MagicMock [OK]

Hint: Use MagicMock for special methods like indexing [OK]

Common Mistakes:

• Assuming Mock supports all special methods
• Confusing syntax errors with capability errors
• Not importing MagicMock when needed

5. You want to test a function that calls obj.__str__() internally. Which mock object and setup will correctly simulate str(obj) returning 'mocked string'?

hard

A. Use mock = Mock() and set mock.str = 'mocked string'

B. Use mock = Mock() and set mock.__str__ = lambda: 'mocked string'

C. Use mock = MagicMock() and set mock.str.return_value = 'mocked string'

D. Use mock = MagicMock() and set mock.__str__.return_value = 'mocked string'

Solution

1. Step 1: Identify the need to mock __str__ special method

   The str(obj) call internally uses the __str__ method, which is a special method.

2. Step 2: Choose the correct mock and setup

   MagicMock supports special methods like __str__. Setting mock.__str__.return_value = 'mocked string' makes str(mock) return 'mocked string'.

3. Step 3: Eliminate incorrect options

   Use mock = Mock() and set mock.__str__ = lambda: 'mocked string' uses Mock which does not support special methods by default. Options C and D use incorrect attribute names or types.

4. Final Answer:

   Use mock = MagicMock() and set mock.__str__.return_value = 'mocked string' -> Option D

5. Quick Check:

   Mock special methods with MagicMock and return_value [OK]

Hint: Set __str__.return_value on MagicMock for str() calls [OK]

Common Mistakes:

• Using Mock instead of MagicMock for special methods
• Setting wrong attribute names like str instead of __str__
• Assigning string directly instead of return_value