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

package main

import (
    "time"
)

type TickFunc func(d time.Duration)

// Countdown 函数在指定持续时间内，以指定间隔调用tickCallback
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 { // 确保在最后一次回调后不再等待
            break
        }
        <-ticker.C
    }
}

// 示例测试，不推荐用于复杂或严格的时间测试
func TestCountdownWithSmallInterval(t *testing.T) {
    var calls []time.Duration
    mockTickFunc := func(d time.Duration) {
        calls = append(calls, d)
    }

    duration := 3 * time.Millisecond
    interval := 1 * time.Millisecond
    Countdown(duration, interval, mockTickFunc)

    expectedCalls := []time.Duration{3 * time.Millisecond, 2 * time.Millisecond, 1 * time.Millisecond, 0 * time.Millisecond}
    if !reflect.DeepEqual(calls, expectedCalls) {
        t.Errorf("Expected %v, got %v", expectedCalls, calls)
    }
}

// Ticker 接口定义了我们期望的计时器行为
type Ticker interface {
    C() <-chan time.Time // 用于模拟时间流逝的通道
    Stop()               // 停止计时器
    Duration() time.Duration // 获取计时器的间隔
}

// realTicker 结构体是 time.Ticker 的适配器
type realTicker struct {
    *time.Ticker
    interval time.Duration
}

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

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

// NewRealTicker 是创建真实 Ticker 的辅助函数
func NewRealTicker(d time.Duration) Ticker {
    return &realTicker{Ticker: time.NewTicker(d), interval: d}
}

// Countdown 函数现在接受一个 Ticker 接口
// 注意：原始的TickFunc回调在Go中通常被认为是“代码异味”，后面会改进
func CountdownWithInterface(ticker Ticker, duration time.Duration, tickCallback TickFunc) {
    defer ticker.Stop()

    interval := ticker.Duration() // 从Ticker接口获取间隔
    for remaining := duration; remaining >= 0; remaining -= interval {
        tickCallback(remaining)
        if remaining <= 0 {
            break
        }
        <-ticker.C() // 使用接口的C()方法
    }
}

// Countdown 函数现在返回一个通道，用于发送剩余时间
// 结合了接口注入和通道通信
func Countdown(ticker Ticker, duration time.Duration) chan time.Duration {
    remainingCh := make(chan time.Duration, 1) // 使用缓冲通道避免阻塞

    go func() {
        defer close(remainingCh) // 确保通道在协程结束时关闭
        defer ticker.Stop()

        interval := ticker.Duration()
        for remaining := duration; remaining >= 0; remaining -= interval {
            remainingCh <- remaining // 发送剩余时间
            if remaining <= 0 {
                break
            }
            <-ticker.C() // 等待下一个tick
        }
    }()
    return remainingCh
}

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

// MockTicker 用于测试，可以手动控制其Tick
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) // 通知停止
    // 关闭tickCh可能导致测试中的panic，通常不直接关闭
    // 而是依赖垃圾回收或在测试结束后显式清理
}

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

// Tick 手动触发一次tick
func (m *MockTicker) Tick() {
    select {
    case m.tickCh <- time.Now():
    case <-m.stopCh: // 如果已被停止，则不发送
    }
}

package main

import (
    "reflect"
    "testing"
    "time"
)

// (此处省略上面定义的 Ticker 接口、realTicker、NewRealTicker、Countdown 函数和 MockTicker 定义)

func TestCountdown(t *testing.T) {
    mockTicker := NewMockTicker(1 * time.Second)
    duration := 3 * time.Second

    // 启动Countdown函数，它将在后台运行
    remainingCh := Countdown(mockTicker, duration)

    var receivedDurations []time.Duration

    // 模拟时间流逝并收集结果
    // 第一次发送 3s
    receivedDurations = append(receivedDurations, <-remainingCh)
    mockTicker.Tick() // 模拟 1s 过去

    // 第二次发送 2s
    receivedDurations = append(receivedDurations, <-remainingCh)
    mockTicker.Tick() // 模拟 1s 过去

    // 第三次发送 1s
    receivedDurations = append(receivedDurations, <-remainingCh)
    mockTicker.Tick() // 模拟 1s 过去

    // 第四次发送 0s
    receivedDurations = append(receivedDurations, <-remainingCh)

    // 确保通道已关闭，表示倒计时结束
    _, ok := <-remainingCh
    if ok {
        t.Error("Expected remaining channel to be closed")
    }

    expectedDurations := []time.Duration{3 * time.Second, 2 * time.Second, 1 * time.Second, 0 * time.Second}
    if !reflect.DeepEqual(receivedDurations, expectedDurations) {
        t.Errorf("Expected durations %v, got %v", expectedDurations, receivedDurations)
    }
}