golang web补充知识：单元测试

golang web补充知识：单元测试
文章目录
- golang 单元测试
  引言
  单元测试的重要性
  Go语言单元测试的优势
  
  Go语言单元测试基础
  testing包
  辅助测试函数
  运行单元测试
  
  Mock技术
  Mock简介
  GoMock框架介绍
  编写Mock代码
  使用Mock进行单元测试
  
  面向测试编程（TDD）
  TDD简介
  TDD的优势
  TDD的基本步骤
  Go语言中的TDD实践
golang 单元测试

 引言

在Go语言Web编程进阶中，我们使用到了单元测试的概念，来对编写的程序进行测试。单元测试是软件开发过程中的一种质量保证方法，它通过对软件中的最小可测试单元进行检查和验证，确保每个单元都能按照预期工作。

单元测试的重要性
- 提高代码质量：单元测试能够及时发现代码中的错误和缺陷，减少软件发布后出现问题的概率。
- 简化调试过程：当发现代码异常时，单元测试可以帮助开发者快速定位问题所在，减少调试时间。
- 促进代码重构：有了单元测试的保护，开发者可以更加自信地对代码进行重构，提高代码的可读性和可维护性。
- 文档化代码：单元测试可以看作是代码的一种文档形式，它展示了函数或方法预期的行为和功能。
- 支持持续集成：单元测试可以自动化运行，与持续集成工具结合使用，确保代码库的稳定性。
Go语言单元测试的优势

Go语言在设计时就非常注重简洁和高效，这同样体现在其单元测试的支持上。Go语言单元测试的优势有
- 内置测试框架：Go语言的标准库中包含了完整的测试框架，无需额外安装第三方库。
- 简洁的测试语法：Go语言的测试代码编写简单，易于理解，即使是初学者也能快速上手。
- 并行测试：Go语言的测试框架支持并行执行测试，提高测试效率。
- 测试覆盖率工具：Go语言提供了内置的测试覆盖率工具，可以方便地分析测试的全面性。
- 集成到标准工作流：Go语言的测试与构建、部署等环节紧密集成，支持统一的命令行操作。
- 社区支持：Go语言有着活跃的社区，提供了大量的文档、教程和工具，方便开发者学习和使用单元测试。
Go语言单元测试基础

testing包

在Go语言中，testing包是编写单元测试的基础。这个包提供了测试框架和断言函数，使得编写和运行测试变得非常简单。
- 测试函数
  
  在Go中，测试代码通常位于与被测试代码相同的包中，测试文件通常以_test.go结尾(如hello_test.go)。测试函数的命名规则是以Test开头，后跟被测试函数的名字，例如TestAdd用于测试Add函数。
```
func TestAdd(t *testing.T) {
    sum := Add(1, 2)
    if sum != 3 {
        t.Errorf("Add(1, 2) = %d; want 3", sum)
    }
}
```
  **说明：***testing.T是一个类型，它代表着一个测试的上下文。当一个测试函数被执行时，它会被传递给测试函数，以便测试函数可以使用它来报告测试的状态、记录日志、报告错误或者失败
- 测试组
  测试组允许你将相关的测试函数组合在一起，通常用于共享相同的设置代码
```
func TestGroup(t *testing.T) {
    tests := []struct {
        name string
        x    int
        y    int
        want int
    }{
        {"Positive", 1, 2, 3},
        {"Negative", -1, -1, -2},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := Add(tt.x, tt.y)
            if got != tt.want {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.x, tt.y, got, tt.want)
            }
        })
    }
}
```
  在这段代码中，我们定义了一个名为TestGroup的测试函数，它包含了一个结构体切片tests，这个切片包含了多个测试用例。每个测试用例都有一个名字（name）和对应的输入值（x和y）以及期望的输出值（want）。
  
  接着，我们遍历这个tests切片，并使用t.Run方法来执行每个测试用例。t.Run的第一个参数是子测试的名字，它将显示在测试输出中；第二个参数是一个函数，这个函数包含了实际的测试代码
  
  在t.Run的函数参数中，我们调用了Add函数，并将实际的结果（got）与期望的结果（tt.want）进行比较。如果它们不相等，我们使用t.Errorf来报告测试失败，并输出错误信息。
  
  通过这种方式，我们可以将一组相关的测试用例组织在一起，每个测试用例都可以独立运行，同时共享TestGroup函数中的设置代码。这使得测试更加模块化，易于管理和维护。
辅助测试函数

