Files

221 lines
5.9 KiB
Go

package lock
import (
"context"
"errors"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/alicebob/miniredis/v2"
"github.com/redis/go-redis/v9"
)
// newMiniClient 启动 miniredis 并返回直连客户端。
func newMiniClient(t *testing.T) redis.UniversalClient {
t.Helper()
mr := miniredis.RunT(t)
return redis.NewClient(&redis.Options{Addr: mr.Addr()})
}
// TestTryLock_MutualExclusion 验证锁互斥与释放后可再获取。
func TestTryLock_MutualExclusion(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
ctx := context.Background()
l1, err := lk.TryLock(ctx, "go-sms:lock:1", 10*time.Second)
if err != nil {
t.Fatalf("首次 TryLock 失败: %v", err)
}
if _, err := lk.TryLock(ctx, "go-sms:lock:1", 10*time.Second); !errors.Is(err, ErrLockHeld) {
t.Fatalf("重复 TryLock 应返回 ErrLockHeld, 实际: %v", err)
}
if err := l1.Unlock(ctx); err != nil {
t.Fatalf("Unlock 失败: %v", err)
}
l2, err := lk.TryLock(ctx, "go-sms:lock:1", 10*time.Second)
if err != nil {
t.Fatalf("释放后 TryLock 应成功, 实际: %v", err)
}
_ = l2.Unlock(ctx)
}
// TestUnlock_NotHeld 验证误删保护:value 不匹配时不删除他人锁。
func TestUnlock_NotHeld(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
ctx := context.Background()
l1, err := lk.TryLock(ctx, "go-sms:lock:2", 10*time.Second)
if err != nil {
t.Fatalf("TryLock 失败: %v", err)
}
// 模拟锁被覆盖(他人以不同 token 抢到)
if err := c.Set(ctx, "go-sms:lock:2", "other-token", 10*time.Second).Err(); err != nil {
t.Fatal(err)
}
if err := l1.Unlock(ctx); !errors.Is(err, ErrLockNotHeld) {
t.Fatalf("value 不匹配的 Unlock 应返回 ErrLockNotHeld, 实际: %v", err)
}
// 他人锁不应被误删
if c.Get(ctx, "go-sms:lock:2").Val() != "other-token" {
t.Fatal("误删了他人锁")
}
// 已释放的锁再次 Unlock
if err := l1.Unlock(ctx); !errors.Is(err, ErrLockNotHeld) {
t.Fatalf("二次 Unlock 应返回 ErrLockNotHeld, 实际: %v", err)
}
}
// TestWatchdog_AutoRenew 验证 watchdog 自动续期:TTL 内未 Unlock,锁不过期。
func TestWatchdog_AutoRenew(t *testing.T) {
mr := miniredis.RunT(t)
c := redis.NewClient(&redis.Options{Addr: mr.Addr()})
lk := New(c)
ctx := context.Background()
const ttl = 200 * time.Millisecond
l1, err := lk.TryLock(ctx, "go-sms:lock:3", ttl)
if err != nil {
t.Fatalf("TryLock 失败: %v", err)
}
// 等待远超 TTL(续期间隔 ttl/3≈67ms,期间应完成多次续期)
time.Sleep(3 * ttl)
if !mr.Exists("go-sms:lock:3") {
t.Fatal("watchdog 未续期:锁在 TTL 后丢失")
}
if err := l1.Unlock(ctx); err != nil {
t.Fatalf("Unlock 失败: %v", err)
}
if mr.Exists("go-sms:lock:3") {
t.Fatal("Unlock 后 key 应删除")
}
}
// TestWatchdog_StopsAfterUnlock 验证 Unlock 后续期协程停止(不再复活 key)。
func TestWatchdog_StopsAfterUnlock(t *testing.T) {
mr := miniredis.RunT(t)
c := redis.NewClient(&redis.Options{Addr: mr.Addr()})
lk := New(c)
ctx := context.Background()
l1, err := lk.TryLock(ctx, "go-sms:lock:4", 300*time.Millisecond)
if err != nil {
t.Fatalf("TryLock 失败: %v", err)
}
if err := l1.Unlock(ctx); err != nil {
t.Fatalf("Unlock 失败: %v", err)
}
time.Sleep(400 * time.Millisecond) // 超过原 TTL
if mr.Exists("go-sms:lock:4") {
t.Fatal("Unlock 后 watchdog 不应再续期复活 key")
}
}
// TestLock_Blocking 验证阻塞获取:他人释放后等待者获得锁。
func TestLock_Blocking(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
ctx := context.Background()
l1, err := lk.TryLock(ctx, "go-sms:lock:5", 5*time.Second)
if err != nil {
t.Fatalf("TryLock 失败: %v", err)
}
var got int32
done := make(chan struct{})
go func() {
defer close(done)
ctx2, cancel := context.WithTimeout(ctx, 3*time.Second)
defer cancel()
l2, err := lk.Lock(ctx2, "go-sms:lock:5", 5*time.Second)
if err != nil {
t.Errorf("阻塞 Lock 失败: %v", err)
return
}
atomic.StoreInt32(&got, 1)
_ = l2.Unlock(context.Background())
}()
time.Sleep(300 * time.Millisecond) // 确保等待者已在轮询
if atomic.LoadInt32(&got) != 0 {
t.Fatal("锁未释放前等待者不应获得锁")
}
if err := l1.Unlock(ctx); err != nil {
t.Fatalf("Unlock 失败: %v", err)
}
select {
case <-done:
case <-time.After(2 * time.Second):
t.Fatal("等待者未在超时内获得锁")
}
if atomic.LoadInt32(&got) != 1 {
t.Fatal("等待者应成功获得锁")
}
}
// TestLock_ContextCanceled 验证 ctx 取消时阻塞 Lock 返回错误。
func TestLock_ContextCanceled(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
ctx, cancel := context.WithCancel(context.Background())
l1, _ := lk.TryLock(ctx, "go-sms:lock:6", 5*time.Second)
defer func() { _ = l1.Unlock(context.Background()) }()
go func() {
time.Sleep(200 * time.Millisecond)
cancel()
}()
start := time.Now()
if _, err := lk.Lock(ctx, "go-sms:lock:6", 5*time.Second); !errors.Is(err, context.Canceled) {
t.Fatalf("ctx 取消应返回 context.Canceled, 实际: %v", err)
}
if time.Since(start) > time.Second {
t.Fatal("取消后应迅速返回")
}
}
// TestTryLock_Concurrency 并发场景:同一 key 仅一个持有者成功。
func TestTryLock_Concurrency(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
ctx := context.Background()
const n = 16
var mu sync.Mutex
acquired := 0
var wg sync.WaitGroup
for i := 0; i < n; i++ {
wg.Add(1)
go func() {
defer wg.Done()
got, err := lk.TryLock(ctx, "go-sms:lock:7", 2*time.Second)
if err == nil {
mu.Lock()
acquired++
mu.Unlock()
time.Sleep(50 * time.Millisecond) // 模拟临界区
_ = got.Unlock(context.Background())
}
}()
}
wg.Wait()
if acquired == 0 {
t.Fatal("并发下至少应有一次获取成功")
}
}
// TestTryLock_InvalidTTL 验证非法 TTL 拦截。
func TestTryLock_InvalidTTL(t *testing.T) {
c := newMiniClient(t)
lk := New(c)
if _, err := lk.TryLock(context.Background(), "k", 0); err == nil {
t.Fatal("ttl=0 应报错")
}
}