Go 单元测试之mock接口测试

目次

• 一、gomock 工具介绍
  
• 二、安装
  
• 三、使用
  
  
  
  • 
    
    
    
    • 3.1 指定三个参数
      
    • 3.2 使用命令为接口生成 mock 实现
      
    • 3.3 使用make 命令封装处理mock
      
    
    
  
  
• 四、接口单元测试步骤
  
• 三、小黄书Service层单元测试
  
• 四、flags
  
• 五、打桩（stub）
  
  
  
  • 
    
    
    
    • 参数
      
    
    
  
  
• 六、总结
  
  
  
  • 6.1 测试用例界说
    
  • 6.2 设计测试用例
    
  • 6.3 实行测试用例代码
    
  • 6.4 运行测试用例
    
  • 6.5 不是全部的场景都很好测试
    
  
  

一、gomock 工具介绍

gomock 是一个 Go 语言的测试框架，在现实项目中，需要进行单元测试的时间。却往往发现有一大堆依赖项。这时间就是 Gomock 大显技艺的时间了，用于编写单元测试时模拟和测试依赖于外部服务的代码。它允许你创建模拟对象（Mock Objects），这些对象可以预设期望的行为，以便在测试时模拟外部依赖，通常使用它对代码中的那些接口类型进行mock。
原来 Go 团队提供了一个 mock 工具 https://github.com/golang/mock，但在今年放弃维护了，改用 https://github.com/uber-go/mock。
二、安装

要安装 gomock，你可以使用 Go 包管理器 go get：

1. go install go.uber.org/mock/mockgen@latest

复制代码

三、使用

首先确保你已经安装了gomock ，并且在项目中实行了go mod tidy
3.1 指定三个参数

在使用 mockgen 生成模拟对象（Mock Objects）时，通常需要指定三个主要参数：

• source：这是你想要生成模拟对象的接口界说所在的文件路径。
  
• destination：这是你想要生成模拟对象代码的目标路径。
  
• package：这是生成代码的包名。
  

3.2 使用命令为接口生成 mock 实现

一旦你指定了上述参数，mockgen 就会为你提供的接口生成模拟实现。生成的模拟实现将包含一个 EXPECT 方法，用于设置预期的行为，以及一些方法实现，这些实现将返回默认值或调用真实的实现。
比方，如果你的接口界说在 ./webook/internal/service/user.go 文件中，你可以使用以下命令来生成模拟对象：

1. mockgen -source=./webook/internal/service/user.go -package=svcmocks destination=./webook/internal/service/mocks/user.mock.go

复制代码

3.3 使用make 命令封装处理mock

在现实项目中，你可能会使用 make 命令来自动化构建过程，包括生成模拟对象。你可以创建一个 Makefile 或 make.bash 文件，并添加一个目标来处理 mockgen 的调用。比方：

1. # Makefile 示例
2. # mock 目标 ，可以直接使用 make mock命令
3. .PHONY: mock
4. # 生成模拟对象
5. mock:
6.         @mockgen -source=internal/service/user.go -package=svcmocks -destination=internal/service/mocks/user.mock.go
7.         @mockgen -package=redismocks -destination=internal/repository/cache/redismocks/cmdable.mock.go github.com/redis/go-redis/v9 Cmdable
8.         @go mod tidy

复制代码

最后，只要我们实行make mock 命令，就会生成mock文件。
四、接口单元测试步骤

• 想清楚整体逻辑
  
• 界说想要（模拟）依赖项的interface（接口）
  
• 使用mockgen命令对所需mock的interface生成mock文件
  
• 编写单元测试的逻辑，在测试中使用mock
  
• 进行单元测试的验证
  

三、小黄书Service层单元测试

这里我们已注册接口为例子，代码如下：

