Go语言中时间敏感代码的测试策略：使用接口模拟time.Now()

package mypkg

import "time"

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

// realClock 是 Clock 接口的真实实现
type realClock struct{}

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

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

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

package mypkg_test

import (
    "time"
    "sync"
)

// MockClock 是 Clock 接口的测试实现，允许手动控制时间
type MockClock struct {
    mu      sync.Mutex
    now     time.Time
    afterCh chan time.Time
}

// NewMockClock 创建一个指定初始时间的 MockClock
func NewMockClock(initialTime time.Time) *MockClock {
    return &MockClock{
        now:     initialTime,
        afterCh: make(chan time.Time, 1), // 缓冲区为1，避免阻塞
    }
}

// Now 返回当前模拟的时间
func (mc *MockClock) Now() time.Time {
    mc.mu.Lock()
    defer mc.mu.Unlock()
    return mc.now
}

// After 返回一个通道，用于模拟 time.After
func (mc *MockClock) After(d time.Duration) <-chan time.Time {
    // 在实际测试中，我们通常会手动触发这个通道，而不是真正等待
    // 这里仅为接口实现，实际测试中会更精细地控制
    return mc.afterCh
}

// AdvanceTime 模拟时间前进
func (mc *MockClock) AdvanceTime(d time.Duration) {
    mc.mu.Lock()
    mc.now = mc.now.Add(d)
    mc.mu.Unlock()
    // 如果有等待 After 的 goroutine，可以考虑在此处发送信号
    // 例如：mc.afterCh <- mc.now
}

// SetTime 直接设置当前模拟的时间
func (mc *MockClock) SetTime(t time.Time) {
    mc.mu.Lock()
    mc.now = t
    mc.mu.Unlock()
}

package mypkg

import "time"

// ReservationService 处理预订和释放逻辑
type ReservationService struct {
    clock Clock
    // 其他字段...
}

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

// ReserveSomething 预订一个资源，并在指定时间后释放
func (rs *ReservationService) ReserveSomething(duration time.Duration) (string, error) {
    reservationID := "some-id" // 模拟生成ID
    releaseTime := rs.clock.Now().Add(duration)

    // 启动一个goroutine来模拟在 releaseTime 释放资源
    go func() {
        select {
        case <-rs.clock.After(duration): // 使用注入的 clock.After
            // 模拟释放资源
            // log.Printf("Resource %s released at %s", reservationID, rs.clock.Now().Format(time.RFC3339))
        }
    }()

    return reservationID, nil
}

package mypkg_test

import (
    "mypkg" // 假设 ReservationService 在 mypkg 包中
    "testing"
    "time"
)

func TestReservationService(t *testing.T) {
    initialTime := time.Date(2023, time.January, 1, 10, 0, 0, 0, time.UTC)
    mockClock := NewMockClock(initialTime)
    service := mypkg.NewReservationService(mockClock)

    reservationDuration := 30 * time.Second
    _, err := service.ReserveSomething(reservationDuration)
    if err != nil {
        t.Fatalf("Failed to reserve: %v", err)
    }

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

    // 模拟时间前进，验证资源是否被释放
    // 在实际测试中，可能需要更复杂的同步机制来等待 goroutine 执行
    // 这里仅示意如何控制时间
    mockClock.AdvanceTime(reservationDuration)

    // 在这里添加断言，验证资源是否已释放或相关状态是否正确
    // 例如，通过检查 service 内部状态或模拟的外部系统调用
    // ...
}