def render_html_report(summary,
html_report_name=None,
html_report_template=None,
html_report_dir=None):
""" render html report with specified report name and template
if html_report_name is not specified, use current datetime
if html_report_template is not specified, use default report template
"""
if not html_report_template:
html_report_template = os.path.join(
os.path.abspath(os.path.dirname(__file__)), "templates",
"report_template.html")
logger.log_debug("No html report template specified, use default.")
else:
# logger.log_info("【使用Html报告模板】: {}".format(html_report_template))
pass
logger.log_info("【开始生成Html报告】 ...")
# logger.log_debug("【渲染报告数据】: {}".format(summary))
if html_report_dir:
report_dir_path = html_report_dir
else:
report_dir_path = os.path.join(loader.project_working_directory,
"reports")
start_at_timestamp = int(summary["time"]["start_at"])
summary["time"]["start_datetime"] = datetime.fromtimestamp(
start_at_timestamp).strftime('%Y-%m-%d %H:%M:%S')
if html_report_name:
summary["html_report_name"] = html_report_name
report_dir_path = os.path.join(report_dir_path, html_report_name)
html_report_name += "-{}.html".format(start_at_timestamp)
else:
summary["html_report_name"] = ""
html_report_name = "{}.html".format(start_at_timestamp)
if not os.path.isdir(report_dir_path):
os.makedirs(report_dir_path)
for index, suite_summary in enumerate(summary["details"]):
if not suite_summary.get("name"):
suite_summary["name"] = "test suite {}".format(index)
for record in suite_summary.get("records"):
meta_data = record['meta_data']
stringify_data(meta_data, 'request')
stringify_data(meta_data, 'response')
with io.open(html_report_template, "r", encoding='utf-8') as fp_r:
template_content = fp_r.read()
report_path = os.path.join(report_dir_path, html_report_name)
with io.open(report_path, 'w', encoding='utf-8') as fp_w:
rendered_content = Template(template_content,
extensions=["jinja2.ext.loopcontrols"
]).render(summary)
fp_w.write(rendered_content)
logger.log_info("【已生成Html报告】: {}".format(report_path))
return report_path
def do_setup_hook_actions(self, actions):
for action in actions:
# logger.log_debug("call hook: {}".format(action))
logger.log_info("【执行前置动作】: {}".format(action))
# TODO: check hook function if valid
self.context.eval_content(action, runner=self)
if not self.step_setup_pass:
break
def parse_string_variables(content, variables_mapping, runner=None):
""" parse string content with variables mapping.
Args:
runner:
content (str): string content to be parsed.
variables_mapping (dict): variables mapping.
Returns:
str: parsed string content.
Examples:
>>> content = "/api/users/$uid"
>>> variables_mapping = {"$uid": 1000}
>>> parse_string_variables(content, variables_mapping)
"/api/users/1000"
"""
variables_list = extract_variables(content)
for variable_name in variables_list:
variable_not_found = False
try:
variable_value = get_mapping_variable(variable_name,
variables_mapping)
except (KeyError, exceptions.VariableNotFound) as err:
# logger.log_debug("\n".join([str(err), traceback.format_exc()]))
variable_not_found = True
runner.variable_not_found = True
if variable_not_found:
break
# TODO: replace variable label from $var to {{var}}
if "${}".format(variable_name) == content:
# content is a variable
logger.log_info("【参数替换】: {content} 替换为==> {value}".format(
content=content, value=variable_value))
content = variable_value
else:
# content contains one or several variables
if not isinstance(variable_value, str):
variable_value = builtin_str(variable_value)
logger.log_info("【参数替换】: ${name} 替换为==> {value}".format(
name=variable_name, value=variable_value))
content = content.replace("${}".format(variable_name),
variable_value, 1)
return content
def sql_execute_with_params(sql_list,
param_list,
env_name=None,
db_connect=None):
"""
执行数据库操作，支持携带参数
"""
if len(sql_list) != len(param_list):
raise Exception("sql个数同参数个数不匹配")
if env_name:
try:
obj = EnvInfo.query.filter_by(env_name=env_name).first()
if not obj:
raise Exception("传入的环境不存在")
db_info = obj.db_connect
# db_info = db_connects[env][db_type]
except Exception as err:
raise Exception(err)
elif db_connect:
db_info = db_connect
engine = create_engine(db_info, echo=False, poolclass=NullPool)
return_info = None
with engine.connect() as conn:
try:
for s, p in zip(sql_list, param_list):
if 'insert' not in s.lower() and 'where' not in s.lower():
raise Exception('更新和删除操作不符合安全规范，必须要带上where条件')
if s.lower().strip().startswith('select'):
return_info = conn.execute(text(s), p).fetchall()
hr_logger.log_info("【执行SQL】: {0} 返回数据: {1}".format(
s.replace('\n', ''), return_info))
else:
return_info = conn.execute(text(s), p).rowcount
# logger.info("受影响的行: {0}".format(return_info))
hr_logger.log_info("【执行SQL】: {0} 受影响的行: {1}".format(
s.replace('\n', ''), return_info))
except exc.SQLAlchemyError as err:
hr_logger.log_error("数据库操作失败, {0}".format(err))
raise err
finally:
conn.close()
return return_info
def sql_execute(sql, env_name=None, db_connect=None):
"""
"""
# env = env.upper()
if env_name:
try:
obj = EnvInfo.query.filter_by(env_name=env_name).first()
if not obj:
raise Exception("传入的环境不存在")
db_info = obj.db_connect
# db_info = db_connects[env][db_type]
except Exception as err:
raise Exception(err)
elif db_connect:
db_info = db_connect
engine = create_engine(db_info, echo=False, poolclass=NullPool)
return_info = None
with engine.connect() as conn:
try:
sql = sql.replace('%', '%%')
if re.match('select', sql.lower().strip()):
return_info = conn.execute(sql).fetchall()
elif re.match('exec', sql.lower().strip()):
sql_new = DDL(sql)
conn.execute(sql_new)
else:
for s in str(sql).strip().strip(';').split(';'):
if 'insert' not in s.lower() and 'where' not in s.lower():
raise Exception('更新和删除操作不符合安全规范，必须要带上where条件')
return_info = conn.execute(s).rowcount
# logger.info("受影响的行: {0}".format(return_info))
hr_logger.log_info("【执行SQL】: {0} 受影响的行: {1}".format(
s.replace('\n', ''), return_info))
except exc.SQLAlchemyError as err:
hr_logger.log_error("数据库操作失败, {0}".format(err))
raise err
# hr_logger.log_error(err.args[0])
finally:
conn.close()
return return_info
def extract_field(self, field, key=None, context_obj=None):
""" extract value from requests.Response.
"""
if not isinstance(field, basestring):
err_msg = u"Invalid extractor! => {}\n".format(field)
logger.log_error(err_msg)
raise exceptions.ParamsError(err_msg)
# msg = "extract: {}".format(field)
if key:
msg = "【提取变量】: {}".format(field)
else:
msg = "【提取】: {}".format(field)
sub_str_exp = None
original_value = None
# if text_extractor_regexp_compile.match(field):
# value = self._extract_field_with_regex(field)
# else:
# original_value, sub_str_exp = self._extract_field_with_delimiter(field, context_obj=context_obj)
try:
original_value, sub_str_exp = self._extract_field_with_delimiter(
field, context_obj=context_obj)
except Exception as err:
raise exceptions.ExtractFailure(err)
if sub_str_exp:
value = eval('original_value' + sub_str_exp)
else:
value = original_value
if is_py2 and isinstance(value, unicode):
value = value.encode("utf-8")
if key:
if sub_str_exp:
msg += " ==> {0} ==> {1} 保存为变量 {2}".format(
original_value + sub_str_exp, value, key)
else:
msg += " ==> {0} 保存为变量 {1}".format(value, key)
else:
msg += " ==> {0}".format(value)
logger.log_info(msg)
return value
def db_operation_to_json_cycle(sql, db_connect, expect_value, wait_time=30):
"""数据库json校验 轮询"""
step_time = 5
t = 0
return_value = None
dict_expect = transfer_json_string_to_dict(expect_value)
# 如果期望值非json格式，直接报错
if not isinstance(dict_expect, dict):
raise Exception('结果校验中期望结果非json格式，期望结果内容为{0}({1})'.format(
dict_expect,
type(dict_expect).__name__))
dict_expect_lower_key = {
key.lower(): dict_expect[key]
for key in dict_expect
}
while t <= wait_time:
try:
return_value = db_operation_to_json(sql, db_connect)
dict_check = transfer_json_string_to_dict(return_value)
dict_check_lower_key = {
key.lower(): dict_check[key]
for key in dict_check
}
if not dict_check_lower_key:
hr_logger.log_info("【轮询SQL】: {0} 表中无数据，等待5秒后重试".format(
sql.replace('\n', '')))
else:
res = is_json_contains(dict_check_lower_key,
dict_expect_lower_key)
if res is True:
hr_logger.log_info('【轮询SQL】: {0} 结果为 {1}'.format(
sql.replace('\n', ''), dict_check))
return return_value
else:
hr_logger.log_info('【轮询SQL】: {0} 结果为 {1}，等待5秒后重试'.format(
sql.replace('\n', ''), dict_check))
time.sleep(step_time)
t += step_time
except Exception as err:
logger.error(traceback.format_exc())
raise Exception("【轮询SQL】: 数据库操作失败, {0}".format(err))
hr_logger.log_info('【轮询SQL】: 超过{0}秒表中仍无预期数据'.format(wait_time))
return return_value
def load_dot_env_file():
""" load .env file, .env file should be located in project working directory.
Returns:
dict: environment variables mapping
{
"UserName": "******",
"Password": "******",
"PROJECT_KEY": "ABCDEFGH"
}
Raises:
exceptions.FileFormatError: If env file format is invalid.
"""
path = os.path.join(project_working_directory, ".env")
if not os.path.isfile(path):
# logger.log_debug(".env file not exist in : {}".format(project_working_directory))
# logger.log_debug(" 未使用.env文件".format())
return {}
logger.log_info("Loading environment variables from {}".format(path))
env_variables_mapping = {}
with io.open(path, 'r', encoding='utf-8') as fp:
for line in fp:
if "=" in line:
variable, value = line.split("=")
elif ":" in line:
variable, value = line.split(":")
else:
raise exceptions.FileFormatError(".env format error")
env_variables_mapping[variable.strip()] = value.strip()
project_mapping["env"] = env_variables_mapping
utils.set_os_environ(env_variables_mapping)
return env_variables_mapping
def mq_validate(check_value, expect_value):
""" mq-消息内容包含校验 : topic+tag+system_name, 预期结果
:desc: 说明: 根据topic+tag+system_name查询消息，同预期结果匹配
:param check_value:待校验内容: 需要查询的消息topic和tag，以json格式，如{"topic": "TP_MIME_UNION_FINANCE", "tag": "TAG_capital-mgmt-core_createCashLoan", "system_name": "user-core"}，支持使用变量
:param expect_value:期望值: 例如 "abc" 或 {"a": 123, "b": "xxx"}，支持使用变量
:return:
"""
# 返回ture和flase,关联测试报告success和fail
if not check_value:
return False, '根据topic和tag获取不到最近10分钟的MQ消息'
# hr_logger.log_info(str(len(check_value)))
for index, item in enumerate(check_value):
hr_logger.log_info('消息({0})内容：{1}'.format(str(index+1), item))
try:
dict_check = json.loads(item)
# hr_logger.log_info(type(dict_check).__name__)
if not isinstance(expect_value, dict):
return False, '预期结果和实际结果类型不一致，预期结果是"{0}"，期望结果是"{1}"'.format(type(dict_check).__name__, type(expect_value).__name__)
is_ok = is_json_contains(dict_check, expect_value)
# hr_logger.log_info(type(is_ok).__name__)
if is_ok is True:
return True
else:
continue
except Exception as err:
hr_logger.log_error(traceback.format_exc())
dict_check = item
if dict_check == expect_value:
return True
elif str(dict_check) == str(expect_value):
return True
else:
continue
return False, '找不到同预期结果匹配的MQ消息'
def handle_teardown(self, fail_type):
logger.log_warning("因【{}】错误, 中断测试".format(fail_type))
if not self.step_teardown_executed:
teardown_hooks = self.teststep_dict.get("teardown_hooks", [])
self.step_teardown_executed = True
if teardown_hooks:
logger.log_info("-" * 12 + "【用例后置-开始】" + "-" * 12)
self.do_teardown_hook_actions(teardown_hooks)
logger.log_info("-" * 12 + "【用例后置-结束】" + "-" * 12)
if self.testcase_teardown_hooks and not self.testcase_teardown_hooks_executed:
logger.log_info("-" * 12 + "【全局后置-开始】" + "-" * 12)
self.testcase_teardown_hooks_executed = True
self.do_teardown_hook_actions(self.testcase_teardown_hooks)
logger.log_info("-" * 12 + "【全局后置-结束】" + "-" * 12)
def run(self, path_or_testcases, mapping=None):
""" start to run test with variables mapping.
Args:
path_or_testcases (str/list/dict): YAML/JSON testcase file path or testcase list
path: path could be in several type
- absolute/relative file path
- absolute/relative folder path
- list/set container with file(s) and/or folder(s)
testcases: testcase dict or list of testcases
- (dict) testset_dict
- (list) list of testset_dict
[
testset_dict_1,
testset_dict_2
]
mapping (dict): if mapping specified, it will override variables in config block.
Returns:
instance: HttpRunner() instance
"""
# loader
testcases_list = self.load_tests(path_or_testcases)
# parser
parsed_testcases_list = self.parse_tests(testcases_list)
# initialize
unittest_runner, test_suite = self.__initialize(parsed_testcases_list)
# aggregate
self.summary = {
"success": True,
"stat": {},
"time": {},
"platform": report.get_platform(),
"details": []
}
# execution
for testcase in test_suite:
testcase_name = testcase.config.get("name")
testcase_id = testcase.config.get("case_id")
chain_list = testcase.config.get("chain_list")
is_main = testcase.config.get("is_main")
logger.log_info("【准备运行测试用例】:")
logger.log_info("【用例ID】: {}".format(testcase_id))
logger.log_info("【用例名称】: {}".format(testcase_name))
if len(chain_list) > 1:
if is_main:
chain = ' -> '.join(str(i) for i in chain_list)
logger.log_info("【根据全链路用例组成调用链(ID)】: {}".format(chain))
else:
chain = ' -> '.join(str(i) for i in chain_list)
logger.log_info("【存在前置用例】")
logger.log_info("【根据前置用例组成调用链(ID)】: {}".format(chain))
result = unittest_runner.run(testcase)
testcase_summary = report.get_summary(result)
# summary增加case_id信息
testcase_summary["is_main"] = is_main
testcase_summary["case_id"] = testcase_id
testcase_summary["chain_list"] = chain_list
self.summary["success"] &= testcase_summary["success"]
testcase_summary["name"] = testcase_name
testcase_summary["base_url"] = testcase.config.get("request", {}).get("base_url", "")
# in_out = utils.get_testcase_io(testcase)
# utils.print_io(in_out)
testcase_summary["in_out"] = {"in": {}, "out": {}}
report.aggregate_stat(self.summary["stat"], testcase_summary["stat"])
report.aggregate_stat(self.summary["time"], testcase_summary["time"])
self.summary["details"].append(testcase_summary)
return self
def parse_string_functions(content,
variables_mapping,
functions_mapping,
runner=None):
""" parse string content with functions mapping.
Args:
content (str): string content to be parsed.
variables_mapping (dict): variables mapping.
functions_mapping (dict): functions mapping.
runner (object)
Returns:
str: parsed string content.
Examples:
>>> content = "abc${add_one(3)}def"
>>> functions_mapping = {"add_one": lambda x: x + 1}
>>> parse_string_functions(content, functions_mapping)
"abc4def"
"""
functions_list = extract_functions(content)
for func_content in functions_list:
# logger.log_debug("【执行函数】: {}".format(func_content))
function_meta = parse_function(func_content)
func_name = function_meta["func_name"]
logger.log_info("【识别函数】: {}".format(func_name))
args = function_meta.get("args", [])
kwargs = function_meta.get("kwargs", {})
args = parse_data(args, variables_mapping, functions_mapping)
logger.log_info("【函数{0}参数列表】: {1}".format(func_name, args))
kwargs = parse_data(kwargs, variables_mapping, functions_mapping)
if func_name in ["parameterize", "P"]:
from httprunner import loader
eval_value = loader.load_csv_file(*args, **kwargs)
else:
func = get_mapping_function(func_name, functions_mapping)
try:
eval_value = func(*args, **kwargs)
if eval_value is False:
logger.log_error("【函数{0}异常返回】: {1}".format(
func_name, eval_value))
else:
logger.log_info("【函数{0}返回】: {1}".format(
func_name, eval_value))
except Exception as err:
logger.log_error("【函数{0}异常返回】: {1}".format(
func_name, err.args[0]))
eval_value = '自定义方法调用失败'
if eval_value is False or eval_value == '自定义方法调用失败':
if runner.running_hook == 'step_setup':
runner.step_setup_pass = False
elif runner.running_hook == 'step_teardown':
runner.step_teardown_pass = False
elif runner.running_hook == 'step_request_teardown':
runner.step_request_teardown_pass = False
elif runner.running_hook == 'step_parse_variable':
runner.step_parse_variable_pass = False
func_content = "${" + func_content + "}"
if func_content == content:
# content is a function, e.g. "${add_one(3)}"
content = eval_value
else:
# content contains one or many functions, e.g. "abc${add_one(3)}def"
content = content.replace(func_content, str(eval_value), 1)
return content
def http_runner_run(**kwargs):
"""调用HttpRunner运行测试"""
log_dir = kwargs.pop('log_dir')
env_id = kwargs.pop('env_id')
testset = kwargs.pop('testset')
test_meta_list = kwargs.pop('test_meta_list')
run_task_result_id = kwargs.pop('run_task_result_id')
intf_id = kwargs.pop('intf_id', None)
main_case_id = kwargs.pop('main_case_id', None)
main_case_id_list = kwargs.pop('main_case_id_list', None)
if intf_id:
log_path = '{0}task_run_{1}_intf_{2}.log'.format(log_dir, run_task_result_id, intf_id)
elif main_case_id:
log_path = '{0}task_run_{1}_main_case_{2}.log'.format(log_dir, run_task_result_id, main_case_id)
else:
log_path = '{0}task_run_{1}_main_case_list_{2}.log'.format(log_dir, run_task_result_id, main_case_id_list)
# 初始化hr_runner
hr_kwargs = {
"failfast": True,
"log_path": log_path
}
hr_runner = HttpRunner(**hr_kwargs)
start_time = time.strftime('%Y-%m-%d %H-%M-%S', time.localtime(time.time()))
hr_logger.log_warning("【START】测试开始! (ง •_•)ง")
hr_logger.log_warning("【环境】: {}".format(env_id))
# time.sleep(3)
try:
testset_json = json_dumps(testset)
except Exception:
testset_json = testset
# 执行测试
try:
# hr_logger.log_warning("【调用HttpRunner】: {0}".format(testset_json))
hr_runner.run(testset)
hr_logger.log_info("【结束调用HttpRunner】")
except Exception:
raise Exception(traceback.format_exc())
for detail in hr_runner.summary["details"]:
for record in detail["records"]:
record["meta_data"]["request"].pop("files", None)
# 去除summary中的文件对象
summary_remove_file_obj(hr_runner.summary)
# 完善summary
summary = deepcopy(hr_runner.summary)
# summary = hr_runner.summary
perfect_summary(summary, test_meta_list)
# print(json_dumps(summary))
summary = add_memo(summary)
# 识别错误
# print(json_dumps(summary))
summary = identify_errors(summary)
return {"summary": json_loads(json_dumps(summary)), "run_task_result_id": run_task_result_id, 'log_dir': log_dir}
def sql_execute_cycle(sql, db_connect, expect_value, wait_time=30):
"""
定时执行某条查询sql，用于特定场景，如检查贷款表中贷款数据是否生成，默认每5秒检查一次，1分钟超时退出 \n
:param expect_value:
:param db_connect:
:param sql: 待执行的查询sql \n
:param wait_time: 超时时长，超过该时间自动退出 ，默认60秒 \n
:return: 返回查询结果 \n
"""
expect_is_json = False
step_time = 5
t = 0
return_value = None
dict_expect = transfer_json_string_to_dict(expect_value)
if isinstance(dict_expect, dict):
expect_is_json = True
while t <= wait_time:
try:
return_info = sql_execute(sql, db_connect=db_connect)
if expect_is_json:
return_value = return_info[0][0] if return_info else None
dict_check = transfer_json_string_to_dict(return_value)
# dict_check_lower_key = {key.lower(): dict_check[key] for key in dict_check}
if not dict_check:
hr_logger.log_info("【轮询SQL】: {0} 表中无数据，等待5秒后重试".format(
sql.replace('\n', '')))
else:
res = is_json_contains(dict_check, dict_expect)
if res is True:
hr_logger.log_info('【轮询SQL】: {0} 结果为 {1}'.format(
sql.replace('\n', ''), dict_check))
return return_value
else:
hr_logger.log_info(
'【轮询SQL】: {0} 结果为 {1}，{2}，等待5秒后重试'.format(
sql.replace('\n', ''), dict_check, res[1]))
else:
if not return_info:
hr_logger.log_info("【轮询SQL】: {0} 表中无数据，等待5秒后重试".format(
sql.replace('\n', '')))
else:
return_value = str(return_info[0][0])
if return_value == str(expect_value):
hr_logger.log_info('【轮询SQL】: {0} 结果为 {1}'.format(
sql.replace('\n', ''), return_value))
return return_info[0][0]
else:
hr_logger.log_info(
'【轮询SQL】: {0} 结果为 {1}，等待5秒后重试'.format(
sql.replace('\n', ''), return_value))
time.sleep(step_time)
t += step_time
except Exception as err:
logger.error(traceback.format_exc())
raise Exception("【轮询SQL】: 数据库操作失败, {0}".format(err))
hr_logger.log_info('【轮询SQL】: 超过{0}秒表中仍无预期数据'.format(wait_time))
return return_value
def do_request_teardown_hook_actions(self, actions):
for action in actions:
# logger.log_debug("call hook: {}".format(action))
logger.log_info("【执行请求后置动作】: {}".format(action))
# TODO: check hook function if valid
self.context.eval_content(action, runner=self)
def run_test(self, teststep_dict):
""" run single teststep.
Args:
teststep_dict (dict): teststep info
{
"name": "teststep description",
"skip": "skip this test unconditionally",
"times": 3,
"variables": [], # optional, override
"request": {
"url": "http://127.0.0.1:5000/api/users/1000",
"method": "POST",
"headers": {
"Content-Type": "application/json",
"authorization": "$authorization",
"random": "$random"
},
"body": '{"name": "user", "password": "******"}'
},
"extract": [], # optional
"validate": [], # optional
"setup_hooks": [], # optional
"teardown_hooks": [] # optional
}
Raises:
exceptions.ParamsError
exceptions.ValidationFailure
exceptions.ExtractFailure
"""
self.teststep_dict = teststep_dict
is_last = teststep_dict.get("is_last", None)
case_name = teststep_dict.get("name", None)
case_id = teststep_dict.get("case_id", None)
logger.log_info("【开始执行用例】: ID_{0}, {1}".format(case_id, case_name))
self.step_teardown_executed = False
# check skip
self._handle_skip_feature(teststep_dict)
# prepare
logger.log_info("-" * 12 + "【变量替换-开始】" + "-" * 12)
extractors = teststep_dict.get("extract", []) or teststep_dict.get(
"extractors", [])
validators = teststep_dict.get("validate", []) or teststep_dict.get(
"validators", [])
self.step_parse_variable_pass = True
self.running_hook = 'step_parse_variable'
parsed_request = self.init_config(teststep_dict, level="teststep")
self.context.update_teststep_variables_mapping("request",
parsed_request)
logger.log_info("-" * 12 + "【变量替换-结束】" + "-" * 12)
if self.variable_not_found:
self.handle_teardown(fail_type='变量替换')
raise exceptions.VariableNotFound
if not self.step_parse_variable_pass:
self.handle_teardown(fail_type='变量替换')
raise exceptions.CustomFuncRunError
# setup hooks
setup_hooks = teststep_dict.get("setup_hooks", [])
setup_hooks.insert(0, "${setup_hook_prepare_kwargs($request)}")
logger.log_info("-" * 12 + "【请求前置-开始】" + "-" * 12)
self.step_setup_pass = True
self.running_hook = 'step_setup'
self.do_setup_hook_actions(setup_hooks)
logger.log_info("-" * 12 + "【请求前置-结束】" + "-" * 12)
if not self.step_setup_pass:
self.handle_teardown(fail_type='前置动作')
raise exceptions.SetupHooksFailure
try:
url = parsed_request.pop('url')
method = parsed_request.pop('method')
group_name = parsed_request.pop("group", None)
except KeyError:
raise exceptions.ParamsError("URL or METHOD missed!")
# TODO: move method validation to json schema
valid_methods = [
"GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"
]
if method.upper() not in valid_methods:
err_msg = u"Invalid HTTP method! => {}\n".format(method)
err_msg += "Available HTTP methods: {}".format(
"/".join(valid_methods))
logger.log_error(err_msg)
self.handle_teardown(fail_type='校验发送方式')
raise exceptions.ParamsError(err_msg)
# logger.log_info("{method} {url}".format(method=method, url=url))
# logger.log_debug("request kwargs(raw): {kwargs}".format(kwargs=parsed_request))
# request
try:
resp = self.http_client_session.request(method,
url,
name=group_name,
**parsed_request)
except Exception as e:
self.handle_teardown(fail_type='接口请求')
raise exceptions.RequestFailure
resp_obj = response.ResponseObject(resp)
# # teardown hooks
# teardown_hooks = teststep_dict.get("teardown_hooks", [])
# if teardown_hooks:
# # logger.log_info("start to run teardown hooks")
# logger.log_info("【开始后置动作】...")
# self.context.update_teststep_variables_mapping("response", resp_obj)
# self.do_hook_actions(teardown_hooks)
# logger.log_info("【结束后置动作】")
# request teardown hooks 新增请求后置
request_teardown_hooks = teststep_dict.get("request_teardown_hooks",
[])
if request_teardown_hooks:
# logger.log_info("start to run teardown hooks")
logger.log_info("-" * 12 + "【请求后置-开始】" + "-" * 12)
self.step_request_teardown_pass = True
self.running_hook = 'step_request_teardown'
self.context.update_teststep_variables_mapping(
"response", resp_obj)
self.do_request_teardown_hook_actions(request_teardown_hooks)
logger.log_info("-" * 12 + "【请求后置-结束】" + "-" * 12)
if not self.step_request_teardown_pass:
self.handle_teardown(fail_type='请求后置动作')
raise exceptions.TeardownHooksFailure
# extract
logger.log_info("-" * 12 + "【提取变量-开始】" + "-" * 12)
try:
extracted_variables_mapping = resp_obj.extract_response(
extractors, self.context)
self.context.update_testcase_runtime_variables_mapping(
extracted_variables_mapping)
except Exception as err:
logger.log_error('提取变量失败：{0}'.format(err.args[0]))
self.handle_teardown(fail_type='提取变量')
raise exceptions.ExtractFailure
logger.log_info("-" * 12 + "【提取变量-结束】" + "-" * 12)
# validate
try:
logger.log_info("-" * 12 + "【结果校验-开始】" + "-" * 12)
self.evaluated_validators, validate_pass = self.context.validate(
validators, resp_obj)
logger.log_info("-" * 12 + "【结果校验-结束】" + "-" * 12)
if not validate_pass:
# self.handle_teardown(fail_type='结果校验')
raise exceptions.ValidationFailure
except (exceptions.ParamsError, exceptions.ValidationFailure,
exceptions.ExtractFailure, exceptions.VariableNotFound) as err:
# log request
# err_req_msg = "request: \n"
# err_req_msg += "headers: {}\n".format(parsed_request.pop("headers", {}))
# for k, v in parsed_request.items():
# err_req_msg += "{}: {}\n".format(k, repr(v))
# logger.log_error(err_req_msg)
#
# # log response
# err_resp_msg = "response: \n"
# err_resp_msg += "status_code: {}\n".format(resp_obj.status_code)
# err_resp_msg += "headers: {}\n".format(resp_obj.headers)
# err_resp_msg += "body: {}\n".format(repr(resp_obj.text))
# logger.log_error(err_resp_msg)
logger.log_error('结果校验失败')
self.handle_teardown(fail_type='结果校验')
raise exceptions.ValidationFailure
# teardown hooks
teardown_hooks = teststep_dict.get("teardown_hooks", [])
self.step_teardown_executed = True
if teardown_hooks:
# logger.log_info("start to run teardown hooks")
logger.log_info("-" * 12 + "【用例后置-开始】" + "-" * 12)
self.step_teardown_pass = True
self.running_hook = 'step_teardown'
self.context.update_teststep_variables_mapping(
"response", resp_obj)
self.do_teardown_hook_actions(teardown_hooks)
logger.log_info("-" * 12 + "【用例后置-结束】" + "-" * 12)
if not self.step_teardown_pass:
self.handle_teardown(fail_type='后置动作')
raise exceptions.TeardownHooksFailure
# total teardown hooks
if is_last:
if self.testcase_teardown_hooks and not self.testcase_teardown_hooks_executed:
logger.log_info("-" * 12 + "【全局后置-开始】" + "-" * 12)
self.testcase_teardown_hooks_executed = True
self.do_teardown_hook_actions(self.testcase_teardown_hooks)
logger.log_info("-" * 12 + "【全局后置-结束】" + "-" * 12)
logger.log_info("【结束执行用例】: ID_{0}, {1}".format(case_id, case_name))
def _do_validation(self, validator_dict):
""" validate with functions
Args:
validator_dict (dict): validator dict
{
"check": "status_code",
"check_value": 200,
"expect": 201,
"comparator": "eq"
}
"""
# TODO: move comparator uniform to init_test_suites
comparator = utils.get_uniform_comparator(validator_dict["comparator"])
validate_func = self.TESTCASE_SHARED_FUNCTIONS_MAPPING.get(comparator)
if not validate_func:
raise exceptions.FunctionNotFound(
"comparator not found: {}".format(comparator))
check_item = validator_dict["check"]
check_value = validator_dict["check_value"]
expect_value = validator_dict["expect"]
if (check_value is None or expect_value is None) \
and comparator not in [
"is", "eq", "equals", "==", "json_contains", "json_same", "field_special_check", "db_validate",
"db_validate_cycle", "field_check_empty_list", "field_check_not_empty_list",
"field_check_not_in_list", "field_check_empty_json", "field_check_not_empty_json", "redis_validate", "mq_validate"]:
raise exceptions.ParamsError(
"Null value can only be compared with comparator: eq/equals/=="
)
# validate_msg = "validate: {} {} {}({})".format(
validate_msg = "【验证点】: 校验方法：{}, 待校验内容：{}, 期望结果：{}({})".format(
comparator, check_item, expect_value,
type(expect_value).__name__)
try:
validator_dict["check_result"] = "pass"
is_ok = validate_func(check_value, expect_value)
if is_ok is True:
validate_msg += "\t ....................PASS"
logger.log_info(validate_msg)
else:
validate_msg += "\t ....................FAIL"
if is_ok is not False:
validate_msg += "......原因: {}".format(is_ok[1])
logger.log_error(validate_msg)
validator_dict["check_result"] = "fail"
raise exceptions.ValidationFailure(validate_msg)
except (AssertionError, TypeError) as err:
validate_msg += "\t ....................FAIL"
validate_msg += "\t{}({}), {}, {}({})".format(
check_value,
type(check_value).__name__, comparator, expect_value,
type(expect_value).__name__)
validate_msg += "\t......原因: {}".format(err.args[0])
logger.log_error(validate_msg)
validator_dict["check_result"] = "fail"
raise exceptions.ValidationFailure(validate_msg)
def api_run_test(**kwargs):
report_id = kwargs.pop('report_id', None)
plan_name = kwargs.pop('plan_name', None)
project_id = kwargs.pop('project_id', None)
testcase_main_id_list = kwargs.get('testcase_main_id_list', None)
failfast = kwargs.pop('failfast', False)
if testcase_main_id_list:
is_main = True
else:
is_main = False
try:
logger.debug(
'=============================={dir}run_{report_id}.log'.format(
dir=run_case_log_dir, report_id=report_id))
hr_kwargs = {
"failfast":
failfast,
"log_path":
'{dir}run_{report_id}.log'.format(dir=run_case_log_dir,
report_id=report_id)
}
runner = HttpRunner(**hr_kwargs)
# res = load_test(**kwargs)
# testset = res[0]
# test_meta_list = res[1]
# project_id = res[2]
loader = ApiTestLoader(**kwargs)
testset = loader.get_testset_list()
test_meta_list = loader.get_test_meta_list()
if not testset:
raise LoadCaseError('没有可执行的用例')
logger.debug("{1} testset:{0}".format(testset, type(testset)))
except Exception as err:
save_report(report_path=None,
runner_summary=None,
project_id=project_id,
report_id=report_id)
hr_logger.log_error("【ERROR】组装用例出错！")
hr_logger.log_error('\n'.join([str(err), traceback.format_exc()]))
hr_logger.log_info("【END】测试结束！")
hr_logger.remove_handler(runner.handler)
raise LoadCaseError
try:
# summary = run(testset, report_name='testMock')
start_time = time.strftime('%Y-%m-%d %H-%M-%S',
time.localtime(time.time()))
hr_logger.log_info("【START】测试开始! (ง •_•)ง")
hr_logger.log_info("【环境】: {}".format(kwargs.get('env_name', None)))
# time.sleep(3)
try:
testset_json = json_dumps(testset)
except Exception:
testset_json = testset
hr_logger.log_debug("【调用HttpRunner】: {0}".format(testset_json))
runner.run(testset)
hr_logger.log_info("【结束调用HttpRunner】")
# raise RunCaseError
perfect_summary(runner.summary, test_meta_list)
"""记录用例复用记录"""
summary_remove_file_obj(runner.summary)
summary_for_reuse = copy.deepcopy(runner.summary)
summary_for_reuse = add_memo(summary_for_reuse)
# 识别错误
summary_for_reuse = identify_errors(summary_for_reuse)
# 更新api_testcase_reuse_record表, 并获取covered_intf_id_set, run_cases, success_cases
save_testcase_reuse_record([{
"summary":
json_loads(json_dumps(summary_for_reuse))
}])
del summary_for_reuse
# hr_logger.log_info("【runner.summary】: {}".format(runner.summary))
'''报告优化:1、汉化(包括日志里面的字段)
2、开始时间和持续时间合并成一行
3、增加一个字段“错误类型”，如果用例错误，显示该字段，并说明期望与预期值；
否则该字段不显示
4.log里面去掉一些数据重复和不重要的；行和字段（请求headers，返回体的headers,reason，url，“”ok”）
5.将请求体和返回值数据缩进，且字典里面的key颜色加粗
6.新增接口请求类型字段，http、dubbo、mq'''
for detail in runner.summary["details"]:
for record in detail["records"]:
'''增加用例类型:test_meta_list["intf_type"]'''
record["intf_type"] = test_meta_list[0]["intf_type"]
'''删除报告一些无需关注的字段'''
request_keys = ["json", "start_timestamp"]
response_keys = [
"elapsed_ms", "encoding", 'ok', 'url', 'reason', 'cookies'
]
for request_key in request_keys:
if request_key in record["meta_data"]["request"]:
del record["meta_data"]["request"][request_key]
for respones_key in response_keys:
if respones_key in record["meta_data"]["response"]:
del record["meta_data"]["response"][respones_key]
'''record.status出现error, 抛出错误信息'''
if record['status'] == 'error':
error_msg = record['attachment']
raise Exception(error_msg)
# '''将body和content字节类型转换dic'''
# if "body" in record["meta_data"]["request"].keys() and "content" in record["meta_data"]["response"].keys():
# request_body = record["meta_data"]["request"].pop("body")
# response_content = record["meta_data"]["response"].pop("content")
# if not request_body:
# request_body_dic = {}
# else:
# try:
# request_body_dic = json.loads(request_body)
# except TypeError:
# request_body_dic = json.loads(request_body.decode('utf-8'))
# # 增加捕获异常
# except UnicodeDecodeError:
# if isinstance(request_body, bytes):
# request_body_dic = {}
# # request_body_dic = request_body.decode('utf-8', 'ignore')
# else:
# request_body_dic = {}
#
# if not response_content:
# response_content_dic = {}
# else:
# try:
# response_content_dic = json.loads(response_content)
# except TypeError:
# response_content_dic = json.loads(response_content.decode('utf-8'))
# except json.decoder.JSONDecodeError:
# response_content_dic = {}
#
# record["meta_data"]["request"]["body"] = request_body_dic
# record["meta_data"]["response"]["content"] = response_content_dic
#
# '''将files去除,避免报告超长影响展示效果'''
# if "files" in record["meta_data"]["request"].keys():
# record["meta_data"]["request"].pop("files")
'''报告增加一列：错误类型:'''
for validate in record["meta_data"]["validators"]:
if validate["comparator"] == "json_contains":
check_value = validate["check_value"]
expect_value = validate["expect"]
if json_contains(check_value,
expect_value) is not True:
validate["check_result"] = "fail"
record["status"] = "failure"
detail["stat"]["failures"] += 1
detail["stat"]["successes"] -= 1
runner.summary["stat"]["failures"] += 1
runner.summary["stat"]["successes"] -= 1
error_log = ("预期:{}未在返回报文内".format(expect_value))
validate["error_log"] = {
"json_contains": error_log
}
elif validate["comparator"] == "db_validate":
check_value = validate["check_value"]
expect_value = validate["expect"]
if db_validate(check_value, expect_value) is not True:
validate["check_result"] = "fail"
record["status"] = "failure"
detail["stat"]["failures"] += 1
detail["stat"]["successes"] -= 1
runner.summary["stat"]["failures"] += 1
runner.summary["stat"]["successes"] -= 1
error_log = ("预期:{0},实际是：{1}".format(
expect_value, check_value))
validate["error_log"] = {"db_validate": error_log}
elif validate["comparator"] == "db_json_validate":
check_value = validate["check_value"]
expect_value = validate["expect"]
if not db_json_validate(check_value, expect_value):
validate["check_result"] = "fail"
record["status"] = "failure"
detail["stat"]["failures"] += 1
detail["stat"]["successes"] -= 1
runner.summary["stat"]["failures"] += 1
runner.summary["stat"]["successes"] -= 1
error_log = ("预期:{0},实际是：{1}".format(
expect_value,
json.dumps(check_value).encode('utf-8').decode(
'unicode_escape')))
validate["error_log"] = {
"db_json_validate": error_log
}
hr_logger.log_info("【runner.summary】: {}".format(
json_dumps(runner.summary)))
runner_summary = copy.deepcopy(runner.summary)
"""把每条用例执行成功与否记录到testcase_info.last_run"""
try:
save_last_run(runner_summary, is_main=is_main)
except Exception as e:
logger.error('\n'.join([str(e), traceback.format_exc()]))
# hr_logger.log_error("【ERROR】运行用例出错！")
# hr_logger.log_error('\n'.join([str(e), traceback.format_exc()]))
# logger.debug("runner_summary_list{}".format(runner.summary))
# report_path = runner.gen_html_report(
# html_report_name=plan_name if plan_name else 'default',
# html_report_template=config.REPORT_TEMPLATE_PATH,
# html_report_dir=config.REPORT_DIR
# )
# logger.debug('report_path:{}'.format(report_path))
# report_path = report_path.split('reports')[1]
# report_url = get_host() + r':8899/reports' + report_path
#
# logger.debug('AC report_path:{}'.format(report_path))
report_url = '不生成报告'
save_report(report_url,
runner_summary,
project_id,
report_id=report_id,
is_main=is_main)
except Exception as err:
save_report(report_path=None,
runner_summary=runner.summary,
project_id=project_id,
report_id=report_id)
hr_logger.log_error("【ERROR】运行用例出错！")
hr_logger.log_error('\n'.join([str(err), traceback.format_exc()]))
raise RunCaseError
finally:
hr_logger.log_info("【END】测试结束！")
hr_logger.remove_handler(runner.handler)
return report_url
def get_access_token(phone, base_host, redis_connect, db_connect):
""" 登录-手机号动码登录获取accessToken : 手机号
:desc: 说明: 指定手机号，依次调用获取验证码和动码登录接口，返回accessToken
:param phone:手机号: 例如 18555555555
:return:
"""
# 根据手机号获取memberid
# 根据memberid获取token
try:
_redis_connect = json.loads(redis_connect)
except Exception as err:
raise Exception('环境信息中redis连接配置错误')
redis_host = _redis_connect['host']
redis_port = _redis_connect['port']
redis_password = _redis_connect['password']
get_member_id_sql = "" % phone
ret = sql_execute(get_member_id_sql, db_connect=db_connect)
if ret and ret[0][0]:
member_id = ret[0][0]
with RedisUtils(redis_host, redis_port, redis_password, 2) as r:
user_info = r.get_str_value('user_token_%s' % (str(member_id)))
if isinstance(user_info, dict):
return user_info['accessToken']
hr_logger.log_info('【执行函数{0}】Redis中获取不到手机号【{1}】的accessToken数据，将调用动码登录接口获取'
.format(inspect.stack()[0][3], phone))
current_timestamp = int((time.time() * 1000))
heard_info = {'Content-Type': 'application/json;charset=utf-8'}
send_code_url = base_host + '/user/v2/common/sendMobileCode'
send_code_input = {
"appld": "6916984",
"phone": str(phone),
"sourceFlag": "1",
"timestamp": current_timestamp,
}
# 加签
send_code_input = get_sign_common(send_code_input)
# 获取验证码
hc = HttpClient()
try:
response = hc.http_post(send_code_url, heard_info, send_code_input)
except Exception as err:
raise err
res_dic = json.loads(response.text)
hr_logger.log_info('【执行函数{0}】获取验证码接口返回内容{1}'.format(inspect.stack()[0][3], response.text))
if 'content' not in res_dic:
raise Exception('【执行函数{0}】调用获取验证码接口没有返回content字段，接口返回内容{1}'
.format(inspect.stack()[0][3], response.text))
if 'serialNo' not in res_dic['content']:
raise Exception('【执行函数{0}】调用获取验证码接口没有返回serialNo字段，接口返回内容{1}'
.format(inspect.stack()[0][3], response.text))
serial_no = eval(res_dic['content'])['serialNo']
login_url = base_host + '/user/login/v3/phoneLogin'
login_input = {
"phone": str(phone),
"smsSerialNo": serial_no,
"timestamp": current_timestamp,
"verifyCode": "8888",
}
# 加签
login_input = get_sign_common(login_input)
# 动码登录
try:
response = hc.http_post(login_url, heard_info, login_input)
except Exception as err:
raise err
res_dic = json.loads(response.text)
hr_logger.log_info('【执行函数{0}】动码登录接口返回内容{1}'.format(inspect.stack()[0][3], response.text))
if 'accessToken' not in res_dic:
raise Exception('调用登录接口没有返回accessToken字段，接口返回内容{0}'.format(response.text))
access_token = res_dic['accessToken']
if not access_token:
raise Exception('动码登录失败，具体原因请参考上面日志中动码登录接口返回内容')
return access_token