经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » Go语言 » 查看文章
Go语言单元测试基础从入门到放弃
来源：jb51　　时间：2022/6/21 16:40:56　　对本文有异议

Go语言测试

这是Go单测从入门到放弃系列教程的第0篇，主要讲解在Go语言中如何做单元测试以及介绍了表格驱动测试、回归测试，并且介绍了常用的断言工具。

go test工具

Go语言中的测试依赖go test命令。编写测试代码和编写普通的Go代码过程是类似的，并不需要学习新的语法、规则或工具。

go test命令是一个按照一定约定和组织的测试代码的驱动程序。在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件中。

在*_test.go文件中有三种类型的函数，单元测试函数、基准测试函数和示例函数。

类型格式作用
测试函数函数名前缀为Test测试程序的一些逻辑行为是否正确
基准函数函数名前缀为Benchmark测试函数的性能
示例函数函数名前缀为Example为文档提供示例文档

go test命令会遍历所有的*_test.go文件中符合上述命名规则的函数，然后生成一个临时的main包用于调用相应的测试函数，然后构建并运行、报告测试结果，最后清理测试中生成的临时文件。

单元测试函数

格式

每个测试函数必须导入testing包，测试函数的基本格式（签名）如下：

  1. func?TestName(t?*testing.T){
  2. ????//?...
  3. }

测试函数的名字必须以Test开头，可选的后缀名必须以大写字母开头，举几个例子：

  1. func?TestAdd(t?*testing.T){?...?}
  2. func?TestSum(t?*testing.T){?...?}
  3. func?TestLog(t?*testing.T){?...?}

其中参数t用于报告测试失败和附加的日志信息。testing.T的拥有的方法如下：

  1. func?(c?*T)?Cleanup(func())
  2. func?(c?*T)?Error(args?...interface{})
  3. func?(c?*T)?Errorf(format?string,?args?...interface{})
  4. func?(c?*T)?Fail()
  5. func?(c?*T)?FailNow()
  6. func?(c?*T)?Failed()?bool
  7. func?(c?*T)?Fatal(args?...interface{})
  8. func?(c?*T)?Fatalf(format?string,?args?...interface{})
  9. func?(c?*T)?Helper()
  10. func?(c?*T)?Log(args?...interface{})
  11. func?(c?*T)?Logf(format?string,?args?...interface{})
  12. func?(c?*T)?Name()?string
  13. func?(c?*T)?Skip(args?...interface{})
  14. func?(c?*T)?SkipNow()
  15. func?(c?*T)?Skipf(format?string,?args?...interface{})
  16. func?(c?*T)?Skipped()?bool
  17. func?(c?*T)?TempDir()?string

单元测试示例

就像细胞是构成我们身体的基本单位，一个软件程序也是由很多单元组件构成的。单元组件可以是函数、结构体、方法和最终用户可能依赖的任意东西。总之我们需要确保这些组件是能够正常运行的。单元测试是一些利用各种方法测试单元组件的程序，它会将结果与预期输出进行比较。

接下来，我们在base_demo包中定义了一个Split函数，具体实现如下：

  1. //?base_demo/split.go
  2. package?base_demo
  3. import?"strings"
  4. //?Split?把字符串s按照给定的分隔符sep进行分割返回字符串切片
  5. func?Split(s,?sep?string)?(result?[]string)?{
  6. ?i?:=?strings.Index(s,?sep)
  7. ?for?i?>?-1?{
  8. ??result?=?append(result,?s[:i])
  9. ??s?=?s[i+1:]
  10. ??i?=?strings.Index(s,?sep)
  11. ?}
  12. ?result?=?append(result,?s)
  13. ?return
  14. }

在当前目录下，我们创建一个split_test.go的测试文件，并定义一个测试函数如下：

  1. //?split/split_test.go
  2. package?split
  3. import?(
  4. ?"reflect"
  5. ?"testing"
  6. )
  7. func?TestSplit(t?*testing.T)?{?//?测试函数名必须以Test开头，必须接收一个*testing.T类型参数
  8. ?got?:=?Split("a:b:c",?":")?????????//?程序输出的结果
  9. ?want?:=?[]string{"a",?"b",?"c"}????//?期望的结果
  10. ?if?!reflect.DeepEqual(want,?got)?{?//?因为slice不能比较直接，借助反射包中的方法比较
  11. ??t.Errorf("expected:%v,?got:%v",?want,?got)?//?测试失败输出错误提示
  12. ?}
  13. }

