def test_register(self, case):
# 回写结果的row
row = case.case_id + 1
# 从excel中读取数据，准备请求参数
# 拼接完整的url
new_url = do_yaml.read_yaml('api', 'prefix') + case.url
# 参数化获取发起请求的用例数据
new_data = Parameterize.to_parameter(case.data)
# 对象调用类属性向服务器发起请求
res = self.do_request.send(new_url, data=new_data)
# 将响应报文中的json格式数据转换为字典
actual_value = res.json()
# 从excel中获取excepted
excepted_result = case.excepted
# 获取title
msg = case.title
# 从配置文件中读取断言结果：成功
success_result = do_yaml.read_yaml('excel', 'success_result')
# 从配置文件中读取断言结果：失败
fail_result = do_yaml.read_yaml('excel', 'fail_result')
# 比较预期和实际结果
# 捕获异常，回写结果，打印日志，并主动抛出异常
try:
# unittest 的断言方法
# self.assertEqual(actual_value['code'], excepted_result)
# 第三个参数为：如果断言失败，会提示msg信息
self.assertEqual(actual_value.get('code'),
excepted_result,
msg=msg)
# self.assertEqual(actual_value.get('code'), excepted_result)
except AssertionError as e:
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
fail_result)
# 将异常内容写入日志
# do_log.error(f'{msg}，执行结果为：{fail_result}\n具体异常为：\n{e}\n')
do_log.error({e})
# 主动抛出异常
raise e
else:
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
success_result)
# 打印日志
do_log.info(f'{msg}，执行结果为：{success_result}')
finally:
# 将返回的响应体写入excel
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'actual_col'),
res.text)
def test_todo(self, case):
# 2. 拼接完整的url
new_url = do_yaml.read('api', 'prefix') + case.url
# 3. 向服务器发起请求
res = self.do_request.send(url=new_url, # url地址
method=case.method, # 请求方法
data=case.data # 请求参数
# is_json=True # 是否以json格式来传递数据, 默认为True
)
# 将相应报文中的数据转化为字典
actual_value = res.json()
# 获取用例的行号
row = case.case_id + 1
# 将expected期望值转化为字典
expected_result = json.loads(case.expected, encoding='utf-8')
msg = case.title # 获取标题
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
# 先断言code, 再断言msg
self.assertEqual(expected_result.get('code'), actual_value.get('code'), msg=msg)
self.assertEqual(expected_result.get('msg'), actual_value.get('msg'), msg=msg)
except AssertionError as e:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# do_log.error("断言异常: {}".format(e))
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
if "token" in res.text:
token = actual_value.get('data')['token'] # 获取token信息
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
def test_login(self, case):
#参数化
new_data = Parameterize.to_param(case.data)
#构造请求url
new_url = do_yaml.read("api", "profix") + case.url
#发起请求
res = self.do_request.send(url=new_url, data=new_data)
#将响应报文转化为json
actual_value = res.json()
# 获取测试用例行号
row = case.case_id + 1
# 获取预期结果
expected_result = json.loads(case.expected, encoding="utf8")
#获取测试用例的标题
msg = case.title
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
# 先断言code, 再断言msg
self.assertEqual(expected_result.get("code"),
actual_value.get("code"),
msg=msg)
self.assertEqual(expected_result.get("msg"),
actual_value.get("msg"),
msg=msg)
except Exception as e:
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# error 指的时日志的收集等级
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
# info 指的时日志的收集等级
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
finally:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
def test_register(self, case):
"""
测试用户注册接口
:return:
"""
#处理获取的表数据
msg = case['title']
url = http_host + case['url']
data = eval(Context.replace_all(str(case['data'])))
method = case['method']
except_result = case['expected']
# 创建一个webservice请求对象
dowebservice = DoWebService(url=url)
#发起数据请求
request_res = dowebservice.webservice_requests(post=method, param=data)
# 判断请求方式是否有误
if request_res == 'PostError':
do_log.info('{}\t执行请求方式有误！：{}\n'.format(msg, case['method']))
# 判断是否为发送验证码接口并获取数据库验证码信息
if 'ok' in str(request_res) and case['method'].lower() == 'sendmcode':
setattr(Context, "invest_mobile_num", data["mobile"])
check_sql = case['check_sql']
if check_sql:
check_sql = Context.replace_all(check_sql)
mysql_data = self.do_mysql.select_mysql(sql=check_sql)
mcode = mysql_data['Fverify_code']
# 动态创建Context对象变量sql_mcode（验证码）
setattr(Context, "sql_mcode", mcode)
try:
#断言请求结果
self.assertIn(except_result, str(request_res), msg=msg + '失败！')
# 判断是否为用户注册接口并获取数据库用户信息
if 'ok' in str(
request_res) and case['method'].lower() == 'userregister':
check_sql = case['check_sql']
#动态创建Context对象变量user_id（用户名）
setattr(Context, 'user_id', data['user_id'])
if check_sql:
check_sql = Context.replace_all(check_sql)
mysql_data = self.do_mysql_user.select_mysql(sql=check_sql)
if mysql_data['Fuid'] is not None:
# 动态创建Context对象变量Fuid（数据库中获取的用户ID）
setattr(Context, 'Fuid', mysql_data['Fuid'])
#断言用户是否添加成功
self.assertIsNotNone(mysql_data, msg=msg + '数据库添加用户失败！')
do_log.info('{}\t执行结果：{}\n'.format(msg, 'Pass'))
do_excel.write_result(case['case_id'] + 1, str(request_res),
'Pass')
except AssertionError as e:
do_log.error('{}执行结果:{}\t报错信息：{}\n'.format(msg, 'Fail', e))
do_excel.write_result(case['case_id'] + 1, str(request_res),
'Fail')
raise e
def test_recharge(self, one_testcase):
new_data = Parameterize.to_parma(one_testcase.data)
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 1、在充值之前，查询当前用例的金额
# 在发起请求之前, 查询当前账户金额
check_sql = one_testcase.check_sql
if check_sql:
check_sql = Parameterize.to_parma(check_sql)
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_before = float(mysql_data['leave_amount']) # 不是float浮点数, 也不是int类型, 是decimal数据类型
# 2、进行充值
res = self.do_request.send(one_testcase.method,
new_url,
json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# one_testcase.expected_value为int类型，需要转化为字符串类型
# self.assertIn(one_testcase.expected_value,
# res.text,
# one_testcase.name)
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"),
one_testcase.name)
# 3、查询充值成功之后的金额
# 如果check_sql不为空, 说明要进行数据校验
if check_sql:
mysql_data = self.do_mysql.get_one_value(sql=check_sql)
amount_after = float(mysql_data['leave_amount'])
one_dict = json.loads(new_data, encoding='utf-8')
currrent_recharge_amount = one_dict['amount']
actual_amount = amount_before + currrent_recharge_amount
self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误")
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = actual_value["data"]["token_info"]["token"]
# add_headers需要传字典类型
# self.do_request.add_headers("Authorization", f"Bearer {token}")
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
self.do_excel.write_data(one_testcase, res.text, "成功")
def test_addition(self, case):
#参数化
new_data = Parameterize.to_param(case.data)
#构造请求url
new_url = do_yaml.read("api", "profix") + case.url
#发起加标请求
res = self.do_request.send(url=new_url, data=new_data)
#将相应报文中的数据转化为字典
actul_value = res.json()
#获取测试用例所在的行
row = case.case_id + 1
# 获取预期结果
expected_result = case.expected
#获取测试用例标题
msg = case.title
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
self.assertEqual(expected_result, actul_value.get("code"), msg=msg)
except Exception as e:
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
if "token_info" in res.text:
token = actul_value["data"]["token_info"]["token"]
header = {"Authorization": "Bearer " + token}
self.do_request.add_headers(header)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
# info 指的时日志的收集等级
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
finally:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
def test_invest(self, one_testcase):
if 8 >= one_testcase.id >= 3:
self.do_request.get_ids()
elif 22 >= one_testcase.id >= 15:
self.do_request.get_gjids()
elif 38 >= one_testcase.id >= 33:
self.do_request.get_ghxsid()
new_data = Parameterize.to_parma(one_testcase.data)
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行加标
res = self.do_request.send(one_testcase.method, new_url, json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
self.assertEqual(one_testcase.expected_value,
actual_value.get("errcode"), one_testcase.name)
except AssertionError as e:
do_log.error(f"{one_testcase.name}：具体异常为{e}")
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token" in res.text and one_testcase.id == 1:
token = res.json()["data"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# check_sql_str = one_testcase.check_sql
# if check_sql_str:
# # 将check_sql json格式的字符串转化为字典
# check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
# if 'loan_id' in check_sql_dict:
# # 获取查询loan id的sql语句
# loan_id_sql = check_sql_dict.get('loan_id')
# # 将sql语句进行参数化
# loan_id_sql = Parameterize.to_parma(loan_id_sql)
# mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
#
# load_id = mysql_data['id'] # 获取loan_id
# # 设置loan_id为GlobalData的类属性
# setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
def test_invest(self, one_testcase):
# 将excel中读取的请求参数进行参数化
new_data = Parameterize.to_parma(one_testcase.data)
# 拼接请求URL地址
new_url = do_yaml.get_data("api", "base_url") + one_testcase.url
# 进行投资
res = self.do_request.send(one_testcase.method,
new_url,
json=new_data)
# 获取响应数据并转化为字典类型
actual_value = res.json()
try:
# 断言：预期结果==实际结果，断言结果
self.assertEqual(one_testcase.expected_value,
actual_value.get("code"),
one_testcase.name)
except AssertionError as e:
# 此处使用日志器来记录日志！
do_log.error(f"{one_testcase.name}：具体异常为{e}")
# 把执行结果写入excel中“actual"和”result“
self.do_excel.write_data(one_testcase, res.text, "失败")
raise e
else:
# if one_testcase.id == 2:
# a.如果响应报文中含有token_info，说明当前用例为登录接口用例
# b.从响应报文中获取token，然后添加至请求头中
if "token_info" in res.text:
token = res.json()["data"]["token_info"]["token"]
# add_headers需要传字典类型
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
check_sql_str = one_testcase.check_sql
if check_sql_str:
# 将check_sql json格式的字符串转化为字典
check_sql_dict = json.loads(check_sql_str, encoding='utf-8')
if 'loan_id' in check_sql_dict:
# 获取查询loan id的sql语句
loan_id_sql = check_sql_dict.get('loan_id')
# 将sql语句进行参数化
loan_id_sql = Parameterize.to_parma(loan_id_sql)
mysql_data = self.do_mysql.get_one_value(sql=loan_id_sql)
load_id = mysql_data['id'] # 获取loan_id
# 设置loan_id为GlobalData的类属性
setattr(GlobalData, '${loan_id}', load_id)
self.do_excel.write_data(one_testcase, res.text, "成功")
def test_add(self, case):
# 将期望结果取出
expected = case.expected
# 参数化，将取出来的字符串进行参数替换（如果需要的话）
data_str = HandleParam.to_param(case.data)
# 拼接url
url = do_yaml.read_yaml('api', 'url') + case.url
# 向接口发起请求
res = self.do_request.send(url=url,
method=case.request_method,
data=data_str)
# 获取的报文转换为字典
result = res.json()
msg = case.title # 获取用例标题
success_msg = do_yaml.read_yaml('msg', 'success_result')
fail_msg = do_yaml.read_yaml('msg', 'fail_result')
row = case.case_id + 1
# assertEqual第三个参数为用例执行失败之后的提示信息
try:
self.assertEqual(expected, result['code'], msg=msg)
except AssertionError as e:
# 将用例执行结果写入到result_col列
do_log.info('{}用例执行有误'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=fail_msg)
do_log.error('具体异常为{}'.format(e))
raise e
else:
do_log.info('{}用例执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=success_msg)
# 判断返回报文中是否有token，如果有则将token取出加入到请求头中
if 'token_info' in res.text:
self.do_request.add_headers({"Authorization": \
"Bearer " + result['data']['token_info']['token']})
finally:
# 将响应实际结果写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
def test_ride(self,one_case):
actual_results = Jisuan(one_case['l_data'], one_case['r_data']).ride()
msg = one_case['title']
expected_results = one_case['expected']
success_msg = do_config.get_config("msg", "success_result")
fail_msg = do_config.get_config("msg", "Fail_result")
try:
self.assertEqual(expected_results,actual_results, msg=msg)
# self.rizhi.write("test_ride:{} ,测试结果为 {}\n".format(msg,success_msg))
do_log.info("test_ride:{} ,测试结果为 {}\n".format(msg, success_msg))
do_excel.write_result(one_case['case_id']+1,actual_results,success_msg)
except AssertionError as e:
# self.rizhi.write("test_ride:{} ,测试结果为 {}.具体异常为{}\n".format(msg,fail_msg,e))
do_log.error("test_ride:{} ,测试结果为 {}.具体异常为{}\n".format(msg,fail_msg,e))
do_excel.write_result(one_case['case_id'] + 1, actual_results, fail_msg)
raise e #因为上面捕获了异常，所以这里用raise来返回异常
def test_invest(self, data_namedtuple):
"""
测试投资功能
:return:
"""
do_log.info("\n正在运行的测试用例为：{}".format(data_namedtuple.title))
method = data_namedtuple.method
url = do_config("api", "url") + data_namedtuple.url
print(url)
new_data = HandleContext().invest_parameterization(data_namedtuple.data)
print(new_data)
response = self.send_request(method=method, url=url, data=new_data)
print(response.text)
# 判断服务器是否有异常
try:
self.assertEqual(200, response.status_code,
msg="测试【{}】失败，http请求状态码为【{}】".
format(data_namedtuple.title, response.status_code))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
raise e
# 判断是否加标成功，加标成功，获取loan_id
if response.json().get("msg") == "加标成功":
check_sql = data_namedtuple.check_sql
if check_sql:
check_sql = HandleContext().invest_parameterization(check_sql)
mysql_data = self.handle_mysql(sql=check_sql) # 获取一条记录
HandleContext.loan_id = mysql_data["Id"] # 动态添加属性,获取标的Id
# setattr(HandleContext, "loan_id", mysql_data["Id"]) # 动态创建类属性,获取标的Id
# 验证预期结果是否与实际结果相同
try:
self.assertEqual(data_namedtuple.expected,
response.text,
msg="测试{}失败".format(data_namedtuple.title))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
self.do_excel.write_result(row=data_namedtuple.case_id+1,
actual=response.text,
result=do_config("msg", "fail_result"))
raise e
else:
self.do_excel.write_result(row=data_namedtuple.case_id+1,
actual=response.text,
result=do_config("msg", "success_result"))
def test_login(self, case):
# 将期望结果取出并转换为字典
expected = json.loads(case.expected, encoding='utf-8')
# 参数化，将取出来的字符串进行手机号替换（如果需要的话）
data_str = HandleParam.to_param(case.data)
# 拼接url
url = do_yaml.read_yaml('api', 'url') + case.url
# 将此处的功能模块替换为接口请求
res = self.do_request.send(url=url,
method=case.request_method,
data=data_str
)
result = res.json()
msg = case.title
success_msg = do_yaml.read_yaml('msg', 'success_result')
fail_msg = do_yaml.read_yaml('msg', 'fail_result')
row = case.case_id + 1
# assertEqual第三个参数为用例执行失败之后的提示信息
try:
self.assertEqual(expected['code'], result['code'], msg=msg)
self.assertEqual(expected['msg'], result['msg'], msg=msg)
except AssertionError as e:
# 将用例执行结果写入到result_col列
do_log.info('{}用例执行有误'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml('excel', 'result_col'),
value=fail_msg)
do_log.error('具体异常为{}'.format(e))
raise e
else:
do_log.info('{}用例执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml('excel', 'result_col'),
value=success_msg)
finally:
# 将响应实际结果写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read_yaml('excel', 'actual_col'),
value=res.text
)
def __call__(self, url, api, data):
if isinstance(data, str):
try:
data = json.loads(data)
except Exception as e:
do_log.error(e)
do_log.error("{}不是json格式！".format(data))
data = eval(data)
client = Client(url=url)
if api.lower() == 'sendmcode':
try:
res = client.service.sendMCode(data)
except Exception as e:
return e.fault.faultstring
else:
return res.retInfo
if api.lower() == 'userregister':
try:
res = client.service.userRegister(data)
except Exception as e:
return e.fault.faultstring
else:
return res.retInfo
if api.lower() == 'verifyuserauth':
try:
res = client.service.verifyUserAuth(data)
except Exception as e:
return e.fault.faultstring
else:
return res.retInfo
if api.lower() == 'bindbankcard':
try:
res = client.service.bindBankCard(data)
except Exception as e:
return e.fault.faultstring
else:
return res.retInfo
def test_login(self, data_namedtuple):
"""
测试登录功能
:return:
"""
url = do_config("api", "url") + data_namedtuple.url
new_data = HandleContext().login_parameterization(data_namedtuple.data)
do_log.info("\n正在运行的测试用例为：{}".format(data_namedtuple.title))
response = self.send_request(method=data_namedtuple.method,
url=url,
data=new_data)
# 判断服务器是否有异常
try:
self.assertEqual(200,
response.status_code,
msg="测试【{}】失败，http请求状态码为【{}】".format(
data_namedtuple.title, response.status_code))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
raise e
try:
self.assertEqual(data_namedtuple.expected,
response.text,
msg="测试{}失败".format(data_namedtuple.title))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
self.do_excel.write_result(row=data_namedtuple.case_id + 1,
actual=response.text,
result=do_config("msg", "fail_result"))
raise e
else:
self.do_excel.write_result(row=data_namedtuple.case_id + 1,
actual=response.text,
result=do_config(
"msg", "success_result"))
def test_add(self, data_namedtuple):
"""
测试加标功能
:return:
"""
url = do_config("api", "url") + data_namedtuple.url
new_data = HandleContext().add_parameterization(data_namedtuple.data)
print(new_data)
do_log.info("\n正在运行的测试用例为：{}".format(data_namedtuple.title))
# 接口不支持json格式，只支持form表单，is_json=False, 使用data
response = self.send_request(method=data_namedtuple.method, url=url, data=new_data)
print(response.text)
# 判断服务器是否有异常
try:
self.assertEqual(200, response.status_code,
msg="测试【{}】失败，请求状态码为【{}】"
.format(data_namedtuple.title, response.status_code))
except AssertionError as e : # 出现异常，后面代码不会执行
do_log.error("{},执行结果:{}\n具体异常信息:{}\n".format(data_namedtuple.title, "fail", e))
raise e
try:
self.assertEqual(data_namedtuple.expected,
response.text,
msg="测试{}失败".format(data_namedtuple.title))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
self.do_excel.write_result(row=data_namedtuple.case_id+1,
actual=response.text,
result=do_config("msg", "fail_result"))
raise e
else:
self.do_excel.write_result(row=data_namedtuple.case_id+1,
actual=response.text,
result=do_config("msg", "success_result"))
def test_invest(self, case):
# 1. 参数化
new_data = Parameterize.to_param(case.data)
# 2. 拼接完整的url
new_url = do_yaml.read('api', 'prefix') + case.url
# 3. 向服务器发起请求
res = self.do_request.send(url=new_url, data=new_data)
# 将相应报文中的数据转化为字典
actual_value = res.json()
row = case.case_id + 1
expect_result = case.expected
msg = case.title # 获取用例标题
success_msg = do_yaml.read("msg", "success_result") # 获取用例执行成功的提示信息
fail_msg = do_yaml.read("msg", "fail_result") # 获取用例执行失败的提示信息
try:
self.assertEqual(expect_result, actual_value.get('code'), msg=msg)
except AssertionError as e:
# 将执行结果写入到日志中
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
# 将响应数据写入excel
self.do_excel.write_data(row=row,
column=do_yaml.read(
"excel", "actual_col"),
value=res.text)
# 将测试结果写入excel
self.do_excel.write_data(row=row,
column=do_yaml.read(
"excel", "result_col"),
value=fail_msg)
raise e
else:
# 如果登录接口断言成功, 则取出token, 并添加到公共请求头中
if 'token_info' in res.text:
token = actual_value['data']['token_info']['token']
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# 取出load id的第一种方法
# check_sql = case.check_sql # 取出check_sql
# if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验
# check_sql = Parameterize.to_param(check_sql) # 将check_sql进行参数化
# mysql_data = self.do_mysql.run(check_sql) # 执行sql
# load_id = mysql_data['id']
# # 动态创建属性的机制, 来解决接口依赖的问题
# setattr(Parameterize, 'loan_id', load_id)
# check_sql = json.loads(case.check_sql, encoding='utf-8')
# if 'load_id' in check_sql:
# pass
# 取出load id的第二种方法
# if case.case_id == 2:
# load_id = actual_value.get('data').get('id')
# setattr(Parameterize, 'loan_id', load_id)
# 将执行结果写入到日志中
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
# 将响应数据写入excel
self.do_excel.write_data(row=row,
column=do_yaml.read(
"excel", "actual_col"),
value=res.text)
# 将测试结果写入excel
self.do_excel.write_data(row=row,
column=do_yaml.read(
"excel", "result_col"),
value=success_msg)
def test_recharge(self, data_namedtuple):
"""
测试充值功能
:return:
"""
do_log.info("\n正在运行的测试用例为：{}".format(data_namedtuple.title))
method = data_namedtuple.method
url = do_config("api", "url") + data_namedtuple.url
new_data = HandleContext().recharge_parameterization(
data_namedtuple.data)
check_sql = data_namedtuple.check_sql
# 充值之前用户的剩余金额
if check_sql:
check_sql = HandleContext().recharge_parameterization(check_sql)
mysql_data = self.handle_mysql(sql=check_sql) # 获取一条记录
amount_before_recharge = float(
mysql_data["LeaveAmount"]) # decimal类型数据转换成float类型
amount_before_recharge = round(amount_before_recharge, 2) # 保留两位小数
response = self.send_request(method=method, url=url, data=new_data)
# 判断服务器是否有异常
try:
self.assertEqual(200,
response.status_code,
msg="测试【{}】失败，http请求状态码为【{}】".format(
data_namedtuple.title, response.status_code))
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
raise e
response = response.text # 获取json格式数据
# 将复杂的数据赋值为空，之后单独验证
if check_sql:
response = json.loads(response, encoding="utf8")
response["data"] = None
response = json.dumps(
response, ensure_ascii=False) # ensure_ascii为False,可将乱码转换成中文
# 验证预期结果是否与实际结果相同
try:
self.assertEqual(data_namedtuple.expected,
response,
msg="测试{}失败".format(data_namedtuple.title))
# 充值之后用户的剩余金额
if check_sql:
check_sql = HandleContext().recharge_parameterization(
check_sql)
mysql_data = self.handle_mysql(sql=check_sql)
amount_after_recharge = float(mysql_data["LeaveAmount"])
actual_amount = round(amount_after_recharge, 2)
recharge_amount = float(
json.loads(new_data, encoding="utf8").get("amount"))
excepted_amount = round(
amount_before_recharge + recharge_amount, 2)
# 服务器返回复杂数据的验证，这里验证充值金额
self.assertEqual(excepted_amount,
actual_amount,
msg="数据库中充值的金额有误")
except AssertionError as e:
do_log.error("\n具体异常信息为：{}\n".format(e))
self.do_excel.write_result(row=data_namedtuple.case_id + 1,
actual=response,
result=do_config("msg", "fail_result"))
raise e
else:
self.do_excel.write_result(row=data_namedtuple.case_id + 1,
actual=response,
result=do_config(
"msg", "success_result"))
def test_recharge(self, case):
# 回写结果的row
row = case.case_id + 1
# 从excel中读取数据，准备请求参数
# 拼接完整的url
new_url = do_yaml.read_yaml('api', 'prefix') + case.url
# 参数化获取发起请求的用例数据
new_data = Parameterize.to_parameter(case.data)
# 获取充值前的账户金额
# 根据excel中sql语句是否存在来判断是否获取充值前金额进行数据校验
if case.check_sql:
# 将sql语句参数化
sql = Parameterize.to_parameter(case.check_sql)
# 执行查询语句，在数据库中查询得到数据字典
res_dict = self.do_mysql.run(sql, is_more=False)
# 取得充值前账户金额，转换为float
# global amount_before
amount_before = float(res_dict['leave_amount'])
# 保留2位小数
amount_before = round(amount_before, 2)
# 对象调用类属性向服务器发起请求
res = self.do_request.send(new_url, data=new_data)
# 将响应报文中的json格式数据（响应体）转换为字典
actual_value = res.json()
# # 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token)
# if case.case_id == 2:
# token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']}
# self.do_request.add_headers(token_headers)
# 从excel中获取excepted
excepted_result = case.excepted
# 获取title
msg = case.title
# 从配置文件中读取断言结果：成功
success_result = do_yaml.read_yaml('excel', 'success_result')
# 从配置文件中读取断言结果：失败
fail_result = do_yaml.read_yaml('excel', 'fail_result')
# 比较预期和实际结果
# 捕获异常，回写结果，打印日志，并主动抛出异常
try:
self.assertEqual(actual_value.get('code'), excepted_result, msg=msg)
# 如果充值成功，则获取充值成功后的金额（反向用例没有做数据校验）
if case.check_sql:
# # 将sql语句参数化
# sql = Parameterize.to_parameter(case.check_sql)
# 在数据库中查询得到数据字典
res_dict = self.do_mysql.run(sql, is_more=False)
# 取得充值后账户金额，取2位
amount_after = round(float(res_dict['leave_amount']), 2)
# 进行断言
amount_real = json.loads(new_data)
self.assertEqual(round((amount_after - amount_before), 2), amount_real.get('amount'))
except AssertionError as e:
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
fail_result)
# 将异常内容写入日志
# do_log.error(f'{msg}，执行结果为：{fail_result},具体异常为：{e}\n')
do_log.error({e})
# 主动抛出异常
raise e
else:
# 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token)
if actual_value.get('data'):
if actual_value.get('data').get('token_info'):
token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']}
self.do_request.add_headers(token_headers)
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
success_result)
# 打印日志
do_log.info(f'{msg}，执行结果为：{success_result}')
finally:
# 将返回的响应体写入excel
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'actual_col'),
res.text)
def test_invest(self, case):
# 回写结果的row
row = case.case_id + 1
# 从excel中读取数据，准备请求参数
# 拼接完整的url
new_url = do_yaml.read_yaml('api', 'prefix') + case.url
# 参数化获取发起请求的用例数据
new_data = Parameterize.to_parameter(case.data)
# 对象调用类属性向服务器发起请求
res = self.do_request.send(new_url, method=case.method, data=new_data)
# 将响应报文中的json格式数据（响应体）转换为字典
actual_value = res.json()
# 获取标ID
# # 获取token
# if case.case_id == 2:
# token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']}
# self.do_request.add_headers(token_headers)
# 从excel中获取excepted
excepted_result = case.excepted
# 获取title
msg = case.title
# 从配置文件中读取断言结果：成功
success_result = do_yaml.read_yaml('excel', 'success_result')
# 从配置文件中读取断言结果：失败
fail_result = do_yaml.read_yaml('excel', 'fail_result')
# 比较预期和实际结果
# 捕获异常，回写结果，打印日志，并主动抛出异常
try:
self.assertEqual(actual_value.get('code'), excepted_result, msg=msg)
except AssertionError as e:
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
fail_result)
# 将异常内容写入日志
# do_log.error(f'{msg}，执行结果为：{fail_result},具体异常为：{e}\n')
do_log.error({e})
# 主动抛出异常
raise e
else:
# 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token)
# 也可以使用成员运算：if 'token' in res.text:
if actual_value.get('data'):
if actual_value.get('data').get('token_info'):
token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']}
self.do_request.add_headers(token_headers)
# 获取loan_id (更方便的是直接从响应报文中获取loan_id)
case_sql = case.case_sql
if case_sql:
# 也可以使用成员运算来判断
if 'loan_id_sql' in case_sql:
case_sql = json.loads(case_sql, encoding='utf8').get('loan_id_sql')
# 借款人ID参数化
case_sql = Parameterize.to_parameter(case_sql)
# 查询数据库中该借款人对应的最新的loan_id
loan_id_dict = self.do_mysql.run(case_sql, is_more=False)
# 从结果字典中取loan_id
loan_id = loan_id_dict.get('id')
# 反射机制动态设置类属性，然后进行参数化，使得之后的用例可以取得loan_id（接口依赖）
setattr(Parameterize, 'loan_id', loan_id)
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
success_result)
# 打印日志
do_log.info(f'{msg}，执行结果为：{success_result}')
finally:
# 将返回的响应体写入excel
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'actual_col'),
res.text)
def test_invest(self, case):
#参数化
new_data = Parameterize.to_param(case.data)
#构造请求URL
new_url = do_yaml.read("api", "profix") + case.url
res = self.do_request.send(url=new_url,
method=case.method,
data=new_data)
#将响应报文转化为字典类型
actul_value = res.json()
#获取测试用例所在的行
row = case.case_id + 1
#获取预期结果
expected_result = case.expected
#获取测试用例标题
msg = case.title
# 获取用例执行成功的提示
success_msg = do_yaml.read('msg', 'success_result')
# 获取用例执行失败的提示
fail_msg = do_yaml.read('msg', 'fail_result')
try:
self.assertEqual(actul_value.get("code"), expected_result, msg=msg)
# check_sql = case.check_sql
# if check_sql:
# check_sql = Parameterize.to_param(case.check_sql)
# mysql_data = self.do_mysql.run(sql=check_sql)
# loan_id = mysql_data["id"]
# setattr(Parameterize, "loan_id", loan_id)
except Exception as e:
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
#
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
if "token_info" in res.text:
token = actul_value["data"]["token_info"]["token"]
header = {"Authorization": "Bearer " + token}
self.do_request.add_headers(header)
# 获取表的编号
check_sql = case.check_sql
if check_sql:
check_sql = Parameterize.to_param(case.check_sql)
mysql_data = self.do_mysql.run(sql=check_sql)
loan_id = mysql_data["id"]
setattr(Parameterize, "loan_id", loan_id)
# 取出load id的第二种方法
# if case.case_id == 2:
# load_id = actual_value["data"]["id"]
# setattr(Parameterize, 'loan_id', load_id)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
finally:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
def test_recharge(self, case):
# 回写结果的row
row = case.case_id + 1
# 从excel中读取数据，准备请求参数
# 拼接完整的url
new_url = do_yaml.read_yaml('api', 'prefix') + case.url
# 参数化获取发起请求的用例数据
new_data = Parameterize.to_parameter(case.data)
# 对象调用类属性向服务器发起请求
res = self.do_request.send(new_url, data=new_data)
# 将响应报文中的json格式数据（响应体）转换为字典
actual_value = res.json()
# # 获取token
# if case.case_id == 2:
# token_headers = {'Authorization': 'Bearer ' + actual_value['data']['token_info']['token']}
# self.do_request.add_headers(token_headers)
# 从excel中获取excepted
excepted_result = case.excepted
# 获取title
msg = case.title
# 从配置文件中读取断言结果：成功
success_result = do_yaml.read_yaml('excel', 'success_result')
# 从配置文件中读取断言结果：失败
fail_result = do_yaml.read_yaml('excel', 'fail_result')
# 比较预期和实际结果
# 捕获异常，回写结果，打印日志，并主动抛出异常
try:
self.assertEqual(actual_value.get('code'),
excepted_result,
msg=msg)
except AssertionError as e:
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
fail_result)
# 将异常内容写入日志
# do_log.error(f'{msg}，执行结果为：{fail_result},具体异常为：{e}\n')
do_log.error({e})
# 主动抛出异常
raise e
else:
# 获取token(也可以在发送请求后通过case_id 来判断登录用例从而获取token)
if actual_value.get('data'):
if actual_value.get('data').get('token_info'):
token_headers = {
'Authorization':
'Bearer ' + actual_value['data']['token_info']['token']
}
self.do_request.add_headers(token_headers)
# 回写断言结果
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'result_col'),
success_result)
# 打印日志
do_log.info(f'{msg}，执行结果为：{success_result}')
finally:
# 将返回的响应体写入excel
self.excel.write_result(row,
do_yaml.read_yaml('excel', 'actual_col'),
res.text)
def test_register(self, case):
# 参数化
new_data = Parameterize.to_param(case.data)
# 构造url
new_url = do_yaml.read("api", "profix") + case.url
# 向服务器发起请求
res = self.do_request.send(
url=new_url, # url地址
# method=case.method, # 请求方法
data=new_data # 请求参数
# is_json=True # 是否以json格式来传递数据, 默认为True
)
#将响应报文转化为json
actual_value = res.json()
# 获取测试用例行号
row = case.case_id + 1
#获取预期结果
expected_result = case.expected
# 获取测试用例的标题
msg = case.title
#获取用例成功与失败的提示
success_msg = do_yaml.read('msg', 'success_result')
fail_msg = do_yaml.read('msg', 'fail_result')
try:
self.assertEqual(expected_result,
actual_value.get('code'),
msg=msg)
except Exception as e:
# # # 将相应实际值写入到actual_col列
# self.excel.write_data(row = row,
# column = do_yaml.read("excel","actual_col"),
# value = res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# error 指的时日志的收集等级
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
# # # 将相应实际值写入到actual_col列
# self.excel.write_data(row = row,
# column = do_yaml.read("excel","actual_col"),
# value = res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
# info 指的时日志的收集等级
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
finally:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
def test_recharge(self, case):
# 参数化
new_data = Parameterize.to_param(case.data)
# 构造请求url
new_url = do_yaml.read("api", "profix") + case.url
check_sql = case.check_sql
# 判断check_sql字段是否为空（非空即为True）
if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验
#参数化check_sql
check_sql = Parameterize.to_param(case.check_sql)
#执行sql获取充值前金额
mysql_data = self.do_mysql.run(check_sql)
# 不是float类型, 也不是int类型, 是decimal类型
amount_before = float(mysql_data["leave_amount"])
# 由于使用float转化之后的数, 有可能小数位数超过2位, 需要使用round保留2位小数
amount_before = round(amount_before, 2)
#发起请求
res = self.do_request.send(url=new_url, data=new_data)
# 将相应报文中的数据转化为字典
actual_value = res.json()
#获取测试用例的行
row = case.case_id + 1
#获取预期结果
expected_result = case.expected
# 获取测试用例的标题
msg = case.title
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
self.assertEqual(actual_value.get("code"),
expected_result,
msg=msg)
if check_sql:
check_sql = Parameterize.to_param(check_sql)
mysql_data = self.do_mysql.run(sql=check_sql)
amount_after = float(mysql_data["leave_amount"])
amount_after = round(amount_after, 2)
#从data中取出充值金额
data = json.loads(new_data, encoding="utf8")
# 充值金额
current_recharge_amount = data["amount"]
#充值后金额
actual_amount = round(amount_before + current_recharge_amount,
2)
self.assertEqual(amount_after, actual_amount, msg="数据库中的金额有误")
except Exception as e:
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# error 指的时日志的收集等级
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
if "token_info" in res.text:
token = actual_value["data"]["token_info"]["token"]
header = {"Authorization": "Bearer " + token}
self.do_request.add_headers(header)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
# info 指的时日志的收集等级
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
finally:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
self.assertEqual(expected_result.get('msg'),
actual_value.get('msg'),
msg=msg)
except AssertionError as e:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# do_log.error("断言异常: {}".format(e))
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
if "token" in res.text:
token = actual_value.get('data')['token'] # 获取token信息
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
if case.case_id == 2:
companyId = actual_value.get('data')['companyId']
setattr(Parameterize, 'companyId', companyId)
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
def test_recharge(self, case):
# 将期望结果取出
expected = case.expected
# 参数化，将取出来的字符串进行参数替换（如果需要的话）
data_str = HandleParam.to_param(case.data)
# 拼接url
url = do_yaml.read_yaml('api', 'url') + case.url
# 判断用例种sql语句是否存在，存在的时候去做金额的查询(在充值之前)
check_sql = case.check_sql
# 如果SQL不为空，则进行参数替换，并且获取当前金额
if check_sql:
check_sql = HandleParam.to_param(check_sql)
mysql_data = self.do_mysql.run(check_sql)
old_amount = round(float(mysql_data['leave_amount']),
2) # 不是float和int，是decimal类型
# 向接口发起请求
res = self.do_request.send(url=url,
method=case.request_method,
data=data_str)
# 获取的报文转换为字典
result = res.json()
msg = case.title
success_msg = do_yaml.read_yaml('msg', 'success_result')
fail_msg = do_yaml.read_yaml('msg', 'fail_result')
row = case.case_id + 1
# assertEqual第三个参数为用例执行失败之后的提示信息
try:
self.assertEqual(expected, result['code'], msg=msg)
# 充值成功之后进行金额数值的校验
if check_sql:
# 去数据库取充值后的金额
new_amount = round(
float(self.do_mysql.run(check_sql)['leave_amount']), 2)
# new_amount = result['data']['leave_amount']
recharge_amount = json.loads(data_str)['amount']
actual_amount = round(new_amount - old_amount, 2)
self.assertEqual(recharge_amount, actual_amount, msg=msg)
except AssertionError as e:
# 将用例执行结果写入到result_col列
do_log.info('{}用例执行有误'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=fail_msg)
do_log.error('具体异常为{}'.format(e))
raise e
else:
do_log.info('{}用例执行通过'.format(case.title))
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'result_col'),
value=success_msg)
# 判断返回报文中是否有token，如果有则将token取出加入到请求头中
if result.get('data'):
if result.get('data').get('token_info'):
self.do_request.add_headers({"Authorization": \
"Bearer " + result['data']['token_info']['token']})
finally:
# 将响应实际结果写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read_yaml(
'excel', 'actual_col'),
value=res.text)
def test_recharge(self, case):
# 1. 参数化
new_data = Parameterize.to_param(case.data)
# 2. 拼接完整的url
new_url = do_yaml.read('api', 'prefix') + case.url
check_sql = case.check_sql # 取出check_sql
if check_sql: # 如果check_sql不为空, 则代表当前用例需要进行数据校验
check_sql = Parameterize.to_param(check_sql) # 将check_sql进行参数化
mysql_data = self.do_mysql.run(check_sql) # 执行sql
amount_before = float(mysql_data['leave_amount']) # 不是float类型, 也不是int类型, 是decimal类型
# 由于使用float转化之后的数, 有可能小数位数超过2位, 需要使用round保留2位小数
amount_before = round(amount_before, 2)
# 3. 向服务器发起请求
# 进行充值
res = self.do_request.send(url=new_url, # url地址
# method=case.method, # 请求方法
data=new_data, # 请求参数
# is_json=True # 是否以json格式来传递数据, 默认为True
)
# 将相应报文中的数据转化为字典
actual_value = res.json()
# 获取用例的行号
row = case.case_id + 1
# 将expected期望值转化为字典
expected_result = case.expected
msg = case.title # 获取标题
success_msg = do_yaml.read('msg', 'success_result') # 获取用例执行成功的提示
fail_msg = do_yaml.read('msg', 'fail_result') # 获取用例执行失败的提示
try:
self.assertEqual(expected_result, actual_value.get('code'), msg=msg)
# 如果check_sql不为空, 说明要进行数据校验
if check_sql:
mysql_data = self.do_mysql.run(sql=check_sql)
amount_after = float(mysql_data['leave_amount']) # 不是float浮点数, 更不是int类型, 而是decimal数据类型
amount_after = round(amount_after, 2)
one_dict = json.loads(new_data, encoding='utf-8')
currrent_recharge_amount = one_dict['amount']
actual_amount = round(amount_before + currrent_recharge_amount, 2)
self.assertEqual(actual_amount, amount_after, msg="数据库中充值的金额有误")
except AssertionError as e:
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=fail_msg)
# do_log.error("断言异常: {}".format(e))
do_log.error(f"{msg}, 执行的结果为: {fail_msg}\n具体异常为: {e}\n")
raise e
else:
# 如果登录接口断言成功, 则取出token, 并添加到公共请求头中
if 'token_info' in res.text:
token = actual_value['data']['token_info']['token']
headers = {"Authorization": "Bearer " + token}
self.do_request.add_headers(headers)
# 将相应实际值写入到actual_col列
self.excel.write_data(row=row,
column=do_yaml.read("excel", "actual_col"),
value=res.text)
# 将用例执行结果写入到result_col
self.excel.write_data(row=row,
column=do_yaml.read("excel", "result_col"),
value=success_msg)
do_log.info(f"{msg}, 执行的结果为: {success_msg}\n")
