def check_match_urlpath(self):
"""
检测接口抓包文档与映射接口文档中匹配的UrlPath是否存在一一映射匹配关系
:return:
"""
try:
case_doc_df_count = self.case_doc_df.shape[0]
capture_doc_df_count = self.capture_doc_cid_check.__len__()
if case_doc_df_count < capture_doc_df_count:
swagger_doc_less_set = set([
str(i).strip()
for i in self.capture_doc_df["CID"].values.tolist()
]) - set([
str(i).strip()
for i in self.case_doc_df["UrlPath"].values.tolist()
])
logger.warning(
"[WARNING]：检测到映射接口文档中缺少接口抓包文档中映射匹配的UrlPath，检测结果：{}，请检查相关接口文档是否符合需求或手动追加！"
.format(swagger_doc_less_set))
return False
if case_doc_df_count == capture_doc_df_count:
logger.info(
"[Success]：映射接口文档与接口抓包文档中UrlPath一一映射匹配关系检测通过，二者存在一一映射匹配的UrlPath."
)
return True
except Exception:
logger.exception(
"[Exception]：检测映射接口文档与接口抓包文档进行UrlPath一一映射匹配关系过程中发生异常，请检查！")
return False
def __init__(self, excel_path, sheet=0):
'''
指定默认参数文件、表格、构造标识
:param excel: Excel文件路径(xls格式)
:param sheet: 默认表格0
'''
excel_extension = str(os.path.splitext(excel_path)[1])
try:
if os.path.exists(excel_path):
if excel_extension.lower() not in [".xls"]:
raise DotTypeError
else:
raise FileNotFoundError
self.excel_path = excel_path
init_workbook = open_workbook(excel_path, formatting_info=True)
sheet_reader = init_workbook.sheet_by_index(sheet)
self.row_count = sheet_reader.nrows
self.column_count = sheet_reader.ncols
self.workbook = copy(init_workbook)
logger.info('[Initial]：当前准备同步的EXCEL文件为：{}'.format(excel_path))
self.w = self.workbook.get_sheet(sheet)
logger.info('当前Sheet表格限定为：{}'.format(sheet))
except DotTypeError:
logger.exception(
'当前不支持文件扩展名"{}", 请指定xls格式的表格文件.'.format(excel_extension))
except FileNotFoundError:
logger.exception('非法EXCEL文件路径！~ "{}"'.format(excel_path))
def __init__(self, excel_path, sheet=0):
'''
指定默认参数文件、表格、构造标识
:param excel: Excel文件路径(xlsx格式)
:param sheet: 默认表格0
'''
excel_extension = str(os.path.splitext(excel_path)[1])
try:
if os.path.exists(excel_path):
if excel_extension.lower() not in [".xlsx"]:
raise DotTypeError
else:
raise FileNotFoundError
self.excel_path = excel_path
self.init_workbook = load_workbook(excel_path)
specify_sheet = self.init_workbook.sheetnames[sheet]
self.sheet_reader = self.init_workbook[specify_sheet]
self.row_count = self.sheet_reader.max_row
self.column_count = self.sheet_reader.max_column
logger.info('[Initial]：当前准备同步的EXCEL文件为：{}'.format(excel_path))
logger.info('当前Sheet表格限定为：{}'.format(sheet))
except DotTypeError:
logger.exception(
'当前不支持文件扩展名"{}", 请指定xlsx格式的表格文件.'.format(excel_extension))
except FileNotFoundError:
logger.exception('非法EXCEL文件路径！~ "{}"'.format(excel_path))
def check_exist_urlpath(self):
"""
检测接口抓包文档在Swagger接口文档中是否存在匹配的UrlPath
:return:
"""
try:
if self.capture_doc_df["CID"].shape[
0] == 0 or self.capture_doc_cid_check == []:
logger.warning(
"[WARNING]：接口抓包文档中UrlPath当前无任何填充数据，请首先完成接口抓包工作！")
sys.exit(1)
if self.case_doc_df["UrlPath"].shape[0] == 0:
logger.warning(
"[WARNING]：接口抓包文档中UrlPath在Swagger接口文档中未匹配到任何数据，请检查接口抓包文档和Swagger接口文档是否符合需求！"
)
return False
if self.case_doc_df["UrlPath"].shape[
0] != 0 and self.capture_doc_df["CID"].shape[0] != 0:
logger.info(
"[Success]：Swagger接口文档及接口抓包文档中UrlPath是否存在匹配数据检测通过，二者UrlPath存在匹配数据."
)
return True
except Exception:
logger.exception(
"[Exception]：检测接口抓包文档中UrlPath在Swagger接口文档中是否存在匹配数据过程中发生异常，请检查！"
)
return False
def check_duplicate_urlpath(self):
"""
检测映射接口文档中匹配的UrlPath是否存在重复值
:return:
"""
pass_flag = False
try:
if self.check_exist_urlpath is True:
case_doc_urlpath_veriry = {
i: j
for i, j in dict(
Counter([
str(i).strip() for i in
self.case_doc_df["UrlPath"].values.tolist()
])).items() if j > 1
}
if case_doc_urlpath_veriry == {}:
logger.info(
"[Success]：映射接口文档中匹配的UrlPath是否存在重复值检测通过，其匹配的UrlPath均唯一."
)
return True
if case_doc_urlpath_veriry != {}:
logger.warning(
'[WARNING]：检测到映射接口文档中存在重复的UrlPath，检测结果：{}，请仔细核对并明确需求！'.
format(case_doc_urlpath_veriry))
pass_flag = False
return pass_flag
else:
logger.error(
"[Fail]：Swagger接口文档与接口抓包文档进行UrlPath数据匹配检测失败，请仔细检查相关文档数据！")
sys.exit(1)
except Exception:
logger.exception(
"[Exception]：检测映射接口文档中匹配的UrlPath是否存在重复值过程中发生异常，请检查！")
return False
def login(self):
"""
触发登录接口请求并XX业务请求令牌Token值
:return:
"""
logger.info('[Start]：开始请求登录XX业务{}环境后台服务...'.format(self.env))
login_res = RequestTool().post(url=self.login_url,
headers={"Content-Type": "application/json;charset=UTF-8"},
data=json.dumps(
{"username": "******".format(self.username),
"password": "******".format(encrypt.MD5(self.password)),
"verificationCode": "{}".format(self.validcode),
"code": "hlwyy",
"userType": 3, "token": ""}),
verify=True)
response_str = login_res.text.split("\"")[1]
# response_str = login_res.text
decrypt_login_res = ResponseDecrypt(response_str=response_str).decrypt()
decrypt_login_res = re.sub(r"\n|\t|\r|\r\n|\n\r|\x08|\\", "", decrypt_login_res)
login_res_dict = json.loads(decrypt_login_res)
if login_res_dict.get("err") == 0 and login_res_dict.get("errmsg") == '操作成功':
self.token = login_res_dict['data']['token']
logger.info('[Success]：XX业务{}环境后台服务登录成功, 请求令牌Token值为: {}'.format(self.env, self.token))
return self
else:
logger.warning(
"[WARNING]：XX业务{}环境后台服务登录失败，接口响应为【{}】，重试登录中...".format(self.env, login_res_dict))
sys.exit(1)
def check_match_urlpath(self):
"""
检测Swagger接口文档与接口抓包文档中的UrlPath是否映射匹配
:return:
"""
try:
case_doc_df_count = self.case_doc_df.shape[0]
capture_doc_df_count = self.capture_doc_df.shape[0]
if case_doc_df_count == 0:
logger.warning(
"[WARNING]：检测到Swagger接口文档中无任何映射匹配的UrlPath，请检查相关接口文档是否符合需求或手动追加！"
)
return False
if case_doc_df_count < capture_doc_df_count:
swagger_doc_less_set = set([
str(i).strip()
for i in self.capture_doc_df["CID"].values.tolist()
]) - set([
str(i).strip()
for i in self.case_doc_df["UrlPath"].values.tolist()
])
logger.warning(
"[WARNING]：检测到Swagger接口文档中缺少映射匹配的UrlPath，检测结果：{}，请检查相关接口文档是否符合需求或手动追加！"
.format(swagger_doc_less_set))
return False
if case_doc_df_count == capture_doc_df_count:
logger.info(
"[Success]：Swagger接口文档与接口抓包文档中UrlPath映射匹配规则检测通过，二者存在数量相等且映射匹配的UrlPath."
)
return True
except Exception:
logger.exception(
"[Exception]：检测Swagger接口文档与接口抓包文档进行UrlPath映射匹配规则过程中发生异常，请检查！")
return False
def send(self, msgtype):
"""
发送钉钉机器人消息提醒
:param msgtype: 消息提醒类型
:return:
"""
try:
if msgtype not in [
'text', 'link', 'markdown', 'actionCard', 'feedCard'
]:
logger.warning(
'[WARNING]：检测到非法消息类型"{}"，当前仅支持text、link、markdown、actionCard、feedCard，请重新指定！'
.format(msgtype))
sys.exit(1)
url = "https://oapi.dingtalk.com/robot/send?access_token={}×tamp={}&sign={}".format(
self.token, self.timestamp, self.get_sign)
headers = {'Content-Type': 'application/json'}
response = requests.request("POST",
url,
headers=headers,
data=self.generate_msg(msgtype))
result = response.json()
if result.get("errcode") == 0 and result.get("errmsg") == 'ok':
logger.info("[Done]：钉钉机器人消息提醒成功.")
else:
logger.warning(
"[WARNING]：钉钉机器人消息提醒失败，接口响应为【{}】，开始重试...".format(result))
sys.exit(1)
except Exception:
logger.exception("[Exception]：发送钉钉机器人消息提醒过程中发生异常，请检查！")
sys.exit(1)
def time_frequency(self, start, end):
"""
计算ELK查询时间分片（hour:1小时）
:param start: 开始时间
:param end: 结束时间
:return:
"""
def str_to_format(datetime_str):
temp_datetime = str(datetime_str).split(r"T")
temp_date = temp_datetime[0]
temp_time = temp_datetime[1].split(r".")[0]
format_datetime = " ".join([temp_date, temp_time])
return format_datetime
def dt_to_format(dt):
return dt.strftime("%Y-%m-%dT%H:%M:%S.000Z")
start_datetime = datetime.datetime.strptime(str_to_format(start),
"%Y-%m-%d %H:%M:%S")
end_datetime = datetime.datetime.strptime(str_to_format(end),
"%Y-%m-%d %H:%M:%S")
interval_days = (end_datetime - start_datetime).days
interval_hours = int((end_datetime - start_datetime).seconds / 3600)
total_hours = interval_days * 24 + interval_hours
logger.info("【ELK】起止时间共相差{}天{}小时，则数据采集预期DSL时间分片总数为：{}".format(
interval_days, interval_hours, total_hours))
hours_interval_list = []
for hours in range(1, total_hours + 1):
hours_interval_list.append(
dict(start=dt_to_format(start_datetime),
end=dt_to_format(start_datetime + timedelta(hours=1))))
start_datetime = start_datetime + timedelta(hours=1)
return hours_interval_list
def pytest_sessionfinish():
"""
【终止自动化测试会话】~ 用于测试报告、邮件通知、钉钉提醒等。
:return:
"""
logger.info("☞【同步测试结果】")
AllureTools.generate_report()
# Email().send("E2E接口自动化测试完成，请查阅报告。")
EnvironmentDingTools(ding_notify_file=os.path.join(
RESOURCE_PATH, "Ding", "DingNotifyTemplate.json"),
preview_mode=True).send(msgtype='markdown')
logger.info("O(∩_∩)O【自动化测试全部完成】")
def clear_result(cls):
"""
清空Allure测试结果json文件。
"""
try:
if os.listdir(ALLURE_RESULT) != list():
time.sleep(1)
shutil.rmtree(ALLURE_RESULT)
os.mkdir(ALLURE_RESULT)
logger.info("[Success]：已经成功清空Allure历史测试结果.")
else:
logger.info("当前暂无Allure历史测试结果，无需清除操作！")
except Exception:
logger.exception("[Exception]：清空Allure历史测试结果过程中发生异常，请检查！")
def generate(self, test_case_file, sep=r'|', encoding='utf-8'):
"""
生成测试用例文件(当前支持Excel文件[xls/xlsx]及文本文件[csv/txt])
:param test_case_file: 测试用例文件路径
:param sep: 文件分隔符,默认"|"。
:param encoding: 文件编码格式。
:return:
"""
logger.info("[Initial]：开始自动评估测试用例生成条件......")
file_extend = str(os.path.splitext(test_case_file)[-1]).lower()
try:
test_case_df = self.load_test_case
if file_extend not in [".csv", ".txt", ".xls", ".xlsx"]:
logger.warning(
"[WARNING]：自动生成的测试用例文件扩展名当前仅支持[csv、txt、xls、xlsx]，请检查！")
sys.exit(1)
if file_extend in ['.xls', '.xlsx']:
logger.info(
"[Loading]：开始自动生成{}格式测试用例文件......".format(file_extend))
test_case_df.to_excel(test_case_file, index=False)
if file_extend in ['.csv', '.txt']:
logger.info(
"[Loading]：开始自动生成{}格式测试用例文件......".format(file_extend))
test_case_df.to_csv(test_case_file,
sep=sep,
index=False,
header=True,
encoding=encoding)
logger.info('[Done]：{}格式测试用例文件已经成功自动生成，路径为"{}".'.format(
file_extend, test_case_file))
except Exception:
logger.exception(
"[Exception]: {}格式测试用例文件自动生成过程中发生异常，请检查！".format(file_extend))
sys.exit(1)
def initial_allure(cls):
"""
初始化Allure
:return:
"""
try:
logger.info('[Initial]：开始初始化Allure......')
cls.clear_result()
if os.path.exists(ALLURE_REPORT):
cls.sync_history()
cls.sync_environment()
cls.sync_categories()
logger.info("[Done]：已经成功初始化Allure.")
except Exception:
logger.exception("[Exception]：初始化Allure过程中发生异常，请检查！")
def check_duplicate_urlpath(self):
"""
检查Swagger接口文档及接口抓包文档中是否存在重复的UrlPath.
:return:
"""
pass_flag = False
try:
if self.check_empty_urlpath is True:
swagger_doc_urlpath_veriry = {
i: j
for i, j in dict(
Counter([
str(i).strip() for i in
self.swagger_doc_df["UrlPath"].values.tolist()
])).items() if j > 1
}
capture_doc_urlpath_veriry = {
i: j
for i, j in dict(
Counter([
str(i).strip() for i in
self.capture_doc_df["CID"].values.tolist()
])).items() if j > 1
}
if swagger_doc_urlpath_veriry == {} and capture_doc_urlpath_veriry == {}:
logger.info(
"[Success]：Swagger接口文档或接口抓包文档中各自UrlPath列是否存在重复值检测通过，二者各自UrlPath列均无重复值."
)
return True
if swagger_doc_urlpath_veriry != {}:
logger.warning(
'[WARNING]：检测到Swagger接口文档中存在重复的UrlPath，检测结果：{}，请仔细核对并明确需求！'
.format(swagger_doc_urlpath_veriry))
pass_flag = False
if capture_doc_urlpath_veriry != {}:
logger.warning(
'[WARNING]：检测到接口抓包文档中存在重复的UrlPath，检测结果：{}，请仔细核对并明确需求！'.
format(capture_doc_urlpath_veriry))
pass_flag = False
return pass_flag
else:
logger.warning("[WARNING]：请先正常初始化Swagger接口文档和接口抓包文档！")
sys.exit(1)
except Exception:
logger.exception(
"[Exception]：检测Swagger接口文档或接口抓包文档中各自UrlPath列是否存在重复值过程中发生异常，请检查！"
)
return False
def sync_environment(cls):
"""
同步Allure环境信息文件
:return:
"""
ENVIRONMENT_INFO = os.path.join(RESOURCE_PATH, "Allure", "environment.properties")
try:
if os.path.exists(ENVIRONMENT_INFO):
time.sleep(1)
shutil.copyfile(ENVIRONMENT_INFO, os.path.join(ALLURE_RESULT, "environment.properties"))
logger.info("[Success]：已经成功同步Allure环境信息文件.")
else:
raise FileNotFoundError
except FileNotFoundError:
logger.exception('[Exception]：Allure环境信息文件"{}"并不存在，无法同步，请检查！'.format(ENVIRONMENT_INFO))
except Exception:
logger.exception("[Exception]：同步Allure环境信息文件过程中发生异常，请检查！")
def sync_categories(cls):
"""
同步Allure测试分类文件
:return:
"""
CATEGORIES_INFO = os.path.join(RESOURCE_PATH, "Allure", "categories.json")
try:
if os.path.exists(CATEGORIES_INFO):
time.sleep(1)
shutil.copyfile(CATEGORIES_INFO, os.path.join(ALLURE_RESULT, "categories.json"))
logger.info("[Success]：已经成功同步Allure测试分类文件.")
else:
raise FileNotFoundError
except FileNotFoundError:
logger.exception('[Exception]：Allure测试分类文件"{}"并不存在，无法同步，请检查！'.format(CATEGORIES_INFO))
except Exception:
logger.exception("[Exception]：同步Allure测试分类文件过程中发生异常，请检查！")
def generate_data(self):
'''
返回构造的sheet表单内数据
:return:
'''
try:
if self.data_type:
title = self.r.row_values(0)
for col in range(1, self.r.nrows):
self._data.append(dict(zip(title, self.r.row_values(col))))
else:
for col in range(0, self.r.nrows):
self._data.append(self.r.row_values(col))
logger.info("[Success]：当前Excel文件已成功完成数据生成！")
return self._data
except Exception:
logger.exception("初始化Excel文件数据过程中发生异常，请检查！")
def generate_report(cls):
"""
根据json结果文件自动生成Allure测试报告。
"""
try:
if cls.check_result() is True:
command = "allure generate {0} -o {1} --clean".format(ALLURE_RESULT, ALLURE_REPORT)
time.sleep(1)
logger.info('开始执行Allure测试报告生成命令："{}"'.format(command))
run_command(command)
logger.info("[Done]：已经成功生成Allure测试报告.")
else:
logger.warning("[Warning]：由于未检测到Allure测试结果json文件，停止生成Allure测试报告！")
except CalledProcessError:
logger.exception("[Exception]：Allure测试报告生成命令执行失败！")
except Exception:
logger.exception("[Exception]：生成Allure测试报告过程中发生异常，请检查！")
def teardown_class(self):
"""
测试用例结束操作
:return:
"""
with open(file=os.path.join(RECORD_PATH, "ApiRecordDocs.json"),
mode=r'w',
encoding='utf-8') as record:
record.write(
json.dumps(self.REALTIME_API_DICT,
ensure_ascii=False,
indent=2))
logger.info("[Record]：接口信息实时录制已完成并保存成功.")
# 删除接口信息缓存字典
del self.REALTIME_API_DICT
# 保存更新后的测试用例
self.ender.save_testcase_result()
logger.info("[Done]：EXCEL测试用例文件已同步更新执行结果并保存.")
def testcase_result_clear(self):
"""
清除测试用例文件上次运行的结果记录.
:return:
"""
# 清除上次更新时间
self.writer.write_column(TESTCASE_TITLE_ORDER_ENUM.UpdateTime.value,
"")
# 清除上次测试结果
self.writer.write_column(TESTCASE_TITLE_ORDER_ENUM.TestResult.value,
"")
# 清除上次测试描述
self.writer.write_column(
TESTCASE_TITLE_ORDER_ENUM.TestDescription.value, "")
# 清除上次请求结果
self.writer.write_column(
TESTCASE_TITLE_ORDER_ENUM.ActualResponse.value, "").save()
logger.info("[Done]：EXCEL用例文件已完成结果重置.")
def get_swagger_to_excel(self, file_path):
"""
根据Swagger生成Excel接口文档。
:param file_path: Excel文件路径。
:return:
"""
try:
if str(os.path.splitext(file_path)[-1]).lower() not in [
".xls", ".xlsx"
]:
logger.warning("[WARNING]：生成的Excel文件扩展名必须为xls或xlsx格式，请检查！")
sys.exit(1)
logger.info("[Initial]：开始通过Swagger转换生成Excel接口文档[依赖环境配置]......")
swagger_dataframe = self.get_swagger_to_dataframe
swagger_dataframe.to_excel(file_path, index=False)
logger.info(
'[Done]：已通过Swagger成功转换生成Excel接口文档，路径为"{}".'.format(file_path))
except Exception:
logger.exception("[Exception]: 通过Swagger生成Excel接口文档失败，请检查原因！")
sys.exit(1)
def attachFile(self, file):
'''
构造附件扩展，仅MIMEBase支持中文附件
:param file: 附件文件
'''
# with open(file, 'rb') as f:
# att = MIMEText(f.read(), 'plait', 'utf-8')
# att["Content-Type"] = 'application/octet-stream'
# filename = re.split(r'[\\|/]', file)[-1]
# att["Content-Disposition"] = 'attachment; filename={}'.format(filename)
# self.msg.attach(att)
# logger.info('邮件已添加附件 {}'.format(filename))
att = MIMEBase('application', 'octet-stream')
with open(file, 'rb') as f:
att.set_payload(f.read())
filename = re.split(r'[\\|/]', file)[-1]
att.add_header('Content-Disposition', 'attachment', filename=('gbk', '', filename))
encoders.encode_base64(att)
self.msg.attach(att)
logger.info('邮件已添加附件 {}'.format(filename))
def sync_history(cls):
"""
追加Allure历史追溯信息
:return:
"""
ALLURE_REPORT_HISTORY = os.path.join(ALLURE_REPORT, "history")
ALLURE_RESULT_HISTORY = os.path.join(ALLURE_RESULT, "history")
try:
if os.path.exists(ALLURE_RESULT_HISTORY):
raise FileExistsError
if os.path.exists(ALLURE_REPORT_HISTORY):
time.sleep(1)
shutil.copytree(ALLURE_REPORT_HISTORY, ALLURE_RESULT_HISTORY)
logger.info("[Success]：已经成功同步Allure历史追溯信息.")
else:
logger.warning('[WARNING]：Allure历史追溯信息"{}"当前并不存在，无法完成同步！'.format(ALLURE_REPORT_HISTORY))
except FileExistsError:
logger.exception('[Exception]：已同步Allure历史追溯信息至"{}"，无需再次同步！'.format(ALLURE_RESULT_HISTORY))
except Exception:
logger.exception("[Exception]：同步Allure历史追溯信息过程中发生异常，请检查！")
def check_result(cls, check_count=CHECK_COUNT):
"""
检查Allure测试结果json文件是否生成。
:param check_count: 检测次数。
:return:
"""
check_result = None
for count in range(check_count):
if os.listdir(ALLURE_RESULT) == list() and count < check_count:
if count == check_count - 1:
logger.warning("仍未检测到Allure测试结果json文件，已达检测次数上限({})，停止检测。".format(check_count))
check_result = False
break
logger.info("未检测到Allure测试结果json文件，可能正在生成......")
time.sleep(2)
continue
if os.listdir(ALLURE_RESULT) != list():
logger.info("[Success]：已检测到Allure测试结果json文件.")
check_result = True
break
return check_result
def untar(self, tarname, dstpath=OUTPUT_PATH):
'''
将指定tar包压缩文件解压缩到指定文件夹，并删除源tar包压缩文件
:param tarname: 待解压tar包压缩文件（需指定绝对路径）
:param dstpath: 指定解压路径（层级结构，默认解压缩路径为OUTPUT_PATH文件目录）
:return dstpath:返回解压缩路径
'''
try:
initname = re.split(r'[\\|/]', tarname)[-1]
dot = os.path.splitext(initname)[1]
comtype = dot[1:]
if os.path.isfile(tarname) and os.path.exists(tarname):
if dot in [r'.gz', r'.bz2', r'.xz']:
tarhandler = tarfile.open(tarname, "r:{}".format(comtype))
for file in tarhandler.getnames():
logger.info('文件"{0}"开始{1}解压缩提取.'.format(file, comtype))
tarhandler.extractall(dstpath)
logger.info('压缩文件"{0}"已{1}解压缩成功, 解压路径为："{2}".'.format(
initname, comtype, dstpath))
tarhandler.close()
os.remove(tarname)
logger.info('压缩文件"{}"已物理删除.'.format(initname))
return dstpath
else:
raise DotTypeError
else:
raise FileNotFoundError
except FileNotFoundError:
logger.exception('文件不存在或其路径非法, 请检查参数路径（其中压缩文件需指定绝对路径）.')
except DotTypeError:
logger.exception(
'非法压缩文件后缀名"{}", 请指定".tar.gz/.tar.bz2/.tar.xz"中任意后缀名的压缩文件名称.'.
format(dot))
def unzip(self, zipname, dstpath=OUTPUT_PATH):
'''
将指定zip文件解压缩到指定文件夹，并删除源zip压缩文件
:param zipname: 待解压zip压缩文件（需指定绝对路径）
:param dstpath: 指定解压路径（层级结构，默认解压缩路径为OUTPUT_PATH文件目录）
:return dstpath:返回解压缩路径
'''
try:
initname = re.split(r'[\\|/]', zipname)[-1]
dot = os.path.splitext(initname)[1]
if os.path.isfile(zipname) and os.path.exists(zipname):
if dot == r'.zip':
ziphandler = zipfile.ZipFile(zipname, 'r')
for file in ziphandler.namelist():
logger.info('文件"{}"开始unzip解压缩提取.'.format(file))
ziphandler.extractall(dstpath)
logger.info('压缩文件"{0}"已unzip解压缩成功, 解压路径为："{1}".'.format(
initname, dstpath))
ziphandler.close()
os.remove(zipname)
logger.info('压缩文件"{}"已物理删除.'.format(initname))
return dstpath
else:
raise DotTypeError
else:
raise FileNotFoundError
except FileNotFoundError:
logger.exception('文件不存在或其路径非法, 请检查参数路径（其中zip压缩文件需指定绝对路径）.')
except DotTypeError:
logger.exception('非法压缩文件后缀名"{}", 请指定".zip"后缀名的压缩文件名称.'.format(dot))
def send(self, message):
"""
发送钉钉机器人消息提醒
:param message: 消息提醒
:return:
"""
try:
if not isinstance(message, dict):
logger.warning("[WARNING]：参数message必须以字典形式入参，请检查！")
sys.exit(1)
if not message.__contains__('msgtype'):
logger.warning("[WARNING]：消息体message必须包含消息类型msgtype，请检查！")
sys.exit(1)
if message.get('msgtype') not in [
'text', 'link', 'markdown', 'actionCard', 'feedCard'
]:
logger.warning(
'[WARNING]：检测到非法消息类型"{}"，当前仅支持text、link、markdown、actionCard、feedCard，请重新指定！'
.format(message.get('msgtype')))
sys.exit(1)
url = "https://oapi.dingtalk.com/robot/send?access_token={}×tamp={}&sign={}".format(
self.token, self.timestamp, self.get_sign)
headers = {'Content-Type': 'application/json'}
response = requests.request("POST",
url,
headers=headers,
data=json.dumps(message))
result = response.json()
if result.get("errcode") == 0 and result.get("errmsg") == 'ok':
logger.info("[Done]：『{}』钉钉机器人消息提醒成功.".format(self.alias))
else:
logger.warning(
"[WARNING]：『{}』钉钉机器人消息提醒失败，接口响应为【{}】，开始重试...".format(
self.alias, result))
sys.exit(1)
except Exception:
logger.exception("[Exception]：『{}』发送钉钉机器人消息提醒过程中发生异常，请检查！".format(
self.alias))
sys.exit(1)
def check_empty_urlpath(self):
"""
检查Swagger接口文档及接口抓包文档中UrlPath是否全部填充
:return:
"""
try:
if self.swagger_doc_df["UrlPath"].shape[
0] == 0 or self.capture_doc_df["CID"].shape[0] == 0:
logger.warning(
"[WARNING]：Swagger接口文档或接口抓包文档中UrlPath列当前无任何填充数据，请检查并完全填充相关数据！"
)
return False
if self.swagger_doc_df["UrlPath"].shape[
0] != 0 and self.capture_doc_df["CID"].shape[0] != 0:
logger.info(
"[Success]：Swagger接口文档及接口抓包文档中UrlPath列完全填充状态检测通过，二者UrlPath列均已填充完全."
)
return True
except Exception:
logger.exception(
"[Exception]：检测Swagger接口文档及接口抓包文档中UrlPath列是否完全填充过程中发生异常，请检查！")
return False
def send(self, message='FYI', image_flag=False, *filepath):
'''
触发邮件发送
:param message: 邮件文本信息
:param image_flag: 是否发送图片
:param filepath: 邮件附件元组
:return:
'''
self.message = message
self.image_flag = image_flag
for p in filepath:
if os.path.isdir(p):
self.files = list()
for f in os.listdir(p):
self.files.append(os.path.join(p, f))
self.checkAtType(self.files)
elif os.path.isfile(p):
self.files = p
self.checkAtType(self.files)
else:
self.files = p
filename = re.split(r'[\\|/]', str(p))[-1]
logger.warning('注意! 邮件附件"{0}"的路径"{1}"可能无效, 附件无法上传.'.
format(filename, p))
try:
logger.info("开始发送测试结果邮件......")
session = self.createSession()
session.sendmail(self.sender,
self.receiver.split(';'),
self.build_all_msg().as_string() if self.image_flag else self.build_html_msg().as_string()
)
except (gaierror and error):
logger.exception('邮件发送失败! ~ 无法连接到SMTP服务器, 请检查网络以及邮件配置.')
else:
logger.info('[Done]：{0}邮件发送成功! 收件人：{1}.'.format(self.title, self.receiver))
session.quit()
session.close()
def page_frequency(self, es_index, es_dsl):
"""
计算ELK查询分页频次（size:10000条）
:param es_index: ES索引
:param es_dsl: ES查询语句
:return:
"""
es_res = self.dsl_search(es_index, es_dsl)
if es_res:
hits_count_list = jsonpath(es_res.json(), "$.hits.total.value")
if hits_count_list:
hits_count = hits_count_list[0]
if hits_count == 0:
logger.warning("【ELK】DSL查询结果为空，请知悉！")
sys.exit(1)
logger.info("【ELK】DSL查询匹配结果总量为：{}".format(hits_count))
pages = divmod(hits_count, 10000)
total_page = pages[0]
leave_page = pages[1]
if total_page == 0:
logger.info("【ELK】已计算数据采集预期DSL分页频次为：1")
return dict(count=hits_count,
frequency=1,
total_page=1,
leave_page=0)
elif total_page > 0 and leave_page == 0:
logger.info("【ELK】已计算数据采集预期DSL分页频次为：{}".format(total_page))
return dict(count=hits_count,
frequency=total_page,
total_page=total_page,
leave_page=0)
elif total_page > 0 and leave_page > 0:
logger.info("【ELK】已计算数据采集预期DSL分页频次为：{}".format(total_page +
1))
return dict(count=hits_count,
frequency=total_page + 1,
total_page=total_page,
leave_page=1)
else:
logger.warning("【ELK】未成功计算预期DSL分页频次，请检查！")
sys.exit(1)
else:
logger.error("【ELK】查询匹配结果总量获取失败，请检查查询结果或JsonPath表达式是否合法！")
sys.exit(1)
else:
logger.warning("【ELK】由于DSL查询失败，导致结果总量未能获取！")
sys.exit(1)
