From 6cc2fde85ddbc358934e123da7ec43e72759b76b Mon Sep 17 00:00:00 2001
From: debugtalk <mail@debugtalk.com>
Date: Mon, 31 Jul 2017 22:51:28 +0800
Subject: [PATCH] restructure code: move code related to testcase from
 ate/utils.py to ate/testcase.py

---
 ate/testcase.py        | 126 +++++++++++++++++++++++++--
 ate/utils.py           | 111 ------------------------
 tests/test_testcase.py | 190 ++++++++++++++++++++++++++++++++++++++---
 tests/test_utils.py    | 165 -----------------------------------
 4 files changed, 298 insertions(+), 294 deletions(-)

diff --git a/ate/testcase.py b/ate/testcase.py
index 55f5f107..305da840 100644
--- a/ate/testcase.py
+++ b/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:
diff --git a/ate/utils.py b/ate/utils.py
index 437dc07e..32ea1166 100644
--- a/ate/utils.py
+++ b/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
diff --git a/tests/test_testcase.py b/tests/test_testcase.py
index 7f46fe19..6f201ac8 100644
--- a/tests/test_testcase.py
+++ b/tests/test_testcase.py
@@ -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"],
diff --git a/tests/test_utils.py b/tests/test_utils.py
index 5556f645..c918a667 100644
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -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],