GoLang 单元测试打桩和 mock

目录

什么是 mock

变量打桩

接口方法/Redis

函数/方法打桩

包函数

成员方法

MySQL

sqlmock

sqlite mock gorm

http 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 常用方法：

首先通过 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)
		})
	})
}