2023-08-20 02:36

关注

测试简化与加强： testify 与 gomock ｜青训

测试简化与加强： `testify` 与 `gomock` ｜青训营

go自带的测试使用

Go 自带了一个内置的测试框架，使得编写和运行测试变得非常方便。测试代码可以直接放在与被测试代码相同的包中，以 _test.go 结尾的文件名。以下是 Go 自带的测试框架的一些重要概念和用法：

测试函数命名规则：

在测试文件中，测试函数的命名必须以 Test 开头，并且接着是被测试函数的名称。测试函数应该接受一个 *testing.T 类型的参数，用于报告测试失败和输出错误消息。
```
func TestAdd(t *testing.T) {
    // 测试逻辑
}
```
测试运行：

运行测试可以使用 go test 命令。在包的根目录下执行该命令，Go 工具会自动查找和运行所有测试函数。
```
go test
```
断言：

Go 的内置测试框架没有提供丰富的断言函数，但您可以使用标准库的 testing 包来进行简单的断言。例如，使用 t.Error 或 t.Errorf 报告测试失败，使用 t.Log 记录日志信息。
```
if result != expected {
    t.Errorf("Expected %d, but got %d", expected, result)
}
```

子测试：

您可以通过创建多个测试函数来对不同的测试场景进行测试，但有时候更好的做法是使用子测试。在一个测试函数内部，通过调用 t.Run 来创建子测试。

func TestMyFunction(t *testing.T) {
    t.Run("Case1", func(t *testing.T) {
        // 测试 Case1 的逻辑
    })
    
    t.Run("Case2", func(t *testing.T) {
        // 测试 Case2 的逻辑
    })
}

基准测试：

除了功能测试，Go 的测试框架还支持基准测试。基准测试用于测量代码在一定工作负载下的性能。基准测试函数的名称以 Benchmark 开头，接着是被测试的函数名。
```
func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}
```
运行基准测试时，使用 go test -bench 命令：
```
go test -bench .
```

Go 的内置测试框架虽然相对简单，但对于更高级的测试需求，您可能会考虑使用第三方测试库，如 testify 或 gomock。

在软件开发过程中，测试是确保代码质量和可靠性的关键步骤之一。为了简化和增强测试的编写与执行，社区开发了许多优秀的测试工具和框架。其中的佼佼者就是 testify 和 gomock，它们是 Go 语言中受欢迎的测试工具库。本教程将引导您如何使用 testify 和 gomock来编写更干净、更可读且更强大的测试用例。

什么是 `testify`？

testify 是一个用于编写测试的工具库，它提供了一组用于编写和组织测试用例的函数和工具。该库的目标是使测试代码更加干净、可读和模块化，从而提高测试用例的质量和可维护性。

在本教程中，我们将介绍 testify 的两个子库：assert 和 mock。

assert 子库提供了一组断言函数，用于验证代码的预期行为是否符合实际情况。
mock 子库允许您创建和管理模拟对象，以便更轻松地模拟和测试依赖项。

安装 `testify`

首先，您需要在项目中添加 testify 作为依赖。您可以使用以下命令将 testify 安装到您的 Go 项目中：

go get github.com/stretchr/testify

使用 `assert` 进行断言

assert 子库使断言更容易。以下是一些常见的断言函数示例：

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func Add(a, b int) int {
	return a + b
}
func TestAdd(t *testing.T) {
	result := Add(2, 3)
	assert.Equal(t, 5, result, "2 + 3 应该等于 5")
}

在上面的示例中，我们使用 assert.Equal 来验证 Add 函数的结果是否符合预期。

常用 assert 函数

在 testify 库的 assert 子库中，有许多用于断言的函数可以帮助您验证代码的预期行为是否符合实际情况。以下是一些常用的 assert 函数示例：

Equal：验证两个值是否相等。

assert.Equal(t, expectedValue, actualValue, "错误消息")

NotEqual：验证两个值是否不相等。

assert.NotEqual(t, unexpectedValue, actualValue, "错误消息")

True：验证表达式是否为真。

assert.True(t, someExpression, "错误消息")

False：验证表达式是否为假。

assert.False(t, someExpression, "错误消息")

Nil：验证值是否为 nil。

assert.Nil(t, nilValue, "错误消息")

NotNil：验证值是否不为 nil。

assert.NotNil(t, nonNilValue, "错误消息")

Zero：验证值是否为其类型的零值。

assert.Zero(t, zeroValue, "错误消息")

NotZero：验证值是否不为其类型的零值。

assert.NotZero(t, nonZeroValue, "错误消息")

NotEmpty：验证字符串、切片或映射是否不为空。

assert.NotEmpty(t, nonEmptyValue, "错误消息")

Contains：验证切片、字符串或映射是否包含特定元素或子字符串。

