Go 企业级测试策略：大规模 Web 应用的全面测试指南

//go:build integration

package repository_test

import (
    "testing"

    "github.com/stretchr/testify/suite"
)

type UserRepoIntegrationSuite struct {
    suite.Suite
    // 数据库连接等共享资源
}

func TestUserRepoIntegration(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping integration test in short mode")
    }
    suite.Run(t, new(UserRepoIntegrationSuite))
}

//go:build e2e

package api_test

import "testing"

func TestCreateUserE2E(t *testing.T) {
    if testing.Short() {
        t.Skip("skipping E2E test in short mode")
    }
    // 全链路测试
}

func TestCreateUser(t *testing.T) {
    mockRepo := mocks.NewMockUserRepository(t) // 自动注册 t.Cleanup

    mockRepo.EXPECT().
        Create(mock.Anything, mock.MatchedBy(func(u *model.User) bool {
            return u.Email == "test@example.com"
        })).
        Return(nil).
        Once()

    svc := service.NewUserService(mockRepo)
    err := svc.CreateUser(context.Background(), &model.User{
        Email: "test@example.com",
    })
    assert.NoError(t, err)
}

// 自定义 Matcher：验证参数类型
type ofType struct{ t string }

func OfType(t string) gomock.Matcher {
    return &ofType{t}
}

func (o *ofType) Matches(x interface{}) bool {
    return reflect.TypeOf(x).String() == o.t
}

func (o *ofType) String() string {
    return "is of type " + o.t
}

// 使用自定义 Matcher
mockSvc.EXPECT().
    ProcessPayment(OfType("*model.Payment")).
    Return(nil)

func TestOrderWorkflow(t *testing.T) {
    ctrl := gomock.NewController(t)
    mockOrder := NewMockOrderService(ctrl)

    // 强制按顺序执行
    gomock.InOrder(
        mockOrder.EXPECT().ValidateOrder(gomock.Any()).Return(nil),
        mockOrder.EXPECT().ReserveInventory(gomock.Any()).Return(nil),
        mockOrder.EXPECT().ChargePayment(gomock.Any()).Return(nil),
        mockOrder.EXPECT().SendConfirmation(gomock.Any()).Return(nil),
    )

    workflow := NewOrderWorkflow(mockOrder)
    err := workflow.Execute(context.Background(), testOrder)
    assert.NoError(t, err)
}

mockRepo.EXPECT().
    Save(gomock.Any()).
    Do(func(user *model.User) {
        // 模拟数据库自动生成 ID
        user.ID = 42
    }).
    Return(nil)

//go:build integration

package testutil

