def test_extract_variables(self):
assert parser.extract_variables("$var") == ["var"]
assert parser.extract_variables("$var123") == ["var123"]
assert parser.extract_variables("$var_name") == ["var_name"]
assert parser.extract_variables("var") == []
assert parser.extract_variables("a$var") == ["var"]
assert parser.extract_variables("$v ar") == ["v"]
assert parser.extract_variables("$abc*") == ["abc"]
assert parser.extract_variables("${func()}") == []
assert parser.extract_variables("${func(1,2)}") == []
assert parser.extract_variables(
"${gen_md5($TOKEN, $data, $random)}") == [
"TOKEN", "data", "random"
]
def parse_variables_mapping(variables_mapping):
"""
把每个引用变量的值解析出来
:param variables_mapping:
:return:
"""
run_times = 0
parsed_variables_mapping = {}
while len(parsed_variables_mapping) != len(variables_mapping):
for var_name in variables_mapping:
run_times += 1
if run_times > len(variables_mapping) * 4:
not_found_variables = {
key:variables_mapping[key]
for key in variables_mapping
if key not in parsed_variables_mapping
}
raise exceptions.VariableNotFound(not_found_variables)
if var_name in parsed_variables_mapping:
continue
value = variables_mapping[var_name]
variables = extract_variables(value)
return
def _eval_content_variables(self, content):
""" replace all variables of string content with mapping value.
@param (str) content
@return (str) parsed content
e.g.
variable_mapping = {
"var_1": "abc",
"var_2": "def"
}
$var_1 => "abc"
$var_1#XYZ => "abc#XYZ"
/$var_1/$var_2/var3 => "/abc/def/var3"
${func($var_1, $var_2, xyz)} => "${func(abc, def, xyz)}"
"""
variables_list = parser.extract_variables(content)
for variable_name in variables_list:
variable_value = self.get_bind_variable(variable_name)
if "${}".format(variable_name) == content:
# content is a variable
content = variable_value
else:
# content contains one or several variables
if not isinstance(variable_value, str):
variable_value = builtin_str(variable_value)
content = content.replace("${}".format(variable_name),
variable_value, 1)
return content
def test_extract_variables(self):
prepared_content = parser.prepare_lazy_data("123$a", {}, {"a"})
self.assertEqual(parser.extract_variables(prepared_content), {"a"})
prepared_content = parser.prepare_lazy_data("$a$b", {}, {"a", "b"})
self.assertEqual(parser.extract_variables(prepared_content),
{"a", "b"})
prepared_content = parser.prepare_lazy_data(["$a$b", "$c", "d"], {},
{"a", "b", "c", "d"})
self.assertEqual(parser.extract_variables(prepared_content),
{"a", "b", "c"})
prepared_content = parser.prepare_lazy_data(
{
"a": 1,
"b": {
"c": "$d",
"e": 3
}
}, {}, {"d"})
self.assertEqual(parser.extract_variables(prepared_content), {"d"})
prepared_content = parser.prepare_lazy_data(
{
"a": ["$b"],
"b": {
"c": "$d",
"e": 3
}
}, {}, {"b", "d"})
self.assertEqual(parser.extract_variables(prepared_content),
{"b", "d"})
prepared_content = parser.prepare_lazy_data(
["$a$b", "$c", {
"c": "$d"
}], {}, {"a", "b", "c", "d"})
self.assertEqual(parser.extract_variables(prepared_content),
{"a", "b", "c", "d"})
def extract_variables(content):
"""
递归提取单个引用变量的值
:param content:
:return:
"""
if isinstance(content,(list, set, tuple)):
variables = set()
for item in content:
variables = variables | extract_variables(item)
return variables
elif isinstance(content, dict):
variables = set()
for key, value in content.items():
variables = variables | extract_variables(value)
return variables
elif isinstance(content, LazyString):
return set(regex_findall_variables(content.raw_string))
return set()
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"]
# check_item should only be the following 5 formats:
# 1, variable reference, e.g. $token
# 2, function reference, e.g. ${is_status_code_200($status_code)}
# 3, dict or list, maybe containing variable/function reference, e.g. {"var": "$abc"}
# 4, string joined by delimiter. e.g. "status_code", "headers.content-type"
# 5, regex string, e.g. "LB[\d]*(.*)RB[\d]*"
if 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)
validator["check_value"] = check_value
# expect_value should only be in 2 types:
# 1, variable reference, e.g. $expect_status_code
# 2, actual value, e.g. 200
expect_value = self.eval_content(validator["expect"])
validator["expect"] = expect_value
validator["check_result"] = "unchecked"
return validator
def __eval_check_item(self, validator, resp_obj):
'''
evaludate check item in validator.
Args:
validator (dict): validator
{'check':'status_code','comparator':'eq','expect':200}
{'check':'$resp_body_success','comparator':'eq','expect':True}
Returns:
dict: validator info
{
'check':'status_code',
'check_value':200,
'expect':201,
'comparator':'eq'
}
'''
check_item = validator['check']
# check_item should only be the following 5 formats:
# 1. variable reference, e.g. $token
# 2. function reference, e.g. ${is_status_code_200($status_code)}
# 3. dict or list, may containing variable/function reference, e.g. {'var':'$abc'}
# 4. string joined by delimiter. e.g. 'status_code', 'headers.content-type'
# 5. regex string e.g. 'LB[\d]*(.*)RB[\d]*'
if 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)
validator['check_value'] = check_value
# expect_value should only be in 2 types:
# 1. variable reference, e.g. $expect_status_code
# 2. actual value e.g. 200
expect_value = self.eval_content(validator['expect'])
validator['expect'] = expect_value
validator['check_result'] = 'unchecked'
return validator
def test_extract_variables(self):
self.assertEqual(parser.extract_variables("$var"), {"var"})
self.assertEqual(parser.extract_variables("$var123"), {"var123"})
self.assertEqual(parser.extract_variables("$var_name"), {"var_name"})
self.assertEqual(parser.extract_variables("var"), set())
self.assertEqual(parser.extract_variables("a$var"), {"var"})
self.assertEqual(parser.extract_variables("$v ar"), {"v"})
self.assertEqual(parser.extract_variables(" "), set())
self.assertEqual(parser.extract_variables("$abc*"), {"abc"})
self.assertEqual(parser.extract_variables("${func()}"), set())
self.assertEqual(parser.extract_variables("${func(1,2)}"), set())
self.assertEqual(
parser.extract_variables("${gen_md5($TOKEN, $data, $random)}"),
{"TOKEN", "data", "random"},
)
def test_extract_variables(self):
self.assertEqual(parser.extract_variables("$var"), ["var"])
self.assertEqual(parser.extract_variables("$var123"), ["var123"])
self.assertEqual(parser.extract_variables("$var_name"), ["var_name"])
self.assertEqual(parser.extract_variables("var"), [])
self.assertEqual(parser.extract_variables("a$var"), ["var"])
self.assertEqual(parser.extract_variables("$v ar"), ["v"])
self.assertEqual(parser.extract_variables(" "), [])
self.assertEqual(parser.extract_variables("$abc*"), ["abc"])
self.assertEqual(parser.extract_variables("${func()}"), [])
self.assertEqual(parser.extract_variables("${func(1,2)}"), [])
self.assertEqual(
parser.extract_variables("${gen_md5($TOKEN, $data, $random)}"),
["TOKEN", "data", "random"])
