Go语言中基于time.Ticker的时间依赖型代码测试指南

package main

import "time"

// Ticker 接口定义了时间滴答器的行为
type Ticker interface {
    Tick() // 模拟等待一个滴答
    Duration() time.Duration // 返回滴答间隔
    Stop() // 停止滴答器
}

// realTicker 是 Ticker 接口的真实实现，封装了 time.Ticker
type realTicker struct {
    *time.Ticker
    interval time.Duration // 存储滴答间隔
}

// NewRealTicker 创建一个 realTicker 实例
func NewRealTicker(interval time.Duration) Ticker {
    return &realTicker{
        Ticker:   time.NewTicker(interval),
        interval: interval,
    }
}

// Tick 方法等待 time.Ticker 的下一个滴答
func (rt *realTicker) Tick() {
    <-rt.Ticker.C
}

// Duration 返回真实的滴答间隔
func (rt *realTicker) Duration() time.Duration {
    return rt.interval
}

// Stop 停止底层的 time.Ticker
func (rt *realTicker) Stop() {
    rt.Ticker.Stop()
}

// mockTicker 是 Ticker 接口的模拟实现，用于测试
type mockTicker struct {
    interval time.Duration
    ticks    int // 记录 Tick 方法被调用的次数
    // 可以添加一个 channel 来模拟真实的 Tick 信号，或直接返回
}

// NewMockTicker 创建一个 mockTicker 实例
func NewMockTicker(interval time.Duration) Ticker {
    return &mockTicker{interval: interval}
}

// Tick 方法在模拟环境中不等待，直接返回或记录调用
func (mt *mockTicker) Tick() {
    mt.ticks++
    // 在更复杂的测试场景中，这里可以发送一个信号到某个 channel
    // 以模拟时间流逝，并允许测试代码同步等待。
}

// Duration 返回模拟的滴答间隔
func (mt *mockTicker) Duration() time.Duration {
    return mt.interval
}

// Stop 方法在模拟环境中通常是空操作
func (mt *mockTicker) Stop() {
    // 可以在这里记录 Stop 被调用的次数或状态
}

// Countdown 函数接收一个 Ticker 接口和总时长，并通过通道返回剩余时间
func Countdown(ticker Ticker, duration time.Duration) chan time.Duration {
    // 使用带缓冲的通道，至少可以发送第一个值而不阻塞
    remainingCh := make(chan time.Duration, 1)

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

        for remaining := dur; remaining >= 0; remaining -= ticker.Duration() {
            remainingCh <- remaining // 发送当前剩余时间
            if remaining > 0 { // 只有在还有剩余时间时才等待下一个滴答
                ticker.Tick()
            }
        }
        ticker.Stop() // 倒计时结束，停止滴答器
    }(ticker, duration, remainingCh)

    return remainingCh
}

// 示例：如何在 main 函数中使用重构后的 Countdown
// func main() {
//     interval := time.Second
//     totalDuration := 10 * time.Second
//     fmt.Printf("开始倒计时：%v，间隔：%v\n", totalDuration, interval)
//     for d := range Countdown(NewRealTicker(interval), totalDuration) {
//         fmt.Printf("%v to go\n", d)
//     }
//     fmt.Println("倒计时结束！")
// }

package main

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

// TestCountdownWithMockTicker 测试 Countdown 函数与 mockTicker
func TestCountdownWithMockTicker(t *testing.T) {
    interval := 1 * time.Second
    totalDuration := 3 * time.Second // 3秒倒计时，间隔1秒，预期输出 3, 2, 1, 0

    mock := NewMockTicker(interval).(*mockTicker) // 类型断言获取 mockTicker 实例

    // 调用 Countdown 函数，传入 mock 滴答器
    remainingCh := Countdown(mock, totalDuration)

    // 预期接收到的剩余时间序列
    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, ok := <-remainingCh:
            if !ok {
                t.Fatalf("通道提前关闭，预期收到 %d 个值", len(expectedDurations))
            }
            receivedDurations = append(receivedDurations, d)
            // 每次接收到一个值后，模拟 ticker 的 Tick() 被调用
            // 注意：Countdown 内部在发送最后一个 0 之后不会再 Tick
            if i < len(expectedDurations)-1 {
                // mock.Tick() 实际上在 Countdown 的 goroutine 内部被调用了
                // 这里我们只是验证结果，不需要手动调用 mock.Tick()
            }
        case <-time.After(100 * time.Millisecond): // 设置一个超时，防止测试无限等待
            t.Fatalf("等待通道数据超时，已接收 %v", receivedDurations)
        }
    }

    // 确保通道已关闭
    select {
    case _, ok := <-remainingCh:
        if ok {
            t.Fatal("通道未关闭")
        }
    case <-time.After(10 * time.Millisecond):
        t.Fatal("等待通道关闭超时")
    }

    // 验证接收到的值是否与预期相符
    if !reflect.DeepEqual(receivedDurations, expectedDurations) {
        t.Errorf("预期接收到 %v，实际接收到 %v", expectedDurations, receivedDurations)
    }

    // 验证 Stop 方法是否被调用 (如果 mockTicker 记录了 Stop 状态)
    // if !mock.stopped { // 假设 mockTicker 有一个 stopped 字段
    //     t.Error("预期 ticker.Stop() 被调用")
    // }
}