Go语言中时间敏感代码的测试策略：接口模拟与最佳实践

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

package mypkg

import (
    "time"
    "sync"
)

// mockClock 是 Clock 接口的模拟实现，用于测试
type mockClock struct {
    mu   sync.Mutex
    now  time.Time
    // 可以添加更多字段来模拟 After 等功能
    // 例如，一个通道列表来模拟多个 After 调用
}

// NewMockClock 创建一个新的 mockClock 实例
func NewMockClock(t time.Time) *mockClock {
    return &mockClock{now: t}
}

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

// SetNow 设置模拟的当前时间
func (mc *mockClock) SetNow(t time.Time) {
    mc.mu.Lock()
    defer mc.mu.Unlock()
    mc.now = t
}

// Add 模拟时间流逝
func (mc *mockClock) Add(d time.Duration) {
    mc.mu.Lock()
    defer mc.mu.Unlock()
    mc.now = mc.now.Add(d)
}

// After 可以根据需要实现，例如返回一个立即关闭的通道或通过手动控制
func (mc *mockClock) After(d time.Duration) <-chan time.Time {
    // 简单的模拟：立即返回一个关闭的通道，或者在测试中手动控制
    ch := make(chan time.Time, 1)
    // 在更复杂的模拟中，你可能需要一个协程来在模拟时间到达后发送时间
    // 但对于大多数单元测试，可能不需要精确模拟 After 的异步行为
    close(ch)
    return ch
}

package mypkg

import "time"

// Service 结构体依赖于 Clock 接口
type Service struct {
    clock Clock
}

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

// ReserveItem 模拟一个需要时间敏感操作的函数
func (s *Service) ReserveItem(itemID string, duration time.Duration) bool {
    startTime := s.clock.Now()
    // 模拟一些业务逻辑，可能需要检查时间
    if startTime.Hour() < 9 || startTime.Hour() > 17 {
        return false // 只能在工作时间预订
    }
    // 假设这里有一些操作，并且需要在 duration 后释放
    // 在测试中，我们可以通过 mockClock.Add(duration) 来模拟时间流逝
    return true
}

package mypkg_test

import (
    "testing"
    "time"
    "your_module_path/mypkg" // 替换为你的实际模块路径
)

func TestService_ReserveItem(t *testing.T) {
    // 创建一个模拟时钟，并设置初始时间
    mockTime := time.Date(2023, time.January, 10, 10, 0, 0, 0, time.UTC)
    mockClock := mypkg.NewMockClock(mockTime)

    // 使用模拟时钟创建服务
    service := mypkg.NewService(mockClock)

    // 测试在工作时间内预订
    if !service.ReserveItem("item1", 30*time.Second) {
        t.Errorf("Expected item to be reserved during working hours")
    }

    // 模拟时间流逝到非工作时间
    mockClock.SetNow(time.Date(2023, time.January, 10, 18, 0, 0, 0, time.UTC))
    if service.ReserveItem("item2", 30*time.Second) {
        t.Errorf("Expected item not to be reserved after working hours")
    }

    // 模拟时间流逝，但保持在工作时间
    mockClock.SetNow(time.Date(2023, time.January, 10, 11, 30, 0, 0, time.UTC))
    if !service.ReserveItem("item3", 60*time.Second) {
        t.Errorf("Expected item to be reserved during working hours after time passes")
    }
}