如何使用Mockito模拟最终课程

我有最后一堂课，像这样：

public final class RainOnTrees{

   public void startRain(){

        // some code here
   }
}

我正在像这样的其他班级使用这个班级：

public class Seasons{

   RainOnTrees rain = new RainOnTrees();

   public void findSeasonAndRain(){

        rain.startRain();

    }
}

在我的JUnit测试类中，Seasons.java我想模拟RainOnTrees该类。我该如何使用Mockito做到这一点？

仅在Mockito v2中可以模拟最终/静态类/方法。

将此添加到您的gradle文件中：

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

使用Mockito常见问题解答中的 Mockito v1，这是不可能的：

Mockito的局限性是什么

• 需要Java 1.5+

• 无法模拟最终课程

...

Mockito 2现在支持最终的类和方法！

但是现在这是一个“孵化”功能。它需要一些步骤来激活它，如《 Mockito 2的新增功能》所述：

最终课程和方法的模拟是一个孵化器，可以选择加入。它结合使用Java代理工具和子类，以实现这些类型的可模拟性。由于此功能与我们当前的机制不同，并且此机制具有不同的局限性，并且我们希望收集经验和用户反馈，因此必须明确激活此功能才能使用；通过创建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模拟期末课程，因为您无法自己完成。

我要做的是创建一个非最终类来包装最终类并用作委托。一个例子是TwitterFactory类，这是我的可模拟类：

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代替用户的访问令牌，而getInstance则接受用户）。

在您的情况下，我将创建一个非最终RainOnTrees类，委托给最终类。或者，如果您可以将其定为非决赛，那会更好。

将此添加到您的gradle文件中：

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

这是使模仿与最终类一起使用的配置

使用Powermock。该链接显示了如何执行此操作：https : //github.com/jayway/powermock/wiki/MockFinal

只是跟进。请将此行添加到您的gradle文件中：

testCompile group: 'org.mockito', name: 'mockito-inline', version: '2.8.9'

我尝试了各种版本的mockito-core和mockito-all。他们都不工作。

我猜您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
       }
   }

通过使用这种策略，您将能够使用Mockito并保持类关闭以进行扩展，而只需很少的样板代码。

我有同样的问题。由于我尝试模拟的类是一个简单的类，因此我只创建了一个实例并将其返回。

试试看：

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

它为我工作。“ SomeMockableType.class”是您要模拟或监视的父类，而someInstanceThatIsNotMockableOrSpyable是您要模拟或监视的实际类。

欲了解更多详情，请看这里

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

实际上，有一种方法可供我监视。只有满足两个先决条件，它才对您有用：

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

请记得有效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 3和更高版本中，我有相同的问题，并已通过此链接修复

使用Mockito模拟最终课程和方法， 如下所示

在将Mockito用于模拟最终类和方法之前，需要先对其进行配置。

我们需要向项目的src / test / resources / mockito-extensions目录中添加一个名为org.mockito.plugins.MockMaker的文本文件，并添加一行文本：

mock-maker-inline

加载时，Mockito会检查扩展目录中的配置文件。该文件可模拟最终方法和类。

适用于在Android + Kotlin上遇到相同问题（Mockito +最终课程）的人们节省时间。和Kotlin一样，默认情况下，类是final。我在一个带有Architecture组件的Google Android示例中找到了一个解决方案。从这里选择的解决方案： https //github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample

创建以下注释：

/**
 * This annotation allows us to open some classes for mocking purposes while they are final in
 * release builds.
 */
@Target(AnnotationTarget.ANNOTATION_CLASS)
annotation class OpenClass

/**
 * Annotate a class with [OpenForTesting] if you want it to be extendable in debug builds.
 */
@OpenClass
@Target(AnnotationTarget.CLASS)
annotation class OpenForTesting

修改gradle文件。从这里举个例子：https : //github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample/app/build.gradle

apply plugin: 'kotlin-allopen'

