Mockito Mock Vs. Spy: Choosing the Right Approach

Mockito is a popular Java testing framework with powerful capabilities for creating and managing mock objects. Mock objects are simulated objects that mimic the behavior of real objects, enabling developers to isolate and test specific code components.

Mock and Spy are two important features of Mockito that allow for different types of object manipulation during testing.

Mock Objects

Mock objects in Mockito are entirely synthetic objects that are dynamically created to emulate the behavior of real objects. They allow developers to define the expected behavior of dependencies or collaborators without invoking the actual methods of those objects. Mock objects provide a way to isolate the code under test from its dependencies, enabling focused and controlled testing.

Mockito’s Mock feature provides an easy-to-use syntax for creating and configuring mock objects. With Mockito Mock, you can specify the return values for methods, define custom behaviors, verify method invocations, and more. This allows you to set up a controlled environment for testing specific scenarios, ensuring predictable outcomes.

An Example of Using Mockito Mock

Consider a scenario with a ‘UserService’ class that relies on a ‘UserRepository’ to perform database operations. By creating a mock object for UserRepository, you can simulate the behavior of the database without actually connecting to it during testing. This helps in isolating the behavior of UserService and focusing on the logic being tested.

Spy Objects

Unlike mock objects, spy objects in Mockito are partially real objects that allow developers to retain the original behavior of the object while still providing the ability to customize certain aspects. Spy objects are useful when you want to test the real implementation of an object but also need to stub or mock specific methods.

Mockito’s Spy feature allows you to create a spy object by wrapping an existing class instance. The spy object retains the original behavior of the real object, but you can selectively override certain methods to provide custom behavior or verification.

An Example of Using Mockito Spy

Suppose you have a class called ‘Calculator’ with several methods, and you want to test the behavior of one particular method while keeping the others intact. By creating a spy object for Calculator and stubbing only the required method, you can focus the testing efforts on that specific method while still relying on the actual implementation for the rest.

Learn Java and become a professional developer. This Java course will give you the skills you need to land a job as a Java developer!

Below, we will point out some scenarios where you may consider using Mockito mocks:

• Isolation of Dependencies: Mockito Mock is commonly used to isolate the behavior of dependencies or collaborators in a test scenario. Creating mock objects for these dependencies allows you to control their responses and focus on testing the specific component under scrutiny.
• Simplifying Complex Dependencies: In situations where the dependencies of a class are complex, involving external systems or databases using Mockito Mock can simplify the testing process. Replacing these dependencies with mock objects prevents you from needing actual connections and ensures predictable behavior during testing.
• Testing Error or Edge Cases: Mockito Mock is particularly useful when testing errors or edge cases. You can configure the mock object to return specific values or throw exceptions in response to certain method invocations, allowing you to verify the behavior of the tested component in exceptional scenarios.
• Enhancing Test Reliability: Using Mockito Mock helps improve the reliability of tests by eliminating external factors that could impact the outcome. For example, if a component relies on a web service that might be down or slow, mocking the web service with Mockito Mock allows you to test the component’s behavior consistently without being affected by external issues.
• Controlled and Focused Testing: Mockito Mock allows you to define the expected behavior of dependencies explicitly. This enables controlled and focused testing, as you can specify the responses of mock objects, verify method invocations, and ensure that the tested component behaves as expected under specific conditions.
• Performance Optimization: Mockito Mock can also be utilized for performance optimization in test scenarios. By replacing time-consuming resource-intensive dependencies with mock objects, you can quicken the execution of tests, making the testing process more efficient.
• Collaboration with Teams: Mockito Mock promotes collaboration between teams, particularly when different teams are responsible for different components of an application. By creating mock objects for dependencies that are not yet available or fully implemented, one team can proceed with testing while the others continue their development work.
• Testing in Isolation: Mockito Mock facilitates testing in isolation, allowing you to focus on the behavior of a specific component without interference from other parts of the system. By controlling the responses of mock objects, you can simulate different scenarios and thoroughly test the targeted component without worrying about unintended interactions.
• Stubbing Behavior: Mockito Mock provides a convenient way to stub the behavior of dependencies. You can specify the return values for methods, define custom behaviors, or throw exceptions when specific methods are called. This helps create realistic test cases and ensures that the component under test handles the expected responses correctly.

