bugfix #9: handle string content with multiple variables.

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

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):
+def get_contain_variables(content):
-    """ check if content is a variable, which is in format $variable
+    """ 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
+    e.g. $variable => ["variable"]
-         abc => False
+         /blog/$postid => ["postid"]
+         /$var1/$var2 => ["var1", "var2"]
+         abc => []
     """
-    matched = variable_regexp.match(content)
+    return re.findall(variable_regexp, content)
-    return True if matched else False
 
-def parse_variable(content):
+def parse_variables(content, variable_mapping):
-    """ parse variable name from string content.
+    """ 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)
+    variable_name_list = get_contain_variables(content)
-    return matched.group(1)
+    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()}

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):
+    def test_get_contain_variables(self):
-        content = "$var"
+        self.assertEqual(
-        self.assertTrue(utils.is_variable(content))
+            utils.get_contain_variables("$var"),
-        content = "$var123"
+            ["var"]
-        self.assertTrue(utils.is_variable(content))
+        )
-        content = "$var_name"
+        self.assertEqual(
-        self.assertTrue(utils.is_variable(content))
+            utils.get_contain_variables("$var123"),
-        content = "var"
+            ["var123"]
-        self.assertFalse(utils.is_variable(content))
+        )
-        content = "a$var"
+        self.assertEqual(
-        self.assertFalse(utils.is_variable(content))
+            utils.get_contain_variables("$var_name"),
-        content = "$v ar"
+            ["var_name"]
-        self.assertFalse(utils.is_variable(content))
+        )
-        content = " "
+        self.assertEqual(
-        self.assertFalse(utils.is_variable(content))
+            utils.get_contain_variables("var"),
-        content = "$abc*"
+            []
-        self.assertFalse(utils.is_variable(content))
+        )
+        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):
+    def test_parse_variables(self):
-        content = "$var"
+        variable_mapping = {
-        self.assertEqual(utils.parse_variable(content), "var")
+            "var_1": "abc",
-        content = "$var123"
+            "var_2": "def"
-        self.assertEqual(utils.parse_variable(content), "var123")
+        }
-        content = "$var_name"
+        self.assertEqual(
-        self.assertEqual(utils.parse_variable(content), "var_name")
+            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()}"