测试工具（三）——jMock 1.2

Jmock 是一个开源的工具，建立在junit，mock object项目之上，是一个非常优秀的测试工具。

接口的模拟

   测试类需要继承 org.jmock.MockObjectTestCase。

  Mock tobeMock=new Mock(xx.class);
  testBean.setXxx(tobeMock);
  tobeMock.expects(once()).method("mockedMethod").withAnyArguments().will(returnValue(returnObj));
  testBean.doTestMethod();

 

   因为Jmock的用途是模拟一个和待测试的方法无关的类或者本类方法，理解这点，上面的程序还是比较容易理解的。

   xx类就是我们要mock的类，testBean是待测试类，mockedMethod就是待测试的方法名称。

   倒数第二行的意思就是执行xx.mockedMethod方法，只执行一次，没有参数(如果有参数，并且参数不变，可以用eq,否则可以用isA,arrayContaining等)，执行后返回结果returnObj,

   下面的testBean.doTestMethod方法肯定调用了xx.mockedMethod方法。这样一来，测试就能专注于testBean..doTestMethod方法，适合于TDD开发模型(Test Directive development).

例子

import com.sarkuya.model.User; 
import junit.framework.*;
import org.jmock.Mock;
import org.jmock.MockObjectTestCase;
public class UserServiceTest extends MockObjectTestCase {
    private UserService userService = new UserServiceImpl();
    
    private Mock userDAO = null;
    
    public UserServiceTest(String testName) {
        super(testName);
    }
    //初始化
    protected void setUp() throws Exception {
        userDAO = new Mock(UserDAO.class);
        userService.setUserDAO((UserDAO)userDAO.proxy());
    }
    
    protected void tearDown() throws Exception {
        userDAO = null;
        userService=null;
    }
    
    public static Test suite() {
        TestSuite suite = new TestSuite(UserServiceTest.class);
        
        return suite;
    }
    
    public void testGetUser() {
        User fakeUser = new User("John"); 
        userDAO.expects(once()).method("getUser").with(eq(1L)).will(returnValue(fakeUser));
        
//        userDAO.expects(atLeastOnce()).method("getUser").with(eq(1L))
//        .will( onConsecutiveCalls(
//            returnValue(fakeUser),
//            returnValue(20),
//            throwException(new IOException("end of stream")) ) );
//        
        User user = userService.getUser(1L);
        assertNotNull(user);
        assertEquals("John", user.getName());
    }
    
    public void testSaveUser() {
        User fakeUser = new User("John");
        
        userDAO.expects(this.once()).method("getUser").with(eq(1L)).will(returnValue(fakeUser));
        User user = userService.getUser(1L);
        assertEquals("John", user.getName());
        
        userDAO.expects(once()).method("saveUser").with(same(fakeUser));
        user.setName("Mike");
        userService.saveUser(user);
        
        userDAO.expects(once()).method("getUser").with(eq(1L)).will(returnValue(user));
        User modifiedUser = userService.getUser(1L);
        assertEquals("Mike", user.getName());
    }
}

