我们将从构建简单的驼鹿监视软件开始示例各种场景下的测试驱动开发。

　　鹿是鹿家族中的最大个的成员。目前世界上估计有2百万头。为了更好的统计，世界驼鹿组织让我们开发一个驼鹿监视软件，希望保护人员能够跟踪和记录他们见到的驼鹿。

本文假设读者已经熟悉java/ant/maven/classpath，而且至少写过一两个简单的junit测试。


vanilla junit

首先编写moose类：
package moose;
import java.util.date;
public class moose {
    private date datetimeobserved;
    private int age;
    
    public moose(date datetimeobservedparam, int estimatedage) {
        this.datetimeobserved = datetimeobservedparam;
        this.age = estimatedage;
    }
}

　　虽然驼鹿最长可以生存25年，但大部分驼鹿在年青的时候就被捕杀，通常只活了2、3年。根据世界驼鹿组织报告，我们想知道某一年龄后的驼鹿数据，因此我们增加了isolderthan(int)方法。
单元测试如下：
    public void testisolderthan() {

        moose moose = new moose(new date(), moose_age);
        
        asserttrue("moose age "+ moose_age +" should of been older than "+ test_age, moose.isolderthan(test_age) );
    }
方法:
    boolean isolderthan(int contenderage) {
        return this.age >= contenderage;
    }
　　这是一个普通的junit测试用例，这种方式通常用在测试驱动的开发中。这种完全独立的方法一般是很少的；通常我们都需要一些代价昂贵的或比较难构建的外部资源。

使用伪对象和jmock

　　观察驼鹿的最佳时间是在黎明和黄昏，跟其他动物的观察时间相似。wom希望我们提供获取记录驼鹿被发现的时间的保护人员，这样就可以通过string getobservername()来获取相应的驼鹿了。

　　不幸地是，保护人员的接口来自第三方接口personnelunit，而这是个大家伙没有ldap我们是无法构造的。

　　为了测试getobservername()，我们可以启动ldap服务器，发送数据，运行测试用例，然后再关闭ldap。但那将是集成测试，而不是单元测试了，对我们来说宁可多写些代码。因此，我们创建了一个包含我们需要方法的ranger接口：
    public interface ranger {
    
        string getname();  
    }
　　这给我们第一个启发式的单元测试：用接口分离外部依赖。
　　我们需要改变moose的构造函数增加ranger参数。于是变成：
    ... above as before...

    private ranger observer;
    
    public moose(   date datetimeobservedparam,
                    int estimatedage,
                    ranger observedby)
    {
        this.datetimeobserved = datetimeobservedparam;
        this.age = estimatedage;
        this.observer = observedby;
    }

    ... below as before ...

　　后面，我们会实现ranger接口作为包含在最终产品中的personnelunit代理。但现在，我们需要的是一个简单实现返回我们所需要名字的实现―记住我们是在测试moose而不是ranger.

　　这种我们通过硬编码或定义方法调用异常的简单实现方式被称为伪对象。伪对象是测试中经常需要的东西，目前有很多可用的类库供你选择。其中最好用的类库之一是jmock。他使用j2se1.3中的动态代理使我们在运行时创建接口实现。

