Mocking Specific Method Calls in Superclasses with Mockito
In testing scenarios, it may be necessary to mock only specific method calls in a superclass while preserving the original behavior of others. This can be achieved using Mockito's flexible mocking capabilities.
Consider the following class hierarchy:
<code class="java">class BaseService { public void save() {...} } class ChildService extends BaseService { public void save() { // Custom logic super.save(); } }</code>
In this example, we want to mock only the call to super.save() in ChildService while allowing the original implementation of save() in BaseService to be executed.
To achieve this, we can use the spy function to create a proxy of ChildService:
<code class="java">ChildService classToTest = Mockito.spy(new ChildService());</code>
Next, we need to stub the behavior of super.save() within the context of ChildService. However, since super refers to the BaseService class within ChildService, we need to cast classToTest to BaseService before using Mockito.doNothing().
<code class="java">Mockito.doNothing().when((BaseService)classToTest).validate();</code>
By stubbing the validate() method of BaseService, we are effectively preventing it from being called during the test. Consequently, only the super.save() call in ChildService will be intercepted by the mock.
To complete the test, we can now call save() on classToTest and assert that the expected logic in ChildService is executed:
<code class="java">classToTest.save(); verify(classToTest).load();</code>
This approach allows us to selectively mock specific method calls in superclasses while preserving the functionality of the inherited methods. It proves valuable in situations where modifying the class hierarchy or refactoring code is not feasible.
The above is the detailed content of How to Mock Specific Method Calls in Superclasses with Mockito?. For more information, please follow other related articles on the PHP Chinese website!