如何用mockito模拟最后一个类

只有在Mockito v2中才可以模拟final/static类/方法

testImplementation 'org.mockito:mockito-inline:2.13.0'

这在Mockito v1中是不可能的，从5常见问题解答:

Mockito的局限性是什么

• 需要java1.5 +

• 不能模拟最终类

.．.

你不能用Mockito模拟最后一个类，因为你自己不能这样做。

我所做的是创建一个非final类来包装final类并作为委托使用。一个例子是TwitterFactory类，这是我的mockable类:

public class TwitterFactory {


private final twitter4j.TwitterFactory factory;


public TwitterFactory() {
factory = new twitter4j.TwitterFactory();
}


public Twitter getInstance(User user) {
return factory.getInstance(accessToken(user));
}


private AccessToken accessToken(User user) {
return new AccessToken(user.getAccessToken(), user.getAccessTokenSecret());
}


public Twitter getInstance() {
return factory.getInstance();
}
}

缺点是有很多样板代码;好处是您可以添加一些可能与您的应用程序业务相关的方法(如在上面的例子中，getInstance接受用户而不是accessToken)。

在你的例子中，我会创建一个非final的RainOnTrees类，它委托给final类。或者，如果你能让它变成非最终结果，那就更好了。

使用Powermock。这个链接显示了如何做:https://github.com/jayway/powermock/wiki/MockFinal

我也有同样的问题。由于我试图模拟的类是一个简单的类，所以我只是创建了它的一个实例并返回该实例。

是的，同样的问题在这里，我们不能模拟一个最终类与Mockito。准确地说，Mockito不能模仿/监视以下内容:

• 最后的课程
• 匿名类
• 原始类型

但是在我看来，使用包装器类代价很大，所以改用PowerMockito。

请看JMockit。它有大量的文档和示例。这里有一个解决问题的示例(为了简化，我在Seasons中添加了构造函数，以注入模拟的RainOnTrees实例):

package jmockitexample;


import mockit.Mocked;
import mockit.Verifications;
import mockit.integration.junit4.JMockit;
import org.junit.Test;
import org.junit.runner.RunWith;


@RunWith(JMockit.class)
public class SeasonsTest {


@Test
public void shouldStartRain(@Mocked final RainOnTrees rain) {
Seasons seasons = new Seasons(rain);


seasons.findSeasonAndRain();


new Verifications() \{\{
rain.startRain();
}};
}


public final class RainOnTrees {
public void startRain() {
// some code here
}


}


public class Seasons {


private final RainOnTrees rain;


public Seasons(RainOnTrees rain) {
this.rain = rain;
}


public void findSeasonAndRain() {
rain.startRain();
}


}
}

试一试:

Mockito.mock(SomeMockableType.class,AdditionalAnswers.delegatesTo(someInstanceThatIsNotMockableOrSpyable));

这对我很管用。"SomeMockableType.class"是你想要模拟或监视的对象的父类，而someInstanceThatIsNotMockableOrSpyable是你想要模拟或监视的实际类。

要了解更多细节，请查看在这里

在某些情况下可能适用的另一种解决方法是创建一个由最终类实现的接口，更改代码以使用该接口而不是具体类，然后模拟该接口。这样可以将契约(接口)与实现(最终类)分离。当然，如果您真正想要的是绑定到最终的类，这将不适用。

由RC和Luigi R. Viggiano共同提供的解决方案可能是最好的主意。

虽然Mockito 不能在设计上模拟final类，但委托方法是可能的. c。这有它的优点:

1. 如果你的API一开始就打算将你的类改为非final类(final类有它们的好处)，那么你不会被迫将你的类改为非final类。
2. 你在测试API周围装饰的可能性。

在您的测试用例中，您故意将调用转发到被测试的系统。因此，根据设计，你的装饰做不做任何事情。

因此，测试还可以证明用户只能修饰API，而不能扩展API。

没有尝试final，但私有，使用反射删除修饰符工作!已经进一步检查，它不为最终工作。

我猜你把它做成final是因为你想阻止其他类扩展RainOnTrees。正如有效的Java所建议的(第15项)，有另一种方法来保持类接近以进行扩展，而不使其为final:

