使用 Python Mock 類進行單元測試

　　數據類型、模型或節點——這些都只是mock對象可承擔的角色。但mock在單元測試中扮演一個什么角色呢？

有時，你需要為單元測試的初始設置准備一些“其他”的代碼資源。但這些資源興許會不可用，不穩定，或者是使用起來太笨重。你可以試着找一些其他的資源替代；或者你可以通過創建一個被稱為mock的東西來模擬它。Mocks能夠讓我們模擬那些在單元測試中不可用或太笨重的資源。

在Python中創建mock是通過Mock模塊完成的。你可以通過每次一個屬性（one-attribute-at-a-time）或一個健全的字典對象或是一個類接口來創建mock。你還可以定義mock的行為並且在測試過程中檢查它的使用。讓我們繼續探討。

 

測試准備

典型的測試准備最少有兩個部分。首先是測試對象（紅色），這是測試的關注點。它可以是一個方法、模塊或者類。它可以返回一個結果，也可以不返回結果，但是它可以根據數據數據或者內部狀態產生錯誤或者異常（圖1）。

圖1

第二測試用例（灰色），它可以單獨運行也可以作為套件的一部分。它是為測試對象准備的，也可以是測試對象需要的任意數據或資源。運行一個或多個測試事務，在每個測試中檢查測試對象的行為。收集測試結果並用一個簡潔、易讀的格式呈現測試結果。

現在，為了發揮作用，一些測試對象需要一個或多個資源（綠色）。這些資源可以是其他的類或者模塊，甚至是一個非獨立的進程。不論其性質，測試資源是功能性的代碼。他們的角色是支持測試對象，但是他們不是測試的關注點。

使用Mock的理由

但是有些時候，測試資源不可用，或者不適合。也許這個資源正在和測試對象並行開發中，或者並不完整或者是太不穩定以至於不可靠。

測試資源太昂貴，如果測試資源是第三方的產品，其高昂的價格不適用於測試。測試資源的建立過於復雜，占用的硬件和時間可以用於別的地方。如果測試資源是一個數據源，建立它的數據集模仿真實世界是乏味的。

測試資源是不可預知的。一個好的單元測試是可重復的，允許你分離和識別故障。但是測試資源可能給出隨機的結果，或者它會有不同的響應時間。而作為這樣的結果，測試資源最終可能成為一個潛在的攪局者。

 這些都是你可能想要用mock代替測試資源的原因。mock向測試對象提供一套和測試資源相同的方法接口。但是mock是更容易創建和管理。它能向測試對象提供和真實的測試資源相同的方法接口。它能提供確定的結果，並可以自定義以適用於特定的測試。能夠容易的更新，以反映實際資源的變化。

當然，mocks不是沒有問題的。設計一個精確的mock是困難的,特別是如果你沒有測試資源的可靠信息。你可以嘗試找到一個開源的接口，或者你能對測試資源的方法接口進行猜測。無論你如何選擇，你都可以在以后輕松的更新mock,你可以在首選資源中得到更詳細的信息。

太多的mock會使測試過於復雜，讓你跟蹤錯誤變得更困難。最好的實踐是每個測試用例限制使用一到兩個mock，或者為每個mock/對象對使用獨立的測試用例。

Mocks對Stubs對Fakes

Mock不是模仿測試資源的唯一方式。其他的解決方案如stub和fake也能提供相同的服務。因此，mock和其他兩種解決方案怎樣比較？為什么選擇mock而不是選擇stub或者fake?

認識stub:stub為測試對象提供了一套方法接口，和真實的測試資源提供給測試對象的接口是相同的。當測試對象調用stub方法時，stub響應預定的結果。也可以產生一個預定的錯誤或者異常。stub可以跟蹤和測試對象的交互，但是它不處理輸入的數據。

fake也提供了一套方法接口並且也可以跟蹤和測試對象的交互。但是和stub不同，fake真正的處理了從測試對象輸入的數據產生的結果是基於這些數據的。簡而言之，fake是功能性的，它是真實測試資源的非生產版。它缺乏資源的相互制衡，使用了更簡單的算法，而且它很少存儲和傳輸數據。

使用fake和stub,你可以輸入正確的數據調用了正確的方法對測試對象進行測試。你能測試對象是如何處理數據並產生結果，當出現錯誤或者異常時是怎樣反應的。這些測試被稱為狀態驗證。但是你是否想知道測試對象調用了兩次相同的方法？你是否想知道測試對象是否按照正確的順序調用了幾個方法？這種測試被稱為行為驗證，而要做到這些，你需要mocks。

使用Python Mock

在Python中Mock模塊是用來創建和管理mock對象的。該模塊是Michael Foord的心血結晶，它是Python3.0的標准模塊。因此在Python2.4~2.7中，你不得不自己安裝這個模塊。你可以 Python Package Index website從獲得Mock模塊最新的版本。

基於你的mock對象，Mock模塊提供了少量的類。為了改變運行中的mock甚至提供了補丁機制。但是現在，我們關注一個類：Mock類。

圖2中顯示了Mock類（綠色）的基本結構。它繼承於兩個父類：NonCallableMock和CallableMixin（灰色）。NonCallableMock定義了mock對象所需的例程。它重載了幾個魔法方法，給他們定義了缺省的行為。為了跟蹤mock的行為，它提供了斷言例程。CallableMixin更新了mock對象回調的魔法方法。反過來，兩個父類繼承於Base類（紅色），聲明了mock對象所需的屬性。

圖2

准備Mock

 

