在easymock的使用过程中，当创建mock对象时，我们会遇到 strict mock和nice mock的概念。
比如创建mock对象我们通常使用EasyMock.createMock()，但是我们会发现easymock同时提供了两个类似的方法：
EasyMock.createNiceMock()
EasyMock.createStrictMock() 类似的在创建MocksControl时，除了通常的EasyMock.createControl() 外，easymock也同时提供两个类似的方法：
EasyMock.createNiceControl()
EasyMock.createStrictControl()
我们来看看strict和nice有什么作用。参考easymock的javadoc，我们对比createMock()和createStrictMock()：
EasyMock.createMock()： Creates a mock object that implements the given interface, order checking is disabled by default.
EasyMock.createNiceMock() ： Creates a mock object that implements the given interface, order checking is enabled by default.
发现strict mock方式下默认是开启调用顺序检测的，而普通的mock方式则默认不开启调用顺序检测。
再看一下createNiceMock()：
Creates a mock object that implements the given interface, order checking is disabled by default, and the mock object will return 0, null or false for unexpected invocations.
和createMock()相同的是默认不开启调用顺序检测，另外有一个非常有用的功能就是对于意料之外的调用将返回0,null 或者false.之所以说有用，是因为在我们的实际开发过程中，有时候会有这样的需求：对于某个mock对象的调用(可以是部分，也可以是全部)，我们完全不介意调用细节，包括是否调用和调用顺序，参数，返回值，我们只要求mock对象容许程序可以继续而不是抛出异常报告说 unexpected invocations 。nice mock在这种情况下可以为我们节省大量的工作量，非常方便。
我们来看一个简单的实际使用的例子，假设我们有一个Business类，依赖于两个service 接口：
先看只调用一个依赖的情况，注意在record阶段service1.method2()和service1.method1()的顺序和business.executeService1()方法中的实际调用顺序是故意设置为不同的。
public class Business {
private Service1 service1;
private Service2 service2;
public void executeService1() {
service1.method1();
service1.method2();
}
public void executeService1And2() {
service1.method1();
service1.method2();
service2.method3();
service2.method4();
}
public void setService1(Service1 service1) {
this.service1 = service1;
}
public void setService2(Service2 service2) {
this.service2 = service2;
}
}
private interface Service1 {
public void method1();
public void method2();
}
private interface Service2 {
public void method3();
public void method4();
}
1. 普通mock
@Test
public void testMock() {
Business business = new Business();
Service1 service1 = EasyMock.createMock("service1", Service1.class);
business.setService1(service1);
service1.method2();
EasyMock.expectLastCall();
service1.method1();
EasyMock.expectLastCall();
EasyMock.replay(service1);
business.executeService1();
EasyMock.verify(service1);
}
测试案例可以通过，说明EasyMock.createMock()的确是不检测方法的调用顺序。
2. strict mock
@Test
public void testStrictMock() {
Business business = new Business();
Service1 service1 = EasyMock.createStrictMock("service1", Service1.class);
...
}
案例失败，错误信息如下
java.lang.AssertionError:
Unexpected method call service1.method1():
service1.method2(): expected: 1, actual: 0
at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:45)
at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:73)
at net.sourcesky.study.easymock.tutorial.$Proxy4.method1(Unknown Source)
at net.sourcesky.study.easymock.tutorial.OrderTest$Business.executeService1(OrderTest.java:14)
at net.sourcesky.study.easymock.tutorial.OrderTest.testStrictMock(OrderTest.java:79)
......
说明strict mock下，easymock检测到了实际调用时的顺序和预期的不同。
3. nick mock
@Test
public void testNiceMock() {
Business business = new Business();
Service1 service1 = EasyMock.createNiceMock("service1", Service1.class);
...
}
测试案例可以通过，而且如果是nick mock的话，record阶段可以简化：
@Test
public void testNiceMockSimplify() {
Business business = new Business();
Service1 service1 = EasyMock.createNiceMock("service1", Service1.class);
business.setService1(service1);
EasyMock.replay(service1);
business.executeService1();
EasyMock.verify(service1);
}
这个简化版本的测试案例也是可以通过的。
上述的测试案例验证了strict mock和nice mock的基本使用，对于同一个mock对象，strict模式下多个方法之间的调用顺序在record阶段和replay阶段下是需要保持一致的。但是故事并不是到此结束，更有意思的内容在后面：如果出现多个mock对象，那么这些不同mock对象的方法之间，他们的调用顺序是否检测？普通mock和nice mock模式下自然是不会检测顺序，但是strict模式下呢？
我们来看需要测试的方法executeService1And2()，这个方法会依次调用service1和service2的方法。使用easymock测试这个方法，注意我们在record阶段依然故意将方法的调用顺序设置为和实际不同。
1. 不使用control，直接创建两个strict mock对象
@Test
public void testWithoutControlInWrongOrder() {
Business business = new Business();
Service1 service1 = EasyMock.createStrictMock("service1", Service1.class);
Service2 service2 = EasyMock.createStrictMock("service2", Service2.class);
business.setService1(service1);
business.setService2(service2);
service2.method3();
EasyMock.expectLastCall();
service1.method1();
EasyMock.expectLastCall();
EasyMock.replay(service1, service2);
business.executeService1And2();
EasyMock.verify(service1, service2);
}
这个测试案例，出于意外的，通过了。easymock并没有检测service1.method1()和service2.method3()这两个方法的调用顺序。
2. 使用strict control创建两个strict mock对象
@Test
public void testWithStrictControlInWrongOrder() {
Business business = new Business();
IMocksControl mocksControl = EasyMock.createStrictControl();
...
}
案例失败，错误信息为：
java.lang.AssertionError:
Unexpected method call service1.method1():
service2.method3(): expected: 1, actual: 0
at org.easymock.internal.MockInvocationHandler.invoke(MockInvocationHandler.java:45)
at org.easymock.internal.ObjectMethodsFilter.invoke(ObjectMethodsFilter.java:73)
at net.sourcesky.study.easymock.tutorial.$Proxy4.method1(Unknown Source)
at net.sourcesky.study.easymock.tutorial.OrderTest$Business.executeService1And2(OrderTest.java:19)
at net.sourcesky.study.easymock.tutorial.OrderTest.testWithStrictControlInWrongOrder(OrderTest.java:218)
......
OK，easymock终于检测到service1.method1()和service2.method3()这两个方法的调用顺序和期望的不一致了。
解释一下，EasyMock.createStrictMock()方法实际上内部是生成一个新的strict control，然后再创建mock对象。
Service1 service1 = EasyMock.createStrictMock("service1", Service1.class);
Service2 service2 = EasyMock.createStrictMock("service2", Service2.class);
这里实际是创建了两个strict control，而easymock是不会跨control进行顺序检测的。在实际使用过程中，我们会有大量的场景需要检测多个mock之间的调用顺序(按说如果没有特殊要求，一般的测试场景默认都应该如此),这种情况下就必须使用control, 而且必须是同一个strict control才能满足要求。
教程后面的最佳实践中有一条就是推荐使用mock control，可以跨mock对象检测方法调用顺序是一个重要原因。