refactor hook mechanism:

1, remove EventHook;
2, setup_hooks: could reference request dict;
3, teardown_hooks: could reference Response object.

httprunner/__about__.py

@@ -1,7 +1,7 @@
 __title__ = 'HttpRunner'
 __description__ = 'One-stop solution for HTTP(S) testing.'
 __url__ = 'https://github.com/HttpRunner/HttpRunner'
-__version__ = '1.4.2'
+__version__ = '1.4.3'
 __author__ = 'debugtalk'
 __author_email__ = 'mail@debugtalk.com'
 __license__ = 'MIT'

httprunner/built_in.py

@@ -132,25 +132,25 @@ def endswith(check_value, expect_value):
 
 """ built-in hooks
 """
-def setup_hook_prepare_kwargs(method, url, kwargs):
-    if method == "POST":
-        content_type = kwargs.get("headers", {}).get("content-type")
-        if content_type and "data" in kwargs:
+def setup_hook_prepare_kwargs(request):
+    if request["method"] == "POST":
+        content_type = request.get("headers", {}).get("content-type")
+        if content_type and "data" in request:
             # if request content-type is application/json, request data should be dumped
-            if content_type.startswith("application/json") and isinstance(kwargs["data"], (dict, list)):
-                kwargs["data"] = json.dumps(kwargs["data"])
+            if content_type.startswith("application/json") and isinstance(request["data"], (dict, list)):
+                request["data"] = json.dumps(request["data"])
 
-            if isinstance(kwargs["data"], str):
-                kwargs["data"] = kwargs["data"].encode('utf-8')
+            if isinstance(request["data"], str):
+                request["data"] = request["data"].encode('utf-8')
 
-def setup_hook_httpntlmauth(method, url, kwargs):
-    if "httpntlmauth" in kwargs:
+def setup_hook_httpntlmauth(request):
+    if "httpntlmauth" in request:
         from requests_ntlm import HttpNtlmAuth