Mock類有四套方法（圖3）。第一套方法是類的構造器，它有六個可選和已標記的參數。圖中顯示了4個經常用到的參數。

圖3

構造器的第一個參數是name，它定義了mock對象的唯一標示符。Listing one顯示了怎么創建一個標示符為Foo的mock對象mockFoo。請注意當我打印mock對象（6-9行）時，標示符后緊跟的是mock對象的唯一ID。

構造器的第一個參數是name，它定義了mock對象的唯一標示符。Listing one顯示了怎么創建一個標示符為Foo的mock對象mockFoo。請注意當我打印mock對象（6-9行）時，標示符后緊跟的是mock對象的唯一ID。

Listing One

from mock import Mock

#create the mock object
mockFoo = Mock(name = "Foo")

print mockFoo

print repr(mockFoo)

構造器的第二個參數是spec。它設置mock對象的屬性，可以是property或者方法。屬性可以是一個列表字符串或者是其他的Python類。

為了演示，在Listing Two中，我有一個帶三個項目的列表對象fooSpec(第4行)：property屬性_fooValue,方法屬性callFoo和doFoo。當我把fooSpec帶入類構造器時（第7行），mockFoo獲得了三個屬性，我能用點操作符訪問它們（10~15行）。當我訪問了一個未聲明的屬性時，mockFoo引發AttributeError和"faulty"屬性（21~14行）。

Listing Two

from mock import Mock
 
# prepare the spec list
fooSpec = ["_fooValue", "callFoo", "doFoo"]
 
# create the mock object
mockFoo = Mock(spec = fooSpec)
 
# accessing the mocked attributes
print mockFoo
# <Mock id='427280'>
print mockFoo._fooValue
# returns <Mock name='mock._fooValue' id='2788112'>
print mockFoo.callFoo()
# returns: <Mock name='mock.callFoo()' id='2815376'>
 
mockFoo.callFoo()
# nothing happens, which is fine
 
# accessing the missing attributes
print mockFoo._fooBar
# raises: AttributeError: Mock object has no attribute '_fooBar'
mockFoo.callFoobar()
# raises: AttributeError: Mock object has no attribute 'callFoobar'

Listing Three顯示了spec參數的另一種用法。這次，有帶三個屬性的類Foo(4~12行)。把類名傳入構造器中，這樣就產生了一個和Foo有相同屬性的mock對象（18~23行）。再次，訪問一個未聲明的屬性引發了AttributeError（29~32行）。也就是說，在兩個例子中，方法屬性時沒有功能的。甚至在方法有功能代碼時，調用mock的方法也什么都不做。

Listing Three

from mock import Mock
 
# The class interfaces
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue    
 
# create the mock object
mockFoo = Mock(spec = Foo)
 
# accessing the mocked attributes
print mockFoo
# returns <Mock spec='Foo' id='507120'>
print mockFoo._fooValue
# returns <Mock name='mock._fooValue' id='2788112'>
print mockFoo.callFoo()
# returns: <Mock name='mock.callFoo()' id='2815376'>
 
mockFoo.callFoo()
# nothing happens, which is fine
 
# accessing the missing attributes
print mockFoo._fooBar
# raises: AttributeError: Mock object has no attribute '_fooBar'
mockFoo.callFoobar()
# raises: AttributeError: Mock object has no attribute 'callFoobar'

 下一個構造器參數是return_value。這將設置mock對象的響應當它被直接調用的時候。我用這個參數模擬一個工廠調用。 

為了演示，在Listing Four中，設置return_value為456（第4行）。當調用mockFoo時，將返回456的結果（9~11行）。在Listing Five中，我給return_value傳入了一個類Foo的實例fooObj（15~19行）。現在，當我調用mockFoo時，我獲得了fooObj的實例（顯示為mockObj）(第24行)。和Listing Two和Three不一樣，mockObj的方法是帶有功能的。

Listing Four

from mock import Mock
 
# create the mock object
mockFoo = Mock(return_value = 456)
 
print mockFoo
# <Mock id='2787568'>
 
mockObj = mockFoo()
print mockObj
# returns: 456

Listing Five

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# creating the mock object
fooObj = Foo()
print fooObj
# returns: <__main__.Foo object at 0x68550>
 
mockFoo = Mock(return_value = fooObj)
print mockFoo
# returns: <Mock id='2788144'>
 
# creating an "instance"
mockObj = mockFoo()
print mockObj
# returns: <__main__.Foo object at 0x68550>
 
# working with the mocked instance
print mockObj._fooValue
# returns: 123
mockObj.callFoo()
# returns: Foo:callFoo_
mockObj.doFoo("narf")
# returns: Foo:doFoo:input =  narf
<Mock id='428560'>

side_effect參數和return_value是相反的。它給mock分配了可替換的結果，覆蓋了return_value。簡單的說，一個模擬工廠調用將返回side_effect值，而不是return_value。 

Listing Six演示了side_effect參數的影響。首先，創建類Foo的實例fooObj，把它傳入return_value參數（第17行）。這個結果和Listing Five是類似的。當它被調用的時候，mockFoo返回fooObj(第22行)。然后我重復同樣的步驟，給side_effect參數傳入StandardError（第28行），現在，調用mockFoo引發了StandardError，不再返回fooObj(29~30行)。

Listing Six

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# creating the mock object (without a side effect)
fooObj = Foo()
 
mockFoo = Mock(return_value = fooObj)
print mockFoo
# returns: <Mock id='2788144'>
 
# creating an "instance"
mockObj = mockFoo()
print mockObj
# returns: <__main__.Foo object at 0x2a88f0>
 
