男神鹏：golang 单侧测试框架

1.单元测试框架调研

 

名称	评分	特点
testing	golang 官方自带	不支持断言和 mock
gocheck	近几年无更新	基于testing，支持断言，setup,suit。
testify	start :10000+ 持续更新	基于testing，与gocheck 相似.suite包可以给每个测试用例进行前置操作和后置操作的功能（例如初始化和清空数据库）。
goconvey	start :5000+ 持续更新	直接集成go test; 可以管理和运行测试用例;提供了丰富的断言函数; 支持很多 Web 界面特性。
gomonkey	start :2000+ 持续更新	可以为全局变量、函数、过程、方法mock。
httpexpect	start :1400+ 持续更新	适用于对http的clent进行测试，对服务端的回包进行打桩;支持对不同方法（get，post，head等）的构造，支持自定义返回值json。
sqlmock	start :2600+ 持续更新	适用于和数据库的交互场景。可以创建模拟连接，编写原生sql 语句，编写返回值或者错误信息并判断执行结果和预设的返回值

2. 方案基本选型：testify + gomonkey; 附加 sqlmock

 

需要写单元测试的代码原则：

• 外部依赖少，代码又简单的代码。自然其成本和价值都是比较低的，可选；
• 外部依赖很少，业务复杂代码，最有价值写单元测试的。

testify：

 

testify基于gotesting编写，所以语法上、执行命令行与go test完全兼容。testify的 assert包提供了丰富的断言方法，避免testing的多层if else。此外提供了suite包，可以给每个测试用例进行前置操作和后置操作的功能，这个方便的功能，在前置操作和后置操作中去初始化和清空数据库。同时，还可以声明在这个测试用例周期内都有效的全局变量。

1. //安装testify
2. go get github.com/stretchr/testify
3. //更新testify
4. go get -u github.com/stretchr/testify

前提：

• 测试文件，以_test.go结尾，与被测文件放于相同目录
• 测试函数，函数名以Test开头，并且随后的第一个字符必须为大写字母或下划线，如：TestCategoryService_AddCategory
• 测试函数，参数为t testing.T；对于bench测试，参数为b testing.B

 

1.快速添加测试方法。右键方法，选择go to-test,生成test文件

2.给定对应case，使用assert 包中的方法添加断言，替换testing 的if else 判断。

assert 包还提供了更多断言方法

• assert 断言库
  require包提供了与assert包相同的全局函数，但它们不返回布尔结果，而是终止当前测试。

测试套件：

 

一种针对拥有多个实现的通用接口的测试，一个接口多个实现的时候不用重复的为特定版本书写测试。
前提：

1. 测试套件文件名必须以 test.go 结尾。例：abc_test.go
2. 文件中的函数以 Test，Benchmark，Example 开头。例子：TestAbc()，BenchmarkAbc(), ExampleAbc()。

1. func (s *SuiteType) SetUpSuite(c *C) - 在测试套件启动前执行一次
2. func (s *SuiteType) SetUpTest(c *C) - 在每个用例执行前执行一次
3. func (s *SuiteType) TearDownTest(c *C) - 在每个用例执行后执行一次
4. func (s *SuiteType) TearDownSuite(c *C) - - 在测试套件用例都执行完成

基本格式：以asm 项目 collaborative 为例：

1. 定义测试套件：

 

1. //定义测试套件
2. type CollaborativeCategoryTestSuite struct {
3. suite.Suite
4. //测试集需要用到的变量
5. baseCaller *collaborative.CallerInfo
6. //添加相关变量
7. addCategoryReq *collaborative.AddCategoryReq
8. addCategoryRsp *collaborative.AddCategoryRsp
9. agent *CollaborativeAgent
10. }

2. 定义测试入口：

 

1. //入口，正常的测试功能，将套件传递给suite.Run
2. func TestCollaborativeCategoryTestSuite(t *testing.T) {
3. suite.Run(t, new(CollaborativeCategoryTestSuite))
4. }

