带你走进Golang 单元测试（下）

lsekfe

使用 gomock 打桩
　　最后剩下 getPersonDetailRedis 函数，我们先来看一下这个函数的逻辑。

1. <font size="3">　// 通过 redis 拉取对应用户的资料信息
   
2. 
   
3. 　　func getPersonDetailRedis(username string) (*PersonDetail, error) {
   
4. 
   
5. 　　 result := &PersonDetail{}
   
6. 
   
7. 　　 client, err := redis.Dial("tcp", ":6379")
   
8. 
   
9. 　　 defer client.Close()
   
10. 
    
11. 　　 data, err := redis.Bytes(client.Do("GET", username))
    
12. 
    
13. 　　 if err != nil {
    
14. 
    
15. 　　  return nil, err
    
16. 
    
17. 　　 }
    
18. 
    
19. 　　 err = json.Unmarshal(data, result)
    
20. 
    
21. 　　 if err != nil {
    
22. 
    
23. 　　  return nil, err
    
24. 
    
25. 　　 }
    
26. 
    
27. 　　 return result, nil
    
28. 
    
29. 　　}</font>

复制代码

getPersonDetailRedis 函数的核心在于生成了 client 调用了它的 Do 方法，通过分析得知 client 实际上是一个符合 Conn 接口的结构体。如果我们使用 gomonkey 来进行打桩，需要先声明一个结构体并实现 Client 接口拥有的方法，之后才能使用 gomonkey 给函数打桩。

1. <font size="3">// redis 包中关于 Conn 的定义
   
2. 
   
3. 　　// Conn represents a connection to a Redis server.
   
4. 
   
5. 　　type Conn interface {
   
6. 
   
7. 　　 // Close closes the connection.
   
8. 
   
9. 　　 Close() error
   
10. 
    
11. 　　 // Err returns a non-nil value when the connection is not usable.
    
12. 
    
13. 　　 Err() error
    
14. 
    
15. 　　 // Do sends a command to the server and returns the received reply.
    
16. 
    
17. 　　 Do(commandName string, args ...interface{}) (reply interface{}, err error)
    
18. 
    
19. 　　 // Send writes the command to the client's output buffer.
    
20. 
    
21. 　　 Send(commandName string, args ...interface{}) error
    
22. 
    
23. 　　 // Flush flushes the output buffer to the Redis server.
    
24. 
    
25. 　　 Flush() error
    
26. 
    
27. 　　 // Receive receives a single reply from the Redis server
    
28. 
    
29. 　　 Receive() (reply interface{}, err error)
    
30. 
    
31. 　　}
    
32. 
    
33. 　　// 实现接口
    
34. 
    
35. 　　type Client struct {}
    
36. 
    
37. 　　func (c *Client) Close() error {
    
38. 
    
39. 　　  return nil
    
40. 
    
41. 　　}
    
42. 
    
43. 　　func (c *Client) Err() error {
    
44. 
    
45. 　　  return nil
    
46. 
    
47. 　　}
    
48. 
    
49. 　　func (c *Client) Do(commandName string, args ...interface{}) (interface{}, error) {
    
50. 
    
51. 　　  return nil, nil
    
52. 
    
53. 　　}
    
54. 
    
55. 　　func (c *Client) Send(commandName string, args ...interface{}) error {
    
56. 
    
57. 　　  return nil
    
58. 
    
59. 　　}
    
60. 
    
61. 　　func (c *Client) Flush() error {
    
62. 
    
63. 　　  return nil
    
64. 
    
65. 　　}
    
66. 
    
67. 　　func (c *Client) Receive() (interface{}, error) {
    
68. 
    
69. 　　  return nil, nil
    
70. 
    
71. 　　}
    
72. 
    
73. 　　// 实现接口
    
74. 
    
75. 　　type Client struct {}
    
76. 
    
77. 　　func (c *Client) Close() error {
    
78. 
    
79. 　　 return nil
    
80. 
    
81. 　　}
    
82. 
    
83. 　　func (c *Client) Err() error {
    
84. 
    
85. 　　 return nil
    
86. 
    
87. 　　}
    
88. 
    
89. 　　func (c *Client) Do(commandName string, args ...interface{}) (interface{}, error) {
    
90. 
    
91. 　　 return nil, nil
    
92. 
    
93. 　　}
    
94. 
    
95. 　　func (c *Client) Send(commandName string, args ...interface{}) error {
    
96. 
    
97. 　　 return nil
    
98. 
    
99. 　　}
    
100. 
     
