mirror of
https://github.com/httprunner/httprunner.git
synced 2026-05-12 19:39:44 +08:00
restructure code: move code related to testcase from ate/utils.py to ate/testcase.py
This commit is contained in:
debugtalk
126
ate/testcase.py
126
ate/testcase.py
@@ -1,6 +1,120 @@
|
||||
from ate.exception import ParamsError
|
||||
from ate import utils
|
||||
import ast
|
||||
import re
|
||||
|
||||
from ate import utils
|
||||
from ate.exception import ParamsError
|
||||
|
||||
variable_regexp = r"\$([\w_]+)"
|
||||
function_regexp = re.compile(r"^\$\{([\w_]+)\(([\$\w_ =,]*)\)\}$")
|
||||
|
||||
|
||||
def get_contain_variables(content):
|
||||
""" extract all variable names from content, which is in format $variable
|
||||
@param (str) content
|
||||
@return (list) variable name list
|
||||
|
||||
e.g. $variable => ["variable"]
|
||||
/blog/$postid => ["postid"]
|
||||
/$var1/$var2 => ["var1", "var2"]
|
||||
abc => []
|
||||
"""
|
||||
return re.findall(variable_regexp, content)
|
||||
|
||||
def parse_variables(content, variable_mapping):
|
||||
""" 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)}"
|
||||
"""
|
||||
variable_name_list = get_contain_variables(content)
|
||||
for variable_name in variable_name_list:
|
||||
variable_value = variable_mapping.get(variable_name)
|
||||
if variable_value is None:
|
||||
raise ParamsError(
|
||||
"%s is not defined in bind variables!" % variable_name)
|
||||
|
||||
if "${}".format(variable_name) == content:
|
||||
# content is a variable
|
||||
content = variable_value
|
||||
else:
|
||||
# content contains one or many variables
|
||||
content = content.replace(
|
||||
"${}".format(variable_name),
|
||||
str(variable_value)
|
||||
)
|
||||
|
||||
return content
|
||||
|
||||
def is_functon(content):
|
||||
""" check if content is a function, which is in format ${func()}
|
||||
@param (str) content
|
||||
@return (bool) True or False
|
||||
|
||||
e.g. ${func()} => True
|
||||
${func(5)} => True
|
||||
${func(1, 2)} => True
|
||||
${func(a=1, b=2)} => True
|
||||
$abc => False
|
||||
abc => False
|
||||
"""
|
||||
matched = function_regexp.match(content)
|
||||
return True if matched else False
|
||||
|
||||
def parse_string_value(str_value):
|
||||
""" parse string to number if possible
|
||||
e.g. "123" => 123
|
||||
"12.2" => 12.3
|
||||
"abc" => "abc"
|
||||
"$var" => "$var"
|
||||
"""
|
||||
try:
|
||||
return ast.literal_eval(str_value)
|
||||
except ValueError:
|
||||
return str_value
|
||||
except SyntaxError:
|
||||
# e.g. $var, ${func}
|
||||
return str_value
|
||||
|
||||
def parse_function(content):
|
||||
""" parse function name and args from string content.
|
||||
@param (str) content
|
||||
@return (dict) function name and args
|
||||
|
||||
e.g. ${func()} => {'func_name': 'func', 'args': [], 'kwargs': {}}
|
||||
${func(5)} => {'func_name': 'func', 'args': [5], 'kwargs': {}}
|
||||
${func(1, 2)} => {'func_name': 'func', 'args': [1, 2], 'kwargs': {}}
|
||||
${func(a=1, b=2)} => {'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
${func(1, 2, a=3, b=4)} => {'func_name': 'func', 'args': [1, 2], 'kwargs': {'a':3, 'b':4}}
|
||||
"""
|
||||
function_meta = {
|
||||
"args": [],
|
||||
"kwargs": {}
|
||||
}
|
||||
matched = function_regexp.match(content)
|
||||
function_meta["func_name"] = matched.group(1)
|
||||
|
||||
args_str = matched.group(2).replace(" ", "")
|
||||
if args_str == "":
|
||||
return function_meta
|
||||
|
||||
args_list = args_str.split(',')
|
||||
for arg in args_list:
|
||||
if '=' in arg:
|
||||
key, value = arg.split('=')
|
||||
function_meta["kwargs"][key] = parse_string_value(value)
|
||||
else:
|
||||
function_meta["args"].append(parse_string_value(arg))
|
||||
|
||||
return function_meta
|
||||
|
||||
def parse_content_with_bindings(content, variables_binds, functions_binds):
|
||||
""" evaluate content recursively, each variable in content will be
|
||||
@@ -63,9 +177,9 @@ def parse_content_with_bindings(content, variables_binds, functions_binds):
|
||||
# content is in string format here
|
||||
content = "" if content is None else content.strip()
|
||||
|
||||
if utils.is_functon(content):
|
||||
if is_functon(content):
|
||||
# function marker: ${func(1, 2, a=3, b=4)}
|
||||
fuction_meta = utils.parse_function(content)
|
||||
fuction_meta = parse_function(content)
|
||||
func_name = fuction_meta['func_name']
|
||||
|
||||
func = functions_binds.get(func_name)
|
||||
@@ -79,8 +193,8 @@ def parse_content_with_bindings(content, variables_binds, functions_binds):
|
||||
kwargs = parse_content_with_bindings(kwargs, variables_binds, functions_binds)
|
||||
return func(*args, **kwargs)
|
||||
|
||||
elif utils.get_contain_variables(content):
|
||||
parsed_data = utils.parse_variables(content, variables_binds)
|
||||
elif get_contain_variables(content):
|
||||
parsed_data = parse_variables(content, variables_binds)
|
||||
return parsed_data
|
||||
|
||||
else:
|
||||
|
||||
111
ate/utils.py
111
ate/utils.py
@@ -1,4 +1,3 @@
|
||||
import ast
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
@@ -18,8 +17,6 @@ except NameError:
|
||||
PYTHON_VERSION = 3
|
||||
|
||||
SECRET_KEY = "DebugTalk"
|
||||
variable_regexp = r"\$([\w_]+)"
|
||||
function_regexp = re.compile(r"^\$\{([\w_]+)\(([\$\w_ =,]*)\)\}$")
|
||||
|
||||
def gen_random_string(str_len):
|
||||
return ''.join(
|
||||
@@ -117,114 +114,6 @@ def load_testcases_by_path(path):
|
||||
else:
|
||||
return []
|
||||
|
||||
def get_contain_variables(content):
|
||||
""" extract all variable names from content, which is in format $variable
|
||||
@param (str) content
|
||||
@return (list) variable name list
|
||||
|
||||
e.g. $variable => ["variable"]
|
||||
/blog/$postid => ["postid"]
|
||||
/$var1/$var2 => ["var1", "var2"]
|
||||
abc => []
|
||||
"""
|
||||
return re.findall(variable_regexp, content)
|
||||
|
||||
def parse_variables(content, variable_mapping):
|
||||
""" 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)}"
|
||||
"""
|
||||
variable_name_list = get_contain_variables(content)
|
||||
for variable_name in variable_name_list:
|
||||
variable_value = variable_mapping.get(variable_name)
|
||||
if variable_value is None:
|
||||
raise ParamsError(
|
||||
"%s is not defined in bind variables!" % variable_name)
|
||||
|
||||
if "${}".format(variable_name) == content:
|
||||
# content is a variable
|
||||
content = variable_value
|
||||
else:
|
||||
# content contains one or many variables
|
||||
content = content.replace(
|
||||
"${}".format(variable_name),
|
||||
str(variable_value)
|
||||
)
|
||||
|
||||
return content
|
||||
|
||||
def is_functon(content):
|
||||
""" check if content is a function, which is in format ${func()}
|
||||
@param (str) content
|
||||
@return (bool) True or False
|
||||
|
||||
e.g. ${func()} => True
|
||||
${func(5)} => True
|
||||
${func(1, 2)} => True
|
||||
${func(a=1, b=2)} => True
|
||||
$abc => False
|
||||
abc => False
|
||||
"""
|
||||
matched = function_regexp.match(content)
|
||||
return True if matched else False
|
||||
|
||||
def parse_string_value(str_value):
|
||||
""" parse string to number if possible
|
||||
e.g. "123" => 123
|
||||
"12.2" => 12.3
|
||||
"abc" => "abc"
|
||||
"$var" => "$var"
|
||||
"""
|
||||
try:
|
||||
return ast.literal_eval(str_value)
|
||||
except ValueError:
|
||||
return str_value
|
||||
except SyntaxError:
|
||||
# e.g. $var, ${func}
|
||||
return str_value
|
||||
|
||||
def parse_function(content):
|
||||
""" parse function name and args from string content.
|
||||
@param (str) content
|
||||
@return (dict) function name and args
|
||||
|
||||
e.g. ${func()} => {'func_name': 'func', 'args': [], 'kwargs': {}}
|
||||
${func(5)} => {'func_name': 'func', 'args': [5], 'kwargs': {}}
|
||||
${func(1, 2)} => {'func_name': 'func', 'args': [1, 2], 'kwargs': {}}
|
||||
${func(a=1, b=2)} => {'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
${func(1, 2, a=3, b=4)} => {'func_name': 'func', 'args': [1, 2], 'kwargs': {'a':3, 'b':4}}
|
||||
"""
|
||||
function_meta = {
|
||||
"args": [],
|
||||
"kwargs": {}
|
||||
}
|
||||
matched = function_regexp.match(content)
|
||||
function_meta["func_name"] = matched.group(1)
|
||||
|
||||
args_str = matched.group(2).replace(" ", "")
|
||||
if args_str == "":
|
||||
return function_meta
|
||||
|
||||
args_list = args_str.split(',')
|
||||
for arg in args_list:
|
||||
if '=' in arg:
|
||||
key, value = arg.split('=')
|
||||
function_meta["kwargs"][key] = parse_string_value(value)
|
||||
else:
|
||||
function_meta["args"].append(parse_string_value(arg))
|
||||
|
||||
return function_meta
|
||||
|
||||
def query_json(json_content, query, delimiter='.'):
|
||||
""" Do an xpath-like query with json_content.
|
||||
@param (json_content) json_content
|
||||
|
||||
@@ -1,34 +1,199 @@
|
||||
import unittest
|
||||
|
||||
from ate.exception import ParamsError
|
||||
from ate.testcase import parse_content_with_bindings
|
||||
from ate import testcase
|
||||
|
||||
|
||||
class TestcaseParserUnittest(unittest.TestCase):
|
||||
|
||||
def test_get_contain_variables(self):
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("$var"),
|
||||
["var"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("$var123"),
|
||||
["var123"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("$var_name"),
|
||||
["var_name"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("var"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("a$var"),
|
||||
["var"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("$v ar"),
|
||||
["v"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables(" "),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("$abc*"),
|
||||
["abc"]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("${func()}"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("${func(1,2)}"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.get_contain_variables("${gen_md5($TOKEN, $data, $random)}"),
|
||||
["TOKEN", "data", "random"]
|
||||
)
|
||||
|
||||
def test_parse_variables(self):
|
||||
variable_mapping = {
|
||||
"var_1": "abc",
|
||||
"var_2": "def",
|
||||
"var_3": 123,
|
||||
"var_4": {"a": 1},
|
||||
"var_5": True
|
||||
}
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("$var_1", variable_mapping),
|
||||
"abc"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("var_1", variable_mapping),
|
||||
"var_1"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("$var_1#XYZ", variable_mapping),
|
||||
"abc#XYZ"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("/$var_1/$var_2/var3", variable_mapping),
|
||||
"/abc/def/var3"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("/$var_1/$var_2/$var_1", variable_mapping),
|
||||
"/abc/def/abc"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("${func($var_1, $var_2, xyz)}", variable_mapping),
|
||||
"${func(abc, def, xyz)}"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("$var_3", variable_mapping),
|
||||
123
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("$var_4", variable_mapping),
|
||||
{"a": 1}
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("$var_5", variable_mapping),
|
||||
True
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("abc$var_5", variable_mapping),
|
||||
"abcTrue"
|
||||
)
|
||||
self.assertEqual(
|
||||
testcase.parse_variables("abc$var_4", variable_mapping),
|
||||
"abc{'a': 1}"
|
||||
)
|
||||
|
||||
def test_is_functon(self):
|
||||
content = "${func()}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func(5)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func(1, 2)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func($a, $b)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func(a=1, b=2)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func(1, 2, a=3, b=4)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func(1, $b, c=$x, d=4)}"
|
||||
self.assertTrue(testcase.is_functon(content))
|
||||
content = "${func}"
|
||||
self.assertFalse(testcase.is_functon(content))
|
||||
content = "$abc"
|
||||
self.assertFalse(testcase.is_functon(content))
|
||||
content = "abc"
|
||||
self.assertFalse(testcase.is_functon(content))
|
||||
|
||||
def test_parse_string_value(self):
|
||||
str_value = "123"
|
||||
self.assertEqual(testcase.parse_string_value(str_value), 123)
|
||||
str_value = "12.3"
|
||||
self.assertEqual(testcase.parse_string_value(str_value), 12.3)
|
||||
str_value = "a123"
|
||||
self.assertEqual(testcase.parse_string_value(str_value), "a123")
|
||||
str_value = "$var"
|
||||
self.assertEqual(testcase.parse_string_value(str_value), "$var")
|
||||
str_value = "${func}"
|
||||
self.assertEqual(testcase.parse_string_value(str_value), "${func}")
|
||||
|
||||
def test_parse_functon(self):
|
||||
content = "${func()}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(5)}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [5], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(1, 2)}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [1, 2], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(a=1, b=2)}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
)
|
||||
content = "${func(a= 1, b =2)}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
)
|
||||
content = "${func(1, 2, a=3, b=4)}"
|
||||
self.assertEqual(
|
||||
testcase.parse_function(content),
|
||||
{'func_name': 'func', 'args': [1, 2], 'kwargs': {'a': 3, 'b': 4}}
|
||||
)
|
||||
|
||||
def test_parse_content_with_bindings_variables(self):
|
||||
variables_binds = {
|
||||
"str_1": "str_value1",
|
||||
"str_2": "str_value2"
|
||||
}
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings("$str_1", variables_binds, {}),
|
||||
testcase.parse_content_with_bindings("$str_1", variables_binds, {}),
|
||||
"str_value1"
|
||||
)
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings("123$str_1/456", variables_binds, {}),
|
||||
testcase.parse_content_with_bindings("123$str_1/456", variables_binds, {}),
|
||||
"123str_value1/456"
|
||||
)
|
||||
|
||||
with self.assertRaises(ParamsError):
|
||||
parse_content_with_bindings("$str_3", variables_binds, {})
|
||||
testcase.parse_content_with_bindings("$str_3", variables_binds, {})
|
||||
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings(["$str_1", "str3"], variables_binds, {}),
|
||||
testcase.parse_content_with_bindings(["$str_1", "str3"], variables_binds, {}),
|
||||
["str_value1", "str3"]
|
||||
)
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings({"key": "$str_1"}, variables_binds, {}),
|
||||
testcase.parse_content_with_bindings({"key": "$str_1"}, variables_binds, {}),
|
||||
{"key": "str_value1"}
|
||||
)
|
||||
|
||||
@@ -39,7 +204,7 @@ class TestcaseParserUnittest(unittest.TestCase):
|
||||
}
|
||||
content = "/users/$userid/training/$data?userId=$userid&data=$data"
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings(content, variables_binds, {}),
|
||||
testcase.parse_content_with_bindings(content, variables_binds, {}),
|
||||
"/users/100/training/1498?userId=100&data=1498"
|
||||
)
|
||||
|
||||
@@ -50,17 +215,17 @@ class TestcaseParserUnittest(unittest.TestCase):
|
||||
for _ in range(str_len))
|
||||
}
|
||||
|
||||
result = parse_content_with_bindings("${gen_random_string(5)}", {}, functions_binds)
|
||||
result = testcase.parse_content_with_bindings("${gen_random_string(5)}", {}, functions_binds)
|
||||
self.assertEqual(len(result), 5)
|
||||
|
||||
add_two_nums = lambda a, b=1: a + b
|
||||
functions_binds["add_two_nums"] = add_two_nums
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings("${add_two_nums(1)}", {}, functions_binds),
|
||||
testcase.parse_content_with_bindings("${add_two_nums(1)}", {}, functions_binds),
|
||||
2
|
||||
)
|
||||
self.assertEqual(
|
||||
parse_content_with_bindings("${add_two_nums(1, 2)}", {}, functions_binds),
|
||||
testcase.parse_content_with_bindings("${add_two_nums(1, 2)}", {}, functions_binds),
|
||||
3
|
||||
)
|
||||
|
||||
@@ -76,7 +241,7 @@ class TestcaseParserUnittest(unittest.TestCase):
|
||||
functions_binds = {
|
||||
"add_two_nums": lambda a, b=1: a + b
|
||||
}
|
||||
testcase = {
|
||||
testcase_template = {
|
||||
"url": "http://127.0.0.1:5000/api/users/$uid",
|
||||
"method": "POST",
|
||||
"headers": {
|
||||
@@ -87,7 +252,8 @@ class TestcaseParserUnittest(unittest.TestCase):
|
||||
},
|
||||
"body": "$data"
|
||||
}
|
||||
parsed_testcase = parse_content_with_bindings(testcase, variables_binds, functions_binds)
|
||||
parsed_testcase = testcase.parse_content_with_bindings(
|
||||
testcase_template, variables_binds, functions_binds)
|
||||
|
||||
self.assertEqual(
|
||||
parsed_testcase["url"],
|
||||
|
||||
@@ -115,171 +115,6 @@ class TestUtils(ApiServerUnittest):
|
||||
testset_list_3 = utils.load_testcases_by_path(path)
|
||||
self.assertEqual(testset_list_3, [])
|
||||
|
||||
def test_get_contain_variables(self):
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("$var"),
|
||||
["var"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("$var123"),
|
||||
["var123"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("$var_name"),
|
||||
["var_name"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("var"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("a$var"),
|
||||
["var"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("$v ar"),
|
||||
["v"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables(" "),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("$abc*"),
|
||||
["abc"]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("${func()}"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("${func(1,2)}"),
|
||||
[]
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.get_contain_variables("${gen_md5($TOKEN, $data, $random)}"),
|
||||
["TOKEN", "data", "random"]
|
||||
)
|
||||
|
||||
def test_parse_variables(self):
|
||||
variable_mapping = {
|
||||
"var_1": "abc",
|
||||
"var_2": "def",
|
||||
"var_3": 123,
|
||||
"var_4": {"a": 1},
|
||||
"var_5": True
|
||||
}
|
||||
self.assertEqual(
|
||||
utils.parse_variables("$var_1", variable_mapping),
|
||||
"abc"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("var_1", variable_mapping),
|
||||
"var_1"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("$var_1#XYZ", variable_mapping),
|
||||
"abc#XYZ"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("/$var_1/$var_2/var3", variable_mapping),
|
||||
"/abc/def/var3"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("/$var_1/$var_2/$var_1", variable_mapping),
|
||||
"/abc/def/abc"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("${func($var_1, $var_2, xyz)}", variable_mapping),
|
||||
"${func(abc, def, xyz)}"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("$var_3", variable_mapping),
|
||||
123
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("$var_4", variable_mapping),
|
||||
{"a": 1}
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("$var_5", variable_mapping),
|
||||
True
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("abc$var_5", variable_mapping),
|
||||
"abcTrue"
|
||||
)
|
||||
self.assertEqual(
|
||||
utils.parse_variables("abc$var_4", variable_mapping),
|
||||
"abc{'a': 1}"
|
||||
)
|
||||
|
||||
def test_is_functon(self):
|
||||
content = "${func()}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func(5)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func(1, 2)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func($a, $b)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func(a=1, b=2)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func(1, 2, a=3, b=4)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func(1, $b, c=$x, d=4)}"
|
||||
self.assertTrue(utils.is_functon(content))
|
||||
content = "${func}"
|
||||
self.assertFalse(utils.is_functon(content))
|
||||
content = "$abc"
|
||||
self.assertFalse(utils.is_functon(content))
|
||||
content = "abc"
|
||||
self.assertFalse(utils.is_functon(content))
|
||||
|
||||
def test_parse_string_value(self):
|
||||
str_value = "123"
|
||||
self.assertEqual(utils.parse_string_value(str_value), 123)
|
||||
str_value = "12.3"
|
||||
self.assertEqual(utils.parse_string_value(str_value), 12.3)
|
||||
str_value = "a123"
|
||||
self.assertEqual(utils.parse_string_value(str_value), "a123")
|
||||
str_value = "$var"
|
||||
self.assertEqual(utils.parse_string_value(str_value), "$var")
|
||||
str_value = "${func}"
|
||||
self.assertEqual(utils.parse_string_value(str_value), "${func}")
|
||||
|
||||
def test_parse_functon(self):
|
||||
content = "${func()}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(5)}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [5], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(1, 2)}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [1, 2], 'kwargs': {}}
|
||||
)
|
||||
content = "${func(a=1, b=2)}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
)
|
||||
content = "${func(a= 1, b =2)}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [], 'kwargs': {'a': 1, 'b': 2}}
|
||||
)
|
||||
content = "${func(1, 2, a=3, b=4)}"
|
||||
self.assertEqual(
|
||||
utils.parse_function(content),
|
||||
{'func_name': 'func', 'args': [1, 2], 'kwargs': {'a': 3, 'b': 4}}
|
||||
)
|
||||
|
||||
def test_query_json(self):
|
||||
json_content = {
|
||||
"ids": [1, 2, 3, 4],
|
||||
|
||||
Reference in New Issue
Block a user