295 lines
8.6 KiB
Go
295 lines
8.6 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() }()
|
|
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()
|
|
}
|