import (
    "context"
    "fmt"
    "testing"

    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
    "github.com/testcontainers/testcontainers-go/modules/redis"
    "github.com/testcontainers/testcontainers-go/wait"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

// TestInfra 封装测试基础设施
type TestInfra struct {
    DB          *gorm.DB
    RedisAddr   string
    pgContainer testcontainers.Container
    rdContainer testcontainers.Container
}

func SetupTestInfra(t *testing.T) *TestInfra {
    t.Helper()
    ctx := context.Background()

    // 启动 PostgreSQL 容器
    pgContainer, err := tcpostgres.Run(ctx,
        "postgres:16-alpine",
        tcpostgres.WithDatabase("testdb"),
        tcpostgres.WithUsername("test"),
        tcpostgres.WithPassword("test"),
        testcontainers.WithWaitStrategy(
            wait.ForLog("database system is ready to accept connections").
                WithOccurrence(2),
        ),
    )
    if err != nil {
        t.Fatalf("failed to start postgres: %v", err)
    }
    t.Cleanup(func() { pgContainer.Terminate(ctx) })

    // 启动 Redis 容器
    rdContainer, err := tcredis.Run(ctx, "redis:7-alpine")
    if err != nil {
        t.Fatalf("failed to start redis: %v", err)
    }
    t.Cleanup(func() { rdContainer.Terminate(ctx) })

    // 获取连接字符串
    pgConnStr, _ := pgContainer.ConnectionString(ctx, "sslmode=disable")
    rdEndpoint, _ := rdContainer.Endpoint(ctx, "")

    // 初始化 GORM
    db, err := gorm.Open(pgdriver.Open(pgConnStr), &gorm.Config{})
    if err != nil {
        t.Fatalf("failed to connect to postgres: %v", err)
    }

    // 自动迁移
    db.AutoMigrate(&model.User{}, &model.Order{})

    return &TestInfra{
        DB:          db,
        RedisAddr:   rdEndpoint,
        pgContainer: pgContainer,
        rdContainer: rdContainer,
    }
}

//go:build integration

func TestWithDockerCompose(t *testing.T) {
    compose, err := testcontainers.NewDockerCompose("testdata/docker-compose.yml")
    if err != nil {
        t.Fatal(err)
    }
    t.Cleanup(func() {
        compose.Down(context.Background(), testcontainers.RemoveOrphans(true))
    })

    ctx := context.Background()
    err = compose.
        WaitForService("postgres", wait.ForListeningPort("5432/tcp")).
        WaitForService("redis", wait.ForListeningPort("6379/tcp")).
        WaitForService("kafka", wait.ForListeningPort("9092/tcp")).
        Up(ctx, testcontainers.Wait(true))
    if err != nil {
        t.Fatal(err)
    }

    // 所有 WaitForService 并行执行，提升启动性能
}

import "github.com/testcontainers/testcontainers-go/modules/kafka"

func setupKafka(t *testing.T) string {
    t.Helper()
    ctx := context.Background()

    kafkaContainer, err := kafka.Run(ctx,
        "confluentinc/confluent-local:7.5.0",
    )
    if err != nil {
        t.Fatalf("failed to start kafka: %v", err)
    }
    t.Cleanup(func() { kafkaContainer.Terminate(ctx) })

    brokers, _ := kafkaContainer.Brokers(ctx)
    return brokers[0]
}

func TruncateTables(t *testing.T, db *gorm.DB, tables ...string) {
    t.Helper()
    for _, table := range tables {
        if err := db.Exec(fmt.Sprintf("TRUNCATE TABLE %s CASCADE", table)).Error; err != nil {
            t.Fatalf("failed to truncate %s: %v", table, err)
        }
    }
}

func TestUserOperations(t *testing.T) {
    infra := SetupTestInfra(t) // 共享基础设施

    t.Run("Create", func(t *testing.T) {
        t.Parallel()
        // 每个并行测试使用独立事务
        WithTestTransaction(t, infra.DB, func(tx *gorm.DB) {
            repo := repository.NewUserRepository(tx)
            // ... 测试逻辑
        })
    })

    t.Run("Update", func(t *testing.T) {
        t.Parallel()
        WithTestTransaction(t, infra.DB, func(tx *gorm.DB) {
            repo := repository.NewUserRepository(tx)
            // ... 测试逻辑
        })
    })

    t.Run("Delete", func(t *testing.T) {
        t.Parallel()
        WithTestTransaction(t, infra.DB, func(tx *gorm.DB) {
            repo := repository.NewUserRepository(tx)
            // ... 测试逻辑
        })
    })
}

package consumer_test

import (
    "fmt"
    "net/http"
    "testing"

    "github.com/pact-foundation/pact-go/v2/consumer"
    "github.com/pact-foundation/pact-go/v2/matchers"
    "github.com/stretchr/testify/assert"
)

func TestUserAPIConsumer(t *testing.T) {
    mockProvider, err := consumer.NewV4Pact(consumer.MockHTTPProviderConfig{
        Consumer: "OrderService",
        Provider: "UserService",
    })
    assert.NoError(t, err)

    // 定义期望的交互
    err = mockProvider.
        AddInteraction().
        Given("a user with ID 1 exists").
        UponReceiving("a request for user 1").
        WithRequestPathStringMatcher(http.MethodGet, "/api/users/1", nil).
        WillRespondWith(200, func(b *consumer.V4ResponseBuilder) {
            b.Header("Content-Type", matchers.String("application/json"))
            b.JSONBody(matchers.Map{
                "id":    matchers.Integer(1),
                "name":  matchers.String("Alice"),
                "email": matchers.Regex("alice@example.com", `^[\w.]+@[\w.]+$`),
            })
        }).
        ExecuteTest(t, func(config consumer.MockServerConfig) error {
            // 使用 Mock 服务器地址调用 API 客户端
            client := NewUserClient(fmt.Sprintf("http://%s:%d", config.Host, config.Port))
            user, err := client.GetUser(1)
            if err != nil {
                return err
            }
            assert.Equal(t, "Alice", user.Name)
            return nil
        })
    assert.NoError(t, err)
    // Pact 文件自动生成到 pacts/ 目录
}

package provider_test

import (
    "testing"

    "github.com/pact-foundation/pact-go/v2/provider"
)

func TestUserAPIProvider(t *testing.T) {
    verifier := provider.NewVerifier()

    err := verifier.VerifyProvider(t, provider.VerifyRequest{
        ProviderBaseURL: "http://localhost:8080",
        PactFiles:       []string{"../pacts/orderservice-userservice.json"},
        StateHandlers: map[string]provider.StateHandlerFunc{
            "a user with ID 1 exists": func(setup bool, state provider.ProviderState) (map[string]interface{}, error) {
                if setup {
                    // 在数据库中插入测试数据
                    seedUser(1, "Alice", "alice@example.com")
                }
                return nil, nil
            },
        },
    })
    assert.NoError(t, err)
}

//go:build e2e

package api_test

import (
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gavv/httpexpect/v2"
)

func newTestAPI(t *testing.T) *httpexpect.Expect {
    t.Helper()
    handler := setupRouter() // 你的 Gin router 初始化
    server := httptest.NewServer(handler)
    t.Cleanup(server.Close)

    return httpexpect.WithConfig(httpexpect.Config{
        BaseURL:  server.URL,
        Reporter: httpexpect.NewAssertReporter(t),
        Client: &http.Client{
            Jar: httptest.NewTLSServer(handler).Client().Jar,
        },
        Printers: []httpexpect.Printer{
            httpexpect.NewDebugPrinter(t, true), // 打印 curl 命令
        },
    })
}

func TestUserCRUDFlow(t *testing.T) {
    e := newTestAPI(t)

    // 1. 注册
    registerResp := e.POST("/api/auth/register").
        WithJSON(map[string]string{
            "email":    "test@example.com",
            "password": "SecurePass123!",
            "name":     "Test User",
        }).
        Expect().
        Status(http.StatusCreated).
        JSON().Object()

    registerResp.HasValue("email", "test@example.com")

    // 2. 登录获取 Token
    loginResp := e.POST("/api/auth/login").
        WithJSON(map[string]string{
            "email":    "test@example.com",
            "password": "SecurePass123!",
        }).
        Expect().
        Status(http.StatusOK).
        JSON().Object()

    token := loginResp.Value("token").String().Raw()

    // 3. 使用 Token 访问受保护资源
    e.GET("/api/users/me").
        WithHeader("Authorization", "Bearer "+token).
        Expect().
        Status(http.StatusOK).
        JSON().Object().
        HasValue("name", "Test User")

    // 4. 未认证访问应返回 401
    e.GET("/api/users/me").
        Expect().
        Status(http.StatusUnauthorized)
}

package handler

import (
    "bytes"
    "net/http"
    "net/http/httptest"
    "testing"

    "github.com/gin-gonic/gin"
)

func FuzzCreateUserHandler(f *testing.F) {
    // 添加种子语料库
    f.Add([]byte(`{"name":"Alice","email":"alice@example.com"}`))
    f.Add([]byte(`{"name":"","email":"invalid"}`))
    f.Add([]byte(`{}`))
    f.Add([]byte(`not json at all`))
    f.Add([]byte(``))

    gin.SetMode(gin.TestMode)
    router := setupTestRouter()

    f.Fuzz(func(t *testing.T, data []byte) {
        req := httptest.NewRequest(http.MethodPost, "/api/users", bytes.NewReader(data))
        req.Header.Set("Content-Type", "application/json")
        w := httptest.NewRecorder()

        router.ServeHTTP(w, req)

        // Handler 不应 panic，应返回合理的 HTTP 状态码
        if w.Code == 0 {
            t.Error("handler returned status code 0")
        }
        if w.Code >= 500 && w.Code != http.StatusInternalServerError {
            t.Errorf("unexpected 5xx status: %d", w.Code)
        }
    })
}

func FuzzParseUserInput(f *testing.F) {
    f.Add(`{"name":"test","age":25}`)
    f.Add(`{"name":"","age":-1}`)
    f.Add(`{"name":"x","age":999999}`)

    f.Fuzz(func(t *testing.T, input string) {
        user, err := ParseUserInput([]byte(input))
        if err != nil {
            return // 解析失败是正常的
        }

        // 如果解析成功，验证不变量
        if user.Name == "" {
            t.Error("parsed user with empty name")
        }
        if user.Age < 0 || user.Age > 200 {
            t.Errorf("parsed user with invalid age: %d", user.Age)
        }
    })
}

package repository

import (
    "context"
    "testing"
)

func BenchmarkUserRepository_FindByID(b *testing.B) {
    db := setupBenchDB(b)      // 使用真实数据库
    repo := NewUserRepository(db)
    seedUsers(b, db, 10000)    // 预填充数据

    ctx := context.Background()

    b.ResetTimer() // 重置计时器，排除 setup 时间
    b.RunParallel(func(pb *testing.PB) {
        id := int64(1)
        for pb.Next() {
            _, err := repo.FindByID(ctx, id)
            if err != nil {
                b.Fatal(err)
            }
            id = (id % 10000) + 1
        }
    })
}

func BenchmarkUserRepository_Create(b *testing.B) {
    db := setupBenchDB(b)
    repo := NewUserRepository(db)
    ctx := context.Background()

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        user := &model.User{
            Name:  fmt.Sprintf("user_%d", i),
            Email: fmt.Sprintf("user_%d@bench.com", i),
        }
        if err := repo.Create(ctx, user); err != nil {
            b.Fatal(err)
        }
    }
}