# creating a mock object (with a side effect)
 
mockFoo = Mock(return_value = fooObj, side_effect = StandardError)
mockObj = mockFoo()
# raises: StandardError

Listing Seven顯示了另一個影響。在這個例子中，傳入一個列表對象fooList到類構造器中（17~18行）。然后，每次我調用mockFoo時，它連續的返回列表中的項（20~30行）。一旦mockFoo到達了列表的末尾，調用將引發StopIteration 錯誤（32~34行）

Listing Seven

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# creating the mock object (with a side effect)
fooObj = FooSpec()
 
fooList = [665, 666, 667]
mockFoo = Mock(return_value = fooObj, side_effect = fooList)
 
fooTest = mockFoo()
print fooTest
# returns 665
 
fooTest = mockFoo()
print fooTest
# returns 666
 
fooTest = mockFoo()
print fooTest
# returns 667
 
fooTest = mockFoo()
print fooTest
# raises: StopIteration

你可以傳入其他的可迭代對象（集合，元組）到side_effct對象中。你不能傳入一個簡單對象（如整數、字符串等），因為這些對象是不能迭代的，為了讓簡單對象可迭代，需要將他們加入單一項的列表中。

Mock斷言

Mock類的下一套方法是斷言。它將幫助跟蹤測試對象對mock方法的調用。他們能和unittest模塊的斷言一起工作。能連接到mock或者其方法屬性之一。 有兩個相同的可選參數：一個變量序列，一個鍵/值序列。

第一個斷言assert_called_with()，檢查mock方法是否獲得了正確的參數。當至少一個參數有錯誤的值或者類型時，當參數的數量錯誤時，當參數的順序錯誤時，或者當mock的方法根本不存在任何參數時，這個斷言將引發錯誤。Listing Eight顯示了可以怎樣使用這個斷言。那兒，我准備了一個mock對象，用類Foo作為它的spec參數。我調用了類的方法doFoo()，傳入了一個字符串作為輸入。使用assert_called_with()，我檢查方法是否獲得了正確的輸入。第20行的斷言通過了，因為doFoo()獲得了"narf"的輸入。但是在第24行的斷言失敗了因為doFoo()獲得了"zort"，這是錯誤的輸入。

Listing Eight

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.doFoo("narf")
mockFoo.doFoo.assert_called_with("narf")
# assertion passes
 
mockFoo.doFoo("zort")
mockFoo.doFoo.assert_called_with("narf")
# AssertionError: Expected call: doFoo('narf')
# Actual call: doFoo('zort')

Listing Nine顯示了稍微不同的用法。在這個例子中，我調用了mock方法callFoo()，首先沒有任何輸入，然后輸入了字符串“zort”。第一個斷言通過了（第20行），因為callFoo()不支持獲得任何輸入。而第二個斷言失敗了（第24行）因為顯而易見的原因。

Listing Nine

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.callFoo()
mockFoo.callFoo.assert_called_with()
# assertion passes
 
mockFoo.callFoo("zort")
mockFoo.callFoo.assert_called_with()
# AssertionError: Expected call: callFoo()
# Actual call: callFoo('zort')

先一個斷言是assert_called_once_with()。像assert_called_with()一樣，這個斷言檢查測試對象是否正確的調用了mock方法。但是當同樣的方法調用超過一次時， assert_called_once_with（）將引發錯誤，然而assert_called_with()會忽略多次調用。Listing Ten顯示了怎樣使用這個斷言。那兒，我調用了mock方法callFoo()兩次。第一次調用時（行19~20），斷言通過。但是在第二次調用的時（行23~24），斷言失敗，發送了錯誤消息到stdout。

Listing Ten

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.callFoo()
mockFoo.callFoo.assert_called_once_with()
# assertion passes
 
mockFoo.callFoo()
mockFoo.callFoo.assert_called_once_with()
# AssertionError: Expected to be called once. Called 2 times.

斷言assert_any_call()，檢查測試對象在測試例程中是否調用了測試方法。它不管mock方法和斷言之間有多少其他的調用。和前面兩個斷言相比較，前兩個斷言僅檢查最近一次的調用。

Listing Eleven顯示了assert_any_call()斷言如何工作：仍然是同樣的mock對象，spec參數是Foo類。第一個調用方法callFoo()（第18行），接下來調用兩次doFoo()(行19~20)。注意doFoo()獲得了兩個不同的輸入。

Listing Eleven

<from mock import Mock
 
# The mock specification
class Foo(object):
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.callFoo()
mockFoo.doFoo("narf")
mockFoo.doFoo("zort")
 
mockFoo.callFoo.assert_any_call()
# assert passes
 
mockFoo.callFoo()
mockFoo.doFoo("troz")
 
mockFoo.doFoo.assert_any_call("zort")
# assert passes
 
mockFoo.doFoo.assert_any_call("egad")
# raises: AssertionError: doFoo('egad') call not found

第一個assert_any_call()（第22行）通過，雖然兩次doFoo()調用隔開了斷言和callFoo()。第二個斷言（第28行）也通過了，雖然一個callFoo()隔開了我們提到的doFoo()(第20行)。另一方面，第三個斷言（第31行）失敗了，因為沒有任何doFoo()的調用使用了"egad"的輸入。

最后，還有assert_has_calls（）。它查看方法調用的順序，檢查他們是否按正確的次序調用並帶有正確的參數。它帶有兩個參數：期望調用方法的列表和一個可選懸殊any_order。當測試對象調用了錯誤的方法，調用了不在次序中的方法，或者方法獲得了一個錯誤的輸入，將生產斷言錯誤。

