利用 Spring2.5 和 Reflection 简化 mock 测试

spring2.5最大的特色就是全面使用annotation代替xml配置，包括IOC Container、springMVC和 TestContext测试框架等，给我们开发带来了极大的便利。springMVC的新特性在这篇文章里面已经有了比较详尽的介绍，而对于spring的新TestContext测试框架，大家也可以从这里得到详细的例子说明，有兴趣的可以去仔细阅读，本文不再赘述。总而言之，通过spring2.5提供的 annotation，我们可以让我们的类——包括controller，Test等职责特殊的类——更 POJO 化，更易于测试，也提高了 TestCase的开发效率。

在开发过程中，我们通常需要mock特定的对象来测试预期行为，或者使用stub对象来提高单元测试效率。最常见的例子就是在多层webapp中，在controller类的测试方法里mock或 stub底层dao类的方法，从而减轻单元测试时数据库操作的开销，加快单元测试速率。至于Reflection，已不是java的新概念了，各样框架基本上都有使用Reflection来增强Runtime的动态性。而java5里Reflection效率的提升和annotation的引入，更是极大地提高java语言的动态性，让开发人员得到更多Runtime的灵活性。本文将演示如何使用spring2.5和Reflection简化测试中的 mock，使用的JUnit框架是JUnit4.4，mock框架是Easymock2.4。

让我们先看看最原始的使用mock对象的测试（假设基于jdk5进行开发，使用了包括static import，varargs等新特性）： 

1. import static org.easymock.EasyMock.*;
3. public void HelloworldTest extends AbstractSingleSpringContextTests {
4.     private Foo foo = createMock(Foo.class);
5.     private Bar bar = createMock(Bar.class);
6.     private Helloworld helloworld;
7.     
8.     @Before
9.     public void before() {
10.         reset(foo, bar);
11.         helloworld = new Helloworld(foo, bar);
12.     }
13.     
14.     @After
15.     public void after() {
16.         verify(foo, bar);
17.     }
18.     
19.     @Test
20.     public void shouldSayHello() {
21.         //...set expectations about foo/bar
22.         replay(foo, bar);
23.         
24.         helloworld.sayHello();
25.         //...assert verification
26.     }
27.     
28.     //...
29. }

可以看到，因为使用了 Spring 老版本的 TestContext，上面的代码至少有两个方面是需要加强的：
1. 需要大量的 mock 对象创建操作，与真正的 Test Case 无关的繁琐代码，而且还引入了对Spring Context Test 类的继承依赖
2. 针对不同的 Test 类，因为用到不同的 mock 对象，每次都需要显式去指明 reset/replay/verify 用到的 mock 对象

针对上面的两个问题，我们有相应的解决方案来改进：
1. 使用spring来替我们创建mock对象，由spring IOC Container在runtime注入需要的mock对象
2. 提供更通用的rest/replay/verify机制来验证mock对象，而不是每个 Test 类都需要单独处理

1. 每个mock对象都需要手工创建么？答案当然是否定的，我们有FactoryBean。通过在配置文件中指定bean的定义，让spring来替我们创建mock对象。如下是针对Foo类的定义：

<bean id="mockFoo" class="org.easymock.EasyMock" factory-method="createMock">
<constructor-arg index="0" value="Foo"/>
</bean>

< /constructor-arg>与此同时，Spring TestContext框架提供了 @ContextConfiguration annotation 允许开发人员手工指定 Spring 配置文件所在的位置。这样，开发过程中，如果开发人员遵循比较好的配置文件组织结构，可以维护一套只用于测试的对象关系配置，里面只维护测试用到的 mock 对象，以及测试中用到的对 mock 对象有依赖关系的对象。在产品代码中则使用另一套配置文件，配置真实的业务对象。

JUnit4.4 之后，Test 类上可以通过 @RunWith 注解指定测试用例的 TestRunner ，Spring TestContext框架提供了扩展于 org.junit.internal.runners.JUnit4ClassRunner 的 SpringJUnit4ClassRunner，它负责总装 Spring TestContext 测试框架并将其统一到 JUnit 4.4 框架中。这样，你可以把 Test 类上的关于 Spring Test 类的继承关系去掉，并且使用 JUnit4 之后引入的 annotation 去掉其他任何 JUnit3.8 需要的约定和方法继承，让 Test 类更加 POJO。

Test 类也是“纯正” 的 java 对象，自然也可以通过 Spring 来管理依赖关系：在 Test 类的成员变量上加上 @Autowired 声明，使用 SpringJUnit4ClassRunner 运行 Test Case。Spring 会很聪明地帮助我们摆平 Test 依赖的对象，然后再运行已经“合法”的 Test Case，只要你在用于测试的配置文件里面定义了完整的依赖关系，一如其他正常对象。

<bean id="Helloword" class="Helloworld" autowire="byType"/>

这样，经过上面三点变化，例子代码变成了这样：