// 内存分配基准
func BenchmarkJSONSerialization(b *testing.B) {
    user := &model.User{ID: 1, Name: "Alice", Email: "alice@test.com"}

    b.ReportAllocs() // 报告内存分配
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        _, err := json.Marshal(user)
        if err != nil {
            b.Fatal(err)
        }
    }
}

goos: linux
goarch: amd64
pkg: github.com/yourorg/app/internal/repository
                          │  old.txt   │              new.txt               │
                          │   sec/op   │   sec/op     vs base               │
UserRepository_FindByID     125.3u ± 2%   89.7u ± 1%  -28.41% (p=0.000 n=10)
UserRepository_Create       892.1u ± 3%   743.2u ± 2% -16.69% (p=0.000 n=10)

                          │  old.txt   │              new.txt              │
                          │    B/op    │    B/op     vs base               │
UserRepository_FindByID     1.234Ki ± 0%   0.892Ki ± 0%  -27.71% (p=0.000 n=10)

project/
├── internal/
│   ├── handler/
│   │   ├── user_handler.go
│   │   ├── user_handler_test.go       # 单元测试
│   │   └── fuzz_test.go               # Fuzz 测试
│   ├── service/
│   │   ├── user_service.go
│   │   ├── user_service_test.go
│   │   └── mocks/                     # mockery 生成
│   │       └── mock_user_repository.go
│   └── repository/
│       ├── user_repository.go
│       ├── user_repository_test.go        # 单元测试
│       └── user_repository_integ_test.go  # 集成测试 (build tag)
├── test/
│   ├── testutil/                      # 共享测试辅助
│   │   ├── db.go                      # 数据库 Helper
│   │   ├── fixtures.go                # 夹具加载
│   │   ├── auth.go                    # 认证 Helper
│   │   └── containers.go             # testcontainers 设置
│   ├── e2e/                           # E2E 测试
│   │   ├── api_test.go
│   │   └── testdata/
│   │       └── docker-compose.yml
│   ├── contract/                      # 契约测试
│   │   ├── consumer_test.go
│   │   └── provider_test.go
│   ├── loadtest/                      # 负载测试
│   │   ├── api_load.js                # k6 脚本
│   │   └── vegeta_test.go
│   └── golden/                        # Golden File 测试数据
│       └── testdata/
│           ├── user_response.golden
│           └── error_response.golden
├── .mockery.yaml                      # Mock 配置
├── Makefile                           # 分层测试目标
└── .github/
    └── workflows/
        ├── test.yml                   # CI 测试流水线
        └── benchmark.yml             # 持续基准