此时split这个包中的文件如下：

  1. ??ls?-l
  2. total?16
  3. -rw-r--r--??1?liwenzhou??staff??408??4?29?15:50?split.go
  4. -rw-r--r--??1?liwenzhou??staff??466??4?29?16:04?split_test.go

在当前路径下执行go test命令，可以看到输出结果如下：

? go test
PASS
ok      golang-unit-test-demo/base_demo       0.005s

go test -v

一个测试用例有点单薄，我们再编写一个测试使用多个字符切割字符串的例子，在split_test.go中添加如下测试函数：

  1. func?TestSplitWithComplexSep(t?*testing.T)?{
  2. ?got?:=?Split("abcd",?"bc")
  3. ?want?:=?[]string{"a",?"d"}
  4. ?if?!reflect.DeepEqual(want,?got)?{
  5. ??t.Errorf("expected:%v,?got:%v",?want,?got)
  6. ?}
  7. }

现在我们有多个测试用例了，为了能更好的在输出结果中看到每个测试用例的执行情况，我们可以为go test命令添加-v参数，让它输出完整的测试结果。

? go test -v
=== RUN   TestSplit
--- PASS: TestSplit (0.00s)
=== RUN   TestSplitWithComplexSep
    split_test.go:20: expected:[a d], got:[a cd]
--- FAIL: TestSplitWithComplexSep (0.00s)
FAIL
exit status 1
FAIL    golang-unit-test-demo/base_demo 0.009s

从上面的输出结果我们能清楚的看到是TestSplitWithComplexSep这个测试用例没有测试通过。

go test -run

单元测试的结果表明split函数的实现并不可靠，没有考虑到传入的sep参数是多个字符的情况，下面我们来修复下这个Bug：

  1. package?base_demo
  2. import?"strings"
  3. //?Split?把字符串s按照给定的分隔符sep进行分割返回字符串切片
  4. func?Split(s,?sep?string)?(result?[]string)?{
  5. ?i?:=?strings.Index(s,?sep)
  6. ?for?i?>?-1?{
  7. ??result?=?append(result,?s[:i])
  8. ??s?=?s[i+len(sep):]?//?这里使用len(sep)获取sep的长度
  9. ??i?=?strings.Index(s,?sep)
  10. ?}
  11. ?result?=?append(result,?s)
  12. ?return
  13. }

在执行go test命令的时候可以添加-run参数，它对应一个正则表达式，只有函数名匹配上的测试函数才会被go test命令执行。

例如通过给go test添加-run=Sep参数来告诉它本次测试只运行TestSplitWithComplexSep这个测试用例：

  1. ??go?test?-run=Sep?-v
  2. ===?RUN???TestSplitWithComplexSep
  3. ---?PASS:?TestSplitWithComplexSep?(0.00s)
  4. PASS
  5. ok??????golang-unit-test-demo/base_demo?0.010s

最终的测试结果表情我们成功修复了之前的Bug。

回归测试

我们修改了代码之后仅仅执行那些失败的测试用例或新引入的测试用例是错误且危险的，正确的做法应该是完整运行所有的测试用例，保证不会因为修改代码而引入新的问题。

  1. ??go?test?-v
  2. ===?RUN???TestSplit
  3. ---?PASS:?TestSplit?(0.00s)
  4. ===?RUN???TestSplitWithComplexSep
  5. ---?PASS:?TestSplitWithComplexSep?(0.00s)
  6. PASS
  7. ok??????golang-unit-test-demo/base_demo?0.011s

测试结果表明我们的单元测试全部通过。

通过这个示例我们可以看到，有了单元测试就能够在代码改动后快速进行回归测试，极大地提高开发效率并保证代码的质量。

跳过某些测试用例

为了节省时间支持在单元测试时跳过某些耗时的测试用例。

  1. func?TestTimeConsuming(t?*testing.T)?{
  2. ????if?testing.Short()?{
  3. ????????t.Skip("short模式下会跳过该测试用例")
  4. ????}
  5. ????...
  6. }

当执行go test -short时就不会执行上面的TestTimeConsuming测试用例。

子测试

在上面的示例中我们为每一个测试数据编写了一个测试函数，而通常单元测试中需要多组测试数据保证测试的效果。Go1.7+ 中新增了子测试，支持在测试函数中使用t.Run执行一组测试用例，这样就不需要为不同的测试数据定义多个测试函数了。

  1. func?TestXXX(t?*testing.T){
  2. ??t.Run("case1",?func(t?*testing.T){...})
  3. ??t.Run("case2",?func(t?*testing.T){...})
  4. ??t.Run("case3",?func(t?*testing.T){...})
  5. }

