devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

单元测试实践篇：Mock

作者：Monodyee | 2024-04-19 06:20:56

赞

踩

answers.calls_real_methods

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

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

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

上手

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

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

▐  配置 Maven 依赖

  1.     <dependency>
  2.       <groupId>junit</groupId>
  3.       <artifactId>junit</artifactId>
  4.       <version>4.11</version>
  5.       <scope>test</scope>
  6.     </dependency>
  7.     <dependency>
  8.       <groupId>org.mockito</groupId>
  9.       <artifactId>mockito-core</artifactId>
  10.       <version>3.5.2</version>
  11.       <scope>test</scope>
  12.     </dependency>
  13.     <dependency>
  14.       <groupId>org.powermock</groupId>
  15.       <artifactId>powermock-module-junit4</artifactId>
  16.       <version>2.0.5</version>
  17.       <scope>test</scope>
  18.     </dependency>
  19.     <dependency>
  20.       <groupId>org.powermock</groupId>
  21.       <artifactId>powermock-api-mockito2</artifactId>
  22.       <version>2.0.5</version>
  23.       <scope>test</scope>
  24.     </dependency>
  25.     <dependency>
  26.       <groupId>org.assertj</groupId>
  27.       <artifactId>assertj-core</artifactId>
  28.       <!-- use 2.9.1 for Java 7 projects -->
  29.       <version>3.17.1</version>
  30.       <scope>test</scope>
  31.     </dependency>

▐  Mockito

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

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

  1. import java.util.concurrent.TimeUnit;
  2.  
  3.  
  4. public class MockTarget {
  5.  
  6.  
  7.     public void soSth() {
  8.         System.out.println("do sth.");
  9.     }
  10.  
  11.  
  12.     public String sayHello() {
  13.         return "Hello";
  14.     }
  15.  
  16.  
  17.     public String sayHello(String greetings) {
  18.         return "Hello " + greetings;
  19.     }
  20.  
  21.  
  22.     public String callMethod(Object p) {
  23.         return "callMethod " + p.toString();
  24.     }
  25.  
  26.  
  27.     public String callMethodWait(long million) {
  28.         try {
  29.             TimeUnit.MILLISECONDS.sleep(million);
  30.         } catch (InterruptedException ignored) {
  31.         }
  32.         return "callMethod sleep " + million;
  33.     }
  34.  
  35.  
  36.     public Object callMethodWithException(Object p) {
  37.         throw new IllegalStateException("测试异常");
  38.     }
  39. }

‍

when..then

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

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

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

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

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

    • anyString() 代表任意字符串

    • anyInt() 代表任意int数值 

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

  1.     @Test
  2.     public void testWhenAndThen() {
  3.         MockTarget mock = Mockito.mock(MockTarget.class);
  4.         when(mock.sayHello()).thenReturn("mock hello");
  5.         assertEquals(mock.sayHello(), "mock hello");
  6.  
  7.  
  8.         doCallRealMethod().when(mock).sayHello();
  9.         assertEquals(mock.sayHello(), "Hello");
  10.  
  11.  
  12.         when(mock.sayHello(anyString())).thenAnswer(Answers.CALLS_REAL_METHODS);
  13.         assertEquals(mock.sayHello("testRun"), "Hello testRun");
  14.  
  15.  
  16.         when(mock.callMethod(any())).thenReturn("mock return");
  17.         assertEquals(mock.callMethod(new Object()), "mock return");
  18.  
  19.  
  20.         when(mock.callMethodWithException(any())).thenThrow(new RuntimeException("mock throw exception"), new IllegalArgumentException("test illegal argument"));
  21.  
  22.  
  23.         Assertions.assertThatExceptionOfType(RuntimeException.class)
  24.                 .isThrownBy(() -> mock.callMethodWithException("first invoke"))
  25.                 .withMessage("mock throw exception");
  26.         Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
  27.                 .isThrownBy(() -> mock.callMethodWithException("second invoke"))
  28.                 .withMessage("test illegal argument")
  29.                 .withNoCause();
  30.  
  31.  
  32.         doAnswer((Answer<String>) invocation -> {
  33.             Object[] args = invocation.getArguments();
  34.             MockTarget mock1 = (MockTarget) invocation.getMock();
  35.             return "mock sayHello " + args[0];
  36.         }).when(mock).sayHello("doAnswer");
  37.         assertEquals(mock.sayHello("doAnswer"), "mock sayHello doAnswer");
  38.  
  39.  
  40.         // 1.doNothing, 2. throw RuntimeException
  41.         doNothing().doThrow(RuntimeException.class).when(mock).soSth();
  42.         mock.soSth();
  43.         Assertions.assertThatExceptionOfType(RuntimeException.class).isThrownBy(mock::soSth);
  44.     }