assert.Contains(t, collection, element, "错误消息")

Panics：验证代码是否引发了恐慌。

assert.Panics(t, func() { SomeFunctionThatShouldPanic() }, "错误消息")

NoError：验证函数调用是否未返回错误。

assert.NoError(t, someFunction(), "错误消息")

Error：验证函数调用是否返回了错误。

assert.Error(t, someFunction(), "错误消息")

这只是一小部分可用的断言函数示例。testify/assert 子库提供了更多的断言函数，可以根据您的需求进行选择。使用这些函数，您可以编写更加清晰和准确的测试用例，从而提高代码的可靠性和可维护性。

结论

testify 是一个强大的测试工具库，可以帮助您编写更好的测试用例并提高代码质量。在本教程中，我们介绍了如何使用 testify 的 assert 子库来进行断言。希望通过这个教程，您可以更轻松地进行测试驱动开发，并且编写出更稳定和可维护的代码。如有更多疑问，请查阅 testify 的官方文档以获取更多信息。

使用 `gomock` 进行mock测试

mockgen 是 Golang 中的一个工具，用于生成模拟（mock）代码，以便在单元测试中模拟依赖项的行为。它是在 github.com/golang/mock/gomock 包的基础上构建的，该包提供了控制模拟对象的功能。

通过使用 mockgen 工具和 gomock 包，您可以创建模拟对象并定义其预期行为，以便在测试中模拟外部依赖项的交互。以下是使用 mockgen 和 gomock 的一般步骤：

安装 mockgen 工具：

使用以下命令安装 mockgen 工具：
```
go get github.com/golang/mock/mockgen
```
创建接口：

在您的代码中，首先创建一个接口，该接口定义您要模拟的依赖项的方法。
```
package mypackage

type MyInterface interface {
    DoSomething() string
}
```
使用 mockgen 生成模拟代码：

使用 mockgen 工具生成模拟代码，以便实现您的接口。
```
mockgen -source=mypackage/myinterface.go -destination=mypackage/mock_myinterface/mock_myinterface.go -package=mock_myinterface
```
这将在 mypackage/mock_myinterface 目录中生成一个名为 mock_myinterface.go 的文件，其中包含了模拟代码。

编写测试用例：

在测试用例中，您可以使用 gomock 包来创建模拟对象并定义其预期行为。

package mypackage_test

import (
    "testing"
    "mypackage"
    "mypackage/mock_myinterface"
    "github.com/golang/mock/gomock"
)

func TestSomethingWithMock(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    mockObj := mock_myinterface.NewMockMyInterface(ctrl)
    mockObj.EXPECT().DoSomething().Return("mocked result")

    result := mypackage.SomethingWithDependency(mockObj)

    assert.Equal(t, "mocked result", result)
}

在上面的示例中，我们使用 NewMockMyInterface 创建了一个模拟对象，并使用 EXPECT() 定义了模拟对象的预期行为。

EXPECT() 常用函数

EXPECT() 的主要作用是创建一个期望的调用序列，用于模拟对象的方法。这样，您可以告诉模拟对象在测试中预期的调用顺序、参数和返回值。

以下是使用 EXPECT() 的一些示例：

基本用法：

在模拟对象上使用 EXPECT()，然后通过链式调用函数来定义预期的方法调用和返回值。
```
mockObj := mock_myinterface.NewMockMyInterface(ctrl)
mockObj.EXPECT().DoSomething().Return("mocked result")
```
参数匹配：

您可以使用参数匹配器来匹配预期的方法参数。mock的函数是 MethodWithArg()
```
mockObj.EXPECT().MethodWithArg(gomock.Eq(expectedArg)).Return("result")
```
在上面的示例中，gomock.Eq() 用于匹配预期的参数是否与 expectedArg 相等。

您也可以使用 gomock.Any() 匹配所有的参数。
```
mockObj.EXPECT().MethodWithArg(gomock.Any()).Return("result")
```
调用次数：

您可以使用 Times() 来指定预期方法的调用次数(不指定默认一次)。
```
mockObj.EXPECT().MethodCalledMultipleTimes().Return("result").Times(2)
```
上面的代码表示 MethodCalledMultipleTimes() 方法会被调用两次，并且每次都会返回 "result"。
任意次数：

您可以使用 AnyTimes() 来表示预期方法可以被任意次数调用。
```
mockObj.EXPECT().MethodCanBeCalledAnyTimes().Return("result").AnyTimes()
```
顺序调用：

如果您想要定义多个方法调用的顺序，可以使用 InOrder()。
```
gomock.InOrder(
    mockObj.EXPECT().FirstMethod().Return("first result"),
    mockObj.EXPECT().SecondMethod().Return("second result"),
)
```
上面的代码表示 FirstMethod() 必须在 SecondMethod() 之前被调用。