Files
go-sms-V2/internal/service/send/consume/consumer_test.go
T

359 lines
13 KiB
Go

// consumer_test.go Day 48:submit 消费者单测——事件认领分发终态/幂等重投/
// 定时域不认领/补偿扫描(审核通过即发)/毒丸载荷回死信口径。
package consume
import (
"context"
"encoding/json"
"fmt"
"strings"
"testing"
"time"
"go-sms/internal/model/entity"
"go-sms/internal/service/send/dispatch"
"go-sms/internal/service/send/submit"
"go.uber.org/zap"
"gorm.io/gorm"
)
// mkImmediateTask 直插立即任务(audit 默认免审 3;sendType 默认群发 1)。
func mkImmediateTask(t *testing.T, db *gorm.DB, audit int8, sendType int8) *entity.MessageTask {
t.Helper()
task := &entity.MessageTask{
TaskNo: "CS" + time.Now().Format("150405.000000000"), AccountID: 1001,
SendType: sendType, Content: "【店】测试", Sign: "店",
MobileCount: 2, AuditStatus: audit, Status: 0,
}
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(9100000000 + task.ID*10 + int64(i))
if err := db.Create(&d).Error; err != nil {
t.Fatal(err)
}
}
return task
}
func evPayload(t *testing.T, task *entity.MessageTask, pass int) []byte {
t.Helper()
b, err := json.Marshal(submit.SubmitEvent{TaskID: task.ID, TaskNo: task.TaskNo,
AccountID: task.AccountID, SendType: task.SendType, PassCount: pass})
if err != nil {
t.Fatal(err)
}
return b
}
// TestConsumerHandleClaimDispatch 事件→认领→分发→终态 2+计数回填。
func TestConsumerHandleClaimDispatch(t *testing.T) {
db := newTimerDB(t)
task := mkImmediateTask(t, db, 3, 1)
dp := &fakeDispatcher{}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
if err := sc.HandlePayload(context.Background(), evPayload(t, task, 2)); err != nil {
t.Fatalf("HandlePayload err=%v", err)
}
if len(dp.calls) != 1 || dp.calls[0] != task.ID {
t.Fatalf("分发调用缺失: %v", dp.calls)
}
got := getTask(t, db, task.ID)
if got.Status != 2 || got.SuccessCount != 2 || got.FinishedAt == nil {
t.Fatalf("终态错: status=%d sent=%d fin=%v", got.Status, got.SuccessCount, got.FinishedAt)
}
}
// TestConsumerIdempotentReplay 重投幂等:已终态任务再消费→零动作成功。
func TestConsumerIdempotentReplay(t *testing.T) {
db := newTimerDB(t)
task := mkImmediateTask(t, db, 3, 1)
dp := &fakeDispatcher{}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
for i := 0; i < 3; i++ { // 事件重投 3 次
if err := sc.HandlePayload(context.Background(), evPayload(t, task, 2)); err != nil {
t.Fatalf("第 %d 次重投 err=%v", i+1, err)
}
}
if len(dp.calls) != 1 {
t.Fatalf("重投应只分发 1 次, 实际 %d", len(dp.calls))
}
}
// TestConsumerSkipDomains 域过滤:定时(3)/待审(audit=0)不认领。
func TestConsumerSkipDomains(t *testing.T) {
db := newTimerDB(t)
timerTask := mkImmediateTask(t, db, 3, submit.SendTypeTimer)
pending := mkImmediateTask(t, db, 0, 1)
dp := &fakeDispatcher{}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
for _, tk := range []*entity.MessageTask{timerTask, pending} {
if err := sc.HandlePayload(context.Background(), evPayload(t, tk, 2)); err != nil {
t.Fatalf("err=%v", err)
}
}
if len(dp.calls) != 0 {
t.Fatalf("非本域任务不应分发: %v", dp.calls)
}
if getTask(t, db, timerTask.ID).Status != 0 {
t.Fatal("定时任务被误认领")
}
}
// TestConsumerDispatchErrorRollback 系统性错误:回滚 1→0 留待重扫。
func TestConsumerDispatchErrorRollback(t *testing.T) {
db := newTimerDB(t)
task := mkImmediateTask(t, db, 3, 1)
dp := &fakeDispatcher{err: context.DeadlineExceeded}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
if err := sc.HandlePayload(context.Background(), evPayload(t, task, 2)); err != nil {
t.Fatalf("err=%v", err)
}
got := getTask(t, db, task.ID)
if got.Status != 0 {
t.Fatalf("系统性错误应回滚 0, 实际 %d", got.Status)
}
}
// TestReclaimScannerApproveThenSend 补偿扫描:手动审核通过(audit=1)后无人发→
// ScanOnce 认领下发(Day48 修复"审核通过即发"缺陷)。
func TestReclaimScannerApproveThenSend(t *testing.T) {
db := newTimerDB(t)
task := mkImmediateTask(t, db, 1, 1) // 手动档已过审
dp := &fakeDispatcher{}
rs := NewReclaimScanner(db, dp, zap.NewNop())
claimed, done, err := rs.ScanOnce(context.Background())
if err != nil || claimed != 1 || done != 1 {
t.Fatalf("ScanOnce claimed=%d done=%d err=%v", claimed, done, err)
}
got := getTask(t, db, task.ID)
if got.Status != 2 || got.SuccessCount != 2 {
t.Fatalf("审核通过任务应下发终态: status=%d sent=%d", got.Status, got.SuccessCount)
}
// 二轮幂等:无待发任务。
claimed2, _, _ := rs.ScanOnce(context.Background())
if claimed2 != 0 {
t.Fatalf("二轮应无认领, 实际 %d", claimed2)
}
}
// TestConsumerBadPayload 毒丸载荷:解析失败返回错误(进重试→死信)。
func TestConsumerBadPayload(t *testing.T) {
db := newTimerDB(t)
sc := NewSubmitConsumer(db, &fakeDispatcher{}, zap.NewNop())
if err := sc.HandlePayload(context.Background(), []byte("{not-json")); err == nil {
t.Fatal("坏载荷应报错")
}
// 旧格式兼容:无 task_id 忽略成功。
if err := sc.HandlePayload(context.Background(), []byte(`{"task_no":"X"}`)); err != nil {
t.Fatalf("旧格式应忽略, err=%v", err)
}
// Day46 事件(无 pass_count)按任务现状认领。
task := mkImmediateTask(t, db, 3, 1)
dp := &fakeDispatcher{}
sc2 := NewSubmitConsumer(db, dp, zap.NewNop())
raw := `{"task_id":` + taskNoDigits(task.ID) + `,"task_no":"` + task.TaskNo + `"}`
if err := sc2.HandlePayload(context.Background(), []byte(raw)); err != nil {
t.Fatalf("旧事件 err=%v", err)
}
if len(dp.calls) != 1 {
t.Fatalf("旧事件应正常认领: %v", dp.calls)
}
}
// TestConsumerPersistDetailsIdempotent Day52 R2:事件载明细→批量落库+认领下发;
// 重投 3 次明细不重复(雪花主键 DoNothing)且只分发 1 次。
func TestConsumerPersistDetailsIdempotent(t *testing.T) {
db := newTimerDB(t)
task := &entity.MessageTask{
TaskNo: "CS" + time.Now().Format("150405.000000000"), AccountID: 1001,
SendType: 1, Content: "【店】测试", Sign: "店", MobileCount: 2, AuditStatus: 3, Status: 0,
}
if err := db.Create(task).Error; err != nil {
t.Fatal(err)
}
dets := []submit.EventDetail{
{ID: 9200000001, Mobile: "13800138000", Content: "【店】测试", Fee: 1},
{ID: 9200000002, Mobile: "13800138001", Content: "【店】测试", Fee: 1},
}
b, err := json.Marshal(submit.SubmitEvent{TaskID: task.ID, TaskNo: task.TaskNo,
AccountID: task.AccountID, SendType: 1, PassCount: 2, Details: dets})
if err != nil {
t.Fatal(err)
}
dp := &fakeDispatcher{}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
for i := 0; i < 3; i++ { // 重投 3 次
if err := sc.HandlePayload(context.Background(), b); err != nil {
t.Fatalf("第 %d 次消费 err=%v", i+1, err)
}
}
if len(dp.calls) != 1 {
t.Fatalf("重投应只分发 1 次, 实际 %d", len(dp.calls))
}
var n int64
db.Model(&entity.MessageDetail{}).Where("task_id = ?", task.ID).Count(&n)
if n != 2 {
t.Fatalf("明细应恰 2 行(重投幂等): %d", n)
}
var d entity.MessageDetail
if err := db.Where("task_id = ? AND mobile = ?", task.ID, "13800138000").First(&d).Error; err != nil {
t.Fatal("明细行缺失")
}
if d.AccountID != 1001 || d.ID != 9200000001 || d.Fee != 1 {
t.Fatalf("明细字段口径错: %+v", d)
}
}
// fakeBlockedSink Day62c:拦截终态出口桩(记录调用)。
type fakeBlockedSink struct{ calls []string }
func (f *fakeBlockedSink) PushBlocked(_ context.Context, accountID, detailID int64,
mobile, errCode, submitAt string) {
f.calls = append(f.calls, fmt.Sprintf("%d/%d/%s/%s/%s",
accountID, detailID, mobile, errCode, submitAt))
}
// TestConsumerBlockedDeliver Day62c:拦截终态下发——source=CMPP 且 status=5 的行
// 逐条推送;存活行不推;纯重投(RowsAffected=0)不重推;非 CMPP 来源零调用。
func TestConsumerBlockedDeliver(t *testing.T) {
for _, tc := range []struct {
source int8
want int
}{
{submit.TaskSourceCMPP, 2}, // CMPP:2 条拦截行各 1 次
{submit.TaskSourceAPI, 0}, // API 来源:不下发
{submit.TaskSourceWeb, 0}, // 控制台来源:不下发
} {
db := newTimerDB(t)
task := &entity.MessageTask{
TaskNo: "CS" + time.Now().Format("150405.000000000"), AccountID: 1001,
SendType: 1, Content: "[半角签名]测试", MobileCount: 3, AuditStatus: 3,
Status: 0, Source: tc.source,
}
if err := db.Create(task).Error; err != nil {
t.Fatal(err)
}
dets := []submit.EventDetail{
{ID: 9300000001, Mobile: "13800138000", Content: task.Content, Fee: 1}, // 存活
{ID: 9300000002, Mobile: "13800138001", Content: task.Content, Status: 5,
ErrorCode: "ISC:004"}, // 拦截(签名)
{ID: 9300000003, Mobile: "13800138002", Content: task.Content, Status: 5,
ErrorCode: "ISC:009"}, // 拦截(其他码)
}
b, err := json.Marshal(submit.SubmitEvent{TaskID: task.ID, TaskNo: task.TaskNo,
AccountID: task.AccountID, SendType: 1, PassCount: 1, Details: dets})
if err != nil {
t.Fatal(err)
}
fb := &fakeBlockedSink{}
sc := NewSubmitConsumer(db, &fakeDispatcher{}, zap.NewNop()).WithBlockedDeliverSink(fb)
for i := 0; i < 2; i++ { // 重投一次验证幂等
if err := sc.HandlePayload(context.Background(), b); err != nil {
t.Fatalf("source=%d 第 %d 次消费 err=%v", tc.source, i+1, err)
}
}
if len(fb.calls) != tc.want {
t.Fatalf("source=%d 调用 %d 次, 期望 %d: %v", tc.source, len(fb.calls), tc.want, fb.calls)
}
if tc.want > 0 {
if !strings.Contains(fb.calls[0], "1001/9300000002/13800138001/ISC:004/") {
t.Fatalf("首条载荷口径错: %s", fb.calls[0])
}
if !strings.Contains(fb.calls[1], "9300000003") || strings.Contains(fb.calls[1], "9300000001") {
t.Fatalf("次条应仅含拦截行: %v", fb.calls)
}
}
}
}
// TestOrphanTaskFinalized Day62d:陈年孤儿任务(无明细+超 1h)dispatch 一次性终态
// 结案,不再 5s/轮死循环重试(dev 实证 task 343 刷 warn 两日);新任务同错误仍回滚重试。
func TestOrphanTaskFinalized(t *testing.T) {
db := newTimerDB(t)
mk := func(back time.Duration) *entity.MessageTask {
task := &entity.MessageTask{
TaskNo: "CS" + time.Now().Format("150405.000000000"), AccountID: 1001,
SendType: 1, Content: "【店】测试", MobileCount: 2, AuditStatus: 3, Status: 0,
}
if err := db.Create(task).Error; err != nil {
t.Fatal(err)
}
if err := db.Model(&entity.MessageTask{}).Where("id = ?", task.ID).
Update("created_at", time.Now().Add(back)).Error; err != nil {
t.Fatal(err)
}
return task
}
old, fresh := mk(-2*time.Hour), mk(-time.Minute)
dp := &fakeDispatcher{err: dispatch.ErrDetailsNotReady} // 明细缺失(事件在途/孤儿)
rs := NewReclaimScanner(db, dp, zap.NewNop()).WithBatch(10)
for i := 0; i < 2; i++ { // 两轮扫描:孤儿首轮结案;新任务始终回滚
if _, _, err := rs.ScanOnce(context.Background()); err != nil {
t.Fatal(err)
}
}
var got entity.MessageTask
if err := db.First(&got, old.ID).Error; err != nil {
t.Fatal(err)
}
if got.Status != submit.TaskStDone || got.FinishedAt.IsZero() {
t.Fatalf("孤儿任务应终态结案: status=%d finished_at=%v", got.Status, got.FinishedAt)
}
var freshGot entity.MessageTask
if err := db.First(&freshGot, fresh.ID).Error; err != nil {
t.Fatal(err)
}
if freshGot.Status != 0 {
t.Fatalf("新任务(事件在途)应回滚待重扫而非结案: status=%d", freshGot.Status)
}
}
// TestConsumerTimerEventPersistOnly Day52 R2:定时域事件(载明细)→落明细不认领不下发
// (claim 的 send_type∈{1,2} 保证;到点由 TimerScheduler 认领)。
func TestConsumerTimerEventPersistOnly(t *testing.T) {
db := newTimerDB(t)
task := &entity.MessageTask{
TaskNo: "CS" + time.Now().Format("150405.000000001"), AccountID: 1001,
SendType: submit.SendTypeTimer, Content: "【店】定时", Sign: "店",
MobileCount: 1, AuditStatus: 3, Status: 0,
}
if err := db.Create(task).Error; err != nil {
t.Fatal(err)
}
b, err := json.Marshal(submit.SubmitEvent{TaskID: task.ID, TaskNo: task.TaskNo,
AccountID: task.AccountID, SendType: submit.SendTypeTimer, PassCount: 1,
Details: []submit.EventDetail{{ID: 9200000003, Mobile: "13800138000", Content: "【店】定时", Fee: 1}}})
if err != nil {
t.Fatal(err)
}
dp := &fakeDispatcher{}
sc := NewSubmitConsumer(db, dp, zap.NewNop())
if err := sc.HandlePayload(context.Background(), b); err != nil {
t.Fatalf("err=%v", err)
}
if len(dp.calls) != 0 {
t.Fatalf("定时域事件不应分发: %v", dp.calls)
}
if getTask(t, db, task.ID).Status != 0 {
t.Fatal("定时任务被误认领")
}
var n int64
db.Model(&entity.MessageDetail{}).Where("task_id = ?", task.ID).Count(&n)
if n != 1 {
t.Fatalf("定时事件明细应落库: %d 行", n)
}
}
func taskNoDigits(id int64) string {
d, _ := json.Marshal(id)
return string(d)
}