mock詳解

一、Mock在單元測試中扮演一個什么角色

　　有時，你需要為單元測試的初始設置准備一些“其他”的代碼資源。但這些資源興許會不可用，不穩定，或者是使用起來太笨重。你可以試着找一些其他的資源替代；或者你可以通過創建一個被稱為mock的東西來模擬它。Mocks能夠讓我們模擬那些在單元測試中不可用或太笨重的資源。
　　
　　 在Python中創建mock是通過Mock模塊完成的。你可以通過每次一個屬性（one-attribute-at-a-time）或一個健全的字典對象或是一個類接口來創建mock。你還可以定義mock的行為並且在測試過程中檢查它的使用。讓我們繼續探討。

 

二、測試准備

Test Case           Test Subject         Test Resource

　　典型的測試准備最少有兩個部分。首先是測試對象（紅色），這是測試的關注點。它可以是一個方法、模塊或者類。它可以返回一個結果，也可以不返回結果，但是它可以根據數據數據或者內部狀態產生錯誤或者異常。
　　
　　第二測試用例（灰色），它可以單獨運行也可以作為套件的一部分。它是為測試對象准備的，也可以是測試對象需要的任意數據或資源。運行一個或多個測試事務，在每個測試中檢查測試對象的行為。收集測試結果並用一個簡潔、易讀的格式呈現測試結果。
　　
　　現在，為了發揮作用，一些測試對象需要一個或多個資源（綠色）。這些資源可以是其他的類或者模塊，甚至是一個非獨立的進程。不論其性質，測試資源是功能性的代碼。他們的角色是支持測試對象，但是他們不是測試的關注點。

 

三、使用Mock的理由

　　但是有些時候，測試資源不可用，或者不適合。也許這個資源正在和測試對象並行開發中，或者並不完整或者是太不穩定以至於不可靠。
　　
　　測試資源太昂貴，如果測試資源是第三方的產品，其高昂的價格不適用於測試。測試資源的建立過於復雜，占用的硬件和時間可以用於別的地方。如果測試資源是一個數據源，建立它的數據集模仿真實世界是乏味的。
　　
　　測試資源是不可預知的。一個好的單元測試是可重復的，允許你分離和識別故障。但是測試資源可能給出隨機的結果，或者它會有不同的響應時間。而作為這樣的結果，測試資源最終可能成為一個潛在的攪局者。
　　
　　 這些都是你可能想要用mock代替測試資源的原因。mock向測試對象提供一套和測試資源相同的方法接口。但是mock是更容易創建和管理。它能向測試對象提供和真實的測試資源相同的方法接口。它能提供確定的結果，並可以自定義以適用於特定的測試。能夠容易的更新，以反映實際資源的變化。
　　
　　當然，mocks不是沒有問題的。設計一個精確的mock是困難的,特別是如果你沒有測試資源的可靠信息。你可以嘗試找到一個開源的接口，或者你能對測試資源的方法接口進行猜測。無論你如何選擇，你都可以在以后輕松的更新mock,你可以在首選資源中得到更詳細的信息。
　　
　　太多的mock會使測試過於復雜，讓你跟蹤錯誤變得更困難。最好的實踐是每個測試用例限制使用一到兩個mock，或者為每個mock/對象對使用獨立的測試用例。

 

四、使用Python Mock

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

 

五、MagicMock類

 MagicMock類是Mock類的子類，區別在於MagicMock類實現了常用的魔術方法，比如__str__、__iter__等，其他一樣。

 

六、mock.create_autospce

　　mock.create_autospec為類提供了一個同等功能實例。這意味着，實際上來說，在使用返回的實例進行交互的時候，如果使用了非法的方法將會引發異常。更具體地說，如果一個方法被調用時的參數數目不正確，將引發一個異常。這對於重構來說是非常重要。當一個庫發生變化的時候，中斷測試正是所期望的。如果不使用auto-spec，即使底層的實現已經破壞，我們的測試仍然會通過。
　　在選擇使用mock.Mock實例，mock.MagicMock實例或create_autospec方法的時候,通常傾向於選擇使用 create_autospec方法，因為它能夠對未來的變化保持測試的合理性。這是因為mock.Mock和mock.MagicMock會無視底層的API，接受所有的方法調用和參數賦值。

class Target(object):
    def apply(value):
        return valuedef method(target, value)
    return target.apply(value)

 

我們像下面這樣使用mock.Mock實例來做測試：