Learn Java from scratch with our beginner-friendly Java tutorial. No prior programming experience is necessary!

Here are some situations where you may consider using Mockito spies:

• Partially Test Real Objects: Mockito Spy is useful when you want to test the behavior of a real object but need to modify or override certain methods for the test. It allows you to retain the original behavior of the object while selectively customizing specific methods.
• Integration Testing: Mockito Spy can be employed effectively in integration testing scenarios. When testing the integration between multiple components, you may want to retain the real behavior of some objects while stubbing or mocking some specific methods of others. You can achieve this combination of real and customized behavior by creating spy objects.
• Legacy Code Testing: Legacy code often presents challenges when writing tests due to its tightly coupled dependencies or lack of testability. Mockito Spy can be helpful in such situations by allowing you to create a spy object around the legacy code, keeping the original behavior intact while selectively overriding methods to accommodate testing requirements.
• Refactoring and Regression Testing: When refactoring code, you should ensure that the behavior of certain methods remains unchanged during the process. By creating spy objects for those methods, you can verify that their behavior remains consistent before and after the refactoring, thus aiding in regression testing.
• Data Manipulation During Testing: Mockito Spy can be useful when you need to manipulate or transform data within an object during testing. By spying on the object and selectively overriding methods that perform data operations, you can control the input or output data and verify the object’s behavior accordingly.
• Adapting to External Dependencies: Sometimes, external dependencies may change their behavior or introduce breaking changes. Mockito Spy can help adapt the code to such changes by providing a way to override or modify specific methods in response to the updated behavior of the external dependency.
• Testing Third-Party Libraries or APIs: Mockito Spy is beneficial when testing code that relies on third-party libraries or APIs. Instead of completely mocking these external dependencies, spy objects can retain the original behavior while selectively modifying or verifying specific methods relevant to the test case.
• Collaborative Testing: Mockito Spy allows for collaborative testing among teams or developers. When one team is responsible for the implementation of a class and another team is responsible for testing it, spy objects can be used to test the real implementation while providing flexibility in overriding or verifying certain methods.

Here are the key differences between Mockito Mock and Spy:

• Purpose
  • Mockito Mock: Mock objects are completely simulated versions of real objects. They are primarily used to replace dependencies and control their behavior during unit testing. Mocks allow you to define the expected behavior of methods and verify interactions with the mock object.
  • Mockito Spy: Spies, on the other hand, are partially mock objects that wrap around real objects. They retain the original behavior of the object while still allowing you to stub specific methods or verify method invocations. Spies are useful when you want to partially mock an object and track its interactions with other objects.

• Real Object Behavior
  • Mockito Mock: Mock objects don’t execute the real methods of the underlying object. They provide default behavior or behavior defined using Mockito stubbing methods (e.g., when(…).thenReturn(…)).
  • Mockito Spy: Spies execute the real methods of the underlying object by default. You can stub specific methods of the spy to alter their behavior or verify their invocations.

• Method Invocation Tracking
  • Mockito Mock: Mock objects track all method invocations, allowing you to verify whether specific methods were called and with what arguments.
  • Mockito Spy: Spies also track method invocations, just like mocks. You can verify whether specific methods were called and with what arguments. Additionally, you can selectively stub method behavior for the spy.

• Test Setup
  • Mockito Mock: Mock objects are typically created using the ‘Mockito.mock()’ method or the ‘@Mock’ annotation. You explicitly define the behavior of the mock methods using Mockito stubbing methods.
  • Mockito Spy: Spies are created using the ‘Mockito.spy()’ method, which wraps an existing object. The spy retains the original object’s behavior, and you can selectively stub or verify method invocations as needed.

Read on: Mockito Annotations to enhance your Knowledge!