def set_exec_usefile(_file, sheet):
if os.path.isfile(_file): # dir or file
datas_path_file = os.path.join(datas_path, _file)
logger.info(
f"---datas_path:{datas_path}-------{datas_path_file}--------------"
)
ReadWriteConfFile().set_option('exec', 'exec_file_path',
datas_path_file)
if sheet:
ReadWriteConfFile().set_option('exec', 'exec_sheet_name',
str(sheet))
else:
ReadWriteConfFile().set_option('exec', 'exec_sheet_name', '')
return '1'
elif os.path.isdir(_file): # dir or file
ReadWriteConfFile().set_option('exec', 'exec_file_path', _file)
if sheet:
ReadWriteConfFile().set_option('exec', 'exec_sheet_name',
str(sheet))
else:
ReadWriteConfFile().set_option('exec', 'exec_sheet_name', '')
return '2'
else: # error file or floder
logger.info(f"---datas_path:{datas_path}---------------------")
ReadWriteConfFile().set_option('exec', 'exec_file_path', datas_path)
ReadWriteConfFile().set_option('exec', 'exec_sheet_name', '')
return '3'
def main(file, sheet, report):
starttime = time.time()
set_exec_ini('report_file', 'file_num', '')
if report is None:
report_dir_format = start_time_format(starttime) + '_html'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(file, sheet)
file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
os.mkdir(mk_report_dir)
else:
report_dir_format = report + '_html'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(file, sheet)
file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
if not os.path.exists(mk_report_dir):
os.mkdir(mk_report_dir)
set_exec_ini('exec', 'st', st)
if st == '1':
new_report_excel_name = file_copy(datas_path, file, file,
f'{mk_report_dir}', 're_name')
elif st == '2':
new_report_excel_name = current_folder_file_copy(
datas_path, f'{mk_report_dir}', ['test_', '.xlsx'], 're_name')
else:
new_report_excel_name = file_and_folder_copy(datas_path,
f'{mk_report_dir}',
['test_', '.xlsx'],
're_name')
set_exec_ini('report_file', 'report_file_name', new_report_excel_name)
num = html_num(new_report_excel_name)
set_exec_ini('report_file', 'file_num', num)
from Common.handle_logger import logger
logger.info(f'----------传入参数<--file>,测试excel：{file}')
logger.info(f'----------传入参数<--sheet>,测试excel sheet name：{sheet}')
logger.info(f'----------传入参数<--report>,指定测试报告文件夹：{report}')
logger.info(f'测试报告文件夹：{mk_report_dir}'
) # os.path.join(REPORT_DIR, report_dir_format)
os.system(f'cd {BASE_DIR}')
os.system(
f'pytest {BASE_DIR}/TestCases/test_api.py -v --html={BASE_DIR}/Report/{report_dir_format}/{report_dir_format}_report_{num}_.html --self-contained-html'
)
# input_path = os.path.join(REPORT_DIR, report_dir_format)
# output_path = os.path.join(REPORT_DIR, f'{report_dir_format}.zip')
# file_zip_path(input_path, output_path, ignore=[]) # 压缩文件
# logger.info(f'测试报告压缩路径：{output_path}')
endtime = time.time()
logger.info(use_time(starttime, endtime))
set_exec_ini('report_file', 'file_num', '')
def _re_file_path(self, file_path):
if sys.platform == 'win32':
logger.info(file_path.replace(CASES_DIR.replace('\\', '/'), ''))
new_report_path = file_path.replace(CASES_DIR.replace('\\', '/'),
'')
p, f = os.path.split(new_report_path)
else:
new_report_path = file_path.replace(CASES_DIR, '')
p, f = os.path.split(new_report_path)
return p
def __get_re(self, param):
pattern = r'[$][{](.*?)[}]'
res = re.findall(pattern, str(param)) # ${aa}
paramn = ''
if res:
for r in res:
paramn = param.replace('${' + r + '}', r)
logger.info(
f"----------数据预处理after:--__get_re(param)>>{param}>>{paramn}--")
return paramn
def __abs(self, datan):
dataL = datan.split(',')
tmp = ''
for one in dataL:
if one.strip().isdigit():
tmp = tmp + f"[{one.strip()}]"
else:
tmp = tmp + f"['{one.strip()}']"
logger.info(f"----------数据预处理after:--__abs(datan)>>{datan}>>{tmp}--")
return tmp
def savejson(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
try:
request_data_path = self.__abs(apidata['request_data'].strip())
request_data_value = eval(str(self.jsonres) + request_data_path)
with allure.step(
f"[{mTime()}]['savejson'][relations_key:{apidata['input']}][jsonres_key:{request_data_path}]"
):
logger.info(f"relations_key:[{apidata['input']}]")
logger.info(f"jsonres_key:[{request_data_path}]")
logger.info(
f"self.relations[{apidata['input']}] = self.jsonres{request_data_path}"
)
self.relations[apidata['input'].strip()] = str(
request_data_value)
self.return_value(self.relations[apidata['input'].strip()])
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(sheet, str(request_data_value), row_pos,
col_pos_v) # self.jsonres[data['request_data']]
return {f'{apidata["input"].strip()}': f'{request_data_value}'}
except Exception as e:
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
return_str = f"key:'{request_data_path}'is not in {str(self.jsonres)}."
write_to_excel(sheet, str(return_str), row_pos, col_pos_v)
logger.error(return_str)
logger.error(e)
pass
def savedata(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
request_data_path = apidata['request_data'].strip()
try:
with allure.step(
f"[{mTime()}]['savedata'][relations_key:{apidata['input']}][relations_value:{request_data_path}]"
):
logger.info(f"relations_key:[{apidata['input']}]")
logger.info(f"relations_value:[{request_data_path}]")
logger.info(
f"self.relations[{apidata['input']}] = {request_data_path}"
)
if str(request_data_path).startswith('${'):
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
write_to_excel(sheet, str(request_data_path), row_pos,
col_pos_v)
else:
self.relations[
apidata['input'].strip()] = request_data_path
self.return_value(self.relations[apidata['input'].strip()])
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(
sheet, str(request_data_path), row_pos,
col_pos_v) # self.jsonres[data['request_data']]
return {f'{apidata["input"].strip()}': f'{request_data_path}'}
except Exception as e:
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
logger.error(e)
def saveparam(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
try:
input_path = apidata['input'].strip()
_data = apidata['request_data'].strip()
if str(_data).startswith('{') and str(_data).endswith('}'):
request_data_value = self.__get_data(_data)
else:
request_data_value = self.__get_relations(_data) # ???
with allure.step(
f"[{mTime()}]['saveparam'][saveparam_key:{input_path}][saveparam_value:{request_data_value}]"
):
logger.info(f"saveparam_key:[{input_path}]")
logger.info(f"saveparam_value:[{request_data_value}]")
logger.info(f"self.param[{input_path}] = {request_data_value}")
self.param[input_path] = request_data_value
self.return_value(self.param)
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(sheet, str(request_data_value), row_pos,
col_pos_v) # self.jsonres[data['request_data']]
return {f'{input_path}': f'{request_data_value}'}
except Exception as e:
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
logger.error(e)
pass
def __get_data(self, param):
if (param is None) or param == '':
return None
else:
param = param.replace('\'', '"').replace('\n', '').replace(
'\r', '').replace('\t', '')
paramn = self.__get_relations(param)
paramn = json.loads(paramn)
logger.info(
f"----------数据预处理before:--json.loads(paramn)>>{type(param)}>>{param}--"
)
logger.info(
f"----------数据预处理after :--json.loads(paramn)>>{type(paramn)}>>{paramn}--"
)
return paramn
def __get_relations(self, param):
pattern = r'[$][{](.*?)[}]'
if param is None or param == '':
return None
else:
for key in self.relations:
res = re.findall(pattern, param)
if res:
for r in res:
if r == key:
param = param.replace('${' + key + '}',
str(self.relations[key]))
logger.info(
f"----------数据预处理after:--self.relations[{key}]>>{self.relations[key]}--"
)
return param
def load_excel_setup(self, sheet_name, file_name, file_path):
if num == '':
numstr = ''
else:
numstr = f'(' + num + ')'
p = self._re_file_path(file_path)
write_file_name = os.path.splitext(
file_name)[0] + '_report' + numstr + os.path.splitext(file_name)[1]
new_path = file_path.replace(file_path, tmp_excel_path)
if p:
new_path = new_path + p
write_file_path = os.path.join(new_path, write_file_name)
logger.info(f'aaaaaaaa{write_file_path}')
wb, sheet = load_excel(write_file_path, sheet_name)
return wb, sheet, write_file_path
def __t_data(self, va):
title = ''
method = ''
input = ''
request_data = ''
status = ''
if va['title'] != '':
title = va['title']
if va['method'] != '':
method = va['method']
if va['input'] != '':
input = va['input']
if va['request_data'] != '':
request_data = va['request_data']
logger.info(
f"Test datas:【title:[{title}], method:[{method}], input:[{input}], request_data:[{request_data}]】"
)
def post(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:【'post'】")
url_path = str(apidata['input']).strip()
_data = apidata['request_data'].strip()
if url_path.startswith('http'):
new_url = url_path
else:
if url_path == '' or url_path is None:
new_url = self.url
else:
if str(self.url)[-1:] == '/':
new_url = self.url + url_path
else:
new_url = self.url + '/' + url_path
try:
with allure.step(
fr"[{mTime()}]['POST'][post_after:{self.result}]"):
new_url = self.__get_relations(new_url)
self.return_value(f'请求接口:[{new_url}]')
self.return_value(f'请求头:[{self.session.headers}]')
_data = self.__get_data(_data)
self.return_value(f'请求体:[{_data}]')
self.result = self.session.post(new_url,
json=_data,
data=None,
proxies=None)
self.jsonres = json.loads(self.result.text)
self.return_value(f'返回值:[{json.loads(self.result.text)}]')
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(sheet, str(self.jsonres), row_pos, col_pos_v)
except Exception as e:
logger.error(
f"Execute method '{sys._getframe().f_code.co_name}' error.")
logger.error(e)
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
write_to_excel(sheet, str(self.result.text), row_pos, col_pos_v)
finally:
self.param = {}
return self.jsonres
def seturl(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
try:
with allure.step(f"[{mTime()}]['seturl'][{apidata['input']}]"):
logger.info(f"输入参数:[{apidata['input']}]")
path = str(apidata['input']).strip()
if path.startswith('http'):
self.url = path
self.return_value(self.url)
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(sheet, str(apidata['input']), row_pos,
col_pos_v)
else:
write_to_excel(sheet, 'FAIL', row_pos, col_pos_c)
write_to_excel(sheet, str(apidata['input']), row_pos,
col_pos_v)
except Exception as e:
logger.error(
f"Execute method '{sys._getframe().f_code.co_name}' error.")
logger.error(e)
pass
def _re_file_path(self, file_path):
datas_path = os.path.join(BASE_DIR, "Datas")
logger.info(file_path)
logger.info(datas_path)
logger.info('datas_path')
if sys.platform == 'win32':
new_report_path = file_path.replace(datas_path.replace('\\', '/'),
'')
# p, f = os.path.split(new_report_path.replace('/', '\\'))
p, f = os.path.split(new_report_path)
else:
new_report_path = file_path.replace(datas_path, '')
p, f = os.path.split(new_report_path)
return p
def addheader(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
try:
with allure.step(
f"[{mTime()}]['addheader'][headers_key:{apidata['input']}][{apidata['request_data']}]"
):
logger.info(f"headers_key:[{apidata['input']}]")
logger.info(
f"headers_value_before:[{apidata['request_data']}]")
rel = self.__get_relations(apidata['request_data'].strip())
logger.info(f"headers_value_after(__get_relations):[{rel}]")
self.session.headers[apidata['input'].strip()] = rel
write_to_excel(sheet, 'PASS', row_pos, col_pos_c)
write_to_excel(sheet, str(rel), row_pos, col_pos_v)
return self.session.headers
except Exception as e:
logger.error(
f"key:'{self.__get_re(apidata['request_data'].strip())}' is not in [{self.relations}]."
)
logger.error(e)
pass
def report(request):
"""get command line parameters
:param request: --report
"""
starttime = time.time()
set_exec_ini('report_file', 'file_num', '')
set_exec_ini('report_dir', 'report_dir_folder', '')
if request.config.getoption(
"--report") is None or request.config.getoption("--report") == '':
report_dir_format = start_time_format(starttime) + '_allure'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(datas_path, sheet)
# file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
logger.info(f'-----mk_report_dir--：{mk_report_dir}')
os.mkdir(mk_report_dir)
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
else:
report_dir_format = request.config.getoption("--report") + '_allure'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(datas_path, sheet)
# file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
logger.info(f'-----mk_report_dir--：{mk_report_dir}')
if not os.path.exists(mk_report_dir):
logger.info(f'-----mk_report_dir-')
os.mkdir(mk_report_dir)
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
set_exec_ini('exec', 'st', st)
if st == '1':
print('11')
new_report_excel_name = file_copy(datas_path, execfile, execfile,
f'{mk_report_dir}', 're_name')
elif st == '2':
print('22')
new_report_excel_name = current_folder_file_copy(
datas_path, f'{mk_report_dir}', ['test_', '.xlsx'], 're_name')
else:
print('33')
new_report_excel_name = file_and_folder_copy(datas_path,
f'{mk_report_dir}',
['test_', '.xlsx'],
're_name')
set_exec_ini('report_file', 'report_file_name', new_report_excel_name)
num = html_num(new_report_excel_name)
set_exec_ini('report_file', 'file_num', num)
# from Common.handle_logger import logger
logger.info(f'----------传入参数<--file>,测试excel：{execfile}')
logger.info(f'----------传入参数<--sheet>,测试excel sheet name：{sheet}')
logger.info(
f'----------传入参数<--report>,指定测试报告文件夹：{request.config.getoption("--report")}_allure'
)
logger.info(f'测试报告文件夹：{os.path.join(REPORT_DIR, report_dir_format)}')
yield request.config.getoption("--report")
input_path = os.path.join(REPORT_DIR, report_dir_format)
output_path = os.path.join(REPORT_DIR, f'{report_dir_format}_{num}.zip')
file_zip_path(input_path, output_path, ignore=[]) # 压缩文件
logger.info(f'测试报告压缩路径：{output_path}')
set_exec_ini('report_file', 'file_num', '')
# set_exec_ini('report_dir', 'report_dir_folder', '')
set_exec_ini('exec', 'exec_sheet_name', '')
endtime = time.time()
logger.info(f"------------------------")
logger.info(use_time(starttime, endtime))
logger.info(f"------------------------")
def requests_session():
"""
init requests.session()
"""
logger.info('*' * 100)
logger.info('*' * 20 + '测试执行开始' + '*' * 20)
global _session
_session = requests.session()
logger.info(f'----------requests_session setup----------')
logger.info(f'获取session：{_session}')
yield _session
_session.close()
logger.info(f'销毁session：{_session}')
logger.info(f'----------requests_session teardown----------')
logger.info('*' * 20 + '测试执行结束' + '*' * 20)
logger.info('*' * 100)
def main(file, sheet, report):
starttime = time.time()
set_exec_ini('report_file', 'file_num', '')
if report is None:
report_dir_format = start_time_format(starttime) + '_allure'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(file, sheet)
file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
os.mkdir(mk_report_dir)
else:
report_dir_format = report + '_allure'
set_exec_ini('report_dir', 'report_dir_folder', report_dir_format)
st = set_exec_usefile(file, sheet)
file_del(os.path.join(BASE_DIR, 'temp'))
mk_report_dir = os.path.join(REPORT_DIR, report_dir_format)
if not os.path.exists(mk_report_dir):
os.mkdir(mk_report_dir)
set_exec_ini('exec', 'st', st)
if st == '1':
new_report_excel_name = file_copy(datas_path, file, file, f'{mk_report_dir}', 're_name')
elif st == '2':
new_report_excel_name = current_folder_file_copy(datas_path, f'{mk_report_dir}', ['test_', '.xlsx'], 're_name')
else:
new_report_excel_name = file_and_folder_copy(datas_path, f'{mk_report_dir}', ['test_', '.xlsx'], 're_name')
set_exec_ini('report_file', 'report_file_name', new_report_excel_name)
num = html_num(new_report_excel_name)
set_exec_ini('report_file', 'file_num', num)
from Common.handle_logger import logger
logger.info(f'----------传入参数<--file>,测试excel：{file}')
logger.info(f'----------传入参数<--sheet>,测试excel sheet name：{sheet}')
logger.info(f'----------传入参数<--report>,指定测试报告文件夹：{report}_allure')
logger.info(f'测试报告文件夹：{os.path.join(REPORT_DIR, report_dir_format)}')
# pytest.main(['-sv', './TestCases/Login/test_login.py', '--alluredir', './temp']) # web test
pytest.main(['-sv', './TestCases/test_api.py', '--alluredir', './temp']) # api test
os.system(f'allure generate ./temp -o ./Report/{report_dir_format}/allure/ --clean')
input_path = os.path.join(REPORT_DIR, report_dir_format)
output_path = os.path.join(REPORT_DIR, f'{report_dir_format}_{num}.zip')
file_zip_path(input_path, output_path, ignore=[]) # 压缩文件
logger.info(f'测试报告压缩路径：{output_path}')
endtime = time.time()
logger.info(use_time(starttime, endtime))
set_exec_ini('report_file', 'file_num', '')
def assertequals(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
dictabspath = self.__abs(apidata['input'])
expect_value = str(apidata['request_data']).strip()
actual_value = ''
try:
dict_value = eval(str(self.jsonres) + dictabspath)
actual_value = str(dict_value)
except Exception as e:
logger.error(f"{str(self.jsonres) + dictabspath} is not exist.")
logger.error(e)
pass
with allure.step(
f"[{mTime()}]['assertequals'][key:{apidata['input']},actual_value:{actual_value}][expect_value:{expect_value}]"
):
logger.info(f"key:[{apidata['input']}]")
logger.info(f"ACTUAL_VALUE:[{actual_value}]")
logger.info(f"EXPECT_VALUE:[{expect_value}]")
try:
assert actual_value == expect_value
except AssertionError as e:
self.return_value('FAIL')
logger.info('--Fail--用例失败--')
logger.exception(e)
# raise
str_result = 'FAIL'
else:
self.return_value('PASS')
logger.info('--Pass--用例成功--')
str_result = 'PASS'
self.__allurestep(str_result)
write_to_excel(sheet, str_result, row_pos, col_pos_c)
write_to_excel(sheet, str(actual_value), row_pos, col_pos_v)
return str_result
def allurestep(self, va):
if va['title'] != '':
with allure.step(f"Test title：{va['title']}"):
logger.info(f"Test title：{va['title']}")
def test_all_api(self, requests_session, data):
http = Http(requests_session)
allure.dynamic.feature(
f'{self.__class__.__name__}.{sys.__loader__.__name__}')
allure.dynamic.story(
f'{list(data.values())[1]}<>{list(data.values())[0]}')
allure.dynamic.description(
f'FILE SHEET： {list(data.values())[0]} \n\nFILE NAME： {list(data.values())[1]} \n\nFILE PATH： {list(data.values())[2]}'
)
logger.info(f'{self.__class__.__name__}.{sys.__loader__.__name__}')
logger.info(
f'FILE SHEET： {list(data.values())[0]} FILE NAME： {list(data.values())[1]} FILE PATH： {list(data.values())[2]}'
)
logger.info(list(data.values())[2])
wb, sheet, write_path = self.load_excel_setup(
list(data.values())[0],
list(data.values())[1],
list(data.values())[2])
exec_c, col_pos_c = Handle_excel(list(
data.values())[2]).getColumnValuesByTitle(sheet, 'return_code')
exec_v, col_pos_v = Handle_excel(list(
data.values())[2]).getColumnValuesByTitle(sheet, 'return_values')
logger.info(f"Execute test suite: {self.__class__.__name__}")
logger.info(f"Execute test case: {list(data.values())[0]}")
for va in list(data.values())[3]:
self.allurestep(va) # tilte only
self.__t_data(va)
func = getattr(http, va['method'])
row_pos = va['exec']
res = func(va, sheet, row_pos, col_pos_c, col_pos_v)
logger.info(f'Function return value：{str(res)}')
self.save_excel_teardown(wb, write_path)
logger.info(f"Write Excel：{'save_excel_teardown'}")
def assertInRe(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
expect_value = str(apidata['request_data']).strip()
d_k = str(apidata['input']).strip()
pattern = f'"{d_k}": "(.+?)"'
result_to_json = json.dumps(self.jsonres)
res = re.findall(pattern, result_to_json) # 正则从json中取值
with allure.step(
f"[{mTime()}]['assertInRe'][key:{d_k},actual_value:{res}][expect_value:{expect_value}]"
):
logger.info(f"key:{d_k}")
logger.info(f"ACTUAL_VALUE:[{res}]")
logger.info(f"EXPECT_VALUE:[{expect_value}]")
try:
assert expect_value in res
except AssertionError as e:
self.return_value('FAIL')
logger.info('--Fail--用例失败--')
logger.exception(e)
# raise
str_result = 'FAIL'
else:
self.return_value('PASS')
logger.info('--Pass--用例成功--')
str_result = 'PASS'
self.__allurestep(str_result)
write_to_excel(sheet, str_result, row_pos, col_pos_c)
write_to_excel(sheet, str(res), row_pos, col_pos_v)
return str_result
def assertJsonpath(self, apidata, sheet, row_pos, col_pos_c, col_pos_v):
logger.info(f"执行函数:{sys._getframe().f_code.co_name}")
expect_value = str(apidata['request_data']).strip()
datan = str(apidata['input']).strip()
result_to_json = json.dumps(self.jsonres)
res = jsonpath.jsonpath(result_to_json, f'$..{datan}') # 找不到是结果是 False
with allure.step(
f"[{mTime()}]['assertInRe'][key:{datan},actual_value:{res}][expect_value:{expect_value}]"
):
logger.info(f"key:{datan}")
logger.info(f"ACTUAL_VALUE:[{res}]")
logger.info(f"EXPECT_VALUE:[{expect_value}]")
try:
if isinstance(res, list):
assert expect_value in res
else:
assert expect_value == res
except AssertionError as e:
self.return_value('FAIL')
logger.info('--Fail--用例失败--')
logger.exception(e)
# raise
str_result = 'FAIL'
else:
self.return_value('PASS')
logger.info('--Pass--用例成功--')
str_result = 'PASS'
self.__allurestep(str_result)
write_to_excel(sheet, str_result, row_pos, col_pos_c)
write_to_excel(sheet, str(res), row_pos, col_pos_v)
return str_result
def return_value(self, value):
with allure.step(f"值是：{value}"):
logger.info(f"值是：{value}")