1. // gmock/webook/backend/internal/web/user.go
2. func (u *UserHandler) SignUp(ctx *gin.Context) {
3.         type SignUpReq struct {
4.                 Email           string `json:"email"`
5.                 ConfirmPassword string `json:"confirmPassword"`
6.                 Password        string `json:"password"`
7.         }
9.         var req SignUpReq
10.         // Bind 方法会根据 Content-Type 来解析你的数据到 req 里面
11.         // 解析错了，就会直接写回一个 400 的错误
12.         if err := ctx.Bind(&req); err != nil {
13.                 return
14.         }
16.         ok, err := u.emailExp.MatchString(req.Email)
17.         if err != nil {
18.                 ctx.String(http.StatusOK, "系统错误")
19.                 return
20.         }
21.         if !ok {
22.                 ctx.String(http.StatusOK, "你的邮箱格式不对")
23.                 return
24.         }
25.         if req.ConfirmPassword != req.Password {
26.                 ctx.String(http.StatusOK, "两次输入的密码不一致")
27.                 return
28.         }
29.         ok, err = u.passwordExp.MatchString(req.Password)
30.         if err != nil {
31.                 // 记录日志
32.                 ctx.String(http.StatusOK, "系统错误")
33.                 return
34.         }
35.         if !ok {
36.                 ctx.String(http.StatusOK, "密码必须大于8位，包含数字、特殊字符")
37.                 return
38.         }
40.         // 调用一下 svc 的方法
41.         err = u.svc.SignUp(ctx, domain.User{
42.                 Email:    req.Email,
43.                 Password: req.Password,
44.         })
45.         if err == service.ErrUserDuplicateEmail {
46.                 ctx.String(http.StatusOK, "邮箱冲突")
47.                 return
48.         }
49.         if err != nil {
50.                 ctx.String(http.StatusOK, "系统异常")
51.                 return
52.         }
54.         ctx.String(http.StatusOK, "注册成功")
55. }

复制代码

实行命令，生成mock文件：

1. mockgen -source=./webook/internal/service/user.go -package=svcmocks destination=./webook/internal/service/mocks/user.mock.go

复制代码

接着我们编写单元测试，代码如下：

