转到Java之后我还没有系统地学习那些常用的mock框架，平时写代码都是模仿着别人的code东抄抄西抄抄，不会的再去stack overflow找找答案。最近发现很多新人都是这样写单元测试的，然后看看代码库，同一个包里用不同的框架的大有人在。我并不是说这样不好，但是这样很容易误导新人。我遇见过两次有人在写单元测试的时候，annotation用的是一个mock框架，在setup的时候又是用的另一个框架，然后纠结着怎么跑不通，各种错误呢！🤷♀️我自己摸爬滚打了一阵之后，发现写单元测试的时候最好的参考文档并不是别人的代码，而是官方的Tutorial。
于是我开了这个系列，打算讲讲大家常用的JMockit和Mockito等框架，也借此机会系统学习一遍。这里假设读者对单元测试的基本知识、AAA （Arrange, Act, Assert）的三段式以及什么是mock都了解，而且这里的mock框架与你所用的单元测试的框架Junit／TestNG没有关系。
对于每个框架，我会先介绍它的主要的annotation和功能；然后以自己经常写到的use cases举例说明用这个框架该怎么写。
JMockit
JMockit能mock什么？
The type of the mock field or parameter can be any kind of reference type: an interface, a class (including abstract and final ones), an annotation, or an enum.
总的来说JMockit非常强大，只要你想要mock的，它几乎都能做到。虽然在StackOverflow上Mockito被评为“the best mock framework for Java”，但是仍然有很多人更欣赏JMockit (Comparison between Mockito vs JMockit)。可以看到在Slant上也有Mockito和JMockit的比较，那里非常清楚地列出了JMockit的各种优点，而它的唯一缺点是上手慢(Learning curve is a bit steep)而已。在写这篇文章之前，我也是首先Mockito的，但是整个文档看下来，我开始有点儿喜欢JMockit了。
// 除了Mockito的when语句比JMockit的Expectations好看，我想不到别的理由拒绝JMockit了:)
Annotations
- @Tested：用来修饰被测试的类的对象，这个对象会自动被实例化，并且会对被@Injectable修饰的字段进行构造器注入。
- @Injectable: which constrains mocking to the instance methods of a single mocked instance.
一种用于声明mock字段或者参数的方法，用来修饰被测试类中的一些dependency字段，@Injectable修饰的字段会自动注入到@Tested对应的实例中，如果没初始赋值，那么JMockit会以相应规则进行初始化。 - @Mocked: which will mock all methods and constructors on all existing and future instances of a mocked class (for the duration of the tests using it).
一种用于声明mock字段或者参数的方法，与@Injectable不同的是，被它修饰的类实例（所有实例，包括将来创建的）的任何行为（所有的方法和构造函数）都会被mock掉。 - @Capturing: which extends mocking to the classes implementing a mocked interface, or the subclasses extending a mocked class.
一种用于声明mock字段或者参数的方法，使用它修饰的实例可以把mock扩展到被mocked接口的实现，或者被mocked类的子类。
三段式
JMockit中也有一个三段式模型，Record-Replay-Verify model。
Record：准备阶段，先记录下我们期望的即将在测试中被调用的方法的mock行为。
Replay：执行阶段，我们的测试代码被执行，之前准备阶段的记录被重放。
Verify：验证阶段，验证我们期望的调用都预期发生。
Use Cases
话不多说，先贴一段Demo代码，把自己平时用得比较多的需要mock的情况集中起来。（其中一些跟单元测试无关的其他代码没有贴出来）
public class DemoService {
private DependencyY dependencyY;
private DependencyYY dependencyYY;
private DependencyZ dependencyZ;
public DemoService(DependencyZ dependencyZ) {
this.dependencyZ = dependencyZ;
}
public int run() {
DependencyX dependencyX = new DependencyX("inputOfX");
String x = dependencyX.getX();
List<String> y = dependencyY.getY("default");
List<String> list = new ArrayList<>();
for (String s : y) {
try {
list.add(dependencyYY.doSomethingForY(s));
} catch (DemoException ex) {
// Handle the exception
}
}
int index = doSomething(list, x);
if (StaticDependency.isEnabled() && -1 == index) {
dependencyZ.sendNotification("ErrorMessage");
}
StaticDependency.doAnything();
return index;
}
}
下面是用JMockit写的测试代码（环境：Java 8 and JUnit 4）
@RunWith(JMockit.class)
public class DemoServiceTest {
@Tested
private DemoService demoService;
@Mocked
private DependencyX dependencyX;
@Injectable
private DependencyY dependencyY;
@Injectable
private DependencyYY dependencyYY;
@Injectable
private DependencyZ dependencyZ;
@Before
public void setUp() {
new Expectations(StaticDependency.class) {{
StaticDependency.isEnabled(); result = true;
}};
new MockUp<StaticDependency>() {
@Mock
public void doAnything() {
// Do anything here
}
};
}
@Test
public void testDemoService_ShouldGetCorrectIndex_WhenXExistsInY() throws Exception {
new Expectations() {{
//new DependencyX(withSuffix("X")); result = dependencyX;
dependencyX.getX(); result = "str2";
dependencyY.getY(withAny("")); result = Arrays.asList("B", "A", "C");
dependencyYY.doSomethingForY(anyString);
returns("str1", "str2");
result = new DemoService.DemoException[1];
}};
int actualIndex = demoService.run();
Assert.assertEquals(1, actualIndex);
new Verifications() {{
dependencyZ.sendNotification(anyString); times = 0;
}};
}
@Test
public void testDemoService_ShouldSendNotification_WhenXNotExistsInY() throws Exception {
new Expectations() {{
//new DependencyX(withSuffix("X")); result = dependencyX;
dependencyX.getX(); result = "str4";
dependencyY.getY(withNotNull()); result = Arrays.asList("B", "A", "C");
dependencyYY.doSomethingForY((String)any); minTimes = 3;
returns("str1", "str2", "str3");
}};
demoService.run();
new Verifications() {{
String message;
dependencyZ.sendNotification(message = withCapture()); times = 1;
Assert.assertTrue(message.contains("Error"));
StaticDependency.doAnything(); times = 1;
}};
}
}
mock被测对象中的成员有返回值的方法
当被测试对象中的成员是一个外部依赖的时候，以前初始化这个dependency的方式一般是在构造函数里传入一个外部依赖的实例，现在更多的是采用注入技术，如Spring或Google Guice。这种成员一般也是单例模式的，所以我们在测试的时候通常用@Injectable来mock这种成员，直接把它注入到我们要测试的类的实例中。例如，上面DemoService里面的dependencyY，dependencyYY，dependencyZ。
对于@Injectable修饰的成员的有返回值的方法，我们一般在测试的准备阶段（JMockit里的Expectations）会记下我们期望的这个方法的返回结果。
（0）准备外部依赖的方法的返回值，可以在执行测试代码之前new Expectations()里写上我们预期被调用的方法，以及对应的result值，下面的X可以是任何类型的值，只要与对应的方法返回值一致即可。
// In test class
@Injectable
private Dependency dependency;
// In test case method
new Expectations() {{
dependency.method(); result = X;
}};
（1）上面的method()方法没有参数值，如果是有参数列表的方法，则可以在Expectations里面直接写这个方法invoke时的参数值来精确匹配，也可以用any或with方法进行模糊匹配。
new Expectations() {{
dependency.methodWithParameters(1.0, "blah", Arrays.asList("A", "B")); result = X;
// or
dependency.methodWithParameters(anyDouble, anyString, (List<String>)any); result = X;
// or
dependency.methodWithParameters(withAny(1.0), withSubstring("bla"), withNotNull()); result = X;
}};
（2）上面的写法默认是需要在测试执行的时候至少invoke一次，如果多次执行到的话，返回结果都是result里定义的那个。如果我们希望这个方法被多次调用时返回的结果不一样的话，则可以写多个result，或者用returns定义多次返回时的值。例如DemoService里的dependencyYY.doSomethingForY。
new Expectations() {{
dependency.methodMultipleInvoke(anyString);
result = X;
result = Y;
// or
dependency.methodMultipleInvoke(anyString);
returns(X, Y);
}};
（3）当上面的方法被调用非常多次，每次结果都不一样，但是跟参数值相关时。我们不能用（2）中的方法列出所有的返回结果，这个时候可以用 delegates。
new Expectations() {{
dependency.method(anyString);
result = new Delegate() {
int aDelegateMethod(String s) {
return s.length();
}
};
}};
mock被测对象中的成员没有返回值的方法
从上面的语法我们可以看到，在Expectations中我们是通过定义指定方法的result来记录被mock的方法的行为的。那么，如果我们用到的方法是没有返回值的呢？比如，DemoService里面的dependencyZ.sendNotification()。因为它没有返回值，我们测试的对象的最终表现状态与这个mock的方法具体做了什么没有关系，那么我们怎么保证它被合理地调用了呢？答案就是利用Verifications。我们可以在new Verifications()里面定义期望被执行的mock方法。
new Verifications() {{
dependencyZ.sendNotification(withNotNull()); times = 1;
}};
（1）验证一个不该被执行的方法。
new Verifications() {{
dependency.method(anyString); times = 0;
}};
（2）验证一个方法被执行时参数是预期的，可以在参数列表里直接用期望值，也可以先用withCapture()拿到该方法invoke时的参数，然后再进行验证。
new Verifications() {{
dependency.method("ExpectedValue"); times = 1;
// or
String actualValue;
dependency.method(message = withCapture()); times = 1;
Assert.assertEquals("ExpectedValue", actualValue);
}};
（3）当待验证的方法被执行时参数不确定，但是在一定的范围内时可以用with方法进行模糊匹配。
new Verifications() {{
dependency.method(withPrefix("Prefix")); times = 1;
}}
（4）值得注意的是，当一个方法在测试的执行过程中被调用多次的时候，用上面的withCapture()的话，后一次调用时的值会覆盖之前的值。所以，如果想拿到会被多次调用的mock方法的参数值，我们需要用withCapture(List)。
new Verifications() {{
List<String> inputs = new ArrayList<>();
dependency.method(withCapture(inputs)); times = 2;
Assert.assertEquals(2, inputs.size());
}};
（5）withCapture的另一个功能是获取某个类的实例化时的参数列表，虽然很少用到，但是很简单，也顺便提一下。
new Verifications() {{
List<Person> personsInstantiated = withCapture(new Person(anyString, anyInt));
List<Person> personsCreated = new ArrayList<>();
dependency.method(withCapture(personsCreated));
}};
mock static方法
对于有返回值的static方法，可以采用partial mocking的方式直接在Expectations里面像mock其他mocked实例的方法一样，直接定义期望的result即可。
new Expectations(StaticDependency.class) {{
StaticDependency.isEnabled(); result = true;
}};
也可以用MockUp<T>来mock任意的static方法，包括没有返回值的static方法。
new MockUp<StaticDependency>() {
@Mock
public boolean isEnabled() {
return true;
}
@Mock
public void doAnything() {
// Do anything here
}
};