　　为了使用jmock，我们必须首先修改我们的测试类使用权其继承mockobjecttestcase，并且在setup()和teardown()中调用父类中的相应方法：
    public class testmoose extends mockobjecttestcase {

        public void setup() throws exception {
            super.setup();
        }
        
        public void teardown() throws exception {
            super.teardown();
        }
    
    ... the rest as before ...    
使用jmock后，getobservername()的测试就更简单了：
    public void testobservername() {
    
        mock rangermock = mock(ranger.class);
        rangermock.expects( once() ).method("getname").will( returnvalue(ranger_name) );
        
        moose moose = new moose(new date(), moose_age, (ranger) rangermock.proxy() );
        
        assertequals("moose did not report correct ranger", ranger_name, moose.getobservername() );
    }

　　让我们逐行地解释一下：
?mock rangermock = mock(ranger.class);
这行创建了一个mock对象来伪装ranger接口的实现，调用rangermock.proxy()返回ranger

?rangermock.expects( once() ).method("getname").will( returnvalue(ranger_name) );
这里是最有趣的地方。他的用途很明显：告诉mock期望getname()方法仅被调用一次，并且在被调用后应该返回ranger_name的值。在测试的最后，当我们的teardown()方法调用super.teardown()时，我们的父类mockobjecttestcase会检查是否所有期望值都已经满足，否则就会失败。

?  moose moose = new moose(new date(), moose_age, (ranger) rangermock.proxy() );
这行创建moose对象。注意我们是如何获取ranger的实现的，通过调用的mock.proxy()方法。

?assertequals("moose did not report correct ranger", ranger_name, moose.getobservername() );
最后是测试本身。很容易吧。因为ranger接口使用起来很方便，我们并不需要经常这样。

注册模式

　　驼鹿喜欢居住吃水池草，但他们也是别人的猎物。因为驼鹿与别的物种的关系，wom要求我们在发现一只驼鹿的时候给其他的团队发送消息。这些消息将被熊/狼/鹿/水池草的保护人员获取。

　　在项目中的消息系统是一个企业级的服务系统，如tibco rendezvous, ibm mqseries, 或jms的实现。就像personnelunit依赖ldap服务器，这种消息系统的要求也使得测试变的困难。如何才能使这些对象在没有后台的服务系统时存在呢？我们又如何能得到一个这样的消息系统呢？开始的想法是在集成测试中处理，但实际上我们需要的是一个接口和相应的模式。
让我们用一个友好的接口来隐藏消息系统吧：
public interface messenger {

    void sendmessage(string topic, object[] values);
}

　　现在是我们第二个启发式的单元测试：用接口标示服务或角色，因此他们的名字通常心or/er为结尾。
现在，我们需要的是如何获取一个messenger的实现，这相对于寻找驼鹿来说简单多了。如果你使用ioc容器（如spring或hivemind），你已经知道容器会帮你处理messenger实现。否则，使用注册模式（服务定位模式的一种），这是一种简单的全局静态图来映射服务名与其实现。
public class registry {

    private static map registry = new hashmap();
    
    public static void put(string key, object implementation) {
        registry.put(key, implementation);
    }
    
    public static object get(string key) {
        return registry.get(key);
    }
    
}
在代码中，我们这样使用注册：
   messenger messenger = (messenger) registry.get("messenger");
    messenger.sendmessage(a_topic, somevalues);
跟着是测试用例：
    public void testmessageissent() {
    
        date observationdate = new date();
        
        object[] valuearray = new object[] { observationdate, new integer(moose_age) };
        
        mock messenger = mock(messenger.class);
        messenger.expects( once() ).method("sendmessage").with( eq(message_topic), eq(valuearray) );
    
        registry.put( "messenger", messenger.proxy() );
        
        moose moose = new moose(observationdate, moose_age, null );
    }

　　让我们来看一下重要的几行：
? mock messenger = mock(messenger.class);
创建一个实现messenger接口的伪对象。在产品代码中，我们会创建一个与ms, rendezvous或类似需求通讯的实现。

?messenger.expects( once() ).method("sendmessage").with( eq(message_topic), eq(valuearray) );
告诉伪对象期望sendmessage()方法只被调用一次，包含两个值：消息主题和一组消息内容。

?registry.put( "messenger", messenger.proxy() );
注册接口的伪实现。在这里，所有获取来自注册表中messenger的代码会得到我们刚才创建的伪对象。

?moose moose = new moose(observationdate, moose_age, null);
　　最后是我们的测试。我知道这看起来不像是个测试，但在他运行后，会运行teardown()和调用super.teardown()。在那个方法中会检查是否所有期望被满足，否则测试失败。因此如果sendmessage()方法没有调用我们的伪消息器，消息就会失败。

数据库测试

　　我知道你可能会想：“与ldap和消息通讯的确不错，但在实际中，我们通常需要与数据库通讯。”是的，就像我们第一个启发式测试中（通过接口分离外部依赖），让我们简单地用接口来隐藏数据库：
        public interface storagemanager {
            void save(object objecttosave) throws storageexception;
        }
　　将实现放在注册表中，而代码只需要这样写：
        storagemanager storagemanager = (storagemanager) registry.get( registry.storage );
        storagemanager.save( myobject );
　　在这里我们会用storageexception来封装所有实现中的异常。

　　不管用hibernat,jdo或者其他持久层实现，都很容易将你与jdbc分离开来。我知道为每一个创建的对象编写select/insert/update/delete是很无聊的。因此我们可以只写一个hibernatestoragemanager来实现storagemanager并处理其他细节。（如果你必须手写jdbc，mockrunner项目可能对你写单元测试有所帮助）

　　在我们的单元测试中，会创建一个storagemanager伪对象并期望save方法被正确的对象调用。下面的save()的测试方法：
      public void testsave()  throws storageexception {

          // create a mock messenger than ignores any messages it gets
          mock messenger = mock(messenger.class);
          messenger.stubs().method("sendmessage");
          registry.put( registry.messenger, messenger.proxy() );
          
          // create the moose
          moose moose = new moose(new date(), moose_age, null);
          
          // create a mock storagemanager and tell it what will happen when we save the moose
          mock storage = mock(storagemanager.class);
          storage.expects( once() ).method("save").with( same(moose) );
          registry.put(registry.storage, storage.proxy());
          
          // test !
          moose.save();
      }
　　让我们来看一下重要部分。首先我们建立一个messenger桩：
messenger.stubs().method("sendmessage");

　　jmock拥有一次或多次激活的桩。如果桩没有被调用或者被多次调用测试也不会失败。从先前的部分我们知道如何创建一个moose并通过messenger接口来发送消息。这个行为与save()方法无关，我们不希望他影响我们的测试，因此创建一个桩。

　　下一步，我们创建测试的moose对象并在伪对象storagemanager上设置我们的期望值：
storage.expects( once() ).method("save").with( same(moose) );

　　这个看起来很直观。我们期望save()方法被调用一次，而moose对象被作为参数。在内部，same()方法用==来比较对象。而前面使用的eq()方法会使用equals。
最后我们保存的moose:
         moose.save();

　　一旦测试完成，junit会运行teardown()方法来检查所有的期望值是否被满足，否则测试失败。这个测试确保我们在请求moose保存自己的时候，他会将工作代理给storagemanager。

　　当我们实际的storagemanager实现时(如hibernatestoragemanager)，我们会编写集成测试来确保他正确工作。如果两到三个集成测试用例保证hibernatestoragemanager正确工作，那么你所需要在你单元测试中检查的只胡对象需要正确地将保存工作代理给storagemanager。我们测试的保存并不会真正地保存。

小结
　　所有上面的测试用例可以从资源中下载，可阅读旁注“构建样例程序”来运行样例。
　　下面是我在本文中所关注的两个重点：
　　1、使用接口将你的代码与外部资源分离，就像母牛保护她的孩子。
　　2、使用jmock创建这些接口的伪实现。

　　这两个技巧会的用处就像单元测试的用处。就像驼鹿不能出汗因为他们庞大的身体而且热量会通过内脏的发酵过程发散出去，我们在测试中也不需要出汗。