單元測試中的偽對象

在單元測試的策略中偽對象被廣泛使用。他從測試中分離了外部的不需要的因素并且幫助開發人員專注于被測試的功能。

EasyMock是一個在這方面很有名的工具，可以在運行時為給定的接口創建偽對象。偽對象的行為可以在測試用例中的執行測試代碼之前被定義。EasyMock基于java.lang.reflect.Proxy，他可以根據給定的接口創建動態代理類或者對象。但因為使用Proxy使得他有一個天生的缺陷：只能創建基于接口的偽對象。

Mocquer是一個類似的工具，但他擴展了EasyMock的功能能夠支持創建類的偽對象。

Mocquer介紹
Mocquer基于Dunamis項目，被用來為特定的類或接口生成動態代理類或對象。為方便使用，他遵循EasyMock的類和方法的命名規范，只是在內部使用不同的實現方法。

MockControl是Mocquer項目中最重要的類。他被用來控制偽對象的生命周期和行為定義。這個類中有四類方法。

1、生命周期控制方法：
·public void replay();
·public void verify();
·public void reset();

偽對象在他的生命周期中有三種狀態：準備態、工作態、驗證態。圖1顯示了偽對象的生命周期。


Figure 1. Mock object life cycle

剛開始，偽對象處于準備態，他的表現行為可以在這里定義。replay()將改變偽對象的狀態為工作態。在這個狀態中所有偽對象的方法調用將會遵循在準備態下定義的行為。在verify()調用后，偽對象就處于驗證態。MockControl會比較偽對象的預定義行為與實際行為是否匹配。匹配規則依賴于使用的MockControl類型，這個會在稍后解釋。開發人員可以在需要時調用replay()來重現預定義的行為。而任何狀態下調用reset()將會清除狀態歷史并重置為初始的準備態。

2、工廠方法
·public static MockControl createNiceControl(...);
·public static MockControl createControl(...);
·public static MockControl createStrictControl(...);

Mocquer提供了三種MockControl：寬松的，普通的和嚴格的。開發人員可以在自己的測試用例中根據測試的內容（測試點）和測試的執行方式（測試策略）選擇相應的MockControl。寬松的MockControl是最隨意的，他不關心偽對象中方法調用的順序，甚至未預期的方法調用，只是返回一個缺省值（依賴于方法的返回值）。普通的MockControl比寬松的MockControl嚴格些，未預期的方法調用會導致AssertionFailedError異常。嚴格的MockControl是最嚴格的，如果偽對象在工作態下方法調用的順序與準備態的不同，就會拋出AssertionFailedError異常。下表顯示了三種不同MockControl的區別。


下面是每一個工廠方法的兩個不同版本。
public static MockControl createXXXControl(Class clazz); public static MockControl createXXXControl(Class clazz,     Class[] argTypes, Object[] args);如果類是作為接口來模擬的或者他有一個公共或保護的缺省構造函數，則第一個版本的方法會被使用。否則第二個版本會被用來定義標識和提供參數給期望的構造函數。例如，假設 ClassWithNoDefaultConstructor是一個沒有缺省構造函數的類：     public class ClassWithNoDefaultConstructor {       public ClassWithNoDefaultConstructor(int i) {         ...       }       ...     }·偽對象獲取方法
public Object getMock();

每一個MockControl包含一個生成的偽對象的引用。開發人員可以使用這個方法取得偽對象并且轉換為實際的對象類型。
//get mock control     MockControl control = MockControl.createControl(Foo.class);     //Get the mock object from mock control     Foo foo = (Foo) control.getMock();·行為定義方法
public void setReturnValue(... value);
public void setThrowable(Throwable throwable);
public void setVoidCallable();
public void setDefaultReturnValue(... value);
public void setDefaultThrowable(Throwable throwable);
public void setDefaultVoidCallable();
public void setMatcher(ArgumentsMatcher matcher);
public void setDefaultMatcher(ArgumentsMatcher matcher);

