I’m a big fan of using mocks as a testing/design tool. But if I find myself reaching for patch instead of Mock in python, I usually stop and rethink my design.

I consider the use of patch in tests to be a code smell. It means the test code is not using my internal API. It’s reaching in to the private implementation details of my object.

For example, I recently needed a helper function for creating users on a third-party service with a set of default values. I could have written it like this:

from services import UserService from settings import SERVICE_CONF def create_user_with_defaults(**attributes): defaults = { "name": "test" } defaults.update(attributes) service = UserService(**SERVICE_CONF) return service.create_user(**defaults)

This would get the job done. And because this is python, I can test it without hitting real services using @patch :

@patch("users.helpers.UserService") def test_creates_user_with_defaults_on_user_service(self, MockUserService): user_service = MockUserService.return_value # execution: user = create_user_with_defaults() # verification: user_service.create_user.assert_called_once_with(name="test") self.assertEqual(user, user_service.create_user.return_value)

But look at the verification step: there is nothing in the execution step about user_service , yet that’s what I’m asserting against. My tests have knowledge about private implementation details of the thing they’re testing. That’s bad news.

I prefer my tests to be normal consumers of my internal APIs. This forces me to keep my APIs easy to use and flexible. @patch lets me get around issues like tight coupling by hijacking my hard-coded dependencies.

Here is how I actually implemented the helper function:

def create_user_with_defaults(service, **attributes): defaults = { "name": "test" } defaults.update(attributes) return service.create_user(**defaults)

I didn’t even need to import anything! This is how I would test it:

def test_creates_user_with_defaults_on_user_service(self): user_service = Mock() # execution: user = create_user_with_defaults(user_service) # verification: user_service.create_user.assert_called_once_with(name="test") self.assertEqual(user, user_service.create_user.return_value)

Now compare the verification to the execution. Instead of patching the internal workings of the module, I’m explicitly passing in a mock object. I can do this because the function no longer depends on the concrete implementation of the user service, it depends on an abstraction*: some object that must be passed in that conforms to a certain interface. So it makes sense that my test verifies the interaction with that interface.

This means my test is now a normal consumer of my function, and my desire to avoid patch led me to a design that is more flexible. This became clear as soon as I wanted to create some test users in the repl. I happily created an instance of the UserService that uses the settings for our sandbox, and passed that in to my function.

*See The Dependency Inversion Principle (the D from SOLID).