testing包中，测试辅助函数是一组用于在测试过程中报告状态、错误、日志等的方法。这些方法都是*testing.T类型的一部分，下面是一些常用的测试辅助函数及其例子
1. Error和Errorf
  
  Error和Errorf方法用于在测试中报告错误。它们会标记测试为失败，但不会停止测试的执行。
```
func TestAdd(t *testing.T) {
    sum := Add(1, 2)
    if sum != 3 {
        t.Error("Add(1, 2) failed") // 使用Error
    }
}

func TestSubtract(t *testing.T) {
    result := Subtract(5, 3)
    if result != 2 {
        t.Errorf("Subtract(5, 3) = %d; want 2", result) // 使用Errorf
    }
}
```
2. Fail和FailNow
  
  Fail方法用于标记测试为失败，但不提供错误信息。FailNow方法会立即停止当前测试的执行，并标记测试为失败
```
func TestFail(t *testing.T) {
    t.Fail() // 标记测试为失败，但继续执行
    // 更多代码...
}

func TestFailNow(t *testing.T) {
    t.FailNow() // 立即停止测试
    // 此行代码不会被执行
}
```
3. Fatal和Fatalf
  
  Fatal和Fatalf方法用于在测试中报告致命错误。它们会标记测试为失败，并立即停止测试的执行。
```
func TestFatal(t *testing.T) {
    if _, err := os.Stat("nonexistentfile"); err == nil {
        t.Fatal("os.Stat returned no error for nonexistent file") // 使用Fatal
    }
}

func TestFatalf(t *testing.T) {
    if _, err := os.Open("nonexistentfile"); err != nil {
        t.Fatalf("os.Open returned an error: %v", err) // 使用Fatalf
    }
}
```
4. Log和Logf
  
  Log和Logf方法用于记录测试日志。这些日志信息仅在详细输出时可见，不会影响测试的状态。
```
func TestLog(t *testing.T) {
    t.Log("This is a log message") // 使用Log
}

func TestLogf(t *testing.T) {
    t.Logf("This is a formatted log message: %v", 42) // 使用Logf
}
```
5. Skip和Skipf
  
  Skip和Skipf方法用于跳过当前测试。这些方法通常用于条件测试，当某些前提条件不满足时，可以跳过测试
```
func TestSkip(t *testing.T) {
    if os.Getenv("SKIP_TEST") == "true" {
        t.Skip("Skipping this test due to environment variable") // 使用Skip
    }
    // 测试代码...
}

func TestSkipf(t *testing.T) {
    if runtime.GOOS == "windows" {
        t.Skipf("Skipping this test on Windows") // 使用Skipf
    }
    // 测试代码...
}
```
运行单元测试

运行单元测试通常可以通过IDE工具或者命令行的方式来触发，下面展示一些运行的例子
1. IDE的以vscode为例子
  
  可以点击run test(直接运行)或者debug test(debug代码)的方式，来对测试代码进行验证
2. 命令行
  - 测试全部测试文件
    
    最基础的运行单元测试的方法是使用go test命令。在你的项目根目录或包含测试文件的目录下，运行以下命令
    
    go test
    
    这会编译并运行所有命名符合TestXXX格式的测试函数。
  - 测试单个文件
    
    go test -run TestFileName
    
    其中TestFileName是你的测试文件名（不包括.go扩展名）
  - 测试单个测试函数
    可以通过指定测试函数的全名来运行单个测试函数
    
    go test -run TestFunctionName
    
    这里TestFunctionName是你要运行的测试函数的名称
  - 并行运行测试
    如果你的测试是并行安全的，你可以使用-parallel标志来并行运行测试，以提高效率
    
    go test -parallel 4
    
    这里4是并行运行的测试数量。你可以根据你的CPU核心数来调整这个值。
  - 显示测试覆盖率
    可以使用-cover标志来查看测试覆盖率
    
    go test -cover
    
    这将输出每个包的测试覆盖率摘要
  - 输出详细信息
    如果你想看到更多的测试输出，可以使用-v标志
    
    go test -v
    
    这将显示每个测试函数的运行结果和日志信息。
  - 测试当前包
    如果你想测试当前包，而不管它是否是测试主包，可以使用-run标志和.模式
    
    go test -run .
通过这些命令和选项，你可以灵活地运行和管理你的Go语言单元测试

 Mock技术

Mock简介

Mock技术是在单元测试中用来模拟外部依赖项（如数据库、网络服务、文件系统等）的技术。在编写单元测试时，我们通常希望测试案例能够独立于外部系统，以便能够快速、可靠地运行测试，并确保测试结果只受被测试代码的影响。Mock技术允许我们创建模拟对象（mock objects），这些对象的行为和真实的外部依赖项相似，但在测试环境中是可控的。

