How to use the httprunner.parser function in httprunner

}
                        },
                        "validate": [
                            {"check": "status_code", "expect": 200}
                        ]
                    }
                ]
            }
        ]
        tests_mapping = {
            "project_mapping": {
                "functions": self.debugtalk_functions
            },
            "testcases": testcases
        }
        parsed_testcases = parser.parse_tests(tests_mapping)
        parsed_testcase = parsed_testcases[0]
        test_runner = runner.Runner(parsed_testcase["config"])
        end_time = time.time()
        # check if testcase setup hook executed
        self.assertGreater(end_time - start_time, 0.5)

        start_time = time.time()
        test_runner.run_test(parsed_testcase["teststeps"][0])
        end_time = time.time()
        # testcase teardown hook has not been executed now
        self.assertLess(end_time - start_time, 2)

def test_testcase_parser(self):
        testcase_path = "tests/testcases/setup.yml"
        tests_mapping = loader.load_tests(testcase_path)

        parsed_testcases = parser.parse_tests(tests_mapping)

        self.assertEqual(len(parsed_testcases), 1)

        self.assertIn("variables", parsed_testcases[0]["config"])
        self.assertEqual(len(parsed_testcases[0]["teststeps"]), 2)

        test_dict1 = parsed_testcases[0]["teststeps"][0]
        self.assertEqual(test_dict1["name"], "get token (setup)")
        self.assertNotIn("api_def", test_dict1)
        self.assertEqual(test_dict1["variables"]["device_sn"], "TESTCASE_SETUP_XXX")
        self.assertEqual(test_dict1["request"]["url"], "/api/get-token")
        self.assertEqual(test_dict1["request"]["verify"], False)

        test_dict2 = parsed_testcases[0]["teststeps"][1]
        self.assertEqual(test_dict2["request"]["verify"], False)

def _eval_content_functions(self, content):
        functions_list = extract_functions(content)
        for func_content in functions_list:
            function_meta = parser.parse_function(func_content)
            func_name = function_meta['func_name']

            args = function_meta.get('args', [])
            kwargs = function_meta.get('kwargs', {})
            args = self.eval_content_with_bindings(args)
            kwargs = self.eval_content_with_bindings(kwargs)

            if func_name in ["parameterize", "P"]:
                eval_value = self.parameterize(*args, **kwargs)
            else:
                func = self.get_bind_function(func_name)
                eval_value = func(*args, **kwargs)

            func_content = "${" + func_content + "}"
            if func_content == content:
                # content is a variable

def test_parse_environ(self):
        os.environ["PROJECT_KEY"] = "ABCDEFGH"
        content = {
            "variables": [
                {"PROJECT_KEY": "${ENV(PROJECT_KEY)}"}
            ]
        }
        result = parser.eval_lazy_data(content)

        content = {
            "variables": [
                {"PROJECT_KEY": "${ENV(PROJECT_KEY, abc)}"}
            ]
        }
        with self.assertRaises(exceptions.ParamsError):
            parser.eval_lazy_data(content)

        content = {
            "variables": [
                {"PROJECT_KEY": "${ENV(abc=123)}"}
            ]
        }
        with self.assertRaises(exceptions.ParamsError):
            parser.eval_lazy_data(content)

def test_parse_string_value(self):
        self.assertEqual(parser.parse_string_value("123"), 123)
        self.assertEqual(parser.parse_string_value("12.3"), 12.3)
        self.assertEqual(parser.parse_string_value("a123"), "a123")
        self.assertEqual(parser.parse_string_value("$var"), "$var")
        self.assertEqual(parser.parse_string_value("${func}"), "${func}")

def test_testcase_complex_verify(self):
        testcase_path = "tests/testcases/create_user.yml"
        tests_mapping = loader.load_cases(testcase_path)
        testcases = parser.parse_tests(tests_mapping)
        teststeps = testcases[0]["teststeps"]

        # testcases/setup.yml
        teststep0 = teststeps[0]
        self.assertEqual(teststep0["teststeps"][0]["request"]["verify"], False)
        self.assertEqual(teststep0["teststeps"][1]["request"]["verify"], False)

        # testcases/create_user.yml
        teststep1 = teststeps[1]
        self.assertEqual(teststep1["teststeps"][0]["request"]["verify"], True)
        self.assertEqual(teststep1["teststeps"][1]["request"]["verify"], True)
        self.assertEqual(teststep1["teststeps"][2]["request"]["verify"], True)

""" prepare locust testcases

    Args:
        path (str): testcase file path.

    Returns:
        list: locust tests data

            [
                testcase1_dict,
                testcase2_dict
            ]

    """
    tests_mapping = loader.load_cases(path)
    testcases = parser.parse_tests(tests_mapping)

    locust_tests = []

    for testcase in testcases:
        testcase_weight = testcase.get("config", {}).pop("weight", 1)
        for _ in range(testcase_weight):
            locust_tests.append(testcase)

    return locust_tests

"abc" => "abc"
         "$var" => "$var"
    """
    try:
        if '-' in str_value:
            return str_value
        else:
            return ast.literal_eval(str_value)
    except ValueError:
        return str_value
    except SyntaxError:
        # e.g. $var, ${func}
        return str_value


httprunner.parser.parse_string_value = parse_string_value


def request(self, method, url, name=None, **kwargs):
    self.init_meta_data()

    # record test name
    self.meta_data["name"] = name

    # record original request info
    self.meta_data["data"][0]["request"]["method"] = method
    self.meta_data["data"][0]["request"]["url"] = url
    kwargs.setdefault("timeout", 120)
    self.meta_data["data"][0]["request"].update(kwargs)

    # prepend url with hostname unless it's already an absolute URL
    url = build_url(self.base_url, url)

def __eval_validator_check(self, check_item):
        """ evaluate check item in validator.

        Args:
            check_item: 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 isinstance(check_item, parser.LazyString):
            # format 1/2/3
            check_value = self.session_context.eval_content(check_item)
        else:
            # format 4/5
            check_value = self.resp_obj.extract_field(check_item)

        return check_value