Python接口測試之數據驅動
在接口的自動化測試中，客戶端發送請求給服務端，在客戶端發送請求的時候，包含了請求地址，請求方法，以及請求參數等數據，那麼在接口的自動化測試中如何來分離這些...
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
2、測試框架優化
unittest 是 python 中進行單元測試使用廣泛的框架，其與 java 中的單元測試框架junit 類似。該框架使用簡單，需要編寫以 test 開頭的函數，選擇 unittest 框架運行測試函數，測試結果在終端顯示。這裡舉一個簡單的例子：
import unittest
class ApiTestSample(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
testResult = self.jiafa(input01=4, input02=5)
self.assertEqual(testResult, 9)
if __name__=='__main__':
unittest.main()
簡單解釋下這段代碼，首先我們創建一個類 ApiTestSample，這個類繼承自unittest.TestCase 類。然後在這個類中寫了 jiafa 函數，它有兩個參數 input01，input02，返回 input01 與 input02 相加的和。接著在 test_jiafa 方法中，我們對剛才 jiafa 函數進行了和值校驗。通過給 jiafa 輸入兩個值，獲取其函數返回值，並與真實值做相等判斷，以此實現函數單元測試。這裡用到了 unittest 中斷言值相等的 assertEqual(m, n)函數，上述代碼運行結果如下：
Ran 1 test in 0.000s
OK
以上是 unittest 框架最基本的單元測試應用，但是這個框架有個缺陷，就是不能自己傳入參數。對於接口來說，往往需要傳入很多參數，並且這每個參數又有很多取值，如果不對原先的 unittest 框架做改變，不僅無法用來進行接口測試，而且一個個結合參數取值去寫測試代碼，工作量極其龐大，也沒有實現測試數據與腳本沒有分離。基於此，我們對該框架做出一下兩點優化。
1）擴展 unittest.TestCase 類，支持自定義參數輸入；
2）測試數據與測試腳本分離，測試數據存儲在文件和數據庫中，以增強測試腳本複用性；
以下是對 unittest.TestCase 類的擴展，使其支持參數化把參數加進去。下面是具體的代碼實現過程：
class ExtendTestCaseParams(unittest.TestCase):
#擴展 unittest.TestCase 類，使其支持自定義參數輸入
def __init__(self, method_name='runTest', canshu=None):
super(ExtendTestCaseParams, self).__init__(method_name)
self.canshu = canshu
#靜態參數化方法
@staticmethod
def parametrize(testcase_klass, default_name=None, canshu=None):
""" Create a suite containing all tests taken from the given
subclass, passing them the parameter 'canshu'
"""
test_loader = unittest.TestLoader()
testcase_names = test_loader.getTestCaseNames(testcase_klass)
suite = unittest.TestSuite()
if default_name != None:
for casename in testcase_names:
if casename == defName:
suite.addTest(testcase_klass(casename, canshu=canshu))
else:
for casename in testcase_names:
suite.addTest(testcase_klass(casename, canshu=canshu))
return suite
這裡，canshu 就是優化後加的自定義參數，參數類型可以是元組或列表。下面使用這個參數化類來改寫之前的代碼。
class ApiTestSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
input_01 = self.param[0]
input_02 = self.param[1]
expectedResult = self.param[2]
result = self.sub(input_01, input_02)
print(result)
self.assertEqual(result, expectedResult)
if __name__=='__main__':
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample, 'test_jiafa', canshu=i))
runner = unittest.TextTestRunner()
runner.run(suite)
執行結果如下：
....
## 19
25
Ran 4 tests in 0.000s
22
6
OK
通過對 unittest 框架優化，我們實現了 unittest 框架的參數化，這樣就可以用於接口測試了。雖然我們實現了參數化，但是測試結果的展示不夠直觀，這個時候需要一個可視化頁面來直接顯示測試結果。所幸的是，python 中有專門展示測試結果的框架：HTMLTestRunner。該框架可以將測試結果轉換為 HTML 頁面，並且該框架可以和unittest 框架完美的結合起來。接下來我們講述一下 HTMLTestRunner 框架的使用。
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
2、測試框架優化
unittest 是 python 中進行單元測試使用廣泛的框架，其與 java 中的單元測試框架junit 類似。該框架使用簡單，需要編寫以 test 開頭的函數，選擇 unittest 框架運行測試函數，測試結果在終端顯示。這裡舉一個簡單的例子：
import unittest
class ApiTestSample(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
testResult = self.jiafa(input01=4, input02=5)
self.assertEqual(testResult, 9)
if __name__=='__main__':
unittest.main()
簡單解釋下這段代碼，首先我們創建一個類 ApiTestSample，這個類繼承自unittest.TestCase 類。然後在這個類中寫了 jiafa 函數，它有兩個參數 input01，input02，返回 input01 與 input02 相加的和。接著在 test_jiafa 方法中，我們對剛才 jiafa 函數進行了和值校驗。通過給 jiafa 輸入兩個值，獲取其函數返回值，並與真實值做相等判斷，以此實現函數單元測試。這裡用到了 unittest 中斷言值相等的 assertEqual(m, n)函數，上述代碼運行結果如下：
Ran 1 test in 0.000s
OK
以上是 unittest 框架最基本的單元測試應用，但是這個框架有個缺陷，就是不能自己傳入參數。對於接口來說，往往需要傳入很多參數，並且這每個參數又有很多取值，如果不對原先的 unittest 框架做改變，不僅無法用來進行接口測試，而且一個個結合參數取值去寫測試代碼，工作量極其龐大，也沒有實現測試數據與腳本沒有分離。基於此，我們對該框架做出一下兩點優化。
1）擴展 unittest.TestCase 類，支持自定義參數輸入；
2）測試數據與測試腳本分離，測試數據存儲在文件和數據庫中，以增強測試腳本複用性；
以下是對 unittest.TestCase 類的擴展，使其支持參數化把參數加進去。下面是具體的代碼實現過程：
class ExtendTestCaseParams(unittest.TestCase):
#擴展 unittest.TestCase 類，使其支持自定義參數輸入
def __init__(self, method_name='runTest', canshu=None):
super(ExtendTestCaseParams, self).__init__(method_name)
self.canshu = canshu
#靜態參數化方法
@staticmethod
def parametrize(testcase_klass, default_name=None, canshu=None):
""" Create a suite containing all tests taken from the given
subclass, passing them the parameter 'canshu'
"""
test_loader = unittest.TestLoader()
testcase_names = test_loader.getTestCaseNames(testcase_klass)
suite = unittest.TestSuite()
if default_name != None:
for casename in testcase_names:
if casename == defName:
suite.addTest(testcase_klass(casename, canshu=canshu))
else:
for casename in testcase_names:
suite.addTest(testcase_klass(casename, canshu=canshu))
return suite
這裡，canshu 就是優化後加的自定義參數，參數類型可以是元組或列表。下面使用這個參數化類來改寫之前的代碼。
class ApiTestSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
input_01 = self.param[0]
input_02 = self.param[1]
expectedResult = self.param[2]
result = self.sub(input_01, input_02)
print(result)
self.assertEqual(result, expectedResult)
if __name__=='__main__':
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample, 'test_jiafa', canshu=i))
runner = unittest.TextTestRunner()
runner.run(suite)
執行結果如下：
....
## 19
25
Ran 4 tests in 0.000s
22
6
OK
通過對 unittest 框架優化，我們實現了 unittest 框架的參數化，這樣就可以用於接口測試了。雖然我們實現了參數化，但是測試結果的展示不夠直觀，這個時候需要一個可視化頁面來直接顯示測試結果。所幸的是，python 中有專門展示測試結果的框架：HTMLTestRunner。該框架可以將測試結果轉換為 HTML 頁面，並且該框架可以和unittest 框架完美的結合起來。接下來我們講述一下 HTMLTestRunner 框架的使用。
3、測試結果可視化
HTMLTestRunner 框架可用來生成可視化測試報告，並能很好的與 unittest 框架結合使用，接下來我們以一段代碼來展示一下 HTMLTestRunner 的使用。
if __name__=='__main__':
from HTMLTestRunner import HTMLTestRunner
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample,'test_jiafa',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
result_path = './test_results'
if not os.path.exists(path):
os.makedirs(path)
report_path = result_path + '/' + currentTime + "_report.html"
reportTitle = '測試報告'
desc = u'測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
測試結果如下：
下面詳細講解一下 html 報告的生成代碼：
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
HTMLTestRunner 中的 stream 表示輸入流，這裡我們將文件描述符傳遞給 stream，title 參數表示要輸出的測試報告主題名稱，description 參數是對測試報告的描述。在使用 HTMLTestRunner 時，有幾點需要注意：
1）HTMLTestRunner 模塊非 Python 自帶庫，需要到 HTMLTestRunner 的官網下載
該安裝包；
2）官網的 HTMLTestRunner 模塊僅支持 Python 2.x 版本，如果要在 Python 3.x中，需要修改部分代碼，修改的代碼部分請自行上網搜索；
如果需要生成 xml 格式，只需將上面代碼中的
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
runner.run(suite)
修改為如下代碼
import xmlrunner
runner = xmlrunner.XMLTestRunner(output='report')
runner.run(suite)
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
2、測試框架優化
unittest 是 python 中進行單元測試使用廣泛的框架，其與 java 中的單元測試框架junit 類似。該框架使用簡單，需要編寫以 test 開頭的函數，選擇 unittest 框架運行測試函數，測試結果在終端顯示。這裡舉一個簡單的例子：
import unittest
class ApiTestSample(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
testResult = self.jiafa(input01=4, input02=5)
self.assertEqual(testResult, 9)
if __name__=='__main__':
unittest.main()
簡單解釋下這段代碼，首先我們創建一個類 ApiTestSample，這個類繼承自unittest.TestCase 類。然後在這個類中寫了 jiafa 函數，它有兩個參數 input01，input02，返回 input01 與 input02 相加的和。接著在 test_jiafa 方法中，我們對剛才 jiafa 函數進行了和值校驗。通過給 jiafa 輸入兩個值，獲取其函數返回值，並與真實值做相等判斷，以此實現函數單元測試。這裡用到了 unittest 中斷言值相等的 assertEqual(m, n)函數，上述代碼運行結果如下：
Ran 1 test in 0.000s
OK
以上是 unittest 框架最基本的單元測試應用，但是這個框架有個缺陷，就是不能自己傳入參數。對於接口來說，往往需要傳入很多參數，並且這每個參數又有很多取值，如果不對原先的 unittest 框架做改變，不僅無法用來進行接口測試，而且一個個結合參數取值去寫測試代碼，工作量極其龐大，也沒有實現測試數據與腳本沒有分離。基於此，我們對該框架做出一下兩點優化。
1）擴展 unittest.TestCase 類，支持自定義參數輸入；
2）測試數據與測試腳本分離，測試數據存儲在文件和數據庫中，以增強測試腳本複用性；
以下是對 unittest.TestCase 類的擴展，使其支持參數化把參數加進去。下面是具體的代碼實現過程：
class ExtendTestCaseParams(unittest.TestCase):
#擴展 unittest.TestCase 類，使其支持自定義參數輸入
def __init__(self, method_name='runTest', canshu=None):
super(ExtendTestCaseParams, self).__init__(method_name)
self.canshu = canshu
#靜態參數化方法
@staticmethod
def parametrize(testcase_klass, default_name=None, canshu=None):
""" Create a suite containing all tests taken from the given
subclass, passing them the parameter 'canshu'
"""
test_loader = unittest.TestLoader()
testcase_names = test_loader.getTestCaseNames(testcase_klass)
suite = unittest.TestSuite()
if default_name != None:
for casename in testcase_names:
if casename == defName:
suite.addTest(testcase_klass(casename, canshu=canshu))
else:
for casename in testcase_names:
suite.addTest(testcase_klass(casename, canshu=canshu))
return suite
這裡，canshu 就是優化後加的自定義參數，參數類型可以是元組或列表。下面使用這個參數化類來改寫之前的代碼。
class ApiTestSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
input_01 = self.param[0]
input_02 = self.param[1]
expectedResult = self.param[2]
result = self.sub(input_01, input_02)
print(result)
self.assertEqual(result, expectedResult)
if __name__=='__main__':
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample, 'test_jiafa', canshu=i))
runner = unittest.TextTestRunner()
runner.run(suite)
執行結果如下：
....
## 19
25
Ran 4 tests in 0.000s
22
6
OK
通過對 unittest 框架優化，我們實現了 unittest 框架的參數化，這樣就可以用於接口測試了。雖然我們實現了參數化，但是測試結果的展示不夠直觀，這個時候需要一個可視化頁面來直接顯示測試結果。所幸的是，python 中有專門展示測試結果的框架：HTMLTestRunner。該框架可以將測試結果轉換為 HTML 頁面，並且該框架可以和unittest 框架完美的結合起來。接下來我們講述一下 HTMLTestRunner 框架的使用。
3、測試結果可視化
HTMLTestRunner 框架可用來生成可視化測試報告，並能很好的與 unittest 框架結合使用，接下來我們以一段代碼來展示一下 HTMLTestRunner 的使用。
if __name__=='__main__':
from HTMLTestRunner import HTMLTestRunner
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample,'test_jiafa',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
result_path = './test_results'
if not os.path.exists(path):
os.makedirs(path)
report_path = result_path + '/' + currentTime + "_report.html"
reportTitle = '測試報告'
desc = u'測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
測試結果如下：
下面詳細講解一下 html 報告的生成代碼：
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
HTMLTestRunner 中的 stream 表示輸入流，這裡我們將文件描述符傳遞給 stream，title 參數表示要輸出的測試報告主題名稱，description 參數是對測試報告的描述。在使用 HTMLTestRunner 時，有幾點需要注意：
1）HTMLTestRunner 模塊非 Python 自帶庫，需要到 HTMLTestRunner 的官網下載
該安裝包；
2）官網的 HTMLTestRunner 模塊僅支持 Python 2.x 版本，如果要在 Python 3.x中，需要修改部分代碼，修改的代碼部分請自行上網搜索；
如果需要生成 xml 格式，只需將上面代碼中的
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
runner.run(suite)
修改為如下代碼
import xmlrunner
runner = xmlrunner.XMLTestRunner(output='report')
runner.run(suite)
4、接口測試分類
前面大家對接口請求，測試框架和測試結果可視化方面有了深入的瞭解。有了前面的基礎，對於接下來理解和編寫接口測試會有很大幫助。這裡我們先來講解一下接口測試與單元測試的區別。單元測試只針對函數進行多組參數測試，包括正常和異常參數組合。而接口測試是針對某一接口進行多組參數測試。實際接口測試中，我們又將接口測試分為兩種：
1）單接口測試；
2）多接口測試。
對於單接口測試，只需針對單個接口測試，測試數據根據接口文檔中的參數規則來設計測試用例；對多接口測試，首先要確保接口之間調用邏輯正確，然後再根據接口文檔中的參數規則來設計用例進行測試。下面我就根據這兩種不同情況的接口測試，用實際項目代碼展示一下。
4.1 單接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'http://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def test_register(self):
for index, value in enumerate(self.param):
print('Test Token {0} parameter is {1}'.format(index, value)）
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expectedValue = self.param[4]
req = self.grant_register(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expectedValue, msg="Test Failed.")
if __name__=='__main__':
import random
import string
ip = '172.36.17.108'
testData = [
(1, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample,'test_register',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = './results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中的 register()為註冊接口函數，test_register()為測試註冊接口函數，testData 為測試數據，這裡沒有完全做到測試腳本與測試數據分離。為了實現測試數據與測試腳本分離，可以將 testData 列表單獨寫在文本文件或者數據庫中，運行測試腳本時再去加載這些數據，就能實現測試腳本與測試數據的分離。
4.2 多接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'https://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def oauth2_basic(self, ip, name, desc):
apps = self.register(ip, name, desc)
apps = apps.json()
url = 'http://%s/api/v1/basic' % ip
data = {"client_id":apps['appId'], "client_secret":apps['appKey']}
headers = None
req = requests.post(url, data, headers)
basic = str(req.content, encoding='utf-8')
return apps, basic, req
def test_oauth2_basic(self):
count = 0
for i in self.param:
count += 1
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expected = self.param[4]
apps, basic, req = self.oauth2_basic(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expected, msg="Grant Failed.")
if __name__=='__main__':
import random
import string
ipAddr = '172.36.17.108'
testData = [
(1, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample, 'test_oauth2_basic',
canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = '../Results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中，我們對兩個接口進行了函數封裝，兩個接口之間有依賴關係，oauth2_basic()函數在請求之前必須先去請求 register()函數獲取數據。對於這種多接口測試，且接口之間存在互相調用的情況，最好是在調用該接口前時，將互相之間有依賴的接口封裝進該接口中，保證接口調用邏輯一致。其次再針對該接口的其它參數設計測試用例去測試該接口。
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
2、測試框架優化
unittest 是 python 中進行單元測試使用廣泛的框架，其與 java 中的單元測試框架junit 類似。該框架使用簡單，需要編寫以 test 開頭的函數，選擇 unittest 框架運行測試函數，測試結果在終端顯示。這裡舉一個簡單的例子：
import unittest
class ApiTestSample(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
testResult = self.jiafa(input01=4, input02=5)
self.assertEqual(testResult, 9)
if __name__=='__main__':
unittest.main()
簡單解釋下這段代碼，首先我們創建一個類 ApiTestSample，這個類繼承自unittest.TestCase 類。然後在這個類中寫了 jiafa 函數，它有兩個參數 input01，input02，返回 input01 與 input02 相加的和。接著在 test_jiafa 方法中，我們對剛才 jiafa 函數進行了和值校驗。通過給 jiafa 輸入兩個值，獲取其函數返回值，並與真實值做相等判斷，以此實現函數單元測試。這裡用到了 unittest 中斷言值相等的 assertEqual(m, n)函數，上述代碼運行結果如下：
Ran 1 test in 0.000s
OK
以上是 unittest 框架最基本的單元測試應用，但是這個框架有個缺陷，就是不能自己傳入參數。對於接口來說，往往需要傳入很多參數，並且這每個參數又有很多取值，如果不對原先的 unittest 框架做改變，不僅無法用來進行接口測試，而且一個個結合參數取值去寫測試代碼，工作量極其龐大，也沒有實現測試數據與腳本沒有分離。基於此，我們對該框架做出一下兩點優化。
1）擴展 unittest.TestCase 類，支持自定義參數輸入；
2）測試數據與測試腳本分離，測試數據存儲在文件和數據庫中，以增強測試腳本複用性；
以下是對 unittest.TestCase 類的擴展，使其支持參數化把參數加進去。下面是具體的代碼實現過程：
class ExtendTestCaseParams(unittest.TestCase):
#擴展 unittest.TestCase 類，使其支持自定義參數輸入
def __init__(self, method_name='runTest', canshu=None):
super(ExtendTestCaseParams, self).__init__(method_name)
self.canshu = canshu
#靜態參數化方法
@staticmethod
def parametrize(testcase_klass, default_name=None, canshu=None):
""" Create a suite containing all tests taken from the given
subclass, passing them the parameter 'canshu'
"""
test_loader = unittest.TestLoader()
testcase_names = test_loader.getTestCaseNames(testcase_klass)
suite = unittest.TestSuite()
if default_name != None:
for casename in testcase_names:
if casename == defName:
suite.addTest(testcase_klass(casename, canshu=canshu))
else:
for casename in testcase_names:
suite.addTest(testcase_klass(casename, canshu=canshu))
return suite
這裡，canshu 就是優化後加的自定義參數，參數類型可以是元組或列表。下面使用這個參數化類來改寫之前的代碼。
class ApiTestSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
input_01 = self.param[0]
input_02 = self.param[1]
expectedResult = self.param[2]
result = self.sub(input_01, input_02)
print(result)
self.assertEqual(result, expectedResult)
if __name__=='__main__':
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample, 'test_jiafa', canshu=i))
runner = unittest.TextTestRunner()
runner.run(suite)
執行結果如下：
....
## 19
25
Ran 4 tests in 0.000s
22
6
OK
通過對 unittest 框架優化，我們實現了 unittest 框架的參數化，這樣就可以用於接口測試了。雖然我們實現了參數化，但是測試結果的展示不夠直觀，這個時候需要一個可視化頁面來直接顯示測試結果。所幸的是，python 中有專門展示測試結果的框架：HTMLTestRunner。該框架可以將測試結果轉換為 HTML 頁面，並且該框架可以和unittest 框架完美的結合起來。接下來我們講述一下 HTMLTestRunner 框架的使用。
3、測試結果可視化
HTMLTestRunner 框架可用來生成可視化測試報告，並能很好的與 unittest 框架結合使用，接下來我們以一段代碼來展示一下 HTMLTestRunner 的使用。
if __name__=='__main__':
from HTMLTestRunner import HTMLTestRunner
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample,'test_jiafa',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
result_path = './test_results'
if not os.path.exists(path):
os.makedirs(path)
report_path = result_path + '/' + currentTime + "_report.html"
reportTitle = '測試報告'
desc = u'測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
測試結果如下：
下面詳細講解一下 html 報告的生成代碼：
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
HTMLTestRunner 中的 stream 表示輸入流，這裡我們將文件描述符傳遞給 stream，title 參數表示要輸出的測試報告主題名稱，description 參數是對測試報告的描述。在使用 HTMLTestRunner 時，有幾點需要注意：
1）HTMLTestRunner 模塊非 Python 自帶庫，需要到 HTMLTestRunner 的官網下載
該安裝包；
2）官網的 HTMLTestRunner 模塊僅支持 Python 2.x 版本，如果要在 Python 3.x中，需要修改部分代碼，修改的代碼部分請自行上網搜索；
如果需要生成 xml 格式，只需將上面代碼中的
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
runner.run(suite)
修改為如下代碼
import xmlrunner
runner = xmlrunner.XMLTestRunner(output='report')
runner.run(suite)
4、接口測試分類
前面大家對接口請求，測試框架和測試結果可視化方面有了深入的瞭解。有了前面的基礎，對於接下來理解和編寫接口測試會有很大幫助。這裡我們先來講解一下接口測試與單元測試的區別。單元測試只針對函數進行多組參數測試，包括正常和異常參數組合。而接口測試是針對某一接口進行多組參數測試。實際接口測試中，我們又將接口測試分為兩種：
1）單接口測試；
2）多接口測試。
對於單接口測試，只需針對單個接口測試，測試數據根據接口文檔中的參數規則來設計測試用例；對多接口測試，首先要確保接口之間調用邏輯正確，然後再根據接口文檔中的參數規則來設計用例進行測試。下面我就根據這兩種不同情況的接口測試，用實際項目代碼展示一下。
4.1 單接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'http://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def test_register(self):
for index, value in enumerate(self.param):
print('Test Token {0} parameter is {1}'.format(index, value)）
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expectedValue = self.param[4]
req = self.grant_register(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expectedValue, msg="Test Failed.")
if __name__=='__main__':
import random
import string
ip = '172.36.17.108'
testData = [
(1, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample,'test_register',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = './results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中的 register()為註冊接口函數，test_register()為測試註冊接口函數，testData 為測試數據，這裡沒有完全做到測試腳本與測試數據分離。為了實現測試數據與測試腳本分離，可以將 testData 列表單獨寫在文本文件或者數據庫中，運行測試腳本時再去加載這些數據，就能實現測試腳本與測試數據的分離。
4.2 多接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'https://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def oauth2_basic(self, ip, name, desc):
apps = self.register(ip, name, desc)
apps = apps.json()
url = 'http://%s/api/v1/basic' % ip
data = {"client_id":apps['appId'], "client_secret":apps['appKey']}
headers = None
req = requests.post(url, data, headers)
basic = str(req.content, encoding='utf-8')
return apps, basic, req
def test_oauth2_basic(self):
count = 0
for i in self.param:
count += 1
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expected = self.param[4]
apps, basic, req = self.oauth2_basic(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expected, msg="Grant Failed.")
if __name__=='__main__':
import random
import string
ipAddr = '172.36.17.108'
testData = [
(1, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample, 'test_oauth2_basic',
canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = '../Results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中，我們對兩個接口進行了函數封裝，兩個接口之間有依賴關係，oauth2_basic()函數在請求之前必須先去請求 register()函數獲取數據。對於這種多接口測試，且接口之間存在互相調用的情況，最好是在調用該接口前時，將互相之間有依賴的接口封裝進該接口中，保證接口調用邏輯一致。其次再針對該接口的其它參數設計測試用例去測試該接口。
5、https 協議請求
前面我們提及的接口測試，僅是關於請求 http 協議的。然而，http 協議在傳輸過程中並不安全，通過該協議傳輸內容容易被截取，由此人們提出了 https 協議。該協議在原先的 http 協議之外，對傳輸過程中的內容進行了加密處理，這樣就能確保信息在傳輸過程中的安全。目前很多公司的訪問 url 都已轉換到 https 協議。因此在接口測試中也要考慮到對 https 協議訪問的支持。目前對於 https 協議訪問的處理有以下幾種方案。
第一種，對於一般網站訪問，無法獲得支持 https 協議的證書信息，因此只能選擇忽略 ssl 校驗；
第二種，對於外部網絡訪問公司內容網絡和內容來說，除了要經過防火牆外，訪問具體業務要經過負載均衡器。而負載均衡器一般要求支持 https 協議，這個時候就需要使用 Python 中的 ssl 模塊對證書進行校驗；
關於忽略訪問 https 協議的證書校驗，這裡忽略不表。重點講解 https 協議證書的校驗。在 Python 中，提供了 ssl 模塊，用於對 https 協議證書的認證。這裡以一段代碼來展示該模塊的應用。
import ssl
cont = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
cont.check_hostname = False
cont.load_cert_chain(certfile=public_key, keyfile=private_key)
cont.verify_mode = 2
cont.load_verify_locations(ca_key)
上述代碼中先生成 ssl 上下文對象 cont，接下來用這個上下文對象 cont 依次進行域名校驗、證書導入、驗證模式選擇及 CA 證書驗證。cont.checkhostname 用於域名校驗，值為 True 表示進行主機名校驗，值為 False 表示不進行主機名校驗。
cont.loadcertchain(certfile=publickey, keyfile=privatekey)，certfile 表示導入公鑰證書，keyfile 表示導入私鑰證書。一般情況下，Python 支持的 certfile 證書文件後綴為.crt，keyfile 證書文件後綴為.pem。cont.verifymode 為驗證模式，值為 0 表示不做證書校驗，值為 1 表示代表可選，值為 2 表示做證書校驗。cont.loadverifylocations(ca_key)表示導入CA 證書。一般的證書校驗都要經過上述這幾個步驟。此時 ssl 證書的基本配置已完成。接下來就需要在發送 https 請求時加入證書驗證環節，示例代碼如下：
req = request.Request(url=url, data=para, headers=headers, method='GET')
response = request.urlopen(req, context=self.context)
整個完整的 ssl 證書驗證代碼如下：
if __name__=='__main__':
from urllib import parse, request
import ssl
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.check_hostname = False
context.load_cert_chain(certfile=pub_key_cert_file, keyfile=pri_key_pem_file)
context.verify_mode = 2
context.load_verify_locations(ca_file)
req = request.Request(url=url, data=para, headers=headers, method='GET')
response = request.urlopen(req, context=self.context)
上述代碼中，我們選擇了 python 中 urllib 模塊做接口請求，是因為在多次對比了reuests模塊和 urllib 對 https 證書驗證的支持之後，發現 urllib 模塊能夠很好地支持 ssl 證書校驗。更多有關 python 中 ssl 模塊的信息，請參考 ssl 官方文檔
6、總結
回顧整個項目經過，應該說是是被現實問題逼著進步，從一開始的走捷徑使用 API集成工具來測試接口，到後來使用自動化測試腳本實現接口測試，再到最後增加對 https協議的支持。這一路走來，帶著遇到問題解決問題地思路，我的測試技能得到很大提升。總結這幾個月的項目經歷就一句話：遇到問題，解決問題，能力才會得到快速提升，與大家共勉。
請關注+私信回覆：“學習”就可以免費拿到軟件測試學習資料
"
"
引言：年初參與到一個後臺系統開發的項目中，裡面涉及了很多接口，我做為項目組測試人員，需要對這些接口進行測試，一開始使用 postman 工具測試，很是方便。但隨著接口數量的增加，不光要執行手動點擊測試，而且，一旦接口參數變動，都重新更改接口參數，次數多了，使得測試效率嚴重下降。
後來我將目光轉向了自動化測試，考慮到項目組對接口質量要求很高，需要快速開發。最終選定 python 作為腳本開發語言，使用其自帶的 requests 和 urllib 模塊進行接口請求，使用優化後的 unittest 測試框架編寫測試接口函數，測試結果選用 HTMLTestRunner 框架予以展示，並使用 python 的 ssl 模塊支持 https 協議的驗證。接下來，我詳細地介紹這些模塊，並給出各個模塊完整的測試代碼。
1、接口請求
python 特別是 python 3.x 中的 urllib 和 requests 模塊，是用來請求 url 的兩個主要模塊。這兩個模塊中，如果僅僅是支持 http 協議的 url 請求，推薦使用 requests 模塊。為什麼這麼說呢？因為愛因斯坦說過一句話：簡潔就是美。requests 模塊對 urllib 模塊又做了一層封裝，使用更加方便。該模塊支持 GET, POST, PUT, DELETE 等請求方法。請求返回信息包含狀態碼和消息體，狀態碼用三位數字表示，消息體可用字符串，二進制或json 等格式表示。下面用一個例子來介紹一下 requests 模塊的使用。代碼如下：
import requests
def get_method(url, para, headers):
try:
req = requests.get(url=url, params=para, headers=headers)
except Exception as e:
print(e)
else:
if req.status_code == "200":
return req
else:
print("Requests Failed.")
if __name__=='__main__':
url = "http://www.google.com"
req = get_method(url=url, para=None, headers=None)
print(req.status_code)
print(req.text)
輸出為：
200
<!DOCTYPE html>
<!--STATUS OK--><html> <head><meta...（省略）
上述程序輸出狀態碼為 200，表明請求成功，返回消息體為網頁內容。這裡我僅對requests 模塊中的 get 請求方法做了封裝，其它方法（如 post，put，delete 等）的封裝類似。當讓你也可以不用封裝，直接使用 requests.methodName 來直接調用該方法。這裡提醒一句，在實際的接口測試中，headers 和 data 都是有值的，要確保這些值的填寫正確，大部分請求下的請求失敗或返回結果錯誤，基本上都是由於這些值的缺失或錯誤造成的。更多關於 requests 模塊的介紹，請參考官方文檔。
2、測試框架優化
unittest 是 python 中進行單元測試使用廣泛的框架，其與 java 中的單元測試框架junit 類似。該框架使用簡單，需要編寫以 test 開頭的函數，選擇 unittest 框架運行測試函數，測試結果在終端顯示。這裡舉一個簡單的例子：
import unittest
class ApiTestSample(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
testResult = self.jiafa(input01=4, input02=5)
self.assertEqual(testResult, 9)
if __name__=='__main__':
unittest.main()
簡單解釋下這段代碼，首先我們創建一個類 ApiTestSample，這個類繼承自unittest.TestCase 類。然後在這個類中寫了 jiafa 函數，它有兩個參數 input01，input02，返回 input01 與 input02 相加的和。接著在 test_jiafa 方法中，我們對剛才 jiafa 函數進行了和值校驗。通過給 jiafa 輸入兩個值，獲取其函數返回值，並與真實值做相等判斷，以此實現函數單元測試。這裡用到了 unittest 中斷言值相等的 assertEqual(m, n)函數，上述代碼運行結果如下：
Ran 1 test in 0.000s
OK
以上是 unittest 框架最基本的單元測試應用，但是這個框架有個缺陷，就是不能自己傳入參數。對於接口來說，往往需要傳入很多參數，並且這每個參數又有很多取值，如果不對原先的 unittest 框架做改變，不僅無法用來進行接口測試，而且一個個結合參數取值去寫測試代碼，工作量極其龐大，也沒有實現測試數據與腳本沒有分離。基於此，我們對該框架做出一下兩點優化。
1）擴展 unittest.TestCase 類，支持自定義參數輸入；
2）測試數據與測試腳本分離，測試數據存儲在文件和數據庫中，以增強測試腳本複用性；
以下是對 unittest.TestCase 類的擴展，使其支持參數化把參數加進去。下面是具體的代碼實現過程：
class ExtendTestCaseParams(unittest.TestCase):
#擴展 unittest.TestCase 類，使其支持自定義參數輸入
def __init__(self, method_name='runTest', canshu=None):
super(ExtendTestCaseParams, self).__init__(method_name)
self.canshu = canshu
#靜態參數化方法
@staticmethod
def parametrize(testcase_klass, default_name=None, canshu=None):
""" Create a suite containing all tests taken from the given
subclass, passing them the parameter 'canshu'
"""
test_loader = unittest.TestLoader()
testcase_names = test_loader.getTestCaseNames(testcase_klass)
suite = unittest.TestSuite()
if default_name != None:
for casename in testcase_names:
if casename == defName:
suite.addTest(testcase_klass(casename, canshu=canshu))
else:
for casename in testcase_names:
suite.addTest(testcase_klass(casename, canshu=canshu))
return suite
這裡，canshu 就是優化後加的自定義參數，參數類型可以是元組或列表。下面使用這個參數化類來改寫之前的代碼。
class ApiTestSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def jiafa(self, input01, input02):
result = input01 + input02
return result
def test_jiafa(self):
input_01 = self.param[0]
input_02 = self.param[1]
expectedResult = self.param[2]
result = self.sub(input_01, input_02)
print(result)
self.assertEqual(result, expectedResult)
if __name__=='__main__':
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample, 'test_jiafa', canshu=i))
runner = unittest.TextTestRunner()
runner.run(suite)
執行結果如下：
....
## 19
25
Ran 4 tests in 0.000s
22
6
OK
通過對 unittest 框架優化，我們實現了 unittest 框架的參數化，這樣就可以用於接口測試了。雖然我們實現了參數化，但是測試結果的展示不夠直觀，這個時候需要一個可視化頁面來直接顯示測試結果。所幸的是，python 中有專門展示測試結果的框架：HTMLTestRunner。該框架可以將測試結果轉換為 HTML 頁面，並且該框架可以和unittest 框架完美的結合起來。接下來我們講述一下 HTMLTestRunner 框架的使用。
3、測試結果可視化
HTMLTestRunner 框架可用來生成可視化測試報告，並能很好的與 unittest 框架結合使用，接下來我們以一段代碼來展示一下 HTMLTestRunner 的使用。
if __name__=='__main__':
from HTMLTestRunner import HTMLTestRunner
testData = [
(10, 9, 19),
(12, 13, 25),
(12, 10, 22),
(2, 4, 6)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(ApiTestSample,'test_jiafa',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
result_path = './test_results'
if not os.path.exists(path):
os.makedirs(path)
report_path = result_path + '/' + currentTime + "_report.html"
reportTitle = '測試報告'
desc = u'測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
測試結果如下：
下面詳細講解一下 html 報告的生成代碼：
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
HTMLTestRunner 中的 stream 表示輸入流，這裡我們將文件描述符傳遞給 stream，title 參數表示要輸出的測試報告主題名稱，description 參數是對測試報告的描述。在使用 HTMLTestRunner 時，有幾點需要注意：
1）HTMLTestRunner 模塊非 Python 自帶庫，需要到 HTMLTestRunner 的官網下載
該安裝包；
2）官網的 HTMLTestRunner 模塊僅支持 Python 2.x 版本，如果要在 Python 3.x中，需要修改部分代碼，修改的代碼部分請自行上網搜索；
如果需要生成 xml 格式，只需將上面代碼中的
runner = HTMLTestRunner(stream=fp, title=reportTitle, description=desc)
runner.run(suite)
修改為如下代碼
import xmlrunner
runner = xmlrunner.XMLTestRunner(output='report')
runner.run(suite)
4、接口測試分類
前面大家對接口請求，測試框架和測試結果可視化方面有了深入的瞭解。有了前面的基礎，對於接下來理解和編寫接口測試會有很大幫助。這裡我們先來講解一下接口測試與單元測試的區別。單元測試只針對函數進行多組參數測試，包括正常和異常參數組合。而接口測試是針對某一接口進行多組參數測試。實際接口測試中，我們又將接口測試分為兩種：
1）單接口測試；
2）多接口測試。
對於單接口測試，只需針對單個接口測試，測試數據根據接口文檔中的參數規則來設計測試用例；對多接口測試，首先要確保接口之間調用邏輯正確，然後再根據接口文檔中的參數規則來設計用例進行測試。下面我就根據這兩種不同情況的接口測試，用實際項目代碼展示一下。
4.1 單接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'http://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def test_register(self):
for index, value in enumerate(self.param):
print('Test Token {0} parameter is {1}'.format(index, value)）
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expectedValue = self.param[4]
req = self.grant_register(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expectedValue, msg="Test Failed.")
if __name__=='__main__':
import random
import string
ip = '172.36.17.108'
testData = [
(1, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ip, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample,'test_register',canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = './results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中的 register()為註冊接口函數，test_register()為測試註冊接口函數，testData 為測試數據，這裡沒有完全做到測試腳本與測試數據分離。為了實現測試數據與測試腳本分離，可以將 testData 列表單獨寫在文本文件或者數據庫中，運行測試腳本時再去加載這些數據，就能實現測試腳本與測試數據的分離。
4.2 多接口測試
class TestApiSample(ExtendTestCaseParams):
def setUp(self):
pass
def tearDown(self):
pass
def register(self, ip, name, desc):
url = 'https://%s/api/v1/reg' % ip
headers = {"Content-Type": "application/x-www-form-urlencoded"}
para = {"app_name": name, "description": desc}
req = self.Post(url, para, headers）
return req
def oauth2_basic(self, ip, name, desc):
apps = self.register(ip, name, desc)
apps = apps.json()
url = 'http://%s/api/v1/basic' % ip
data = {"client_id":apps['appId'], "client_secret":apps['appKey']}
headers = None
req = requests.post(url, data, headers)
basic = str(req.content, encoding='utf-8')
return apps, basic, req
def test_oauth2_basic(self):
count = 0
for i in self.param:
count += 1
self.ip = self.param[1]
self.name = self.param[2]
self.desc = self.param[3]
self.expected = self.param[4]
apps, basic, req = self.oauth2_basic(self.ip, self.name, self.desc)
self.assertIn(req.status_code, self.expected, msg="Grant Failed.")
if __name__=='__main__':
import random
import string
ipAddr = '172.36.17.108'
testData = [
(1, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(2, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200),
(3, ipAddr, ''.join(random.sample(string.ascii_letters + string.digits, 7)), '', 200)
]
suite = unittest.TestSuite()
for i in testData:
suite.addTest(ExtendTestCaseParams.parametrize(TestApiSample, 'test_oauth2_basic',
canshu=i))
currentTime = time.strftime("%Y-%m-%d %H_%M_%S")
path = '../Results'
if not os.path.exists(path):
os.makedirs(path)
report_path = path + '/' + currentTime + "_report.html"
reportTitle = '接口測試報告'
desc = u'接口測試報告詳情'
with open(report_path, 'wd') as f:
runner = HTMLTestRunner(stream=f, title=reportTitle, description=desc)
runner.run(suite)
上述代碼中，我們對兩個接口進行了函數封裝，兩個接口之間有依賴關係，oauth2_basic()函數在請求之前必須先去請求 register()函數獲取數據。對於這種多接口測試，且接口之間存在互相調用的情況，最好是在調用該接口前時，將互相之間有依賴的接口封裝進該接口中，保證接口調用邏輯一致。其次再針對該接口的其它參數設計測試用例去測試該接口。
5、https 協議請求
前面我們提及的接口測試，僅是關於請求 http 協議的。然而，http 協議在傳輸過程中並不安全，通過該協議傳輸內容容易被截取，由此人們提出了 https 協議。該協議在原先的 http 協議之外，對傳輸過程中的內容進行了加密處理，這樣就能確保信息在傳輸過程中的安全。目前很多公司的訪問 url 都已轉換到 https 協議。因此在接口測試中也要考慮到對 https 協議訪問的支持。目前對於 https 協議訪問的處理有以下幾種方案。
第一種，對於一般網站訪問，無法獲得支持 https 協議的證書信息，因此只能選擇忽略 ssl 校驗；
第二種，對於外部網絡訪問公司內容網絡和內容來說，除了要經過防火牆外，訪問具體業務要經過負載均衡器。而負載均衡器一般要求支持 https 協議，這個時候就需要使用 Python 中的 ssl 模塊對證書進行校驗；
關於忽略訪問 https 協議的證書校驗，這裡忽略不表。重點講解 https 協議證書的校驗。在 Python 中，提供了 ssl 模塊，用於對 https 協議證書的認證。這裡以一段代碼來展示該模塊的應用。
import ssl
cont = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
cont.check_hostname = False
cont.load_cert_chain(certfile=public_key, keyfile=private_key)
cont.verify_mode = 2
cont.load_verify_locations(ca_key)
上述代碼中先生成 ssl 上下文對象 cont，接下來用這個上下文對象 cont 依次進行域名校驗、證書導入、驗證模式選擇及 CA 證書驗證。cont.checkhostname 用於域名校驗，值為 True 表示進行主機名校驗，值為 False 表示不進行主機名校驗。
cont.loadcertchain(certfile=publickey, keyfile=privatekey)，certfile 表示導入公鑰證書，keyfile 表示導入私鑰證書。一般情況下，Python 支持的 certfile 證書文件後綴為.crt，keyfile 證書文件後綴為.pem。cont.verifymode 為驗證模式，值為 0 表示不做證書校驗，值為 1 表示代表可選，值為 2 表示做證書校驗。cont.loadverifylocations(ca_key)表示導入CA 證書。一般的證書校驗都要經過上述這幾個步驟。此時 ssl 證書的基本配置已完成。接下來就需要在發送 https 請求時加入證書驗證環節，示例代碼如下：
req = request.Request(url=url, data=para, headers=headers, method='GET')
response = request.urlopen(req, context=self.context)
整個完整的 ssl 證書驗證代碼如下：
if __name__=='__main__':
from urllib import parse, request
import ssl
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.check_hostname = False
context.load_cert_chain(certfile=pub_key_cert_file, keyfile=pri_key_pem_file)
context.verify_mode = 2
context.load_verify_locations(ca_file)
req = request.Request(url=url, data=para, headers=headers, method='GET')
response = request.urlopen(req, context=self.context)
上述代碼中，我們選擇了 python 中 urllib 模塊做接口請求，是因為在多次對比了reuests模塊和 urllib 對 https 證書驗證的支持之後，發現 urllib 模塊能夠很好地支持 ssl 證書校驗。更多有關 python 中 ssl 模塊的信息，請參考 ssl 官方文檔
6、總結
回顧整個項目經過，應該說是是被現實問題逼著進步，從一開始的走捷徑使用 API集成工具來測試接口，到後來使用自動化測試腳本實現接口測試，再到最後增加對 https協議的支持。這一路走來，帶著遇到問題解決問題地思路，我的測試技能得到很大提升。總結這幾個月的項目經歷就一句話：遇到問題，解決問題，能力才會得到快速提升，與大家共勉。
請關注+私信回覆：“學習”就可以免費拿到軟件測試學習資料
相關推薦
'乾貨分享｜Python中最常用的字符串方法'
"字符串是字符序列。Python中內置的string類代表基於Unicode國際字符集的字符串。除了Python中常見的操作外，字符串還有一些專屬於它們的附加方法。下圖顯示了所有這些可用的方法:Python中的內置字符串函數在本文中，我們將學習一些最常用的方法。這裡需要注意...
一篇乾貨好文，輕鬆掌握python魔法方法
在python學習中，往往你會看到有的名稱前面和後面都加上了雙下劃線，這種寫法很特別，到底是什麼意思呢？在python 中由這些名字組成的集合所包含的方法...
Java：反射功能和API簡介、4個反射方法的代碼實戰、反射的優劣勢
1. Java反射的概念和提供的功能 （1）概念在Java運行時的環境中，動態獲取類的信息以及動態調用對象的方法的功能叫反射機制（Reflection）（...
6步驟帶你瞭解樸素貝葉斯分類器（含Python和R語言代碼）
本文最初由Sunil Ray發表於2015年9月13日，作者於2017年9月進行了更新。假設你正在處理一個分類問題，你已經形成了一些假設，建立了一套特徵並...
GET 技巧！python模塊性能測試
算法是程序的靈魂,，優秀的算法能給程序的效率帶來極大的提升，而算法的優劣,往往要經過大量的測試。在硬件環境基本不變的前提下，對算法實驗的次數越多，測試算法...
Python接口測試，Requests模塊講解：GET、POST、Cookies、Session等
文章最下方有對應課程的視頻鏈接哦^_^一、安裝、GET，公共方法二、POST三、Cookies四、Session五、認證六、超時配置、代理、事件鉤子七、錯...
推薦中...