444 lines
15 KiB
Go
444 lines
15 KiB
Go
// consumer_test.go Day 56:回执消费者单测——三态归一化联动(detail 终态)/
|
|
// 长短信 9 片段级聚合(部分到达挂起/到齐成功/任一失败)/首到终态锁定
|
|
// (乱序异态不翻转)/无配对段挂起不重试/合包多号独立置态。
|
|
package report
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/glebarez/sqlite"
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
|
|
"go-sms/internal/model/entity"
|
|
)
|
|
|
|
func newConsumerDB(t *testing.T) *gorm.DB {
|
|
t.Helper()
|
|
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Discard})
|
|
if err != nil {
|
|
t.Fatalf("打开内存库失败: %v", err)
|
|
}
|
|
if err := db.AutoMigrate(&entity.MessageDetail{}, &entity.MessageReport{}, &entity.MessageReportSeg{}); err != nil {
|
|
t.Fatalf("AutoMigrate 失败: %v", err)
|
|
}
|
|
return db
|
|
}
|
|
|
|
var testCtx = context.Background()
|
|
|
|
// detailSeq 测试明细 ID 序列(MessageDetail=雪花主键非自增,须显式赋值)。
|
|
var detailSeq int64
|
|
|
|
// mkDetail 直插明细(显式雪花 ID)。
|
|
func mkDetail(t *testing.T, db *gorm.DB, taskID int64, mobile string, status int8) entity.MessageDetail {
|
|
t.Helper()
|
|
d := entity.MessageDetail{TaskID: taskID, AccountID: 1, Mobile: mobile, Status: status}
|
|
d.ID = time.Now().UnixNano() + atomic.AddInt64(&detailSeq, 1)
|
|
if err := db.Create(&d).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return d
|
|
}
|
|
|
|
// mkSeg 直插配对段(提交侧 writeSegRows 等价;msg_id 由 detailID+段序唯一化)。
|
|
func mkSeg(t *testing.T, db *gorm.DB, detailID, channelID int64, mobile string, pkNumber, pkTotal int) string {
|
|
t.Helper()
|
|
mid := fmt.Sprintf("m%d-%02d", detailID, pkNumber)
|
|
row := entity.MessageReportSeg{
|
|
DetailID: detailID, ChannelID: channelID, MsgID: mid, Mobile: mobile,
|
|
PkNumber: int8(pkNumber), PkTotal: int8(pkTotal),
|
|
}
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return mid
|
|
}
|
|
|
|
// ev 回执事件构造。
|
|
func ev(channelID int64, msgID, stat, dest string) *Event {
|
|
return &Event{ChannelID: channelID, MsgID: msgID, Stat: stat, Dest: dest, RecvAt: time.Now().Format(time.RFC3339)}
|
|
}
|
|
|
|
func getDetail(t *testing.T, db *gorm.DB, id int64) entity.MessageDetail {
|
|
t.Helper()
|
|
var d entity.MessageDetail
|
|
if err := db.First(&d, id).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return d
|
|
}
|
|
|
|
// TestConsumer_SingleSuccess 单段成功:detail 1→2,message_report SUCCESS 落库。
|
|
func TestConsumer_SingleSuccess(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
d := mkDetail(t, db, 1, "13800001111", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13800001111", 1, 1)
|
|
|
|
if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13800001111")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := getDetail(t, db, d.ID)
|
|
if got.Status != 2 {
|
|
t.Fatalf("status=%d 期望 2(成功)", got.Status)
|
|
}
|
|
if got.ReportAt == nil {
|
|
t.Fatal("report_at 应写入")
|
|
}
|
|
var rep entity.MessageReport
|
|
if err := db.Where("detail_id = ?", d.ID).First(&rep).Error; err != nil {
|
|
t.Fatalf("message_report 未落库: %v", err)
|
|
}
|
|
if rep.Status != string(StatusSuccess) {
|
|
t.Fatalf("report.status=%s 期望 SUCCESS", rep.Status)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_SingleFailure 失败终态:detail→3,error_code=通道原始码。
|
|
func TestConsumer_SingleFailure(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
d := mkDetail(t, db, 1, "13900002222", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13900002222", 1, 1)
|
|
|
|
if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13900002222")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := getDetail(t, db, d.ID)
|
|
if got.Status != 3 || got.ErrorCode != "UNDELIV" {
|
|
t.Fatalf("status=%d code=%s 期望 3/UNDELIV", got.Status, got.ErrorCode)
|
|
}
|
|
var rep entity.MessageReport
|
|
if err := db.Where("detail_id = ?", d.ID).First(&rep).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if rep.Status != string(StatusFailure) {
|
|
t.Fatalf("report.status=%s 期望 FAILURE", rep.Status)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_NineSegAggregate 长短信 9 片段级聚合(验收主用例):
|
|
// 8 片 DELIVRD=挂起(detail 保持 1);第 9 片到齐=成功(2);
|
|
// 另一 9 片任务任一片 UNDELIV=失败(3)。
|
|
func TestConsumer_NineSegAggregate(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
mobile := "13700003333"
|
|
d := mkDetail(t, db, 1, mobile, 1)
|
|
var mids []string
|
|
for pn := 1; pn <= 9; pn++ {
|
|
mids = append(mids, mkSeg(t, db, d.ID, 7, mobile, pn, 9))
|
|
}
|
|
// 8 片成功:未到齐→挂起。
|
|
for i := 0; i < 8; i++ {
|
|
if err := c.Process(testCtx, ev(7, mids[i], "DELIVRD", mobile)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 1 {
|
|
t.Fatalf("8/9 片应挂起(status=1),实际 %d", got.Status)
|
|
}
|
|
// 第 9 片到齐→成功(大小写空白容错同步验证)。
|
|
if err := c.Process(testCtx, ev(7, mids[8], " DELIVRD ", mobile)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("9/9 片应成功(2),实际 %d", got.Status)
|
|
}
|
|
|
|
// 第二任务:任一片失败→整条失败。
|
|
d2 := mkDetail(t, db, 2, mobile, 1)
|
|
var mids2 []string
|
|
for pn := 1; pn <= 9; pn++ {
|
|
mids2 = append(mids2, mkSeg(t, db, d2.ID, 7, mobile, pn, 9))
|
|
}
|
|
if err := c.Process(testCtx, ev(7, mids2[0], "DELIVRD", mobile)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := c.Process(testCtx, ev(7, mids2[3], "REJECTD", mobile)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := getDetail(t, db, d2.ID)
|
|
if got.Status != 3 || got.ErrorCode != "REJECTD" {
|
|
t.Fatalf("任一片失败应整条失败(3/REJECTD),实际 %d/%s", got.Status, got.ErrorCode)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_UnknownPending UNKNOWN(中间态 GB:0001)不判终态:detail 保持 1。
|
|
func TestConsumer_UnknownPending(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
d := mkDetail(t, db, 1, "13600004444", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13600004444", 1, 1)
|
|
if err := c.Process(testCtx, ev(7, mid, "GB:0001", "13600004444")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 1 {
|
|
t.Fatalf("UNKNOWN 应挂起(status=1),实际 %d", got.Status)
|
|
}
|
|
var n int64
|
|
db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n)
|
|
if n != 0 {
|
|
t.Fatal("挂起不应写 message_report")
|
|
}
|
|
}
|
|
|
|
// TestConsumer_FinalLocked 首到终态锁定:已成功(2)后再收 UNDELIV 不翻转。
|
|
func TestConsumer_FinalLocked(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
d := mkDetail(t, db, 1, "13500005555", 2)
|
|
mid := mkSeg(t, db, d.ID, 7, "13500005555", 1, 1)
|
|
if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13500005555")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("终态锁定被破坏: %d", got.Status)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_UnpairedNoRetry 无配对段:返回 nil(不重试),挂起口径。
|
|
func TestConsumer_UnpairedNoRetry(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
if err := c.Process(testCtx, ev(7, "404", "DELIVRD", "13000000000")); err != nil {
|
|
t.Fatalf("无配对应返回 nil(挂起不重试): %v", err)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_BatchMultiMobile 合包同 msg_id 多号:按 (msg_id,mobile) 独立置态。
|
|
func TestConsumer_BatchMultiMobile(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
mos := []string{"13111110001", "13111110002"}
|
|
var ds []entity.MessageDetail
|
|
for _, mo := range mos {
|
|
ds = append(ds, mkDetail(t, db, 1, mo, 1))
|
|
}
|
|
// 同一包 msg_id,两号各一段。
|
|
for i, mo := range mos {
|
|
row := entity.MessageReportSeg{DetailID: ds[i].ID, ChannelID: 7, MsgID: "shared-1", Mobile: mo, PkNumber: 1, PkTotal: 1}
|
|
if err := db.Create(&row).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := c.Process(testCtx, ev(7, "shared-1", "DELIVRD", mos[0])); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := c.Process(testCtx, ev(7, "shared-1", "EXPIRED", mos[1])); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, ds[0].ID); got.Status != 2 {
|
|
t.Fatalf("号1应成功: %d", got.Status)
|
|
}
|
|
if got := getDetail(t, db, ds[1].ID); got.Status != 3 {
|
|
t.Fatalf("号2应失败: %d", got.Status)
|
|
}
|
|
}
|
|
|
|
// ---- Day 57:计费确认联动(msg_id 重复回执幂等主验收=A-5.2/A-5.3 零差额) ----
|
|
|
|
// TestConsumer_FailureRefundIdempotent 失败回执重复投递:detail 终态+退款
|
|
// 恰一次(首到终态锁定=资金动作幂等锚;预扣-退款零差额)。
|
|
func TestConsumer_FailureRefundIdempotent(t *testing.T) {
|
|
db := newBillingDB(t)
|
|
fs := &fakeStore{}
|
|
c := NewConsumer(db).WithBilling(NewBilling(db, fs))
|
|
d := mkDetail(t, db, 1, "13222220001", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13222220001", 1, 1)
|
|
for i := 0; i < 3; i++ { // 通道重推/重放三次
|
|
if err := c.Process(testCtx, ev(7, mid, "UNDELIV", "13222220001")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 3 {
|
|
t.Fatalf("应失败终态: %d", got.Status)
|
|
}
|
|
if calls := fs.calls(); len(calls) != 1 {
|
|
t.Fatalf("重复回执应恰一次退款(msg_id 幂等),实得 %d 次: %+v", len(calls), calls)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_SuccessNoMoneyMove 成功回执:零资金动作(预扣=实扣半边)。
|
|
func TestConsumer_SuccessNoMoneyMove(t *testing.T) {
|
|
db := newBillingDB(t)
|
|
fs := &fakeStore{}
|
|
c := NewConsumer(db).WithBilling(NewBilling(db, fs))
|
|
d := mkDetail(t, db, 1, "13222220002", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13222220002", 1, 1)
|
|
if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13222220002")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("应成功终态: %d", got.Status)
|
|
}
|
|
if calls := fs.calls(); len(calls) != 0 {
|
|
t.Fatalf("成功不应动钱,实得 %d 次: %+v", len(calls), calls)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_TaskCounterLinked 成功回执→task 聚合计数联动(覆写口径)。
|
|
func TestConsumer_TaskCounterLinked(t *testing.T) {
|
|
db := newBillingDB(t)
|
|
if err := db.Create(&entity.MessageTask{
|
|
ID: 3, TaskNo: "T57B", AccountID: 1, MobileCount: 2, Status: 1,
|
|
}).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c := NewConsumer(db).WithBilling(NewBilling(db, &fakeStore{}))
|
|
d := mkDetail(t, db, 3, "13222220003", 1)
|
|
mid := mkSeg(t, db, d.ID, 7, "13222220003", 1, 1)
|
|
if err := c.Process(testCtx, ev(7, mid, "DELIVRD", "13222220003")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if tk := getTask(t, db, 3); tk.SuccessCount != 1 || tk.UnknownCount != 0 {
|
|
t.Fatalf("task 计数联动错: %+v", tk)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_ConcurrentSegAggregate 并发聚合回归(Day 69 竞态修复):
|
|
// 同一 detail 两段回执并发 Process。sqlite 内存库每连接独立库,单连接
|
|
// 强制串行——验证串行语义下"两段全到→恰终态一次+report 恰 1 条";
|
|
// 真并发互不可见(MVCC)场景由生产 MySQL 的 detail 行 FOR UPDATE 串行
|
|
// 化保障(consumer.go aggregate 锁,单测库不可复现该竞态)。
|
|
func TestConsumer_ConcurrentSegAggregate(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
if sqlDB, err := db.DB(); err == nil {
|
|
sqlDB.SetMaxOpenConns(1) // :memory: 防串库;两 goroutine 事务排队串行
|
|
}
|
|
c := NewConsumer(db)
|
|
mobile := "13700004444"
|
|
d := mkDetail(t, db, 3, mobile, 1)
|
|
m1 := mkSeg(t, db, d.ID, 9, mobile, 1, 2)
|
|
m2 := mkSeg(t, db, d.ID, 9, mobile, 2, 2)
|
|
|
|
var wg sync.WaitGroup
|
|
errCh := make(chan error, 2)
|
|
for _, mid := range []string{m1, m2} {
|
|
wg.Add(1)
|
|
go func(mid string) {
|
|
defer wg.Done()
|
|
errCh <- c.Process(testCtx, ev(9, mid, "DELIVRD", mobile))
|
|
}(mid)
|
|
}
|
|
wg.Wait()
|
|
close(errCh)
|
|
for err := range errCh {
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("两段全 DELIVRD 应到齐终态(2),实际 %d(挂起=聚合竞态回归)", got.Status)
|
|
}
|
|
var n int64
|
|
db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n)
|
|
if n != 1 {
|
|
t.Fatalf("message_report 应恰 1 条,实际 %d", n)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_RecheckPendingFinalizes 竞态双盲兜底回归(Day 69 二轮):
|
|
// 两段已全 SUCCESS 而 detail 仍挂起时,复查路径直接到齐终态——模拟并发
|
|
// 簇最后提交者的 recheck 必见全部已提交段。(sqlite 单连接无法复现双盲
|
|
// 交错,双盲时序由生产 MySQL 实机验证;复查路径本身在此锁定+幂等。)
|
|
func TestConsumer_RecheckPendingFinalizes(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
c := NewConsumer(db)
|
|
mobile := "13700005555"
|
|
d := mkDetail(t, db, 4, mobile, 1)
|
|
m1 := mkSeg(t, db, d.ID, 9, mobile, 1, 2)
|
|
m2 := mkSeg(t, db, d.ID, 9, mobile, 2, 2)
|
|
// 两段均已被"并发事务"置态 SUCCESS(模拟对方已提交、本方快照看不到)。
|
|
if err := db.Model(&entity.MessageReportSeg{}).Where("msg_id IN ?", []string{m1, m2}).
|
|
Updates(map[string]any{"status": "SUCCESS", "raw_code": "DELIVRD"}).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := c.recheckPending(testCtx, ev(9, m1, "DELIVRD", mobile), StatusSuccess, time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("复查应到齐终态(2),实际 %d", got.Status)
|
|
}
|
|
var n int64
|
|
db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n)
|
|
if n != 1 {
|
|
t.Fatalf("message_report 应恰 1 条,实际 %d", n)
|
|
}
|
|
// 幂等:二次复查终态已锁——不翻转、不重报、不报错。
|
|
if err := c.recheckPending(testCtx, ev(9, m2, "DELIVRD", mobile), StatusSuccess, time.Now()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("终态不应翻转,实际 %d", got.Status)
|
|
}
|
|
db.Model(&entity.MessageReport{}).Where("detail_id = ?", d.ID).Count(&n)
|
|
if n != 1 {
|
|
t.Fatalf("message_report 应仍 1 条,实际 %d", n)
|
|
}
|
|
}
|
|
|
|
// TestConsumer_UnpairedRequeue 秒回竞态重投回归(Day 69 三轮):回执先于
|
|
// 发送侧 seg 落库到达时 unpaired——短重投(计数透传+1)而非丢弃;重投后
|
|
// seg 到位的二次消费正常配对终态(竞态自愈);耗尽按杂音丢弃;重投失败上抛。
|
|
func TestConsumer_UnpairedRequeue(t *testing.T) {
|
|
db := newConsumerDB(t)
|
|
mobile := "13700006666"
|
|
d := mkDetail(t, db, 5, mobile, 1)
|
|
|
|
var requeued []*Event
|
|
c := NewConsumer(db).WithRequeue(func(e *Event) error {
|
|
cp := *e
|
|
requeued = append(requeued, &cp)
|
|
return nil
|
|
})
|
|
|
|
// ① seg 未落库(竞态窗口):unpaired → 重投不丢弃,detail 保持挂起。
|
|
e1 := ev(9, "race-1", "DELIVRD", mobile)
|
|
if err := c.Process(testCtx, e1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(requeued) != 1 || requeued[0].Retries != 1 {
|
|
t.Fatalf("应重投 1 次(Retries=1),实际 %v", requeued)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 1 {
|
|
t.Fatalf("seg 缺失时不应置态,实际 %d", got.Status)
|
|
}
|
|
|
|
// ② 重投事件二次消费前 seg 已落库:正常配对(单段)直接终态=竞态自愈。
|
|
mkSeg(t, db, d.ID, 9, mobile, 1, 1) // msg_id=m{d.ID}-01,与 race-1 不同——
|
|
// 用真实 msg_id 再走一遍:重投载荷换为配对段号,模拟 seg 补登记后重放。
|
|
segMid := fmt.Sprintf("m%d-01", d.ID)
|
|
e2 := ev(9, segMid, "DELIVRD", mobile)
|
|
e2.Retries = 1
|
|
if err := c.Process(testCtx, e2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := getDetail(t, db, d.ID); got.Status != 2 {
|
|
t.Fatalf("seg 到位后应终态(2),实际 %d", got.Status)
|
|
}
|
|
|
|
// ③ 重投耗尽(Retries=3):按杂音丢弃,不再重投、不报错。
|
|
before := len(requeued)
|
|
e3 := ev(9, "noise-9", "DELIVRD", mobile)
|
|
e3.Retries = unpairedMaxRetries
|
|
if err := c.Process(testCtx, e3); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(requeued) != before {
|
|
t.Fatalf("耗尽后不应重投,实际 %d 次", len(requeued)-before)
|
|
}
|
|
|
|
// ④ 重投出口失败:上抛交消费组重试(消息不丢)。
|
|
cFail := NewConsumer(db).WithRequeue(func(e *Event) error { return fmt.Errorf("kafka down") })
|
|
if err := cFail.Process(testCtx, ev(9, "race-2", "DELIVRD", mobile)); err == nil {
|
|
t.Fatal("重投失败应上抛")
|
|
}
|
|
}
|