GoLang 单元测试打桩和 mock

源码地址

单测基础

什么是 mock

   单元测试，顾名思义对某个单元函数进行测试，被测函数本身中用到的变量、函数、资源不应被测试代码依赖，所谓 mock，就是想办法通过 “虚拟” 代码替换掉依赖的方法和资源，一般需要 mock 掉以下依赖：

• 变量
• 函数/方法
• MySQL
• Redis
• http 调用

变量打桩

有时我们的代码里依赖一个全局变量，测试方法根据全局变量的不同值执行不同的逻辑，那么可以用 gostub 对变量进行打桩。

global.go：

package main

var size = 5

func Size() int {
    if size > 10 {
        return 10
    }
    return size
}

package main

import (
    "testing"

    "github.com/agiledragon/gomonkey/v2"
    "github.com/prashantv/gostub"
)

func TestSizeStub(t *testing.T) {
    tests := []struct {
        name string
        want int
        f    func() *gostub.Stubs
    }{
        {name: "size > 10", want: 10, f: func() *gostub.Stubs {
            return gostub.Stub(&size, 11)
        }},
        {name: "size <= 10", want: 3, f: func() *gostub.Stubs {
            return gostub.Stub(&size, 3)
        }},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            stub := tt.f()
            if got := Size(); got != tt.want {
                t.Errorf("Size() = %v, want %v", got, tt.want)
            }
            stub.Reset()
        })
    }
}

func TestSizeMonkey(t *testing.T) {
    tests := []struct {
        name string
        want int
        f    func() *gomonkey.Patches
    }{
        {name: "size > 10", want: 10, f: func() *gomonkey.Patches {
            return gomonkey.ApplyGlobalVar(&size, 11)
        }},
        {name: "size <= 10", want: 3, f: func() *gomonkey.Patches {
            return gomonkey.ApplyGlobalVar(&size, 3)
        }},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            stub := tt.f()
            if got := Size(); got != tt.want {
                t.Errorf("Size() = %v, want %v", got, tt.want)
            }
            stub.Reset()
        })
    }
}

$ go test -v -cover
=== RUN   TestSize
=== RUN   TestSize/size_>_10
=== RUN   TestSize/size_<=_10
--- PASS: TestSize (0.00s)
    --- PASS: TestSize/size_>_10 (0.00s)
    --- PASS: TestSize/size_<=_10 (0.00s)
PASS
coverage: 100.0% of statements

接口方法/Redis

首先 Go 语言推荐的是面向接口编程，所以官方提供并推荐使用 gomock 对依赖的方法进行 mock，前提是依赖的方法是通过抽象接口实现的，gomock 执行过程如下：

1. 使用mockgen为你想要mock的接口生成一个mock。
2. 在你的测试代码中，创建一个gomock.Controller实例并把它作为参数传递给mock对象的构造函数来创建一个mock对象。
3. 调用EXPECT()为你的mock对象设置各种期望和返回值。
4. 调用mock控制器的Finish()以验证mock的期望行为。

gomock 常用方法：

类型

用法

作用

参数

gomock.Any(v)

匹配任何类型

gomock.Eq(v)

匹配使用反射 reflect.DeepEqual 与 v 相等的值

gomock.Not(v)

v 不是 Matcher 时，匹配使用反射 reflect.DeepEqual 与 v 不相等的值；v 是 Matcher 时，匹配和 Macher 不匹配的值（Matcher）

gomock.Nil()

匹配等于 nil 的值

返回

Return()

mock 方法返回值

Do(func)

传入的 func 在 mock 真正被调用时自动执行，忽略 Return，比如：对调用方法的参数进行校验

DoAndReturn(func)

传入的 func 在 mock 真正被调用时自动执行，对应 func 返回值作为 mock 方法返回值

调用次数

AnyTimes(n int)

mock 方法可以被调用任意次数，一次不调用也不会失败（这里大家可以自检一下各自的单测代码，用这个方法的单测可能并没有按照预期运行）

Times()

mock 方法被调用次数，次数不相等运行失败

