手把手教你用Golang写单元测试，超全最佳实践来了！

想知道如何编写高质量、可维护的 Golang 单元测试吗？本文将手把手教你从入门到精通，掌握 Golang 单元测试的最佳实践。文章将深入讲解如何利用 `testing` 标准库进行测试，包括创建测试文件、编写测试函数、使用断言以及运行测试。同时，还将分享编写可维护测试的关键技巧，例如清晰命名、覆盖边界条件、避免重复代码以及使用表驱动测试。此外，文章还将介绍如何使用 `gomock` 框架 Mock 外部依赖，以及如何进行并发测试和 Benchmark 测试。最后，我们将学习如何使用代码覆盖率工具来评估测试的完整性。无论你是 Golang 新手还是经验丰富的开发者，都能从中受益，提升你的代码质量和测试效率。

Golang单元测试是用代码验证代码是否按预期工作，以发现bug、提高质量并支持重构。其核心解决方案依赖标准库testing，流程包括：1.创建以\_test.go结尾的测试文件；2.编写以Test开头、含*testing.T参数的测试函数；3.使用t.Errorf等方法进行断言；4.运行go test命令执行测试。为提升可维护性，应采用清晰命名、覆盖边界条件、减少重复代码、使用表驱动测试。对于外部依赖，可通过gomock框架定义接口、生成Mock对象、设置预期行为并注入测试代码中。并发测试可用sync.WaitGroup、chan及t.Parallel()实现并行控制。Benchmark测试以Benchmark开头，用*testing.B参数评估性能，通过go test -bench=.运行。代码覆盖率工具go test -coverprofile及go tool cover可分析测试覆盖情况，但覆盖率仅作参考指标。

Golang单元测试，简单来说，就是用代码来验证你的代码是否按照预期工作。它能帮你尽早发现bug，提高代码质量，并让你更有信心进行重构。

解决方案

Golang的单元测试非常方便，标准库testing已经提供了所有你需要的基础设施。一个基本的测试流程如下：

1. 创建测试文件： 对于你的my_module.go文件，创建一个对应的my_module_test.go文件。
2. 编写测试函数： 测试函数必须以Test开头，并且接收一个*testing.T类型的参数。
3. 使用断言： 使用t.Errorf、t.Fatalf等方法来报告测试失败。
4. 运行测试： 使用go test命令运行测试。

下面是一个简单的例子：

// my_module.go
package mymodule

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

// my_module_test.go
package mymodule

import "testing"

func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("Add(2, 3) = %d; want 5", result)
    }
}

运行 go test，如果一切正常，你会看到 "PASS"。

如何编写可维护的Golang单元测试？

编写可维护的单元测试，意味着你的测试不仅要能发现bug，还要易于理解、修改和扩展。可以试试以下几个技巧：

• 清晰的命名： 测试函数的名字应该清晰地描述它测试的内容。例如，TestAdd_PositiveNumbers 比 TestAdd 更好。
• 测试边界条件： 不要只测试正常情况，还要测试边界条件、错误情况和异常输入。
• 避免重复代码： 使用 helper 函数来减少测试代码中的重复。
• 使用表驱动测试： 对于类似的测试用例，可以使用表驱动测试来提高代码的可读性和可维护性。

下面是一个表驱动测试的例子：

func TestAdd(t *testing.T) {
    testCases := []struct {
        a, b     int
        expected int
    }{
        {2, 3, 5},
        {-1, 1, 0},
        {0, 0, 0},
        {10, -5, 5},
    }

    for _, tc := range testCases {
        result := Add(tc.a, tc.b)
        if result != tc.expected {
            t.Errorf("Add(%d, %d) = %d; want %d", tc.a, tc.b, result, tc.expected)
        }
    }
}

如何Mock外部依赖进行单元测试？

在单元测试中，我们希望隔离被测试的代码，避免受到外部依赖的影响。这时，就需要使用 Mock。Golang有很多Mock框架，例如gomock。

使用 gomock 的基本步骤：

1. 定义接口： 定义一个接口，描述外部依赖的行为。
2. 生成 Mock 对象： 使用 gomock 生成接口的 Mock 对象。
3. 设置 Mock 对象的预期行为： 使用 EXPECT() 方法设置 Mock 对象的预期行为和返回值。
4. 在测试中使用 Mock 对象： 将 Mock 对象注入到被测试的代码中。

例如，假设你的代码依赖于一个数据库连接：

// db.go
package db

type Database interface {
    Get(key string) (string, error)
}

// my_module.go
package mymodule

import "db"

type MyService struct {
    db db.Database
}

func (s *MyService) GetData(key string) (string, error) {
    return s.db.Get(key)
}

你可以这样 Mock 数据库连接：

// my_module_test.go
package mymodule

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

//go:generate mockgen -destination=mock_db.go -package=mymodule db Database

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

    mockDB := NewMockDatabase(ctrl)
    mockDB.EXPECT().Get("mykey").Return("myvalue", nil)

    service := &MyService{db: mockDB}
    result, err := service.GetData("mykey")

    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }

    if result != "myvalue" {
        t.Errorf("GetData() = %v, want myvalue", result)
    }
}

首先，需要安装 gomock: go install github.com/golang/mock/mockgen@v1.6.0。 然后，使用 go generate 命令生成 Mock 对象：go generate。

如何测试并发代码？

测试并发代码是一项挑战，因为它涉及到不确定性和竞态条件。Golang提供了一些工具来帮助你测试并发代码：

• sync.WaitGroup： 用于等待一组 Goroutine 完成。
• chan： 用于 Goroutine 之间的通信。
• testing.T.Parallel()： 允许并行运行测试用例。

一个简单的例子：

func TestParallel(t *testing.T) {
    testCases := []int{1, 2, 3, 4, 5}

    for _, tc := range testCases {
        tc := tc // Capture range variable
        t.Run(fmt.Sprintf("TestCase-%d", tc), func(t *testing.T) {
            t.Parallel() // Mark this test case as parallel

            // Simulate some work
            time.Sleep(time.Duration(tc) * time.Millisecond)
            fmt.Printf("Running test case: %d\n", tc)

            // Add your assertions here
        })
    }
}

注意，t.Parallel() 必须在每个并行运行的测试用例中调用。 另外，要小心共享变量，使用互斥锁或其他同步机制来避免竞态条件。

如何进行Benchmark测试？

Benchmark测试用于评估代码的性能。Golang的testing包也提供了Benchmark测试的支持。

Benchmark测试函数必须以Benchmark开头，并且接收一个*testing.B类型的参数。

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

运行Benchmark测试：go test -bench=.。 -bench=. 表示运行所有Benchmark测试。

Benchmark测试会运行多次，并报告每次操作的平均时间。

如何使用代码覆盖率工具？

代码覆盖率工具可以帮助你了解你的测试覆盖了多少代码。Golang提供了一个内置的代码覆盖率工具。

运行代码覆盖率：go test -coverprofile=coverage.out。

然后，可以使用go tool cover命令来分析覆盖率结果：

• go tool cover -html=coverage.out：生成一个HTML报告，显示哪些代码被覆盖了，哪些代码没有被覆盖。
• go tool cover -func=coverage.out：显示每个函数的覆盖率。

代码覆盖率只是一个指标，不能完全保证代码的质量。但是，它可以帮助你发现测试的盲点，并提高代码的可靠性。

好了，本文到此结束，带大家了解了《手把手教你用Golang写单元测试，超全最佳实践来了！》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！