1. // gmock/webook/backend/internal/web/user_test.go
2. package web
4. import (
5.         "bytes"
6.         "context"
7.         "errors"
8.         "github.com/gin-gonic/gin"
9.         "github.com/stretchr/testify/assert"
10.         "github.com/stretchr/testify/require"
11.         "go.uber.org/mock/gomock"
12.         "golang.org/x/crypto/bcrypt"
13.         "net/http"
14.         "net/http/httptest"
15.         "testing"
16.         "webook/internal/domain"
17.         "webook/internal/service"
18.         svcmocks "webook/internal/service/mocks"
19. )
21. func TestEncrypt(t *testing.T) {
22.         _ = NewUserHandler(nil, nil)
23.         password := "hello#world123"
24.         encrypted, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
25.         if err != nil {
26.                 t.Fatal(err)
27.         }
28.         err = bcrypt.CompareHashAndPassword(encrypted, []byte(password))
29.         assert.NoError(t, err)
30. }
32. func TestNil(t *testing.T) {
33.         testTypeAssert(nil)
34. }
36. func testTypeAssert(c any) {
37.         _, ok := c.(*UserClaims)
38.         println(ok)
39. }
41. func TestUserHandler_SignUp(t *testing.T) {
42.         testCases := []struct {
43.                 name string
45.                 mock func(ctrl *gomock.Controller) service.UserService
47.                 reqBody string
49.                 wantCode int
50.                 wantBody string
51.         }{
52.                 {
53.                         name: "注册成功",
54.                         mock: func(ctrl *gomock.Controller) service.UserService {
55.                                 usersvc := svcmocks.NewMockUserService(ctrl)
56.                                 usersvc.EXPECT().SignUp(gomock.Any(), domain.User{
57.                                         Email:    "123@qq.com",
58.                                         Password: "hello#world123",
59.                                 }).Return(nil)
60.                                 // 注册成功是 return nil
61.                                 return usersvc
62.                         },
64.                         reqBody: `
65. {
66.         "email": "123@qq.com",
67.         "password": "hello#world123",
68.         "confirmPassword": "hello#world123"
69. }
70. `,
71.                         wantCode: http.StatusOK,
72.                         wantBody: "注册成功",
73.                 },
74.                 {
75.                         name: "参数不对，bind 失败",
76.                         mock: func(ctrl *gomock.Controller) service.UserService {
77.                                 usersvc := svcmocks.NewMockUserService(ctrl)
78.                                 // 注册成功是 return nil
79.                                 return usersvc
80.                         },
82.                         reqBody: `
83. {
84.         "email": "123@qq.com",
85.         "password": "hello#world123"
86. `,
87.                         wantCode: http.StatusBadRequest,
88.                 },
89.                 {
90.                         name: "邮箱格式不对",
91.                         mock: func(ctrl *gomock.Controller) service.UserService {
92.                                 usersvc := svcmocks.NewMockUserService(ctrl)
93.                                 return usersvc
94.                         },
96.                         reqBody: `
97. {
98.         "email": "123@q",
99.         "password": "hello#world123",
100.         "confirmPassword": "hello#world123"
101. }
102. `,
103.                         wantCode: http.StatusOK,
104.                         wantBody: "你的邮箱格式不对",
105.                 },
106.                 {
107.                         name: "两次输入密码不匹配",
108.                         mock: func(ctrl *gomock.Controller) service.UserService {
109.                                 usersvc := svcmocks.NewMockUserService(ctrl)
110.                                 return usersvc
111.                         },
113.                         reqBody: `
114. {
115.         "email": "123@qq.com",
116.         "password": "hello#world1234",
117.         "confirmPassword": "hello#world123"
118. }
119. `,
120.                         wantCode: http.StatusOK,
121.                         wantBody: "两次输入的密码不一致",
122.                 },
123.                 {
124.                         name: "密码格式不对",
125.                         mock: func(ctrl *gomock.Controller) service.UserService {
126.                                 usersvc := svcmocks.NewMockUserService(ctrl)
127.                                 return usersvc
128.                         },
129.                         reqBody: `
130. {
131.         "email": "123@qq.com",
132.         "password": "hello123",
133.         "confirmPassword": "hello123"
134. }
135. `,
136.                         wantCode: http.StatusOK,
137.                         wantBody: "密码必须大于8位，包含数字、特殊字符",
138.                 },
139.                 {
140.                         name: "邮箱冲突",
141.                         mock: func(ctrl *gomock.Controller) service.UserService {
142.                                 usersvc := svcmocks.NewMockUserService(ctrl)
143.                                 usersvc.EXPECT().SignUp(gomock.Any(), domain.User{
144.                                         Email:    "123@qq.com",
145.                                         Password: "hello#world123",
146.                                 }).Return(service.ErrUserDuplicateEmail)
147.                                 // 注册成功是 return nil
148.                                 return usersvc
149.                         },
151.                         reqBody: `
152. {
153.         "email": "123@qq.com",
154.         "password": "hello#world123",
155.         "confirmPassword": "hello#world123"
156. }
157. `,
158.                         wantCode: http.StatusOK,
159.                         wantBody: "邮箱冲突",
160.                 },
161.                 {
162.                         name: "系统异常",
163.                         mock: func(ctrl *gomock.Controller) service.UserService {
164.                                 usersvc := svcmocks.NewMockUserService(ctrl)
165.                                 usersvc.EXPECT().SignUp(gomock.Any(), domain.User{
166.                                         Email:    "123@qq.com",
167.                                         Password: "hello#world123",
168.                                 }).Return(errors.New("随便一个 error"))
169.                                 // 注册成功是 return nil
170.                                 return usersvc
171.                         },
173.                         reqBody: `
174. {
175.         "email": "123@qq.com",
176.         "password": "hello#world123",
177.         "confirmPassword": "hello#world123"
178. }
179. `,
180.                         wantCode: http.StatusOK,
181.                         wantBody: "系统异常",
182.                 },
183.         }
185.         for _, tc := range testCases {
186.                 t.Run(tc.name, func(t *testing.T) {
187.                         ctrl := gomock.NewController(t)
188.                         defer ctrl.Finish()
189.                         server := gin.Default()
190.                         // 用不上 codeSvc
191.                         h := NewUserHandler(tc.mock(ctrl), nil)
192.                         h.RegisterRoutes(server)
194.                         req, err := http.NewRequest(http.MethodPost,
195.                                 "/users/signup", bytes.NewBuffer([]byte(tc.reqBody)))
196.                         require.NoError(t, err)
197.                         // 数据是 JSON 格式
198.                         req.Header.Set("Content-Type", "application/json")
199.                         // 这里你就可以继续使用 req
201.                         resp := httptest.NewRecorder()
202.                         // 这就是 HTTP 请求进去 GIN 框架的入口。
203.                         // 当你这样调用的时候，GIN 就会处理这个请求
204.                         // 响应写回到 resp 里
205.                         server.ServeHTTP(resp, req)
207.                         assert.Equal(t, tc.wantCode, resp.Code)
208.                         assert.Equal(t, tc.wantBody, resp.Body.String())
210.                 })
211.         }
212. }
214. func TestMock(t *testing.T) {
215.         ctrl := gomock.NewController(t)
216.         defer ctrl.Finish()
218.         usersvc := svcmocks.NewMockUserService(ctrl)
220.         usersvc.EXPECT().SignUp(gomock.Any(), gomock.Any()).
221.                 Return(errors.New("mock error"))
223.         //usersvc.EXPECT().SignUp(gomock.Any(), domain.User{
224.         //        Email: "124@qq.com",
225.         //}).Return(errors.New("mock error"))
227.         err := usersvc.SignUp(context.Background(), domain.User{
228.                 Email: "123@qq.com",
229.         })
230.         t.Log(err)
231. }

