454 lines
15 KiB
Go
454 lines
15 KiB
Go
// link_test.go Day 31+:通道常驻链路管理测试——建链/守卫/提交/回执缓冲/引导/拆除。
|
|
// 链路经真实 TCP 连接 service_test.go 的迷你 CMPP 网关(listenMiniCMPP:密钥 pw,Submit 固定 MsgID=777)。
|
|
package pool_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/glebarez/sqlite"
|
|
"go-sms/internal/model/entity"
|
|
"go-sms/internal/protocol/cmpp"
|
|
"go-sms/internal/service/channel"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// TestLinkStartStop 验收:建链(池连通)→ 状态视图 → 幂等 → 拆除(重复幂等)。
|
|
func TestLinkStartStop(t *testing.T) {
|
|
s := newSvc(t)
|
|
t.Cleanup(func() { s.ShutdownLinks() })
|
|
ln, _ := listenMiniCMPP(t)
|
|
ctx := context.Background()
|
|
ch := mustCreateLinkable(t, s, "lk-1", ln)
|
|
|
|
st, err := s.StartLink(ctx, ch.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !st.Running || st.Total != 1 || st.ChannelID != ch.ID {
|
|
t.Fatalf("初始状态: %+v", st)
|
|
}
|
|
if !waitLink(t, s, ch.ID, 1) {
|
|
t.Fatalf("链路未就绪: %+v", s.LinkStatus(ch.ID))
|
|
}
|
|
if st := s.LinkStatus(ch.ID); st.StartedAt == "" {
|
|
t.Fatal("started_at 应非空")
|
|
}
|
|
// 幂等:重复 StartLink 不翻倍
|
|
st, err = s.StartLink(ctx, ch.ID)
|
|
if err != nil || st.Total != 1 {
|
|
t.Fatalf("幂等: st=%+v err=%v", st, err)
|
|
}
|
|
// 拆除
|
|
s.StopLink(ch.ID)
|
|
if st := s.LinkStatus(ch.ID); st.Running || st.Total != 0 {
|
|
t.Fatalf("停止后: %+v", st)
|
|
}
|
|
// 重复拆除幂等
|
|
s.StopLink(ch.ID)
|
|
}
|
|
|
|
// TestLinkGuard 验收:协议/状态/版本/不存在守卫。
|
|
func TestLinkGuard(t *testing.T) {
|
|
s := newSvc(t)
|
|
t.Cleanup(func() { s.ShutdownLinks() })
|
|
ctx := context.Background()
|
|
|
|
// 非 cmpp 通道
|
|
httpCh := mustCreateCh(t, s, "lg-http")
|
|
if _, err := s.StartLink(ctx, httpCh.ID); err == nil {
|
|
t.Fatal("非 cmpp 应拒")
|
|
}
|
|
// 不存在的通道
|
|
if _, err := s.StartLink(ctx, 999); err == nil {
|
|
t.Fatal("不存在应报错")
|
|
}
|
|
// 停用通道
|
|
ln, _ := listenMiniCMPP(t)
|
|
chOff := mustCreateLinkable(t, s, "lg-off", ln)
|
|
_ = s.SetStatus(ctx, chOff.ID, 0)
|
|
if _, err := s.StartLink(ctx, chOff.ID); err == nil {
|
|
t.Fatal("停用应拒")
|
|
}
|
|
// CMPP 3.0(Create 已拒 30,直接改库构造纵深防御场景)
|
|
ln30, _ := netListen()
|
|
t.Cleanup(func() { _ = ln30.Close() })
|
|
ch30 := mustCreateLinkable(t, s, "lg-30", ln30)
|
|
if res := s.DB().WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", ch30.ID).Update("protocol_version", int8(30)); res.Error != nil {
|
|
t.Fatal(res.Error)
|
|
}
|
|
if _, err := s.StartLink(ctx, ch30.ID); err == nil || !strings.Contains(err.Error(), "CMPP 3.0") {
|
|
t.Fatalf("CMPP3.0 应拒: %v", err)
|
|
}
|
|
}
|
|
|
|
// TestSubmitViaLink 验收:经常驻链路提交返回上游 MsgID(迷你网关固定 777)。
|
|
func TestSubmitViaLink(t *testing.T) {
|
|
s := newSvc(t)
|
|
t.Cleanup(func() { s.ShutdownLinks() })
|
|
ln, _ := listenMiniCMPP(t)
|
|
ctx := context.Background()
|
|
ch := mustCreateLinkable(t, s, "svl", ln)
|
|
if st, err := s.StartLink(ctx, ch.ID); err != nil || !st.Running {
|
|
t.Fatalf("初始建链: st=%+v err=%v", st, err)
|
|
}
|
|
if !waitLink(t, s, ch.ID, 1) {
|
|
st := s.LinkStatus(ch.ID)
|
|
t.Fatalf("建链失败: status=%+v", st)
|
|
}
|
|
msgIDs, err := s.SubmitViaLink(ctx, ch.ID, "13800001111", "hello")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(msgIDs) != 1 || msgIDs[0] != "777" {
|
|
t.Fatalf("msg_ids = %v, 期望 [777]", msgIDs)
|
|
}
|
|
}
|
|
|
|
// TestLinkReceiptsPersist Day 56:持久化回执查询——seg(状态报告)与
|
|
// message_uplink(上行)按时间倒序归并;channel 过滤与 limit 截断。
|
|
func TestLinkReceiptsPersist(t *testing.T) {
|
|
s := newSvc(t)
|
|
if err := s.DB().AutoMigrate(&entity.MessageReportSeg{}, &entity.MessageUplink{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
base := time.Now().Add(-time.Hour)
|
|
mk := func(mins int) time.Time { return base.Add(time.Duration(mins) * time.Minute) }
|
|
// 通道 7:两份状态报告+一条上行;通道 8:一条(过滤用)。
|
|
segs := []entity.MessageReportSeg{
|
|
{DetailID: 1, ChannelID: 7, MsgID: "a1", Mobile: "13800001111", PkTotal: 1, ReportAt: ptrTime(mk(10))},
|
|
{DetailID: 2, ChannelID: 7, MsgID: "a2", Mobile: "13900002222", PkTotal: 1, ReportAt: ptrTime(mk(30))},
|
|
{DetailID: 3, ChannelID: 8, MsgID: "a3", Mobile: "13700003333", PkTotal: 1, ReportAt: ptrTime(mk(5))},
|
|
}
|
|
for i := range segs {
|
|
if err := s.DB().Create(&segs[i]).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
mos := []entity.MessageUplink{
|
|
{DestCode: "10086", SrcMobile: "13511112222", Content: "TD退订", AccountID: 1, ChannelID: 7, RecvAt: mk(20)},
|
|
{DestCode: "10086", SrcMobile: "13611113333", Content: "hi", AccountID: 1, ChannelID: 9, RecvAt: mk(15)},
|
|
}
|
|
for i := range mos {
|
|
if err := s.DB().Create(&mos[i]).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
out, err := s.LinkReceiptsPersist(context.Background(), 7, 50)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(out) != 3 { // 通道 7:报告×2+上行×1
|
|
t.Fatalf("行数=%d 期望 3", len(out))
|
|
}
|
|
// 倒序归并:mk(30) 最晚——a2(报告)→上行(20 分)→a1(10 分,报告)。
|
|
if !out[0].IsReport || out[0].MsgID != "a2" {
|
|
t.Fatalf("最新应为报告 a2: %+v", out[0])
|
|
}
|
|
if out[1].IsReport || out[1].Src != "13511112222" {
|
|
t.Fatalf("次新应为上行: %+v", out[1])
|
|
}
|
|
if !out[2].IsReport || out[2].MsgID != "a1" {
|
|
t.Fatalf("最旧应为报告 a1: %+v", out[2])
|
|
}
|
|
// limit 截断。
|
|
out2, _ := s.LinkReceiptsPersist(context.Background(), 7, 2)
|
|
if len(out2) != 2 || out2[0].MsgID != "a2" {
|
|
t.Fatalf("limit=2 截断: %+v", out2)
|
|
}
|
|
}
|
|
|
|
// ptrTime 便捷取址。
|
|
func ptrTime(t time.Time) *time.Time { return &t }
|
|
|
|
// TestDeliverReportSink Day 56:状态报告注入 ReportSink(goroutine 派发,
|
|
// 读循环零阻塞红线);上行不派发;未注入维持旧行为(nil 安全)。
|
|
func TestDeliverReportSink(t *testing.T) {
|
|
s := newSvc(t)
|
|
ch1 := mustCreateCh(t, s, "rs-1")
|
|
got := make(chan []string, 4)
|
|
s.SetReportSink(sinkFunc(func(channelID int64, msgID, stat, dest, doneTime string) {
|
|
got <- []string{msgID, stat, dest, doneTime}
|
|
}))
|
|
defer s.SetReportSink(nil)
|
|
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 9, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII,
|
|
IsReport: true,
|
|
Report: &cmpp.ReportInfo{MsgID: 9, Stat: "DELIVRD",
|
|
DoneTime: "0913113005", DestTerminalID: "13800009999"}})
|
|
select {
|
|
case v := <-got:
|
|
if v[0] != "9" || v[1] != "DELIVRD" || v[2] != "13800009999" || v[3] != "0913113005" {
|
|
t.Fatalf("派发参数: %v", v)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("状态报告未派发 ReportSink")
|
|
}
|
|
|
|
// 上行不派发。
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 10, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII,
|
|
SrcTerminal: "13700008888", Content: []byte("MO")})
|
|
select {
|
|
case v := <-got:
|
|
t.Fatalf("上行不应派发: %v", v)
|
|
case <-time.After(150 * time.Millisecond):
|
|
}
|
|
}
|
|
|
|
// sinkFunc 适配器(测试注入)。
|
|
type sinkFunc func(channelID int64, msgID, stat, dest, doneTime string)
|
|
|
|
func (f sinkFunc) IngestReport(_ context.Context, channelID int64, msgID, stat, dest, doneTime string) {
|
|
f(channelID, msgID, stat, dest, doneTime)
|
|
}
|
|
|
|
// TestDeliverReceipts 验收:回执/上行注入环形缓冲,查询倒序 + 按通道过滤。
|
|
func TestDeliverReceipts(t *testing.T) {
|
|
s := newSvc(t)
|
|
ch1 := mustCreateCh(t, s, "rc-1") // http 通道亦可(handleDeliver 只消费 id)
|
|
ch2 := mustCreateCh(t, s, "rc-2")
|
|
// 状态报告
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 1, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13800001111",
|
|
IsReport: true,
|
|
Report: &cmpp.ReportInfo{MsgID: 1, Stat: "DELIVRD", SubmitTime: "0904113001",
|
|
DoneTime: "0904113005", DestTerminalID: "13800001111", SMSCSequence: 7}})
|
|
// 上行(通道2)
|
|
s.Pool().HandleDeliver(ch2.ID, &cmpp.Deliver{
|
|
MsgID: 2, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13900002222",
|
|
Content: []byte("TD")})
|
|
// 上行(通道1)
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 3, DestID: "10086", MsgFmt: cmpp.MsgFmtASCII, SrcTerminal: "13700003333",
|
|
Content: []byte("hi")})
|
|
|
|
all := s.LinkReceipts(0, 10)
|
|
if len(all) != 3 {
|
|
t.Fatalf("total = %d", len(all))
|
|
}
|
|
if all[0].IsReport || all[0].Content != "hi" || all[0].Src != "13700003333" {
|
|
t.Fatalf("倒序最近(上行): %+v", all[0])
|
|
}
|
|
if !all[2].IsReport || all[2].MsgID != "1" || all[2].Stat != "DELIVRD" || all[2].Dest != "13800001111" {
|
|
t.Fatalf("最旧(报告): %+v", all[2])
|
|
}
|
|
// 按通道过滤(倒序)
|
|
one := s.LinkReceipts(ch1.ID, 10)
|
|
if len(one) != 2 || one[0].Content != "hi" || one[1].MsgID != "1" {
|
|
t.Fatalf("ch1 过滤: %+v", one)
|
|
}
|
|
// n 截断
|
|
if two := s.LinkReceipts(0, 2); len(two) != 2 || two[0].Content != "hi" {
|
|
t.Fatalf("n 截断: %+v", two)
|
|
}
|
|
}
|
|
|
|
// TestDeliverMODecode 上行按 Msg_Fmt 解码(Day52 编码复盘补齐):GBK(0x0F)/UCS2(0x08)
|
|
// 注入 → 环形缓冲还原 UTF-8 中文;此前 string(d.Content) 原样直灌致真实上游中文上行乱码。
|
|
func TestDeliverMODecode(t *testing.T) {
|
|
s := newSvc(t)
|
|
ch := mustCreateCh(t, s, "mo-dec")
|
|
// GBK 上行:复用 EncodeContent 编码「退订」
|
|
gbk, fmtGbk, err := cmpp.EncodeContent("退订")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s.Pool().HandleDeliver(ch.ID, &cmpp.Deliver{
|
|
MsgID: 1, DestID: "10086", MsgFmt: fmtGbk, SrcTerminal: "13800001111", Content: gbk})
|
|
// UCS2 上行:「停」U+505C
|
|
s.Pool().HandleDeliver(ch.ID, &cmpp.Deliver{
|
|
MsgID: 2, DestID: "10086", MsgFmt: cmpp.MsgFmtUCS2, SrcTerminal: "13900002222",
|
|
Content: []byte{0x50, 0x5C}})
|
|
all := s.LinkReceipts(0, 10)
|
|
if len(all) != 2 {
|
|
t.Fatalf("total = %d", len(all))
|
|
}
|
|
if all[0].Content != "停" || all[0].Src != "13900002222" {
|
|
t.Fatalf("UCS2 上行解码: %+v", all[0])
|
|
}
|
|
if all[1].Content != "退订" || all[1].Src != "13800001111" {
|
|
t.Fatalf("GBK 上行解码: %+v", all[1])
|
|
}
|
|
}
|
|
|
|
// TestReceiptsCap 验收:环形缓冲上限(最近 100 条)。
|
|
func TestReceiptsCap(t *testing.T) {
|
|
s := newSvc(t)
|
|
ch := mustCreateCh(t, s, "cap")
|
|
for i := 0; i < 120; i++ {
|
|
s.Pool().HandleDeliver(ch.ID, &cmpp.Deliver{
|
|
MsgID: uint64(i), DestID: "10086", MsgFmt: cmpp.MsgFmtASCII,
|
|
SrcTerminal: "13800001111", Content: fmt.Appendf(nil, "c%d", i)})
|
|
}
|
|
all := s.LinkReceipts(0, 200)
|
|
if len(all) != 100 {
|
|
t.Fatalf("缓冲上限 = %d, 期望 100", len(all))
|
|
}
|
|
if all[0].Content != "c119" || all[99].Content != "c20" {
|
|
t.Fatalf("保留最新: all[0]=%q all[99]=%q", all[0].Content, all[99].Content)
|
|
}
|
|
}
|
|
|
|
// TestBootstrapLinks 验收:启动引导仅对启用中 cmpp 建链(禁用/他协议跳过);Shutdown 全拆。
|
|
func TestBootstrapLinks(t *testing.T) {
|
|
s := newSvc(t)
|
|
t.Cleanup(func() { s.ShutdownLinks() })
|
|
ln, _ := listenMiniCMPP(t)
|
|
ctx := context.Background()
|
|
ch1 := mustCreateLinkable(t, s, "bt-1", ln)
|
|
ch2 := mustCreateLinkable(t, s, "bt-2", ln)
|
|
ch3 := mustCreateLinkable(t, s, "bt-3", ln)
|
|
_ = s.SetStatus(ctx, ch3.ID, 0)
|
|
_ = mustCreateCh(t, s, "bt-http")
|
|
|
|
s.BootstrapLinks(ctx)
|
|
deadline := time.Now().Add(3 * time.Second)
|
|
ok1, ok2 := false, false
|
|
for time.Now().Before(deadline) {
|
|
ok1 = s.LinkStatus(ch1.ID).Running
|
|
ok2 = s.LinkStatus(ch2.ID).Running
|
|
if ok1 && ok2 {
|
|
break
|
|
}
|
|
time.Sleep(20 * time.Millisecond)
|
|
}
|
|
if !ok1 || !ok2 {
|
|
t.Fatalf("bootstrap: ch1=%v ch2=%v", s.LinkStatus(ch1.ID), s.LinkStatus(ch2.ID))
|
|
}
|
|
if s.LinkStatus(ch3.ID).Running {
|
|
t.Fatal("禁用通道不应建链")
|
|
}
|
|
// Shutdown 全拆
|
|
s.ShutdownLinks()
|
|
if s.LinkStatus(ch1.ID).Running || s.LinkStatus(ch2.ID).Running {
|
|
t.Fatal("shutdown 后仍在运行")
|
|
}
|
|
}
|
|
|
|
// TestRestartLink 验收:参数变更重建(Stop+Start)后链路可用。
|
|
func TestRestartLink(t *testing.T) {
|
|
s := newSvc(t)
|
|
t.Cleanup(func() { s.ShutdownLinks() })
|
|
ln, _ := listenMiniCMPP(t)
|
|
ctx := context.Background()
|
|
ch := mustCreateLinkable(t, s, "rs", ln)
|
|
if st, err := s.StartLink(ctx, ch.ID); err != nil || !st.Running {
|
|
t.Fatalf("初始建链: st=%+v err=%v", st, err)
|
|
}
|
|
if !waitLink(t, s, ch.ID, 1) {
|
|
t.Fatal("初始建链失败")
|
|
}
|
|
st, err := s.RestartLink(ctx, ch.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !st.Running {
|
|
t.Fatalf("restart 应 Running: %+v", st)
|
|
}
|
|
if !waitLink(t, s, ch.ID, 1) {
|
|
t.Fatalf("restart 后链路未就绪: %+v", s.LinkStatus(ch.ID))
|
|
}
|
|
msgIDs, err := s.SubmitViaLink(ctx, ch.ID, "13800001111", "again")
|
|
if err != nil || len(msgIDs) != 1 || msgIDs[0] != "777" {
|
|
t.Fatalf("restart 后提交: msg=%v err=%v", msgIDs, err)
|
|
}
|
|
}
|
|
|
|
// mustCreateLinkable 建一条可建链的 cmpp 通道(密码与迷你网关密钥 pw 校准)。
|
|
func mustCreateLinkable(t *testing.T, s *channel.Service, code string, ln net.Listener) *entity.ChannelChannel {
|
|
t.Helper()
|
|
ch, err := s.Create(context.Background(), &channel.CreateReq{
|
|
Name: code, Code: code, Protocol: "cmpp",
|
|
Host: "127.0.0.1", Port: portOf(ln), Username: "901234", Password: "pw",
|
|
ConnCount: 1, HeartbeatInterval: 1})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return ch
|
|
}
|
|
|
|
// waitLink 轮询等待链路健康连接达到期望值(t 预留测试上下文)。
|
|
func waitLink(_ *testing.T, s *channel.Service, id int64, want int) bool {
|
|
deadline := time.Now().Add(3 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if st := s.LinkStatus(id); st.Running && st.Healthy >= want {
|
|
return true
|
|
}
|
|
time.Sleep(20 * time.Millisecond)
|
|
}
|
|
return false
|
|
}
|
|
|
|
// uplinkCapture Day 49:上行出口捕获。
|
|
type uplinkCapture struct {
|
|
ch chan [4]any // channelID/destCode/srcMobile/content
|
|
}
|
|
|
|
func newUplinkCapture() *uplinkCapture {
|
|
return &uplinkCapture{ch: make(chan [4]any, 4)}
|
|
}
|
|
|
|
func (u *uplinkCapture) Ingest(_ context.Context, channelID int64, destCode, srcMobile, content string) (int64, error) {
|
|
u.ch <- [4]any{channelID, destCode, srcMobile, content}
|
|
return 0, nil
|
|
}
|
|
|
|
// TestHandleDeliverUplinkSink Day 49 验收:Deliver MO 派发上行出口
|
|
// (码号/手机号/内容透传);状态报告不派发;未注入(nil)不派发维持旧行为。
|
|
func TestHandleDeliverUplinkSink(t *testing.T) {
|
|
s := newSvc(t)
|
|
ch1 := mustCreateCh(t, s, "up-1")
|
|
|
|
// 未注入:无 panic 无派发。
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 1, DestID: "10690001", SrcTerminal: "13800001111", Content: []byte("TD")})
|
|
|
|
cap := newUplinkCapture()
|
|
s.SetUplinkSink(cap)
|
|
// 上行 MO:派发(异步 goroutine)。
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 2, DestID: "10690001", SrcTerminal: "13800001111", Content: []byte("TD")})
|
|
select {
|
|
case got := <-cap.ch:
|
|
if got[0] != ch1.ID || got[1] != "10690001" || got[2] != "13800001111" || got[3] != "TD" {
|
|
t.Fatalf("派发字段: %v", got)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("MO 未派发上行出口")
|
|
}
|
|
// 状态报告:不派发。
|
|
s.Pool().HandleDeliver(ch1.ID, &cmpp.Deliver{
|
|
MsgID: 3, IsReport: true, Report: &cmpp.ReportInfo{MsgID: 3, Stat: "DELIVRD"}})
|
|
select {
|
|
case got := <-cap.ch:
|
|
t.Fatalf("状态报告不应派发上行: %v", got)
|
|
case <-time.After(150 * time.Millisecond):
|
|
}
|
|
}
|
|
|
|
// newSvc pool 链路测试构造(S1-B P2 自 channel/service_test.go newSvc35 同体复制;
|
|
// 外部测试包断环后本地化,口径与原实现一致)。
|
|
func newSvc(t *testing.T) *channel.Service {
|
|
t.Helper()
|
|
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if sqlDB, e := db.DB(); e == nil {
|
|
sqlDB.SetMaxOpenConns(1)
|
|
}
|
|
if err := db.AutoMigrate(&entity.ChannelChannel{}, &entity.ChannelLog{}, &entity.SystemAlertRule{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
s := channel.NewService(db)
|
|
t.Cleanup(s.Close) // Day 40:冲刷通道日志 writer,防 goroutine/连接泄漏
|
|
return s
|
|
}
|