-        auth_account = kwargs.pop("httpntlmauth")
-        kwargs["auth"] = HttpNtlmAuth(
+        auth_account = request.pop("httpntlmauth")
+        request["auth"] = HttpNtlmAuth(
             auth_account["username"], auth_account["password"])
 
-def teardown_hook_sleep_1_secs(resp_obj):
-    """ sleep 1 seconds after request
+def sleep_N_secs(n_secs):
+    """ sleep n seconds
     """
-    time.sleep(1)
+    time.sleep(n_secs)

httprunner/runner.py

@@ -5,7 +5,6 @@
 from httprunner import exception, logger, response, utils
 from httprunner.client import HttpSession
 from httprunner.context import Context
-from httprunner.events import EventHook
 
 
 class Runner(object):
@@ -94,45 +93,10 @@ def _handle_skip_feature(self, testcase_dict):
         if skip_reason:
             raise SkipTest(skip_reason)
 
-    def _prepare_hooks_event(self, hooks):
-        if not hooks:
-            return None
-
-        event = EventHook()
-        for hook in hooks:
-            func = self.context.testcase_parser.get_bind_function(hook)
-            event += func
-
-        return event
-
-    def _call_setup_hooks(self, hooks, method, url, kwargs):
-        """ call hook functions before request
-
-        Listeners should take the following arguments:
-
-        * *method*: request method type, e.g. GET, POST, PUT
-        * *url*: URL that was called (or override name if it was used in the call to the client)
-        * *kwargs*: kwargs of request
-        """
-        hooks.insert(0, "setup_hook_prepare_kwargs")
-        event = self._prepare_hooks_event(hooks)
-        if not event:
-            return
-
-        event.fire(method=method, url=url, kwargs=kwargs)
-
-    def _call_teardown_hooks(self, hooks, resp_obj):
-        """ call hook functions after request
-
-        Listeners should take the following arguments:
-
-        * *resp_obj*: response object
-        """
-        event = self._prepare_hooks_event(hooks)
-        if not event:
-            return
-
-        event.fire(resp_obj=resp_obj)
+    def do_hook_actions(self, actions):
+        for action in actions:
+            logger.log_debug("call hook: {}".format(action))
+            self.context.eval_content(action)
 
     def run_test(self, testcase_dict):
         """ run single testcase.
@@ -161,7 +125,12 @@ def run_test(self, testcase_dict):
             }
         @return True or raise exception during test
         """
+        # check skip
+        self._handle_skip_feature(testcase_dict)
+
+        # prepare
         parsed_request = self.init_config(testcase_dict, level="testcase")
+        self.context.bind_variables({"request": parsed_request})
 
         try:
             url = parsed_request.pop('url')
@@ -170,28 +139,36 @@ def run_test(self, testcase_dict):
         except KeyError:
             raise exception.ParamsError("URL or METHOD missed!")
 
-        self._handle_skip_feature(testcase_dict)
+        logger.log_info("{method} {url}".format(method=method, url=url))
+        logger.log_debug("request kwargs(raw): {kwargs}".format(kwargs=parsed_request))
 
-        extractors = testcase_dict.get("extract", []) or testcase_dict.get("extractors", [])
-        validators = testcase_dict.get("validate", []) or testcase_dict.get("validators", [])
+        # setup hooks
         setup_hooks = testcase_dict.get("setup_hooks", [])
-        teardown_hooks = testcase_dict.get("teardown_hooks", [])
+        setup_hooks.insert(0, "${setup_hook_prepare_kwargs($request)}")
+        self.do_hook_actions(setup_hooks)
 
-        logger.log_info("{method} {url}".format(method=method, url=url))
-        logger.log_debug("request kwargs(raw): {kwargs}".format(kwargs=parsed_request))
-        self._call_setup_hooks(setup_hooks, method, url, parsed_request)
+        # request
         resp = self.http_client_session.request(
             method,
             url,
             name=group_name,
             **parsed_request
         )
-        self._call_teardown_hooks(teardown_hooks, resp)
-        resp_obj = response.ResponseObject(resp)
 
+        # teardown hooks
+        teardown_hooks = testcase_dict.get("teardown_hooks", [])
+        if teardown_hooks:
+            self.context.bind_variables({"response": resp})
+            self.do_hook_actions(teardown_hooks)
+
+        # extract
+        extractors = testcase_dict.get("extract", []) or testcase_dict.get("extractors", [])
+        resp_obj = response.ResponseObject(resp)
         extracted_variables_mapping = resp_obj.extract_response(extractors)
         self.context.bind_extracted_variables(extracted_variables_mapping)
 
+        # validate
+        validators = testcase_dict.get("validate", []) or testcase_dict.get("validators", [])
         try:
             self.context.validate(validators, resp_obj)
         except (exception.ParamsError, exception.ResponseError, \

httprunner/testcase.py

@@ -10,7 +10,7 @@
 import re
 
 from httprunner import exception, logger, utils
-from httprunner.compat import OrderedDict, numeric_types
+from httprunner.compat import OrderedDict, basestring, numeric_types
 from httprunner.utils import FileUtils
 
 variable_regexp = r"\$([\w_]+)"
@@ -75,14 +75,15 @@ def parse_function(content):
          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}}
     """
+    matched = function_regexp_compile.match(content)
+    if not matched:
+        raise exception.FunctionNotFound("{} not found!".format(content))
+
     function_meta = {
+        "func_name": matched.group(1),
         "args": [],
         "kwargs": {}
     }
-    matched = function_regexp_compile.match(content)
-    if not matched:
-        raise exception.ApiNotFound("{} not found!".format(content))
-    function_meta["func_name"] = matched.group(1)
 
     args_str = matched.group(2).replace(" ", "")
     if args_str == "":