3. 测试套启动前初始化工作：SetUpSuite测试套件启动前执行一次，可做组件初始化和变量初始化,mock依赖调用的方法

1. //测试套件启动前执行一次，用到的变量和各种依赖组件的初始化
2. func (suite *CollaborativeCategoryTestSuite) SetupSuite() {
3. //agent 初始化
4. suite.agent, _ = NewCollaborativeAgent(c, m)
6. //参数初始化
7. suite.baseCaller = &collaborative.CallerInfo{
8. CorpID: 313380573584411862,
9. UserID: 312792371890801860,
10. Role: collaborative.CallerRole_Role_SP,
11. }
12. suite.addCategoryReq = &collaborative.AddCategoryReq{
13. BaseCaller: suite.baseCaller,
14. Category: &collaborative.Category{
15. Name: "lyricli1",
16. },
17. }
18. }

4.SetupTest也可以在每个用例执行前执行一次，这样就能在每个测试函数隐式调用。根据测试场景添加

1. func (suite *CollaborativeCategoryTestSuite) SetupTest() {
2. //将数据还原为初始状态，比如删除的数据之后的Expiry标志位还原,便于下次测试
3. err := suite.agent.dbagent.Db.Model(&_type.Category{}).Where("id = ? ",suite.getCategoryReq.ID).Update(map[string]interface{}{ "expiry": false}).Error
4. assert.NoError(suite.T(), err)
5. }

5. 下面是测试函数的例子

1. //测试 添加分类
2. func (suite *CollaborativeCategoryTestSuite) TestAddCategory() {
3. req :=&collaborative.AddCategoryReq{}
4. res :=&collaborative.AddCategoryRsp{}
5. req = suite.addCategoryReq
6. suite.agent.AddCategory(context.TODO(),req,res)
7. assert.Equal(suite.T(), int32(common.CodeSucc), res.ErrCode)
8. //也可以用suite.True()判断
9. suite.True(int32(common.CodeSucc)==res.ErrCode,"add fail")
10. }

6. TearDownSuite 的在测试套件用例都执行完成的时候执行。比如清空本次测试的数据。

1. //所有测试中使用的拆卸变量，测试完清空数据
2. func (suite *CollaborativeCategoryTestSuite) TearDownSuite() {
3. err := suite.agent.dbagent.Db.Debug().Exec("truncate TABLE categories;").Error
4. assert.NoError(suite.T(), err)
5. err = suite.agent.dbagent.Db.Debug().Exec("truncate TABLE category_sort_trees;").Error
6. assert.NoError(suite.T(), err)
7. }

注意：整个测试套件的执行顺序是 按照测试方法的名字的ASCII顺序来执行的，如果测试套件的执行想按照顺序去执行，那需要按照名字排序。

gomonkey：

 

gomonkey 是 golang 的一款打桩框架，目标是让用户在单元测试中低成本的完成打桩，从而将精力聚焦于业务功能的开发。使用思路，被测函数中需要使用的其他依赖函数，进行打桩处理。

gomonkey 支持的特性：（前四个比较常用）

• 支持为一个函数打一个桩
• 支持为一个函数打一个特定的桩序列
• 支持为一个成员方法打一个桩
• 支持为一个成员方法打一个特定的桩序列
• 支持为一个接口打一个桩
• 支持为一个接口打一个特定的桩序列
• 支持为一个函数变量打一个桩
• 支持为一个函数变量打一个特定的桩序列
• 支持为一个全局变量打一个桩

使用：

 

1. //安装 gomonkey
2. go get github.com/agiledragon/gomonkey

1. 函数打桩

 

gomonkey.ApplyFunc(target，double)
Patch是Monkey提供给用户用于函数打桩的API：

• 第一个参数是目标函数的函数名，target是被mock的目标函数。
• 第二个参数是桩函数的函数名，习惯用法是匿名函数或闭包，double是用户重写的函数
• 返回值是一个Patches对象指针，主要用于在测试结束时删除当前的补丁