其优势主要体现在
- 隔离测试：通过模拟外部依赖，我们可以确保测试只针对当前单元，而不是整个系统。
- 可重复性：Mock对象提供一致的行为，使得测试结果可预测和重复。
- 速度：Mock对象通常比真实的外部系统更快，可以加快测试执行速度。
- 安全性：Mock技术可以避免在测试过程中对真实数据库或服务进行不必要的操作，减少风险。
- 灵活性：可以模拟各种异常情况，测试边缘情况和错误处理逻辑。
Go中手动mock的示例

假设我们有一个简单的用户服务，该服务负责从数据库中获取用户信息。我们将使用Mock技术来模拟数据库服务，以便在不需要实际数据库的情况下测试用户服务

首先，我们定义一个数据库接口和它的实现：
```
// db/interface.go
package db

type User struct {
    ID   int
    Name string
}

type Database interface {
    GetUser(id int) (*User, error)
}
```
```
// db/mock_db.go
package db

type MockDB struct {
    data map[int]*User
}

func (m *MockDB) GetUser(id int) (*User, error) {
    user, ok := m.data[id]
    if !ok {
        return nil, fmt.Errorf("user not found")
    }
    return user, nil
}

func NewMockDB() *MockDB {
    return &MockDB{
        data: make(map[int]*User),
    }
}
```
现在，我们有一个用户服务，它使用这个数据库接口来获取用户信息：
```
// service/user_service.go
package service

import (
    "fmt"
    "myproject/db"
)

type UserService struct {
    db db.Database
}

func NewUserService(db db.Database) *UserService {
    return &UserService{
        db: db,
    }
}

func (us *UserService) GetUser(id int) (string, error) {
    user, err := us.db.GetUser(id)
    if err != nil {
        return "", err
    }
    return fmt.Sprintf("User: %s", user.Name), nil
}
```
最后，我们编写一个单元测试来测试UserService，使用Mock数据库代替真实的数据库：
```
// service/user_service_test.go
package service

import (
    "myproject/db"
    "testing"
)

func TestGetUser(t *testing.T) {
    // 创建Mock数据库
    mockDB := db.NewMockDB()

    // 设置Mock数据
    mockDB.data[1] = &db.User{
        ID:   1,
        Name: "John Doe",
    }

    // 创建UserService实例，注入Mock数据库
    userService := NewUserService(mockDB)

    // 调用GetUser方法
    name, err := userService.GetUser(1)

    // 断言结果
    if err != nil {
        t.Errorf("Expected no error, got %v", err)
    }
    if name != "User: John Doe" {
        t.Errorf("Expected name 'John Doe', got %s", name)
    }
}
```
在这个例子中，我们创建了一个MockDB实例，并设置了期望的数据。然后，我们创建了UserService实例，并将MockDB注入到其中。最后，我们调用了GetUser方法，并使用断言来验证结果是否符合预期

不过这样手动mock的方法比较冗长，也不好批量编写，我们可以用GoMock框架来轻松编写mock的单元测试

GoMock框架介绍

GoMock 是一个用于 Go 语言的开源 Mock 框架，它允许开发者创建 Mock 对象来模拟接口的行为。GoMock 是由 Go 社区维护的，并且与 Go 的标准测试包 testing 集成得很好。使用 GoMock，可以轻松地为接口创建 Mock 实现，并定义这些 Mock 对象在调用时的行为和返回值

特点
- 基于接口的 Mocking：GoMock 允许你为任何接口生成 Mock 实现。
- 强大的断言：可以精确地断言 Mock 方法被调用的次数、参数和返回值。
- 灵活的行为定义：可以定义 Mock 方法在每次调用时的不同行为。
- 与 Go 测试包集成：GoMock 与 Go 的标准测试包 testing 完美集成，可以很容易地在测试中使用 Mock 对象。
安装 GoMock
要使用 GoMock，首先需要安装 GoMock 命令行工具。可以通过以下命令安装：
```
go get github.com/golang/mock/gomock
go install github.com/golang/mock/mockgen@latest
```
google在2023年已经停止了对gomock的更新和支持，以上的命令也还能获取，如果要获取更新的版本，可以用下面的
```
go get github.com/uber-go/mock/gomock
go install go.uber.org/mock/mockgen@latest
```
编写Mock代码