MaxTimes(n int)

mock 方法被调用次数，大于规定次数运行失败

MinTimes(n int)

mock 方法被调用次数，小于规定次数运行失败

调用排序

gomock.InOrder(

first.EXPECT.Func().Return(),

second.EXPECT.Func().Return(),

thrid.EXPECT.Func().Return(),

)

规定多个 mock 方法的调用顺序，顺序不符运行失败

first := rc.EXPECT().DoFucn()

second := rc.EXPECT().DoFunc().After(first)

规定多个 mock 方法的先后依赖关系，顺序不符运行失败

首先通过 mockgen 生成 Redis Client 的 mock 代码：

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

本地interface：
mockgen[go run -mod=mod github.com/golang/mock/mockgen -package mock] -source ~/go/pkg/mod/github.com/opentracing/opentracing-go\@v1.2.0/tracer.go -destination ./opentracing/tracer.go Tracer
远端interface：
go run -mod=mod github.com/golang/mock/mockgen -package redis -destination ./mock/redis/redis.go  github.com/go-redis/redis/v8 Cmdable

redis.go：

package main

import (
    "context"

    "github.com/go-redis/redis/v8"
)

func handleRedis(c redis.Cmdable) (string, error) {
    return c.Get(context.Background(), "redis").Result()
}

func conn() *redis.Client {
    return redis.NewClient(&redis.Options{Addr: "127.0.0.1:6379"})
}

package main

import (
    "testing"

    "github.com/go-redis/redis/v8"
    "github.com/golang/mock/gomock"
)

func Test_handleRedis(t *testing.T) {
    ctl := gomock.NewController(t)
    defer ctl.Finish()

    c := NewMockCmdable(ctl)
    c.EXPECT().Get(gomock.Any(), gomock.Any()).Times(1).Return(redis.NewStringResult("redis", nil))

    handleRedis(c)
}

函数/方法打桩

假如我们依赖的其他人写的方法，并不是通过接口实现的，无法使用 gomock 时，可以用 gomonkey 进行打桩

包函数

常用函数：

• gomonkey.ApplyFunc()：单个包函数打桩
• gomonkey.ApplyFuncSeq()：连续多个包函数打桩

func.go

package main

func A() int {
    return B()
}

func AA() int {
    return B() + B()
}

func B() int {
    return 0
}

package main

import (
    "testing"

    "github.com/agiledragon/gomonkey/v2"
    "github.com/stretchr/testify/assert"
)

// TestA 函数，单次打桩
func TestA(t *testing.T) {
    patch := gomonkey.ApplyFunc(B, func() int {
        return 1
    })
    defer patch.Reset()

    assert.Equal(t, 1, A())
}

// TestAA 函数，连续打桩
func TestAA(t *testing.T) {
    patch := gomonkey.ApplyFuncSeq(B, []gomonkey.OutputCell{
        {Values: gomonkey.Params{1}},
        {Values: gomonkey.Params{2}},
    })
    defer patch.Reset()

    assert.Equal(t, 3, AA())
}

成员方法

常用函数：

• gomonkey.ApplyMethod()：单个公有成员方法打桩
• patch.ApplyPrivateMethod()：单个私有成员方法打桩
• patch.ApplyMethodSeq()：连续多个公有成员方法打桩
• gomonkey.ApplyFuncSeq()：连续多个私有成员方法打桩

method.go

package main

type S struct{}

func (s *S) A() int {
    return s.B() + s.b()
}

func (s *S) AA() int {
    return s.B() + s.b() + s.B() + s.b()
}

func (s *S) B() int {
    return 0
}

func (s *S) b() int {
    return 0
}

package main

import (
    "reflect"
    "testing"

    "github.com/agiledragon/gomonkey/v2"
    "github.com/stretchr/testify/assert"
)

