Styjun

I am testing a relatively simple piece of code that uses two relatively complex object that requires disk access. The complex objects are from a library. I would like to mock these library objects and assert that some of their member functions were called with particular values, depending on the input.

The calls that I use rely on some internal state of the library objects. I recognise that I can mock every function call on the complex objects individually, and set a return_value before each. This seems much messier and painful than it needs to be, though.

It seems like you should be able to provide a custom class and wrap it with a Mock object to track all the calls to member functions. I've spent a few hours trying to make sense of the official documentation, and the closest I've found is the wraps argument. Unfortunately, this doesn't seem to replace all the members with mocks that wrap, instead, it just uses the member variables of the mock object, only tracking the calls to __init__.

e.g. in module_a.py:

# Assuming some library class that acts something like this:
class A:
 def __init__(self, filename):
 self.filename = filename
 def get(self):
 # ... Some complicated code, involving state and disk access ...
 return something

def some_fnc(filename):
 a = A(filename)
 a.get()
 a.get()
 a.get()
 a.get()

in test_module_a.py:

import unittest
import unittest.mock

import module_a

class MockA:
 def __init__(self, *args, **kwargs):
 self.i = 0
 pass
 def get(self):
 # Fake version that returns dummy values,
 # but more complicated than simply returning some value.
 # Easy to reason about. If this gets complicated then you have problems.
 print(self.i, 'is gotten')
 if self.i > 3:
 return 5
 self.i += 1
 return 1

class SomeFncTestCase(unittest.TestCase):
 @unittest.mock.patch('module_a.A', wraps=MockA)
 def test_it(self, m):
 module_a.some_fnc('in_file')
 m.assert_called_with('in_file')
 m.get.assert_called()

MockA.get is called, and the first assert passes, but the second assert fails.

Is there some functionality that I'm missing? Is it possible to do what I want? Is there any reason why what I'm suggesting is particularly bad?

You can use your patched Mock object to return an instance of MagicMock that wraps your mock class by setting that as the return value when the callee tries to instantiate module_a.A.

class SomeFncTestCase(unittest.TestCase):
 @unittest.mock.patch('module_a.A')
 def test_it(self, m):
 mock_a = MagicMock(wraps=MockA())
 m.return_value = mock_a

 module_a.some_fnc('in_file')

 m.assert_called_with('in_file')
 mock_a.get.assert_called()

There is a distinction between m the Mock that essentially mocks A.__call__, and mock_a, a mocked instantiation of the A class (which provides actual function return values by wrapping an instance of MockA).