Mockito How to mock only the call of a method of the superclass

I found a way to suppress the superclass method using PowerMockito. 3 simple steps need for this

1. Use PowerMockito.suppress method and MemberMatcher.methodsDeclaredIn method to supress parent class method

2. Second add Parent class in @PrepareForTest

3. Run your test class with PowerMock ie add @RunWith(PowerMockRunner.class) above your test class.

   @RunWith(PowerMockRunner.class)
   @PrepareForTest({BaseService.class})
   public class TestChildService(){
   
       @Spy
       private ChildService testChildServiceObj = Mockito.spy(new ChildService());
   
       @Test
       public void testSave(){
           PowerMockito.suppress(MemberMatcher.methodsDeclaredIn(BaseService.class));
   
           //your further test code
   
           testChildServiceObj.save();
       }
   }
   

Note: This will work only when the superclass method does not return anything.

If you really don't have a choice for refactoring you can mock/stub everything in the super method call e.g.

    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();
    }

Consider refactoring the code from ChildService.save() method to different method and test that new method instead of testing ChildService.save(), this way you will avoid unnecessary call to super method.

Example:

class BaseService {  
    public void save() {...}  
}

public Childservice extends BaseService {  
    public void save(){  
        newMethod();    
        super.save();
    }
    public void newMethod(){
       //some codes
    }
} 

No, Mockito does not support this.

This might not be the answer you're looking for, but what you're seeing is a symptom of not applying the design principle:

Favor composition over inheritance

If you extract a strategy instead of extending a super class the problem is gone.

If however you are not allowed to change the code, but you must test it anyway, and in this awkward way, there is still hope. With some AOP tools (for example AspectJ) you can weave code into the super class method and avoid its execution entirely (yuck). This doesn't work if you're using proxies, you have to use bytecode modification (either load time weaving or compile time weaving). There are be mocking frameworks that support this type of trick as well, like PowerMock and PowerMockito.

I suggest you go for the refactoring, but if that is not an option you're in for some serious hacking fun.