Go语言中time.Ticker的测试策略与最佳实践

type TickFunc func(d time.Duration)

func Countdown(duration time.Duration, interval time.Duration, tickCallback TickFunc) {
    ticker := time.NewTicker(interval)
    defer ticker.Stop() // 确保ticker停止

    for remaining := duration; remaining >= 0; remaining -= interval {
        tickCallback(remaining)
        if remaining > 0 { // 避免在最后一次迭代后等待
            <-ticker.C
        }
    }
}

// Ticker接口定义了我们期望的定时器行为
type Ticker interface {
    C() <-chan time.Time // 返回一个只读通道，模拟时间“滴答”事件
    Stop()               // 停止定时器
    Duration() time.Duration // 获取定时器的间隔
}

// RealTicker是对time.Ticker的包装，使其符合Ticker接口
type RealTicker struct {
    *time.Ticker
    interval time.Duration
}

func NewRealTicker(interval time.Duration) Ticker {
    return &RealTicker{
        Ticker:   time.NewTicker(interval),
        interval: interval,
    }
}

func (r *RealTicker) C() <-chan time.Time {
    return r.Ticker.C
}

func (r *RealTicker) Stop() {
    r.Ticker.Stop()
}

func (r *RealTicker) Duration() time.Duration {
    return r.interval
}

// 初始的Countdown函数，接受一个Ticker接口
func CountdownWithInterface(ticker Ticker, duration time.Duration, tickCallback TickFunc) {
    defer ticker.Stop()

    for remaining := duration; remaining >= 0; remaining -= ticker.Duration() {
        tickCallback(remaining)
        if remaining > 0 {
            <-ticker.C() // 使用接口的C()方法
        }
    }
}

// Countdown函数返回一个通道，用于发送剩余时间
func Countdown(ticker Ticker, duration time.Duration) chan time.Duration {
    remainingCh := make(chan time.Duration, 1) // 使用带缓冲的通道，避免初始发送阻塞

    go func(ticker Ticker, dur time.Duration, ch chan time.Duration) {
        defer ticker.Stop()
        defer close(ch) // 确保通道在函数退出时关闭

        currentDuration := dur
        for currentDuration >= 0 {
            ch <- currentDuration // 发送当前剩余时间
            currentDuration -= ticker.Duration()

            if currentDuration >= 0 { // 只有当还有剩余时间时才等待下一个tick
                <-ticker.C()
            }
        }
    }(ticker, duration, remainingCh)

    return remainingCh
}

func main() {
    // 生产环境中使用真实的Ticker
    realTicker := NewRealTicker(time.Second)
    for d := range Countdown(realTicker, 5*time.Second) {
        fmt.Printf("%v to go\n", d)
    }
    fmt.Println("Countdown finished!")
}

// MockTicker是一个用于测试的Ticker实现
type MockTicker struct {
    tickCh   chan time.Time
    stopCh   chan struct{}
    interval time.Duration
}

func NewMockTicker(interval time.Duration) *MockTicker {
    return &MockTicker{
        tickCh:   make(chan time.Time),
        stopCh:   make(chan struct{}),
        interval: interval,
    }
}

func (m *MockTicker) C() <-chan time.Time {
    return m.tickCh
}

func (m *MockTicker) Stop() {
    close(m.stopCh) // 关闭stopCh表示停止
    // 为了确保所有goroutine都能感知到stop，可以考虑关闭tickCh
    // 但需要注意，如果在Stop之后还有goroutine尝试写入tickCh会panic
    // 更好的做法是依赖select语句中的stopCh来优雅退出
}

func (m *MockTicker) Duration() time.Duration {
    return m.interval
}

// Tick手动触发一次“滴答”事件
func (m *MockTicker) Tick() {
    m.tickCh <- time.Now()
}

import (
    "testing"
    "time"
    "github.com/stretchr/testify/assert" // 示例中使用assert库
)

func TestCountdownWithMockTicker(t *testing.T) {
    interval := 1 * time.Second
    duration := 3 * time.Second // 倒计时从3s开始，0s结束，共4个值 (3, 2, 1, 0)

    mockTicker := NewMockTicker(interval)

    // 启动Countdown函数
    remainingCh := Countdown(mockTicker, duration)

    expectedDurations := []time.Duration{3 * time.Second, 2 * time.Second, 1 * time.Second, 0 * time.Second}
    receivedDurations := []time.Duration{}

    // 模拟时间流逝并收集结果
    for i := 0; i < len(expectedDurations); i++ {
        select {
        case d := <-remainingCh:
            receivedDurations = append(receivedDurations, d)
        case <-time.After(100 * time.Millisecond): // 设置一个短的超时，防止测试无限等待
            t.Fatalf("Test timed out waiting for duration %d", i)
        }
        // 只有在还有更多tick时才触发下一个
        if i < len(expectedDurations)-1 {
            mockTicker.Tick() // 手动触发下一个“滴答”
        }
    }

    // 验证所有预期值是否都被接收
    assert.Equal(t, expectedDurations, receivedDurations, "The countdown durations should match")

    // 确保通道在所有值发送完毕后被关闭
    select {
    case _, ok := <-remainingCh:
        assert.False(t, ok, "The remaining channel should be closed")
    case <-time.After(100 * time.Millisecond):
        t.Fatal("Test timed out waiting for channel close")
    }
}