// TestS_AA 成员方法单个打桩
func TestS_A(t *testing.T) {
    s := &S{}

    // 公共成员方法
    patch := gomonkey.ApplyMethod(reflect.TypeOf(s), "B", func(_ *S) int {
        return 1
    })
    // 私有成员方法
    patch.ApplyPrivateMethod(reflect.TypeOf(s), "b", func(_ *S) int {
        return 2
    })
    defer patch.Reset()

    assert.Equal(t, 3, s.A())
}

// TestS_AA 成员方法连续打桩
func TestS_AA(t *testing.T) {
    s := &S{}

    // 私有成员方法
    patch := gomonkey.ApplyFuncSeq((*S).b, []gomonkey.OutputCell{
        {Values: gomonkey.Params{1}},
        {Values: gomonkey.Params{2}},
    })
    // 公共成员方法
    patch.ApplyMethodSeq(reflect.TypeOf(s), "B", []gomonkey.OutputCell{
        {Values: gomonkey.Params{1}},
        {Values: gomonkey.Params{2}},
    })
    defer patch.Reset()

    assert.Equal(t, 6, s.AA())
}

MySQL

sqlmock

db.go

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"

    _ "github.com/go-sql-driver/mysql"
    "github.com/jmoiron/sqlx"
)

const dsn = "root:123456@tcp(127.0.0.1:3306)/test"

type Test struct {
    ID      int64  `json:"id" db:"id" gorm:"column:id"`
    GoodsID int64  `json:"goodsID" db:"goods_id" gorm:"column:goods_id"`
    Name    string `json:"name" db:"name" gorm:"column:name"`
}

func (Test) TableName() string {
    return "test"
}

func handle(db *sql.DB) (err error) {
    tx, err := db.Begin()
    if err != nil {
        return
    }

    defer func() {
        switch err {
        case nil:
            err = tx.Commit()
        default:
            tx.Rollback()
        }
    }()

    rows, err := tx.Query("SELECT * from test where id > ?", 0)
    if err != nil {
        panic(err)
    }
    result := []Test{}
    if err = sqlx.StructScan(rows, &result); err != nil {
        panic(err)
    }

    b, err := json.Marshal(result)
    if err != nil {
        panic(err)
    }
    fmt.Println("sql:", string(b))

    if _, err = tx.Exec("UPDATE test SET goods_id = goods_id + 1 where id = 2"); err != nil {
        return
    }
    if _, err = tx.Exec("INSERT INTO test (goods_id, name) VALUES (?, ?)", 1, "1"); err != nil {
        return
    }
    return
}

func main() {
    db, err := sql.Open("mysql", dsn)
    if err != nil {
        panic(err)
    }
    defer db.Close()

    if err = handle(db); err != nil {
        panic(err)
    }
}

package main

import (
    "log"
    "os"
    "testing"
    "time"

    "github.com/DATA-DOG/go-sqlmock"
    _ "github.com/go-sql-driver/mysql"
    "github.com/stretchr/testify/assert"
)

func Test_handle(t *testing.T) {
    db, mock, err := sqlmock.New()
    if err != nil {
        panic(err)
    }

    mock.ExpectBegin()
    // (.+) 用于替代字段，可用于 select、order、group等
    mock.ExpectQuery("SELECT (.+) from test where id > ?").WillReturnRows(sqlmock.NewRows([]string{"id", "goods_id", "name"}).AddRow(1, 1, "1"))
    // sql前缀匹配
    mock.ExpectExec("UPDATE test SET goods_id").WillReturnResult(sqlmock.NewResult(1, 1))
    mock.ExpectExec("INSERT INTO test").WithArgs(1, "1").WillReturnResult(sqlmock.NewResult(1, 1))
    mock.ExpectCommit()

    if err = handle(db); err != nil {
        panic(err)
    }

    if err = mock.ExpectationsWereMet(); err != nil {
        panic(err)
    }
}

sqlite mock gorm

如果遇到如下错误：