class MethodTestCase(unittest.TestCase):
    def test_method(self):
        target = mock.Mock()
        method(target, 'value')
        target.apply.assert_called_with('value')

 

這個邏輯看似合理，但如果我們修改Target.apply方法接受更多參數：

class Target(object):
    def apply(value, are_you_sure):
        if are_you_sure:
            return value
        else:
            return None

重新運行你的測試，然后你會發現它仍然能夠通過。這是因為它不是針對你的API創建的。這就是為什么你總是應該使用create_autospec方法，並且在使用@patch和@patch.object裝飾方法時使用autospec參數。

 

七、mock.patch和mock.patch.object

1.參數

unittest.mock.patch（target，new = DEFAULT，spec = None，create = False，spec_set = None，autospec = None，new_callable = None，** kwargs ）

• target參數必須是一個str,格式為'package.module.ClassName'，
  注意這里的格式一定要寫對，如果你的函數或類寫在pakege名稱為a下，b.py腳本里，有個c的函數（或類），那這個參數就寫“a.b.c”

• new參數如果沒寫，默認指定的是MagicMock
• spec=True或spec_set=True，這會導致patch傳遞給被模擬為spec / spec_set的對象

• new_callable允許您指定將被調用以創建新對象的不同類或可調用對象。默認情況下MagicMock使用。

 

注意：@mock.patch整個對象，@mock.patch.object對象中的方法

示例

# 文件名：Mymodel
class MyTest(object):
    def func(self):
        pass

那么@mock.patch

import Mymodel


class AppMockTests(unit.TestCase):

    def setUp(self):
        super(AppMockTests, self).setUp()
        self.project_zbj = webtest.TestApp(self.loadapp('project_zbj'))

    @mock.patch('Mymodel.MyTest')  # 必須是字符串,具體到類
    def test_list(self, mock_MyTest):
        url = '/api/zzz'
        mock_MyTest.func.return_value = 500
        res = self.project_zbj.get(url)
        self.assertEqual(res.json['data'], 500)

 

而@mock.patch.object

import Mymodel


class AppMockTests(unit.TestCase):

    def setUp(self):
        super(AppMockTests, self).setUp()
        self.project_zbj = webtest.TestApp(self.loadapp('project_zbj'))

    @mock.patch.object(Mymodel.MyTest, 'func')  # 具體到某個方法 
    def test_list(self, mock_func):
        url = '/api/zzz'
        mock_func.return_value = 500
        res = self.project_zbj.get(url)
        self.assertEqual(res.json['data'], 500)

 

 

八、python3中的mock(前面介紹的是python2的)

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

　但在，實際生產中的項目是非常復雜的，對其進行單元測試的時候，會遇到以下問題：

• 接口的依賴
• 外部接口調用
• 測試環境非常復雜

　　單元測試應該只針對當前單元進行測試, 所有的內部或外部的依賴應該是穩定的, 已經在別處進行測試過的.使用mock 就可以對外部依賴組件實現進行模擬並且替換掉, 從而使得單元測試將焦點只放在當前的單元功能。

 

1、簡單的例子

我們先從最簡單例子開始。

modular.py

#modular.py

class Count():

    def add(self):
        pass

這里要實現一個Count計算類，add() 方法要實現兩數相加。但，這個功能我還沒有完成。這時就可以借助mock對其進行測試。

mock_demo01.py

from unittest import mock
import unittest

from modular import Count

# test Count class
class TestCount(unittest.TestCase):

    def test_add(self):
        count = Count()
        count.add = mock.Mock(return_value=7)
        result = count.add(2,5)
        self.assertEqual(result,7)
        # 如果是python2，那么return_value的值會保存在返回值的json格式中的data
　　　　 self.assertEqual(result.json['data'], 7)


if __name__ == '__main__':
    unittest.main()

　　count = Count()

　　首先，調用被測試類Count() 。

 

　　count.add = mock.Mock(return_value=7)

　　通過Mock類模擬被調用的方法add()方法，return_value 定義add()方法的返回值。

 

　　result = count.add(2,5)

　　接下來，相當於在正常的調用add()方法，傳兩個參數2和5，然后會得到相加的結果7。然后，7的結果是我們在上一步就預先設定好的。

 

　　self.assertEqual(result,7)

　　最后，通過assertEqual()方法斷言，返回的結果是否是預期的結果7。

 　 運行測試結果：

> python3 mock_demo01.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

這樣一個用例就在mock的幫助下編寫完成，並且測試通過了。

 

