「第二十六章」 搭建接口自动化测试框架
26.1 为什么要开发Python3 接口测试框架
先看教育局招生管理系统登录接口用例。
import requests
from bs4 import BeautifulSoup
import xlrd
import json
def readExcel(rowx, filePath='data.xls'):
'''
读取excel中数据并且返回
:parameter filePath:xlsx文件名称
:parameter rowx:在excel中的行数
'''
book = xlrd.open_workbook(filePath)
sheet = book.sheet_by_index(0)
return sheet.row_values(rowx)
#提取第一个测试用例数据
print("第一行数据内容：",readExcel(2))
#查看数据的类型
print("数据类型：{0}：".format(type(readExcel(2))))
# 从列表中提取url
url = readExcel(2)[3]
print(url)
# 从列表中提取data参数
# 由于JSON中，标准语法中，不支持单引号，属性或者属性值，都必须是双引号括起来,用字符串方法replace("'",'\"')进行处理
data1 =readExcel(2)[4].replace("'",'\"')
#因为请求参数数据类型是字典，所以进行了反序列化的处理。
data = json.loads(data1)
print(data)
print(type(data))
print("---------------------------------------------")
#招生系统接口例子
headers = {
"Connection": "keep-alive",
"User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36",
"Referer": "http://127.0.0.1:8090/recruit.students/login/view",
}
# URL参数
payload = data
# 发送get请求
response = requests.get(url,headers = headers,params=payload)
# 打印请求response后的URL
print(response.url)
# 查看响应内容，response.text 返回的是Unicode格式的数据
print(response.text)
# 查看响应码
print(response.status_code)
从教育局招生管理系统登录接口用例中，我们看到，要完成一个接口测试，需要写很多行的代码，一个完整的系统测试，测试用例可能有100~1000个，那么如果每个用例都一个一个这样写，那么编写用例和维护用例的成本就很高，而且代码很多，不直观。
随着自动化测试的不断推广，各家软件科技公司也不断的引进了专门的自动化测试人员，一个完整的系统测试，测试用例中有许多共用的模块和方法，不需要每个人都重复去写，这就需要有资深的测试专家去规划一个项目的自动化测试框架。
同时，接口测试生成测试报告，发送给相关的领导，也是需要一个完整的接口自动化测试框架。
26.2 Python3 接口自动化测试框架介绍
a) 基于 python 脚本编写，不需要借助其他工具，环境配置简单。
b) 采用数据驱动测试的方式，后期仅仅只需要维护一个测试数据。
c) 测试用例可以分模块编写，方便对用例的管理维护。
d) 测试用例和测试执行分离，实现执行测试时用例可以任意配置。
e) 实现多线程执行，可以同时运行多个测试集。
f) 测试结束后直接生成测试报告，统计测试执行情况，执行情况详细，能够快速定位问题，并且容易扩展优化。
26.3 框架流程说明
26.4 框架的目录结构
【common】：存放公共的方法。
【result】：执行过程中生成的文件夹，里面存放每次测试的结果。
【testCase】：用于存放具体的测试case。
【testFile】：存放测试过程中用到的文件，包括上传的文件，测试用例数据驱动以及数据库的sql语句。
【caselist】：caselist.txt文件，配置每次执行的case名称。
【config】：配置一些常量，例如数据库的相关信息，接口的相关信息等。
【readConfig】：用于读取config配置文件中的内容
【runAll】：用于执行case，生成测试报告。
上面是整个Python3接口测试框架的目录结构，下面对每一块进行介绍。
26.5 config.ini 和 readConfig.py
ini 文件其实就是所谓的初始化配置文件，一般的格式为：
[SECTION0]
key0 = value0
key1 = value1
config.ini 文件的内容：
[EMAIL]
mail_host = smtp.163.com
mail_user = [email protected]
mail_pass = 123456
mail_port = 25
sender = [email protected]
receiver = [email protected]/[email protected]
subject = Interface Test Report
content = "All interface test has been complited\\nplease read the report file about the detile of result in the attachment."
testuser = Someone
on_off = off
[HTTP]
scheme = http
baseurl = www.baidu.com
port = 8080
timeout = 10.0
[HEADERS]
siteuid = all
clientid = 100
token_v = 213612368807_5811a363c85b19.22399915_75e4ee2761d60f2d7597eaec2579297f1cd7f6e3
token_u = 320012369021_586b1c65c3b3c1.51719831_e76832dc51f7ec8de0ba6ecdd69c8b7658dee93c
[DATABASE]
host = localhost
username = root
password = root
port = 3306
database = test
这个文件是整个Python3接口测试框架的配置文件，主要用来配置一些固定不变的参数。我们在测试用例中使用这些配置文件的内容，就需要使用readConfig.py去读取。
readConfig.py文件的代码。
import os
#导入codecs模块，使用codecs模块进行文件操作
import codecs
#导入configparser模块,python3 用ConfigParser包处理 ini文件
import configparser
#获取config.ini 文件路径
proDir = os.path.split(os.path.realpath(__file__))[0]
configPath = os.path.join(proDir, "config.ini")
class ReadConfig:
def __init__(self):
fd = open(configPath)
data = fd.read()
# remove BOM
if data[:3] == codecs.BOM_UTF8:
data = data[3:]
file = codecs.open(configPath, "w")
file.write(data)
file.close()
fd.close()
self.cf = configparser.ConfigParser()
self.cf.read(configPath)
def get_email(self, name):
value = self.cf.get("EMAIL", name)
return value
def get_http(self, name):
value = self.cf.get("HTTP", name)
return value
def get_headers(self, name):
value = self.cf.get("HEADERS", name)
return value
def set_headers(self, name, value):
self.cf.set("HEADERS", name, value)
with open(configPath, 'w+') as f:
self.cf.write(f)
def get_url(self, name):
value = self.cf.get("URL", name)
return value
def get_db(self, name):
value = self.cf.get("DATABASE", name)
return value
readConfig.py文件定义了相应的方法，根据名称取对应的值。
26.6 common 文件夹
配置文件和读取配置文件已经介绍，接下来就可以写common里的共通方法。
【Log.py】：Log 模块是一个独立的模块，对输出的日志的所有操作。
【configHttp.py】：configHttp 模块是接口配置文件。
【common】：common 模块 是数据驱动的配置文件。
【configDB 模块】：configDB 模块主要是封装了操作mysql数据的相关操作方法。
【configEmail 模块】：configEmail 模块主要是封装了发送邮件的相关方法。
【businessCommon 模块】：businessCommon 模块封装了登录和登录退出的方法。
26.6.1 Log.py 模块
Log.py 模块主要是对输出格式的规定，输出等级的定义以及其他一些输出的定义等。
import os,sys
import readConfig as readConfig
import logging
from datetime import datetime
import threading
localReadConfig = readConfig.ReadConfig()
class Log:
def __init__(self):
global logPath, resultPath, proDir
proDir = readConfig.proDir
resultPath = os.path.join(proDir, "result")
if not os.path.exists(resultPath):
os.mkdir(resultPath)
logPath = os.path.join(resultPath, str(datetime.now().strftime("%Y%m%d%H%M%S")))
if not os.path.exists(logPath):
os.mkdir(logPath)
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
# defined handler
handler = logging.FileHandler(os.path.join(logPath, "output.log"))
# defined formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def get_logger(self):
"""
get logger
:return:
"""
return self.logger
def build_start_line(self, case_no):
"""
write start line
:return:
"""
self.logger.info("--------" + case_no + " START--------")
def build_end_line(self, case_no):
"""
write end line
:return:
"""
self.logger.info("--------" + case_no + " END--------")
def build_case_line(self, case_name, code, msg):
"""
write test case line
:param case_name:
:param code:
:param msg:
:return:
"""
self.logger.info(case_name+" - Code:"+code+" - msg:"+msg)
def get_report_path(self):
"""
get report file path
:return:
"""
report_path = os.path.join(logPath, "report.html")
return report_path
def get_result_path(self):
"""
get test result path
:return:
"""
return logPath
def write_result(self, result):
"""
:param result:
:return:
"""
result_path = os.path.join(logPath, "report.txt")
fb = open(result_path, "wb")
try:
fb.write(result)
except FileNotFoundError as ex:
logger.error(str(ex))
class MyLog:
log = None
mutex = threading.Lock()
def __init__(self):
pass
@staticmethod
def get_log():
if MyLog.log is None:
MyLog.mutex.acquire()
MyLog.log = Log()
MyLog.mutex.release()
return MyLog.log
if __name__ == "__main__":
log = MyLog.get_log()
logger = log.get_logger()
logger.debug("test debug")
logger.info("test info")
26.6.2 configHttp.py 模块
configHttp.py 模块代码：
import requests
import readConfig as readConfig
from common.Log import MyLog as Log
import json
localReadConfig = readConfig.ReadConfig()
class ConfigHttp:
def __init__(self):
global scheme, host, port, timeout
scheme = localReadConfig.get_http("scheme")
host = localReadConfig.get_http("baseurl")
port = localReadConfig.get_http("port")
timeout = localReadConfig.get_http("timeout")
self.log = Log.get_log()
self.logger = self.log.get_logger()
self.headers = {}
self.params = {}
self.data = {}
self.url = None
self.files = {}
self.state = 0
def set_url(self, url):
"""
set url
:param: interface url
:return:
"""
self.url = scheme+'://'+host+url
def set_headers(self, header):
"""
set headers
:param header:
:return:
"""
self.headers = header
def set_params(self, param):
"""
set params
:param param:
:return:
"""
self.params = param
def set_data(self, data):
"""
set data
:param data:
:return:
"""
self.data = data
def set_files(self, filename):
"""
set upload files
:param filename:
:return:
"""
if filename != '':
file_path = 'F:/AppTest/Test/interfaceTest/testFile/img/' + filename
self.files = {'file': open(file_path, 'rb')}
if filename == '' or filename is None:
self.state = 1
# defined http get method
def get(self):
"""
defined get method
:return:
"""
try:
response = requests.get(self.url, headers=self.headers, params=self.params, timeout=float(timeout))
# response.raise_for_status()
return response
except TimeoutError:
self.logger.error("Time out!")
return None
# defined http post method
# include get params and post data
# uninclude upload file
def post(self):
"""
defined post method
:return:
"""
try:
response = requests.post(self.url, headers=self.headers, params=self.params, data=self.data, timeout=float(timeout))
# response.raise_for_status()
return response
except TimeoutError:
self.logger.error("Time out!")
return None
# defined http post method
# include upload file
def postWithFile(self):
"""
defined post method
:return:
"""
try:
response = requests.post(self.url, headers=self.headers, data=self.data, files=self.files, timeout=float(timeout))
return response
except TimeoutError:
self.logger.error("Time out!")
return None
# defined http post method
# for json
def postWithJson(self):
"""
defined post method
:return:
"""
try:
response = requests.post(self.url, headers=self.headers, json=self.data, timeout=float(timeout))
return response
except TimeoutError:
self.logger.error("Time out!")
return None
if __name__ == "__main__":
print("ConfigHTTP")
configHttp.py 模块说明：
接口测试框架用python3自带的requests来进行接口请求测试。里面封装了get和post两个方法。
【get方法】
对于requests提供的get方法，有几个常用的参数：
url：接口的url地址。
headers：定制请求头（headers），例如：content-type = application/x-www-form-urlencoded。
params：用于传递测试接口所要用的参数，这里我们用python中的字典形式（key：value）进行参数的传递。
timeout：设置接口连接的最大时间（超过该时间会抛出超时错误）
例子:
url=‘http://api.shein.com/v2/member/logout’
header={‘content-type’： application/x-www-form-urlencoded}
param={‘user_id’： 123456,‘email’： [email protected]}
timeout=0.5
requests.get（url, headers=header, params=param, timeout=timeout）
【post方法】
与get方法类似，只要设置好对应的参数，就可以了
例子：
url=‘http://api.shein.com/v2/member/login’
header={‘content-type’： application/x-www-form-urlencoded}
data={‘email’： [email protected],‘password’： 123456}
timeout=0.5
requests.post（url, headers=header, data=data, timeout=timeout）
备注：post 方法中的参数，我们不是使用 params 进行传递，而是改用 data 进行传递。
26.6.3 common.py 模块
common.py 模块代码：
import requests
import readConfig as readConfig
import os
from xlrd import open_workbook
from xml.etree import ElementTree as ElementTree
from common import configHttp as configHttp
from common.Log import MyLog as Log
import json
localReadConfig = readConfig.ReadConfig()
proDir = readConfig.proDir
localConfigHttp = configHttp.ConfigHttp()
log = Log.get_log()
logger = log.get_logger()
caseNo = 0
def get_visitor_token():
"""
create a token for visitor
:return:
"""
host = localReadConfig.get_http("BASEURL")
response = requests.get(host+"/v2/User/Token/generate")
info = response.json()
token = info.get("info")
logger.debug("Create token:%s" % (token))
return token
def set_visitor_token_to_config():
"""
set token that created for visitor to config
:return:
"""
token_v = get_visitor_token()
localReadConfig.set_headers("TOKEN_V", token_v)
def get_value_from_return_json(json, name1, name2):
"""
get value by key
:param json:
:param name1:
:param name2:
:return:
"""
info = json['info']
group = info[name1]
value = group[name2]
return value
def show_return_msg(response):
"""
show msg detail
:param response:
:return:
"""
url = response.url
msg = response.text
print("\\n请求地址："+url)
# 可以显示中文
print("\\n请求返回值："+'\\n'+json.dumps(json.loads(msg), ensure_ascii=False, sort_keys=True, indent=4))
# ****************************** read testCase excel ********************************
def get_xls(xls_name, sheet_name):
"""
get interface data from xls file
:return:
"""
cls = []
# get xls file's path
xlsPath = os.path.join(proDir, "testFile", 'case', xls_name)
# open xls file
file = open_workbook(xlsPath)
# get sheet by name
sheet = file.sheet_by_name(sheet_name)
# get one sheet's rows
nrows = sheet.nrows
for i in range(nrows):
if sheet.row_values(i)[0] != u'case_name':
cls.append(sheet.row_values(i))
return cls
# ****************************** read SQL xml ********************************
database = {}
def set_xml():
"""
set sql xml
:return:
"""
if len(database) == 0:
sql_path = os.path.join(proDir, "testFile", "SQL.xml")
tree = ElementTree.parse(sql_path)
for db in tree.findall("database"):
db_name = db.get("name")
# print(db_name)
table = {}
for tb in db.getchildren():
table_name = tb.get("name")
# print(table_name)
sql = {}
for data in tb.getchildren():
sql_id = data.get("id")
# print(sql_id)
sql[sql_id] = data.text
table[table_name] = sql
database[db_name] = table
def get_xml_dict(database_name, table_name):
"""
get db dict by given name
:param database_name:
:param table_name:
:return:
"""
set_xml()
database_dict = database.get(database_name).get(table_name)
return database_dict
def get_sql(database_name, table_name, sql_id):
"""
get sql by given name and sql_id
:param database_name:
:param table_name:
:param sql_id:
:return:
"""
db = get_xml_dict(database_name, table_name)
sql = db.get(sql_id)
return sql
# ****************************** read interfaceURL xml ********************************
def get_url_from_xml(name):
"""
By name get url from interfaceURL.xml
:param name: interface's url name
:return: url
"""
url_list = []
url_path = os.path.join(proDir, 'testFile', 'interfaceURL.xml')
tree = ElementTree.parse(url_path)
for u in tree.findall('url'):
url_name = u.get('name')
if url_name == name:
for c in u.getchildren():
url_list.append(c.text)
url = '/v2/' + '/'.join(url_list)
return url
if __name__ == "__main__":
print(get_xls("login"))
set_visitor_token_to_config()
common.py 模块主要是封装了数据驱动的各种方法（读取xml文件、读取excel文件，读取mysql数据库数据），测试用例就是通过 excel 文件来管理测试用例的。
26.6.4 configDB 模块
configDB 模块代码：
import pymysql
import readConfig as readConfig
from common.Log import MyLog as Log
localReadConfig = readConfig.ReadConfig()
class MyDB:
global host, username, password, port, database, config
host = localReadConfig.get_db("host")
username = localReadConfig.get_db("username")
password = localReadConfig.get_db("password")
port = localReadConfig.get_db("port")
database = localReadConfig.get_db("database")
config = {
'host': str(host),
'user': username,
'passwd': password,
'port': int(port),
'db': database
}
def __init__(self):
self.log = Log.get_log()
self.logger = self.log.get_logger()
self.db = None
self.cursor = None
def connectDB(self):
"""
connect to database
:return:
"""
try:
# connect to DB
self.db = pymysql.connect(**config)
# create cursor
self.cursor = self.db.cursor()
print("Connect DB successfully!")
except ConnectionError as ex:
self.logger.error(str(ex))
def executeSQL(self, sql, params):
"""
execute sql
:param sql:
:return:
"""
self.connectDB()
# executing sql
self.cursor.execute(sql, params)
# executing by committing to DB
self.db.commit()
return self.cursor
def get_all(self, cursor):
"""
get all result after execute sql
:param cursor:
:return:
"""
value = cursor.fetchall()
return value
def get_one(self, cursor):
"""
get one result after execute sql
:param cursor:
:return:
"""
value = cursor.fetchone()
return value
def closeDB(self):
"""
close database
:return:
"""
self.db.close()
print("Database closed!")
configDB 模块主要是封装了操作mysql数据的相关操作方法（连接数据库，执行sql，获取结果，最后关闭数据库）。
26.6.5 configEmail 模块
configEmail 模块代码：
import os
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from datetime import datetime
import threading
import readConfig as readConfig
from common.Log import MyLog
import zipfile
import glob
localReadConfig = readConfig.ReadConfig()
class Email:
def __init__(self):
global host, user, password, port, sender, title
host = localReadConfig.get_email("mail_host")
user = localReadConfig.get_email("mail_user")
password = localReadConfig.get_email("mail_pass")
port = localReadConfig.get_email("mail_port")
sender = localReadConfig.get_email("sender")
title = localReadConfig.get_email("subject")
# content = localReadConfig.get_email("content")
# get receiver list
self.value = localReadConfig.get_email("receiver")
self.receiver = []
for n in str(self.value).split("/"):
self.receiver.append(n)
# defined email subject
date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
self.subject = "接口测试报告" + " " + date
self.log = MyLog.get_log()
self.logger = self.log.get_logger()
self.msg = MIMEMultipart('related')
def config_header(self):
"""
defined email header include subject, sender and receiver
:return:
"""
self.msg['subject'] = self.subject
self.msg['from'] = sender
self.msg['to'] = ";".join(self.receiver)
def config_content(self):
"""
write the content of email
:return:
"""
f = open(os.path.join(readConfig.proDir, 'testFile', 'emailStyle.txt'))
content = f.read()
f.close()
content_plain = MIMEText(content, 'html', 'UTF-8')
self.msg.attach(content_plain)
self.config_image()
def config_image(self):
"""
config image that be used by content
:return:
"""
# defined image path
image1_path = os.path.join(readConfig.proDir, 'testFile', 'img', '1.png')
fp1 = open(image1_path, 'rb')
msgImage1 = MIMEImage(fp1.read())
# self.msg.attach(msgImage1)
fp1.close()
# defined image id
msgImage1.add_header('Content-ID', '<image1>')/<image1>
self.msg.attach(msgImage1)
image2_path = os.path.join(readConfig.proDir, 'testFile', 'img', 'logo.jpg')
fp2 = open(image2_path, 'rb')
msgImage2 = MIMEImage(fp2.read())
# self.msg.attach(msgImage2)
fp2.close()
# defined image id
msgImage2.add_header('Content-ID', '<image2>')/<image2>
self.msg.attach(msgImage2)
def config_file(self):
"""
config email file
:return:
"""
# if the file content is not null, then config the email file
if self.check_file():
reportpath = self.log.get_result_path()
zippath = os.path.join(readConfig.proDir, "result", "test.zip")
# zip file
files = glob.glob(reportpath + '\\*')
f = zipfile.ZipFile(zippath, 'w', zipfile.ZIP_DEFLATED)
for file in files:
# 修改压缩文件的目录结构
f.write(file, '/report/'+os.path.basename(file))
f.close()
reportfile = open(zippath, 'rb').read()
filehtml = MIMEText(reportfile, 'base64', 'utf-8')
filehtml['Content-Type'] = 'application/octet-stream'
filehtml['Content-Disposition'] = 'attachment; filename="test.zip"'
self.msg.attach(filehtml)
def check_file(self):
"""
check test report
:return:
"""
reportpath = self.log.get_report_path()
if os.path.isfile(reportpath) and not os.stat(reportpath) == 0:
return True
else:
return False
def send_email(self):
"""
send email
:return:
"""
self.config_header()
self.config_content()
self.config_file()
try:
smtp = smtplib.SMTP()
smtp.connect(host)
smtp.login(user, password)
smtp.sendmail(sender, self.receiver, self.msg.as_string())
smtp.quit()
self.logger.info("The test report has send to developer by email.")
except Exception as ex:
self.logger.error(str(ex))
class MyEmail:
email = None
mutex = threading.Lock()
def __init__(self):
pass
@staticmethod
def get_email():
if MyEmail.email is None:
MyEmail.mutex.acquire()
MyEmail.email = Email()
MyEmail.mutex.release()
return MyEmail.email
if __name__ == "__main__":
email = MyEmail.get_email()
configEmail 模块主要是封装了发送邮件的相关方法（每次测试完之后，都会生成一份测试报告，并且把测试报告以附件的形式，通过email发送给相关的邮箱）。
26.6.6 businessCommon 模块
businessCommon 模块代码：
from common import common
from common import configHttp
import readConfig as readConfig
localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localLogin_xls = common.get_xls("userCase.xlsx", "login")
localAddAddress_xls = common.get_xls("userCase.xlsx", "addAddress")
# login
def login():
"""
login
:return: token
"""
# set url
url = common.get_url_from_xml('login')
localConfigHttp.set_url(url)
# set header
token = localReadConfig.get_headers("token_v")
header = {"token": token}
localConfigHttp.set_headers(header)
# set param
data = {"email": localLogin_xls[0][3],
"password": localLogin_xls[0][4]}
localConfigHttp.set_data(data)
# login
response = localConfigHttp.post().json()
token = common.get_value_from_return_json(response, "member", "token")
return token
# logout
def logout(token):
"""
logout
:param token: login token
:return:
"""
# set url
url = common.get_url_from_xml('logout')
localConfigHttp.set_url(url)
# set header
header = {'token': token}
localConfigHttp.set_headers(header)
# logout
localConfigHttp.get()
businessCommon 模块封装了登录和登录退出的方法，因为每个测试用例都用到。
26.7 runAll 文件
runAll 文件代码：
import os
import unittest
import time as t
from common.Log import MyLog as Log
import readConfig as readConfig
import HTMLTestRunner
from common.configEmail import MyEmail
localReadConfig = readConfig.ReadConfig()
class AllTest:
def __init__(self):
global log, logger, resultPath, on_off
log = Log.get_log()
logger = log.get_logger()
resultPath = log.get_report_path()
on_off = localReadConfig.get_email("on_off")
self.caseListFile = os.path.join(readConfig.proDir, "caselist.txt")
self.caseFile = os.path.join(readConfig.proDir, "testCase")
# self.caseFile = None
self.caseList = []
self.email = MyEmail.get_email()
def set_case_list(self):
"""
set case list
:return:
"""
fb = open(self.caseListFile)
for value in fb.readlines():
data = str(value)
if data != '' and not data.startswith("#"):
self.caseList.append(data.replace("\\n", ""))
fb.close()
def set_case_suite(self):
"""
set case suite
:return:
"""
self.set_case_list()
test_suite = unittest.TestSuite()
suite_module = []
for case in self.caseList:
case_name = case.split("/")[-1]
print(case_name+".py")
discover = unittest.defaultTestLoader.discover(self.caseFile, pattern=case_name + '.py', top_level_dir=None)
suite_module.append(discover)
if len(suite_module) > 0:
for suite in suite_module:
for test_name in suite:
test_suite.addTest(test_name)
else:
return None
return test_suite
def run(self):
"""
run test
:return:
"""
try:
suit = self.set_case_suite()
if suit is not None:
logger.info("********TEST START********")
fp = open(resultPath, 'wb')
runner = HTMLTestRunner.HTMLTestRunner(stream=fp, title='Test Report', description='Test Description')
runner.run(suit)
else:
logger.info("Have no case to test.")
except Exception as ex:
logger.error(str(ex))
finally:
logger.info("*********TEST END*********")
fp.close()
# send test report by email
if on_off == 'on':
self.email.send_email()
elif on_off == 'off':
logger.info("Doesn't send report email to developer.")
else:
logger.info("Unknow state.")
if __name__ == '__main__':
obj = AllTest()
obj.run()
runAll的执行原理，首先我们要从 caselist.txt 文件中读取需要执行的 case 名称，然后将他们添加到 python3 自带的 unittest 测试集的测试套件中，最后执行run()函数，执行测试集。
26.8 result 文件
result文件夹会在首次执行case时生成，并且以后的测试结果都会被保存在该文件夹下，同时每次测试的文件夹都是用系统时间命名，里面包含了两个文件，log文件和测试报告。
26.9 caselist.txt文件
caselist.txt文件存放了要执行的测试用例名称，凡是没有被注释掉的，都是要被执行的case名称。
26.10 testFile文件夹
testFile文件夹下，case文件夹下放置我们测试时用来管理测试用例, img下放用于数据库查询的sql语句的xml文件、邮件的样式等。
26.11 testCase文件夹
testCase文件夹下，存放我们写的具体的测试用例，测试用例目录可以根据模块来划分，也可以根据其他特定需求来划分。
注意：所有的 case 名称都要以 test 开头来命名，这是因为 Python3 unittest 在进行测试时会自动匹配 testCase 文件夹下面所有 test 开头的 .py 文件。
26.12 汇总
对 Python3 的接口测试框架简单介绍了一下，其实大家要学习的是封装的思想，如何把一些公共的模块抽象出来，达到数据与业务流程的分离，在上面的框架中，我把常用固定的参数放到 config.ini 文件中，测试用例的管理（excel文件），sql 语句的存放（xml文件），每个公司的项目不同，要求的不一样，自己可以根据自己项目的需求去封装自己的接口测试框架。
閱讀更多 聽海8 的文章
