单元测试实践篇：Mock

淘系的技术发展已经有相当一段历史了，在历史的长河中总能沉淀出很多复杂的巨型项目，包罗多个业务，而且往往服务依赖比较复杂；再加上一些特殊环境变量的设置，想要在本地运行、debug 自测这种大型应用的难度越来越高；尤其是对环境不太熟悉的新人而言成本会更高。

这类应用的单元测试不能像微服务化的应用一样，可以方便的将整个 service 在本地 Run Test，但是依靠于日常开发部署环境的远程 debug、日志、Arthas 等工具定位项目自测联调中的问题又会显得格外的笨重，问题修复几秒钟，发布一次 10min 会成为严重的效率瓶颈。

如何高效的自测代码逻辑，如何不启动整个服务就能验证我的目标方法呢？那就是我今天要介绍的三板斧 Mockito + PowerMock + AssertJ

上手

---

Mock 框架能帮助我们 mock 待测试的类中使用到的外部服务依赖，分布式缓存，DB查询等复杂逻辑，让我们轻松验证待测试类的目标方法的逻辑，当遇到外部依赖时可通过存根 mock 对应的返回结果，从而专注于验证本方法的逻辑正确性，而且跑单元测试不用把整个项目在本地跑起来，只会把当前测试所用到的类加载出来。换言之，Mock 能让代码对外部系统(或复杂依赖)隔离，不需要进行各种初始化操作。在假设外部依赖都能如预期返回的情况下验证自身逻辑的自洽性。

talk is cheap，show me your code.  开始盘它~

▐  配置 Maven 依赖

    
      junit
      junit
      4.11
      test
    
    
      org.mockito
      mockito-core
      3.5.2
      test
    
    
      org.powermock
      powermock-module-junit4
      2.0.5
      test
    
    
      org.powermock
      powermock-api-mockito2
      2.0.5
      test
    
    
      org.assertj
      assertj-core
      
      3.17.1
      test
    

▐  Mockito

Mockito 可以 mock 类的 public 方法或接口的方法。它是通过 cglib 动态生成一个 Proxy，因此在未指定某个方法行为的情况下，会默认返回空值，当然，一个完善的框架肯定会支持直接访问被代理的对象的真实方法的，下文会有介绍，一共会有3种方式哦，我们继续吧。

这里我们使用的 mock 类定义如下：

import java.util.concurrent.TimeUnit;


public class MockTarget {


    public void soSth() {
        System.out.println("do sth.");
    }


    public String sayHello() {
        return "Hello";
    }


    public String sayHello(String greetings) {
        return "Hello " + greetings;
    }


    public String callMethod(Object p) {
        return "callMethod " + p.toString();
    }


    public String callMethodWait(long million) {
        try {
            TimeUnit.MILLISECONDS.sleep(million);
        } catch (InterruptedException ignored) {
        }
        return "callMethod sleep " + million;
    }


    public Object callMethodWithException(Object p) {
        throw new IllegalStateException("测试异常");
    }
}

‍

when..then

用于 mock 方法调用的各种返回情况。

• 通过 doCallRealMethod 指定 mock 对象的方法调用它的真实逻辑，也可通过 thenAnswer(Answers.CALLS_REAL_METHODS) 实现

• 通过 when..thenThrow 或者 doThrow..when 的方式 mock 目标方法返回对应的异常

• 通过 AssertJ 的句法 assertThatExceptionOfType..isThrownBy..withXxx断言某个方法的执行会抛出预期异常

• anyXxx() 可用于表示任意类型的任意参数    

• • anyString() 代表任意字符串

  • anyInt() 代表任意int数值 

  • anyObject() 代表任意类型对象

    @Test
    public void testWhenAndThen() {
        MockTarget mock = Mockito.mock(MockTarget.class);
        when(mock.sayHello()).thenReturn("mock hello");
        assertEquals(mock.sayHello(), "mock hello");


        doCallRealMethod().when(mock).sayHello();
        assertEquals(mock.sayHello(), "Hello");


        when(mock.sayHello(anyString())).thenAnswer(Answers.CALLS_REAL_METHODS);
        assertEquals(mock.sayHello("testRun"), "Hello testRun");


        when(mock.callMethod(any())).thenReturn("mock return");
        assertEquals(mock.callMethod(new Object()), "mock return");


        when(mock.callMethodWithException(any())).thenThrow(new RuntimeException("mock throw exception"), new IllegalArgumentException("test illegal argument"));


        Assertions.assertThatExceptionOfType(RuntimeException.class)
                .isThrownBy(() -> mock.callMethodWithException("first invoke"))
                .withMessage("mock throw exception");
        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
                .isThrownBy(() -> mock.callMethodWithException("second invoke"))
                .withMessage("test illegal argument")
                .withNoCause();


        doAnswer((Answer) invocation -> {
            Object[] args = invocation.getArguments();
            MockTarget mock1 = (MockTarget) invocation.getMock();
            return "mock sayHello " + args[0];
        }).when(mock).sayHello("doAnswer");
        assertEquals(mock.sayHello("doAnswer"), "mock sayHello doAnswer");


        // 1.doNothing, 2. throw RuntimeException
        doNothing().doThrow(RuntimeException.class).when(mock).soSth();
        mock.soSth();
        Assertions.assertThatExceptionOfType(RuntimeException.class).isThrownBy(mock::soSth);
    }