2、完成功能測試

再接下來完成module.py文件中add()方法。

# module.py

class Count():

    def add(self, a, b):
        return a + b

然后，修改測試用例：

from unittest import mock
import unittest
from module import Count


class MockDemo(unittest.TestCase):

    def test_add(self):
        count = Count()
        count.add = mock.Mock(return_value=13, side_effect=count.add)
        result = count.add(8, 8)
        print(result)
        count.add.assert_called_with(8, 8)
        self.assertEqual(result, 16)

if __name__ == '__main__':
    unittest.main()

  　count.add = mock.Mock(return_value=13, side_effect=count.add)

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

　　所以，設置side_effect參數為Count類add()方法，那么return_value的作用失效。

 

　　result = count.add(8, 8)

　　print(result)

　　這次將會真正的調用add()方法，得到的返回值為16（8+8）。通過print打印結果。

 

　　assert_called_with(8,8)

　　檢查mock方法是否獲得了正確的參數。

 

3、解決測試依賴                           

 　  前面的例子，只為了讓大家對mock有個初步的印象。再接來，我們看看如何mock方法的依賴。

　　例如，我們要測試A模塊，然后A模塊依賴於B模塊的調用。但是，由於B模塊的改變，導致了A模塊返回結果的改變，從而使A模塊的測試用例失敗。其實，對於A模塊，以及A模塊的用例來說，並沒有變化，不應該失敗才對。

　　這個時候就是mock發揮作用的時候了。通過mock模擬掉影響A模塊的部分（B模塊）。至於mock掉的部分（B模塊）應該由其它用例來測試。

# function.py
def add_and_multiply(x, y):
    addition = x + y
    multiple = multiply(x, y)
    return (addition, multiple)


def multiply(x, y):
    return x * y

  　　然后，針對 add_and_multiply()函數編寫測試用例。func_test.py

import unittest
import function


class MyTestCase(unittest.TestCase):

    def test_add_and_multiply(self):
        x = 3
        y = 5
        addition, multiple = function.add_and_multiply(x, y)
        self.assertEqual(8, addition)
        self.assertEqual(15, multiple)


if __name__ == "__main__":
    unittest.main()

 運行結果：

>  python3 func_test.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

OK

　　

　　目前運行一切正確常，然而，add_and_multiply()函數依賴了multiply()函數的返回值。如果這個時候修改multiply()函數的代碼。

……
def multiply(x, y):
    return x * y + 3

　　這個時候，multiply()函數返回的結果變成了x*y加3。

　　再次運行測試：

>  python3 func_test.py                                                   
F                                                                       
======================================================================  
FAIL: test_add_and_multiply (__main__.MyTestCase)                       
----------------------------------------------------------------------  
Traceback (most recent call last):                                      
  File "fun_test.py", line 19, in test_add_and_multiply                 
    self.assertEqual(15, multiple)                                      
AssertionError: 15 != 18                                                
                                                                        
----------------------------------------------------------------------  
Ran 1 test in 0.000s                                                    
                                                                        
FAILED (failures=1)   

　　測試用例運行失敗了，然而，add_and_multiply()函數以及它的測試用例並沒有做任何修改，罪魁禍首是multiply()函數引起的，我們應該把 multiply()函數mock掉。

import unittest
from unittest.mock import patch
import function


class MyTestCase(unittest.TestCase):

    @patch("function.multiply")
    def test_add_and_multiply2(self, mock_multiply):
        x = 3
        y = 5
        mock_multiply.return_value = 15
        addition, multiple = function.add_and_multiply(x, y)
        mock_multiply.assert_called_once_with(3, 5)

        self.assertEqual(8, addition)
        self.assertEqual(15, multiple)


if __name__ == "__main__":
    unittest.main()

　　@patch("function.multiply")

　　patch()裝飾/上下文管理器可以很容易地模擬類或對象在模塊測試。在測試過程中，您指定的對象將被替換為一個模擬（或其他對象），並在測試結束時還原。

　　這里模擬function.py文件中multiply()函數。

 

　　def test_add_and_multiply2(self, mock_multiply):

　　在定義測試用例中，將mock的multiply()函數（對象）重命名為 mock_multiply對象。

 

　　mock_multiply.return_value = 15

　　設定mock_multiply對象的返回值為固定的15。

 

　　ock_multiply.assert_called_once_with(3, 5)

　　檢查ock_multiply方法的參數是否正確。

 

　　再次，運行測試用例，通過！