1. // 一个简单的函数
2. func GetRecommendKey(module int) string {
3. return fmt.Sprintf("pserver_recommend_%d", module)
4. }
6. //函数打桩
7. patches :=gomonkey.ApplyFunc(GetRecommendKey, func(int) string {
8. return "aaa"
9. })
10. defer p.Reset()

2. 函数打序列桩

 

ApplyFuncSeq第一个参数是函数名，第二个参数是特定的桩序列参数。

1. //序列桩
2. key1 := "hello test"
3. key2 := "hello golang"
4. key3 := "hello gomonkey"
5. outputs := []gomonkey.OutputCell{
6. {Values: gomonkey.Params{key1}},// 模拟函数的第1次输出
7. {Values: gomonkey.Params{key2}},// 模拟函数的第2次输出
8. {Values: gomonkey.Params{key3}},// 模拟函数的第3次输出
9. }
10. patches :=gomonkey.ApplyFuncSeq(GetRecommendKey, outputs)
11. output := GetRecommendKey(1)
12. //第一次输出是否为指定的第一次打桩
13. assert.Equal(suite.T(),output,key1)
14. output = GetRecommendKey(2)
15. //第一次输出是否为指定的第二次打桩
16. assert.Equal(suite.T(),output,key2)

3.成员方法打桩

 

gomonkey.ApplyMethod(reflect.TypeOf(s), "target",double {mock方法实现})
s为目标变量，target为目标变量方法名，double为mock方法；同理double方法入参和出参需要和target方法保持一致。
这里注意，要被打桩的方式不能是私有方法，gomonkey通过反射是找不到的

• 在使用前，先要定义一个目标类的指针变量x
• 第一个参数是reflect.TypeOf(s)
• 第二个参数是字符串形式的函数名
• 返回值是一个Patches对象指针，主要用于在测试结束时删除当前的补丁

1. // 方法
2. func (u *CollaborativeAgent) NotifyServerStateChange(req *collaborative.ModifyServerStateReq) error {
3. logrus.Errorf("notifyServerStateChange req: %v", req)
4. if req == nil {
5. return nil
6. }
7. state := req.State
8. if state == collaborative.CollaborativeState_CS_Expired {
9. return mq.PublishServerStateChange(req)
10. } else {
11. return nil
12. }
13. }
15. //方法打桩
16. var s *CollaborativeAgent
17. p := gomonkey.ApplyMethod(reflect.TypeOf(s), "NotifyServerStateChange",
18. func(u *CollaborativeAgent, ctx context.Context, req *collaborative.ModifyServerStateReq) error {
19. return nil
20. })

4.成员方法打一个特定的序列桩

 

ApplyMethodSeq 第一个参数是目标类的指针变量的反射类型，第二个参数是字符串形式的方法名，第三参数是特定的桩序列参数。

1. key1 := errors.New("existed")
2. key2 := errors.New("not existed")
3. key3 := error(nil)
4. outputs := []gomonkey.OutputCell{
5. {Values: gomonkey.Params{key1}},// 模拟函数的第1次输出
6. {Values: gomonkey.Params{key2}},// 模拟函数的第2次输出
7. {Values: gomonkey.Params{key3}},// 模拟函数的第3次输出
8. }
9. var s *CollaborativeAgent
10. patches := gomonkey.ApplyMethodSeq(reflect.TypeOf(s), "NotifyServerStateChange", outputs)
11. output := suite.agent.NotifyServerStateChange(req)
12. //第一次输出是否为指定的第一次打桩
13. assert.Equal(suite.T(),output,key1)
14. output = suite.agent.NotifyServerStateChange(req)
15. //第一次输出是否为指定的第二次打桩
16. assert.Equal(suite.T(),output,key2)

以ApplyMethod 为例，一个简单的demo说明帮助理解gomonkey打桩：

其他的方法使用
FAQ：