@@ -597,6 +598,7 @@ def substitute_variables_with_mapping(content, mapping):
             }
         }
     """
+    # TODO: refactor type check
     if isinstance(content, bool):
         return content
 
@@ -903,17 +905,16 @@ def eval_content_with_bindings(self, content):
 
             return evaluated_data
 
-        if isinstance(content, (numeric_types, type)):
-            return content
+        if isinstance(content, basestring):
 
-        # content is in string format here
-        content = content.strip()
+            # content is in string format here
+            content = content.strip()
 
-        # replace functions with evaluated value
-        # Notice: _eval_content_functions must be called before _eval_content_variables
-        content = self._eval_content_functions(content)
+            # replace functions with evaluated value
+            # Notice: _eval_content_functions must be called before _eval_content_variables
+            content = self._eval_content_functions(content)
 
-        # replace variables with binding value
-        content = self._eval_content_variables(content)
+            # replace variables with binding value
+            content = self._eval_content_variables(content)
 
         return content

tests/debugtalk.py

@@ -68,8 +68,16 @@ def gen_random_string(str_len):
     random_string = ''.join(random_char_list)
     return random_string
 
-def setup_hook_add_kwargs(method, url, kwargs):
-    kwargs["key"] = "value"
+def setup_hook_add_kwargs(request):
+    request["key"] = "value"
 
-def setup_hook_remove_kwargs(method, url, kwargs):
-    kwargs.pop("key")
+def setup_hook_remove_kwargs(request):
+    request.pop("key")
+
+def teardown_hook_sleep_N_secs(response, n_secs):
+    """ sleep n seconds after request
+    """
+    if response.status_code == 200:
+        time.sleep(0.1)
+    else:
+        time.sleep(n_secs)

tests/httpbin/hooks.yml

@@ -9,8 +9,10 @@
         url: /headers
         method: GET
     setup_hooks:
-        - setup_hook_add_kwargs
-        - setup_hook_remove_kwargs
+        - ${setup_hook_add_kwargs($request)}
+        - ${setup_hook_remove_kwargs($request)}
+    teardown_hooks:
+        - ${teardown_hook_sleep_N_secs($response, 1)}
     validate:
         - eq: ["status_code", 200]
         - eq: [content.headers.Host, "127.0.0.1:3458"]

tests/test_client.py

@@ -40,7 +40,9 @@ def test_request_without_base_url(self):
         self.assertEqual(True, resp.json()['success'])
 
     def test_prepare_kwargs_content_type_application_json_without_charset(self):
-        kwargs = {
+        request = {
+            "url": "/path",
+            "method": "POST",
             "headers": {
                 "content-type": "application/json"
             },
@@ -49,13 +51,15 @@ def test_prepare_kwargs_content_type_application_json_without_charset(self):
                 "b": 2
             }
         }
-        setup_hook_prepare_kwargs("POST", "/path", kwargs)
-        self.assertIsInstance(kwargs["data"], bytes)
-        self.assertIn(b'"a": 1', kwargs["data"])
-        self.assertIn(b'"b": 2', kwargs["data"])
+        setup_hook_prepare_kwargs(request)
+        self.assertIsInstance(request["data"], bytes)
+        self.assertIn(b'"a": 1', request["data"])
+        self.assertIn(b'"b": 2', request["data"])
 
     def test_prepare_kwargs_content_type_application_json_charset_utf8(self):
-        kwargs = {
+        request = {
+            "url": "/path",
+            "method": "POST",
             "headers": {
                 "content-type": "application/json; charset=utf-8"
             },
@@ -64,5 +68,5 @@ def test_prepare_kwargs_content_type_application_json_charset_utf8(self):
                 "b": 2
             }
         }
-        setup_hook_prepare_kwargs("POST", "/path", kwargs)
-        self.assertIsInstance(kwargs["data"], bytes)
+        setup_hook_prepare_kwargs(request)
+        self.assertIsInstance(request["data"], bytes)

tests/test_context.py

@@ -231,7 +231,7 @@ def test_get_parsed_request(self):
 
     def test_exec_content_functions(self):
         test_runner = runner.Runner()
-        content = "${teardown_hook_sleep_1_secs(1)}"
+        content = "${sleep_N_secs(1)}"
         start_time = time.time()
         test_runner.context.eval_content(content)
         end_time = time.time()