What are the best practices for using test doubles and mocks in unit testing?

1 What are test doubles and mocks?

Test doubles and mocks are terms that refer to different kinds of objects that can be used to substitute or mimic the behavior of real dependencies in unit testing. Test doubles are a general category that includes several types, such as dummies, stubs, spies, and fakes. Mocks are a specific type of test double that can verify the interactions between the code under test and the mock object, such as the number of calls, the arguments, and the order of execution. Test doubles and mocks can be created manually, using frameworks, or using tools that generate them automatically.

2 When to use test doubles and mocks?

Test doubles and mocks can be useful in a variety of situations, such as when the real dependency is not accessible, slow, expensive, unreliable, or has side effects. They can also be helpful when the real dependency is complex or difficult to set up. Additionally, test doubles and mocks are beneficial when you want to isolate the code under test from the behavior or state of the real dependency, for example when testing error handling, edge cases, or alternative scenarios.

3 How to choose the right type of test double or mock?

When choosing a test double or mock, it is important to consider the type and implementation that suits your testing needs and goals. As a guideline, dummies should be used when passing an object as a parameter, but not caring about its value or behavior. Stubs should be used when returning a predefined value or behavior from a method or property, but not caring about the interactions with the object. Spies should be used when verifying the interactions with the object, such as the number of calls or arguments, but not needing to control the return value or behavior. Fakes should be used when simulating the functionality of the real dependency, but with a simpler or different implementation. Mocks should be used when needing to control and verify the interactions with the object, such as the return value, behavior, and order of execution.

4 How to write testable code with test doubles and mocks?

Test doubles and mocks can help make unit tests more readable, reliable, and maintainable, but they may also present challenges and risks if they are overused, misused, or abused. To ensure successful tests, it’s important to write testable code that follows best practices such as dependency injection to decouple the code under test from concrete dependencies. Interfaces, abstract classes, or virtual methods should be used to define the contracts or expectations of the dependencies. Additionally, the principles of least astonishment and least knowledge should be employed to design test doubles or mocks that behave consistently and intuitively with the real dependencies while limiting their scope and exposure. Lastly, the principle of single responsibility should be used to separate the concerns and responsibilities of test doubles or mocks.

5 How to use frameworks and tools for test doubles and mocks?

Creating test doubles and mocks manually can be tedious, repetitive, or error-prone, so it is often preferable to use frameworks and tools that can simplify and automate the process. Popular frameworks and tools include Mockito, Moq, Sinon, Jasmine, and Jest. These provide fluent and expressive syntax to define and configure test doubles or mocks, as well as flexible and powerful options to control and verify interactions. Additionally, they offer smart and dynamic generation of test doubles or mocks, with integration and compatibility with other testing frameworks and tools. However, there are drawbacks to using these frameworks and tools such as a learning curve to understand how to use them correctly, dependency on the code under test, and over-reliance on the framework or tool.

6 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?