Listing Twelve演示了assert_has_calls()斷言。在18~20行，我調用了三個方法，提供了兩個輸入。然后，我准備了一個期望調用的列表（fooCalls）並把這個列表傳入assert_has_calls()（22~23行）。由於列表匹配了方法的調用，斷言通過。

Listing Twelve

from mock import Mock, call
 
# The mock specification
class Foo(object):
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.callFoo()
mockFoo.doFoo("narf")
mockFoo.doFoo("zort")
 
fooCalls = [call.callFoo(), call.doFoo("narf"), call.doFoo("zort")]
mockFoo.assert_has_calls(fooCalls)
# assert passes
 
fooCalls = [call.callFoo(), call.doFoo("zort"), call.doFoo("narf")]
mockFoo.assert_has_calls(fooCalls)
# AssertionError: Calls not found.
# Expected: [call.callFoo(), call.doFoo('zort'), call.doFoo('narf')]
# Actual: [call.callFoo(), call.doFoo('narf'), call.doFoo('zort')]
 
fooCalls = [call.callFoo(), call.doFoo("zort"), call.doFoo("narf")]
mockFoo.assert_has_calls(fooCalls, any_order = True)

在第26行，我交換了兩個doFoo()調用的順序。第一個doFoo()獲得"zort"的輸入，第二個獲得了"narf"。如果我傳入這個fooCalls到assert_has_calls()（第27行）中，斷言失敗。但是如果我給參數any_order傳入參數True，斷言通過。這是因為斷言將忽略方法調用的順序。

 

Listing Thirteen演示了其他的用法。在fooCalls列表中，我添加了不存在的方法dooFoo()（第22行）。然后我傳入fooCalls到assert_has_calls()中（第24行）。斷言失敗，通知我期望調用的順序和真實發生的順序不匹配。如果我給any_order賦值為True（第30行），斷言名稱dooFoo()作為違規的方法調用。

Listing Thirteen

from mock import Mock, call
 
# The mock specification
class Foo(object):
    _fooValue = 123
     
    def callFoo(self):
        pass
     
    def doFoo(self, argValue):
        pass
 
# create the mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo.callFoo()
mockFoo.doFoo("narf")
mockFoo.doFoo("zort")
 
fooCalls = [call.callFoo(), call.dooFoo("narf"), call.doFoo("zort")]
 
mockFoo.assert_has_calls(fooCalls)
# AssertionError: Calls not found.
# Expected: [call.callFoo(), call.dooFoo('narf'), call.doFoo('zort')]
# Actual: [call.callFoo(), call.doFoo('narf'), call.doFoo('zort')]
 
fooCalls = [call.callFoo(), call.dooFoo("narf"), call.doFoo("zort")]
mockFoo.assert_has_calls(fooCalls, any_order = True)
# AssertionError: (call.dooFoo('narf'),) not all found in call list

在assert_has_calls()的兩個例子中，注意到關鍵字call是出現在每個方法的前面。這個關鍵字是一個helper對象，標記出mock對象的方法屬性。為了使用call關鍵字，請確保使用如下的方法從mocke模塊導入helper：

from mock import Mock, call

管理Mock

Mock類的第三套方法允許你控制和管理mock對象。你可以更改mock的行為，改變它的屬性或者將mock恢復到測試前的狀態。你甚至可以更改每個mock方法或者mock本身的響應值。attach_mock()方法讓你在mock中添加第二個mock對象。這個方法帶有兩個參數：第二個mock對象(aMock)和一個屬性名稱(aName)。

Listing Fourteen 樣式了attach_mock（）方法的使用。那兒，我創建了兩個mock對象mockFoo和mockBar,他們有不同spec參數（第25行和第30行）。我用attach_mock()方法將mockBar添加到mockFoo中，命名為fooBar(第35行)。一旦添加成功，我就能通過property fooBar訪問第二mock對象和它的屬性（46~53行）。並且我仍然可以訪問第一個mock對象mockFoo的屬性。

Listing Fourteen

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
class Bar(object):
    # instance properties
    _barValue = 456
     
    def callBar(self):
        pass
     
    def doBar(self, argValue):
        pass
 
# create the first mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
# create the second mock object
mockBar = Mock(spec = Bar)
print mockBar
# returns: <Mock spec='Bar' id='2784400'>
 
# attach the second mock to the first
mockFoo.attach_mock(mockBar, 'fooBar')
 
# access the first mock's attributes
print mockFoo
# returns: <Mock spec='Foo' id='495312'>
print mockFoo._fooValue
# returns: <Mock name='mock._fooValue' id='428976'>
print mockFoo.callFoo()
# returns: <Mock name='mock.callFoo()' id='448144'>
 
# access the second mock and its attributes
print mockFoo.fooBar
# returns: <Mock name='mock.fooBar' spec='Bar' id='2788592'>
print mockFoo.fooBar._barValue
# returns: <Mock name='mock.fooBar._barValue' id='2788016'>
print mockFoo.fooBar.callBar()
# returns: <Mock name='mock.fooBar.callBar()' id='2819344'>
print mockFoo.fooBar.doBar("narf")
# returns: <Mock name='mock.fooBar.doBar()' id='4544528'>

configure_mock()方法讓你批量的更改mock對象。它唯一的參數是一個鍵值對序列，每個鍵就是你想要修改的屬性。如果你的對象沒有指定的屬性，configure_mock()將在mock中添加屬性。 

 

