100. Go单测系列0---单元测试基础

文章目录

本文主要讲解在

Go

语言中如何编写单元测试以及介绍表格驱动测试、回归测试和单元测试中常用的断言工具。

一、Go语言测试

1. go test工具

Go

语言中的测试依赖

go test

命令。编写测试代码和编写普通的

Go

代码过程是类似的，并不需要学习新的语法、规则或工具。

go test

命令是一个按照一定约定和组织的测试代码的驱动程序。

在包目录内，所有以_test.go为后缀名的源代码文件都是go test测试的一部分，不会被go build编译到最终的可执行文件中。

在

*_test.go

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

go test

命令会遍历所有的

*_test.go

文件中符合上述命名规则的函数，然后生成一个临时的

main

包用于调用相应的测试函数，然后构建并运行、报告测试结果，最后清理测试中生成的临时文件。

2. 单元测试函数

格式
每个测试函数必须导入

testing

包，测试函数的基本格式（签名）如下：

funcTestName(t *testing.T){// ...}

测试函数的名字必须以

Test

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

funcTestAdd(t *testing.T){...}funcTestSum(t *testing.T){...}funcTestLog(t *testing.T){...}

其中参数

t

用于报告测试失败和附加的日志信息。

testing.T

的拥有的方法如下：

func(c *T)Cleanup(func())func(c *T)Error(args ...interface{})func(c *T)Errorf(format string, args ...interface{})func(c *T)Fail()func(c *T)FailNow()func(c *T)Failed()boolfunc(c *T)Fatal(args ...interface{})func(c *T)Fatalf(format string, args ...interface{})func(c *T)Helper()func(c *T)Log(args ...interface{})func(c *T)Logf(format string, args ...interface{})func(c *T)Name()stringfunc(c *T)Skip(args ...interface{})func(c *T)SkipNow()func(c *T)Skipf(format string, args ...interface{})func(c *T)Skipped()boolfunc(c *T)TempDir()string

3. 单元测试示例

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

接下来，我们在

base_demo

包中定义了一个

Split

函数，具体实现如下：

// base_demo/split.gopackage base_demo

import"strings"// Split 把字符串s按照给定的分隔符sep进行分割返回字符串切片funcSplit(s, sep string)(result []string){
    i := strings.Index(s, sep)for i >-1{
        result =append(result, s[:i])
        s = s[i+1:]
        i = strings.Index(s, sep)}
    result =append(result, s)return}

在当前目录下，我们创建一个

split_test.go

的测试文件，并定义一个测试函数如下：

// split/split_test.gopackage split

import("reflect""testing")funcTestSplit(t *testing.T){// 测试函数名必须以Test开头，必须接收一个*testing.T类型参数
    got :=Split("a:b:c",":")// 程序输出的结果
    want :=[]string{"a","b","c"}// 期望的结果if!reflect.DeepEqual(want, got){// 因为slice不能比较直接，借助反射包中的方法比较
        t.Errorf("expected:%v, got:%v", want, got)// 测试失败输出错误提示}}

在当前路径下执行

go test

命令，可以看到输出结果如下：

❯ go test
PASS
ok      golang-trick/45-go-test/base_demo       0.769s

go test -v

一个测试用例有点单薄，我们再编写一个测试使用多个字符切割字符串的例子，在

split_test.go

中添加如下测试函数：

funcTestSplitWithComplexSep(t *testing.T){
    got :=Split("abcd","bc")
    want :=[]string{"a","d"}if!reflect.DeepEqual(want, got){
        t.Errorf("expected:%v, got:%v", want, got)}}

现在我们有多个测试用例了，为了能更好的在输出结果中看到每个测试用例的执行情况，我们可以为

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-trick/45-go-test/base_demo 0.009s

从上面的输出结果我们能清楚的看到是

TestSplitWithComplexSep

这个测试用例没有测试通过。

go test -run
单元测试的结果表明

split

函数的实现并不可靠，没有考虑到传入的

sep

参数是多个字符的情况，下面我们来修复下这个

Bug

：

package base_demo

import"strings"// Split 把字符串s按照给定的分隔符sep进行分割返回字符串切片funcSplit(s, sep string)(result []string){
    i := strings.Index(s, sep)for i >-1{
        result =append(result, s[:i])
        s = s[i+len(sep):]// 这里使用len(sep)获取sep的长度
        i = strings.Index(s, sep)}
    result =append(result, s)return}

在执行

go test

命令的时候可以添加

-run

参数，它对应一个正则表达式，只有函数名匹配上的测试函数才会被

go test

命令执行。

例如通过给

go test

添加

-run=Sep

参数来告诉它本次测试只运行