使用 GoMock 的基本步骤
1. 定义接口：首先，你需要定义一个接口，你想要为这个接口创建 Mock 实现
```
// my_interface.go
package mypackage

type MyInterface interface {
    DoSomething(arg int) (int, error)
}
```
2. 生成 Mock 代码：使用 GoMock 命令行工具mockgen生成 Mock 代码
```
mockgen -source=my_interface.go -destination=my_interface_mock.go -package=mypackage
```
  这将生成一个名为 my_interface_mock.go 的文件，其中包含 Mock 实现的代码。
3. 编写测试：在你的测试代码中，创建 Mock 控制器并定义 Mock 对象的行为
```
// my_interface_test.go
package mypackage

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

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

    mock := NewMockMyInterface(ctrl)
    mock.EXPECT().DoSomething(gomock.Eq(123)).Return(456, nil)

    // 使用 Mock 对象进行测试
}
```
  1. 代码首先创建了一个新的 Mock 控制器ctrl。控制器负责管理 Mock 对象和 Mock 期望（expectations）。
  2. defer ctrl.Finish() 是一个延迟调用的声明，它将在当前函数执行完毕后执行。Finish 方法是 Mock 控制器的一个方法，它用于释放控制器占用的资源，比如在测试结束后关闭 Mock 对象可能打开的文件描述符。
  3. mock := NewMockMyInterface(ctrl) 创建了一个新的 Mock 对象，它实现了我们之前定义的 MyInterface 接口。NewMockMyInterface 是 GoMock 框架提供的一个方法，它创建了一个新的 Mock 对象，并将其与当前的 Mock 控制器关联起来。
  4. mock.EXPECT().DoSomething(gomock.Eq(123)).Return(456, nil) 定义了一个期望的行为。EXPECT() 方法用于告诉 GoMock，我们应该期望 DoSomething 方法被调用，并且它应该被调用的方式。gomock.Eq(123) 是一个断言，它告诉 GoMock，我们期望 DoSomething 方法的第一个参数等于 123。Return(456, nil) 定义了当 DoSomething 方法被调用时，我们应该返回的值。在这个例子中，我们期望 DoSomething 方法被调用一次，并且它的第一个参数是 123，然后我们应该返回 456 和 nil。
使用Mock进行单元测试

我们看一个具体的例子，创建一个简单的 HTTP 客户端接口和它的 Mock，然后编写一个测试用例来使用这个 Mock
1. 定义接口：首先，定义一个 HTTP 客户端接口
```
// http_client/interface.go
 package httpclient

 type HTTPClient interface {
     Get(url string) ([]byte, error)
 }
```
2. 生成 Mock 实现：使用 mockgen 命令生成 Mock 实现。
```
mockgen -source=interface.go -destination=interface_mock.go -package=mypackage
```
  有兴趣的同学可以对比一下，看看interface_mock.go与之前手动编写的mock_db.go有什么区别，来加深对于mock的设计理念的认识
3. 编写一个使用 HTTP 客户端的服务
```
// service/http_service.go
package service

import (
    "encoding/json"

    httpclient "golang-30-days/Day13-15/code/unit_test/http_client"
)

type Response struct {
    Message string `json:"message"`
}

func FetchMessage(client httpclient.HTTPClient, url string) (string, error) {
    data, err := client.Get(url)
    if err != nil {
        return "", err
    }

    var resp Response
    if err := json.Unmarshal(data, &resp); err != nil {
        return "", err
    }

    return resp.Message, nil
}
```
4. 编写一个单元测试，使用 GoMock Mock 对象来模拟 HTTP 客户端的行为
```
// service/http_service_test.go
 package service

 import (
     "encoding/json"
     httpclient "golang-30-days/Day13-15/code/unit_test/http_client"
     "testing"

     "github.com/golang/mock/gomock"
 )

 func TestFetchMessage(t *testing.T) {
     // 创建 Mock 控制器
     ctrl := gomock.NewController(t)
     defer ctrl.Finish()

     // 创建 Mock HTTP 客户端
     mockClient := httpclient.NewMockHTTPClient(ctrl)

     // 设置 Mock 行为：当调用 Get 方法时，返回预定义的响应
     mockResponse := Response{Message: "Hello, World!"}
     mockData, _ := json.Marshal(mockResponse)
     mockClient.EXPECT().Get("http://example.com/message").Return(mockData, nil)

     // 调用服务函数
     message, err := FetchMessage(mockClient, "http://example.com/message")

     // 断言结果
     if err != nil {
         t.Errorf("Expected no error, got %v", err)
     }
     if message != mockResponse.Message {
         t.Errorf("Expected message '%s', got '%s'", mockResponse.Message, message)
     }
 }
```
  可以看到我们并没有直接调用我们进行mock的接口，而是通过FetchMessage方法，来间接调用httpclient.Get的；我们并未对FetchMessage进行mock操作，但最后返回的依然是我们设定的返回结果，而不是实际去请求http://example.com/message。由此可见，mock控制器创建后，就会直接在测试函数域内生效，只要使用httpclient.Get接口，并且输入参数为http://example.com/message，都会返回我们预设的{Message: "Hello, World!"}