/usr/local/go16/pkg/tool/linux_amd64/link: running gcc failed: exit status 1
/usr/bin/ld: /tmp/go-link-866330658/000020.o(.text+0x74): unresolvable H��@�>H��FH��H��H��@�~�F�H��@�~H��8�H��H��0�FH��H��(�FH��H�� �FH��H���FH��H���FH��H��F�fD relocation against symbol `stderr@@GLIBC_2.2.5'
/usr/bin/ld: BFD version 2.20.51.0.2-5.34.el6 20100205 internal error, aborting at reloc.c line 443 in bfd_get_reloc_size
/usr/bin/ld: Please report this bug.
collect2: ld returned 1 exit status

更新 go env gcc 版本：
go env -w CC=/opt/compiler/gcc-8.2/bin/gcc
go env -w CXX=/opt/compiler/gcc-8.2/bin/g++

或

CC=/opt/compiler/gcc-8.2/bin/gcc CXX=/opt/compiler/gcc-8.2/bin/g++ go test -c -cover 

db.go

package main

import (
    "database/sql"
    "encoding/json"
    "fmt"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

const dsn = "root:123456@tcp(127.0.0.1:3306)/test"

type Test struct {
    ID      int64  `json:"id" db:"id" gorm:"column:id"`
    GoodsID int64  `json:"goodsID" db:"goods_id" gorm:"column:goods_id"`
    Name    string `json:"name" db:"name" gorm:"column:name"`
}

func (Test) TableName() string {
    return "test"
}

func main() {
    orm, err := gorm.Open(mysql.Open(dsn))
    if err != nil {
        panic(err)
    }

    handleOrm(orm)
}

func handleOrm(orm *gorm.DB) {
    var rows []Test

    clause := func(db *gorm.DB) *gorm.DB {
        return db.Where("id >= ?", 1)
    }
    err := clause(orm.Select("*")).Find(&rows).Error
    if err != nil {
        panic(err)
    }

    b, err := json.Marshal(rows)
    if err != nil {
        panic(err)
    }
    fmt.Println("gorm", string(b))
}

package main

import (
    "log"
    "os"
    "testing"
    "time"

    "github.com/stretchr/testify/assert"
    "gorm.io/driver/sqlite"
    "gorm.io/gorm"
    "gorm.io/gorm/logger"
)

func Test_handleOrm(t *testing.T) {
    db := NewMemoryDB()
    err := db.Migrator().CreateTable(&Test{})
    assert.Nil(t, err)

    handleOrm(db)
}

func NewMemoryDB() *gorm.DB {
    var db *gorm.DB
    var err error
    newLogger := logger.New(
        log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
        logger.Config{
            SlowThreshold: time.Second, // 慢 SQL 阈值
            LogLevel:      logger.Info, // Log level
            Colorful:      false,       // 禁用彩色打印
        },
    )
    dialector := sqlite.Open(":memory:?cache=shared")
    if db, err = gorm.Open(dialector, &gorm.Config{
        Logger: newLogger,
    }); err != nil {
        panic(err)
    }
    dba, err := db.DB()
    dba.SetMaxOpenConns(1)
    return db
}

func CloseMemoryDB(db *gorm.DB) {
    sqlDB, _ := db.DB()
    sqlDB.Close()
}

http mock

http.go

package main

import (
    "fmt"
    "net/http"
    "time"
)

func Send() (err error) {
    req, err := http.NewRequest(http.MethodGet, "https://127.0.0.1:8080", nil)
    if err != nil {
        return
    }
    client := &http.Client{
        Timeout: time.Second,
    }
    resp, err := client.Do(req)
    if err != nil {
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return fmt.Errorf("HTTP status is %d", resp.StatusCode)
    }

    return
}

package main

import (
    "net/http"
    "testing"

    "github.com/jarcoal/httpmock"
    "github.com/smartystreets/goconvey/convey"
    "github.com/stretchr/testify/assert"
)

func TestSend(t *testing.T) {
    convey.Convey("TestSend", t, func() {
        convey.Convey("success", func() {
            httpmock.Activate()
            defer httpmock.DeactivateAndReset()
            httpmock.RegisterResponder(http.MethodGet, "https://127.0.0.1:8080", httpmock.NewStringResponder(http.StatusOK, ""))

            err := Send()
            assert.Nil(t, err)
        })
    })
}