Вызовите вызов super.method (), используя mockito [duplicate]

Даже если я полностью согласен с ответом iwein (

предпочитает композицию над наследованием

), я допускаю, что наследование наследования несколько раз кажется естественным, и я не чувствую взлома или рефакторирования его только для модульного теста.

Итак, мое предложение:

/**
 * BaseService is now an asbtract class encapsulating 
 * some common logic callable by child implementations
 */
abstract class BaseService {  
    protected void commonSave() {
        // Put your common work here
    }

    abstract void save();
}

public ChildService extends BaseService {  
    public void save() {
        // Put your child specific work here
        // ...

        this.commonSave();
    }  
}

И затем в модульном тесте:

    ChildService childSrv = Mockito.mock(ChildService.class, Mockito.CALLS_REAL_METHODS);

    Mockito.doAnswer(new Answer<Void>() {
        @Override
        public Boolean answer(InvocationOnMock invocation)
                throws Throwable {
            // Put your mocked behavior of BaseService.commonSave() here
            return null;
        }
    }).when(childSrv).commonSave();

    childSrv.save();

    Mockito.verify(childSrv, Mockito.times(1)).commonSave();

    // Put any other assertions to check child specific work is done

создать защищенный пакет (предполагается, что класс теста в том же пакете) в подклассе, который вызывает метод суперкласса, а затем вызывать этот метод в методе переопределенного подкласса. вы можете установить ожидания этого метода в своем тесте с помощью шаблона шпиона. не очень, но, конечно, лучше, чем иметь дело со всеми настройками ожидания для супер метода в вашем тесте

Рассмотрим рефакторинг кода из метода ChildService.save () для другого метода и протестируйте этот новый метод вместо тестирования ChildService.save (), таким образом вы избежите ненужного вызова метода super.

Пример :

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

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

Если у вас действительно нет выбора для рефакторинга, вы можете высмеивать / заглушить все в вызове супер метода, например

    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 spy = Mockito.spy(new ChildService());

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

        // When
        spy.save();

        // Then
        verify(spy).load();
    }

Возможно, самый простой вариант, если наследование имеет смысл, - создать новый метод (private private), чтобы вызвать супер (позволяет называть его superFindall), заглянуть в реальный экземпляр и затем высмеять метод superFindAll () таким образом, как вы хотел высмеять родительский класс. Это не идеальное решение с точки зрения охвата и видимости, но оно должно выполнять эту работу, и ее легко применять.

 public Childservice extends BaseService {
    public void save(){
        //some code
        superSave();
    }

    void superSave(){
        super.save();
    }
}

Причина в том, что ваш базовый класс не является общедоступным, тогда Mockito не может перехватить его из-за видимости, если вы измените базовый класс как общедоступный или @Override в подклассе (как общедоступный), то Mockito может издеваться над ним правильно.

public class BaseService{
  public boolean foo(){
    return true;
  }
}

public ChildService extends BaseService{
}

@Test
@Mock ChildService childService;
public void testSave() {
  Mockito.when(childService.foo()).thenReturn(false);

  // When
  assertFalse(childService.foo());
}