101. 　　func (c *Client) Flush() error {
     
102. 
     
103. 　　 return nil
     
104. 
     
105. 　　}
     
106. 
     
107. 　　func (c *Client) Receive() (interface{}, error) {
     
108. 
     
109. 　　 return nil, nil
     
110. 
     
111. 　　}
     
112. 
     
113. 　　// 进行测试
     
114. 
     
115. 　　func test() {
     
116. 
     
117. 　　 c := &Client{}
     
118. 
     
119. 　　 gomonkey.ApplyFunc(redis.Dial, func(_ string, _ string, _ ...redis.DialOption) (redis.Conn, error) {
     
120. 
     
121. 　　  return c, nil
     
122. 
     
123. 　　 })
     
124. 
     
125. 　　 gomonkey.ApplyMethod(reflect.TypeOf(c), "Do", func(commandName string, args ...interface{}) (interface{}, error) {
     
126. 
     
127. 　　  var result interface{}
     
128. 
     
129. 　　  return result, nil
     
130. 
     
131. 　　 })
     
132. 
     
133. 　　}</font>

复制代码

可见，如果接口实现的方法更多，那么打桩需要手写的代码会更多。因此这里需要一种能自动根据原接口的定义生成接口的 mock 代码以及更方便的接口 mock 方式。于是这里我们使用 gomock 来解决这个问题。
　　本地安装 gomock

1. <font size="3"># 打开终端后依次执行
   
2. 
   
3. 　　go get -u github.com/golang/mock/gomock
   
4. 
   
5. 　　go install github.com/golang/mock/mockgen
   
6. 
   
7. 　　# 备注说明，很重要！！！
   
8. 
   
9. 　　# 安装完成之后，执行 mockgen 看命令是否生效 # 如果显示命令无效，请找到本机的 GOPATH 安装目录下的 bin 文件夹是否有 mockgen 二进制文件
   
10. 
    
11. 　　# GOPATH 可以执行 go env 命令找到
    
12. 
    
13. 　　# 如果命令无效但是 GOPATH 路径下的 bin 文件夹中存在 mockgen，请将 GOPATH 下 bin 文件夹的绝对路径添加到全局 PATH 中</font>

复制代码

生成 gomock 桩代码
　　安装完毕后，找到要进行打桩的接口，这里是 http://github.com/gomodule/redigo/redis 包里面的 Conn 接口。
　　在当前代码目录下执行以下指令，这里我们只对某个特定的接口生成 mock 代码。

1. <font size="3">　mockgen -destination=mock_redis.go -package=unit github.com/gomodule/redigo/redis Conn
   
2. 
   
3. 　　# 更多指令参考：https://github.com/golang/mock#flags</font>

复制代码

完善 gomock 相关逻辑

1. <font size="3">func Test_getPersonDetailRedis(t *testing.T) {
   
2. 
   
3. 　　 tests := []struct {
   
4. 
   
5. 　　  name    string
   
6. 
   
7. 　　  want    *PersonDetail
   
8. 
   
9. 　　  wantErr bool
   
10. 
    
11. 　　 }{
    
12. 
    
13. 　　  {name: "redis.Do err", want: nil, wantErr: true},
    
14. 
    
15. 　　  {name: "json.Unmarshal err", want: nil, wantErr: true},
    
16. 
    
17. 　　  {name: "success", want: &PersonDetail{
    
18. 
    
19. 　　   Username: "steven",
    
20. 
    
21. 　　   Email:    "1234567@qq.com",
    
22. 
    
23. 　　  }, wantErr: false},
    
24. 
    
25. 　　 }
    
26. 
    
27. 　　 ctrl := gomock.NewController(t)
    
28. 
    
29. 　　 defer ctrl.Finish()
    
30. 
    
31. 　　 // 1. 生成符合 redis.Conn 接口的 mockConn
    
32. 
    
33. 　　 mockConn := NewMockConn(ctrl)
    
34. 
    
35. 　　 // 2. 给接口打桩序列
    
36. 
    
37. 　　 gomock.InOrder(
    
38. 
    
39. 　　  mockConn.EXPECT().Do("GET", gomock.Any()).Return("", errors.New("redis.Do err")),
    
40. 
    
41. 　　  mockConn.EXPECT().Close().Return(nil),
    
42. 
    
43. 　　  mockConn.EXPECT().Do("GET", gomock.Any()).Return("123", nil),
    
44. 
    
45. 　　  mockConn.EXPECT().Close().Return(nil),
    
46. 
    
47. 　　  mockConn.EXPECT().Do("GET", gomock.Any()).Return([]byte(`{"username": "steven", "email": "1234567@qq.com"}`), nil),
    
48. 
    
49. 　　  mockConn.EXPECT().Close().Return(nil),
    
50. 
    
51. 　　 )
    
52. 
    
53. 　　 // 3. 给 redis.Dail 函数打桩
    
54. 
    
55. 　　 outputs := []gomonkey.OutputCell{
    
56. 
    
57. 　　  {
    
58. 
    
59. 　　   Values: gomonkey.Params{mockConn, nil},
    
60. 
    
61. 　　   Times:  3, // 3 个用例
    
62. 
    
63. 　　  },
    
64. 
    
65. 　　 }
    
66. 
    
67. 　　 patches := gomonkey.ApplyFuncSeq(redis.Dial, outputs)
    
68. 
    
69. 　　 // 执行完毕之后释放桩序列
    
70. 
    
71. 　　 defer patches.Reset()
    
72. 
    
73. 　　 // 4. 断言
    
74. 
    
75. 　　 for _, tt := range tests {
    
76. 
    
77. 　　  actual, err := getPersonDetailRedis(tt.name)
    
78. 
    
79. 　　  // 注意，equal 函数能够对结构体进行 deap diff
    
80. 
    
81. 　　  assert.Equal(t, tt.want, actual)
    
82. 
    
83. 　　  assert.Equal(t, tt.wantErr, err != nil)
    
84. 
    
85. 　　 }
    
86. 
    
87. 　　}</font>