package handler_test

import (
    "flag"
    "os"
    "path/filepath"
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)

var update = flag.Bool("update", false, "update golden files")

func TestUserResponseGolden(t *testing.T) {
    // 获取实际响应
    resp := getUserResponse(t, 1)
    actual := normalizeJSON(t, resp)

    goldenFile := filepath.Join("testdata", t.Name()+".golden")

    if *update {
        // 更新模式：写入新的 golden file
        err := os.MkdirAll("testdata", 0o755)
        require.NoError(t, err)
        err = os.WriteFile(goldenFile, actual, 0o644)
        require.NoError(t, err)
        return
    }

    // 比较模式：读取并对比
    expected, err := os.ReadFile(goldenFile)
    require.NoError(t, err)
    assert.JSONEq(t, string(expected), string(actual))
}

import "github.com/sebdah/goldie/v2"

func TestAPIResponses(t *testing.T) {
    g := goldie.New(t,
        goldie.WithFixtureDir("testdata"),
        goldie.WithNameSuffix(".golden"),
        goldie.WithDiffEngine(goldie.ColoredDiff),
    )

    resp := callAPI(t, "/api/users/1")
    g.AssertJson(t, "user_response", resp)
}

# Makefile
.PHONY: test test-unit test-integration test-e2e test-contract test-all \
        test-fuzz test-bench test-coverage lint

