背景
在自动化测试中，通常在测试开始前需要做一些预处理操作，以及在测试结束后做一些清理性的工作。
例如，测试使用手机号注册账号的接口：
测试开始前需要确保该手机号未进行过注册，常用的做法是先在数据库中删除该手机号相关的账号数据（若存在）； 测试结束后，为了减少对测试环境的影响，常用的做法是在数据库中将本次测试产生的相关数据删除掉。 显然，在自动化测试中的这类预处理操作和清理性工作，由人工来做肯定是不合适的，我们最好的方式还是在测试脚本中进行实现，也就是我们常说的 hook 机制。
hook 机制的概念很简单，在各个主流的测试工具和测试框架中也很常见。
例如 Python 的 unittest 框架，常用的就有如下几种 hook 函数。
setUp：在每个 test 运行前执行 tearDown：在每个 test 运行后执行 setUpClass：在整个用例集运行前执行 tearDownClass：在整个用例集运行后执行 概括地讲，就是针对自动化测试用例，要在单个测试用例和整个测试用例集的前后实现 hook 函数。
描述方式设想
在 HttpRunner 的 YAML/JSON 测试用例文件中，本身就具有分层的思想，用例集层面的配置在 config 中，用例层面的配置在 test 中；同时，在 YAML/JSON 中也实现了比较方便的函数调用机制，$func($a, $b)。
因此，我们可以新增两个关键字：setup_hooks 和 teardown_hooks。类似于 variables 和 parameters 关键字，根据关键字放置的位置来决定是用例集层面还是单个用例层面。
根据设想，我们就可以采用如下形式来描述 hook 机制。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
- config :
name : basic test with httpbin
request :
base_url : http://127.0.0.1:3458/
setup_hooks :
- ${hook_print(setup_testset)}
teardown_hooks :
- ${hook_print(teardown_testset)}
- test :
name : get headers
times : 2
request :
url : /headers
method : GET
setup_hooks :
- ${hook_print(---setup-testcase)}
teardown_hooks :
- ${hook_print(---teardown-testcase)}
validate :
- eq : [ "status_code" , 200 ]
- eq : [ content.headers.Host, "127.0.0.1:3458"]
同时，hook 函数需要定义在项目的 debugtalk.py 中。
1
2
def hook_print ( msg ):
print ( msg )
基本实现方式
基于 hook 机制的简单概念，要在 HttpRunner 中实现类似功能也就很容易了。
在 HttpRunner 中，负责测试执行的类为 httprunner/runner.py 中的 Runner。因此，要实现用例集层面的 hook 机制，只需要将用例集的 setup_hooks 放置到 __init__ 中，将 teardown_hooks 放置到 __del__ 中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Runner ( object ):
def __init__ ( self , config_dict = None , http_client_session = None ):
# 省略
# testset setup hooks
testset_setup_hooks = config_dict . pop ( "setup_hooks" , [])
if testset_setup_hooks :
self . do_hook_actions ( testset_setup_hooks )
# testset teardown hooks
self . testset_teardown_hooks = config_dict . pop ( "teardown_hooks" , [])
def __del__ ( self ):
if self . testset_teardown_hooks :
self . do_hook_actions ( self . testset_teardown_hooks )
类似地，要实现单个用例层面的 hook 机制，只需要将单个用例的 setup_hooks 放置到 request 之前，将 teardown_hooks 放置到 request 之后。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Runner ( object ):
def run_test ( self , testcase_dict ):
# 省略
# setup hooks
setup_hooks = testcase_dict . get ( "setup_hooks" , [])
self . do_hook_actions ( setup_hooks )
# request
resp = self . http_client_session . request ( method , url , name = group_name , ** parsed_request )
# teardown hooks
teardown_hooks = testcase_dict . get ( "teardown_hooks" , [])
if teardown_hooks :
self . do_hook_actions ( teardown_hooks )
# 省略
至于具体执行 hook 函数的 do_hook_actions，因为之前我们已经实现了文本格式函数描述的解析器 context.eval_content，因此直接调用就可以了。
1
2
3
4
def do_hook_actions ( self , actions ):
for action in actions :
logger . log_debug ( "call hook: {} " . format ( action ))
self . context . eval_content ( action )
通过以上方式，我们就在 HttpRunner 中实现了用例集和单个用例层面的 hook 机制。
还是上面的测试用例，我们执行的效果如下所示。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ hrun tests/httpbin/hooks.yml
setup_testset
get headers
INFO GET /headers
---setup-testcase
INFO status_code: 200, response_time(ms): 10.29 ms, response_length: 151 bytes
---teardown-testcase
.
get headers
INFO GET /headers
---setup-testcase
INFO status_code: 200, response_time(ms): 4.46 ms, response_length: 151 bytes
---teardown-testcase
.
----------------------------------------------------------------------
Ran 2 tests in 0.028s
OK
teardown_testset
可以看出，这的确已经满足了我们在用例集和单个用例层面的 hook 需求。
进一步优化
以上实现已经可以满足大多数场景的测试需求了，不过还有两种场景无法满足：
需要对请求的 request 内容进行预处理，例如，根据请求方法和请求的 Content-Type 来对请求的 data 进行加工处理； 需要根据响应结果来进行不同的后续处理，例如，根据接口响应的状态码来进行不同时间的延迟等待。 在之前的实现方式中，我们无法实现上述两个场景，是因为我们无法将请求的 request 内容和响应的结果传给 hook 函数。
问题明确了，要进行进一步优化也就容易了。
因为我们在 hook 函数（类似于$func($a, $b)）中，是可以传入变量的，而变量都是存在于当前测试用例的上下文（context）中的，那么我们只要将 request 内容和请求响应分别作为变量绑定到当前测试用例的上下文即可。
具体地，我们可以约定两个变量，$request和$response，分别对应测试用例的请求内容（request）和响应实例（requests.Response）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Runner ( object ):
def run_test ( self , testcase_dict ):
self . context . bind_variables ({ "request" : parsed_request }, level = "testcase" )
# 省略
# setup hooks
setup_hooks = testcase_dict . get ( "setup_hooks" , [])
self . do_hook_actions ( setup_hooks )
# request
resp = self . http_client_session . request ( method , url , name = group_name , ** parsed_request )
# teardown hooks
teardown_hooks = testcase_dict . get ( "teardown_hooks" , [])
if teardown_hooks :
self . context . bind_variables ({ "response" : resp }, level = "testcase" )
self . do_hook_actions ( teardown_hooks )
# 省略
在优化后的实现中，新增了两次调用，self.context.bind_variables，作用就是将解析后的 request 内容和请求的响应实例绑定到当前测试用例的上下文中。
然后，我们在 YAML/JSON 测试用例中就可以在需要的时候调用$request和$response了。
1
2
3
4
5
6
7
8
9
10
11
12
- test :
name : headers
request :
url : /headers
method : GET
setup_hooks :
- ${setup_hook_prepare_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"]
对应的 hook 函数如下所示：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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 ( request [ "data" ], ( dict , list )):
request [ "data" ] = json . dumps ( request [ "data" ])
if isinstance ( request [ "data" ], str ):
request [ "data" ] = request [ "data" ] . encode ( 'utf-8' )
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 )
值得特别说明的是，因为 request 是可变参数类型（dict），因此该函数参数为引用传递，我们在 hook 函数里面对 request 进行修改后，后续在实际请求时也同样会发生改变，这对于我们需要对请求参数进行预处理时尤其有用。
更多内容
中文使用说明文档：https://httprunner.com/docs/user-guide/request-hook/ 代码实现：GitHub commit