Listing fifteen顯示了configure_mock()方法的運用。再次，我定義了一個spec為類Foo和return_value為555的mock對象mockFoo（第13行）。然后使用configure_mock()方法更改return_value為999（第17行）。當我直接調用mockFoo時，獲得的結果為999，替換了原來的555。

Listing Fifteen

from mock import Mock
 
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
mockFoo = Mock(spec = Foo, return_value = 555)
print mockFoo()
# returns: 555
 
mockFoo.configure_mock(return_value = 999)
print mockFoo()
# returns: 999
 
fooSpec = {'callFoo.return_value':"narf", 'doFoo.return_value':"zort", 'doFoo.side_effect':StandardError}
mockFoo.configure_mock(**fooSpec)
 
print mockFoo.callFoo()
# returns: narf
print mockFoo.doFoo("narf")
# raises: StandardError
 
fooSpec = {'doFoo.side_effect':None}
mockFoo.configure_mock(**fooSpec)
print mockFoo.doFoo("narf")
# returns: zort

接着，我准備了一個字段對象(fooSpec)，對兩個mock方法設置了返回值，為doFoo()設置了side_effect（第21行）。我將fooSpec傳入configure_mock()，注意fooSpec帶有前綴'**'（第22行）。現在調用callFoo()結果返回“narf”。調用doFoo()，無論輸入什么，引發StandardError 信號（行24~27）。如果我修改了fooSpec，設置doFoo(）的side_effect的值為None,當我調用doFoo()時，將得到結果“zort”（29~32行）。

 

下一個方法mock_add_spec()讓你向mock對象添加新的屬性。除了mock_add_spec()工作在一個已存在的對象上之外，它的功能類似於構造器的spec參數。它擦除了一些構造器設置的屬性。這個方法帶有兩個參數：spec屬性（aSpec）和spc_set標志（aFlag）。再次，spce可以是字符串列表或者是類。已添加的屬性缺省狀態是只讀的，但是通過設置spec_set標志為True，可以讓屬性可寫。

Listing Sixteen演示了mock_add_spec()的運用。mock對象mockFoo開始的屬性來自於類Foo(第25行)。當我訪問兩個屬性（_fooValue和callFoo()）時，我得到結果確認他們是存在的（29~32行）。

Listing Sixteen

from mock import Mock
 
# The class interfaces
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
class Bar(object):
    # instance properties
    _barValue = 456
     
    def callBar(self):
        pass
     
    def doBar(self, argValue):
        pass
     
# create the mock object
mockFoo = Mock(spec = Foo)
 
print mockFoo
# returns <Mock spec='Foo' id='507120'>
print mockFoo._fooValue
# returns <Mock name='mock._fooValue' id='2788112'>
print mockFoo.callFoo()
# returns: <Mock name='mock.callFoo()' id='2815376'>
 
# add a new spec attributes
mockFoo.mock_add_spec(Bar)
 
print mockFoo
# returns: <Mock spec='Bar' id='491088'>
print mockFoo._barValue
# returns: <Mock name='mock._barValue' id='2815120'>
print mockFoo.callBar()
# returns: <Mock name='mock.callBar()' id='4544368'>
 
print mockFoo._fooValue
# raises: AttributeError: Mock object has no attribute '_fooValue'
print mockFoo.callFoo()
# raises: AttributeError: Mock object has no attribute 'callFoo'

然后，我使用mock_add_spec()方法添加類Bar到mockFoo(第35行)。mock對象現在的屬性已聲明在類Bar中（39~42行）。如果我訪問任何Foo屬性，mock對象將引發AttributeError 信號，表示他們不存在（44~47行）。

 

最后一個方法resetMock()，恢復mock對象到測試前的狀態。它清除了mock對象的調用統計和斷言。它不會清除mock對象的return_value和side_effect屬性和它的方法屬性。這樣做是為了重新使用mock對象避免重新創建mock的開銷。

最后，你能給每個方法屬性分配返回值或者side-effect。你能通過return_value和side_effect訪問器做到這些。例如，按如下的語句通過return_value訪問器設置方法callFoo()的返回值為"narf"：

mockFoo.callFoo.return_value = "narf"

按如下的語句通過side_effect訪問器 設置方法callFoo()的side-ffect為TypeError

mockFoo.callFoo.side_effect = TypeError

傳入None清除side-effect

mockFoo.callFoo.side_effect = None

你也可以用這個兩個相同的訪問器改變mock對象對工廠調用的響應值。 

 

Mock統計

最后一套方法包含跟蹤mock對象所做的任意調用的訪問器。當mock對象獲得工廠調用時，訪問器called返回True，否則返回False。查看Listing Seventeen中的代碼，我創建了mockFoo之后，called訪問器返回了結果False(19~20行)。如果我做了一個工廠調用，它將返回結果True(22~23行)。但是如果我創建了第二個mock對象，然后調用了mock方法callFoo()（第30行）?在這個例子中，called訪問器僅僅放回了False結果（31~32行）。

Listing Seventeen

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
print mockFoo.called
# returns: False
 
mockFoo()
print mockFoo.called
# returns: True
 
mockFoo = Mock(spec = Foo)
print mockFoo.called
# returns: False
 
mockFoo.callFoo()
print mockFoo.called
# returns: False

訪問器call_count給出了mock對象被工廠調用的次數。查看Listing Eighteen中的代碼。我創建mockFoo之后，call_count給出的期望結果為0(19~20行)。當我對mockFoo做了一個工廠調用時，call_count增加1（22~24行）。當我調用mock方法callFoo()時，call_count沒有改變（26~28行）。如果我做了第二次工廠調用call_count將再增加1。

Listing Eighteen

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo)
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
print mockFoo.call_count
# returns: 0
 
