409 lines
14 KiB
Go
409 lines
14 KiB
Go
// server_test.go Day 47:CMPP 服务端测试——真实 TCP 回环:cmpp.Client(现有客户端)
|
|
// 连接 cmpp.Server,验证 Connect 鉴权(通过/拒绝)/Submit 受理(GBK 内容解码/
|
|
// 多号码/Result 回带)/ActiveTest 心跳。
|
|
package cmpp
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"golang.org/x/text/encoding/unicode"
|
|
)
|
|
|
|
// fakeHandler 测试回调:密钥固定,Submit 落 channel 供断言。
|
|
type fakeHandler struct {
|
|
secret string
|
|
submits chan *submitRecord
|
|
rejectAll bool
|
|
connLimit int // Day 62:账号最大连接数(0=不限)
|
|
rateLimit int // Day 62:单链限速 条/s(0=不限)
|
|
}
|
|
|
|
type submitRecord struct {
|
|
srcID string
|
|
dest []string
|
|
content string
|
|
regDel uint8
|
|
udh *UDHInfo // 长短信拼接头(批次 2278141 修复;nil=普通提交)
|
|
}
|
|
|
|
func (h *fakeHandler) Connect(sourceAddr string, ts uint32, authenticator []byte, clientIP string) byte {
|
|
if !VerifyAuth(sourceAddr, h.secret, ts, authenticator) {
|
|
return ConnectBadAuth
|
|
}
|
|
return ConnectOK
|
|
}
|
|
|
|
func (h *fakeHandler) Submit(sourceAddr, srcID string, dest []string,
|
|
content string, udh *UDHInfo, registeredDelivery uint8, msgFmt uint8) (uint64, byte) {
|
|
if h.rejectAll {
|
|
return 0, SubmitRejected
|
|
}
|
|
h.submits <- &submitRecord{srcID: srcID, dest: dest, content: content,
|
|
regDel: registeredDelivery, udh: udh}
|
|
return 20260911, SubmitOK
|
|
}
|
|
|
|
// Day 62:可选限流接口(零值=不限,既有用例零影响)。
|
|
func (h *fakeHandler) ConnLimit(sourceAddr string) int { return h.connLimit }
|
|
func (h *fakeHandler) SubmitRateLimit(sourceAddr string) int { return h.rateLimit }
|
|
|
|
// startTestServer 起 :0 端口服务端。
|
|
func startTestServer(t *testing.T, h *fakeHandler) *Server {
|
|
t.Helper()
|
|
srv := NewServer(ServerConfig{Addr: "127.0.0.1:0", IdleTimeout: 5 * time.Second}, h)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
t.Cleanup(func() { cancel(); srv.Close() })
|
|
go func() { _ = srv.ListenAndServe(ctx) }()
|
|
// 等监听就绪
|
|
for i := 0; i < 50 && srv.Addr() == ""; i++ {
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
if srv.Addr() == "" {
|
|
t.Fatal("server 未监听")
|
|
}
|
|
return srv
|
|
}
|
|
|
|
// TestServer_ConnectOKAndSubmit 鉴权通过+中文 Submit 受理(GBK 解码)。
|
|
func TestServer_ConnectOKAndSubmit(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4)}
|
|
srv := startTestServer(t, h)
|
|
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
frags, err := SplitContent("【签名】中文测试内容")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
resp, err := c.Submit(&SubmitReq{
|
|
ServiceID: "TEST", MsgFmt: frags[0].MsgFmt, TPUdhi: frags[0].TPUdhi,
|
|
MsgSrc: "user1", FeeType: "01", SrcID: "UT0012",
|
|
DestTerminalIDs: []string{"13800138000", "13800138001"},
|
|
Content: frags[0].Content, RegisteredDelivery: 1,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Submit: %v", err)
|
|
}
|
|
if resp.Result != 0 {
|
|
t.Fatalf("Result=%d", resp.Result)
|
|
}
|
|
if resp.MsgID != 20260911 {
|
|
t.Fatalf("MsgID=%d", resp.MsgID)
|
|
}
|
|
select {
|
|
case rec := <-h.submits:
|
|
if rec.content != "【签名】中文测试内容" {
|
|
t.Fatalf("内容解码错误: %q", rec.content)
|
|
}
|
|
if rec.srcID != "UT0012" || len(rec.dest) != 2 || rec.dest[0] != "13800138000" {
|
|
t.Fatalf("受理字段错误: %+v", rec)
|
|
}
|
|
if rec.regDel != 1 {
|
|
t.Fatalf("RegisteredDelivery=%d", rec.regDel)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("服务端未收到 Submit")
|
|
}
|
|
}
|
|
|
|
// TestServer_PushDeliver Day 61(P0.5):Connect 注册会话→PushDeliver 下发状态报告
|
|
// →客户端 OnDeliver 收到(含 MsgID/Stat 口径)→服务端吸收 Deliver_Resp。
|
|
func TestServer_PushDeliver(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4)}
|
|
srv := startTestServer(t, h)
|
|
|
|
got := make(chan *Deliver, 2)
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
c.OnDeliver = func(d *Deliver) { got <- d }
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
if n := srv.PushDeliver("user1", &Deliver{
|
|
MsgID: 622373593669439488, DestID: "10690", SrcTerminal: "13800138000",
|
|
IsReport: true, Report: &ReportInfo{
|
|
MsgID: 622373593669439488, Stat: "DELIVRD",
|
|
SubmitTime: "0914181028", DoneTime: "0914181033",
|
|
DestTerminalID: "13800138000",
|
|
},
|
|
}); n != 1 {
|
|
t.Fatalf("在线会话应送达 1 条,实际 %d", n)
|
|
}
|
|
select {
|
|
case d := <-got:
|
|
if !d.IsReport || d.Report == nil {
|
|
t.Fatalf("应为状态报告: %+v", d)
|
|
}
|
|
if d.Report.MsgID != 622373593669439488 || d.Report.Stat != "DELIVRD" {
|
|
t.Fatalf("报告口径错误: %+v", d.Report)
|
|
}
|
|
if d.SrcTerminal != "13800138000" {
|
|
t.Fatalf("SrcTerminal=%q", d.SrcTerminal)
|
|
}
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("客户端未收到 Deliver")
|
|
}
|
|
|
|
// 离线账号:0 条送达(尽力而为口径)。
|
|
if n := srv.PushDeliver("nobody", &Deliver{IsReport: true}); n != 0 {
|
|
t.Fatalf("离线账号应 0 条,实际 %d", n)
|
|
}
|
|
}
|
|
|
|
// TestServer_PushDeliverSessionLifecycle 断连后会话注销:PushDeliver 不再指向死连接。
|
|
func TestServer_PushDeliverSessionLifecycle(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4)}
|
|
srv := startTestServer(t, h)
|
|
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
_ = c.Close() // 断连
|
|
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if srv.PushDeliver("user1", &Deliver{IsReport: true}) == 0 {
|
|
return // 注销生效
|
|
}
|
|
time.Sleep(50 * time.Millisecond)
|
|
}
|
|
t.Fatal("断连后会话未注销")
|
|
}
|
|
|
|
// TestServer_ConnLimitRejected Day 62:账号级连接数上限——上限 1 时第二条
|
|
// 连接被拒(ConnectResp status=0x8 扩展语义),且超限会话不注册(PushDeliver
|
|
// 仍只送达第一条)。
|
|
func TestServer_ConnLimitRejected(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4), connLimit: 1}
|
|
srv := startTestServer(t, h)
|
|
|
|
c1 := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c1.Connect(context.Background()); err != nil {
|
|
t.Fatalf("首条连接应成功: %v", err)
|
|
}
|
|
defer c1.Close()
|
|
|
|
c2 := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c2.Connect(context.Background()); err == nil {
|
|
c2.Close()
|
|
t.Fatal("超限连接应被拒")
|
|
}
|
|
if n := srv.PushDeliver("user1", &Deliver{IsReport: true}); n != 1 {
|
|
t.Fatalf("超限会话不应注册,送达数=%d", n)
|
|
}
|
|
}
|
|
|
|
// TestServer_SubmitRateLimit Day 62:单链限速——1s 窗口超限回 Result=8
|
|
// (流量控制错,标准退避语义),窗口内前 N 条正常受理。
|
|
func TestServer_SubmitRateLimit(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4), rateLimit: 2}
|
|
srv := startTestServer(t, h)
|
|
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
submit := func() byte {
|
|
resp, err := c.Submit(&SubmitReq{SrcID: "T1", DestTerminalIDs: []string{"13800138000"},
|
|
Content: []byte("hi"), MsgFmt: 0, ServiceID: "T", MsgSrc: "user1", FeeType: "01"})
|
|
if err != nil {
|
|
t.Fatalf("Submit: %v", err)
|
|
}
|
|
return resp.Result
|
|
}
|
|
if r := submit(); r != 0 {
|
|
t.Fatalf("窗口内第 1 条 Result=%d", r)
|
|
}
|
|
if r := submit(); r != 0 {
|
|
t.Fatalf("窗口内第 2 条 Result=%d", r)
|
|
}
|
|
if r := submit(); r != SubmitFlowCtrl {
|
|
t.Fatalf("超窗第 3 条应回流量控制(8),实际 %d", r)
|
|
}
|
|
}
|
|
|
|
// TestServer_ConnectRejected 错误密钥:ISMG 回 status=2,客户端报登录被拒。
|
|
func TestServer_ConnectRejected(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 1)}
|
|
srv := startTestServer(t, h)
|
|
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "wrong"})
|
|
if err := c.Connect(context.Background()); err == nil {
|
|
c.Close()
|
|
t.Fatal("期望登录被拒")
|
|
}
|
|
}
|
|
|
|
// TestServer_ActiveTest 鉴权后心跳应答(直调 heartbeat:同包白盒)。
|
|
func TestServer_ActiveTest(t *testing.T) {
|
|
h := &fakeHandler{secret: "s", submits: make(chan *submitRecord, 1)}
|
|
srv := startTestServer(t, h)
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "u", Secret: "s"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer c.Close()
|
|
for i := 0; i < 3; i++ {
|
|
if err := c.heartbeat(); err != nil {
|
|
t.Fatalf("heartbeat #%d: %v", i, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestParseSubmitReq_RoundTrip Marshal→ParseSubmitReq 往返(偏移口径回归:
|
|
// Day 39 曾因 3.0 字段混入错位,服务端解析必须与 2.0 编码对称)。
|
|
func TestParseSubmitReq_RoundTrip(t *testing.T) {
|
|
req := &SubmitReq{
|
|
PkTotal: 1, PkNumber: 1, RegisteredDelivery: 1,
|
|
ServiceID: "SVC", FeeUserType: 0, MsgFmt: MsgFmtASCII,
|
|
MsgSrc: "900001", FeeType: "01", FeeCode: "000000",
|
|
SrcID: "UT0012", DestTerminalIDs: []string{"13800138000"},
|
|
Content: []byte("hello"),
|
|
}
|
|
body, err := req.Marshal()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p, err := ParseSubmitReq(body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if p.SrcID != "UT0012" || p.MsgSrc != "900001" || p.ServiceID != "SVC" {
|
|
t.Fatalf("定长字段错位: %+v", p)
|
|
}
|
|
if len(p.DestTerminalIDs) != 1 || p.DestTerminalIDs[0] != "13800138000" {
|
|
t.Fatalf("号码解析错误: %v", p.DestTerminalIDs)
|
|
}
|
|
if string(p.Content) != "hello" || p.RegisteredDelivery != 1 {
|
|
t.Fatalf("内容/回执标志错误: %+v", p)
|
|
}
|
|
}
|
|
|
|
// TestParseUDH 拼接 UDH 识别/剥离(批次 2278141 修复):只认与出向 SplitContent
|
|
// 同构的 05 00 03 ref total idx 形态;其它 IEI/语义非法原样透传不误剥。
|
|
func TestParseUDH(t *testing.T) {
|
|
head := []byte{0x05, 0x00, 0x03, 0x02, 0x02, 0x01}
|
|
udh, rest := ParseUDH(append(append([]byte{}, head...), 'a', 'b'))
|
|
if udh == nil || udh.Ref != 2 || udh.Total != 2 || udh.Idx != 1 || string(rest) != "ab" {
|
|
t.Fatalf("拼接形态: %+v rest=%q", udh, rest)
|
|
}
|
|
for _, c := range [][]byte{
|
|
{0x05, 0x04, 0x0F, 0x84, 0x00, 0x00, 'x'}, // 端口寻址 IEI:非拼接
|
|
{0x05, 0x00, 0x03, 0x01, 0x01, 0x01, 'x'}, // total=1 非拼接
|
|
{0x05, 0x00, 0x03, 0x02, 0x02, 0x03, 'x'}, // idx 越界
|
|
{0x05, 0x00, 0x03, 0x02, 0x02}, // 短包
|
|
} {
|
|
if udh, rest := ParseUDH(c); udh != nil || len(rest) != len(c) {
|
|
t.Fatalf("非拼接形态应原样透传: in=% x udh=%+v", c, udh)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestServer_LongSmsUDHRoundTrip 长短信片回环:出向 SplitContent 拆片→客户端
|
|
// 逐片 Submit→服务端剥 UDH 解码(无乱码)+拼接信息透传 handler,拼接还原原文
|
|
// ——出向拆分与入向剥头互逆自证(批次 2278141:原实现整包解码片首 3 乱码字符)。
|
|
func TestServer_LongSmsUDHRoundTrip(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 4)}
|
|
srv := startTestServer(t, h)
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
full := strings.Repeat("汉", 100) // 200B → GBK 2 片
|
|
frags, err := SplitContent(full)
|
|
if err != nil || len(frags) != 2 {
|
|
t.Fatalf("拆分: n=%d err=%v", len(frags), err)
|
|
}
|
|
var rebuilt strings.Builder
|
|
for i, f := range frags {
|
|
resp, err := c.Submit(&SubmitReq{
|
|
ServiceID: "TEST", MsgFmt: f.MsgFmt, TPUdhi: f.TPUdhi,
|
|
PkTotal: f.PkTotal, PkNumber: f.PkNumber,
|
|
MsgSrc: "user1", FeeType: "01", SrcID: "10690331",
|
|
DestTerminalIDs: []string{"13800001111"},
|
|
Content: f.Content, RegisteredDelivery: 1,
|
|
})
|
|
if err != nil || resp.Result != SubmitOK {
|
|
t.Fatalf("片%d Submit: resp=%+v err=%v", i+1, resp, err)
|
|
}
|
|
select {
|
|
case rec := <-h.submits:
|
|
if rec.udh == nil {
|
|
t.Fatal("拼接 UDH 未透传 handler")
|
|
}
|
|
if rec.udh.Total != 2 || rec.udh.Idx != uint8(i+1) || rec.udh.Ref != f.Content[3] {
|
|
t.Fatalf("片%d UDH: %+v", i+1, rec.udh)
|
|
}
|
|
rebuilt.WriteString(rec.content)
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("服务端未收到片")
|
|
}
|
|
}
|
|
if rebuilt.String() != full {
|
|
t.Fatalf("剥头解码后拼接不还原: got %d 字 want %d 字",
|
|
len([]rune(rebuilt.String())), len([]rune(full)))
|
|
}
|
|
}
|
|
|
|
// TestServer_LongSmsUDHUCS2 UCS2 客户端形态(批次 2278141 实例:片首
|
|
// 「05 00 03 02 02 01/02」+UTF-16BE 正文):剥头解码拼接还原,锁乱码缺陷回归。
|
|
func TestServer_LongSmsUDHUCS2(t *testing.T) {
|
|
h := &fakeHandler{secret: "abc123", submits: make(chan *submitRecord, 2)}
|
|
srv := startTestServer(t, h)
|
|
c := NewClient(Config{Addr: srv.Addr(), SourceAddr: "user1", Secret: "abc123"})
|
|
if err := c.Connect(context.Background()); err != nil {
|
|
t.Fatalf("Connect: %v", err)
|
|
}
|
|
defer c.Close()
|
|
|
|
enc := unicode.UTF16(unicode.BigEndian, unicode.IgnoreBOM).NewEncoder()
|
|
frag := func(idx int, text string) []byte {
|
|
body, err := enc.Bytes([]byte(text))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return append([]byte{0x05, 0x00, 0x03, 0x02, 0x02, byte(idx)}, body...)
|
|
}
|
|
p1, p2 := strings.Repeat("甲", 40), strings.Repeat("乙", 10)
|
|
for i, f := range [][]byte{frag(1, p1), frag(2, p2)} {
|
|
resp, err := c.Submit(&SubmitReq{
|
|
ServiceID: "TEST", MsgFmt: MsgFmtUCS2, TPUdhi: 1,
|
|
PkTotal: 2, PkNumber: uint8(i + 1),
|
|
MsgSrc: "user1", FeeType: "01", SrcID: "10690331",
|
|
DestTerminalIDs: []string{"13800001111"},
|
|
Content: f, RegisteredDelivery: 1,
|
|
})
|
|
if err != nil || resp.Result != SubmitOK {
|
|
t.Fatalf("片%d: resp=%+v err=%v", i+1, resp, err)
|
|
}
|
|
}
|
|
var got strings.Builder
|
|
for i := 0; i < 2; i++ {
|
|
select {
|
|
case rec := <-h.submits:
|
|
if rec.udh == nil || rec.udh.Ref != 0x02 || rec.udh.Total != 2 {
|
|
t.Fatalf("UDH: %+v", rec.udh)
|
|
}
|
|
got.WriteString(rec.content)
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("服务端未收到片")
|
|
}
|
|
}
|
|
if got.String() != p1+p2 {
|
|
t.Fatal("UCS2 剥头拼接不还原(2278141 乱码缺陷回归锁)")
|
|
}
|
|
}
|