复制代码

四、flags

gomock 有一些命令行标志，可以资助你控制生成过程。这些标志通常在 gomock 工具的资助下使用，比方 gomock generate。
mockgen 命令用来为给定一个包含要mock的接口的Go源文件，生成mock类源代码。它支持以下标志：

• -source：包含要mock的接口的文件。
  
• -destination：生成的源代码写入的文件。如果不设置此项，代码将打印到标准输出。
  
• -package：用于生成的模拟类源代码的包名。如果不设置此项包名默认在原包名前添加mock_前缀。
  
• -imports：在生成的源代码中使用的显式导入列表。值为foo=bar/baz形式的逗号分隔的元素列表，其中bar/baz是要导入的包，foo是要在生成的源代码中用于包的标识符。
  
• -aux_files：需要参考以解决的附加文件列表，比方在差别文件中界说的嵌入式接口。指定的值应为foo=bar/baz.go形式的以逗号分隔的元素列表，其中bar/baz.go是源文件，foo是-source文件使用的文件的包名。
  
• -build_flags：（仅反射模式）一字不差地传递标志给go build
  
• -mock_names：生成的模拟的自界说名称列表。这被指定为一个逗号分隔的元素列表，形式为Repository = MockSensorRepository,Endpoint=MockSensorEndpoint，其中Repository是接口名称，mockSensorrepository是所需的mock名称(mock工厂方法和mock记录器将以mock命名)。如果其中一个接口没有指定自界说名称，则将使用默认命名约定。
  
• -self_package：生成的代码的完备包导入路径。使用此flag的目的是通过实验包含本身的包来防止生成代码中的循环导入。如果mock的包被设置为它的一个输入(通常是主输入)，并且输出是stdio，那么mockgen就无法检测到最终的输出包，这种环境就会发生。设置此标志将告诉 mockgen 排除哪个导入
  
• -copyright_file：用于将版权标头添加到生成的源代码中的版权文件
  
• -debug_parser：仅打印解析器结果
  
• -exec_only：（反射模式） 如果设置，则实行此反射程序
  
• -prog_only：（反射模式）只生成反射程序；将其写入标准输出并退出。
  