verify

用于验证某个方法是否被调用，包括可以验证该方法被调用的次数，以及等待异步方法调用完成等特性。

常用句式  verify(mockObject  [,  times(n)  ]  ).targetMethod

    @Test
    public void testVerifyInteractions() {
        // mock creation
        List mockedList = mock(List.class);
        mockedList.clear();
        // only clear() invoked
        verify(mockedList, only()).clear();
        verifyNoMoreInteractions(mockedList);


        // 此处不会抛异常，因为是mock的list对象，非实际list对象
        when(mockedList.get(1)).thenReturn("two");
        assertEquals(mockedList.get(1), "two");


        // using mock object - it does not throw any "unexpected interaction" exception
        mockedList.add("one");


        // selective, explicit, highly readable verification
        verify(mockedList).add("one");
        verify(mockedList, times(1)).clear();
        verify(mockedList, atLeastOnce()).add("one");
        verify(mockedList, atMostOnce()).add("one");
        verify(mockedList, atMost(1)).add("one");
        verify(mockedList, atLeast(1)).add("one");
        verify(mockedList, never()).add("never");
    }

‍

verify 之 after 与 timeout

针对异步调用，我们可以通过 after 或 timeout 等待一定时间，来校验目标方法是否有调用，以及在此之后获取目标方法的返回值，作进一步逻辑校验

• after 会阻塞等满时间之后再往下执行，是固定等待多长时间的语义

• timeout 在等待期内，拿到结果后立即向下执行，不做多余等待；是最多等待多长时间的语义

    @Test
    public void testAfterAndTimeout() throws Exception {
        MockTarget mock = mockTarget;
        doCallRealMethod().when(mock).callMethodWait(anyLong());


        final long timeout = 500L;
        final long delta = 100L;
        // 异步调用
        CompletableFuture async = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(timeout);
            } catch (InterruptedException ignored) {
            }
            mock.sayHello();
            mock.callMethod("test");
            mock.callMethod("test");
        });


        // timeout() exits immediately with success when verification passes
        // verify(mock, description("invoke not yet, This will print on failure")).callMethod("test");
        verify(mock, timeout(timeout + delta).times(2)).callMethod("test");
        // immediately success
        verify(mock, timeout(10)).sayHello();
        async.get();


        // after() awaits full duration to check if verification passes
        verify(mock, after(10).times(2)).callMethod("test");
        verify(mock, after(10)).sayHello();
    }

spy

spy 的官方定义是：

partial mocking, real methods are invoked but still can be verified and stubbed

会调用被 spy 的真实对象的方法，但仍能被 Mockiton 所直接用于 mock 和 verify，也就是说在没有配置 mock 行为的情况下默认是调用被 mock 对象的真实方法。

• 句式 doXxx..when 当同一目标方法上定义了多个 mock 行为，后序 mock 可以覆盖前序 mock

• clearInvocations 仅清理之前的调用

• reset 会重置为初始状态(所有中途的赋值都会被清理掉)

    @Test
    public void testDoReturn() {
        // real creation
        List list = new LinkedList();
        List spy = spy(list);


        //optionally, you can stub out some methods:
        int mockSize = 100;
        when(spy.size()).thenReturn(mockSize);
        //size() method was stubbed - 100 is printed
        assertEquals(spy.size(), mockSize);


        // Overriding a previous exception-stubbing:
        when(spy.size()).thenThrow(new IllegalStateException("not init"));
        doReturn(mockSize).when(spy).size();
        assertEquals(spy.size(), mockSize);
        //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
        Assertions.assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> spy.get(0));
        doReturn("mock data").when(spy).get(1);


        //using the spy calls real methods
        spy.add("one");
        assertEquals(spy.get(0), "one");


        /*
        Use this method in order to only clear invocations, when stubbing is non-trivial. Use-cases can be:
        You are using a dependency injection framework to inject your mocks.
        The mock is used in a stateful scenario. For example a class is Singleton which depends on your mock.
        Try to avoid this method at all costs. Only clear invocations if you are unable to efficiently test your program.
         */
        clearInvocations(spy);
        verify(spy, times(0)).add("two");
        reset(spy);
        when(spy.size()).thenReturn(0);
        assertEquals(spy.size(), 0);
    }