mockFoo()
print mockFoo.call_count
# returns: 1
 
mockFoo.callFoo()
print mockFoo.call_count
# returns: 1

訪問器call_args返回工廠調用已用的參數。Listing Nineteen演示了它的運用。對於新創建的mock對象(mockFoo)，call_args訪問器返回結果為None(17~21行)。如果我做了一個工廠調用，在輸入中傳入"zort"，call_args報告的結果為call('zort')（23~25行）。注意結果中的call關鍵字。對於第二個沒有輸入的工廠調用，call_args返回call()（27~29行）。第三個工廠調用，輸入“troz”，call_args給出結果為call('troz')（31~33行）。但是當我調用mock方法callFoo()時，call_args訪問器仍然返回call('troz')（35~37行）。

Listing Nineteen

#!/usr/bin/python
 
from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo, return_value = "narf")
print mockFoo
# returns <Mock spec='Foo' id='507120'>
print mockFoo.call_args
# returns: None
 
mockFoo("zort")
print mockFoo.call_args
# returns: call('zort')
 
mockFoo()
print mockFoo.call_args
# returns: call()
 
mockFoo("troz")
print mockFoo.call_args
# returns: call('troz')
 
mockFoo.callFoo()
print mockFoo.call_args
# returns: call('troz')

訪問器call_args_list 也報告了工廠調用中已使用的參數。但是call_args返回最近使用的參數，而call_args_list返回一個列表，第一項為最早的參數。Listing Twenty顯示了這個訪問的的運用，使用了和Listing Nineteen相同的代碼。

Listing Twenty

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo, return_value = "narf")
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
mockFoo("zort")
print mockFoo.call_args_list
# returns: [call('zort')]
 
mockFoo()
print mockFoo.call_args_list
# returns: [call('zort'), call()]
 
mockFoo("troz")
print mockFoo.call_args_list
# returns: [call('zort'), call(), call('troz')]
 
mockFoo.callFoo()
print mockFoo.call_args_list
# returns: [call('zort'), call(), call('troz')]

訪問器mothod_calls報告了測試對象所做的mock方法的調用。它的結果是一個列表對象，每一項顯示了方法的名稱和它的參數。

Listing Twenty-one演示了method_calls的運用。對新創建的mockFoo，method_calls返回了空列表（15~19行）。當做了工廠調用時，同樣返回空列表（21~23行）。當我調用了mock方法callFoo()時，method_calls返回一個帶一項數據的列表對象（25~27行）。當我調用doFoo()，並傳入"narf"參數時，method_calls返回帶有兩項數據的列表（29~31行）。注意每個方法名稱是按照它調用的順序顯示的。

Listing Twenty-one

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo, return_value = "poink")
print mockFoo
# returns <Mock spec='Foo' id='507120'>
print mockFoo.method_calls
# returns []
 
mockFoo()
print mockFoo.method_calls
# returns []
 
mockFoo.callFoo()
print mockFoo.method_calls
# returns: [call.callFoo()]
 
mockFoo.doFoo("narf")
print mockFoo.method_calls
# returns: [call.callFoo(), call.doFoo('narf')]
 
mockFoo()
print mockFoo.method_calls
# returns: [call.callFoo(), call.doFoo('narf')]

最后一個訪問器mock_calls報告了測試對象對mock對象所有的調用。結果是一個列表，但是工廠調用和方法調用都顯示了。Listing Twenty-two演示這個訪問器的運用，使用了和Listing Twenty-one相同的代碼

Listing Twenty-two

from mock import Mock
 
# The mock object
class Foo(object):
    # instance properties
    _fooValue = 123
     
    def callFoo(self):
        print "Foo:callFoo_"
     
    def doFoo(self, argValue):
        print "Foo:doFoo:input = ", argValue
 
# create the first mock object
mockFoo = Mock(spec = Foo, return_value = "poink")
print mockFoo
# returns <Mock spec='Foo' id='507120'>
 
print mockFoo.mock_calls
# returns []
 
mockFoo()
print mockFoo.mock_calls
# returns [call()]
 
mockFoo.callFoo()>
print mockFoo.mock_calls
# returns: [call(), call.callFoo()]
 
mockFoo.doFoo("narf")
print mockFoo.mock_calls
# returns: [call(), call.callFoo(), call.doFoo('narf')]
 
mockFoo()
print mockFoo.mock_calls
# returns: [call(), call.callFoo(), call.doFoo('narf'), call()]

在測試中使用MOCK

數據類型，模型或者節點，這些是mock對象可能被假定的一些角色。但是mock對象怎樣適合單元測試呢？讓我們一起來看看，來自Martin Fowler的文章Mocks Aren't Stubs采取了簡化的設置。

在這個測試中，設置了三個類（圖4）。Order類是測試對象。它模擬了單一項目的采購訂單，訂單來源於一個數據源。Warehouse類是測試資源。它包含了鍵值對的序列，鍵是項目的名稱，值是可用的數量。OrderTest類是測試用例本身。

圖4

Listing Twenty-three描述了Order。Order類聲明了三個屬性:項目名稱（_orderItem），要求的數量（_orderAmount）和已填寫的數量(_orderFilled)。它的構造器帶有兩個參數（8~18行），填入的屬性是_orderItem和_orderAmount。它的__repr__()方法返回了購買清單的摘要(21~24行)。

Listing Twenty-three

