gomock 使用

发表于 2021-06-29 更新于 2021-07-03 阅读次数：本文字数： 7.4k 阅读时长 ≈ 7 分钟

gomock 是 Go 官方的模拟框架，可以与 go 的 test 很好的集成。在实际项目中，当需要进行单元测试时，往往会有很多的依赖项，有些依赖可能还没有办法直接进行创建，例如数据库连接，文件 I/O 等。此时通过使用 go mock 可以模拟依赖项，简化测试。

mock 的用处

mock 测试可以支持 io 类型的测试，比如：数据库，网络API请求，文件访问等。mock 测试还可以做为未开发服务的模拟、服务压力测试支持、对未知复杂的服务进行模拟，比如开发阶段我们依赖的服务还没有开发好，那么就可以使用 mock 方法来模拟一个服务，模拟的这个服务接收的参数和返回的参数和规划设计的服务是一致的，那我们就可以直接使用这个模拟的服务来协助开发测试了；再比如要对服务进行压力测试，这个时候我们就要把服务依赖的网络，数据等服务进行模拟，不然得到的结果不纯粹。总结一下，有以下几种情况下使用 mock 会比较好：

IO类型的，本地文件，数据库，网络API，RPC等
依赖的服务还没有开发好，这时候可以自己模拟一个服务，加快开发进度提升开发效率
压力性能测试的时候屏蔽外部依赖，专注测试本模块
依赖的内部函数非常复杂，要构造数据非常不方便，这也是一种

mock 测试，简单来说就是通过对服务或者函数发送设计好的参数，并且通过构造注入期望返回的数据来方便以上几种测试开发。

gomock 安装

go get -u github.com/golang/mock/gomock
go install github.com/golang/mock/mockgen

在上面首先安装了 go mock 的依赖包，然后安装了 mockgen 代码生成工具，用于生成 mock 代码，该工具会被安装在 go/bin 目录下。

gomock 使用

使用 mockgen 命令时，支持两种代码生成方式。

一种是 source 指定的方式，这种方式从源文件生成 mock 接口：

mockgen -source=foo.go [other options]

另外一种是 reflect 方式，可以通过反射生成代码，这种方式需要传递两个非标志参数来启动：导入路径 import 和逗号分割的需要进行 mock 的接口列表：

mockgen database/sql/driver Conn,Driver

# Convenient for `go:generate`.
mockgen . Conn,Driver

可以使用 . 表示当前路径下的包。

mockgen 的相关参数

mockgen 的用途在于为需要模拟数据的接口生成模拟数据代码，它具有以下参数：

-source：要模拟的接口的文件。
-destination：mock 文件输出的地方，如果不进行设置，则会打印到标准输出中。
-package：生成的 mock 文件的包名，如果不设置则为 mock_ 前缀加上输入的文件名。
-imports：表示需要在输出的代码中显示导入的列表，其格式为逗号分割的单元素列表 foo=bar/baz，其中 bar/baz 就是需要显示导入的包，foo 是生成的代码中的包的标识符。
-aux_files：应查阅的附加文件列表，以解决例如在不同文件中定义的嵌入式接口。这被指定为以逗号分隔的形式元素列表 foo=bar/baz.go，其中 bar/baz.go 是源文件，foo 是 -source 文件使用的该文件的包名称。
-build_flags：这个参数只在 reflect 模式下使用，用于 go build 的时候使用
-mock_names：自定义生成 mock 文件的列表，使用逗号分割。如Repository=MockSensorRepository,Endpoint=MockSensorEndpoint。 Repository、Endpoint 为接口，MockSensorRepository，MockSensorEndpoint 为相应的 mock 文件。

mockgen工作模式适用场景

mockgen 工作模式适用场景如下：

对于简单场景，只需使用 -source 选项。
对于复杂场景，如一个源文件定义了多个 interface 而只想对部分i nterface 进行 mock，或者 interface 存在嵌套，则需要使用反射模式。

使用示例

首先代码目录结构如下：

go mock目录结构

male.go 的代码如下：

package person

// 这里假设 Male 是与数据库交互的部分
type Male interface {
    Get(id int64) error
}

