221 lines
5.9 KiB
Go
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 应报错")
|
|
}
|
|
}
|