Go 的 time.Sleep 在测试中的替代方案

go func process(data string, done chan<- bool) { // 模拟异步工作 time.Sleep(10 * time.Millisecond) // 这是被测试的代码，不是测试中的等待 done <- true }

func TestProcessWithChannel(t *testing.T) { done := make(chan bool) go process("hello", done)

select {
case <-done:
    // 收到完成信号，测试通过
case <-time.After(1 * time.Second):
    t.Fatal("测试超时，process 没有在预期时间内完成")
}

}

**关键点**：
- 使用 `done` channel 让测试者明确知道工作何时完成。
- `time.After` 用作超时保护，防止测试永远阻塞，但它本身不是被动等待，而是设置了一个最大等待上限。
- 这种方式让测试只在实际完成时立即返回，而不是盲目等待一段固定时间。

## 方案二：使用 sync.WaitGroup 等待多个协程

当你有多个并发的 goroutine 需要等待时，`sync.WaitGroup` 是标准库提供的绝佳工具。

### 示例：并发处理多个任务

```go
func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    // 执行一些操作
}

func TestMultipleWorkers(t *testing.T) {
    var wg sync.WaitGroup
    numWorkers := 5

    for i := 0; i < numWorkers; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    // 等待所有 worker 完成，或直到超时
    done := make(chan struct{})
    go func() {
        wg.Wait()
        close(done)
    }()

    select {
    case <-done:
        // 所有 worker 正常完成
    case <-time.After(2 * time.Second):
        t.Fatal("workers 超时未完成")
    }
}

为什么不用 time.Sleep？
使用 wg.Wait() 后，测试会精确地在所有 goroutine 完成后继续执行，完全消除了猜测等待时间的需要。

方案三：使用 testify 的 assert.Eventually

testify 是 Go 中最流行的测试工具库之一，它提供了 assert.Eventually 函数，用于在一定时间内轮询某个条件直到其满足。

示例：等待某个状态变为预期值

import (
    "testing"
    "time"
    "github.com/stretchr/testify/assert"
)

func TestCacheUpdate(t *testing.T) {
    cache := NewCache()
    go cache.RefreshInBackground()

    assert.Eventually(t, func() bool {
        return cache.IsReady()
    }, 2*time.Second, 100*time.Millisecond, "缓存应该在2秒内就绪")
}

参数解释：

• 第一个参数：一个返回 bool 的断言函数。
• 2*time.Second：最大等待时间，之后测试失败。
• 100*time.Millisecond：轮询间隔，避免过于频繁的检查。

这样既避免了硬编码的 time.Sleep，又能动态地等待条件达成，同时利用超时防止无限等待。

方案四：使用 context 实现超时控制

在更复杂的场景中，你可以通过 context.WithTimeout 或 context.WithDeadline 来协调 goroutine 的生命周期，让它们能够在测试结束时自动取消。

示例：测试一个可取消的长时间运行操作

func longRunningOp(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
            // 模拟工作
        }
    }
}

func TestWithContext(t *testing.T) {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()

    err := longRunningOp(ctx)
    if err != context.DeadlineExceeded {
        t.Fatalf("预期超时错误，但得到: %v", err)
    }
}

这种方式不仅测试了超时行为，还确保 goroutine 不会泄露。

方案五：模拟时间（Fake Clock）

上述方案解决了同步等待的问题，但很多业务逻辑本身就依赖 time.Now() 或 time.Sleep。例如一个限流器需要等待一段时间才能再次允许请求。如果测试中真的等待几秒钟，那依然很慢。

此时我们可以引入 Clock 接口 来抽象时间，然后在测试中注入一个可控的模拟时钟。

第一步：定义 Clock 接口，不要在代码中直接调用 time.Sleep

使用类似 benbjohnson/clock 的库，或者自己定义一个最小接口：

type Clock interface {
    Now() time.Time
    Sleep(d time.Duration)
    After(d time.Duration) <-chan time.Time
}

第二步：在业务结构体中使用 Clock 接口

type RateLimiter struct {
    clock  Clock
    last   time.Time
    period time.Duration
}

func NewRateLimiter(clock Clock, period time.Duration) *RateLimiter {
    return &RateLimiter{clock: clock, period: period}
}

func (r *RateLimiter) Allow() bool {
    if r.clock.Now().Sub(r.last) >= r.period {
        r.last = r.clock.Now()
        return true
    }
    return false
}

第三步：在测试中使用模拟时钟

import "github.com/benbjohnson/clock"

func TestRateLimiter(t *testing.T) {
    mock := clock.NewMock()
    rl := NewRateLimiter(mock, time.Second)

    // 第一次应该允许
    assert.True(t, rl.Allow())
    // 立即再次请求，应该拒绝
    assert.False(t, rl.Allow())

    // 将模拟时钟向前拨动 1 秒
    mock.Add(time.Second)

    // 现在应该再次允许
    assert.True(t, rl.Allow())
}