表格驱动测试

介绍

编写好的测试并非易事，但在许多情况下，表格驱动测试可以涵盖很多方面：表格里的每一个条目都是一个完整的测试用例，包含输入和预期结果，有时还包含测试名称等附加信息，以使测试输出易于阅读。

使用表格驱动测试能够很方便的维护多个测试用例，避免在编写单元测试时频繁的复制粘贴。

表格驱动测试的步骤通常是定义一个测试用例表格，然后遍历表格，并使用t.Run对每个条目执行必要的测试。

表格驱动测试不是工具、包或其他任何东西，它只是编写更清晰测试的一种方式和视角。

示例

官方标准库中有很多表格驱动测试的示例，例如fmt包中的测试代码：

  1. var?flagtests?=?[]struct?{
  2. ?in??string
  3. ?out?string
  4. }{
  5. ?{"%a",?"[%a]"},
  6. ?{"%-a",?"[%-a]"},
  7. ?{"%+a",?"[%+a]"},
  8. ?{"%#a",?"[%#a]"},
  9. ?{"%?a",?"[%?a]"},
  10. ?{"%0a",?"[%0a]"},
  11. ?{"%1.2a",?"[%1.2a]"},
  12. ?{"%-1.2a",?"[%-1.2a]"},
  13. ?{"%+1.2a",?"[%+1.2a]"},
  14. ?{"%-+1.2a",?"[%+-1.2a]"},
  15. ?{"%-+1.2abc",?"[%+-1.2a]bc"},
  16. ?{"%-1.2abc",?"[%-1.2a]bc"},
  17. }
  18. func?TestFlagParser(t?*testing.T)?{
  19. ?var?flagprinter?flagPrinter
  20. ?for?_,?tt?:=?range?flagtests?{
  21. ??t.Run(tt.in,?func(t?*testing.T)?{
  22. ???s?:=?Sprintf(tt.in,?&flagprinter)
  23. ???if?s?!=?tt.out?{
  24. ????t.Errorf("got?%q,?want?%q",?s,?tt.out)
  25. ???}
  26. ??})
  27. ?}
  28. }

通常表格是匿名结构体数组切片，可以定义结构体或使用已经存在的结构进行结构体数组声明。name属性用来描述特定的测试用例。

接下来让我们试着自己编写表格驱动测试：

  1. func?TestSplitAll(t?*testing.T)?{
  2. ?//?定义测试表格
  3. ?//?这里使用匿名结构体定义了若干个测试用例
  4. ?//?并且为每个测试用例设置了一个名称
  5. ?tests?:=?[]struct?{
  6. ??name??string
  7. ??input?string
  8. ??sep???string
  9. ??want??[]string
  10. ?}{
  11. ??{"base?case",?"a:b:c",?":",?[]string{"a",?"b",?"c"}},
  12. ??{"wrong?sep",?"a:b:c",?",",?[]string{"a:b:c"}},
  13. ??{"more?sep",?"abcd",?"bc",?[]string{"a",?"d"}},
  14. ??{"leading?sep",?"沙河有沙又有河",?"沙",?[]string{"",?"河有",?"又有河"}},
  15. ?}
  16. ?//?遍历测试用例
  17. ?for?_,?tt?:=?range?tests?{
  18. ??t.Run(tt.name,?func(t?*testing.T)?{?//?使用t.Run()执行子测试
  19. ???got?:=?Split(tt.input,?tt.sep)
  20. ???if?!reflect.DeepEqual(got,?tt.want)?{
  21. ????t.Errorf("expected:%#v,?got:%#v",?tt.want,?got)
  22. ???}
  23. ??})
  24. ?}
  25. }

在终端执行go test -v，会得到如下测试输出结果：

? go test -v
=== RUN   TestSplit
--- PASS: TestSplit (0.00s)
=== RUN   TestSplitWithComplexSep
--- PASS: TestSplitWithComplexSep (0.00s)
=== RUN   TestSplitAll
=== RUN   TestSplitAll/base_case
=== RUN   TestSplitAll/wrong_sep
=== RUN   TestSplitAll/more_sep
=== RUN   TestSplitAll/leading_sep
--- PASS: TestSplitAll (0.00s)
    --- PASS: TestSplitAll/base_case (0.00s)
    --- PASS: TestSplitAll/wrong_sep (0.00s)
    --- PASS: TestSplitAll/more_sep (0.00s)
    --- PASS: TestSplitAll/leading_sep (0.00s)