verify

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

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

  1.     @Test
  2.     public void testVerifyInteractions() {
  3.         // mock creation
  4.         List mockedList = mock(List.class);
  5.         mockedList.clear();
  6.         // only clear() invoked
  7.         verify(mockedList, only()).clear();
  8.         verifyNoMoreInteractions(mockedList);
  9.  
  10.  
  11.         // 此处不会抛异常，因为是mock的list对象，非实际list对象
  12.         when(mockedList.get(1)).thenReturn("two");
  13.         assertEquals(mockedList.get(1), "two");
  14.  
  15.  
  16.         // using mock object - it does not throw any "unexpected interaction" exception
  17.         mockedList.add("one");
  18.  
  19.  
  20.         // selective, explicit, highly readable verification
  21.         verify(mockedList).add("one");
  22.         verify(mockedList, times(1)).clear();
  23.         verify(mockedList, atLeastOnce()).add("one");
  24.         verify(mockedList, atMostOnce()).add("one");
  25.         verify(mockedList, atMost(1)).add("one");
  26.         verify(mockedList, atLeast(1)).add("one");
  27.         verify(mockedList, never()).add("never");
  28.     }

‍

verify 之 after 与 timeout

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

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

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

  1.     @Test
  2.     public void testAfterAndTimeout() throws Exception {
  3.         MockTarget mock = mockTarget;
  4.         doCallRealMethod().when(mock).callMethodWait(anyLong());
  5.  
  6.  
  7.         final long timeout = 500L;
  8.         final long delta = 100L;
  9.         // 异步调用
  10.         CompletableFuture<Void> async = CompletableFuture.runAsync(() -> {
  11.             try {
  12.                 TimeUnit.MILLISECONDS.sleep(timeout);
  13.             } catch (InterruptedException ignored) {
  14.             }
  15.             mock.sayHello();
  16.             mock.callMethod("test");
  17.             mock.callMethod("test");
  18.         });
  19.  
  20.  
  21.         // timeout() exits immediately with success when verification passes
  22.         // verify(mock, description("invoke not yet, This will print on failure")).callMethod("test");
  23.         verify(mock, timeout(timeout + delta).times(2)).callMethod("test");
  24.         // immediately success
  25.         verify(mock, timeout(10)).sayHello();
  26.         async.get();
  27.  
  28.  
  29.         // after() awaits full duration to check if verification passes
  30.         verify(mock, after(10).times(2)).callMethod("test");
  31.         verify(mock, after(10)).sayHello();
  32.     }
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 会重置为初始状态(所有中途的赋值都会被清理掉)

  1.     @Test
  2.     public void testDoReturn() {
  3.         // real creation
  4.         List list = new LinkedList();
  5.         List spy = spy(list);
  6.  
  7.  
  8.         //optionally, you can stub out some methods:
  9.         int mockSize = 100;
  10.         when(spy.size()).thenReturn(mockSize);
  11.         //size() method was stubbed - 100 is printed
  12.         assertEquals(spy.size(), mockSize);
  13.  
  14.  
  15.         // Overriding a previous exception-stubbing:
  16.         when(spy.size()).thenThrow(new IllegalStateException("not init"));
  17.         doReturn(mockSize).when(spy).size();
  18.         assertEquals(spy.size(), mockSize);
  19.         //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
  20.         Assertions.assertThatExceptionOfType(IndexOutOfBoundsException.class).isThrownBy(() -> spy.get(0));
  21.         doReturn("mock data").when(spy).get(1);
  22.  
  23.  
  24.         //using the spy calls real methods
  25.         spy.add("one");
  26.         assertEquals(spy.get(0), "one");
  27.  
  28.  
  29.         /*
  30.         Use this method in order to only clear invocations, when stubbing is non-trivial. Use-cases can be:
  31.         You are using a dependency injection framework to inject your mocks.
  32.         The mock is used in a stateful scenario. For example a class is Singleton which depends on your mock.
  33.         Try to avoid this method at all costs. Only clear invocations if you are unable to efficiently test your program.
  34.          */
  35.         clearInvocations(spy);
  36.         verify(spy, times(0)).add("two");
  37.         reset(spy);
  38.         when(spy.size()).thenReturn(0);
  39.         assertEquals(spy.size(), 0);
  40.     }


