Go语言测试中模拟时间：使用接口实现time.Now()的灵活控制

package mypkg

import "time"

// Clock 接口定义了时间操作的抽象
type Clock interface {
    Now() time.Time
    After(d time.Duration) <-chan time.Time
}

package mypkg

import "time"

// realClock 是 Clock 接口的真实实现，使用标准库 time 包
type realClock struct{}

func (realClock) Now() time.Time {
    return time.Now()
}

func (realClock) After(d time.Duration) <-chan time.Time {
    return time.After(d)
}

// DefaultClock 是一个全局可用的 realClock 实例
var DefaultClock Clock = realClock{}

package mypkg

import (
    "sync"
    "time"
)

// mockClock 是 Clock 接口的模拟实现，用于测试
type mockClock struct {
    mu   sync.Mutex
    now  time.Time
    chans []chan time.Time // 用于模拟 After
}

// NewMockClock 创建一个新的 mockClock 实例，初始时间为 t
func NewMockClock(t time.Time) *mockClock {
    return &mockClock{
        now: t,
    }
}

func (mc *mockClock) Now() time.Time {
    mc.mu.Lock()
    defer mc.mu.Unlock()
    return mc.now
}

// AdvanceBy 将当前时间向前推进指定的持续时间
func (mc *mockClock) AdvanceBy(d time.Duration) {
    mc.mu.Lock()
    defer mc.mu.Unlock()
    mc.now = mc.now.Add(d)

    // 触发所有已注册的 After 通道
    for _, ch := range mc.chans {
        select {
        case ch <- mc.now:
        default:
            // 如果通道未准备好接收，则跳过
        }
    }
    mc.chans = nil // 清空已触发的通道
}

func (mc *mockClock) After(d time.Duration) <-chan time.Time {
    mc.mu.Lock()
    defer mc.mu.Unlock()

    ch := make(chan time.Time, 1) // 缓冲区为1，防止AdvanceBy阻塞
    // 如果模拟时间已经超过了 d，则立即发送
    if mc.now.Add(d).Before(mc.now) { // 这是一个错误的判断，应该是 mc.now 已经超过了某个点
        // 修正：如果模拟时间已经到达或超过了目标时间点
        // 实际上，mockClock 的 After 应该在 AdvanceBy 时触发
        // 所以这里只是注册通道，等待 AdvanceBy 触发
    }
    mc.chans = append(mc.chans, ch)
    return ch
}

// 注意：mockClock 的 After 实现需要更精细的逻辑来模拟 time.After
// 一个更简单的 mockClock.After 可能是这样的：
// func (mc *mockClock) After(d time.Duration) <-chan time.Time {
//     ch := make(chan time.Time, 1)
//     // 在测试中，通常我们会手动调用 AdvanceBy 来推进时间
//     // 所以这里的 After 只是返回一个通道，等待 AdvanceBy 来发送时间
//     // 或者，更复杂的实现会维护一个待触发事件列表
//     return ch
// }
// 为了简化，上面的 AdvanceBy 已经包含了触发逻辑。

package mypkg

import (
    "fmt"
    "time"
)

// ReservationManager 管理预订，需要知道当前时间
type ReservationManager struct {
    clock Clock
    // 其他字段...
}

// NewReservationManager 创建一个新的 ReservationManager
func NewReservationManager(c Clock) *ReservationManager {
    return &ReservationManager{
        clock: c,
    }
}

// Reserve 模拟一个预订操作，并在一段时间后释放
func (rm *ReservationManager) Reserve(id string, duration time.Duration) string {
    startTime := rm.clock.Now()
    fmt.Printf("[%s] 预订 %s 开始于 %s\n", rm.clock.Now().Format(time.RFC3339), id, startTime.Format(time.RFC3339))

    // 模拟等待
    <-rm.clock.After(duration)

    releaseTime := rm.clock.Now()
    fmt.Printf("[%s] 预订 %s 释放于 %s\n", rm.clock.Now().Format(time.RFC3339), id, releaseTime.Format(time.RFC3339))
    return fmt.Sprintf("Reservation %s completed from %s to %s", id, startTime.Format(time.RFC3339), releaseTime.Format(time.RFC3339))
}

package mypkg_test

import (
    "testing"
    "time"
    "mypkg" // 假设你的代码在 mypkg 包中
)

func TestReservationManager(t *testing.T) {
    // 初始化一个模拟时钟，设置初始时间
    mockTime := time.Date(2023, time.January, 1, 10, 0, 0, 0, time.UTC)
    mc := mypkg.NewMockClock(mockTime)

    // 使用模拟时钟创建 ReservationManager
    rm := mypkg.NewReservationManager(mc)

    // 启动一个 goroutine 来执行 Reserve 操作，因为它会阻塞
    done := make(chan string)
    go func() {
        result := rm.Reserve("item-123", 30*time.Second)
        done <- result
    }()

    // 验证初始时间
    if mc.Now() != mockTime {
        t.Errorf("Expected initial mock time %v, got %v", mockTime, mc.Now())
    }

    // 模拟时间推进 15 秒
    mc.AdvanceBy(15 * time.Second)
    expectedTime1 := mockTime.Add(15 * time.Second)
    if mc.Now() != expectedTime1 {
        t.Errorf("Expected mock time after 15s %v, got %v", expectedTime1, mc.Now())
    }

    // 模拟时间再推进 15 秒，总共 30 秒，触发 Reserve 的释放
    mc.AdvanceBy(15 * time.Second)
    expectedTime2 := mockTime.Add(30 * time.Second)
    if mc.Now() != expectedTime2 {
        t.Errorf("Expected mock time after 30s %v, got %v", expectedTime2, mc.Now())
    }

    // 从 goroutine 接收结果，确保 Reserve 完成
    select {
    case res := <-done:
        expectedResult := "Reservation item-123 completed from 2023-01-01T10:00:00Z to 2023-01-01T10:00:30Z"
        if res != expectedResult {
            t.Errorf("Expected result %q, got %q", expectedResult, res)
        }
    case <-time.After(100 * time.Millisecond): // 设置一个短的超时，防止测试永远等待
        t.Fatal("Reservation did not complete in time")
    }
}

// package mytime
var currentClock Clock = realClock{} // 默认使用真实时钟

func SetClock(c Clock) {
    currentClock = c
}

func Now() time.Time {
    return currentClock.Now()
}
// ...