def json_same(check_value, expect_value):
""" 接口响应-json完全匹配校验 : 校验, 预期结果
:desc: 说明: 验证待校验内容作为json是否和期望值json完全一致
:param check_value: 待校验内容: 指定待校验的内容，支持多层级，例如 content，content.demoList.0.code，headers
:param expect_value: 期望值: 例如 {"code": "000","desc":"成功!", "msg": "$my_var"}
:return:
"""
dict_check = transfer_json_string_to_dict(check_value)
dict_expect = transfer_json_string_to_dict(expect_value)
# dict_check和dict_expect是字符串/数字的情况
if isinstance(dict_expect, (str, int)) and isinstance(dict_check, (str, int)):
if str(dict_expect) == str(dict_check):
return True
else:
return False, '预期结果是"{0}", 实际结果是"{1}"'.format(str(dict_expect), str(dict_check))
# 返回True和False或者(False, 'err_msg'),关联测试报告success和fail
try:
# assert is_json_contains(dict_check, dict_expect)
res = is_json_contains(dict_check, dict_expect)
if res is not True:
return res
res = is_json_contains(dict_expect, dict_check)
return res
except Exception as err:
return False, err.args[0]
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 db_json_validate(dict_check, dict_expect):
""" 数据库-多字段校验(轮询) : 校验sql, 预期结果
:desc: 说明: 30s内轮询验证查询SQL的多字段结果和期望值是否一致
:param dict_check: 待校验内容: 查询多字段的SQL语句，支持在SQL结束符';'后填一个正整数指定轮询超时时间，例如 select merchant_no,term_total from accounting.fss_loans WHERE loan_id='$loan_id';15
:param dict_expect: 期望值: 必须json格式，其中key和查询SQL中的字段名对应，例如 {"merchant_no": $my_var, "term_total": 12}
:return:
"""
dict_check = transfer_json_string_to_dict(dict_check)
dict_expect = transfer_json_string_to_dict(dict_expect)
dict_check_lower_key = {key.lower(): dict_check[key] for key in dict_check}
dict_expect_lower_key = {key.lower(): dict_expect[key] for key in dict_expect}
# for key in dict_check:
# dict_check_lower_key[key.lower()] = dict_check[key]
# for key in dict_expect:
# dict_expect_lower_key[key.lower()] = dict_expect[key]
# 返回True和False或者(False, 'err_msg'),关联测试报告success和fail
try:
return is_json_contains(dict_check_lower_key, dict_expect_lower_key)
except:
return False
def db_validate_cycle(check_value, expect_value):
""" 数据库-单字段校验(轮询) : 校验sql, 预期结果
:desc: 说明: 30s内轮询验证查询SQL的单字段结果和期望值是否一致， 当查询SQL结果和期望值都是json时，自动转为json包含校验
:param check_value: 待校验内容: 查询单字段的SQL语句，支持在SQL结束符';'后填一个正整数指定轮询超时时间，例如 select merchant_no from accounting.fss_loans WHERE loan_id='$loan_id';15
:param expect_value: 期望值: 例如 023 或 {"a": "b", "c": "d"}
:return:
"""
dict_expect = transfer_json_string_to_dict(expect_value)
if isinstance(dict_expect, (dict, list)):
dict_check = transfer_json_string_to_dict(check_value)
try:
return is_json_contains(dict_check, dict_expect)
except Exception as e:
return False, format(e)
else:
try:
if check_value == expect_value:
return True
elif str(check_value) == str(expect_value):
return True
else:
return False, '预期结果是"{0}", 实际结果是"{1}"'.format(expect_value, check_value)
except Exception as e:
return False, format(e)
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 __eval_check_item(self, validator, resp_obj):
""" evaluate check item in validator.
Args:
validator (dict): validator
{"check": "status_code", "comparator": "eq", "expect": 201}
{"check": "$resp_body_success", "comparator": "eq", "expect": True}
resp_obj (object): requests.Response() object
Returns:
dict: validator info
{
"check": "status_code",
"check_value": 200,
"expect": 201,
"comparator": "eq"
}
"""
check_item = validator["check"]
expect_value = self.eval_content(
transfer_json_string_to_dict(validator["expect"]))
if validator['comparator'] == 'db_validate':
# format 6
db_connect_content = '$DB_CONNECT'
check_item = check_item.strip(db_connect_content)
if parser.extract_variables(check_item):
check_item = self.eval_content(check_item)
res = mysql_sql_executor.sql_execute(
check_item, db_connect=self.eval_content(db_connect_content))
check_value = res[0][0] if res else "DB query returns EMPTY result!"
validator["check"] = check_item
elif validator['comparator'] == 'db_json_validate':
# format 6
db_connect_content = '$DB_CONNECT'
check_item = check_item.strip(db_connect_content)
if parser.extract_variables(check_item):
check_item = self.eval_content(check_item)
try:
wait_time = int(check_item.split(';')[1])
check_item = check_item.split(';')[0] + ';'
except (IndexError, ValueError):
wait_time = 30
res = mysql_sql_executor.db_operation_to_json_cycle(
check_item,
db_connect=self.eval_content(db_connect_content),
expect_value=expect_value,
wait_time=wait_time)
check_value = res if res is not None else "DB query returns EMPTY result!"
validator["check"] = check_item
elif validator['comparator'] == 'db_validate_cycle':
# format 6
db_connect_content = '$DB_CONNECT'
check_item = check_item.strip(db_connect_content)
if parser.extract_variables(check_item):
check_item = self.eval_content(check_item)
try:
wait_time = int(check_item.split(';')[1])
check_item = check_item.split(';')[0] + ';'
except (IndexError, ValueError):
wait_time = 30
res = mysql_sql_executor.sql_execute_cycle(
check_item,
db_connect=self.eval_content(db_connect_content),
expect_value=expect_value,
wait_time=wait_time)
check_value = res if res is not None else "DB query returns EMPTY result!"
validator["check"] = check_item
# 增加redis校验
elif validator['comparator'] == 'redis_validate':
db_num = self.eval_content(
json.loads(validator['check'])['db_num'])
redis_key = self.eval_content(
json.loads(validator['check'])['redis_key'])
redis_connect = self.eval_content('$REDIS_CONNECT')
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']
with RedisUtils(redis_host, redis_port, redis_password,
db_num) as r:
check_value = r.get_str_value(redis_key)
# 增加mq校验
elif validator['comparator'] == 'mq_validate':
topic = self.eval_content(json.loads(validator['check'])['topic']
) + '_' + self.eval_content('$ENV_NAME')
tag = self.eval_content(json.loads(validator['check'])['tag'])
system_name = self.eval_content(
json.loads(validator['check'])['system_name'])
server_app_map = json.loads(self.eval_content('$SERVER_APP_MAP'))
server_default_user = json.loads(
self.eval_content('$SERVER_DEFAULT_USER'))
server_host = None
for k, v in server_app_map.items():
if system_name in v:
server_host = k
break
if not server_host:
raise Exception('环境配置中找不到指定的系统名称 {0}'.format(system_name))
server_info = [
server_host, "22", server_default_user['user'],
server_default_user['password']
]
gc = GetContenFromLog(system_name, server_info)
check_value = list(gc.get_mq_log(topic, tag))
elif isinstance(check_item, (dict, list)) \
or parser.extract_variables(check_item) \
or parser.extract_functions(check_item):
# format 1/2/3
check_value = self.eval_content(check_item)
else:
# format 4/5
check_value = resp_obj.extract_field(check_item)
from atp.utils.tools import convert_mysql_datatype_to_py
validator["check_value"] = convert_mysql_datatype_to_py(check_value)
validator["expect"] = expect_value
validator["check_result"] = "unchecked"
return validator