Files

218 lines
6.4 KiB
Go

// sgip_test.go Day 33:SGIP 编解码 + 模拟网关(bind/submit/report)。
package sgip
import (
"context"
"net"
"sync"
"sync/atomic"
"testing"
"time"
)
// TestHeaderRoundTrip 20B 头编解码往返与非法头。
func TestHeaderRoundTrip(t *testing.T) {
h := &Header{MessageLength: HeaderLen, CommandID: CmdSubmit,
Sequence: Sequence{NodeID: 1, DateTime: 904120000, Seq: 7}}
got, err := ParseHeader(h.Marshal())
if err != nil || got.CommandID != CmdSubmit || got.Sequence.Seq != 7 || got.Sequence.NodeID != 1 {
t.Fatalf("往返: %+v err=%v", got, err)
}
if got.MessageLength != HeaderLen {
t.Fatalf("length = %d", got.MessageLength)
}
if _, err := ParseHeader(make([]byte, 10)); err == nil {
t.Fatal("短头应拒绝")
}
bad := h.Marshal()
bad[0] = 0xFF // length 高位置 1 → 巨大(超出 64KB 上限)
if _, err := ParseHeader(bad); err == nil {
t.Fatal("超大 length 应拒绝")
}
}
// TestBindCodec Bind 编解码。
func TestBindCodec(t *testing.T) {
b := &Bind{Name: "sp001", Password: "pw123"}
name, pw, err := ParseBind(b.Marshal())
if err != nil || name != "sp001" || pw != "pw123" {
t.Fatalf("bind: %q/%q err=%v", name, pw, err)
}
if _, _, err := ParseBind([]byte{1}); err == nil {
t.Fatal("短包应拒绝")
}
}
// TestSubmitCodec Submit 编码 → 解析(关键偏移断言)。
func TestSubmitCodec(t *testing.T) {
req := &SubmitReq{
SPNumber: "1065512345", ChargeNum: "", UserNumbers: []string{"13100002222"},
CorpID: "12345", ServiceType: "BIS", FeeType: 1, FeeValue: "10",
Content: []byte("hello sgip"), ReportFlag: 1,
}
body := req.Marshal()
sp, user, corp, content, rf, err := ParseSubmit(body)
if err != nil {
t.Fatal(err)
}
if sp != "1065512345" || user != "13100002222" || corp != "12345" || rf != 1 {
t.Fatalf("字段: sp=%s user=%s corp=%s rf=%d", sp, user, corp, rf)
}
if string(content) != "hello sgip" {
t.Fatalf("content = %q", content)
}
}
// TestReportCodec Report 往返。
func TestReportCodec(t *testing.T) {
rep := &Report{SubmitSequence: Sequence{NodeID: 9, DateTime: 904120000, Seq: 3},
ReportType: 1, UserNumber: "13100002222", State: StateDelivered, ErrorCode: 0}
got, err := ParseReport(MarshalReport(rep))
if err != nil {
t.Fatal(err)
}
if got.SubmitSequence != rep.SubmitSequence || got.UserNumber != "13100002222" ||
got.State != StateDelivered || got.ReportType != 1 {
t.Fatalf("report: %+v", got)
}
if _, err := ParseReport(make([]byte, 10)); err == nil {
t.Fatal("短包应拒绝")
}
}
// fakeSGIP 模拟 SGIP 网关。
type fakeSGIP struct {
ln net.Listener
namePw [2]string // 合法账号密码
mu sync.Mutex
conns map[net.Conn]struct{}
binds atomic.Int32
submits atomic.Int32
repAcks atomic.Int32
}
func newFakeSGIP(t *testing.T, name, pw string) *fakeSGIP {
t.Helper()
ln, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
g := &fakeSGIP{ln: ln, namePw: [2]string{name, pw}, conns: map[net.Conn]struct{}{}}
go g.serve()
t.Cleanup(func() { _ = ln.Close() })
return g
}
func (g *fakeSGIP) serve() {
for {
conn, err := g.ln.Accept()
if err != nil {
return
}
go g.handle(conn)
}
}
func (g *fakeSGIP) 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 CmdBind:
name, pw, err := ParseBind(body)
result := uint8(0)
if err != nil || name != g.namePw[0] || pw != g.namePw[1] {
result = 1
}
_ = WritePacket(conn, &Header{CommandID: CmdBindResp, Sequence: h.Sequence}, MakeResultBody(result))
if result == 0 {
g.binds.Add(1)
}
case CmdSubmit:
g.submits.Add(1)
_ = WritePacket(conn, &Header{CommandID: CmdSubmitResp, Sequence: h.Sequence}, MakeResultBody(0))
case CmdReportResp:
g.repAcks.Add(1)
case CmdUnbind:
_ = WritePacket(conn, &Header{CommandID: CmdUnbindResp, Sequence: h.Sequence}, MakeResultBody(0))
return
}
}
}
// pushReport 向全部活跃连接推一条状态报告。
func (g *fakeSGIP) pushReport(rep *Report) {
body := MarshalReport(rep)
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: CmdReport, Sequence: Sequence{NodeID: 1, DateTime: 904120000, Seq: 88}}, body)
}
}
// TestSGIP_Client 验收:bind/submit 打通模拟端 + Report 解析与自动应答。
func TestSGIP_Client(t *testing.T) {
g := newFakeSGIP(t, "sp001", "pw123")
// Day42(P1④):Timeout 2s→5s——全量并发时 fake server accept/响应受资源争用,
// 2s 偶发 bind 超时;5s 只影响失败路径耗时,不影响正常路径速度。
c := NewClient(Config{Addr: g.ln.Addr().String(), Name: "sp001", Password: "pw123", NodeID: 9, Timeout: 5 * time.Second})
if err := c.Connect(context.Background()); err != nil {
t.Fatalf("bind: %v", err)
}
defer func() { _ = c.Close() }()
if g.binds.Load() != 1 {
t.Fatal("网关未见成功 bind")
}
// 错密码拒绝
bad := NewClient(Config{Addr: g.ln.Addr().String(), Name: "sp001", Password: "wrong", NodeID: 9, Timeout: time.Second})
if err := bad.Connect(context.Background()); err == nil {
t.Fatal("错密码应被拒")
}
// Submit → Result 0
req := &SubmitReq{SPNumber: "1065512345", UserNumbers: []string{"13100002222"},
CorpID: "12345", ServiceType: "BIS", Content: []byte("x"), ReportFlag: 1}
if result, err := c.Submit(req); err != nil || result != 0 {
t.Fatalf("submit: result=%d err=%v", result, err)
}
if g.submits.Load() != 1 {
t.Fatal("网关未见 submit")
}
// Report 下发 → OnReport 解析 + 自动回 ReportResp
got := make(chan *Report, 1)
c.OnReport = func(r *Report) { got <- r }
g.pushReport(&Report{SubmitSequence: Sequence{NodeID: 9, DateTime: 904120000, Seq: 3},
ReportType: 1, UserNumber: "13100002222", State: StateDelivered})
select {
case r := <-got:
if r.UserNumber != "13100002222" || r.State != StateDelivered || r.SubmitSequence.Seq != 3 {
t.Fatalf("report 解析: %+v", r)
}
case <-time.After(2 * time.Second):
t.Fatal("未收到 report")
}
deadline := time.Now().Add(2 * time.Second)
for time.Now().Before(deadline) && g.repAcks.Load() < 1 {
time.Sleep(20 * time.Millisecond)
}
if g.repAcks.Load() < 1 {
t.Fatal("客户端未自动回 report_resp")
}
}