▐  PowerMock

以上介绍的是 Mockiton 中常用的API，而 PowerMock 则更强大，可以 mock static 方法，private 方法，final 方法，enum，构造函数调用等。

示例代码中用到的测试类如下：

public enum TypeEnum {
    Y("TRUE"),
    N("FALSE");


    private final String title;


    TypeEnum(String title) {
        this.title = title;
    }


    public String getTitle() {
        return title;
    }
}


public final class FinalTarget {


    public FinalTarget() { }


    public final String finalMethod() {
        return "Hello final!";
    }


}


public class StaticTarget {


    public static String firstMethod(String name) {
        return "Hello " + name + " !";
    }


    public static String secondMethod() {
        return "Hello no one!";
    }


}


public class PartialTarget {
    private String arg;


    public PartialTarget(String arg) {
        this.arg = arg;
    }


    public PartialTarget() { }


    public String getArg() {
        return arg;
    }


    private String privateWithArg(String arg) {
        return "Hello privateWithArg! " + arg;
    }


    public String privateMethodCaller(String arg) {
        return privateWithArg(arg) + " privateMethodCall.";
    }
}

类注解

在使用 PowerMockito mock static , private , final , enum , constructor 之前需要在测试类上加入如下注解：

@RunWith(PowerMockRunner.class)
@PrepareForTest({StaticTarget.class, PartialTarget.class, TypeEnum.class, FinalTarget.class})

‍

static

PowerMockito.mockStatic 声明了要 mock static 方法的类

PowerMockito.mockStatic(StaticTarget.class);
StaticTarget.firstMethod("xxx");

verify

值得注意的是，它的 verify 方法使用比 Mockiton 更复杂。

需要先声明一下验证目标类的静态方法再紧接着调用一下，表示待验证的目标方法

PowerMockito.verifyStatic(StaticTarget.class); // 1
StaticTarget.firstMethod(invokeParam); // 2

也有类似于 Mockiton 的调用次数校验：

PowerMockito.verifyStatic(StaticTarget.class, times(1)); 
PowerMockito.verifyStatic(StaticTarget.class, Mockito.atLeastOnce());

private

PowerMock 模拟 private 方法 "privateWithArg" 的返回值并校验 "privateWithArg" 被调用的次数

PartialTarget partialMock = PowerMockito.mock(PartialTarget.class);
doCallRealMethod().when(partialMock).privateMethodCaller(anyString());
PowerMockito.doReturn("mockResult").when(partialMock, "privateWithArg", any());
// *privateMethodCaller* will invoke method *privateWithArg*
String result = partialMock.privateMethodCaller("arg");
Assert.assertEquals(result, "mockResult privateMethodCall.");
PowerMockito.verifyPrivate(partialMock, times(1)).invoke("privateWithArg", "arg");

final

PowerMock 校验 mock final方法

FinalTarget finalTarget = PowerMockito.mock(FinalTarget.class);
String finalReturn = "finalReturn";
PowerMockito.when(finalTarget.finalMethod()).thenReturn(finalReturn);
Assert.assertThat(finalTarget.finalMethod(), is(finalReturn));

enum

PowerMock mock enum，这里的 Whitebox.setInternalState 可以设置 TypeEnum fieldName=N 的值为给定的 mock 枚举

String mockValue = "mock title";
TypeEnum typeMock = PowerMockito.mock(TypeEnum.class);
Whitebox.setInternalState(TypeEnum.class, "N", typeMock);
when(typeMock.getTitle()).thenReturn(mockValue);
Assert.assertEquals(TypeEnum.N.getTitle(), mockValue);
Assert.assertEquals(TypeEnum.Y.getTitle(), "TRUE");

constructor

构造器 mock 与 verify

String arg = "special arg";
PartialTarget partialWithArgSpy = PowerMockito.spy(new PartialTarget(arg));
whenNew(PartialTarget.class).withNoArguments().thenReturn(partialWithArgSpy);
PartialTarget partialNoArg = new PartialTarget();
Assert.assertEquals(partialNoArg.getArg(), arg);
verifyNew(PartialTarget.class).withNoArguments();

