Files
go-sms-V2/internal/protocol/cmpp/client_test.go
T

301 lines
8.9 KiB
Go

// client_test.go Day 31:模拟网关集成——握手/鉴权拒绝/心跳/超时断连自动重连。
package cmpp
import (
"context"
"errors"
"net"
"sync"
"sync/atomic"
"testing"
"time"
)
// fakeGateway 模拟 CMPP 网关:校验 Connect 鉴权并应答;心跳可随时"静默"制造超时。
// Day 32:Submit 应答(msg_id 分配)/DeliverResp 计数/主动下发 pushDeliver。
type fakeGateway struct {
ln net.Listener
secret string
acceptAuth bool // false:一律回 status=1 拒绝
mu sync.Mutex
// respondHB false:收到心跳不应答(制造客户端读超时)
respondHB bool
// rejectSubmit true:Submit 一律回 result=1
rejectSubmit bool
conns map[net.Conn]struct{} // 活跃连接(pushDeliver 用)
logins atomic.Int32
heartbeats atomic.Int32
connCount atomic.Int32 // 累计 TCP 连接数
deliverAck atomic.Int32 // 收到的 Deliver_Resp 计数
submits atomic.Int32 // 收到的 Submit 计数
}
func newFakeGateway(t *testing.T, secret string, acceptAuth, respondHB bool) *fakeGateway {
t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
g := &fakeGateway{ln: ln, secret: secret, acceptAuth: acceptAuth, respondHB: respondHB,
conns: map[net.Conn]struct{}{}}
go g.serve()
t.Cleanup(func() { _ = ln.Close() })
return g
}
// pushDeliver 向全部活跃连接下发一条 Deliver(报告/上行)。
func (g *fakeGateway) pushDeliver(d *Deliver) {
body, err := MarshalDeliver(d)
if err != nil {
return
}
g.mu.Lock()
conns := make([]net.Conn, 0, len(g.conns))
for c := range g.conns {
conns = append(conns, c)
}
g.mu.Unlock()
for _, c := range conns {
_ = WritePacket(c, &Header{CommandID: CmdDeliver, SequenceID: 99}, body)
}
}
// serve 接受并处理连接。
func (g *fakeGateway) serve() {
for {
conn, err := g.ln.Accept()
if err != nil {
return
}
// 连接计数移至 login 成功处(connCount)
go g.handle(conn)
}
}
// handle 单连接处理循环。
func (g *fakeGateway) handle(conn net.Conn) {
g.mu.Lock()
g.conns[conn] = struct{}{}
g.mu.Unlock()
defer func() {
g.mu.Lock()
delete(g.conns, conn)
g.mu.Unlock()
_ = conn.Close()
}()
for {
h, body, err := ReadPacket(conn)
if err != nil {
return
}
switch h.CommandID {
case CmdConnect:
addr, auth, ts, err := ParseConnect(body)
status := byte(0)
if err != nil || !g.acceptAuth || !VerifyAuth(addr, g.secret, ts, auth) {
status = 1
}
resp := &ConnectResp{Status: status, Secret: g.secret, AuthenticatorClient: auth}
if status != 0 {
resp.AuthenticatorClient = body[6:22] // 拒绝时仍回包(客户端按 status 判)
}
_ = WritePacket(conn, &Header{CommandID: CmdConnectResp, SequenceID: h.SequenceID}, resp.Marshal())
if status == 0 {
g.logins.Add(1)
g.connCount.Add(1)
}
case CmdSubmit:
g.submits.Add(1)
result := uint8(0)
g.mu.Lock()
reject := g.rejectSubmit
g.mu.Unlock()
if reject {
result = 1
}
// 分配 msg_id = seq(客户端可关联)
_ = WritePacket(conn, &Header{CommandID: CmdSubmitResp, SequenceID: h.SequenceID},
(&SubmitResp{MsgID: uint64(h.SequenceID), Result: result}).Marshal())
case CmdDeliverResp:
g.deliverAck.Add(1)
case CmdActiveTest:
g.heartbeats.Add(1)
g.mu.Lock()
respond := g.respondHB
g.mu.Unlock()
if respond {
_ = WritePacket(conn, &Header{CommandID: CmdActiveTestResp, SequenceID: h.SequenceID}, ActiveTestResp(0))
}
case CmdTerminate:
_ = WritePacket(conn, &Header{CommandID: CmdTerminateResp, SequenceID: h.SequenceID}, nil)
return
}
}
}
// setReject 切换 Submit 拒绝。
func (g *fakeGateway) setReject(v bool) {
g.mu.Lock()
g.rejectSubmit = v
g.mu.Unlock()
}
// setRespond 切换心跳应答。
func (g *fakeGateway) setRespond(v bool) {
g.mu.Lock()
g.respondHB = v
g.mu.Unlock()
}
// fastCfg 测试用快速参数(心跳 80ms/读超时 350ms/重连退避 40ms)。
func fastCfg(addr string) Config {
return Config{
Addr: addr, SourceAddr: "901234", Secret: "s3cret",
HeartbeatInterval: 80 * time.Millisecond,
ReadTimeout: 350 * time.Millisecond,
ReconnectMin: 40 * time.Millisecond,
ReconnectMax: 160 * time.Millisecond,
LoginTimeout: time.Second,
}
}
// TestClient_LoginOK 验收:与模拟网关握手成功,Login status=0。
func TestClient_LoginOK(t *testing.T) {
g := newFakeGateway(t, "s3cret", true, true)
c := NewClient(fastCfg(g.ln.Addr().String()))
if err := c.Connect(context.Background()); err != nil {
t.Fatalf("握手应成功: %v", err)
}
defer func() { _ = c.Close() }()
// 网关侧 logins.Add 在 WritePacket 之后:客户端握手完成与计数落账存在
// 调度窗口,全量 -race 并行下曾偶发 0(轮询吸收,免 flaky 阻塞门禁)。
deadline := time.Now().Add(time.Second)
for g.logins.Load() != 1 && time.Now().Before(deadline) {
time.Sleep(5 * time.Millisecond)
}
if g.logins.Load() != 1 {
t.Fatalf("网关成功登录数 = %d", g.logins.Load())
}
}
// TestClient_LoginRejected 鉴权失败:网关回 status=1 → ErrLoginRejected。
func TestClient_LoginRejected(t *testing.T) {
g := newFakeGateway(t, "other-secret", true, true) // 密钥不匹配
c := NewClient(fastCfg(g.ln.Addr().String()))
err := c.Connect(context.Background())
if !errors.Is(err, ErrLoginRejected) {
t.Fatalf("应 ErrLoginRejected, got %v", err)
}
}
// TestClient_Heartbeat 心跳往返:OnHeartbeat 触发且网关计数。
func TestClient_Heartbeat(t *testing.T) {
g := newFakeGateway(t, "s3cret", true, true)
c := NewClient(fastCfg(g.ln.Addr().String()))
if err := c.Connect(context.Background()); err != nil {
t.Fatal(err)
}
defer func() { _ = c.Close() }()
var beats atomic.Int32
c.OnHeartbeat = func(seq uint32) { beats.Add(1) }
if err := c.heartbeat(); err != nil {
t.Fatalf("首次心跳: %v", err)
}
if err := c.heartbeat(); err != nil {
t.Fatalf("二次心跳: %v", err)
}
if beats.Load() != 2 || g.heartbeats.Load() != 2 {
t.Fatalf("心跳计数 cli=%d gw=%d", beats.Load(), g.heartbeats.Load())
}
}
// TestClient_HeartbeatTimeoutDisconnected 心跳无应答:读超时触发,链路标记失效。
func TestClient_HeartbeatTimeoutDisconnected(t *testing.T) {
g := newFakeGateway(t, "s3cret", true, false) // 不应答心跳
c := NewClient(fastCfg(g.ln.Addr().String()))
if err := c.Connect(context.Background()); err != nil {
t.Fatal(err)
}
disconnected := make(chan error, 1)
c.OnDisconnected = func(err error) { disconnected <- err }
if err := c.heartbeat(); err == nil {
t.Fatal("无应答心跳应超时失败")
}
select {
case err := <-disconnected:
if err == nil {
t.Fatal("断连回调应携带错误")
}
case <-time.After(time.Second):
t.Fatal("未触发断连回调")
}
}
// TestClient_LoginUnreachable 网关不可达:Connect 返回错误。
func TestClient_LoginUnreachable(t *testing.T) {
c := NewClient(Config{Addr: "127.0.0.1:1", SourceAddr: "x", Secret: "y", LoginTimeout: 500 * time.Millisecond})
if err := c.Connect(context.Background()); err == nil {
t.Fatal("不可达地址应报错")
}
}
// TestClient_HeartbeatWithoutConn 未连接心跳报错。
func TestClient_HeartbeatWithoutConn(t *testing.T) {
c := NewClient(fastCfg("127.0.0.1:1"))
if err := c.heartbeat(); err == nil || err.Error() != "cmpp: 未连接" {
t.Fatalf("未连接心跳 = %v", err)
}
}
// TestClient_RunCtxCancel Run 响应 ctx 取消。
func TestClient_RunCtxCancel(t *testing.T) {
g := newFakeGateway(t, "s3cret", true, true)
c := NewClient(fastCfg(g.ln.Addr().String()))
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { done <- c.Run(ctx) }()
cancel()
select {
case err := <-done:
if !errors.Is(err, context.Canceled) {
t.Fatalf("应返回 ctx.Canceled, got %v", err)
}
case <-time.After(2 * time.Second):
t.Fatal("Run 未随 ctx 退出")
}
}
// TestClient_RunReconnects 验收:心跳超时断连 → Run 自动重连成功(二次登录)。
func TestClient_RunReconnects(t *testing.T) {
g := newFakeGateway(t, "s3cret", true, false) // 初始静默心跳(制造超时)
cfg := fastCfg(g.ln.Addr().String())
c := NewClient(cfg)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go func() { _ = c.Run(ctx) }()
waitFor := func(desc string, cond func() bool) {
t.Helper()
deadline := time.Now().Add(4 * time.Second)
for time.Now().Before(deadline) {
if cond() {
return
}
time.Sleep(20 * time.Millisecond)
}
t.Fatalf("%s 超时: logins=%d heartbeats=%d conns=%d", desc, g.logins.Load(), g.heartbeats.Load(), g.connCount.Load())
}
// ① 首次登录
waitFor("首次登录", func() bool { return g.logins.Load() >= 1 })
// ② 心跳超时 → 断连(客户端感知链路失效)
waitFor("心跳超时断连", func() bool { return c.LastErr() != nil && g.connCount.Load() >= 2 })
// ③ 恢复应答 → 客户端重连并再次登录成功
g.setRespond(true)
waitFor("自动重连成功", func() bool { return g.logins.Load() >= 2 && g.heartbeats.Load() >= 1 })
_ = c.Close()
}