1.要被mock的方式如果是私有方法，gomonkey通过反射是找不到的
在go1.6版本中可以成功打桩的首字母小写的方法，当go版本升级后Monkey框架会显式触发panic，首字母小写的方法或函数不是public的。如果在UT测试中对首字母小写的方法或函数打桩的话，会导致重构的成本比较大。

2.macOS 10.15 syscall.Mprotect panic: permission denied
gomonkey issue
解决方案
3.Gomonkey对inline函数打桩无效
解决：通过命令行参数-gcflags=-l禁止inline（ go test -gcflags=-l -v *_test.go -test.run 测试方法 ）

sqlmock

 

适用于和数据库的交互场景。可以创建模拟连接，编写原生sql 语句，编写返回值或者错误信息并判断执行结果和预设的返回值,提供了完整的事务的执行测试框架，支持prepare参数化提交和执行的Mock方案。

1. //安装
2. go get github.com/DATA-DOG/go-sqlmock

1.通过 Sqlmock 可以获取 sql.DB 和 mock 对象

 

1. db, mock, err := sqlmock.New()

2.以 MySQL 为例进行 mock：

 

1. gdb, err := gorm.Open("mysql", db)
2. //关联
3. dbAgent := &DBAgent{Db: gdb}

3.完整代码如下：

 

1. package data
3. import (
4. "git.code.oa.com/cloud_industry/asm/collaborative/type"
5. "github.com/DATA-DOG/go-sqlmock"
6. "github.com/jinzhu/gorm"
7. _ "github.com/jinzhu/gorm/dialects/mysql"
8. "github.com/stretchr/testify/assert"
9. "testing"
10. )
12. func TestDBAgent_GetCategory(t *testing.T) {
13. db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))
14. assert.Nil(t,err)
15. defer db.Close()
16. gdb, err := gorm.Open("mysql", db)
17. //关联
18. dbAgent := &DBAgent{Db: gdb}
20. category := &_type.Category{
21. Name:"aaa",
22. Description:"description",
23. ParentID:1,
24. Expiry:false,
25. Depth:1,
26. Disable:false,
27. }
28. rows := sqlmock.
29. NewRows([]string{"id","name", "description", "parent_id", "expiry", "depth","disable"}).
30. AddRow(category.ID,category.Name, category.Description, category.ParentID, category.Expiry, category.Depth, category.Disable)
32. sql := "SELECT * FROM `categories` WHERE `categories`.`deleted_at` IS NULL AND ((`categories`.`id` = 1) AND (expiry = false)) ORDER BY `categories`.`id` ASC LIMIT 1"
33. mock.ExpectQuery(sql).WillReturnRows(rows)
34. c, err := dbAgent.GetCategory(1)
35. assert.Nil(t,err)
36. assert.Equal(t,"aaa",c.Name)
37. }

 

指定查询的 SQL 语句，可以提供正则表达式，默认通过正则匹配。 WithArgs 指定 SQL 的参数， WillReturnRows 设置期待返回的查询结果。每次执行完 mock 用例，都需要执行 ExpectationsWereMet 来判断所有的 Sql mock 是否被满足。

其他的方法使用

FAQ：

could not match actual sql with expected regexp？
解决：

• 使用 regexp.QuoteMeta 方法转义SQL字符串中的所有正则表达式元字符。因此我们可以将 ExcectQuery 更改为 mock.ExpectQuery(regexp.QuoteMeta(sqlSelectAll)) 。
• 更改默认的SQL匹配器。创建模拟实例时，我们可以提供匹配器选项：sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual))

测试覆盖率

 

1. 执行代码覆盖率测试如下：

 

1. cd test.go文件所在目录
2. go test -cover
3. cd -

2.使用 -coverprofile 标志来指定输出的文件( -coverprofile 标志自动设置 -cover 来启用覆盖率分析)

 

1. go test -coverprofile=test_coverage.out
3. //可以要求 覆盖率 按函数分解
4. go tool cover -func=size_coverage.out

3.获取 覆盖率信息注释的源代码 的HTML展示。 该显示由 -html 标志调用：

 

1. go tool cover -html=test_coverage.out