Files
go-sms-V2/internal/util/snowflake_test.go
T

140 lines
3.6 KiB
Go

package util
import (
"sync"
"testing"
"time"
)
// TestSnowflake_InvalidWorkerID 验证 WorkerID 越界拦截。
func TestSnowflake_InvalidWorkerID(t *testing.T) {
for _, id := range []int64{-1, MaxWorkerID + 1, 4096} {
if _, err := NewSnowflake(id); err == nil {
t.Errorf("workerID=%d 应报错", id)
}
}
if _, err := NewSnowflake(0); err != nil {
t.Errorf("workerID=0 不应报错: %v", err)
}
if _, err := NewSnowflake(MaxWorkerID); err != nil {
t.Errorf("workerID=%d 不应报错: %v", MaxWorkerID, err)
}
}
// TestSnowflake_Structure 验证 ID 位段结构与趋势递增。
func TestSnowflake_Structure(t *testing.T) {
s, err := NewSnowflake(5)
if err != nil {
t.Fatal(err)
}
prev := int64(0)
for i := 0; i < 10000; i++ {
id := s.NextID()
if id <= prev {
t.Fatalf("ID 应严格递增: %d -> %d", prev, id)
}
ms, workerID, seq := DecomposeID(id)
if workerID != 5 {
t.Fatalf("WorkerID 段 = %d, 期望 5", workerID)
}
if ms <= 0 || seq < 0 || seq > maxSequence {
t.Fatalf("位段非法: ms=%d seq=%d", ms, seq)
}
prev = id
}
}
// TestSnowflake_ConcurrentNoConflict 并发场景无 ID 冲突(验收项)。
func TestSnowflake_ConcurrentNoConflict(t *testing.T) {
const workers = 8
const perWorker = 5000
s, _ := NewSnowflake(1023)
var mu sync.Mutex
seen := make(map[int64]struct{}, workers*perWorker)
var wg sync.WaitGroup
for w := 0; w < workers; w++ {
wg.Add(1)
go func() {
defer wg.Done()
local := make([]int64, 0, perWorker)
for i := 0; i < perWorker; i++ {
local = append(local, s.NextID())
}
mu.Lock()
defer mu.Unlock()
for _, id := range local {
if _, dup := seen[id]; dup {
t.Errorf("ID 冲突: %d", id)
return
}
seen[id] = struct{}{}
}
}()
}
wg.Wait()
if len(seen) != workers*perWorker {
t.Errorf("唯一 ID 数 = %d, 期望 %d", len(seen), workers*perWorker)
}
}
// TestSnowflake_MultiInstanceDistinct 同毫秒下不同 WorkerID 的 ID 互不相同。
func TestSnowflake_MultiInstanceDistinct(t *testing.T) {
s1, _ := NewSnowflake(1)
s2, _ := NewSnowflake(2)
set := make(map[int64]struct{})
for i := 0; i < 1000; i++ {
set[s1.NextID()] = struct{}{}
set[s2.NextID()] = struct{}{}
}
if len(set) != 2000 {
t.Errorf("跨实例 ID 冲突: 唯一数 %d, 期望 2000", len(set))
}
}
// TestSnowflake_WorkIDGetter 验证 WorkerID 读取方法。
func TestSnowflake_WorkIDGetter(t *testing.T) {
s, _ := NewSnowflake(42)
if s.WorkerID() != 42 {
t.Errorf("WorkerID() = %d, 期望 42", s.WorkerID())
}
if _, wid, _ := DecomposeID(s.NextID()); wid != 42 {
t.Errorf("DecomposeID worker 段 = %d, 期望 42", wid)
}
}
// TestSnowflake_SequenceExhausted 白盒触发同毫秒序列耗尽:等待下一毫秒继续。
func TestSnowflake_SequenceExhausted(t *testing.T) {
s, _ := NewSnowflake(7)
s.mu.Lock()
s.lastTS = nowMillis() - Epoch // 锁定在当前毫秒
s.seq = maxSequence // 序列即将耗尽
s.mu.Unlock()
if _, _, seq := DecomposeID(s.NextID()); seq > maxSequence {
t.Fatalf("耗尽后序列非法: %d", seq)
}
if _, _, seq := DecomposeID(s.NextID()); seq > maxSequence {
t.Fatalf("序列越界: %d", seq)
}
}
// TestSnowflake_ClockBackward 白盒触发时钟回拨:NextID 等待追平后正常生成。
func TestSnowflake_ClockBackward(t *testing.T) {
s, _ := NewSnowflake(9)
s.mu.Lock()
s.lastTS = nowMillis() - Epoch + 80 // 人为领先 80ms 模拟回拨
s.mu.Unlock()
done := make(chan int64, 1)
go func() { done <- s.NextID() }()
select {
case id := <-done:
if id <= 0 {
t.Fatalf("回拨追平后 ID 非法: %d", id)
}
case <-time.After(3 * time.Second):
t.Fatal("时钟回拨自旋等待超时")
}
}