此段代码有几点应注意：

   1、此测试类继承了JMock的MockObjectTestCase

   2、private Mock userDAO = null;说明userDao是一个准备虚拟的对象

   3、在setup()中，将userDAO.class传入Mock()后，再通过proxy()方法返回一个UserDAO的代理类实例(即虚拟对象实例)，并赋值于userService

   4、尽管这句代码很长，我们可作如下理解：

       1) userDAO.expects(once())：我们期望userDAO的某方法被执行一次，如果此方法未被执行，或者执行了二次以上，测试就不会通过

       2) method("getUser")：这个期望被执行一次的方法名为userDAO.getUser()

       3) with(eq(1L))：执行getUser()方法时，确认其传入的参数值为“1L”

       4) will(returnValue(fakeUser))：上述条件均满足后，返回一个虚假的对象，即我们前面实例化的fakeUser

    总体来说，当设定好第二行语句后，JMock就在后台监控着，确保userDAO.getUser()必须，且只被执行一次，且参数“1L”已经正确地传给了此方法，一旦这些条件被满足，就返回fakeUser。

    而在第三行，User user = userService.getUser(1L)将触发所有这些条件，作为奖励，它接受了奖品fakeUser并赋值于user对象。而下面第四行及第五行均对此user对象进行测试，不通过才怪。

  5. 第五行userDAO.expects(once()).method("saveUser").with(same(fakeUser))比较特殊。首先，with(same(fakeUser))说明，传入参数必须是fakeUser此实例，尽管我们在下面的语句中通过user.setName("Mike")，但只是改变了其name的属性，而fakeUser的实例引用并未发生改变，因此可以满足条件。其次，其后没有.will(returnValue(fakeUser))，因为userDAO.saveUser()不需要返回任何对象或基本数据类型。

    另外，当再次执行userDAO.expects()时，JMock将重设其监控条件。我们也可以通过userDAO.reset()来显式是清除监控条件。

    通过以上实例代码及其说明，我们看出，用好JMock的关键是先设置监控条件，再写相应的测试语句。一旦设好监控条件后，在某段代码块执行完毕时，如果监控条件未得到满足，或是没有通过expects()再次重设条件，或通过reset()来显式是清除监控条件，测试将无法通过。

非接口的模拟

     需要继承org.jmock.cglib.MockObjectTestCase类，同时新建Mock类的时候需要把变量名作为参数。
     修改上面的类为Service2,其他不变

public class Service2
{
    private UserDAOImpl userDAO;
     

    public void setUserDAO(UserDAOImpl userDAO) {
        this.userDAO = userDAO;
    }
 

    public void saveUser(User user) throws Exception {
        userDAO.saveUser(user);
    }

    public User getUser(long id)
    {
        return userDAO.getUser(id);
    }
}    
测试类如下
import junit.framework.Test;
import junit.framework.TestSuite;

import org.jmock.Mock;
import org.jmock.cglib.MockObjectTestCase;

public class Service2Test extends MockObjectTestCase
{
    private Service2 userService = new Service2();

    private Mock userDAO = null;

    public Service2Test(String testName)
    {
        super(testName);
    }

    protected void setUp() throws Exception
    {
        //注意
        userDAO = mock(UserDAOImpl.class, "userDAO");
        userService.setUserDAO((UserDAOImpl) userDAO.proxy());
    }

    protected void tearDown() throws Exception
    {
    }

    public static Test suite()
    {
        TestSuite suite = new TestSuite(Service2Test.class);

        return suite;
    }

    public void testGetUser()
    {

        User fakeUser = new User("John");
        userDAO.expects(once()).method("getUser").with(eq(1L)).will(returnValue(fakeUser));
        
        User user = userService.getUser(1L);
        assertNotNull(user);
        assertEquals("John", user.getName());
    }

    public void testSaveUser()
    {

        User fakeUser = new User("John");

        userDAO.expects(once()).method("getUser").with(eq(1L)).will(returnValue(fakeUser));
        User user = userService.getUser(1L);
        assertEquals("John", user.getName());

        userDAO.expects(once()).method("saveUser").with(same(fakeUser));
        user.setName("Mike");
        try {
            userService.saveUser(user);
        } catch (Exception e) {
            e.printStackTrace();
        }

        userDAO.expects(once()).method("getUser").with(eq(1L)).will(returnValue(user));
        User modifiedUser = userService.getUser(1L);
        assertEquals("Mike", user.getName());
    }

}

        对于类的Mock，如果有代参数的构造方法，需要把参数和参数类型作为参数，分别和成一个数组。在mock方法中加上就可以了。如下: 

Class [] pClass = {String.class, String.class};
   String pass=...,name=...;
        Object [] pObject = {pass,name};
        userDAO = mock(UserDAOImpl.class, "userDAO",pClass,pObject);