TestSplitWithComplexSep

这个测试用例：

❯ go test -run=Sep -v
=== RUN   TestSplitWithComplexSep
--- PASS: TestSplitWithComplexSep (0.00s)
PASS
ok      golang-trick/45-go-test/base_demo 0.010s

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

Bug

。

回归测试

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

❯ go test -v
=== RUN   TestSplit
--- PASS: TestSplit (0.00s)=== RUN   TestSplitWithComplexSep
--- PASS: TestSplitWithComplexSep (0.00s)
PASS
ok      golang-trick/45-go-test/base_demo 0.011s

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

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

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

funcTestTimeConsuming(t *testing.T){if testing.Short(){
        t.Skip("short模式下会跳过该测试用例")}...}

当执行

go test -short

时就不会执行上面的

TestTimeConsuming

测试用例。

4. 子测试

在上面的示例中我们为每一个测试数据编写了一个测试函数，而通常单元测试中需要多组测试数据保证测试的效果。

Go1.7+

中新增了子测试，支持在测试函数中使用

t.Run

执行一组测试用例，这样就不需要为不同的测试数据定义多个测试函数了。

funcTestXXX(t *testing.T){
  t.Run("case1",func(t *testing.T){...})
  t.Run("case2",func(t *testing.T){...})
  t.Run("case3",func(t *testing.T){...})}

5. 表格驱动测试

介绍

表格驱动测试不是工具、包或其他任何东西，它只是编写更清晰测试的一种方式和视角。工作最为常见的代码单测实践

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

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

表格驱动测试的步骤通常是定义一个测试用例表格，然后遍历表格，并使用

t.Run

对每个条目执行必要的测试。

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

fmt

包中便有如下测试代码：

var flagtests =[]struct{
    in  string
    out string}{{"%a","[%a]"},{"%-a","[%-a]"},{"%+a","[%+a]"},{"%#a","[%#a]"},{"% a","[% a]"},{"%0a","[%0a]"},{"%1.2a","[%1.2a]"},{"%-1.2a","[%-1.2a]"},{"%+1.2a","[%+1.2a]"},{"%-+1.2a","[%+-1.2a]"},{"%-+1.2abc","[%+-1.2a]bc"},{"%-1.2abc","[%-1.2a]bc"},}funcTestFlagParser(t *testing.T){var flagprinter flagPrinter
    for_, tt :=range flagtests {
        t.Run(tt.in,func(t *testing.T){
            s :=Sprintf(tt.in,&flagprinter)if s != tt.out {
                t.Errorf("got %q, want %q", s, tt.out)}})}}

通常表格是匿名结构体切片，可以定义结构体或使用已经存在的结构进行结构体数组声明。

name

属性用来描述特定的测试用例。

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

funcTestSplitAll(t *testing.T){// 定义测试表格// 这里使用匿名结构体定义了若干个测试用例// 并且为每个测试用例设置了一个名称
    tests :=[]struct{
        name  string
        input string
        sep   string
        want  []string}{{"base case","a:b:c",":",[]string{"a","b","c"}},{"wrong sep","a:b:c",",",[]string{"a:b:c"}},{"more sep","abcd","bc",[]string{"a","d"}},{"leading sep","沙河有沙又有河","沙",[]string{"","河有","又有河"}},}// 遍历测试用例for_, tt :=range tests {
        t.Run(tt.name,func(t *testing.T){// 使用t.Run()执行子测试
            got :=Split(tt.input, tt.sep)if!reflect.DeepEqual(got, tt.want){
                t.Errorf("expected:%#v, got:%#v", tt.want, got)}})}}

在终端执行

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-trick/45-go-test/base_demo 0.010s

6. 并行测试

表格驱动测试中通常会定义比较多的测试用例，而

Go

语言又天生支持并发，所以很容易发挥自身并发优势将表格驱动测试并行化。 想要在单元测试过程中使用并行测试，可以像下面的代码示例中那样通过添加

t.Parallel()

来实现。

funcTestSplitAll(t *testing.T){
    t.Parallel()// 将 TLog 标记为能够与其他测试并行运行// 定义测试表格// 这里使用匿名结构体定义了若干个测试用例// 并且为每个测试用例设置了一个名称
    tests :=[]struct{
        name  string
        input string
        sep   string
        want  []string}{{"base case","a:b:c",":",[]string{"a","b","c"}},{"wrong sep","a:b:c",",",[]string{"a:b:c"}},{"more sep","abcd","bc",[]string{"a","d"}},{"leading sep","沙河有沙又有河","沙",[]string{"","河有","又有河"}},}// 遍历测试用例for_, tt :=range tests {
        tt := tt  // 注意这里重新声明tt变量（避免多个goroutine中使用了相同的变量）
        t.Run(tt.name,func(t *testing.T){// 使用t.Run()执行子测试
            t.Parallel()// 将每个测试用例标记为能够彼此并行运行
            got :=Split(tt.input, tt.sep)if!reflect.DeepEqual(got, tt.want){
                t.Errorf("expected:%#v, got:%#v", tt.want, got)}})}}

