--- tags: - Go - golang - go单测 - 单元测试 --- # Go单元测试 ## 1. 什么是单元测试 单元测试是软件开发中的一种测试方法，旨在验证代码中最小可测试单元（如函数、方法、类）的行为是否符合预期，它是开发流程的重要组成部分。单元测试的目标是发现代码中的缺陷和错误，并确保代码的正确性和稳定性。 Go语言中自带有一个轻量级的测试框架testing和自带的go test命令来实现单元测试和性能测试。在包目录内，以\_test.go为后缀名的源文件都是go test的一部分，而不是go build的构建部分。 ## 2. Go单元测试命名规范 1. 在 Go 中，测试文件的命名规则非常重要。测试文件**必须以 `_test.go` 结尾**，否则 Go 的测试框架在执行时将不会识别这些文件。 举个例子，如果你的主程序文件名是 `hello.go`，那么对应的测试文件应命名为 `hello_test.go`。 注意： * 测试方法名以`Test`开头，参数要用`testing` ，例如`func TestXxx(t *testing.T)` * 在测试的时候通过`go test`命令进行测试 ## 3. Go语言的测试框架 Go语言有以下几种常见的测试框架： | 测试框架 | 推荐指数 | | ------------ | ----- | | Go原生testing包 | ★★★☆☆ | | GoConvey | ★★★★★ | | testify | ★★★☆☆ | 从测试用例编写的复杂度来看：testify比GoConvey简单；GoConvey比Go自带的testing包简单。然而在测试框架的选择上，我们更推荐使用GoConvey，主要原因有： * GoConvey与其他Stub/Mock框架的兼容性比Testify更好 * Testify虽然自带Mock功能，但需要手动编写Mock类；而GoMock可以一键自动生成这些重复的代码 接下来也会重点讲一下Go原生testing包的单测写法和GoConvey的主要用法 ## 4. Go自带的testing包 `testing`包为Go语言的package提供了自动化测试支持。通过`go test`命令，可以自动执行如下形式的任何函数： ```go func TestXxx(*testing.T) ``` 注意：`Xxx`可以是任何字母数字字符串，但第一个字母不能是小写字母。在这些测试函数中，可以使用`Error`、`Fail`等方法来指示测试失败。 要创建一个新的测试套件，需要创建一个名称以`_test.go`结尾的文件，该文件包含上述`TestXxx`函数。将该文件放在与被测试文件相同的包中。该文件会在正常的程序包构建中被排除，但在运行`go test`命令时会被包含。更多详情可执行`go help test`和`go help testflag`查看。 > 创建一个新的文件夹hello1，作为项目的根目录。在项目中根目录创建一个文件夹gotest，在gotest目录中创建一个example.go用于编写被测试代码，然后同样在gotest目录中创建一个example\_test.go，用于编写测试代码。后续的所有测试用例都是在此基础上进行 ### 4.1 基础示例 被测试代码： ```go package gotest func Factorial(n int) int { if n <= 0 { return 1 } return n * Factorial(n-1) } ``` 测试代码： ```go func TestFactorial(t *testing.T) { var ( input = 5 expected = 120 ) actual := Factorial(input) if actual != expected { t.Errorf("Factorial(%d) = %d; expected %d", input, actual, expected) } } ``` 在gotest目录下执行`go test .`，输出： ```go ➜ gotest go test . ok hello1/gotest 0.332s ``` 注意：➜ gotest表示是在gotest执行的后面的命令。上述当输入为`inut`时，结果实际结果`actual`和预期结果`expected`相等，表示测试通过。如果我们将`Factorial`函数修改为错误的实现： ```go func Factorial(n int) int { if n <= 0 { return 1 } return n * Factorial(n-2) // 错误的递归调用 } ``` 再执行`go test .`，将输出： ```go ➜ gotest go test . --- FAIL: TestFactorial (0.00s) example_test.go:12: Factorial(5) = 15; expected 120 FAIL FAIL hello1/gotest 0.334s FAIL ``` ### 4.2 Table-Driven测试 Table-Driven方式可以在同一个测试函数中测试多个用例，将`TestFactorial`函数改为最初正确的形式，再次测试 ```go func TestFactorial(t *testing.T) { var factorialTests = []struct { input int // 输入值 expected int // 预期结果 }{ {0, 1}, {1, 1}, {2, 2}, {3, 6}, {4, 24}, {5, 120}, {6, 720}, } for _, tt := range factorialTests { actual := Factorial(tt.input) if actual != tt.expected { t.Errorf("Factorial(%d) = %d; expected %d", tt.input, actual, tt.expected) } } } ``` 程序输出 ```go ➜ gotest go test . ok hello1/gotest 0.345s ``` Go自带testing包的更多用法可以参考[Go标准库文档](https://golang.org/pkg/testing/)。 ## 5. GoConvey GoConvey适用于编写单元测试用例，并且可以兼容到testing框架中。可以通过`go test`命令或使用`goconvey`命令访问`localhost:8080`的Web测试界面来查看测试结果。GoConvey的基本用法如下： ```go Convey("测试描述", t, func() { So(...) }) ``` GoConvey通常使用`So`函数进行断言，断言方式可以传入一个函数，或者使用内置的`ShouldBeNil`、`ShouldEqual`、`ShouldNotBeNil`等函数。 ### 5.1 基本示例 被测试代码： ```go package gotest func SlicesEqual(a, b []int) bool { if len(a) != len(b) { return false } if (a == nil) != (b == nil) { return false } for i, v := range a { if v != b[i] { return false } } return true } ``` 测试代码： ```go package gotest import ( . "github.com/smartystreets/goconvey/convey" "testing" ) func TestSlicesEqual(t *testing.T) { Convey("测试切片相等性函数", t, func() { a := []int{1, 2, 3, 4} b := []int{1, 2, 3, 4} So(SlicesEqual(a, b), ShouldBeTrue) // a和b相等，这个判定应该为true，如果确实相等，则单测绘PASS，否侧不通过 }) } ``` 这次我们不再使用`go test .`命令，而用`go test -v`命令来查看一下具体的单测执行详情 ```go ➜ gotest go test -v === RUN TestSlicesEqual 测试切片相等性函数 ✔ 1 total assertion --- PASS: TestSlicesEqual (0.00s) PASS ok hello1/gotest 0.231s ``` 总共执行了一个断言，测试结果跟我们预测的结果相同，a和b相等，这个判定应该为true，如果确实相等，则单测会PASS，否侧不通过。测试结果为PASS，表示通过。执行耗时为0.231s ### 5.2 嵌套测试 测试代码： ```go package gotest import ( . "github.com/smartystreets/goconvey/convey" "testing" ) func TestSlicesEqual(t *testing.T) { Convey("测试切片相等性函数", t, func() { Convey("当两个非空切片内容相同时", func() { a := []int{1, 2, 3, 4} b := []int{1, 2, 3, 4} So(SlicesEqual(a, b), ShouldBeTrue) }) Convey("当两个都是nil切片时", func() { So(SlicesEqual(nil, nil), ShouldBeTrue) }) Convey("当两个切片长度不同时", func() { a := []int{1, 2, 3} b := []int{1, 2, 3, 4} So(SlicesEqual(a, b), ShouldBeFalse) }) }) } ``` 测试结果： ```go ➜ gotest go test -v === RUN TestSlicesEqual 测试切片相等性函数 当两个非空切片内容相同时 ✔ 当两个都是nil切片时 ✔ 当两个切片长度不同时 ✔ 3 total assertions --- PASS: TestSlicesEqual (0.00s) PASS ok hello1/gotest 0.235s ``` 内层的Convey不需要再传入`t *testing.T`参数，这个例子测试了三种情况，当两个非空切片内容相同时，当两个都是nil切片时当两个切片长度不同时的预期情况和真实的代码测试情况，三种情况都是测试通过的 GoConvey的更多用法可以参考[官方文档](https://github.com/smartystreets/goconvey)。 ## 6. Stub/Mock框架 在单元测试中，我们往往需要**隔离外部依赖**（如数据库、网络、文件系统、第三方服务等），这时就会用到 **Stub** 和 **Mock** 框架。它们帮助我们**模拟依赖组件的行为**，让测试只聚焦于目标函数的逻辑本身。 ### 6.1 Stub 是什么？ **Stub（桩）** 是一种最基础的替代品，它通常是你手动实现的函数或对象，用来返回**固定的值或行为**。 假设你有一个函数 `GetUserName(id)`，会从数据库中查询用户姓名。但在测试中你不想真的连数据库： ```go func GetUserNameFromDB(id int) string { return "RealNameFromDB" // 真实实现，测试中不想调用 } func GetUserName(id int, dbFunc func(int) string) string { return dbFunc(id) } ``` 测试中则可以写一个 Stub： ```go func StubGetUserName(id int) string { return "StubUser" } func TestGetUserName(t *testing.T) { name := GetUserName(1, StubGetUserName) if name != "StubUser" { t.Fail() } } ``` **Stub的特点是简单、手动、只模拟"结果"。** ### 6.2 Mock 是什么？ **Mock（模拟）** 是一种更高级的替代品，通常配合框架使用（如：GoMock、Testify）。除了返回值，它还可以**验证调用过程**，比如： * 被调用了几次？ * 参数是否正确？ * 调用顺序对不对？ 比如同样，假设我们有一个函数 `GetUserName(id)`，它依赖一个数据库查询函数 `GetUser(id)`，我们想在测试中 mock 这个函数的行为。 ```go package main import ( "testing" . "github.com/smartystreets/goconvey/convey" "github.com/stretchr/testify/mock" ) type DBMock struct { mock.Mock } func (m *DBMock) GetUser(id int) string { args := m.Called(id) return args.String(0) } func GetUserName(id int, getUser func(int) string) string { return getUser(id) } func TestGetUserName(t *testing.T) { Convey("给定一个用户ID，应该返回对应的用户名", t, func() { db := new(DBMock) db.On("GetUser", 1).Return("MockUser") result := GetUserName(1, db.GetUser) So(result, ShouldEqual, "MockUser") // 验证 mock 调用是否正确 db.AssertExpectations(t) }) } ``` Golang有以下Stub/Mock框架： * GoStub * GoMock * Monkey 一般来说，GoConvey可以和GoStub、GoMock、Monkey中的一个或多个搭配使用。 ### 6.3 GoStub GoStub框架有多种使用场景： * 基本场景：为全局变量打桩 * 基本场景：为函数打桩 * 基本场景：为过程打桩 * 复合场景：由多个基本场景组合而成 #### 6.3.1 为全局变量打桩 假设在被测函数中使用了一个全局整型变量count，当前测试用例需要将count的值固定为150： ```go stubs := Stub(&count, 150) defer stubs.Reset() ``` stubs是GoStub框架函数接口Stub返回的对象，该对象有Reset方法可以将全局变量恢复为原值。 #### 6.3.2 为函数打桩 设我们的代码中有以下函数定义： ```go func Execute(cmd string, args ...string) (string, error) { // 实际实现... } ``` 我们可以对Execute函数打桩，代码如下： ```go stubs := StubFunc(&Execute, "command-output", nil) defer stubs.Reset() ``` #### 6.3.3 为过程打桩 当函数没有返回值时，我们通常称之为过程。例如，一个资源清理函数： ```go func CleanupResources() { // 清理资源的代码... } ``` 我们对CleanupResources过程的打桩代码为： ```go stubs := StubFunc(&CleanupResources) defer stubs.Reset() ``` GoStub的更多用法可以参考[官方文档](https://github.com/prashantv/gostub)。 ### 6.4 GoMock GoMock是由Go官方开发维护的测试框架，提供了基于接口的Mock功能，能够与Go内置的testing包良好集成。GoMock包含两个主要部分：GoMock库和mockgen工具，其中GoMock库管理桩对象的生命周期，mockgen工具用于生成接口对应的Mock类源文件。 #### 6.4.1 定义接口 ```go package db type DataStore interface { Create(key string, value []byte) error Retrieve(key string) ([]byte, error) Update(key string, value []byte) error Delete(key string) error } ``` #### 6.4.2 生成Mock类文件 mockgen工具有两种操作模式：源文件模式和反射模式。 1. 源文件模式通过包含接口定义的文件生成Mock类： ```go mockgen -source=datastore.go [其他选项] ``` * 反射模式通过构建程序并使用反射理解接口生成Mock类： ```go mockgen database/sql/driver Conn,Driver ``` 生成的mock\_datastore.go文件内容大致如下： ```go // 自动生成的代码 - 请勿手动修改! // Source: db (interfaces: DataStore) package mock_db import ( gomock "github.com/golang/mock/gomock" ) // MockDataStore 是DataStore接口的模拟实现 type MockDataStore struct { ctrl *gomock.Controller recorder *MockDataStoreMockRecorder } // MockDataStoreMockRecorder 是MockDataStore的记录器 type MockDataStoreMockRecorder struct { mock *MockDataStore } // NewMockDataStore 创建一个新的模拟实例 func NewMockDataStore(ctrl *gomock.Controller) *MockDataStore { mock := &MockDataStore{ctrl: ctrl} mock.recorder = &MockDataStoreMockRecorder{mock} return mock } // EXPECT 返回一个对象，允许调用者指示预期的用法 func (_m *MockDataStore) EXPECT() *MockDataStoreMockRecorder { return _m.recorder } // Create 模拟基础方法 func (_m *MockDataStore) Create(_param0 string, _param1 []byte) error { ret := _m.ctrl.Call(_m, "Create", _param0, _param1) ret0, _ := ret[0].(error) return ret0 } // ... 其他方法实现 ``` #### 6.4.3 使用Mock对象进行测试 1. 导入相关包 ```go import ( "testing" . "github.com/golang/mock/gomock" "myapp/mock/db" // 其他导入... ) ``` * 创建Mock控制器 Mock控制器通过NewController接口生成，是Mock生态系统的顶层控制，它定义了Mock对象的作用域和生命周期，以及期望行为。 ```go ctrl := NewController(t) defer ctrl.Finish() ``` 创建Mock对象时需要注入控制器： ```go ctrl := NewController(t) defer ctrl.Finish() mockDB := mock_db.NewMockDataStore(ctrl) mockAPI := mock_api.NewMockHttpClient(ctrl) ``` * 定义Mock对象行为 假设有这样一个场景：首先尝试获取数据失败，然后创建数据成功，再次获取就能成功。这个场景的Mock行为设置如下： ```sql mockDB.EXPECT().Retrieve(Any()).Return(nil, errors.New("不存在")) mockDB.EXPECT().Create(Any(), Any()).Return(nil) mockDB.EXPECT().Retrieve(Any()).Return(dataBytes, nil) ``` 其中dataBytes是测试数据的序列化结果： ```go data := MyData{Field1: "value", Field2: 123} dataBytes, _ := json.Marshal(data) ``` 批量操作可以使用Times指定次数： ```go mockDB.EXPECT().Create(Any(), Any()).Return(nil).Times(5) ``` 多次获取不同数据时，需要设置多个行为： ```go mockDB.EXPECT().Retrieve(Any()).Return(dataBytes1, nil) mockDB.EXPECT().Retrieve(Any()).Return(dataBytes2, nil) mockDB.EXPECT().Retrieve(Any()).Return(dataBytes3, nil) ``` GoMock的更多用法可以参考[官方文档](https://github.com/golang/mock)。 ### 6.5 Monkey 前面我们已经了解到： * 全局变量可通过GoStub框架打桩 * 过程可通过GoStub框架打桩 * 函数可通过GoStub框架打桩 * 接口可通过GoMock框架打桩 但还有两个问题较难解决： 1. 方法（成员函数）无法通过GoStub框架打桩，特别是当代码的OO设计较多时 2. 通过GoStub框架打桩时，对产品代码有侵入性 Monkey是Go的一个猴子补丁（monkeypatching）框架，通过在运行时重写可执行文件，将待打桩函数或方法的实现重定向到桩实现。原理类似于热补丁技术。但需要注意的是，Monkey不是线程安全的，不应用于并发测试。 Monkey框架的使用场景： * 基本场景：为函数打桩 * 基本场景：为过程打桩 * 基本场景：为方法打桩 * 复合场景：由多个基本场景组合而成 * 特殊场景：桩中桩的案例 #### 6.5.1 为函数打桩 假设Execute是一个执行命令的函数： ```go func Execute(cmd string, args ...string) (string, error) { cmdPath, err := exec.LookPath(cmd) if err != nil { log.Printf("exec.LookPath err: %v, cmd: %s", err, cmd) return "", errors.New("command not found") } output, err := exec.Command(cmdPath, args...).CombinedOutput() if err != nil { log.Printf("exec.Command.CombinedOutput err: %v, cmd: %s", err, cmd) return "", errors.New("command execution failed") } log.Printf("CMD[%s]ARGS[%v]OUT[%s]", cmdPath, args, string(output)) return string(output), nil } ``` 使用Monkey打桩的代码： ```go import ( "testing" . "github.com/smartystreets/goconvey/convey" . "github.com/bouk/monkey" "myapp/utils" ) func TestExecute(t *testing.T) { Convey("测试命令执行", t, func() { Convey("成功执行", func() { expectedOutput := "command output" guard := Patch( utils.Execute, func(_ string, _ ...string) (string, error) { return expectedOutput, nil }) defer guard.Unpatch() output, err := utils.Execute("any", "any") So(output, ShouldEqual, expectedOutput) So(err, ShouldBeNil) }) }) } ``` `Patch`是`Monkey`提供的函数打桩API： 1. 第一个参数是目标函数 2. 第二个参数是桩函数，通常使用匿名函数或闭包 3. 返回值是PatchGuard对象指针，用于在测试结束时移除补丁 #### 6.5.2 为过程打桩 对于没有返回值的函数（过程），打桩代码如下： ```go guard := Patch(CleanupResources, func() { // 空实现或测试所需的行为 }) defer guard.Unpatch() ``` #### 6.5.3 为方法打桩 假设在分布式系统中，需要模拟从配置中心获取配置的行为： ```go type ConfigCenter struct { // 字段... } func (c *ConfigCenter) GetConfig(key string) (string, error) { // 实际实现... return "", nil } ``` 使用Monkey对方法打桩： ```go var cc *ConfigCenter guard := PatchInstanceMethod( reflect.TypeOf(cc), "GetConfig", func(_ *ConfigCenter, _ string) (string, error) { return "{\"feature\":\"enabled\",\"timeout\":30}", nil }) defer guard.Unpatch() ``` PatchInstanceMethod API是Monkey提供的方法打桩API： * 首先定义目标类的指针变量x * 第一个参数是reflect.TypeOf(x) * 第二个参数是方法名的字符串 * 第三个参数是替换方法 * 返回值是PatchGuard对象指针，用于移除补丁 Monkey的更多用法可以参考[官方文档](https://github.com/bouk/monkey)。 ## 7. Mock场景最佳实践 ### 7.1 实例函数Mock：Monkey。 Monkey框架可用于对依赖函数进行替换，完成针对当前模块的单元测试。 有如下例子，\`helper\`包是实际功能实现，\`mock\_helper\`包是用于mock的替代实现。 helper.go: ```go package helper import "fmt" func FormatSum(a, b int) string { return fmt.Sprintf("a:%v+b:%v", a, b) } type Calculator struct { } func (*Calculator) FormatResult(a, b int) string { return fmt.Sprintf("a:%v+b:%v", a, b) } ``` mock\_helper.go: ```go package mock_helper import ( "fmt" "myapp/helper" ) func FormatSum(a, b int) string { return fmt.Sprintf("a:%v+b:%v=%v", a, b, a+b) } // 对应helper包中的FormatResult func FormatResult(_ *helper.Calculator, a, b int) string { return fmt.Sprintf("a:%v+b:%v=%v", a, b, a+b) } ``` 测试代码： ```go func TestFormatting() { // 替换函数 monkey.Patch(helper.FormatSum, mock_helper.FormatSum) result := helper.FormatSum(1, 2) fmt.Println(result) monkey.UnpatchAll() // 解除所有替换 result = helper.FormatSum(1, 2) fmt.Println(result) } func TestMethodFormatting() { calc := &helper.Calculator{} // 参数1: 获取实例的反射类型, 参数2: 被替换的方法名, 参数3: 替换方法 monkey.PatchInstanceMethod(reflect.TypeOf(calc), "FormatResult", mock_helper.FormatResult) result := calc.FormatResult(1, 2) fmt.Println(result) monkey.UnpatchAll() // 解除所有替换 result = calc.FormatResult(1, 2) fmt.Println(result) } ``` ### 7.2 未实现函数Mock：GoMock 假设场景：`Company`（公司）和`Person`（人）之间的关系： 1. 公司可以举行会议 2. 公司内部的人实现了`Speaker`接口，拥有`SayHello`方法 若所有类都已实现，测试代码如下： ```go func TestCompany_Meeting(t *testing.T) { // 直接创建一个Person对象 speaker := NewPerson("小张", "工程师") company := NewCompany(speaker) t.Log(company.Meeting("张三", "实习生")) } ``` 但如果`Person`类尚未实现，可以通过GoMock模拟一个符合`Speaker`接口的对象 定义`Speaker.go`接口： ```go package domain type Speaker interface { SayHello(name, role string) (response string) } ``` 用`mockgen`命令生成Mock对象： ```go mockgen -source=Speaker.go -destination=mock_speaker.go -package=mock_domain ``` 测试代码： ```go func TestCompany_Meeting(t *testing.T) { // 创建Mock控制器 ctrl := gomock.NewController(t) // 创建Mock对象 speaker := mock_domain.NewMockSpeaker(ctrl) // 设置期望行为 speaker.EXPECT().SayHello(gomock.Eq("张三"), gomock.Eq("实习生")).Return( "你好，张三(角色：实习生)，欢迎加入公司会议。我是会议主持人。") // 将Mock对象传入测试对象 company := NewCompany(speaker) // 执行测试 t.Log(company.Meeting("张三", "实习生")) } ``` ### 7.3 系统内置函数Mock：Monkey 使用Monkey可以mock系统内置函数，例如json.Unmarshal： ```go monkey.Patch(json.Unmarshal, mockUnmarshal) func mockUnmarshal(b []byte, v interface{}) error { // 强制设置为指定值，无视输入 *(v.(*models.LoginMessage)) = models.LoginMessage{ UserID: 1, Username: "admin", Password: "admin", } return nil } ``` 取消替换： ```go monkey.Unpatch(json.Unmarshal) // 解除单个Patch monkey.UnpatchAll() // 解除所有Patch ``` ### 7.4 数据库行为Mock 使用sqlmock库模拟数据库操作： ```go func TestDatabaseQuery(t *testing.T) { db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual)) if err != nil { t.Fatalf("创建sqlmock失败: %v", err) } defer db.Close() // 模拟查询结果 rows := sqlmock.NewRows([]string{"id", "username"}). AddRow(1, "user1"). AddRow(2, "user2") // 设置期望的SQL查询 mock.ExpectQuery("SELECT id, username FROM users").WillReturnRows(rows) // 执行查询 result, err := db.Query("SELECT id, username FROM users") if err != nil { t.Fatalf("查询执行失败: %v", err) } defer result.Close() // 处理结果 var users []struct { ID int Username string } for result.Next() { var id int var username string result.Scan(&id, &username) users = append(users, struct { ID int Username string }{id, username}) t.Logf("查询结果: ID=%d, 用户名=%s", id, username) } if result.Err() != nil { t.Fatalf("结果处理错误: %v", result.Err()) } // 验证所有期望都已满足 if err := mock.ExpectationsWereMet(); err != nil { t.Errorf("有未满足的期望: %v", err) } } ``` ### 7.5 服务器行为Mock 使用net/http/httptest模拟HTTP服务器： ```go func TestHTTPRequest(t *testing.T) { // 创建处理器 handler := func(w http.ResponseWriter, r *http.Request) { io.WriteString(w, `{"status": "success", "data": {"message": "Hello World"}}`) } // 创建请求和响应记录器 req := httptest.NewRequest("GET", "/api/hello", nil) w := httptest.NewRecorder() // 处理请求 handler(w, req) // 获取响应 resp := w.Result() body, _ := ioutil.ReadAll(resp.Body) // 验证结果 t.Logf("状态码: %d", resp.StatusCode) t.Logf("内容类型: %s", resp.Header.Get("Content-Type")) t.Logf("响应体: %s", string(body)) // 可以进一步解析JSON并断言 var result struct { Status string `json:"status"` Data struct { Message string `json:"message"` } `json:"data"` } json.Unmarshal(body, &result) assert.Equal(t, "success", result.Status) assert.Equal(t, "Hello World", result.Data.Message) } ``` 对于涉及方法的情况，需要使用`PatchInstanceMethod`： ```go func TestHTTPClient(t *testing.T) { var client *http.Client // 替换http.Client的Do方法 monkey.PatchInstanceMethod(reflect.TypeOf(client), "Do", func(_ *http.Client, _ *http.Request) (*http.Response, error) { // 创建模拟响应 resp := &http.Response{ StatusCode: 200, Body: ioutil.NopCloser(bytes.NewBufferString(`{"result": "mocked response"}`)), Header: make(http.Header), } resp.Header.Set("Content-Type", "application/json") return resp, nil }) defer monkey.UnpatchAll() // 测试使用http.Client的函数 result, err := FetchData("https://api.example.com/data") assert.NoError(t, err) assert.Equal(t, "mocked response", result.Value) } ``` ## 8. 实战案例：消息通讯系统 ### 8.1 项目概览 假设该项目是一个具有用户登录、查看在线用户、私聊、群聊等功能的命令行通讯系统。项目分为Client和Server两个子模块，都采用Model-Controller(Processor)-View(Main)的架构进行功能划分。另外还有一个Common模块存放通用工具类和数据结构。 ```go ├─Client │ ├─main │ ├─model │ ├─processor │ └─utils ├─Common └─Server ├─main ├─model ├─processor └─utils ``` 测试目标：为核心功能模块编写单元测试，确保各模块功能的正确性、完整性和健壮性，并在代码变更后能快速验证。 单元测试应包括： * 模块接口测试：验证参数传递、处理和返回值 * 模块数据结构测试：确保局部数据在处理过程中的完整性和正确性 * 异常处理测试：验证各种异常情况下的错误处理是否合理 接口测试应全面考察参数合法性、必要性、参数间的冗余性，以及指针引用的正确性等。数据结构测试应关注临时存储在模块内的数据结构的正确性，因为局部数据结构往往是错误的根源。 异常处理测试应关注几种常见问题： 1. 错误信息提示不足 2. 异常未被处理 3. 错误信息与实际不符 4. 错误信息未能准确定位问题 在本案例中，假设Model层向服务层提供的接口较少，只有`WritePkg`和`ReadPkg`两个核心函数，服务层基于这些基础函数封装具体业务逻辑。由于涉及网络连接，需要编写桩函数进行测试。服务层涉及多个网络连接调用和数据库操作，同样需要Mock。 鉴于需要编写Mock和桩函数，我们使用`GoStub`和`Monkey`包来简化测试，只需要编写替代接口和Mock函数，就能在测试过程中替换系统函数或依赖模块。 ### 8.2 Model层与数据库测试 由于是单元测试，我们需要创建Mock数据库实例，测试CRUD操作的SQL语句执行： ```go const ( sqlSelect = "SELECT id, username FROM users" sqlDelete = "DELETE FROM users WHERE id > 100 AND id < 200" sqlUpdate = "UPDATE users SET status = 'active' WHERE id = 1" sqlInsert = "INSERT INTO users (id, username) VALUES (101, 'newuser')" ) func TestUserRepository(t *testing.T) { // 创建sqlmock数据库连接 db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherEqual)) if err != nil { t.Fatalf("创建sqlmock失败: %v", err) } defer db.Close() // 模拟查询结果 rows1 := sqlmock.NewRows([]string{"id", "username"}). AddRow(1, "admin"). AddRow(2, "user") rows2 := sqlmock.NewRows([]string{"id", "username"}). AddRow(101, "temp1"). AddRow(102, "temp2") rows3 := sqlmock.NewRows([]string{"id", "username"}). AddRow(1, "admin") rows4 := sqlmock.NewRows([]string{"id", "username"}). AddRow(101, "newuser") // 设置SQL执行预期 mock.ExpectQuery(sqlSelect).WillReturnRows(rows1) mock.ExpectQuery(sqlDelete).WillReturnRows(rows2) mock.ExpectQuery(sqlUpdate).WillReturnRows(rows3) mock.ExpectQuery(sqlInsert).WillReturnRows(rows4) // 测试用例 var tests = []struct{ querySql string expected interface{} }{ {sqlSelect, nil}, {sqlDelete, nil}, {sqlUpdate, nil}, {sqlInsert, nil}, } for _, test := range tests { // 执行查询 res, err := db.Query(test.querySql) assert.Equal(t, err, test.expected) // 验证无错误 // 处理结果 var users []struct { ID int Username string } for res.Next() { var id int var username string res.Scan(&id, &username) users = append(users, struct { ID int Username string }{id, username}) t.Logf("查询结果: ID=%d, 用户名=%s", id, username) } assert.Equal(t, res.Err(), test.expected) // 验证结果处理无错误 } } ``` ### 8.3 私聊功能测试 私聊功能涉及JSON编码和发送消息的底层操作（`WritePkg`函数），我们使用Monkey进行Mock： ```go func TestMessageSender_SendPrivateMessage(t *testing.T) { var conn net.Conn transfer := &utils.Transfer{ Conn: conn, } // Mock WritePkg方法 monkey.PatchInstanceMethod(reflect.TypeOf(transfer), "WritePkg", func(_ *utils.Transfer, _ []byte) error { return nil }) convey.Convey("测试发送私聊消息", t, func() { msg := &models.PrivateMessage{ From: "user1", To: "user2", Content: "你好！", } sender := &MessageSender{Transfer: transfer} err := sender.SendPrivateMessage(msg) convey.So(err, convey.ShouldBeNil) }) monkey.UnpatchAll() } ``` ### 8.4 登录功能测试 登录功能涉及服务器连接和数据处理，我们可以使用多种Mock技术结合测试： ```go func TestMessageSender_SendPrivateMessage(t *testing.T) { var conn net.Conn transfer := &utils.Transfer{ Conn: conn, } // Mock WritePkg方法 monkey.PatchInstanceMethod(reflect.TypeOf(transfer), "WritePkg", func(_ *utils.Transfer, _ []byte) error { return nil }) convey.Convey("测试发送私聊消息", t, func() { msg := &models.PrivateMessage{ From: "user1", To: "user2", Content: "你好！", } sender := &MessageSender{Transfer: transfer} err := sender.SendPrivateMessage(msg) convey.So(err, convey.ShouldBeNil) }) monkey.UnpatchAll() } ``` ### 4. 登录功能测试 登录功能涉及服务器连接和数据处理，我们可以使用多种Mock技术结合测试： ```go func mockJsonUnmarshal(b []byte, v interface{}) error { // 强制设置登录消息对象的值 *(v.(*models.LoginMessage)) = models.LoginMessage{ UserID: 1, Username: "admin", Password: "password123", } return nil } func mockJsonMarshal(v interface{}) ([]byte, error) { // 简化的JSON序列化，返回固定内容 return []byte(`{"status":"success"}`), nil } func TestUserProcessor_Login(t *testing.T) { // 创建测试消息 message := &models.Message{ Type: models.LoginMessageType, Data: "mock_login_data", } userProcessor := &UserProcessor{ Conn: nil, } // Mock系统函数 monkey.Patch(json.Unmarshal, mockJsonUnmarshal) monkey.Patch(json.Marshal, mockJsonMarshal) // Mock用户数据访问对象 var userDao *model.UserDao monkey.PatchInstanceMethod(reflect.TypeOf(userDao), "Login", func(_ *model.UserDao, _ int, _ string) (*models.User, error) { return &models.User{ UserID: 1, Username: "admin", Password: "password123", }, nil }) // Mock传输层 var transfer *utils.Transfer monkey.PatchInstanceMethod(reflect.TypeOf(transfer), "WritePkg", func(_ *utils.Transfer, _ []byte) error { return nil }) // 执行测试 convey.Convey("测试用户登录处理", t, func() { err := userProcessor.HandleLogin(message) convey.So(err, convey.ShouldBeNil) }) // 清理Mock monkey.UnpatchAll() } ``` ## 8.5 工具类测试 测试网络传输工具类： ```go func mockNetRead(conn net.Conn, _ []byte) (int, error) { // 模拟读取4字节数据 return 4, nil } func mockJsonMarshal(v interface{}) ([]byte, error) { return []byte{1, 2, 3, 4}, nil } func mockJsonUnmarshal(data []byte, v interface{}) error { return nil } func TestTransfer_ReadPackage(t *testing.T) { // Mock网络读取 monkey.Patch(net.Conn.Read, mockNetRead) monkey.Patch(json.Marshal, mockJsonMarshal) monkey.Patch(json.Unmarshal, mockJsonUnmarshal) // 创建测试服务器 listener, _ := net.Listen("tcp", "localhost:9999") defer listener.Close() // 创建客户端连接 go net.Dial("tcp", "localhost:9999") // 接受连接 var conn net.Conn for { conn, _ = listener.Accept() if conn != nil { break } } // 创建测试对象 transfer := &Transfer{ Conn: conn, Buf: [8096]byte{1, 2, 3, 4}, } // 执行测试 convey.Convey("测试数据包读取", t, func() { message, err := transfer.ReadPackage() convey.So(err, convey.ShouldBeNil) convey.So(message, convey.ShouldNotBeNil) }) // 清理Mock monkey.UnpatchAll() } func TestTransfer_WritePackage(t *testing.T) { // Mock JSON操作 monkey.Patch(json.Marshal, mockJsonMarshal) monkey.Patch(json.Unmarshal, mockJsonUnmarshal) // 创建测试对象 transfer := &Transfer{ Conn: nil, Buf: [8096]byte{}, } // 执行测试 convey.Convey("测试数据包写入", t, func() { err := transfer.WritePackage([]byte{1, 2}) convey.So(err, convey.ShouldBeNil) }) // 清理Mock monkey.UnpatchAll() } ``` 在编写单元测试的时候，推荐使用第三方包来完成，虽然原生包能满足基本需求，但不提供断言语法，导致要写大量重复的错误检查代码，因此引入convey和assert包简化判断逻辑，可以使代码更简洁易读 更多测试实践案例可参考： * [go-sqlmock](https://github.com/DATA-DOG/go-sqlmock) * [GoMock实践指南](https://github.com/golang/mock) ## 9. 基准测试 除了前面提到的单元测试，测试代码单元的正确性之外，Go语言还提供了基准测试框架，可以测试一段程序的性能、CPU消耗，可以对代码做性能分析，测试方法与单元测试类似。 基准测试规则： * 基准测试以Benchmark为前缀 * 需要一个\*testing.B类型的参数b * 基准测试必须要执行b.N次 常见的基准测试函数写法： ```go func BenchmarkTest(b *testing.B) { ... } ``` 执行基准测试时，需要添加`-bench`参数 ```go go test -bench="." ``` 下面通过一个模拟负载均衡的例子，来看下基准测试： 在gotest包下准备一个`Abs` 函数作为被测试的代码位于example.go，代码如下： ```go package gotest import "math" func Abs(x float64) float64 { return math.Abs(x) } ``` 然后在example\_test.go文件中为 `Abs` 函数编写的基准测试，代码如下： ```go package gotest func BenchmarkAbs(b *testing.B) { for i := 0; i < b.N; i++ { Abs(-1) } } ``` 注意基准测试的时候参数不再是 `*testing.T`，而是 `*testing.B`，在测试函数中，我们循环了 `b.N` 次调用 `Abs(-1)`，`b.N` 的值是一个动态值，我们无需操心，`testing` 框架会为其分配合理的值，以使测试函数运行足够多的次数，可以准确的计时。 默认情况下，执行 `go test` 命令时不会自动运行基准测试，需要显式指定 `-bench` 参数 ```go ➜ gotest go test -bench="." ... 3 total assertions goos: darwin goarch: arm64 pkg: hello1/gotest BenchmarkAbs-12 1000000000 0.2954 ns/op PASS ok hello1/gotest 1.513s ``` `-bench` 的参数接收一个正则表达式，`.` 匹配所有基准测试。重点看一下执行结果的这一行 ```go BenchmarkAbs-12 1000000000 0.2954 ns/op ``` `BenchmarkAbs-`12 中，`BenchmarkAbs` 是测试函数名，12 是 `GOMAXPROCS` 的值，即参与执行的 CPU 核心数。`1000000000` 表示测试执行了这么多次。`0.5096 ns/op` 表示每次循环平均消耗的纳秒数。 如果想查看基准测试的内存占用情况，可以通过 `-benchmem` 参数指定： ```bash ➜ gotest go test -bench="BenchmarkAbs$" -benchmem ... 3 total assertions goos: darwin goarch: arm64 pkg: hello1/gotest BenchmarkAbs-12 1000000000 0.2932 ns/op 0 B/op 0 allocs/op PASS ok hello1/gotest 0.683s ``` 可以发现，加上`-benchmem` 参数后，`BenchmarkAbs-8` 这行打印了更多输出内容： ```go BenchmarkAbs-12 1000000000 0.2932 ns/op 0 B/op ``` `0 B/op` 表示每次执行测试代码分配了多少字节内存。`0 allocs/op` 表示每次执行测试代码分配了多少次内存。 此外，在执行 `go test` 命令时，我们可以使用 `-benchtime=Ns` 参数指定基准测试函数执行时间为 `N` 秒： ```go ➜ gotest go test -bench="BenchmarkAbs$" -benchtime=0.1s ... 3 total assertions goos: darwin goarch: arm64 pkg: hello1/gotest BenchmarkAbs-12 385589265 0.3081 ns/op PASS ok hello1/gotest 0.686s ``` `-benchtime` 参数值为 `time.Duration` 类型支持的时间格式。此外，`-benchtime` 参数还有一个特殊语法 `-benchtime=Nx` 参数，可以指定基准测试函数执行次数为 `N` 次： ```go ➜ gotest go test -bench="BenchmarkAbs$" -benchtime=10x ... 3 total assertions goos: darwin goarch: arm64 pkg: hello1/gotest BenchmarkAbs-12 10 25.00 ns/op PASS ok hello1/gotest 0.466s ``` 有时在进行基准测试时，目标函数可能依赖一些预处理步骤，比如数据准备，这些数据准备的时间不应被计入函数本身的性能统计。这时候，我们可以调用 `(*testing.B).ResetTimer` 来重新开始计时，从而确保测试只衡量核心逻辑的执行时间。 ```go func BenchmarkAbsResetTimer(b *testing.B) { time.Sleep(100 * time.Millisecond) // 模拟数据准备阶段的耗时 b.ResetTimer() for i := 0; i < b.N; i++ { Abs(-1) } } ``` 这样，在调用 `b.ResetTimer()` 之前进行的耗时操作将不会被纳入最终的基准测试时间统计中。 另外，还有一种更灵活的做法是：先调用 `b.StopTimer()` 来暂停计时，等准备工作完成后，再通过 `b.StartTimer()` 恢复计时，这样也能避免将准备过程的耗时计算在内。 ```go func BenchmarkAbsStopTimerStartTimer(b *testing.B) { b.StopTimer() time.Sleep(100 * time.Millisecond) // 模拟数据准备阶段的耗时 b.StartTimer() for i := 0; i < b.N; i++ { Abs(-1) } } ``` 默认情况下，基准测试中的 `for` 循环是串行方式执行的。如果想要对被测代码进行并发性能测试，可以将其封装在 `(*testing.B).RunParallel` 方法中，实现并行调用 ```go func BenchmarkAbsParallel(b *testing.B) { b.RunParallel(func(pb *testing.PB) { for pb.Next() { Abs(-1) } }) } ``` 还可以使用 `(*testing.B).SetParallelism` 控制并发协程数： ```go func BenchmarkAbsParallel(b *testing.B) { b.SetParallelism(2) // 设置并发 Goroutines 数量为 2 * GOMAXPROCS b.RunParallel(func(pb *testing.PB) { for pb.Next() { Abs(-1) } }) } ``` 可以通过 `-cpu` 参数为 `go test` 指定 GOMAXPROCS 的值，用来控制使用的 CPU 核心数量。如果想了解更多 `go test` 支持的参数选项，可以执行命令 `go help testflag` 来获取完整的帮助信息。 ## 10. 小结 单元测试（Unit Test，简称 UT）是高质量软件项目中不可缺少的一个组成部分。它的核心目标是对程序中**最小的功能单位**进行验证，通常是一个函数或者方法，确保其行为符合预期。Go语言对单元测试提供了很好的支持，其自身就带有一个轻量级的测试框架testing，可以用自带的go test命令来实现单元测试和性能测试。同时也有非常多好用的第三方测试包，比如GoConvey，testify等，可以更加简洁的写测试用例。写好Go程序的单测，不仅仅可以确保代码的完整性和正确性，也是一个Gopher基本功的重要体现