Files
go-sms-V2/internal/service/send/timer_test.go
T

251 lines
8.1 KiB
Go

// timer_test.go Day 45:定时调度单测——miniredis 真 ZSet 队列+sqlite:
// 到点认领分发终态/幂等二轮/未来不入/改期重排/取消清理/纯 DB 降级/分发错误回滚重试。
package send
import (
"context"
"testing"
"time"
"github.com/alicebob/miniredis/v2"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
"go-sms/internal/model/entity"
"go-sms/internal/pkg/cache"
)
// newTimerDB 定时域测试库。
func newTimerDB(t *testing.T) *gorm.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
if err != nil {
t.Fatal(err)
}
for _, m := range []any{&entity.MessageTask{}, &entity.MessageDetail{}} {
if err := db.Migrator().CreateTable(m); err != nil {
t.Fatal(err)
}
}
return db
}
// newTestQueue miniredis 真队列。
func newTestQueue(t *testing.T) (*RedisZSetQueue, *miniredis.Miniredis) {
t.Helper()
mr := miniredis.RunT(t)
rc, err := cache.New(cache.Options{Addrs: []string{mr.Addr()}})
if err != nil {
t.Fatal(err)
}
return NewRedisZSetQueue(rc, QueueKey()), mr
}
// fakeDispatcher 测试分发器(记录调用;可注入系统性错误)。
type fakeDispatcher struct {
calls []int64
err error
}
func (f *fakeDispatcher) Dispatch(_ context.Context, task *entity.MessageTask) (int64, int64, error) {
if f.err != nil {
return 0, 0, f.err
}
f.calls = append(f.calls, task.ID)
return int64(task.MobileCount), 0, nil
}
var ttSeq int64
// mkTimerTask 直插定时任务(默认 免审/待发/2 号码)。
func mkTimerTask(t *testing.T, db *gorm.DB, at time.Time, audit int8) *entity.MessageTask {
t.Helper()
ttSeq++
task := &entity.MessageTask{
TaskNo: "TT" + time.Now().Format("150405.000000000") + "_",
AccountID: 1001, SendType: SendTypeTimer, Content: "【店】测试", Sign: "店",
MobileCount: 2, AuditStatus: audit, Status: 0, ScheduleAt: &at,
}
task.TaskNo += time.Duration(ttSeq).String()
if err := db.Create(task).Error; err != nil {
t.Fatal(err)
}
for i := 0; i < 2; i++ {
d := entity.MessageDetail{TaskID: task.ID, AccountID: 1001,
Mobile: "1380013800", Content: task.Content, Status: 0}
d.ID = int64(9000000000 + task.ID*10 + int64(i))
if err := db.Create(&d).Error; err != nil {
t.Fatal(err)
}
}
return task
}
func getTask(t *testing.T, db *gorm.DB, id int64) entity.MessageTask {
t.Helper()
var task entity.MessageTask
if err := db.First(&task, id).Error; err != nil {
t.Fatal(err)
}
return task
}
// TestTimerDueClaimDispatch 到点认领→分发→终态→出队;二轮幂等。
func TestTimerDueClaimDispatch(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
past := time.Now().Add(-time.Minute)
task := mkTimerTask(t, db, past, 3) // 免审+已到点
fd := &fakeDispatcher{}
s := NewTimerScheduler(db, q, fd)
enq, claimed, done, err := s.ScanOnce(ctx)
if err != nil || enq != 1 || claimed != 1 || done != 1 {
t.Fatalf("首轮 enq=%d claimed=%d done=%d err=%v", enq, claimed, done, err)
}
got := getTask(t, db, task.ID)
if got.Status != 2 || got.SuccessCount != 2 || got.FinishedAt == nil {
t.Fatalf("终态不符: status=%d success=%d finished=%v", got.Status, got.SuccessCount, got.FinishedAt)
}
if n, _ := q.rc.ZCard(ctx, QueueKey()).Result(); n != 0 {
t.Fatalf("终态应出队, ZCard=%d", n)
}
// 二轮:幂等(无认领无重复分发)。
_, c2, d2, err := s.ScanOnce(ctx)
if err != nil || c2 != 0 || d2 != 0 || len(fd.calls) != 1 {
t.Fatalf("二轮非幂等: c2=%d d2=%d calls=%d err=%v", c2, d2, len(fd.calls), err)
}
}
// TestTimerFutureNotClaimed 未来任务仅入队不认领;Due 不含未来。
func TestTimerFutureNotClaimed(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
mkTimerTask(t, db, time.Now().Add(time.Hour), 3)
s := NewTimerScheduler(db, q, &fakeDispatcher{})
enq, claimed, _, err := s.ScanOnce(ctx)
if err != nil || enq != 1 || claimed != 0 {
t.Fatalf("未来任务: enq=%d claimed=%d err=%v", enq, claimed, err)
}
if ids, _ := q.Due(ctx, time.Now(), 100); len(ids) != 0 {
t.Fatalf("Due 误含未来: %v", ids)
}
}
// TestTimerRescheduleRequeue 改期:旧时刻到点认领失败→按新时刻重排→新到点发出。
func TestTimerRescheduleRequeue(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
past := time.Now().Add(-time.Minute)
task := mkTimerTask(t, db, past, 1) // 已通过+旧时刻已到
if err := q.Enqueue(ctx, task.ID, past); err != nil {
t.Fatal(err)
}
// 改期到未来(模拟 Reschedule 只动 DB,ZSet 残留旧 score)。
future := time.Now().Add(time.Hour)
if err := db.Model(task).Update("schedule_at", future).Error; err != nil {
t.Fatal(err)
}
s := NewTimerScheduler(db, q, &fakeDispatcher{})
_, claimed, _, err := s.ScanOnce(ctx)
if err != nil || claimed != 0 {
t.Fatalf("旧时刻不应认领: claimed=%d err=%v", claimed, err)
}
// 补偿已按新 score 覆盖→模拟到点(新时刻调回过去)后应发出。
if err := db.Model(task).Update("schedule_at", time.Now().Add(-time.Second)).Error; err != nil {
t.Fatal(err)
}
_, claimed2, done2, err := s.ScanOnce(ctx)
if err != nil || claimed2 != 1 || done2 != 1 {
t.Fatalf("新时刻应认领分发: claimed=%d done=%d err=%v", claimed2, done2, err)
}
}
// TestTimerCanceledRemoved 取消任务索引残留→认领失败→出队清理。
func TestTimerCanceledRemoved(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
past := time.Now().Add(-time.Minute)
task := mkTimerTask(t, db, past, 3)
if err := db.Model(task).Update("status", 3).Error; err != nil { // 已取消
t.Fatal(err)
}
if err := q.Enqueue(ctx, task.ID, past); err != nil { // 残留索引
t.Fatal(err)
}
s := NewTimerScheduler(db, q, &fakeDispatcher{})
if _, claimed, _, err := s.ScanOnce(ctx); err != nil || claimed != 0 {
t.Fatalf("取消任务不应认领: claimed=%d err=%v", claimed, err)
}
if n, _ := q.rc.ZCard(ctx, QueueKey()).Result(); n != 0 {
t.Fatalf("取消应清理索引, ZCard=%d", n)
}
}
// TestTimerDBFallback Redis 缺失(q=nil)纯 DB 扫描降级。
func TestTimerDBFallback(t *testing.T) {
db := newTimerDB(t)
ctx := context.Background()
task := mkTimerTask(t, db, time.Now().Add(-time.Second), 3)
s := NewTimerScheduler(db, nil, &fakeDispatcher{})
_, claimed, done, err := s.ScanOnce(ctx)
if err != nil || claimed != 1 || done != 1 {
t.Fatalf("DB 降级模式: claimed=%d done=%d err=%v", claimed, done, err)
}
if got := getTask(t, db, task.ID); got.Status != 2 {
t.Fatalf("降级模式终态: %d", got.Status)
}
}
// TestTimerDispatchErrorRetry 分发系统性错误→status 回滚 0→下轮重试成功。
func TestTimerDispatchErrorRetry(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
task := mkTimerTask(t, db, time.Now().Add(-time.Second), 3)
fd := &fakeDispatcher{err: errTestSys}
s := NewTimerScheduler(db, q, fd)
if _, claimed, done, _ := s.ScanOnce(ctx); claimed != 1 || done != 0 {
t.Fatalf("首轮应认领但分发失败: claimed=%d done=%d", claimed, done)
}
if got := getTask(t, db, task.ID); got.Status != 0 {
t.Fatalf("分发失败应回滚待发: %d", got.Status)
}
fd.err = nil
if _, c2, d2, _ := s.ScanOnce(ctx); c2 != 1 || d2 != 1 {
t.Fatalf("二轮应重试成功: c2=%d d2=%d", c2, d2)
}
}
// errTestSys 测试用系统性错误。
var errTestSys = &testSysErr{}
type testSysErr struct{}
func (e *testSysErr) Error() string { return "sys down" }
// TestTimerDiffCleanup 差集清理:取消任务未来时刻残留→下一轮即出队(不等到点)。
func TestTimerDiffCleanup(t *testing.T) {
db := newTimerDB(t)
q, _ := newTestQueue(t)
ctx := context.Background()
future := time.Now().Add(time.Hour)
task := mkTimerTask(t, db, future, 3)
if err := db.Model(task).Update("status", 3).Error; err != nil { // 取消
t.Fatal(err)
}
if err := q.Enqueue(ctx, task.ID, future); err != nil { // 残留(未来 score,永不到点)
t.Fatal(err)
}
s := NewTimerScheduler(db, q, &fakeDispatcher{})
if _, _, _, err := s.ScanOnce(ctx); err != nil {
t.Fatal(err)
}
if n, _ := q.rc.ZCard(ctx, QueueKey()).Result(); n != 0 {
t.Fatalf("差集清理未生效, ZCard=%d", n)
}
}