allOpen {
    // allows mocking for classes w/o directly opening them for release builds
    annotation 'com.android.example.github.testing.OpenClass'
}

现在，您可以注释任何类以使其可供测试：

@OpenForTesting
class RepoRepository 

如果您使用的是Mockito2，可以通过支持孵化最终类和方法的新孵化功能来完成此操作。

需要注意的重点：
1.创建一个名称为“ org.mockito.plugins.MockMaker”的简单文件，并将其放置在名为“ mockito-extensions”的文件夹中。该文件夹应在类路径上可用。
2.上面创建的文件的内容应为单行，如下所示：
mock-maker-inline

为了激活模仿扩展机制并使用此选择加入功能，需要执行上述两个步骤。

示例类如下：

FinalClass.java

public final class FinalClass {

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

}

Foo.java

public class Foo {

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

}

FooTest.java

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

}

}

希望能帮助到你。

完整的文章在这里嘲笑不可嘲笑。

是同样的问题，我们无法使用Mockito模拟最终课程。准确地说，Mockito无法模拟/监视以下内容：

• 期末课程
• 匿名类
• 基本类型

但是在我看来，使用包装器类似乎要付出很大的代价，因此请改为使用PowerMockito。

我认为您需要更多地考虑原则。相反，您的最后一堂课改用他的接口和模拟接口。

为了这：

 public class RainOnTrees{

   fun startRain():Observable<Boolean>{

        // some code here
   }
}

加

interface iRainOnTrees{
  public void startRain():Observable<Boolean>
}

并模拟您的界面：

 @Before
    fun setUp() {
        rainService= Mockito.mock(iRainOnTrees::class.java)

        `when`(rainService.startRain()).thenReturn(
            just(true).delay(3, TimeUnit.SECONDS)
        )

    }

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

    }
}

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

尽管Mockito 不能通过设计模拟最终类，但可以采用委派方法。这有其优点：

1. 如果这是您的API最初打算的，那么您不必强迫将类更改为非最终类（最终类具有其优势））。
2. 您正在测试围绕API 进行装饰的可能性。

在您的测试用例中，您有意将呼叫转发到被测系统。因此，通过设计，您的装饰不会做任何事情。

因此，您的测试还可以证明用户只能装饰API而不是对其进行扩展。

从更主观的角度来看：我更喜欢将框架保持在最低水平，这就是为什么JUnit和Mockito通常足以满足我的需求。实际上，限制这种方式有时也会迫使我也进行良好的重构。

如果您尝试在测试文件夹下运行单元测试，则最佳解决方案是可以的。只需跟随它添加扩展名即可。

但是，如果您想使用androidtest文件夹下的android 相关类（例如上下文或活动）来运行它，答案就是适合您。

添加以下依赖项以成功运行mockito：

testImplementation'org.mockito：mockito-core：
2.24.5'testImplementation“ org.mockito：mockito-inline：2.24.5”

正如其他人所说，这对于Mockito来说是开箱即用的。我建议使用反射来设置被测试代码所使用的对象上的特定字段。如果发现自己经常这样做，则可以将此功能包装在库中。

顺便说一句，如果您是最后一个标记班，请停止这样做。我遇到了这个问题，因为我正在使用一个API，其中所有内容均标记为final，以防止我对扩展的合法需求（嘲笑），并且我希望开发人员不必假设我永远不需要扩展该类。

对我们来说，这是因为我们从koin-test中排除了模仿内联。一个gradle模块实际上需要这个，并且由于原因仅在发行版本中失败（IDE中的调试版本有效）：-P

对于最终类，在下面添加以模拟并调用静态或非静态。

1-将其添加到类级别@SuppressStatucInitializationFor（value = {带有包的类名称}）
2- PowerMockito.mockStatic（classname.class）将模拟类
3-然后在调用此类的方法时使用when语句返回模拟对象。

请享用

并没有尝试final，但私下使用反射删除了修饰符！经过进一步检查，它不适用于最终版本。