▐  PowerMock


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

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

  1. public enum TypeEnum {
  2.     Y("TRUE"),
  3.     N("FALSE");
  4.  
  5.  
  6.     private final String title;
  7.  
  8.  
  9.     TypeEnum(String title) {
  10.         this.title = title;
  11.     }
  12.  
  13.  
  14.     public String getTitle() {
  15.         return title;
  16.     }
  17. }
  18.  
  19.  
  20. public final class FinalTarget {
  21.  
  22.  
  23.     public FinalTarget() { }
  24.  
  25.  
  26.     public final String finalMethod() {
  27.         return "Hello final!";
  28.     }
  29.  
  30.  
  31. }
  32.  
  33.  
  34. public class StaticTarget {
  35.  
  36.  
  37.     public static String firstMethod(String name) {
  38.         return "Hello " + name + " !";
  39.     }
  40.  
  41.  
  42.     public static String secondMethod() {
  43.         return "Hello no one!";
  44.     }
  45.  
  46.  
  47. }
  48.  
  49.  
  50. public class PartialTarget {
  51.     private String arg;
  52.  
  53.  
  54.     public PartialTarget(String arg) {
  55.         this.arg = arg;
  56.     }
  57.  
  58.  
  59.     public PartialTarget() { }
  60.  
  61.  
  62.     public String getArg() {
  63.         return arg;
  64.     }
  65.  
  66.  
  67.     private String privateWithArg(String arg) {
  68.         return "Hello privateWithArg! " + arg;
  69.     }
  70.  
  71.  
  72.     public String privateMethodCaller(String arg) {
  73.         return privateWithArg(arg) + " privateMethodCall.";
  74.     }
  75. }
类注解

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

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

‍

static

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

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

verify

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

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

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

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

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

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

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

final

PowerMock 校验 mock final方法

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

enum

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

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

constructor

构造器 mock 与 verify

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

