How to Mock Subclass Methods While Preserving Superclass Implementations in Mockito?

Mocking Subclass Methods While Preserving Superclass Implementations

Mockito, a widely-used Java mocking framework, often faces the challenge of selectively mocking specific methods within class hierarchies. This article addresses a scenario where you want to mock only the call to a method inherited from the superclass.

Problem Statement

Consider the following class structure:

<code class="java">class BaseService {  
    public void save() {...}  
}

public Childservice extends BaseService {  
    public void save(){  
        //some code  
        super.save();
    }  
}  </code>

In unit tests, you may want to mock only the second call to super.save() without affecting the implementation in ChildService.

Solution

While it's generally not recommended to refactor existing class hierarchies for testing purposes, there are ways to address this challenge without modifying the codebase.

Consider the following approach:

<code class="java">class BaseService {

        public void validate(){
            fail(" I must not be called");
        }

        public void save(){
            //Save method of super will still be called.
            validate();
        }
    }

    class ChildService extends BaseService{

        public void load(){}

        public void save(){
            super.save();
            load();
        }
    }

    @Test
    public void testSave() {
        ChildService classToTest = Mockito.spy(new ChildService());

        // Prevent/stub logic in super.save()
        Mockito.doNothing().when((BaseService)classToTest).validate();

        // When
        classToTest.save();

        // Then
        verify(classToTest).load();
    }</code>

This solution leverages Mockito's Mockito.spy() API to wrap an instance of the ChildService class. Then, it overrides the validate() method of BaseService (the superclass) using Mockito.doNothing(). This ensures that the logic in validate() is avoided during the test. As a result, the real implementation of ChildService.save() is called, while the call to super.save() is effectively stubbed.

Additional Notes

This technique should be used sparingly, as stubbing or mocking external methods can lead to fragile tests and impact the accuracy of your test results. However, it can be a pragmatic solution when refactoring the class hierarchy is not an option.

The above is the detailed content of How to Mock Subclass Methods While Preserving Superclass Implementations in Mockito?. For more information, please follow other related articles on the PHP Chinese website!