go 测试基本知识

在 go 语言中编写测试用例非常简单，只需要在测试文件中导入 testing 包，然后编写测试函数即可：

1. 测试文件的命名规则是 xxx_test.go，其中 xxx 是被测试的文件名
2. 测试函数以 Test 开始，后面跟被测试的函数名，参数是 *testing.T，这个参数是用来报告测试失败的

比如说现在有一个文件 math.go，里面有一个函数 Add，那么我们就可以在同一个目录下创建一个 math_test.go 文件，然后在里面编写测试用例

math.go 代码如下

func Add(a, b int) (int, error) {
  return a + b, nil
}

math_test.go 代码如下

• 使用的断言库是 github.com/stretchr/testify/assert

func TestAdd(t *testing.T) {
  ret, err := Add(1, 2)
  assert.Nil(t, err, "err should be nil")
  assert.Equal(t, 3, ret, "1 + 2 should be 3")
}

然后运行测试用例，有 3 种方式：

1. 进入到有测试文件的目录下
   • 运行当前文件夹下的 xxx_test.go 文件

     go test -v .
     

2. 运行整个工程下面的所有测试文件

   go test -v ./...
   

3. 运行指定的测试函数

   go test -timeout 30s -run ^TestAdd$ demo/utils
   

子测试用例

子测试用是指在一个测试函数中，有多个测试用例，每个测试用例都是一个子测试用例，这样可以更好的组织测试用例

使用 t.Run 方法来创建子测试用例，第一个参数是子测试用例的名字，第二个参数是一个函数，这个函数就是子测试用例的测试函数，代码如下：

func TestAdd(t *testing.T) {
  t.Run("10 + 20", func(t *testing.T) {
    ret, err := Add(10, 20)
    assert.Nil(t, err, "err should be nil")
    assert.Equal(t, 30, ret, "10 + 20 should be 30")
  })

  t.Run("20 + 30", func(t *testing.T) {
    ret, err := Add(20, 30)
    assert.Nil(t, err, "err should be nil")
    assert.Equal(t, 50, ret, "20 + 30 should be 50")
  })
}

上面的代码可以进行优化，使用表格驱动测试，代码如下：

func TestAdd(t *testing.T) {
  tests := []struct {
    name     string
    input    []int
    expected int
  }{
    {"10 + 20", []int{10, 20}, 30},
    {"20 + 30", []int{20, 30}, 50},
  }

  for _, test := range tests {
    t.Run(test.name, func(t *testing.T) {
      ret, err := Add(test.input[0], test.input[1])
      assert.Nil(t, err, "err should be nil")
      assert.Equal(t, test.expected, ret, "10 + 20 should be 30")
    })
  }
}

并行执行

假如说 Add 函数是一个耗时的操作，我们同时测试多个 Add 函数，这样会导致测试用例的执行时间变长

math.go 代码如下:

func Add(a, b int) (int, error) {
  time.Sleep(5 * time.Second)
  return a + b, nil
}

当我们运行 TestAdd 测试用例时，会发现测试用例执行时间为 10s，这是因为一个 Add 函数执行需要 5s，而我们测试了两个 Add 函数

实际上这两个测试是可以并行执行的，我们可以使用 t.Parallel() 方法来让测试用例并行执行，math_test.go 修改后的代码如下：

func TestAdd(t *testing.T) {
  tests := []struct {
    name     string
    input    []int
    expected int
  }{
    {"10 + 20", []int{10, 20}, 30},
    {"20 + 30", []int{20, 30}, 50},
  }

  for _, test := range tests {
    t.Run(test.name, func(t *testing.T) {
      t.Parallel() // 并行执行
      ret, err := Add(test.input[0], test.input[1])
      assert.Nil(t, err, "err should be nil")
      assert.Equal(t, test.expected, ret, "10 + 20 should be 30")
    })
  }
}

这样测试用例的执行时间就会变为 5s，因为两个 Add 函数是并行执行的

跳过某个测试用例

有时候我们可能不想执行某个测试用例，可以使用 t.Skip 方法来跳过某个测试用例，代码如下：

func TestAdd(t *testing.T) {
  tests := []struct {
    name     string
    input    []int
    expected int
  }{
    {"10 + 20", []int{10, 20}, 30},
    {"20 + 30", []int{20, 30}, 50},
  }

  for _, test := range tests {
    t.Run(test.name, func(t *testing.T) {
      if test.name == "10 + 20" {
        t.Skip("skip 10 + 20") // 跳过 10 + 20 的测试用例
      }
      t.Parallel() // 并行执行
      ret, err := Add(test.input[0], test.input[1])
      assert.Nil(t, err, "err should be nil")
      assert.Equal(t, test.expected, ret, "10 + 20 should be 30")
    })
  }
}

testing.M

testing.M 是一个测试程序的驱动器，它可以用来控制测试用例的执行，比如说我们可以在测试用例执行前后做一些操作

在 TestMain 函数中，需要手动调用 t.Run() 方法来执行测试用例，如果不调用 t.Run() 方法，那么测试用例就不会执行

一般在 t.Run() 方法之前可以做一些资源的申请、配置的初始化，t.Run() 方法之后可以做一些资源的释放

math_test.go 代码如下：

func TestMain(t *testing.M) {
  // 资源的申请、配置的初始化
  os.Setenv("TEST", "1-----------444")
  t.Run()
  // 资源的释放
}

func TestAdd(t *testing.T) {
  t.Log(os.Getenv("TEST")) // 读取环境变量，值为：1-----------444
  tests := []struct {
    name     string
    input    []int
    expected int
  }{
    {"10 + 20", []int{10, 20}, 30},
    {"20 + 30", []int{20, 30}, 50},
  }

  for _, test := range tests {
    t.Run(test.name, func(t *testing.T) {
      if test.name == "10 + 20" {
        t.Skip("skip 10 + 20") // 跳过 10 + 20 的测试用例
      }
      t.Parallel() // 并行执行
      ret, err := Add(test.input[0], test.input[1])
      assert.Nil(t, err, "err should be nil")
      assert.Equal(t, test.expected, ret, "10 + 20 should be 30")
    })
  }
}

如果单独运行子测试用例，TestMain 函数也会被执行的，这是因为 TestMain 函数是在整个测试用例执行之前执行的