class Order(object):
    # instance properties
    _orderItem = "None"
    _orderAmount = 0
    _orderFilled = -1
     
    # Constructor
    def __init__(self, argItem, argAmount):
        print "Order:__init__"
         
        # set the order item
        if (isinstance(argItem, str)):
            if (len(argItem) > 0):
                self._orderItem = argItem
         
        # set the order amount
        if (argAmount > 0):
            self._orderAmount = argAmount
         
    # Magic methods
    def __repr__(self):
       # assemble the dictionary
        locOrder = {'item':self._orderItem, 'amount':self._orderAmount}
        return repr(locOrder)
     
    # Instance methods
    # attempt to fill the order
    def fill(self, argSrc):
        print "Order:fill_"
         
        try:
            # does the warehouse has the item in stock?
            if (argSrc is not None):
                if (argSrc.hasInventory(self._orderItem)):
                    # get the item
                    locCount =    argSrc.getInventory(self._orderItem, self._orderAmount)
                 
                    # update the following property
                    self._orderFilled = locCount
                else:
                    print "Inventory item not available"
            else:
                print "Warehouse not available"
        except TypeError:
            print "Invalid warehouse"
     
    # check if the order has been filled
    def isFilled(self):
        print "Order:isFilled_"
        return (self._orderAmount == self._orderFilled)

Order類定義了兩個實例方法。fill()方法從參數(argSrc)中獲取數據源。它檢查數據源是否可用，數據源的項目是否存在問題（33~34行）。它提交了一個申請並用實際返回的數量更新_orderFilled（36~39行）。當_orderAmount和_orderFilled有相同的值時，isFilled()方法返回True(48~50行)。

 

Listing Twenty-four描述了Warehouse類。它是一個抽象類，聲明了屬性和方法接口，但是沒有定義方法本身。屬性_houseName是倉庫的名字，而_houseList是它持有的庫存。還有這兩個屬性的訪問器。

Listing Twenty-four

class Warehouse(object):    
    # private properties
    _houseName = None
    _houseList = None
         
    # accessors
    def warehouseName(self):
        return (self._houseName)
     
    def inventory(self):
        return (self._houseList)
     
     
    # -- INVENTORY ACTIONS
    # set up the warehouse
    def setup(self, argName, argList):
    	pass
     
    # check for an inventory item
    def hasInventory(self, argItem):
        pass
     
    # retrieve an inventory item
    def getInventory(self, argItem, argCount):
        pass
         
    # add an inventory item
    def addInventory(self, argItem, argCount):
        pass

Warehouse類聲明了四個方法接口。方法setup()帶有兩個參數，是為了更新這兩個屬性。方法hasInventory()參數是項目的名稱，如果項目在庫存中則返回True。方法getInventory()的參數是項目的名稱和數量。它嘗試着從庫存中扣除數量，返回哪些是成功的扣除。方法addInventory()的參數也是項目名稱和數量。它將用這兩個參數更新_houseList。

Listing Twenty-five是測試用例本身，orderTest類。他有一個屬性fooSource是Order類所需的mock對象。setUp()方法識別執行的測試例程（14~16行），然后創建和配置mock對象（21~34行）。tearDown()方法向stdout打印一個空行。

Listing Twenty-five

import unittest
from mock import Mock, call
 
class OrderTest(unittest.TestCase):
    # declare the test resource
    fooSource = None
     
    # preparing to test
    def setUp(self):
        """ Setting up for the test """
        print "OrderTest:setUp_:begin"
         
        # identify the test routine
        testName = self.id().split(".")
        testName = testName[2]
        print testName
         
        # prepare and configure the test resource
        if (testName == "testA_newOrder"):
            print "OrderTest:setup_:testA_newOrder:RESERVED"
        elif (testName == "testB_nilInventory"):
            self.fooSource = Mock(spec = Warehouse, return_value = None)
        elif (testName == "testC_orderCheck"):
            self.fooSource = Mock(spec = Warehouse)
            self.fooSource.hasInventory.return_value = True
            self.fooSource.getInventory.return_value = 0
        elif (testName == "testD_orderFilled"):
            self.fooSource = Mock(spec = Warehouse)
            self.fooSource.hasInventory.return_value = True
            self.fooSource.getInventory.return_value = 10
        elif (testName == "testE_orderIncomplete"):
            self.fooSource = Mock(spec = Warehouse)
            self.fooSource.hasInventory.return_value = True
            self.fooSource.getInventory.return_value = 5
        else:
            print "UNSUPPORTED TEST ROUTINE"
     
    # ending the test
    def tearDown(self):
        """Cleaning up after the test"""
        print "OrderTest:tearDown_:begin"
        print ""
     
    # test: new order
    # objective: creating an order
    def testA_newOrder(self):
        # creating a new order
        testOrder = Order("mushrooms", 10)
        print repr(testOrder)
         
        # test for a nil object
        self.assertIsNotNone(testOrder, "Order object is a nil.")
         
        # test for a valid item name
        testName = testOrder._orderItem
        self.assertEqual(testName, "mushrooms", "Invalid item name")
         
        # test for a valid item amount
        testAmount = testOrder._orderAmount
        self.assertGreater(testAmount, 0, "Invalid item amount")
     
    # test: nil inventory
    # objective: how the order object handles a nil inventory
    def testB_nilInventory(self):
        """Test routine B"""
        # creating a new order
        testOrder = Order("mushrooms", 10)
        print repr(testOrder)
         
        # fill the order
        testSource = self.fooSource()
        testOrder.fill(testSource)
         
        # print the mocked calls
        print self.fooSource.mock_calls
         
        # check the call history
        testCalls = [call()]
        self.fooSource.assert_has_calls(testCalls)
     
    # ... continued in the next listing