PASS
ok      golang-unit-test-demo/base_demo 0.010s

并行测试

表格驱动测试中通常会定义比较多的测试case，在Go语言中很容易发挥自身并发优势将表格驱动测试并行化，可以查看下面的代码示例。

  1. func?TestSplitAll(t?*testing.T)?{
  2. ?t.Parallel()??//?将?TLog?标记为能够与其他测试并行运行
  3. ?//?定义测试表格
  4. ?//?这里使用匿名结构体定义了若干个测试用例
  5. ?//?并且为每个测试用例设置了一个名称
  6. ?tests?:=?[]struct?{
  7. ??name??string
  8. ??input?string
  9. ??sep???string
  10. ??want??[]string
  11. ?}{
  12. ??{"base?case",?"a:b:c",?":",?[]string{"a",?"b",?"c"}},
  13. ??{"wrong?sep",?"a:b:c",?",",?[]string{"a:b:c"}},
  14. ??{"more?sep",?"abcd",?"bc",?[]string{"a",?"d"}},
  15. ??{"leading?sep",?"沙河有沙又有河",?"沙",?[]string{"",?"河有",?"又有河"}},
  16. ?}
  17. ?//?遍历测试用例
  18. ?for?_,?tt?:=?range?tests?{
  19. ??tt?:=?tt??//?注意这里重新声明tt变量（避免多个goroutine中使用了相同的变量）
  20. ??t.Run(tt.name,?func(t?*testing.T)?{?//?使用t.Run()执行子测试
  21. ???t.Parallel()??//?将每个测试用例标记为能够彼此并行运行
  22. ???got?:=?Split(tt.input,?tt.sep)
  23. ???if?!reflect.DeepEqual(got,?tt.want)?{
  24. ????t.Errorf("expected:%#v,?got:%#v",?tt.want,?got)
  25. ???}
  26. ??})
  27. ?}
  28. }

使用工具生成测试代码

社区里有很多自动生成表格驱动测试函数的工具，比如gotests等，很多编辑器如Goland也支持快速生成测试文件。这里简单演示一下gotests的使用。

安装

  1. go?get?-u?github.com/cweill/gotests/...

执行

  1. gotests?-all?-w?split.go

上面的命令表示，为split.go文件的所有函数生成测试代码至split_test.go文件（目录下如果事先存在这个文件就不再生成）。

生成的测试代码大致如下：

  1. package?base_demo
  2. import?(
  3. ?"reflect"
  4. ?"testing"
  5. )
  6. func?TestSplit(t?*testing.T)?{
  7. ?type?args?struct?{
  8. ??s???string
  9. ??sep?string
  10. ?}
  11. ?tests?:=?[]struct?{
  12. ??name???????string
  13. ??args???????args
  14. ??wantResult?[]string
  15. ?}{
  16. ??//?TODO:?Add?test?cases.
  17. ?}
  18. ?for?_,?tt?:=?range?tests?{
  19. ??t.Run(tt.name,?func(t?*testing.T)?{
  20. ???if?gotResult?:=?Split(tt.args.s,?tt.args.sep);?!reflect.DeepEqual(gotResult,?tt.wantResult)?{
  21. ????t.Errorf("Split()?=?%v,?want?%v",?gotResult,?tt.wantResult)
  22. ???}
  23. ??})
  24. ?}
  25. }

代码格式与我们上面的类似，只需要在TODO位置添加我们的测试逻辑就可以了。

测试覆盖率

测试覆盖率是指代码被测试套件覆盖的百分比。通常我们使用的都是语句的覆盖率，也就是在测试中至少被运行一次的代码占总代码的比例。在公司内部一般会要求测试覆盖率达到80%左右。

Go提供内置功能来检查你的代码覆盖率。我们可以使用go test -cover来查看测试覆盖率。例如：

  1. ??go?test?-cover
  2. PASS
  3. coverage:?100.0%?of?statements
  4. ok??????golang-unit-test-demo/base_demo?0.009s

从上面的结果可以看到我们的测试用例覆盖了100%的代码。

Go还提供了一个额外的-coverprofile参数，用来将覆盖率相关的记录信息输出到一个文件。例如：

  1. ??go?test?-cover?-coverprofile=c.out
  2. PASS
  3. coverage:?100.0%?of?statements
  4. ok??????golang-unit-test-demo/base_demo?0.009s

上面的命令会将覆盖率相关的信息输出到当前文件夹下面的c.out文件中。

  1. ??tree?.
  2. .
  3. ├──?c.out
  4. ├──?split.go
  5. └──?split_test.go

