如何模拟在构造函数中实例化的对象？

Question

I'm writing unit-tests with Pytest. I want to unit-test a class that has on its __init__ method an object that connects to a database:

data_model.py

from my_pkg.data_base_wrapper import DataBaseWrapper

class DataModel:
  def __init__(self):
    self.db = DataBaseWrapper()
    self.db.update_data()

  def foo(self):
    data = self.db.get_some_data()
    # make some processing and return a result

data_base_wrapper.py

class DataBaseWrapper:
  def __init__(self):
    # Init process of the wrapper
    pass

  def update_data(self):
    # Connect to the database and perform some operations
    pass

I've tried using monkeypatch on the DataBaseWrapper object of DataModel :

from my_pkg.data_model import DataModel

class MockDataBaseWrapper:
  @staticmethod
  def update_cache():
      pass

  @staticmethod
  def get_table(table):
    # Return some data for testing
    pass

@pytest.fixture
def data_model(monkeypatch):
  monkeypatch.setattr(DataModel, 'db', MockDataBaseWrapper)
  data_model = DataModel()

  return data_model

However, I get the following error:

monkeypatch = <_pytest.monkeypatch.MonkeyPatch object at 0x7f10221669e8>

    @pytest.fixture
    def data_model(monkeypatch):
>       monkeypatch.setattr(DataModel, 'db', MockDataBaseWrapper)
E       AttributeError: <class 'dashboard.datamodel.DataModel'> has no attribute 'db'

I've read in the answers of similar questions, that I could try writing a sub-class of my DataBaseWrapper and change it on the DataModel class, but I'm in the same situation, as I cannot monkeypatch the attribute of the __init__ method. I can, though, if it is not in the __init__ method.

How can I write tests for this composition of classes? Suggestions on how to rewrite these classes or a different patter are also welcome.

Answer 1

The problem is that your MockDataBaseWrapper is totally unrelated to the DataBaseWrapper used in DataModel .

My proposal is to get rid of your MockDataBaseWrapper and:

• If you want to keep your current structure, you can use patch to mock the DataBaseWrapper that is actually imported in data_model.py.

from mock import patch
from my_pkg.data_model import DataModel

def test_data_model():
    with patch("my_pkg.data_model.DataBaseWrapper") as MockedDB:
        mocked_db = MockedDB()
        data_model = DataModel()
        assert data_model.db is mocked_db

The patch context manager will replace the DataBaseWrapper class that gets imported in your data_model.py with a Mock instance and let you interact with that mock, which allows me here to verify that it got instantiated.

Note that it is very important to patch the class in the module where it is imported (and not in the model where it is defined, ie we patch your_package.data_model.DataBaseWrapper and not your_package.data_base_wrapper.DataBaseWrapper )

• If you don't mind changing your class, then the usual pattern is to inject the db parameter into the constructor of DataModel . Mocking it then becomes a piece of cake.

class DataModel:
    def __init__(self, db):
        self.db = db
        self.db.update_data()

from mock import patch, Mock
from my_pkg.data_model import DataModel

def test_data_model():
    mocked_db = Mock()
    data_model = DataModel(mocked_db)
    assert data_model.db is mocked_db