1. 移除final关键字;

2. 使其构造函数为private。没有类能够扩展它，因为它不能调用super构造函数;

3. 创建一个静态工厂方法来实例化你的类。

   // No more final keyword here.
   public class RainOnTrees {
   
   
   public static RainOnTrees newInstance() {
   return new RainOnTrees();
   }
   
   
   
   
   private RainOnTrees() {
   // Private constructor.
   }
   
   
   public void startRain() {
   
   
   // some code here
   }
   }
   

By using this strategy, you'll be able to use Mockito and keep your class closed for extension with little boilerplate code.

实际上有一种方法，我用来监视的。只有满足两个前提条件，它才会为你工作:

1. 使用某种DI注入final类的实例
2. Final类实现了一个接口

请回忆有效的Java中的第16项。你可以创建一个包装器(不是final)并将所有调用转发给final类的实例:

public final class RainOnTrees implement IRainOnTrees {
@Override public void startRain() { // some code here }
}


public class RainOnTreesWrapper implement IRainOnTrees {
private IRainOnTrees delegate;
public RainOnTreesWrapper(IRainOnTrees delegate) {this.delegate = delegate;}
@Override public void startRain() { delegate.startRain(); }
}

现在你不仅可以模仿你的最后一个类，还可以监视它:

public class Seasons{
RainOnTrees rain;
public Seasons(IRainOnTrees rain) { this.rain = rain; };
public void findSeasonAndRain(){
rain.startRain();
}
}


IRainOnTrees rain = spy(new RainOnTreesWrapper(new RainOnTrees()) // or mock(IRainOnTrees.class)
doNothing().when(rain).startRain();
new Seasons(rain).findSeasonAndRain();

Mockito 2现在支持final类和方法!

但就目前而言，这只是一个“孵化”阶段。特性。它需要一些步骤来激活它，这些步骤在《Mockito 2》有什么新内容中描述:

模拟final类和方法是孵化的一个可选特性。它结合使用了Java代理插装和子类化，以支持这些类型的可伪性。因为这与我们当前的机制不同，而且有不同的局限性，因为我们想要收集经验和用户反馈，所以这个功能必须被明确激活。它可以通过mockito扩展机制通过创建包含单行的文件src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker来完成:

mock-maker-inline

在你创建这个文件后，Mockito会自动使用这个新引擎，你可以这样做:

 final class FinalClass {
final String finalMethod() { return "something"; }
}


FinalClass concrete = new FinalClass();


FinalClass mock = mock(FinalClass.class);
given(mock.finalMethod()).willReturn("not anymore");


assertThat(mock.finalMethod()).isNotEqualTo(concrete.finalMethod());

在随后的里程碑中，团队将带来使用该特性的程序化方式。我们将为所有不可嘲笑的场景识别并提供支持。请继续关注，让我们知道你对这个功能的看法!

正如其他人所说，这不会在Mockito的盒子外工作。我建议使用反射来设置测试代码正在使用的对象上的特定字段。如果您发现自己经常这样做，可以将此功能打包到一个库中。

说句题外话，如果你是那个给课程打期末分数的人，那就别这么做了。我遇到这个问题是因为我正在使用一个API，其中所有内容都被标记为final，以防止我合理地需要扩展(mock)，我希望开发人员没有假设我永远不需要扩展该类。

如果你正在使用Mockito2，这可以做到，新的孵化功能支持模拟最终类&方法。

public final class FinalClass {


public final String hello(){
System.out.println("Final class says Hello!!!");
return "0";
}

public class Foo {


public String executeFinal(FinalClass finalClass){
return finalClass.hello();
}

public class FooTest {


@Test
public void testFinalClass(){
// Instantiate the class under test.
Foo foo = new Foo();


// Instantiate the external dependency
FinalClass realFinalClass = new FinalClass();


// Create mock object for the final class.
FinalClass mockedFinalClass = mock(FinalClass.class);


// Provide stub for mocked object.
when(mockedFinalClass.hello()).thenReturn("1");


// assert
assertEquals("0", foo.executeFinal(realFinalClass));
assertEquals("1", foo.executeFinal(mockedFinalClass));


}