然后我们执行go tool cover -html=c.out，使用cover工具来处理生成的记录信息，该命令会打开本地的浏览器窗口生成一个HTML报告。

上图中每个用绿色标记的语句块表示被覆盖了，而红色的表示没有被覆盖。

testify/assert

testify是一个社区非常流行的Go单元测试工具包，其中使用最多的功能就是它提供的断言工具——testify/assert或testify/require。

安装

  1. go?get?github.com/stretchr/testify

使用示例

我们在写单元测试的时候，通常需要使用断言来校验测试结果，但是由于Go语言中没有提供断言，所以我们会写出很多的if...else...语句。而testify/assert为我们提供了很多常用的断言函数，并且能够输出友好、易于阅读的错误描述信息。

比如我们之前在TestSplit测试函数中就使用了reflect.DeepEqual来判断期望结果与实际结果是否一致。

  1. t.Run(tt.name,?func(t?*testing.T)?{?//?使用t.Run()执行子测试
  2. ?got?:=?Split(tt.input,?tt.sep)
  3. ?if?!reflect.DeepEqual(got,?tt.want)?{
  4. ??t.Errorf("expected:%#v,?got:%#v",?tt.want,?got)
  5. ?}
  6. })

使用testify/assert之后就能将上述判断过程简化如下：

  1. t.Run(tt.name,?func(t?*testing.T)?{?//?使用t.Run()执行子测试
  2. ?got?:=?Split(tt.input,?tt.sep)
  3. ?assert.Equal(t,?got,?tt.want)??//?使用assert提供的断言函数
  4. })

当我们有多个断言语句时，还可以使用assert := assert.New(t)创建一个assert对象，它拥有前面所有的断言方法，只是不需要再传入Testing.T参数了。

  1. func?TestSomething(t?*testing.T)?{
  2. ??assert?:=?assert.New(t)
  3. ??//?assert?equality
  4. ??assert.Equal(123,?123,?"they?should?be?equal")
  5. ??//?assert?inequality
  6. ??assert.NotEqual(123,?456,?"they?should?not?be?equal")
  7. ??//?assert?for?nil?(good?for?errors)
  8. ??assert.Nil(object)
  9. ??//?assert?for?not?nil?(good?when?you?expect?something)
  10. ??if?assert.NotNil(object)?{
  11. ????//?now?we?know?that?object?isn't?nil,?we?are?safe?to?make
  12. ????//?further?assertions?without?causing?any?errors
  13. ????assert.Equal("Something",?object.Value)
  14. ??}
  15. }

testify/assert提供了非常多的断言函数，这里没办法一一列举出来，大家可以查看官方文档了解。

testify/require拥有testify/assert所有断言函数，它们的唯一区别就是——testify/require遇到失败的用例会立即终止本次测试。

此外，testify包还提供了mock、http等其他测试工具，篇幅所限这里就不详细介绍了，有兴趣的同学可以自己了解一下。

总结

本文介绍了Go语言单元测试的基本用法，通过为Split函数编写单元测试的真实案例，模拟了日常开发过程中的场景，一步一步详细介绍了表格驱动测试、回归测试和常用的断言工具testify/assert的使用。在下一篇中，我们将更进一步，详细介绍如何使用httptest和gock工具进行网络测试，更多关于Go语言单元测试基础的资料请关注w3xue其它相关文章！

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Go语言热门文章

  • Golang从文件服务器获取图片显示到客户端
  • 谈谈Go语言中的内存重排
  • Golang 模块引入及表格读写业务快速实现示例
  • 创建并使用https证书
  • golang的reflection（转）
  • TICK技术栈（一）TICK技术栈介绍
  • beego解读Cache之MemoryCache
  • go语言reflect包最佳实践之struct操作（遍历、赋值与方法调用）
  • golang中gin框架接入jwt使用token验证身份
  • Golang解析、验证、修改URL之Host、Port、Path

    • Go语言推荐文章

  • Go 互斥锁 Mutex 源码分析(二)
  • golang对遍历目录操作的优化
  • 美团VS饿了么，到底谁更胜一筹？
  • 解码 xsync 的 map 实现
  • [golang]在Gin框架中使用JWT鉴权
  • Golang 依赖注入设计哲学｜12.6K 🌟 的依赖注入库 wire
  • 这么简单的问题都不会，那还面试什么！？
  • golang select 和外层的 for 搭配
  • Go语言的100个错误使用场景（61-68）｜并发实践
  • 实战：如何优雅的从 Skywalking 切换到 OpenTelemetry

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号