Coding Man
文章 标签 分类
链接
BiliBili YouTube
Coding Man

Contents

PowerMockito 简介

 included in Testing
   2171 words   5 minutes 

1. 概述

长期以来，借助模拟框架进行单元测试被认为是一种有用的实践，尤其是Mockito 框架近年来主导了这个市场。

并且为了促进体面的代码设计并使公共 API 变得简单，一些想要的功能被故意遗漏了。然而，在某些情况下，这些缺点迫使测试人员编写繁琐的代码只是为了使模拟的创建变得可行。

这就是PowerMock 框架发挥作用的地方。

PowerMockito 是 PowerMock 的扩展 API，用于支持 Mockito。它提供了以一种简单的方式使用 Java 反射 API 的功能，以克服 Mockito 的问题，例如缺乏模拟最终、静态或私有方法的能力。

本教程将介绍 PowerMockito API 并了解它是如何在测试中应用的。

2. 准备使用 PowerMockito 进行测试

为 Mockito 集成 PowerMock 支持的第一步是在 Maven POM 文件中包含以下两个依赖项：

<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>1.6.4</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito</artifactId>
    <version>1.6.4</version>
    <scope>test</scope>
</dependency>

接下来，我们需要通过应用以下两个注解来准备使用PowerMockito的测试用例：

@RunWith(PowerMockRunner.class)
@PrepareForTest(fullyQualifiedNames = "com.blogdemo.powermockito.introduction.*")

@PrepareForTest注解中的fullyQualifiedNames元素表示我们要模拟的类型的完全限定名称数组。在这种情况下，我们使用带有通配符的包名称来告诉PowerMockito准备com.blogdemo.powermockito.introduction包中的所有类型以进行模拟。

现在我们准备好利用PowerMockito的强大功能了。

3. 模拟构造函数和最终方法

在本节中，我们将演示在使用new运算符实例化类时获取模拟实例而不是真实实例的方法，然后使用该对象模拟最终方法。

以下是我们将如何定义协作类，其构造函数和最终方法将被模拟：

public class CollaboratorWithFinalMethods {
    public final String helloMethod() {
        return "Hello World!";
    }
}

首先，我们使用PowerMockito API创建一个模拟对象：

CollaboratorWithFinalMethods mock = mock(CollaboratorWithFinalMethods.class);

接下来，我们设置一个期望，即每当调用该类的无参数构造函数时，都应该返回一个模拟实例，而不是一个真实的实例：

whenNew(CollaboratorWithFinalMethods.class).withNoArguments().thenReturn(mock);

让我们通过使用默认构造函数实例化CollaboratorWithFinalMethods类来看看这个构造模拟是如何工作的，然后我们将验证 PowerMock 的行为：

CollaboratorWithFinalMethods collaborator = new CollaboratorWithFinalMethods();
verifyNew(CollaboratorWithFinalMethods.class).withNoArguments();

在下一步中，将期望设置为最终方法：

when(collaborator.helloMethod()).thenReturn("Hello Blogdemo!");

然后执行此方法：

String welcome = collaborator.helloMethod();

以下断言确认已在collaborator对象上调用了helloMethod方法并返回模拟期望设置的值：

Mockito.verify(collaborator).helloMethod();
assertEquals("Hello Blogdemo!", welcome);

如果我们想模拟一个特定的 final 方法而不是对象中的所有 final 方法，*Mockito.spy(T object)*方法可能会派上用场。这在第 5 节中进行了说明。

4. 模拟静态方法

假设我们要模拟一个名为CollaboratorWithStaticMethods的类的静态方法。

下面是我们如何声明这个类：

public class CollaboratorWithStaticMethods {
    public static String firstMethod(String name) {
        return "Hello " + name + " !";
    }
    public static String secondMethod() {
        return "Hello no one!";
    }
    public static String thirdMethod() {
        return "Hello no one again!";
    }
}

为了模拟这些静态方法，我们需要使用PowerMockito API 注册封闭类：

mockStatic(CollaboratorWithStaticMethods.class);

或者，我们可以使用*Mockito.spy(Class<T> class)*方法来模拟一个特定的方法，如下一节所示。

接下来，可以设置期望值来定义方法在调用时应该返回的值：

when(CollaboratorWithStaticMethods.firstMethod(Mockito.anyString()))
  .thenReturn("Hello Blogdemo!");
