From 460dd557d8d7602283eb01722bdbe1e0363ad0df Mon Sep 17 00:00:00 2001 From: debugtalk Date: Sun, 30 Jul 2017 16:18:11 +0800 Subject: [PATCH] bugfix #9: handle string content with multiple variables. --- ate/context.py | 17 ++++---- ate/utils.py | 47 ++++++++++++++++------- tests/test_utils.py | 94 +++++++++++++++++++++++++++++++++------------ 3 files changed, 110 insertions(+), 48 deletions(-) diff --git a/ate/context.py b/ate/context.py index e7efa9a9..c5f3bded 100644 --- a/ate/context.py +++ b/ate/context.py @@ -6,7 +6,7 @@ import sys import types from collections import OrderedDict -from ate import exception, testcase, utils +from ate import testcase, utils def is_function(tup): @@ -154,16 +154,8 @@ class Context(object): # data is in string format here data = "" if data is None else data.strip() - if utils.is_variable(data): - # variable marker: $var - variable_name = utils.parse_variable(data) - value = self.testcase_variables_mapping.get(variable_name) - if value is None: - raise exception.ParamsError( - "%s is not defined in bind variables!" % variable_name) - return value - elif utils.is_functon(data): + if utils.is_functon(data): # function marker: ${func(1, 2, a=3, b=4)} fuction_meta = utils.parse_function(data) func_name = fuction_meta['func_name'] @@ -172,5 +164,10 @@ class Context(object): args = self.get_eval_value(args) kwargs = self.get_eval_value(kwargs) return self.testcase_functions_config[func_name](*args, **kwargs) + + elif utils.get_contain_variables(data): + parsed_data = utils.parse_variables(data, self.testcase_variables_mapping) + return parsed_data + else: return data diff --git a/ate/utils.py b/ate/utils.py index 4e915bff..f51e84be 100644 --- a/ate/utils.py +++ b/ate/utils.py @@ -18,7 +18,7 @@ except NameError: PYTHON_VERSION = 3 SECRET_KEY = "DebugTalk" -variable_regexp = re.compile(r"^\$([\w_]+)$") +variable_regexp = r"\$([\w_]+)" function_regexp = re.compile(r"^\$\{([\w_]+)\(([\$\w_ =,]*)\)\}$") def gen_random_string(str_len): @@ -117,26 +117,45 @@ def load_testcases_by_path(path): else: return [] -def is_variable(content): - """ check if content is a variable, which is in format $variable +def get_contain_variables(content): + """ extract all variable names from content, which is in format $variable @param (str) content - @return (bool) True or False + @return (list) variable name list - e.g. $variable => True - abc => False + e.g. $variable => ["variable"] + /blog/$postid => ["postid"] + /$var1/$var2 => ["var1", "var2"] + abc => [] """ - matched = variable_regexp.match(content) - return True if matched else False + return re.findall(variable_regexp, content) -def parse_variable(content): - """ parse variable name from string content. +def parse_variables(content, variable_mapping): + """ replace all variables of string content with mapping value. @param (str) content - @return (str) variable name + @return (str) parsed content - e.g. $variable => variable + 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)}" """ - matched = variable_regexp.match(content) - return matched.group(1) + 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) + + content = content.replace( + "${}".format(variable_name), + variable_value + ) + return content def is_functon(content): """ check if content is a function, which is in format ${func()} diff --git a/tests/test_utils.py b/tests/test_utils.py index 1678edcb..7f609a90 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -115,31 +115,77 @@ class TestUtils(ApiServerUnittest): testset_list_3 = utils.load_testcases_by_path(path) self.assertEqual(testset_list_3, []) - def test_is_variable(self): - content = "$var" - self.assertTrue(utils.is_variable(content)) - content = "$var123" - self.assertTrue(utils.is_variable(content)) - content = "$var_name" - self.assertTrue(utils.is_variable(content)) - content = "var" - self.assertFalse(utils.is_variable(content)) - content = "a$var" - self.assertFalse(utils.is_variable(content)) - content = "$v ar" - self.assertFalse(utils.is_variable(content)) - content = " " - self.assertFalse(utils.is_variable(content)) - content = "$abc*" - self.assertFalse(utils.is_variable(content)) + 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_variable(self): - content = "$var" - self.assertEqual(utils.parse_variable(content), "var") - content = "$var123" - self.assertEqual(utils.parse_variable(content), "var123") - content = "$var_name" - self.assertEqual(utils.parse_variable(content), "var_name") + def test_parse_variables(self): + variable_mapping = { + "var_1": "abc", + "var_2": "def" + } + 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("${func($var_1, $var_2, xyz)}", variable_mapping), + "${func(abc, def, xyz)}" + ) def test_is_functon(self): content = "${func()}"