218 lines
6.4 KiB
Go
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")
|
|
}
|
|
}
|