Go语言中测试时间敏感代码的策略与实践

package myapp

import "time"

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

package myapp

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)
}

// NewRealClock 返回一个 realClock 实例
func NewRealClock() Clock {
    return realClock{}
}

package myapp_test // 通常在 _test 包中定义测试辅助结构

import (
    "sync"
    "time"
)

// testClock 是 Clock 接口的测试实现，允许手动控制时间
type testClock struct {
    mu   sync.RWMutex
    now  time.Time
    // 用于模拟 After 的通道列表
    afterChans []chan time.Time
}

// NewTestClock 创建一个新的 testClock 实例，初始化为指定时间
func NewTestClock(initialTime time.Time) *testClock {
    return &testClock{
        now: initialTime,
    }
}

func (tc *testClock) Now() time.Time {
    tc.mu.RLock()
    defer tc.mu.RUnlock()
    return tc.now
}

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

    ch := make(chan time.Time, 1) // 缓冲通道，避免阻塞
    tc.afterChans = append(tc.afterChans, ch)
    // 如果模拟时间已经超过了 d，则立即发送
    if d <= 0 { // 简化处理，实际可能需要更复杂的逻辑
        ch <- tc.now
    }
    return ch
}

// Add 模拟时间流逝，并触发 After 通道
func (tc *testClock) Add(d time.Duration) {
    tc.mu.Lock()
    defer tc.mu.Unlock()
    tc.now = tc.now.Add(d)

    // 触发所有等待中的 After 通道
    for _, ch := range tc.afterChans {
        select {
        case ch <- tc.now:
        default:
            // 如果通道已满或已关闭，则跳过
        }
    }
    tc.afterChans = nil // 清空已触发的通道
}

package myapp

import "time"

// ReservationManager 管理预留资源的生命周期
type ReservationManager struct {
    clock Clock
    // 其他字段，如存储预留信息的 map
}

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

// Reserve 预留一个资源，并在指定时间后释放
func (rm *ReservationManager) Reserve(resourceID string, duration time.Duration) {
    // 实际的预留逻辑...
    go func() {
        <-rm.clock.After(duration) // 使用抽象的 After 方法
        // 释放资源逻辑...
        // fmt.Printf("Resource %s released at %s\n", resourceID, rm.clock.Now())
    }()
}

// GetCurrentTime 获取当前时间
func (rm *ReservationManager) GetCurrentTime() time.Time {
    return rm.clock.Now() // 使用抽象的 Now 方法
}

package myapp_test

import (
    "myapp" // 假设 myapp 是你的模块名
    "testing"
    "time"
)

func TestReservationManager(t *testing.T) {
    initialTime := time.Date(2023, time.January, 1, 10, 0, 0, 0, time.UTC)
    mockClock := NewTestClock(initialTime)
    manager := myapp.NewReservationManager(mockClock)

    resourceID := "test-resource-1"
    reserveDuration := 30 * time.Second

    manager.Reserve(resourceID, reserveDuration)

    // 验证初始时间
    if manager.GetCurrentTime() != initialTime {
        t.Errorf("Expected current time %v, got %v", initialTime, manager.GetCurrentTime())
    }

    // 模拟时间流逝
    mockClock.Add(reserveDuration)

    // 此时，资源应该已经被释放，可以添加断言来验证释放逻辑
    // 例如，检查资源状态是否变为可用
    // if !manager.IsResourceAvailable(resourceID) {
    //  t.Errorf("Resource %s should have been released", resourceID)
    // }

    // 再次模拟时间流逝，检查是否仍然正常
    mockClock.Add(1 * time.Minute)
    expectedTime := initialTime.Add(reserveDuration).Add(1 * time.Minute)
    if manager.GetCurrentTime() != expectedTime {
        t.Errorf("Expected current time %v, got %v", expectedTime, manager.GetCurrentTime())
    }
}