掌握 PowerMockito 静态方法

一、为什么需要 PowerMockito

在传统的单元测试中，我们使用的是 Junit 等测试框架来完成测试。这些框架往往只能测试到被测类中普通的方法，但很多时候，我们需要测试一些涉及到静态方法、私有方法、构造方法、final 类、enum 等特殊情况的方法。这个时候，传统的单元测试框架就显得力不从心了。

此时，我们就需要借助 PowerMockito，它可以帮助我们绕过一些限制，完成更加全面的测试工作。

二、使用 PowerMockito 绕过静态方法的限制

下面我们以一个具体的案例来介绍 PowerMockito 如何解决无法测试静态方法的问题。

1) 案例描述

现在我们要测试的类是一个日志记录器 Logger，其中有一个静态方法 write，可以将日志信息写入到文件中。

public class Logger {
    public static void write(String message) {
        // 将日志信息写入到文件中
    }
}

假设我们需要测试如下的 Printer 类：

public class Printer {
    public void print(String message) {
        Logger.write(message);
        // 还有其他代码
    }
}

在传统的单元测试框架中，我们无法测试 print 方法中调用的 Logger.write 方法，因为 Logger.write 是一个静态方法。此时，我们需要使用 PowerMockito 来解决这个问题。

2) 解决方法

首先，我们需要在测试类中使用 PowerMockito.mockStatic 方法创建一个被测类中静态方法的 Mock 对象：

@RunWith(PowerMockRunner.class)
@PrepareForTest({Logger.class})
public class PrinterTest {

    @Test
    public void printTest() {
        PowerMockito.mockStatic(Logger.class);
        // 此处省略其他测试代码
    }
}

mockStatic 方法中传入的参数就是我们需要测试的类中的静态方法所在的类名。在本例中，需要测试的类是 Printer，其调用了 Logger.write 静态方法，因此我们传入的参数是 Logger.class。

接下来，我们可以使用 PowerMockito.when(xxx) 和 PowerMockito.verify(xxx) 方法来模拟和验证被测方法中的静态方法的行为：

@RunWith(PowerMockRunner.class)
@PrepareForTest({Logger.class})
public class PrinterTest {

    @Test
    public void printTest() {
        PowerMockito.mockStatic(Logger.class);

        Printer printer = new Printer();
        String message = "hello world";
        printer.print(message);

        PowerMockito.verifyStatic(Logger.class);
        Logger.write(message);
    }
}

在上面的代码中，我们使用 PowerMockito.verifyStatic 方法来验证 Logger.write 方法是否被正确地执行。同时，我们在执行被测方法前，需要先创建一个 Printer 对象，并传入需要打印的信息 message。

三、使用 PowerMockito 绕过私有方法的限制

在进行单元测试时，有时候我们需要测试这个类中的某一个私有方法，但是传统的单元测试框架并不支持测试私有方法。这个时候，我们需要使用 PowerMockito 来解决这个问题。

1) 解决方法

首先，我们需要在测试类中使用 PowerMockito.spy 方法来创建一个被测类的 Spy 对象。Spy 对象是可以调用被测类中的私有方法的。

@RunWith(PowerMockRunner.class)
public class CalculatorTest {

    @Test
    public void testAdd() throws Exception {
        Calculator calculator = new Calculator();
        Calculator calculatorSpy = PowerMockito.spy(calculator);

        // 这里调用 calculatorSpy 中的私有方法
        int result = (int) PowerMockito.invokeMethod(calculatorSpy, "addHelper", 1, 2);

        assertEquals(3, result);
    }
}

在上面的代码中，我们先创建一个 Calculator 对象，然后使用 PowerMockito.spy 方法来创建一个 Calculator 的 Spy 对象 calculatorSpy。接着，我们使用 PowerMockito.invokeMethod 方法来调用 calculatorSpy 中的私有方法 addHelper，并将 1 和 2 作为参数传入。

四、使用 PowerMockito 绕过构造方法的限制

在进行单元测试时，有时候我们需要测试一些没有无参构造函数的类，但是传统的单元测试框架并不支持测试这样的类。这个时候，我们需要使用 PowerMockito 来解决这个问题。

1) 案例描述

现在我们要测试的是一个没有无参构造函数的类 AndroidDevice，它具有一个有参构造函数，接受一个设备名称作为参数：

public class AndroidDevice {
    private String deviceName;

    public AndroidDevice(String deviceName) {
        this.deviceName = deviceName;
    }

    public String getDeviceName() {
        return deviceName;
    }
}

我们在测试中需要创建一个 AndroidDevice 对象，并调用 getDeviceName 方法来验证其正确性。

2) 解决方法

我们可以使用 PowerMockito.whenNew(xxx.class).withArguments(xxx).thenReturn(xxx) 方法来创建一个没有无参构造函数的类的 Mock 对象，并为其设置返回值：

@RunWith(PowerMockRunner.class)
@PrepareForTest({AndroidDevice.class})
public class DeviceManagerTest {

    @Test
    public void testGetDeviceName() throws Exception {
        AndroidDevice androidDeviceMock = PowerMockito.mock(AndroidDevice.class);
        whenNew(AndroidDevice.class).withArguments("设备1").thenReturn(androidDeviceMock);

        DeviceManager deviceManager = new DeviceManager();
        String deviceName = deviceManager.getDeviceName("设备1");

        assertEquals("设备1", deviceName);
    }
}

在上面的代码中，我们首先使用 PowerMockito.mock 方法创建一个 AndroidDevice 的 Mock 对象 androidDeviceMock。然后，我们使用 PowerMockito.whenNew 方法，来模拟 AndroidDevice 类的有参构造方法，并将 “设备1” 作为参数传入，并将 androidDeviceMock 设置为其返回值。

五、使用 PowerMockito 绕过 final 类和 enum 的限制

在进行单元测试时，有时候我们需要测试一些 final 类和 enum，但是传统的单元测试框架并不支持测试这样的类。这个时候，我们需要使用 PowerMockito 来解决这个问题。

1) 解决方法

我们可以使用 PowerMockito.mock 方法来创建 final 类和 enum 的 Mock 对象：

@RunWith(PowerMockRunner.class)
@PrepareForTest({FinalClass.class, EnumClass.class})
public class ClassTest {

    @Test
    public void testFinalClass() {
        FinalClass finalClassMock = PowerMockito.mock(FinalClass.class);
        PowerMockito.when(finalClassMock.finalMethod()).thenReturn("mock");
        String result = finalClassMock.finalMethod();
        assertEquals("mock", result);
    }

    @Test
    public void testEnumClass() {
        EnumClass enumClassMock = PowerMockito.mock(EnumClass.class);
        PowerMockito.when(enumClassMock.getName()).thenReturn("mock");
        String result = enumClassMock.getName();
        assertEquals("mock", result);
    }
}

在上面的代码中，我们分别使用 PowerMockito.mock 方法创建 FinalClass 类和 EnumClass 类的 Mock 对象 finalClassMock 和 enumClassMock。然后，我们使用 PowerMockito.when 方法，来预设 Mock 对象的行为。在测试 FinalClass 类时，我们需要调用 final 方法 finalMethod，因此我们在设置行为时需要使用 finalClassMock.finalMethod()。而在测试 EnumClass 类时，我们需要调用枚举类中的 getName 方法，因此我们在设置行为时需要使用 enumClassMock.getName()。