Python Unit Test Mocking

I think you are not showing us the code that triggers the error because there is nothing wrong with your strategy. Using some imagination to mimic code we don't have I can write this and it runs with no problem:

import unittest
from unittest.mock import MagicMock
class CarList():
 def get_by_registration(self, registration):
 pass
class Dal:
 def __init__(self):
 self.cars = CarList() 
 pass
class CarController:
 def __init__(self):
 self.dal = Dal()
 def change_registration(self):
 registration = None
 car = self.dal.cars.get_by_registration(registration)
 return car 
class CarTestCase(unittest.TestCase):
 def setUp(self):
 self.car_controller = CarController()
 def test_change_registrations(self):
 self.car_controller.dal.cars.get_by_registration =\
 MagicMock(return_value=3)
 result = self.car_controller.change_registration()
 self.assertEqual(result, 3)
unittest.main()

Here my example:

# test_tool_file.py
import unittest
from unittest.mock import patch, Mock, call
import test_tools_file
class MyObject():
 def __init__(self, data):
 self.data = data
 def get_data(self):
 return self.data
 def count(self):
 return len(self.get_data())
class TestFile(unittest.TestCase):
 """ Cas de tests.
 """
 @patch("test_tools_file.MyObject.get_data")
 def test_1(self, mock_get):
 """ test_1
 """
 mock_get.return_value = [1,2,3,4,5,6]
 obj = MyObject(["12", "13"])
 result = obj.count()
 self.assertEqual(result, 6)

Personal opinion: I would suggest you to start simple. Use anything 'magic' once you understand what it provides you over the non-magic way. Using a non-magic solution tends to be easier to understand.

I think you have multiple simple solutions at hand. For what you tried to achieve, instead of:

self.car_controller.dal.cars.get_by_registration = MagicMock(return_value=3)

You could try:

self.car_controller.dal.cars.get_by_registration = lambda: 3

But you mentioned you want to replace all methods. In fact I would consider a 'simple' dependency injection. If you find it difficult to test, it might be a sign that the another design would be better (that's the idea of TDD - Test Driven Design). A simple dependency injection is one where you for example just pass dal to the constructor of CarController.

Here is a complete example with some variations of the test:

from unittest import TestCase
from unittest.mock import Mock
class SomeDal(object):
 def get_something(self):
 return 'something'
class SomeController(object):
 def __init__(self, dal):
 self.dal = dal
 def upper_something(self):
 return self.dal.get_something().upper()
class TestSomeController(TestCase):
 def test_using_simple_patch(self):
 controller = SomeController(SomeDal())
 controller.dal.get_something = lambda: 'anything'
 assert controller.upper_something() == 'ANYTHING'
 def test_using_simple_patch_and_injection(self):
 dal = SomeDal()
 dal.get_something = lambda: 'anything'
 controller = SomeController(dal)
 assert controller.upper_something() == 'ANYTHING'
 def test_using_simple_mock_class(self):
 class MockDal(object):
 def get_something(self):
 return 'anything'
 controller = SomeController(MockDal())
 assert controller.upper_something() == 'ANYTHING'
 def test_using_semi_magic_mock(self):
 mock_dal = Mock(spec=SomeDal)
 mock_dal.get_something.return_value = 'anything'
 controller = SomeController(mock_dal)
 assert controller.upper_something() == 'ANYTHING'

• python
• unit-testing
• mocking