• -write_package_comment：如果为true，则写入包文档注释 (godoc)。（默以为true）
  

五、打桩（stub）

在测试中，打桩是一种测试术语，用于为函数或方法设置一个预设的返回值，而不是调用真实的实现。在 gomock 中，打桩通常通过设置期望的行为来实现。
比方，您可以为 myServiceMock 的 DoSomething 方法设置一个期望的行为，并返回一个特定的错误。这可以通过调用 myServiceMock.EXPECT().DoSomething().Return(error) 来实现。
在单元测试中，使用 gomock 可以资助你更有用地模拟外部依赖，从而编写更可靠和更高效的测试。通常用来屏蔽或补齐业务逻辑中的关键代码方便进行单元测试。

屏蔽：不想在单元测试用引入数据库连接等重资源
补齐：依赖的上下游函数或方法还未实现

gomock支持针对参数、返回值、调用次数、调用顺序等进行打桩操作。
参数

参数相关的用法有：

• gomock.Eq(value)：表示一个等价于value值的参数
  
• gomock.Not(value)：表示一个非value值的参数
  
• gomock.Any()：表示恣意值的参数
  
• gomock.Nil()：表示空值的参数
  
• SetArg(n, value)：设置第n（从0开始）个参数的值，通常用于指针参数或切片
  

六、总结

6.1 测试用例界说

测试用例界说，最完备的环境下应该包含：

• 名字：简明扼要说清楚你测试的场景，建议用中文。
  
• 预期输入：也就是作为你方法的输入。如果测试的是界说在类型上的方法，那么也可以包含类型实例。
  
• 预期输出：你的方法实行完毕之后，预期返回的数据。如果方法是界说在类型上的方法，那么也可以包含实行之后的实例的状态。
  
• mock：每一个测试需要使用到的mock状态。单元测试里面常见，集成测试一样平常没有。
  
• 数据准备：每一个测试用例需要的数据。集成测试里常见。
  
• 数据清理：每一个测试用例在实行完毕之后，需要实行一些数据清理动作。集成测试里常见。
  

如果你要测试的方法很简单，那么你用不上全部字段。

6.2 设计测试用例

测试用例界说和运行测试用例都是很模板化的东西。测试用例就是要根据具体的方法来设计。

• 如果是单元测试：看代码，最起码做到分支覆盖。
  
• 如果是集成测试：至少测完业务层面的主要正常流程和主要非常流程。
  

单元测试覆盖率做到80%以上，在这个要求之下，只有少少数的非常分支没有测试。其它测试就不是我们研发要思量的了，让测试团队去搞。

6.3 实行测试用例代码

测试用例界说出来之后，怎么实行这些用例，就已经呼之欲出了。
这里分成几个部门：

• 初始化 mock 控制器，每个测试用例都有独立的 mock 控制器。
  
• 使用控制器 ctrl 调用 tc.mock，拿到 mock 的 UserService 和 CodeService。
  
• 使用 mock 的服务初始化 UserHandler，并且注册路由。
  
• 构造 HTTP 请求和相应 Recorder。
  
• 发起调用 ServeHTTP。
  

6.4 运行测试用例

测试里面的testCases是一个匿名结构体的切片，所以运行的时间就是直接遍历。
那么针对每一个测试用例：

• 首先调用mock部门，或者实行before。
  
• 实行测试的方法。
  
• 比较预期结果。
  
• 调用after方法。
  

注意运行的时间，先调用了t.Run，并且传入了测试用例的名字。

6.5 不是全部的场景都很好测试

即便你的代码写得非常好，但是有一些场景根本上不可能测试到。如图中的error分支，就是属于很难测试的。
由于bcrypt包你控制不住，Generate这个方法只有在超时的时间才会返回error。那么你不测试也是可以的，代码review可以确保这边正确处理了error。
记住：没有测试到的代码，一定要认真review。

小黄书单元测试代码：https://github.com/tao-xiaoxin/demo/tree/main/gotest/gmock/webook/backend

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。