1. import static org.easymock.EasyMock.*;
3. @RunWith(SpringJUnit4ClassRunner.class)
4. @ContextConfiguration("test-context.xml")
5. public void HelloworldTest {
6.     @Autowired
7.     private Foo foo;
8.     
9.     @Autowired
10.     private Bar bar;
11.     
12.     @Autowired
13.     private Helloworld helloworld;
14.     
15.     @Before
16.     public void before() {
17.         reset(foo, bar);
18.     }
19.     
20.     @After
21.     public void after() {
22.         verify(foo, bar);
23.     }
24.     
25.     @Test
26.     public void shouldSayHello() {
27.         //...set expectations about foo/bar
28.         replay(foo, bar);
29.         
30.         helloworld.sayHello();
31.         //...assert verification
32.     }
33.     
34.     //...
35. }

2. 现在看上去是不是好多了？嗯，对象间的依赖关系和mock对象的创建都由 Spring 来替我们维护，再也不用费心了。不过，reset/verify 是不是还是看上去那么舒服？我们观察一下，通常为了简化对 mock 对象的验证，我们对 Test 类中使用到的 mock 对象都是一起reset/replay /verify，要是能有resetAll()/replayAll()/verifyAll()方法就好了，也省得不同的 Test 类写一大串对不同的 Mock 对象验证的方法。OK，这时候我们就要借助 Reflection 来完成这项任务了：通过 Reflection 得到 Test 类中所有加上 @Autowired 声明的成员变量，验证它们是不是由代理或者字节码增强，从而得到该 Test 类的所有由 Spring 创建的 mock 对象，进行 reset/replay/verify。

根据这个思路，我们引入这样一个 mock 测试的Helper类：

2. import static org.easymock.EasyMock.*;
4. final class MockTestHelper {
6.     public static void resetAll(Object testObject) {
7.         reset(getDeclaredMockedFields(testObject));
8.     }
10.     public static void verifyAll(Object testObject) {
11.         verify(getDeclaredMockedFields(testObject));
12.     }
14.     public static void replayAll(Object testObject) {
15.         replay(getDeclaredMockedFields(testObject));
16.     }
18.     private static Object[] getDeclaredMockedFields(Object testObject) {
19.         Field[] declaredFields = testObject.getClass().getDeclaredFields();
20.         List declaredMockedFields = new ArrayList();
21.         for (Field field : declaredFields) {
22.             if (field.isAnnotationPresent(Autowired.class)) {
23.                 boolean isAccessible = field.isAccessible();
24.                 try {
25.                     field.setAccessible(true);
26.                     Object value = field.get(testObject);
27.                     if (isClassProxy(value.getClass())) {
28.                         declaredMockedFields.add(value);
29.                     }
30.                 } catch (IllegalAccessException e) {
31.                     e.printStackTrace();
32.                 }
33.                 finally {
34.                     field.setAccessible(isAccessible);
35.                 }
36.             }
37.         }
38.         return declaredMockedFields.toArray();
39.     }
41.     private static boolean isClassProxy(Class clazz) {
42.         String className = clazz.getName();
43.         return className.contains("$Proxy") || className.contains("$$EnhancerByCGLIB$$");
44.     }
46. }

好了，有了这么一个 Helper 类，写 mock 对象的Test 类就简单了许多。还是以上面的例子为例，经过这么一重构，变成如下：

1. import static MockTestHelper.*;
3. @RunWith(SpringJUnit4ClassRunner.class)
4. @ContextConfiguration("test-context.xml")
5. public void HelloworldTest {
6.     @Autowired
7.     private Foo foo;
8.     
9.     @Autowired
10.     private Bar bar;
11.     
12.     @Autowired
13.     private Helloworld helloworld;
14.     
15.     @Before
16.     public void before() {
17.         resetAll(this);
18.     }
19.     
20.     @After
21.     public void after() {
22.         verifyAll(this);
23.     }
24.     
25.     @Test
26.     public void shouldSayHello() {
27.         //...set expectations about foo/bar
28.         replay(this);
29.         
30.         helloworld.sayHello();
31.         //...assert verification
32.     }
33.     
34.     //...
35. }

这样看起来就好多了，以后不管在 Test 类里面添加多少个 Test 类需要的 mock 对象，我们都不需要再修改对 mock 对象的验证了，Helper类会自动帮我们完成所有的工作。

综上所述，使用Spring2.5里面引入的 Test Cntext 和 annotations 的确帮助我们减轻了大量的测试代码量，而且让我们的 Test 类更加POJO，更易于让人理解其职责，成为对 feature 的 specification。而 Reflection的小技巧，则能很方便的改进原来代码中不够动态的地方，进一步简化代码量和维护难度。当然我们可以看到，即使这样，代码里面还是有不少resetAll/replayAll/verifyAll的地方，作为 mock 框架带来的一些约束，我们没有办法来省略。这里推荐一种新的 mock 框架—— mockito，是有我的外国同事开发的，它不仅把mock、stub、spy等double的概念区分更清楚，而且让我们的 mock 测试更易写，更易读。

更多敬请期待本博的其他文章。

References：
Spring 2.5：Spring MVC中的新特性：http://www.infoq.com/cn/articles/spring-2.5-ii-spring-mvc
使用 Spring 2.5 TestContext 测试框架：https://www.ibm.com/developerworks/cn/java/j-lo-spring25-test/
mockito project homepage：http://code.google.com/p/mockito/