OrderTest類有五個測試例程。所有五個測試例程在開始的時候都創建了一個Order類的實例。例程testA_newOrder()測試Order對象是否可用是否有正確的數據（46~60行）。例程testB_nilWarehouse()創建了一個空的mock並傳入Order對象的fill()方法（64~79行）。它檢查了mock的調用歷史，確保僅僅發生了工廠調用。

 

例程testC_orderCheck()（Listing Twenty-six）測試了Order對象在庫存不足時的反應。最初，fooSource的hasInventory()方法響應True，getinventory()方法返回0。測試例程檢查是否訂單未達成，是否正確的mock方法被帶調用(16~19行)。然后測試例程創建了一個新的Order對象，這次是一個不同的項目。mock(fooSource)的方法hasInventory()的響應設置為False（第27行）。再次，例程檢查是否訂單未達成，是否調用了正確的mock方法（34~37行）。注意使用reset_mock()方法將fooSource恢復到測試前的狀態（第28行）。

Listing Twenty-six

class OrderTest(unittest.TestCase):
    # ... see previous listing
     
    # test: checking the inventory
    # objective: does the order object check for inventory?
    def testC_orderCheck(self):
        """Test routine C"""
        # creating a test order
        testOrder = Order("mushrooms", 10)
        print repr(testOrder)
         
        # perform the test
        testOrder.fill(self.fooSource)
         
        # perform the checks
        self.assertFalse(testOrder.isFilled())
        self.assertEqual(testOrder._orderFilled, 0)
         
        self.fooSource.hasInventory.assert_called_once_with("mushrooms")
        print self.fooSource.mock_calls
         
        # creating another order
        testOrder = Order("cabbage", 10)
        print repr(testOrder)
         
        # reconfigure the test resource
        self.fooSource.hasInventory.return_value = False
        self.fooSource.reset_mock()
         
        # perform the test
        testOrder.fill(self.fooSource)
         
        # perform the checks
        self.assertFalse(testOrder.isFilled())
        self.assertEqual(testOrder._orderFilled, -1)
         
        self.fooSource.hasInventory.assert_called_once_with("cabbage")
        print self.fooSource.mock_calls
     
    # ... continued in the next listing

測試例程testD_orderFilled()（Listing Twenty-seven）模擬了一個成功的訂單事務。fooSource的hasInventory()方法響應True，getinventory()方法返回10。例程調用fill()方法傳入mock對象，然后檢查訂單是否已完成（17~18行）。它也檢查了是否采用正確的順序和正確的參數調用了 正確的mock方法（20~24行）。

Listing Twenty-seven

class OrderTest(unittest.TestCase):
    # ... see previous listing
     
    # test: fulfilling an order
    # objective: how does the order object behave with a successful transaction
    def testD_orderFilled(self):
        """Test routine D"""
        # creating a test order
        testOrder = Order("mushrooms", 10)
        print repr(testOrder)
         
        # perform the test
        testOrder.fill(self.fooSource)
        print testOrder.isFilled()
         
        # perform the checks
        self.assertTrue(testOrder.isFilled())
        self.assertNotEqual(testOrder._orderFilled, -1)
         
        self.fooSource.hasInventory.assert_called_once_with("mushrooms")
        self.fooSource.getInventory.assert_called_with("mushrooms", 10)
         
        testCalls = [call.hasInventory("mushrooms"), call.getInventory("mushrooms", 10)]
        self.fooSource.assert_has_calls(testCalls)
     
    # ... continued in the next listing

測試例程testE_orderIncomplete()（Listing Twenty-eight）模擬了一個未完成的事務。在這個測試中，fooSource的方法hasInventory()響應True,但是getinventory()返回5。例程調用fill()方法傳入mock對象，然后檢查未完成的訂單（17~18行）。 它也檢查了是否采用正確的順序和正確的參數調用了正確的mock方法（20~25行）。

Listing Twenty-eight

class OrderTest(unittest.TestCase):
    # ... see previous listing
     
    # test: fulfilling an order
    # objective: how does the order object behave with an incomplete transaction
    def testE_orderIncomplete(self):
        """Test routine E"""
        # creating a test order
        testOrder = Order("mushrooms", 10)
        print repr(testOrder)
         
        # perform the test
        testOrder.fill(self.fooSource)
        print testOrder.isFilled()
         
        # perform the checks
        self.assertFalse(testOrder.isFilled())
        self.assertNotEqual(testOrder._orderFilled, testOrder._orderAmount)
         
        self.fooSource.hasInventory.assert_called_once_with("mushrooms")
        self.fooSource.getInventory.assert_called_with("mushrooms", 10)
        print self.fooSource.mock_calls
         
        testCalls = [call.hasInventory("mushrooms"), call.getInventory("mushrooms", 10)]
        self.fooSource.assert_has_calls(testCalls)

結束語

Mocks讓我們為單元測試模擬了那些不可用或者是太龐大的資源。我們可以在運行中配置mock，在特定的測試中改變它的行為或響應，或者讓它在恰當的時候拋出錯誤和異常。

在這篇文章中，我們看到了在單元測試中設置mock的好處。我們了解了mock和fake或者stub的區別。我們了解了怎樣在Python中創建mock，怎樣管理它和用斷言跟蹤它的行為。我們研究了簡單的mock在基礎測試用例中的工作。隨意嘗試了這個測試設置並觀察它的結構。隨意的調整已提供的測試例程並觀察這些調整對測試的影響