完整示例如下：

import org.assertj.core.api.Assertions;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
import static org.hamcrest.core.Is.is;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.times;
import static org.powermock.api.mockito.PowerMockito.doCallRealMethod;
import static org.powermock.api.mockito.PowerMockito.verifyNew;
import static org.powermock.api.mockito.PowerMockito.when;
import static org.powermock.api.mockito.PowerMockito.whenNew;


@RunWith(PowerMockRunner.class)
@PrepareForTest({StaticTarget.class, PartialTarget.class, TypeEnum.class, FinalTarget.class})
public class PowerMockTest {


    @Test
    public void testStatic() throws Exception {
        PowerMockito.mockStatic(StaticTarget.class);
        String mockResult = "Static mock";
        PowerMockito.when(StaticTarget.firstMethod(anyString())).thenReturn(mockResult);
        String invokeParam = "any String parameter";
        Assert.assertEquals(StaticTarget.firstMethod(invokeParam), mockResult);


        // Verification of a static method is done in two steps.
        PowerMockito.verifyStatic(StaticTarget.class); // 1
        // StaticTarget.secondMethod();// not invoked
        StaticTarget.firstMethod(invokeParam);// 2
        // use argument matchers
        PowerMockito.verifyStatic(StaticTarget.class); // 1
        StaticTarget.firstMethod(anyString()); // 2
        // atLeastOnce
        PowerMockito.verifyStatic(StaticTarget.class, Mockito.atLeastOnce()); // 1
        StaticTarget.firstMethod(anyString()); // 2
        // times
        PowerMockito.verifyStatic(StaticTarget.class, times(1)); // 1
        StaticTarget.firstMethod(anyString()); // 2


        // partial mocking of a private method & verifyPrivate
        // PartialTarget partialNoArgSpy = PowerMockito.spy(new PartialTarget());
        PartialTarget partialMock = PowerMockito.mock(PartialTarget.class);
        doCallRealMethod().when(partialMock, "privateMethodCaller", anyString());
        PowerMockito.doReturn("mockResult").when(partialMock, "privateWithArg", any());
        // *privateMethodCaller* will invoke method *privateWithArg*
        String result = partialMock.privateMethodCaller("arg");
        Assert.assertEquals(result, "mockResult privateMethodCall.");
        PowerMockito.verifyPrivate(partialMock, times(1)).invoke("privateWithArg", "arg");


        // Final
        FinalTarget finalTarget = PowerMockito.mock(FinalTarget.class);
        String finalReturn = "finalReturn";
        PowerMockito.when(finalTarget.finalMethod()).thenReturn(finalReturn);
        Assert.assertThat(finalTarget.finalMethod(), is(finalReturn));


        // enum
        String mockValue = "mock title";
        TypeEnum typeMock = PowerMockito.mock(TypeEnum.class);
        Whitebox.setInternalState(TypeEnum.class, "N", typeMock);
        when(typeMock.getTitle()).thenReturn(mockValue);
        Assert.assertEquals(TypeEnum.N.getTitle(), mockValue);
        Assert.assertEquals(TypeEnum.Y.getTitle(), "TRUE");


        // verify New
        String arg = "special arg";
        PartialTarget partialWithArgSpy = PowerMockito.spy(new PartialTarget(arg));
        whenNew(PartialTarget.class).withNoArguments().thenReturn(partialWithArgSpy);
        PartialTarget partialNoArg = new PartialTarget();
        Assert.assertEquals(partialNoArg.getArg(), arg);
        verifyNew(PartialTarget.class).withNoArguments();


        // throw exception
        PowerMockito.doThrow(new ArrayStoreException("Mock secondMethod error")).when(StaticTarget.class);
        StaticTarget.secondMethod();
        // AssertJ: Exception assertions
        Assertions.assertThatThrownBy(StaticTarget::secondMethod)
                .isInstanceOf(ArrayStoreException.class)
                .hasNoCause()
                .hasMessage("Mock secondMethod error");
    }
}

▐  AssertJ

上面提到的 AssertJ 是 Assert 的一些功能增强，以流式编程的方式调用，下面介绍一些常用的用法

• isIn,isNotIn 和 matches 用于断言匹配条件

• filteredOn 可以针对 assertThat 中传入的参数进行过滤，类似 java8 中Stream() 的 filter 方法

• extracting 可以针对 assertThat 中传入的元组进行字段提取校验

• assertThatExceptionOfType 和 assertThatThrownBy 可用于捕获预期的异常