user.go 的代码如下：

package user

import "MockTest/person"

type User struct {
    Person person.Male
}

func NewUser(p person.Male) *User {
    return &User{Person: p}
}

func (u *User) GetUserInfo(id int64) error {
    return u.Person.Get(id)
}

首先通过 mockgen 生成 mock 代码：

mockgen -source=./person/male.go -destination=./mock/male_mock.go -package=mock

生成的 male_mock.go 代码如下：

// Code generated by MockGen. DO NOT EDIT.
// Source: ./person/male.go

// Package mock is a generated GoMock package.
package mock

import (
    reflect "reflect"

    gomock "github.com/golang/mock/gomock"
)

// MockMale is a mock of Male interface.
type MockMale struct {
    ctrl     *gomock.Controller
    recorder *MockMaleMockRecorder
}

// MockMaleMockRecorder is the mock recorder for MockMale.
type MockMaleMockRecorder struct {
    mock *MockMale
}

// NewMockMale creates a new mock instance.
func NewMockMale(ctrl *gomock.Controller) *MockMale {
    mock := &MockMale{ctrl: ctrl}
    mock.recorder = &MockMaleMockRecorder{mock}
    return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockMale) EXPECT() *MockMaleMockRecorder {
    return m.recorder
}

// Get mocks base method.
func (m *MockMale) Get(id int64) error {
    m.ctrl.T.Helper()
    ret := m.ctrl.Call(m, "Get", id)
    ret0, _ := ret[0].(error)
    return ret0
}

// Get indicates an expected call of Get.
func (mr *MockMaleMockRecorder) Get(id interface{}) *gomock.Call {
    mr.mock.ctrl.T.Helper()
    return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockMale)(nil).Get), id)
}

可以看到生成的文件已经实现了上面 Male 中定义的接口，接下来就可以进行测试文件的编写：

package user

import (
    "MockTest/mock"
    "errors"
    "github.com/golang/mock/gomock"
    "testing"
)

func TestUser_GetUserInfo(t *testing.T) {
    ctl := gomock.NewController(t)
    // go version 1.14+ && mockgen version 1.5.0+ 可以不用手动释放
    //defer ctl.Finish()

    var id int64 = 1
    mockMale := mock.NewMockMale(ctl)
    gomock.InOrder(
        mockMale.EXPECT().Get(id).Return(errors.New("test error")),
    )

    user := NewUser(mockMale)
    err := user.GetUserInfo(id)
    if err != nil {
        t.Errorf("user.GetUserInfo err: %v", err)
    }
}

上面代码相关的解析如下：

gomock.NewController：返回 gomock.Controller,它代表 mock 生态系统中的顶级控件，定义了 mock 对象的范围,生命周期和期待值，另外它在多个 goroutine 中是安全的。
mock.NewMockMale：创建一个新的 mock 实例
gomock.InOrder：声明给定的调用应按顺序进行（是对 gomock.After 的二次封装）
mockMale.EXPECT().Get(id).Return(nil)：这里有三个步骤,EXPECT()返回一个允许调用者设置期望和返回值的对象。Get(id) 是设置入参并调用 mock 实例中的方法。Return(nil) 是设置先前调用的方法出参。简单来说，就是设置入参并调用，最后设置返回值。
NewUser(mockMale)：创建 User 实例,值得注意的是，在这里注入了 mock 对象，因此实际在随后的 user.GetUserInfo(id) 调用（入参：id 为 1）中，它调用的是事先模拟好的 mock 方法。

之后就是运行测试函数的步骤了。

mock 常用方法

除了上面的 Return 等方法，mock 还有以下这些常用的方法：

Call.Do()：声明在匹配时要运行的操作
Call.DoAndReturn()：声明在匹配调用时要运行的操作,并且模拟返回该函数的返回值
Call.MaxTimes()：设置最大的调用次数为 n 次
Call.MinTimes()：设置最小的调用次数为 n 次
Call.AnyTimes()：允许调用次数为 0 次或更多次
Call.Times()：设置调用次数为 n 次

另外还有用于匹配参数的方法：