面向测试编程（TDD）

TDD简介

面向测试编程（Test-Driven Development，TDD）是一种软件开发过程，它强调在编写实际的代码实现之前先编写测试代码。这种开发方式的核心思想是通过测试来推动软件设计，确保代码的质量和可维护性

TDD的优势
1. 提高代码质量：通过持续的测试，可以及早发现和修复错误。
2. 更好的设计：测试驱动的方式鼓励更好的设计和模块化，因为代码必须易于测试。
3. 文档化：测试本身可以作为代码行为的文档。
4. 勇气重构：因为有测试作为安全保障，开发者在进行重构时更加大胆。
TDD的基本步骤

TDD通常遵循以下步骤：
- 编写测试（Red）：开发人员首先编写一个会失败的测试用例，这个测试用例用来描述代码的一个小的、特定的行为。
- 编写最小量的代码（Green）：接着，开发人员编写足够的代码使测试通过，这个过程要求开发者只编写必要的代码，而不是一开始就实现所有的功能。
- 重构（Refactor）：最后，开发人员对已经通过测试的代码进行重构，改进代码结构，提高代码的可读性和可维护性，同时确保所有的测试仍然通过。
Go语言中的TDD实践

golang中的实践主要遵循以下步骤
1. 编写测试：在.go文件中编写测试代码。Go语言的测试文件通常与源代码文件在同一目录下，文件名以_test.go结尾。测试函数以Test开头，并且接受一个类型为*testing.T的参数。
2. 运行测试：使用go test命令运行测试。如果测试失败，go test会输出失败的测试信息。
3. 编写最小量的代码：根据测试失败的原因，编写最少的代码使测试通过。
4. 重构：一旦测试通过，对代码进行重构，以提高代码质量和可读性。
5. 重复：重复以上步骤，每次添加一个新的测试，然后编写代码使测试通过，最后重构。
看一个简单例子，首先，创建一个名为calculator_test.go的测试文件，并编写一个测试用例
```
package calculator

import "testing"

func TestAdd(t *testing.T) {
    result := Add(1, 2)
    expected := 3
    if result != expected {
        t.Errorf("Add(1, 2) = %d; expected %d", result, expected)
    }
}
```
接着，创建一个名为calculator.go的文件，并编写一个空的Add函数：
```
package calculator

// Add takes two numbers and returns their sum.
func Add(a, b int) int {
    return 0
}
```
运行go test命令，测试将会失败，因为我们的Add函数还没有实现加法功能
```
go test
```
接下来，我们回到calculator.go文件，实现Add函数
```
package calculator

// Add takes two numbers and returns their sum.
func Add(a, b int) int {
    return a + b
}
```
再次运行go test命令，测试会通过。之后我们可以继续添加更多的测试用例，比如测试负数相加、零相加等，然后根据测试结果逐步完善Add函数。

这就是在Go语言中实践TDD的基本流程。通过不断地重复这个过程，你可以逐步构建起一个健壮的代码库。
相关阅读:
MQTT，EMQX认识，安装，部署
 JS前端开发框架常用的有哪些？
Spring: Springboot 框架集成不同版本的spring redis
vue和react的diff算法源码
 深入理解JVM虚拟机第八篇：引导类加载器、拓展类加载器、应用类加载器与自定义类加载器
 浅谈虚树（虚仙人掌）
6. 【图的遍历】⼴度优先遍历(BFS)、⼴度优先⽣成树(森林） + 深度优先遍历(DFS)、深度优先⽣成树(森林）
理论和实践详解RabbitMQ惰性/延迟队列（lazy queues）（带测试样例及分析）
鸿蒙：从0到“Hello Harmony”
【网络安全】文件上传之安全狗bypass
原文地址：https://blog.csdn.net/loo_Charles_ool/article/details/139330458

文章目录

golang 单元测试

引言

单元测试的重要性

Go语言单元测试的优势

Go语言单元测试基础

testing包

辅助测试函数

运行单元测试

Mock技术

Mock简介

GoMock框架介绍

编写Mock代码

使用Mock进行单元测试

面向测试编程（TDD）

TDD简介

TDD的优势

TDD的基本步骤

Go语言中的TDD实践