复制代码

从上面可以看到，给 getPersonDetailRedis 函数做单元测试主要做了四件事情：
　　·生成符合 redis.Conn 接口的 mockConn
　　· 给接口打桩序列
　　· 给函数 redis.Dial 打桩
　　· 断言
　　这里面同时使用了 gomock、gomonkey 和 testify 三个包作为压测工具，日常使用中，由于复杂的调用逻辑带来繁杂的单测，也无外乎使用这三个包协同完成。
　　查看单测报告
　　单元测试编写完毕之后，我们可以调用相关的指令来查看覆盖范围，帮助我们查看单元测试是否已经完全覆盖逻辑代码，以便我们及时调整单测逻辑和用例。
　　使用 go test 指令
　　默认情况下，我们在当前代码目录下执行 go test 指令，会自动的执行当前目录下面带 _test.go 后缀的文件进行测试。如若想展示具体的测试函数以及覆盖率，可以添加 -v 和 -cover 参数，如下所示：

1. <font size="3">  go_unit_test [master]    go test -v -cover
   
2. 
   
3. 　　=== RUN   TestGetPersonDetail
   
4. 
   
5. 　　--- PASS: TestGetPersonDetail (0.00s)
   
6. 
   
7. 　　=== RUN   Test_checkEmail
   
8. 
   
9. 　　--- PASS: Test_checkEmail (0.00s)
   
10. 
    
11. 　　=== RUN   Test_checkUsername
    
12. 
    
13. 　　--- PASS: Test_checkUsername (0.00s)
    
14. 
    
15. 　　=== RUN   Test_getPersonDetailRedis
    
16. 
    
17. 　　--- PASS: Test_getPersonDetailRedis (0.00s)
    
18. 
    
19. 　　PASS
    
20. 
    
21. 　　coverage: 60.8% of statements
    
22. 
    
23. 　　ok      unit    0.131s</font>

复制代码

如果想指定测试某一个函数，可以在指令后面添加 -run ${test文件内函数名} 来指定执行。

1. <font size="3">   go_unit_test [master]    go test -cover -v  -run Test_getPersonDetailRedis
   
2. 
   
3. 　　=== RUN   Test_getPersonDetailRedis
   
4. 
   
5. 　　--- PASS: Test_getPersonDetailRedis (0.00s)
   
6. 
   
7. 　　PASS
   
8. 
   
9. 　　coverage: 41.9% of statements
   
10. 
    
11. 　　ok      unit    0.369s</font>

复制代码

在执行 go test 命令时，需要加上 -gcflags=all=-l 防止编译器内联优化导致单测出现问题，这跟打桩代码存在密切的关系，后面我们会详细的介绍这一点。
　　因此，一个完整的单测指令可以是 go test -v -cover -gcflags=all=-l -coverprofile=coverage.out
　　生成覆盖报告
　　最后，我们可以执行 go tool cover -html=coverage.out ，查看代码的覆盖情况，使用前请先安装好 go tool 工具。