完整示例如下：

  1. import org.assertj.core.api.Assertions;
  2. import org.junit.Assert;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.mockito.Mockito;
  6. import org.powermock.api.mockito.PowerMockito;
  7. import org.powermock.core.classloader.annotations.PrepareForTest;
  8. import org.powermock.modules.junit4.PowerMockRunner;
  9. import org.powermock.reflect.Whitebox;
  10. import static org.hamcrest.core.Is.is;
  11. import static org.mockito.ArgumentMatchers.anyString;
  12. import static org.mockito.Mockito.times;
  13. import static org.powermock.api.mockito.PowerMockito.doCallRealMethod;
  14. import static org.powermock.api.mockito.PowerMockito.verifyNew;
  15. import static org.powermock.api.mockito.PowerMockito.when;
  16. import static org.powermock.api.mockito.PowerMockito.whenNew;
  17.  
  18.  
  19. @RunWith(PowerMockRunner.class)
  20. @PrepareForTest({StaticTarget.class, PartialTarget.class, TypeEnum.class, FinalTarget.class})
  21. public class PowerMockTest {
  22.  
  23.  
  24.     @Test
  25.     public void testStatic() throws Exception {
  26.         PowerMockito.mockStatic(StaticTarget.class);
  27.         String mockResult = "Static mock";
  28.         PowerMockito.when(StaticTarget.firstMethod(anyString())).thenReturn(mockResult);
  29.         String invokeParam = "any String parameter";
  30.         Assert.assertEquals(StaticTarget.firstMethod(invokeParam), mockResult);
  31.  
  32.  
  33.         // Verification of a static method is done in two steps.
  34.         PowerMockito.verifyStatic(StaticTarget.class); // 1
  35.         // StaticTarget.secondMethod();// not invoked
  36.         StaticTarget.firstMethod(invokeParam);// 2
  37.         // use argument matchers
  38.         PowerMockito.verifyStatic(StaticTarget.class); // 1
  39.         StaticTarget.firstMethod(anyString()); // 2
  40.         // atLeastOnce
  41.         PowerMockito.verifyStatic(StaticTarget.class, Mockito.atLeastOnce()); // 1
  42.         StaticTarget.firstMethod(anyString()); // 2
  43.         // times
  44.         PowerMockito.verifyStatic(StaticTarget.class, times(1)); // 1
  45.         StaticTarget.firstMethod(anyString()); // 2
  46.  
  47.  
  48.         // partial mocking of a private method & verifyPrivate
  49.         // PartialTarget partialNoArgSpy = PowerMockito.spy(new PartialTarget());
  50.         PartialTarget partialMock = PowerMockito.mock(PartialTarget.class);
  51.         doCallRealMethod().when(partialMock, "privateMethodCaller", anyString());
  52.         PowerMockito.doReturn("mockResult").when(partialMock, "privateWithArg", any());
  53.         // *privateMethodCaller* will invoke method *privateWithArg*
  54.         String result = partialMock.privateMethodCaller("arg");
  55.         Assert.assertEquals(result, "mockResult privateMethodCall.");
  56.         PowerMockito.verifyPrivate(partialMock, times(1)).invoke("privateWithArg", "arg");
  57.  
  58.  
  59.         // Final
  60.         FinalTarget finalTarget = PowerMockito.mock(FinalTarget.class);
  61.         String finalReturn = "finalReturn";
  62.         PowerMockito.when(finalTarget.finalMethod()).thenReturn(finalReturn);
  63.         Assert.assertThat(finalTarget.finalMethod(), is(finalReturn));
  64.  
  65.  
  66.         // enum
  67.         String mockValue = "mock title";
  68.         TypeEnum typeMock = PowerMockito.mock(TypeEnum.class);
  69.         Whitebox.setInternalState(TypeEnum.class, "N", typeMock);
  70.         when(typeMock.getTitle()).thenReturn(mockValue);
  71.         Assert.assertEquals(TypeEnum.N.getTitle(), mockValue);
  72.         Assert.assertEquals(TypeEnum.Y.getTitle(), "TRUE");
  73.  
  74.  
  75.         // verify New
  76.         String arg = "special arg";
  77.         PartialTarget partialWithArgSpy = PowerMockito.spy(new PartialTarget(arg));
  78.         whenNew(PartialTarget.class).withNoArguments().thenReturn(partialWithArgSpy);
  79.         PartialTarget partialNoArg = new PartialTarget();
  80.         Assert.assertEquals(partialNoArg.getArg(), arg);
  81.         verifyNew(PartialTarget.class).withNoArguments();
  82.  
  83.  
  84.         // throw exception
  85.         PowerMockito.doThrow(new ArrayStoreException("Mock secondMethod error")).when(StaticTarget.class);
  86.         StaticTarget.secondMethod();
  87.         // AssertJ: Exception assertions
  88.         Assertions.assertThatThrownBy(StaticTarget::secondMethod)
  89.                 .isInstanceOf(ArrayStoreException.class)
  90.                 .hasNoCause()
  91.                 .hasMessage("Mock secondMethod error");
  92.     }
  93. }