when(CollaboratorWithStaticMethods.secondMethod()).thenReturn("Nothing special");

或者调用thirdMethod方法时可能会设置抛出异常：

doThrow(new RuntimeException()).when(CollaboratorWithStaticMethods.class);
CollaboratorWithStaticMethods.thirdMethod();

现在是时候运行前两种方法了：

String firstWelcome = CollaboratorWithStaticMethods.firstMethod("Whoever");
String secondWelcome = CollaboratorWithStaticMethods.firstMethod("Whatever");

上面的调用不是调用真实类的成员，而是委托给 mock 的方法。

这些断言证明了 mock 已经生效：

assertEquals("Hello Blogdemo!", firstWelcome);
assertEquals("Hello Blogdemo!", secondWelcome);

我们还能够验证模拟方法的行为，包括调用方法的次数。

在这种情况下，firstMethod被调用了两次，而secondMethod从未被调用过：

verifyStatic(Mockito.times(2));
CollaboratorWithStaticMethods.firstMethod(Mockito.anyString());

verifyStatic(Mockito.never());
CollaboratorWithStaticMethods.secondMethod();

**注意：**必须在任何静态方法验证之前调用 verifyStatic 方法，以便PowerMockito知道连续的方法调用是需要验证的。

最后，静态的thirdMethod方法应该抛出一个RuntimeException，就像之前在 mock 上声明的那样。

它由*@Test注解的expected*元素验证：

@Test(expected = RuntimeException.class)
public void givenStaticMethods_whenUsingPowerMockito_thenCorrect() {
    // other methods

    CollaboratorWithStaticMethods.thirdMethod();
}

5. 部分模拟

PowerMockito API不是模拟整个类，而是允许使用spy方法模拟其中的一部分。

此类将用作协作者来说明 PowerMock 对部分模拟的支持：

public class CollaboratorForPartialMocking {
    public static String staticMethod() {
        return "Hello Blogdemo!";
    }
    public final String finalMethod() {
        return "Hello Blogdemo!";
    }
    private String privateMethod() {
        return "Hello Blogdemo!";
    }
    public String privateMethodCaller() {
        return privateMethod() + " Welcome to the Java world.";
    }
}

让我们从模拟一个静态方法开始，它在上面的类定义中被命名为staticMethod。

首先，我们使用PowerMockito API 部分模拟CollaboratorForPartialMocking类并为其静态方法设置期望：

spy(CollaboratorForPartialMocking.class);
when(CollaboratorForPartialMocking.staticMethod()).thenReturn("I am a static mock method.");

然后执行静态方法：

returnValue = CollaboratorForPartialMocking.staticMethod();

模拟行为得到验证：

verifyStatic();
CollaboratorForPartialMocking.staticMethod();

以下断言通过将返回值与期望值进行比较来确认模拟方法实际上已被调用：

assertEquals("I am a static mock method.", returnValue);

现在是时候继续讨论 final 和 private 方法了。

为了说明这些方法的部分模拟，我们需要实例化该类并告诉PowerMockito API 来监视它：

CollaboratorForPartialMocking collaborator = new CollaboratorForPartialMocking();
CollaboratorForPartialMocking mock = spy(collaborator);

上面创建的对象用于演示最终方法和私有方法的模拟。

我们现在将通过设置期望并调用该方法来处理最终方法：

when(mock.finalMethod()).thenReturn("I am a final mock method.");
returnValue = mock.finalMethod();

证明了部分模拟该方法的行为：

Mockito.verify(mock).finalMethod();

测试验证调用finalMethod方法将返回一个与预期匹配的值：

assertEquals("I am a final mock method.", returnValue);

类似的过程适用于私有方法。主要区别在于我们不能直接从测试用例中调用此方法。

基本上，私有方法由同一类的其他方法调用。在CollaboratorForPartialMocking类中，privateMethod方法由 privateMethodCaller 方法调用，我们将使用后者作为委托。

让我们从期望和调用开始：

when(mock, "privateMethod").thenReturn("I am a private mock method.");
returnValue = mock.privateMethodCaller();

确认私有方法的模拟：

verifyPrivate(mock).invoke("privateMethod");

以下测试确保调用私有方法的返回值与预期相同：

assertEquals("I am a private mock method. Welcome to the Java world.", returnValue);
Updated on 2023-09-19
 Mockito
Back | Home