Mockito如何仅模拟超类方法的调用

我在某些测试中使用了Mockito。

我有以下课程：

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

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

我只想模拟的第二个调用（super.save）ChildService。第一次调用必须调用real方法。有没有办法做到这一点？

不，Mockito不支持此功能。

这可能不是您要寻找的答案，但是您看到的是不采用设计原则的症状：

偏爱继承而不是继承

如果您提取策略而不是扩展超类，那么问题就不存在了。

但是，如果不允许您更改代码，但无论如何都必须对其进行测试，并且以这种尴尬的方式仍然存在希望。使用某些AOP工具（例如AspectJ），您可以将代码编织到超类方法中，而完全避免执行（讨厌）。如果使用代理，这将不起作用，则必须使用字节码修改（加载时编织或编译时编织）。也有支持这种技巧的模拟框架，例如PowerMock和PowerMockito。

我建议您进行重构，但是如果这不是一种选择，那么您将获得一些严肃的黑客乐趣。

如果您真的没有重构的选择，可以在超级方法调用中模拟/存根所有内容，例如

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

考虑将代码从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
    }
} 

在调用超类方法的子类中创建一个受程序包保护的方法（假定在同一程序包中为测试类），然后该方法在您重写的子类方法中调用该方法。然后，您可以通过使用间谍模式在测试中对此方法设置期望值。虽然不是很漂亮，但肯定比必须在测试中处理超级方法的所有期望设置要好

即使我完全同意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

原因是您的基类未公开，所以Mockito由于可见性而无法拦截它，如果您将基类更改为public，或者将子类中的@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());
}

如果继承有意义，那么最简单的选择可能是创建一个新方法（私有包??）来调用超级方法（将其称为superFindall），监视真实实例，然后以您想模拟的方式模拟superFindAll（）方法。父类一。就覆盖范围和可见性而言，这不是完美的解决方案，但它应该可以完成工作，并且易于应用。

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

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