class TestCaseGenPay(unittest.TestCase):
'''回款计划测试用例'''
mylog = MyLog('mylog')
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 测试用例存放的路径
excle = ReadExcelData(test_case, 'generateRepayments') # 创建读取excle表格的对象
case_list = excle.read() # 读取测试用例的数据
@classmethod
def setUpClass(cls):
print('{}测试开始执行'.format(cls))
cls.mysql = ObMysql() # 创建数据库连接
pr = PreClass()
pr.add() # 借款人加标
pr.recharge() # 投资人登录并充值
cls.mylog.info('-----添加回款计划测试开始执行-----')
def setUp(self):
print('{}测试用例开始执行'.format(self))
@data(*case_list)
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if items.check_sql:
if items.interface == 'generateRepayments':
result1 = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 请求前数据表中记录的个数
if "@loanId@" in items.data:
max_loanId = self.mysql.select(sql="SELECT max(Id)From loan",
row=1)[0] # 查到loan表的最大标id
data = data.replace("@loanId@", str(max_loanId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
if items.check_sql: # 如果需要数据库校验
if items.interface == 'bidloan':
investId = self.mysql.select(
rp.replace_data(items.check_sql))[0][0] # 竞标得到investId
setattr(ConText, 'investId', investId) # 将investId写进常量类
if items.interface == 'generateRepayments':
select_result = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 得到投资之后结果
self.assertEqual(1,
select_result - result1) # 比对查询的结果与预期的结果
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def tearDown(self):
print('{}测试执行完毕'.format(self))
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mylog.info('-----回款计划测试执行结束-----')
cls.mysql.close() # 关闭数据库
class TestCaseGet(unittest.TestCase):
'''获取相关记录测试用例'''
mylog = MyLog('mylog')
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 测试用例存放的路径
excle = ReadExcelData(test_case, 'get') # 创建读取excle表格的对象
case_list = excle.read() # 读取测试用例的数据
@classmethod
def setUpClass(cls):
print('{}测试开始执行'.format(cls))
cls.mysql = ObMysql() # 创建数据库连接
pr = PreClass()
pr.add() # 借款人加标
pr.recharge() # 投资人登录并充值
cls.mylog.info('-----获取相关记录测试开始执行-----')
def setUp(self):
print('{}测试用例开始执行'.format(self))
@data(*case_list)
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if "@memberId@" in items.data:
max_memberId = self.mysql.select(sql="SELECT max(Id)From member",
row=1)[0] # 查到member表的最大标id
data = data.replace("@memberId@", str(max_memberId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def tearDown(self):
print('{}测试执行完毕'.format(self))
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mylog.info('-----获取相关记录测试执行结束-----')
cls.mysql.close() # 关闭数据库
class TestUserRegister(unittest.TestCase):
'''注册'''
mylog = MyLog('mylog') # 创建日志对象
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 获取测试用例存放路径
excle = ReadExcelData(test_case, 'userRegister')
test_list = excle.read() # 获取数据列表对象
pr = PreClass() # 创建前置条件对象
@classmethod
def setUpClass(cls):
cls.mysql = ObMysql(database='user_db') # 建立数据库连接对象
cls.mylog.info('-----注册测试开始执行-----')
print('{}开始测试'.format(cls))
def setUp(self):
print('{}开始测试'.format(self))
@data(*test_list)
def test(self, items):
self.pr.sendMCode() # 发送短信验证码
rp = Replace() # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
data = items.data # 获取数据
title = items.title # 获取用例标题
if "@verify_code@" in data:
verify_code = int(getattr(ConText, 'verify_code')) + 1
data = data.replace("@verify_code@",
str(verify_code)) # 用最新的验证码去替换
if title == '验证码超时':
verify_code = ob.getstr("verify_phone",
"verify_code") # 拿到已经超时的验证码
phone = ob.getstr("verify_phone", "phone") # 拿到发送的手机号
data = data.replace("<verify_code>", verify_code) # 替换验证码
data = data.replace("<phone>", phone) # 替换手机号码
client = Client(url) # 创建连接
data = eval(rp.replace_data(data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result) # 获取预期结果,并转换为字典
print('第{}条测试用例：{}开始执行'.format(case_id, title))
re = client.service.userRegister(data) # 发送请求
acl_re = str(re.retCode) # 获取实际结果
print('实际结果:{}'.format(except_result), type(except_result))
print('预期结果:{}'.format(acl_re), type(acl_re))
print(dict(re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
re_username = data["user_id"] # 拿到注册过的用户名
re_phone = data["mobile"]
setattr(ConText, 're_username', re_username) # 将注册过后的用户名写进临时变量
setattr(ConText, 're_phone', re_phone) # 将注册过后的手机号码写进临时变量
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
def tearDown(self):
print('{}测试用例执行完毕'.format(self))
update_phone() # 更新手机号码和登录密码
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mysql.close() # 关闭数据库
cls.mylog.info('-----注册模块测试执行结束-----')
class TestCaseRechargeWithdraw(unittest.TestCase):
'''充值提现测试用例'''
test_case = os.path.join(cons.DATA_DIR, 'testcase.xlsx') # 测试用例存放的路径
excel = ReadExcelData(test_case, 'recharge-withdraw') # 读取表格的对象
case_list = excel.read() # 获取表格对象列表
mylog1 = MyLog('mylog')
@classmethod
def setUpClass(cls):
url = ob.getstr('url', 'url') + '/member/login'
phone = ob.getstr('login', 'phone')
pwd = ob.getstr('login', 'pwd')
login_data = {"mobilephone": phone, "pwd": pwd} # 登录数据
print('{}测试开始执行'.format(cls))
cls.login = HttpSession(url=url, data=login_data).httprequest(
method='post') # 登录
cls.ms = ObMysql() # 创建数据库操作对象，打开数据库
cls.mylog1.info('-----充值提现模块开始测试-----')
def setUp(self):
print('{}测试用例开始执行'.format(self))
@data(*case_list) # 对表格对象进行拆包
def test(self, items):
case_id = items.case_id # 获取case_id
title = items.title # 获取title
method = items.method # 获取请求方法
url = ob.getstr('url', 'url') + items.url # 获取url地址
rp = Replace(section2='login')
data = eval(rp.replace_data(items.data)) # 获取请求数据
except_result = str(items.except_result) # 获取预期结果
print('第{}条用例开始执行：{}'.format(case_id, title))
self.mylog1.info('第{}条用例开始执行：{}'.format(case_id, title)) # 打印日志
if items.check_sql: # 如果需要校验数据库
sql = rp.replace_data(items.check_sql) # 获取sql语句
select_result = self.ms.select(sql) # 充值或者取现前的查询结果
leave_amount = select_result[0][0] # 拿到充值或者取现前的账户余额
print(leave_amount)
res = HttpSession(
url=url, data=data).httprequest(method=method).json() # 请求
select_result1 = self.ms.select(sql) # 充值后的查询结果
if items.interface == 'recharge': # 如果为充值接口
except_leave_amount = leave_amount + Decimal(
str(data['amount'])) # 得到预期的充值之后的余额
elif items.interface == 'withdraw': # 如果为取现接口
except_leave_amount = leave_amount - Decimal(
str(data['amount'])) # 得到预期提现后的余额
leave_amount1 = select_result1[0][0] # 拿到充值或者提现后后的账户余额
print('充值或者取现前的账户余额为{}'.format(leave_amount))
print('预期的账户余额为{}'.format(except_leave_amount))
print('充值或者取现后的账户余额为{}'.format(leave_amount1))
else:
res = HttpSession(
url=url, data=data).httprequest(method=method).json() # 请求
res1 = res['code'] # 返回的状态码
print('实际结果为{}'.format(except_result))
print('预期结果为{}'.format(res1))
# 比对实际与预期结果
try:
self.assertEqual(res1, except_result)
if items.check_sql: # 如果需要校验数据库
self.assertEqual(except_leave_amount,
leave_amount1) # 比对预期的充值之后的余额与实际的账户余额
except AssertionError as e: # 若实际与预期不符
print('测试未通过')
self.excel.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
self.mylog1.error('测试未通过,未通过信息为：{}'.format(e)) # 打印日志
raise e # 抛出异常
else:
print('测试通过')
self.excel.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
self.mylog1.info('测试通过') # 打印日志
finally:
self.excel.write(row=case_id + 1, column=8, value=res1) # 回写实际结果
def tearDown(self):
print('{}测试用例执行完毕'.format(self))
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.login.close() # 关闭session
cls.ms.close() # 关闭数据库
cls.mylog1.info('-----充值提现模块测试执行结束-----')
class TestVerifyUserAuth(unittest.TestCase):
'''实名认证'''
mylog = MyLog('mylog') # 创建日志对象
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 获取测试用例存放路径
excle = ReadExcelData(test_case, 'verifyUserAuth')
test_list = excle.read() # 获取数据列表对象
pr = PreClass() # 创建前置条件对象
@classmethod
def setUpClass(cls):
cls.mysql = ObMysql(database='user_db') # 建立数据库连接对象
cls.mylog.info('-----实名认证模块测试开始执行-----')
print('{}开始测试'.format(cls))
def setUp(self):
print('{}开始测试'.format(self))
@data(*test_list)
def test(self, items):
self.pr.userRegister() # 注册
rp = Replace(section1="userinfo") # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
data = items.data # 获取数据
title = items.title # 获取用例标题
if "@uid@" in data:
max_uid = self.mysql.select(rp.replace_data(items.check_sql))[0][0]
print(max_uid)
data = data.replace("@uid@", str(int(max_uid + 1))) # 用最新uid去替换
client = Client(url) # 创建连接
data = eval(rp.replace_data(data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result)
print('第{}条测试用例：{}开始执行'.format(case_id, title))
re = client.service.verifyUserAuth(data) # 发送请求
acl_re = str(re.retCode) # 获取实际结果
print('实际结果:{}'.format(except_result), type(except_result))
print('预期结果:{}'.format(acl_re), type(acl_re))
print(dict(re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
if items.title == "实名认证成功":
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
def tearDown(self):
print('{}测试用例执行完毕'.format(self))
update() # 更新配置文件里面的姓名和身份证号码
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mysql.close() # 关闭数据库
cls.mylog.info('-----实名认证模块测试执行结束-----')
class TestCaseRegisterLogin(unittest.TestCase):
'''注册测试用例'''
test_case = os.path.join(cons.DATA_DIR, 'testcase.xlsx') # 测试用例存放的路径
excel = ReadExcelData(test_case, 'register-login') # 读取表格的对象
case_list = excel.read() # 获取表格对象列表
mylog = MyLog('mylog')
@classmethod
def setUpClass(cls):
print('{}测试开始执行'.format(cls))
cls.ms = ObMysql() # 创建数据库操作对象,打开数据库
cls.mylog.info('-----注册登录模块开始测试-----')
def setUp(self):
print('{}测试用例开始执行'.format(self))
@data(*case_list) # 对表格对象进行拆包
def test(self, items):
case_id = items.case_id # 获取case_id
title = items.title # 获取title
method = items.method # 获取请求方法
url = ob.getstr('url', 'url') + items.url # 获取url地址
rp = Replace(section1='register', section2='login') # 创建替换对象
data = eval(rp.replace_data(items.data)) # 替换后的数据
except_result = items.except_result # 获取预期结果
print('第{}条用例开始执行：{}'.format(case_id, title))
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 打印日志
res = HttpRequest(url=url,
data=data).httprequest(method=method).content.decode(
'utf8') # 请求获取实际结果
print('实际结果为{}'.format(except_result))
print('预期结果为{}'.format(res))
# 比对实际与预期结果
try:
self.assertEqual(res, except_result)
if items.check_sql: # 如果需要数据库校验
sql = rp.replace_data(items.check_sql)
sql_result = self.ms.find_result(sql) # 数据库查询结果
if sql_result == 1: # 如果注册成功
ob.write('login', 'phone',
data['mobilephone']) # 将手机号写进配置文件
ob.write('login', 'pwd', data['pwd']) # 将密码写进配置文件
self.assertEqual(1, sql_result) # 比对查询结果
except AssertionError as e: # 若实际与预期不符
print('测试未通过')
self.excel.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
self.mylog.error('测试未通过,未通过信息为：{}'.format(e))
raise e # 抛出异常
else:
print('测试通过')
self.excel.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
self.mylog.info('测试通过') # 打印日志
finally:
self.excel.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def tearDown(self):
print('{}测试用例执行完毕'.format(self))
update_phone() # 更新手机号码和登录密码
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.ms.close() # 关闭数据库
cls.mylog.info('-----注册登录模块测试执行结束-----')
class TestCaseBidloan(unittest.TestCase):
'''投资测试用例'''
mylog = MyLog('mylog')
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 测试用例存放的路径
excle = ReadExcelData(test_case, 'bidloan') # 创建读取excle表格的对象
case_list = excle.read() # 读取测试用例的数据
@classmethod
def setUpClass(cls):
print('{}测试开始执行'.format(cls))
cls.mysql = ObMysql() # 创建数据库连接
pr = PreClass()
pr.add() # 借款人加标
pr.recharge() # 投资人登录并充值
cls.mylog.info('-----竞标测试用例开始执行-----')
def setUp(self):
print('{}测试用例开始执行'.format(self))
@data(*case_list)
def test(self, items):
rp = Replace() # 创建替换对象
# 获取测试用例的数据
case_id = items.case_id # 用例数据的编号
title = items.title # 用例的标题
method = items.method # 请求方法
url = ob.getstr('url', 'url') + items.url # 请求地址
except_result = str(items.except_result) # 获得预期结果
data = items.data
if items.check_sql:
result1 = self.mysql.find_result(rp.replace_data(
items.check_sql)) # 查询投资之前invest投资该标记录的个数
amount = self.mysql.select(
"SELECT LeaveAmount FROM member WHERE MobilePhone= '{}'".
format(getattr(ConText, 'phone')))[0][0] # 查询投资用户投资之前的余额
if "@memberId@" in items.data:
max_memberid = self.mysql.select(sql="SELECT max(Id)From member",
row=1)[0] # 查到用户表的最大id
data = data.replace("@memberId@", str(max_memberid + 100))
if "@loanId@" in items.data:
max_loanId = self.mysql.select(sql="SELECT max(Id)From loan",
row=1)[0] # 查到loan表的最大标id
data = data.replace("@loanId@", str(max_loanId + 100))
data = eval(rp.replace_data(data)) # 替换后的申请数据
print(data)
print('第{}条用例开始执行：{}'.format(case_id, title)) # 打印信息
self.mylog.info('第{}条用例开始执行：{}'.format(case_id, title)) # 写进日志
# 发送请求获取实际结果
res = HttpSession(url=url,
data=data).httprequest(method=method).json()['code']
# 比对实际与预期结果
print('预期结果：{}'.format(except_result))
print('实际结果:{}'.format(res))
try:
self.assertEqual(except_result, res)
if items.check_sql: # 如果需要数据库校验
select_result = self.mysql.find_result(
rp.replace_data(items.check_sql)) # 得到投资之后结果
amount1 = self.mysql.select(
"SELECT LeaveAmount FROM member WHERE MobilePhone= '{}'".
format(getattr(ConText, 'phone')))[0][0] # 查询投资用户投资之后的余额
bd_amount = Decimal(str(data['amount'])) # 拿到充值金额
self.assertEqual(1, select_result - result1) # 比对查询的结果与预期的结果
self.assertEqual(bd_amount,
amount - amount1) # 比对余额的减少是否与投资的金额相等
except AssertionError as e:
print('{}测试用例未通过'.format(title))
self.mylog.error('{}测试用例未通过,未通过的信息为{}'.format(title, e)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}测试用例通过'.format(title))
self.mylog.error('{}测试用例通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=9, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=8, value=res) # 回写实际结果
def tearDown(self):
print('{}测试执行完毕'.format(self))
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mylog.info('-----竞标模块测试执行结束-----')
cls.mysql.close() # 关闭数据库
class TestSendMCode(unittest.TestCase):
'''短信验证码'''
mylog = MyLog('mylog') # 创建日志对象
test_case = os.path.join(con.DATA_DIR, 'testcase.xlsx') # 获取测试用例存放路径
excle = ReadExcelData(test_case, 'sendMCode')
test_list = excle.read()
@classmethod
def setUpClass(cls):
cls.mysql = ObMysql(database='sms_db_45') # 建立数据库连接对象
cls.mylog.info('-----短信验证码测试开始执行-----')
print('{}开始测试'.format(cls))
def setUp(self):
print('{}开始测试'.format(self))
@data(*test_list)
def test(self, items):
rp = Replace(section1='register') # 创建替换对象
case_id = items.case_id # 获取用例编号
url = ob.getstr('url', 'url') + items.url
client = Client(url) # 创建连接
title = items.title # 获取用例标题
data = eval(rp.replace_data(items.data)) # 获取请求数据
print("请求数据为：", data)
except_result = str(items.except_result) # 获取预期结果
print('第{}条测试用例：{}开始执行'.format(case_id, title))
try:
re = client.service.sendMCode(data) # 发送请求
except suds.WebFault as e:
acl_re = str(e.fault.faultstring) # 请求有误，返回实际结果
else:
acl_re = str(re.retCode) # 请求通过, 返回实际结果
print('实际结果:{}'.format(except_result))
print('预期结果:{}'.format(acl_re))
# 比对实际结果与预期结果
try:
self.assertEqual(except_result, acl_re)
if items.check_sql:
sql = rp.replace_data(items.check_sql)
slect_result = self.mysql.find_result(sql) # 得到查询结果
self.assertEqual(1, slect_result)
except AssertionError as e:
print('{}用例测试未通过'.format(title))
self.mylog.error('{}用例测试未通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='未通过') # 回写测试结果
raise e # 抛出异常
else:
print('{}用例测试通过'.format(title))
self.mylog.info('{}用例测试通过'.format(title)) # 打印日志信息
self.excle.write(row=case_id + 1, column=8, value='通过') # 回写测试结果
finally:
self.excle.write(row=case_id + 1, column=7, value=acl_re) # 回写实际结果
def tearDown(self):
print('{}测试用例执行完毕'.format(self))
update_phone() # 更新手机号码和登录密码
@classmethod
def tearDownClass(cls):
print('{}测试执行结束'.format(cls))
cls.mysql.close() # 关闭数据库
cls.mylog.info('-----短信验证码模块测试执行结束-----')