这样我们执行

go test -v

的时候就会看到每个测试用例并不是按照我们定义的顺序执行，而是互相并行了。

二、使用工具生成测试代码

社区里有很多自动生成表格驱动测试函数的工具，比如

gotests

等，很多编辑器如

Goland

也支持快速生成测试文件。这里简单演示一下

gotests

的使用。

安装

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

执行

gotests -all -w split.go

上面的命令表示，为

split.go

文件的所有函数生成测试代码至

split_test.go

文件（

目录下如果事先存在这个文件就不再生成

）。

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

package base_demo

import("reflect""testing")funcTestSplit(t *testing.T){type args struct{
        s   string
        sep string}
    tests :=[]struct{
        name       string
        args       args
        wantResult []string}{// TODO: Add test cases.}for_, tt :=range tests {
        t.Run(tt.name,func(t *testing.T){if gotResult :=Split(tt.args.s, tt.args.sep);!reflect.DeepEqual(gotResult, tt.wantResult){
                t.Errorf("Split() = %v, want %v", gotResult, tt.wantResult)}})}}

代码格式与我们上面的类似，只需要在

TODO

位置添加我们的测试逻辑就可以了。

三、测试覆盖率

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

80%

左右。

Go

提供内置功能来检查你的代码覆盖率，即使用

go test -cover

来查看测试覆盖率。

❯ go test -cover
PASS
coverage:100.0% of statements
ok      golang-trick/45-go-test/base_demo       0.623s

从上面的结果可以看到我们的测试用例覆盖了

100%

的代码。

Go

还提供了一个额外的

-coverprofile

参数，用来将覆盖率相关的记录信息输出到一个文件。例如：

❯ go test -cover -coverprofile=c.out
PASS
coverage:100.0% of statements
ok      golang-trick/45-go-test/base_demo 0.009s

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

c.out

文件中。

❯ tree ..
├── c.out
├── split.go
└── split_test.go

然后我们执行

go tool cover -html=c.out

，使用

cover

工具来处理生成的记录信息，该命令会打开本地的浏览器窗口生成一个

HTML

报告。

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

四、testify/assert

testify

是一个社区非常流行的

Go

单元测试工具包，其中使用最多的功能就是它提供的断言工具——testify/assert或testify/require(

工作中用的更多的还是后面要介绍的monkey和goconvey

)。

安装

go get github.com/stretchr/testify

使用示例

我们在写单元测试的时候，通常需要使用断言来校验测试结果，但是由于

Go

语言官方没有提供断言，所以我们会写出很多的

if...else...

语句。而

testify/assert

为我们提供了很多常用的断言函数，并且能够输出友好、易于阅读的错误描述信息。

比如我们之前在

TestSplit

测试函数中就使用了

reflect.DeepEqual

来判断期望结果与实际结果是否一致。

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

使用

testify/assert

之后就能将上述判断过程简化如下：

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

当我们有多个断言语句时，还可以使用

assert := assert.New(t)

创建一个

assert

对象，它拥有前面所有的断言方法，只是不需要再传入

Testing.T

参数了。

funcTestSomething(t *testing.T){
  assert := assert.New(t)// assert equality
  assert.Equal(123,123,"they should be equal")// assert inequality
  assert.NotEqual(123,456,"they should not be equal")// assert for nil (good for errors)
  assert.Nil(object)// assert for not nil (good when you expect something)if assert.NotNil(object){// now we know that object isn't nil, we are safe to make// further assertions without causing any errors
    assert.Equal("Something", object.Value)}}

testify/assert

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

testify/require

拥有

testify/assert

所有断言函数，它们的唯一区别就是——

testify/require

遇到失败的用例会立即终止本次测试。

此外，

testify

包还提供了

mock

、

http

等其他测试工具，篇幅所限这里就不详细介绍了，有兴趣的同学可以自己了解一下。

五、总结

本文介绍了

Go

语言单元测试的基本用法，通过为

Split

函数编写单元测试的真实案例，模拟了日常开发过程中的场景，一步一步详细介绍了表格驱动测试、回归测试和常用的断言工具

testify/assert

的使用。 在下一篇中，我们将更进一步，详细介绍如何使用

httptest

和

gock

工具进行网络测试。