# === 基础变量 ===
COVERAGE_DIR := .coverage
COVERAGE_THRESHOLD := 70
BENCH_COUNT := 10

# === 单元测试（最快，无外部依赖） ===
test-unit:
  @echo "Running unit tests..."
  go test -short -race -count=1 ./internal/...

# === 集成测试（需要 Docker） ===
test-integration:
  @echo "Running integration tests..."
  go test -race -count=1 -tags=integration -timeout=5m ./...

# === E2E 测试 ===
test-e2e:
  @echo "Running E2E tests..."
  go test -race -count=1 -tags=e2e -timeout=10m ./test/e2e/...

# === 契约测试 ===
test-contract:
  @echo "Running contract tests..."
  go test -race -count=1 -tags=contract -timeout=5m ./test/contract/...

# === 全部测试 ===
test-all: test-unit test-integration test-e2e test-contract

# === 默认 test 目标只运行单元测试 ===
test: test-unit

# === Fuzz 测试（运行 1 分钟） ===
test-fuzz:
  @echo "Running fuzz tests..."
  go test -fuzz=Fuzz -fuzztime=1m ./internal/handler/...

# === 基准测试 ===
test-bench:
  @echo "Running benchmarks..."
  go test -bench=. -count=$(BENCH_COUNT) -benchmem -run=^$$ ./... | tee bench.txt

# === 覆盖率 ===
test-coverage:
  @mkdir -p $(COVERAGE_DIR)
  go test -race -coverprofile=$(COVERAGE_DIR)/coverage.out -covermode=atomic ./internal/...
  go tool cover -html=$(COVERAGE_DIR)/coverage.out -o $(COVERAGE_DIR)/coverage.html
  @echo "Coverage report: $(COVERAGE_DIR)/coverage.html"
  @go tool cover -func=$(COVERAGE_DIR)/coverage.out | tail -1

# === 覆盖率阈值检查 ===
check-coverage: test-coverage
  @COVERAGE=$$(go tool cover -func=$(COVERAGE_DIR)/coverage.out | tail -1 | awk '{print $$3}' | sed 's/%//'); \
  echo "Total coverage: $${COVERAGE}%"; \
  if [ $$(echo "$${COVERAGE} < $(COVERAGE_THRESHOLD)" | bc -l) -eq 1 ]; then \
    echo "FAIL: Coverage $${COVERAGE}% is below threshold $(COVERAGE_THRESHOLD)%"; \
    exit 1; \
  fi

# === 代码检查 ===
lint:
  golangci-lint run ./...

# === Mock 生成 ===
generate-mocks:
  mockery

# === CI 全套 ===
ci: lint test-unit test-integration check-coverage