Golang单元测试与集成测试结合方法

testing

testing

TestMain

xxx.go

xxx_test.go

testing.T

t.Run()

package mypackage

import (
    "testing"
)

// MyFunction 是一个简单的函数，我们来测试它
func MyFunction(a, b int) int {
    return a + b
}

func TestMyFunction(t *testing.T) {
    // 表格驱动测试是一个非常高效的模式
    tests := []struct {
        name string
        a, b int
        want int
    }{
        {"positive numbers", 1, 2, 3},
        {"negative numbers", -1, -2, -3},
        {"mixed numbers", -1, 2, 1},
        {"zero", 0, 0, 0},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got := MyFunction(tt.a, tt.b)
            if got != tt.want {
                t.Errorf("MyFunction(%d, %d) = %d; want %d", tt.a, tt.b, got, tt.want)
            }
        })
    }
}

DBClient

MockDBClient

// 假设有一个接口
type DataStore interface {
    GetUser(id int) (string, error)
}

// 实际的实现
type RealDB struct {}
func (r *RealDB) GetUser(id int) (string, error) { /* ... 真实的数据库操作 ... */ return "User From Real DB", nil }

// 用于测试的Mock实现
type MockDataStore struct {
    GetUserFunc func(id int) (string, error)
}

func (m *MockDataStore) GetUser(id int) (string, error) {
    if m.GetUserFunc != nil {
        return m.GetUserFunc(id)
    }
    return "", nil // 默认返回
}

// 业务逻辑函数
func GetUserName(ds DataStore, id int) (string, error) {
    return ds.GetUser(id)
}

func TestGetUserName(t *testing.T) {
    mockDS := &MockDataStore{
        GetUserFunc: func(id int) (string, error) {
            if id == 1 {
                return "Alice", nil
            }
            return "", nil
        },
    }

    name, err := GetUserName(mockDS, 1)
    if err != nil {
        t.Errorf("expected no error, got %v", err)
    }
    if name != "Alice" {
        t.Errorf("expected Alice, got %s", name)
    }

    name, err = GetUserName(mockDS, 2) // 测试不存在的用户
    if err != nil {
        // 期望这里没有错误，但根据mock实现，它返回空字符串
        // 实际应用中，这里可能返回ErrNotFound
    }
    if name != "" {
        t.Errorf("expected empty string, got %s", name)
    }
}

testify/mock

docker-compose.yml

docker-compose.yml

version: '3.8'
services:
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: test_db
      POSTGRES_USER: test_user
      POSTGRES_PASSWORD: test_password
    ports:
      - "5432:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U test_user -d test_db"]
      interval: 5s
      timeout: 5s
      retries: 5

_test.go

TestMain

TestMain

package mypackage_test // 通常集成测试会放在一个单独的包中，或者以_test后缀

import (
    "database/sql"
    "fmt"
    "log"
    "os"
    "os/exec"
    "testing"
    _ "github.com/lib/pq" // PostgreSQL驱动
)

var testDB *sql.DB

func TestMain(m *testing.M) {
    // 1. 启动Docker Compose服务
    log.Println("Starting Docker Compose...")
    cmd := exec.Command("docker-compose", "up", "-d")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        log.Fatalf("Failed to start Docker Compose: %v", err)
    }

    // 确保服务已启动并健康
    // 实际项目中，这里可能需要一个循环等待数据库可用
    log.Println("Waiting for database to be ready...")
    // 简单的等待，实际项目可能需要更健壮的重试逻辑
    // time.Sleep(10 * time.Second)

    // 2. 连接到数据库
    connStr := "postgres://test_user:test_password@localhost:5432/test_db?sslmode=disable"
    var err error
    testDB, err = sql.Open("postgres", connStr)
    if err != nil {
        log.Fatalf("Failed to connect to database: %v", err)
    }
    defer testDB.Close()

    // 尝试Ping数据库，确保连接成功
    if err = testDB.Ping(); err != nil {
        log.Fatalf("Failed to ping database: %v", err)
    }
    log.Println("Database connection established.")

    // 3. 运行所有测试
    code := m.Run()

    // 4. 清理Docker Compose服务
    log.Println("Stopping Docker Compose...")
    cmd = exec.Command("docker-compose", "down")
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        log.Printf("Failed to stop Docker Compose: %v", err)
    }

    os.Exit(code)
}

func TestDatabaseInteraction(t *testing.T) {
    // 在这里编写与testDB交互的集成测试
    // 例如：插入数据，查询数据
    _, err := testDB.Exec("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name VARCHAR(255))")
    if err != nil {
        t.Fatalf("Failed to create table: %v", err)
    }

    res, err := testDB.Exec("INSERT INTO users (name) VALUES ($1)", "Alice")
    if err != nil {
        t.Fatalf("Failed to insert user: %v", err)
    }
    rowsAffected, _ := res.RowsAffected()
    if rowsAffected != 1 {
        t.Errorf("Expected 1 row affected, got %d", rowsAffected)
    }

    var name string
    err = testDB.QueryRow("SELECT name FROM users WHERE id = $1", 1).Scan(&name)
    if err != nil {
        t.Fatalf("Failed to query user: %v", err)
    }
    if name != "Alice" {
        t.Errorf("Expected name Alice, got %s", name)
    }
}

t.Parallel()

t.Parallel()

testcontainers-go

docker-compose.yml

docker-compose

TestMain

testcontainers-go