MockControl允許開發人員定義偽對象的每一個方法的行為。當他在準備態時，開發人員可以調用偽對象的方法。首先規定哪一個調用方法的行為需要被定義。然后開發人員可以使用行為定義的方法之一來定義行為。例如，看一下下面的Foo類：
//Foo.java     public class Foo {       public void dummy() throw ParseException {         ...       }       public String bar(int i) {         ...       }       public boolean isSame(String[] strs) {         ...       }       public void add(StringBuffer sb, String s) {         ...       }     }偽對象的行為可以按照下面的方式來定義：
//get mock control     MockControl control = MockControl.createControl(Foo.class);     //get mock object     Foo foo = (Foo)control.getMock();     //begin behavior definition     //specify which method invocation's behavior     //to be defined.     foo.bar(10);     //define the behavior -- return "ok" when the     //argument is 10     control.setReturnValue("ok");     ...     //end behavior definition     control.replay();     ...MockControl中超過50個方法是行為定義方法。他們可以如下分類。

o        setReturnValue()
這些方法被用來定義最后的方法調用應該返回一個值作為參數。這兒有7個使用原始類型作業參數的`setReturnValue()方法，如setReturnValue(int i)或setReturnValue(float f)。setReturnValue(Object obj)被用來滿足那些需要對象作為參數的方法。如果給定的值不匹配方法的返回值，則拋出AssertionFailedError異常。
當然也可以在行為中加入預期調用的次數。這稱為調用次數限制。
      MockControl control = ...       Foo foo = (Foo)control.getMock();       ...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called just once.       setReturnValue("ok", 1);       ... 上面的代碼段定義了bar(10)方法只能被調用一次。如果提供一個范圍又會怎么樣呢？
      ...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called at least once and at most 3       //times.       setReturnValue("ok", 1, 3);       ...現在bar(10)被限制至少被調用一次最多3次。更方便的是Range已經預定義了一些限制范圍。
      ...       foo.bar(10);       //define the behavior -- return "ok" when the       //argument is 10. And this method is expected       //to be called at least once.       setReturnValue("ok", Range.ONE_OR_MORE);       ...Range.ONE_OR_MORE是一個預定義的Range實例，這意味著方法應該被調用至少一次。如果setReturnValue()中沒有定義調用次數限制，如setReturnValue("Hello")，Range.ONE_OR_MORE被認為是缺省值。還有兩個預定義的Range實例，Range.ONE（就一次）和Range.ZERO_OR_MORE（對調用次數沒有限制）。
這兒還有一個特定的設置返回值的方法：setDefaultReturnValue()。他將代替方法的參數值作為返回值，缺省的調用次數限制為Range.ONE_OR_MORE。這被稱為方法參數值敏感性。
      ...       foo.bar(10);       //define the behavior -- return "ok" when calling       //bar(int) despite the argument value.       setDefaultReturnValue("ok");       ...o        setThrowable

setThrowable(Throwable throwable)被用來定義方法調用異常拋出的行為。如果給定的throwable不匹配方法的異常定義，則AssertionFailedError會被拋出。調用次數的限制與方法參數值敏感性是一致的。
      ...       try {         foo.dummy();       } catch (Exception e) {         //skip       }       //define the behavior -- throw ParseException       //when call dummy(). And this method is expected       //to be called exactly once.       control.setThrowable(new ParseException("", 0), 1);       ...o        setVoidCallable()
setVoidCallable()被用于沒有返回值的方法。調用次數的限制與方法參數值敏感性是一致的。
      ...       try {         foo.dummy();       } catch (Exception e) {         //skip       }       //define the behavior -- no return value       //when calling dummy(). And this method is expected       //to be called at least once.       control.setVoidCallable();       ...o        Set ArgumentsMatcher
在工作態時，MockControl會在偽對象的方法被調用時搜索預定義的行為。有三個因素會影響搜索的標準：方法標識，參數值和調用次數限制。第一和第三個因素是固定的。第二個因素可以通過參數值敏感性來忽略。更靈活的是，還可以自定義參數值匹配規則。setMatcher()可以通過ArgumentsMatcher在準備態時使用。
      public interface ArgumentsMatcher {         public boolean matches(Object[] expected,                                Object[] actual);       }ArgumentsMatcher唯一的方法matches()包含兩個參數。一個是期望的參數值數組（如果參數值敏感特性應用時為NULL）。另一個是實際參數值數組。如果參數值匹配就返回真。
      ...       foo.isSame(null);       //set the argument match rule -- always match       //no matter what parameter is given       control.setMatcher(MockControl.ALWAYS_MATCHER);       //define the behavior -- return true when call       //isSame(). And this method is expected       //to be called at least once.       control.setReturnValue(true, 1);       ...MockControl中有三個預定義的ArgumentsMatcher實例。MockControl.ALWAYS_MATCHER在匹配時始終返回真而不管給什么參數值。MockControl.EQUALS_MATCHER會為參數值數組的每一個元素調用equals()方法。MockControl.ARRAY_MATCHER與MockControl.EQUALS_MATCHER基本一致，除了他調用的是Arrays.equals()。當然，開發人員可以實現自己的ArgumentsMatcher。
然而自定義的ArgumentsMatcher有一個副作用是需要定義方法調用的輸出參數值。
      ...       //just to demonstrate the function       //of out parameter value definition       foo.add(new String[]{null, null});       //set the argument match rule -- always       //match no matter what parameter given.       //Also defined the value of out param.       control.setMatcher(new ArgumentsMatcher() {         public boolean matches(Object[] expected,                                Object[] actual) {            ((StringBuffer)actual[0])                               .append(actual[1]);            return true;         }       });       //define the behavior of add().       //This method is expected to be called at       //least once.       control.setVoidCallable(true, 1);       ...setDefaultMatcher()設置MockControl的缺省ArgumentsMatcher實例。如果沒有特定的ArgumentsMatcher，缺省的ArgumentsMatcher會被使用。這個方法應該在任何方法調用行為定義前被調用。否則，會拋出AssertionFailedError異常。
      //get mock control       MockControl control = ...;       //get mock object       Foo foo = (Foo)control.getMock();       //set default ArgumentsMatcher       control.setDefaultMatcher(                      MockControl.ALWAYS_MATCHER);       //begin behavior definition       foo.bar(10);       control.setReturnValue("ok");       ...如果沒有使用setDefaultMatcher()，MockControl.ARRAY_MATCHER就是缺省的ArgumentsMatcher。

一個例子
下面是一個在單元測試中演示Mocquer用法的例子，假設存在一個類FTPConnector。
package org.jingle.mocquer.sample; import java.io.IOException; import java.net.SocketException; import org.apache.commons.net.ftp.FTPClient; public class FTPConnector {     //ftp server host name     String hostName;     //ftp server port number     int port;     //user name     String user;     //password     String pass;     public FTPConnector(String hostName,                         int port,                         String user,                         String pass) {         this.hostName = hostName;         this.port = port;         this.user = user;         this.pass = pass;     }     /**      * Connect to the ftp server.      * The max retry times is 3.      * @return true if suclearcase/" target="_blank" >cceed      */     public boolean connect() {         boolean ret = false;         FTPClient ftp = getFTPClient();         int times = 1;         while ((times <= 3) && !ret) {             try {                 ftp.connect(hostName, port);                 ret = ftp.login(user, pass);             } catch (SocketException e) {             } catch (IOException e) {             } finally {                 times++;             }         }         return ret;     }     /**      * get the FTPClient instance      * It seems that this method is a nonsense      * at first glance. Actually, this method      * is very important for unit test using      * mock technology.      * @return FTPClient instance      */     protected FTPClient getFTPClient() {         return new FTPClient();     } }connect()方法嘗試連接FTP服務器并且登錄。如果失敗了，他可以嘗試三次。如果操作成功返回真。否則返回假。這個類使用org.apache.commons.net.FTPClient來生成一個實際的連接。他有一個初看起來毫無用處的保護方法getFTPClient()。實際上這個方法對使用偽技術的單元測試是非常重要的。我會在稍后解釋。
一個JUnit測試實例FTPConnectorTest被用來測試connect()方法的邏輯。因為我們想要將單元測試環境從其他因素中（如外部FTP服務器）分離出來，因此我們使用Mocquer來模擬FTPClient。
package org.jingle.mocquer.sample; import java.io.IOException; import org.apache.commons.net.ftp.FTPClient; import org.jingle.mocquer.MockControl; import junit.framework.TestCase; public class FTPConnectorTest extends TestCase {     /*      * @see TestCase#setUp()      */     protected void setUp() throws Exception {         super.setUp();     }     /*      * @see TestCase#tearDown()      */     protected void tearDown() throws Exception {         super.tearDown();     }     /**      * test FTPConnector.connect()      */     public final void testConnect() {         //get strict mock control         MockControl control =              MockControl.createStrictControl(                                 FTPClient.class);         //get mock object         //why final? try to remove it         final FTPClient ftp =                     (FTPClient)control.getMock();         //Test point 1         //begin behavior definition         try {             //specify the method invocation             ftp.connect("202.96.69.8", 7010);             //specify the behavior             //throw IOException when call             //connect() with parameters             //"202.96.69.8" and 7010. This method             //should be called exactly three times             control.setThrowable(                             new IOException(), 3);             //change to working state             control.replay();         } catch (Exception e) {             fail("Unexpected exception: " + e);         }         //prepare the instance         //the overridden method is the bridge to         //introduce the mock object.         FTPConnector inst = new FTPConnector(                                   "202.96.69.8",                                   7010,                                   "user",                                   "pass") {             protected FTPClient getFTPClient() {                 //do you understand why declare                 //the ftp variable as final now?                 return ftp;             }         };         //in this case, the connect() should         //return false         assertFalse(inst.connect());         //change to checking state         control.verify();         //Test point 2         try {             //return to preparing state first             control.reset();             //behavior definition             ftp.connect("202.96.69.8", 7010);             control.setThrowable(                            new IOException(), 2);             ftp.connect("202.96.69.8", 7010);             control.setVoidCallable(1);             ftp.login("user", "pass");             control.setReturnValue(true, 1);             control.replay();         } catch (Exception e) {             fail("Unexpected exception: " + e);         }         //in this case, the connect() should         //return true         assertTrue(inst.connect());         //verify again         control.verify();     } }這里創建了一個嚴格的MockObject。偽對象變量有一個final修飾符因為變量會在匿名內部類中使用，否則有產生編譯錯誤。
在這個測試方法中包含兩個測試點。第一個是什么時候FTPClient.connect()始終拋出異常，也就是說FTPClient.connect()返回假。
try {     ftp.connect("202.96.69.8", 7010);     control.setThrowable(new IOException(), 3);     control.replay(); } catch (Exception e) {     fail("Unexpected exception: " + e); }MockControl在調用偽對象connect()方法傳入參數202.96.96.8作為主機地址及7010作為端口號時會拋出IOException異常。這個方法調用預期執行三次。在行為定義后，replay()改變偽對象狀態為工作態。這里的try/catch塊包裹著FTPClient.connect()的定義，因為他定義了拋出IOException異常。
FTPConnector inst = new FTPConnector("202.96.69.8",                                      7010,                                      "user",                                      "pass") {     protected FTPClient getFTPClient() {         return ftp;     } };上面的代碼創建一個重寫了getFTPClient()方法的FTPConnector實例。這樣就橋接了創建的偽對象給用來測試的目標。
assertFalse(inst.connect());

在這里預期connect()應該返回假。
control.verify();

最后，改變偽對象到驗證態。
第二個測試點是什么時候FTPClient.connect()前兩次拋出異常而第三次會成功，這時FTPClient.login()當然也是成功的，這意味著FTPConnector.connect()會返回真。
這個測試點是在前一個測試點之后運行，因此需要將MockObject的狀態通過reset()重新置為準備態。

總結
模擬技術將測試的對象從其他外部因素中分離出來。在JUnit框架中集成模擬技術使得單元測試更加簡單和優雅。EasyMock是一個好的偽裝工具，可以為特定接口創建偽對象。在Dunamis協助下，Mocquer擴展了EasyMock的功能，他可以為類創建偽對象。這篇文章簡單介紹了Mocquer在單元測試中的使用。更多信息可以參考下面的參考資料。

 

原文轉自：http://www.anti-gravitydesign.com