▐  AssertJ

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

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

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

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

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

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

  1. // AssertJ provides wrappers for common exception types
  2. Assertions.assertThatNoException();
  3. Assertions.assertThatIOException();
  4. Assertions.assertThatNullPointerException();
  5. Assertions.assertThatIllegalStateException();
  6. Assertions.assertThatIllegalArgumentException();

示例如下：

  1. import org.assertj.core.api.Assertions;
  2. import org.junit.Test;
  3. import java.util.Arrays;
  4. import java.util.List;
  5. import static org.assertj.core.api.Assertions.tuple;
  6.  
  7.  
  8. public class AssertTest {
  9.     @Test
  10.     public void testAssertJ() {
  11.         String title = "foo";
  12.         AssertTarget assertTarget = new AssertTarget(title, 12, TypeEnum.Y);
  13.  
  14.  
  15.         String msg = "Illegal Argument error";
  16.         Exception cause = new NullPointerException("cause exception msg");
  17.         Assertions.assertThatExceptionOfType(IllegalArgumentException.class)
  18.                 .isThrownBy(() -> assertTarget.throwIllegalArgumentException(msg, cause))
  19.                 .withMessage(msg)
  20.                 .withMessageContaining("Argument error")
  21.                 .overridingErrorMessage("new error message")
  22.                 .withCause(cause);
  23.  
  24.  
  25.         Assertions.assertThatThrownBy(() -> assertTarget.throwIllegalArgumentException(msg, cause))
  26.                 .isInstanceOf(IllegalArgumentException.class)
  27.                 .hasMessageContaining("Argument error");
  28.  
  29.  
  30.         Assertions.assertThat(assertTarget.getTitle())
  31.                 // as() is used to describe the test and will be shown before the error message
  32.                 .as("PartialTarget's arg is not match", assertTarget.getTitle())
  33.                 .startsWith(title)
  34.                 .endsWith(title)
  35.                 .contains(title)
  36.                 .isNotEqualTo("foo bar")
  37.                 .isEqualToIgnoringCase("FOO")
  38.                 .isEqualTo(title);
  39.  
  40.  
  41.         AssertTarget target1 = new AssertTarget("testTitle", 12, TypeEnum.N);
  42.         AssertTarget target2 = new AssertTarget("titleVal1", 16, TypeEnum.N);
  43.         AssertTarget target3 = new AssertTarget("titleVal2", 18, TypeEnum.Y);
  44.         AssertTarget target4 = new AssertTarget("titleVal3", 20, TypeEnum.N);
  45.         List<AssertTarget> assertTargetRing = Arrays.asList(target1, target2, target3);
  46.  
  47.  
  48.         Assertions.assertThat(target1.getNum()).withFailMessage("the num not matches").isEqualTo(12);
  49.         Assertions.assertThat(target1.getType().equals(TypeEnum.N)).isTrue();
  50.         Assertions.assertThat(target1).isIn(assertTargetRing);
  51.         Assertions.assertThat(target4).isNotIn(assertTargetRing);
  52.         Assertions.assertThat(target4).matches(e -> e.getNum() > 18 && e.getType().equals(TypeEnum.N));
  53.  
  54.  
  55.         Assertions.assertThat(assertTargetRing)
  56.                 // extracting multiple values at once grouped in tuples
  57.                 .extracting("num", "type.title")
  58.                 .contains(tuple(16, TypeEnum.N.getTitle())
  59.                         , tuple(18, TypeEnum.Y.getTitle()));
  60.  
  61.  
  62.         Assertions.assertThat(assertTargetRing)
  63.                 // filtering a collection before asserting
  64.                 .filteredOn(e -> e.getTitle().startsWith("title"))
  65.                 .extracting(AssertTarget::getNum)
  66.                 .contains(16, 18);
  67.  
  68.  
  69.     }
  70. }


真香

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

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

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

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

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

艾玛，真香~

写在最后

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

淘系技术部-商家运营

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

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

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

简历投递邮箱????：xzc270316@alibaba-inc.com

参考文档：


Mockito: https://site.mockito.org

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

✿  拓展阅读

作者|谢志春（志春）

编辑|橙子君

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/450331
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号