gomock.Any()：匹配任意值
gomock.Eq()：通过反射匹配到指定的类型值，而不需要手动设置
gomock.Nil()：返回 nil

指定调用的顺序

gomock.InOrder：声明指定了调用顺序，默认情况下，行为调用顺序可以和 mock 对象行为注入顺序不一致，即不保序。如果要保序，有两种方法：

通过 After 关键字来实现保序
通过 InOrder 关键字来实现保序

call := mockpeople.EXPECT().GetName().Return("helight1")
mockpeople.EXPECT().GetName().Return("helight").After(call)   
gomock.InOrder(
  mockpeople.EXPECT().GetName().Return("helight")
)

详细使用示例

设置函数的返回值

// 静态设置返回值
func TestReturn(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    repo := NewMockUserRepository(ctrl)
    // 期望FindOne(1)返回张三用户
    repo.EXPECT().FindOne(1).Return(&User{Name: "张三"}, nil)
    // 期望FindOne(2)返回李四用户
    repo.EXPECT().FindOne(2).Return(&User{Name: "李四"}, nil)
    // 期望给FindOne(3)返回找不到用户的错误
    repo.EXPECT().FindOne(3).Return(nil, errors.New("user not found"))
    // 验证一下结果
    log.Println(repo.FindOne(1)) // 这是张三
    log.Println(repo.FindOne(2)) // 这是李四
    log.Println(repo.FindOne(3)) // user not found
    log.Println(repo.FindOne(4)) //没有设置4的返回值，却执行了调用，测试不通过
}
// 动态设置返回值
func TestReturnDynamic(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()
    repo := NewMockUserRepository(ctrl)
    // 常用方法之一：DoAndReturn()，动态设置返回值 
    repo.EXPECT().FindOne(gomock.Any()).DoAndReturn(func(i int) (*User,error) {
        if i == 0 {
            return nil, errors.New("user not found")
        }
        if i < 100 {
            return &User{
                Name:"小于100",
            }, nil
        } else {
            return &User{
                Name:"大于等于100",
            }, nil
        }
    })
    log.Println(repo.FindOne(120))
    //log.Println(repo.FindOne(66))
    //log.Println(repo.FindOne(0))
}

调用次数检测

func TestTimes(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    repo := NewMockUserRepository(ctrl)
    // 默认期望调用一次
    repo.EXPECT().FindOne(1).Return(&User{Name: "张三"}, nil)
    // 期望调用2次
    repo.EXPECT().FindOne(2).Return(&User{Name: "李四"}, nil).Times(2)
    // 调用多少次可以,包括0次
    repo.EXPECT().FindOne(3).Return(nil, errors.New("user not found")).AnyTimes()

    // 验证一下结果
    log.Println(repo.FindOne(1)) // 这是张三
    log.Println(repo.FindOne(2)) // 这是李四
    log.Println(repo.FindOne(2)) // FindOne(2) 需调用两次,注释本行代码将导致测试不通过
    log.Println(repo.FindOne(3)) // user not found, 不限调用次数，注释掉本行也能通过测试
}

调用顺序检测

func TestOrder(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()
    repo := NewMockUserRepository(ctrl)
    o1 := repo.EXPECT().FindOne(1).Return(&User{Name: "张三"}, nil)
    o2 := repo.EXPECT().FindOne(2).Return(&User{Name: "李四"}, nil)
    o3 := repo.EXPECT().FindOne(3).Return(nil, errors.New("user not found"))
    gomock.InOrder(o1, o2, o3) //设置调用顺序
    // 按顺序调用，验证一下结果
    log.Println(repo.FindOne(1)) // 这是张三
    log.Println(repo.FindOne(2)) // 这是李四
    log.Println(repo.FindOne(3)) // user not found
    
    // 如果我们调整了调用顺序，将导致测试不通过：
    // log.Println(repo.FindOne(2)) // 这是李四
    // log.Println(repo.FindOne(1)) // 这是张三
    // log.Println(repo.FindOne(3)) // user not found
}

参考文章：

Go进阶06:怎么使用Gomock进行单元测试

笔记go mock用法

golang单元测试之mock

搞定Go单元测试（二）—— mock框架(gomock)