为了方便使用，AssertJ 还提供了几种常用的异常断言的包装器：

// AssertJ provides wrappers for common exception types
Assertions.assertThatNoException();
Assertions.assertThatIOException();
Assertions.assertThatNullPointerException();
Assertions.assertThatIllegalStateException();
Assertions.assertThatIllegalArgumentException();

示例如下：

import org.assertj.core.api.Assertions;
import org.junit.Test;
import java.util.Arrays;
import java.util.List;
import static org.assertj.core.api.Assertions.tuple;


public class AssertTest {
    @Test
    public void testAssertJ() {
        String title = "foo";
        AssertTarget assertTarget = new AssertTarget(title, 12, TypeEnum.Y);


        String msg = "Illegal Argument error";
        Exception cause = new NullPointerException("cause exception msg");
        Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
                .isThrownBy(() -> assertTarget.throwIllegalArgumentException(msg, cause))
                .withMessage(msg)
                .withMessageContaining("Argument error")
                .overridingErrorMessage("new error message")
                .withCause(cause);


        Assertions.assertThatThrownBy(() -> assertTarget.throwIllegalArgumentException(msg, cause))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("Argument error");


        Assertions.assertThat(assertTarget.getTitle())
                // as() is used to describe the test and will be shown before the error message
                .as("PartialTarget's arg is not match", assertTarget.getTitle())
                .startsWith(title)
                .endsWith(title)
                .contains(title)
                .isNotEqualTo("foo bar")
                .isEqualToIgnoringCase("FOO")
                .isEqualTo(title);


        AssertTarget target1 = new AssertTarget("testTitle", 12, TypeEnum.N);
        AssertTarget target2 = new AssertTarget("titleVal1", 16, TypeEnum.N);
        AssertTarget target3 = new AssertTarget("titleVal2", 18, TypeEnum.Y);
        AssertTarget target4 = new AssertTarget("titleVal3", 20, TypeEnum.N);
        List assertTargetRing = Arrays.asList(target1, target2, target3);


        Assertions.assertThat(target1.getNum()).withFailMessage("the num not matches").isEqualTo(12);
        Assertions.assertThat(target1.getType().equals(TypeEnum.N)).isTrue();
        Assertions.assertThat(target1).isIn(assertTargetRing);
        Assertions.assertThat(target4).isNotIn(assertTargetRing);
        Assertions.assertThat(target4).matches(e -> e.getNum() > 18 && e.getType().equals(TypeEnum.N));


        Assertions.assertThat(assertTargetRing)
                // extracting multiple values at once grouped in tuples
                .extracting("num", "type.title")
                .contains(tuple(16, TypeEnum.N.getTitle())
                        , tuple(18, TypeEnum.Y.getTitle()));


        Assertions.assertThat(assertTargetRing)
                // filtering a collection before asserting
                .filteredOn(e -> e.getTitle().startsWith("title"))
                .extracting(AssertTarget::getNum)
                .contains(16, 18);


    }
}

真香

---

以上针对自己使用的 mock 单元测试的三板斧 Mockito + PowerMock + AssertJ 常用姿势做了小结。

• 利用 Mockiton 做常规类和接口的 mock

• PowerMock 则可以 mock 静态方法，私有方法，final 方法，枚举，构造函数等

• AssertJ 流式风格，增强 assert 判断逻辑和校验异常流程

更多姿势等待大家在实操中继续解锁，利用这些姿势在后续的开发自测中可以更快速的做自我逻辑验证，而我再也不必等待每次项目开发环境的 10min 部署了。

艾玛，真香~

写在最后

---

最后的结尾，介绍一下我们团队吧，最近团队内新增了一条业务线，HC多多，机会多多，欢迎内转和外部投递：

淘系技术部-商家运营

我们是淘系商家运营中台团队，负责淘系千万级商家运营技术体系构建，在这里，你将负责攻克商家域复杂业务模型、海量数据挖掘、高稳定性等带来的技术难题与挑战，打造全市场商家运营技术架构标杆，驱动市场增量价值，并成为最懂商业的技术人。

我们HC不限，可以直接跟老板聊，招聘流程快。期待你的加入，共建To B端最具代表性的商业技术体系，迎接产业互联网的到来。

地点杭州阿里巴巴西溪园区。欢迎各路大侠加入！

简历投递邮箱????：[email protected]

参考文档：

Mockito: https://site.mockito.org

PowerMock: https://powermock.github.io
AssertJ: https://assertj.github.io/doc

✿  拓展阅读

作者|谢志春（志春）

编辑|橙子君

出品|阿里巴巴新零售淘系技术