MiFaZhan
377 lines
15 KiB
Go
377 lines
15 KiB
Go
package upstreamapi
|
||
|
||
import (
|
||
"context"
|
||
"crypto/sha256"
|
||
"database/sql"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"errors"
|
||
"strings"
|
||
"sync"
|
||
"testing"
|
||
|
||
"github.com/gogf/gf/v2/container/gvar"
|
||
"github.com/gogf/gf/v2/database/gdb"
|
||
"git.5iot.com/iotlcm-public/iotlcm-upstream-chan/internal/model"
|
||
)
|
||
|
||
type memoryApnOperationStore struct {
|
||
mu sync.Mutex
|
||
rows map[string][2]string
|
||
failSave bool
|
||
}
|
||
|
||
func (s *memoryApnOperationStore) Claim(_ context.Context, id, ch, hash string) (bool, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
k := id + ch
|
||
if _, ok := s.rows[k]; ok {
|
||
return false, nil
|
||
}
|
||
s.rows[k] = [2]string{hash, ""}
|
||
return true, nil
|
||
}
|
||
func (s *memoryApnOperationStore) Load(_ context.Context, id, ch string) (string, string, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
r := s.rows[id+ch]
|
||
return r[0], r[1], nil
|
||
}
|
||
func (s *memoryApnOperationStore) Save(ctx context.Context, id, ch, hash, body string) error {
|
||
if err := ctx.Err(); err != nil {
|
||
return err
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
if s.failSave {
|
||
return errors.New("模拟磁盘失败")
|
||
}
|
||
r, exists := s.rows[id+ch]
|
||
if !exists || r[0] != hash {
|
||
return errors.New("意图不存在或摘要不符")
|
||
}
|
||
merged, err := mergeApnOperationJSON(r[1], body)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
r[1] = merged
|
||
s.rows[id+ch] = r
|
||
return nil
|
||
}
|
||
func operationTestInput() *model.SimCardOperateChangeApnInput {
|
||
return &model.SimCardOperateChangeApnInput{SimKeys: []*model.SimKey{{ICCID: "test", ChanKey: "channel"}}, ReqData: model.SimCardOperateChangeApnInputItem{OperationID: "stable-operation", SubmitOnly: true, OperType: "1"}}
|
||
}
|
||
func acceptedOperation(input *model.SimCardOperateChangeApnInput) model.SimCardOperateChangeApnOutput {
|
||
return model.SimCardOperateChangeApnOutput{&model.SimBaseRes[model.SimCardOperateChangeApnItem]{SimKey: input.SimKeys[0], ResData: model.SimCardOperateChangeApnItem{OrderNum: "saved-job", Pending: true}}}
|
||
}
|
||
|
||
func TestApnCapabilityExistingJobNeedsNoIntentDatabase(t *testing.T) {
|
||
input := operationTestInput()
|
||
input.ReqData.SubmitOnly = false
|
||
input.ReqData.QueryJobID = "existing-job"
|
||
// 此包未配置数据库：已有 jobId 的只读协议探测应仍然返回能力。
|
||
output, err := (&sUpstreamAPI{}).QuerySimApnCapability(context.Background(), input)
|
||
if err != nil || len(output) != 1 || output[0].ResData.ProtocolVersion != 1 || *output[0].SimKey != *input.SimKeys[0] {
|
||
t.Fatalf("已有任务的只读协议探测依赖了提交意图表: output=%+v err=%v", output, err)
|
||
}
|
||
input.SimKeys = []*model.SimKey{nil}
|
||
if _, err := (&sUpstreamAPI{}).QuerySimApnCapability(context.Background(), input); err == nil {
|
||
t.Fatal("已有jobId也必须校验冻结卡标识")
|
||
}
|
||
}
|
||
|
||
func TestApnOperationResponseLossAndRestartRecovery(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
calls := 0
|
||
submit := func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
calls++
|
||
return acceptedOperation(input), nil
|
||
}
|
||
if _, err := durableApnOperation(context.Background(), store, "channel", input, submit); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// 丢弃首次响应后，另一次调用只读受理映射，不访问运营商。
|
||
input.ReqData.RecoverOnly = true
|
||
recovered, err := durableApnOperation(context.Background(), store, "channel", input, submit)
|
||
if err != nil || calls != 1 || recovered[0].ResData.OrderNum != "saved-job" {
|
||
t.Fatalf("恢复失败 calls=%d result=%+v err=%v", calls, recovered, err)
|
||
}
|
||
input.ReqData.RecoverOnly = false
|
||
if _, err = durableApnOperation(context.Background(), store, "channel", input, submit); err != nil || calls != 1 {
|
||
t.Fatalf("重复投递重新办理 calls=%d err=%v", calls, err)
|
||
}
|
||
input.ReqData.OperType = "0"
|
||
if _, err = durableApnOperation(context.Background(), store, "channel", input, submit); err == nil {
|
||
t.Fatal("相同ID不得绑定不同请求")
|
||
}
|
||
}
|
||
|
||
func TestApnOperationConcurrentSubmitOnlyCallsCarrierOnce(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
started, release, done := make(chan struct{}), make(chan struct{}), make(chan error, 1)
|
||
go func() {
|
||
_, err := durableApnOperation(context.Background(), store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
close(started)
|
||
<-release
|
||
return acceptedOperation(input), nil
|
||
})
|
||
done <- err
|
||
}()
|
||
<-started
|
||
duplicate, err := durableApnOperation(context.Background(), store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
t.Error("并发重复operationId不得重新办理")
|
||
return nil, nil
|
||
})
|
||
close(release)
|
||
if err != nil || len(duplicate) != 1 || !duplicate[0].ResData.Uncertain {
|
||
t.Fatalf("并发处理中应标待核对: %v %+v", err, duplicate)
|
||
}
|
||
if err := <-done; err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationRecoveryRejectsDifferentPayload(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
_, err := durableApnOperation(context.Background(), store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
return acceptedOperation(input), nil
|
||
})
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
input.ReqData.RecoverOnly = true
|
||
input.ReqData.OperType = "0"
|
||
if _, err = durableApnOperation(context.Background(), store, "channel", input, nil); err == nil {
|
||
t.Fatal("恢复请求不得读取其他操作的受理映射")
|
||
}
|
||
}
|
||
|
||
func TestApnOperationIntentWithoutResponseNeverResubmits(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
payload, _ := json.Marshal(input)
|
||
digest := sha256.Sum256(payload)
|
||
_, _ = store.Claim(context.Background(), input.ReqData.OperationID, "channel", hex.EncodeToString(digest[:]))
|
||
input.ReqData.RecoverOnly = true
|
||
calls := 0
|
||
output, err := durableApnOperation(context.Background(), store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) { calls++; return nil, nil })
|
||
if err != nil || calls != 0 || !output[0].ResData.Uncertain {
|
||
t.Fatalf("未确认意图被重新提交：calls=%d err=%v", calls, err)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationPersistenceFailureNeverResubmits(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}, failSave: true}
|
||
input := operationTestInput()
|
||
calls := 0
|
||
submit := func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
calls++
|
||
return acceptedOperation(input), nil
|
||
}
|
||
if _, err := durableApnOperation(context.Background(), store, "channel", input, submit); err == nil {
|
||
t.Fatal("持久化失败不得返回已可靠保存")
|
||
}
|
||
store.failSave = false
|
||
input.ReqData.RecoverOnly = true
|
||
output, err := durableApnOperation(context.Background(), store, "channel", input, submit)
|
||
if err != nil || calls != 1 || !output[0].ResData.Uncertain {
|
||
t.Fatalf("受理映射失败后不得重复办理：calls=%d err=%v", calls, err)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationClientCancellationDoesNotLoseJob(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
ctx, cancel := context.WithCancel(context.Background())
|
||
output, err := durableApnOperation(ctx, store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
cancel()
|
||
return acceptedOperation(input), nil
|
||
})
|
||
if err != nil || output[0].ResData.OrderNum != "saved-job" {
|
||
t.Fatalf("客户端取消导致jobId丢失：%v", err)
|
||
}
|
||
_, saved, _ := store.Load(context.Background(), input.ReqData.OperationID, "channel")
|
||
if saved == "" {
|
||
t.Fatal("jobId未落库")
|
||
}
|
||
}
|
||
|
||
type affectedApnTestDB struct {
|
||
gdb.DB
|
||
tx gdb.TX
|
||
}
|
||
|
||
func (d affectedApnTestDB) Transaction(ctx context.Context, f func(context.Context, gdb.TX) error) error {
|
||
return f(ctx, d.tx)
|
||
}
|
||
|
||
type affectedApnTestTX struct {
|
||
gdb.TX
|
||
hash string
|
||
rows int64
|
||
}
|
||
|
||
func (tx affectedApnTestTX) GetOne(string, ...any) (gdb.Record, error) {
|
||
return gdb.Record{"request_hash": gvar.New(tx.hash), "response_json": gvar.New("")}, nil
|
||
}
|
||
func (tx affectedApnTestTX) Exec(string, ...any) (sql.Result, error) {
|
||
return affectedApnTestResult(tx.rows), nil
|
||
}
|
||
|
||
type affectedApnTestResult int64
|
||
|
||
func (r affectedApnTestResult) LastInsertId() (int64, error) { return 0, nil }
|
||
func (r affectedApnTestResult) RowsAffected() (int64, error) { return int64(r), nil }
|
||
func TestApnOperationSQLSaveRejectsAffectedZeroAndHashMismatch(t *testing.T) {
|
||
hash := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
||
for _, tc := range []struct {
|
||
rows int64
|
||
hash string
|
||
wantError bool
|
||
}{{0, hash, true}, {1, "wrong-hash", true}, {1, hash, false}} {
|
||
store := sqlApnOperationStore{db: affectedApnTestDB{tx: affectedApnTestTX{hash: tc.hash, rows: tc.rows}}}
|
||
err := store.Save(context.Background(), "test-operation", "test-channel", hash, "[]")
|
||
if (err != nil) != tc.wantError {
|
||
t.Fatalf("rows=%d hash=%s err=%v", tc.rows, tc.hash, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
type retryCheckpointApnStore struct {
|
||
memoryApnOperationStore
|
||
failed bool
|
||
}
|
||
|
||
func (s *retryCheckpointApnStore) Save(ctx context.Context, id, channel, hash, body string) error {
|
||
if !s.failed {
|
||
s.failed = true
|
||
return errors.New("模拟首次checkpoint磁盘故障")
|
||
}
|
||
return s.memoryApnOperationStore.Save(ctx, id, channel, hash, body)
|
||
}
|
||
func TestApnOperationFailedCheckpointRetriesKnownJobNotUnknown(t *testing.T) {
|
||
store := &retryCheckpointApnStore{memoryApnOperationStore: memoryApnOperationStore{rows: map[string][2]string{}}}
|
||
input := operationTestInput()
|
||
output, err := durableApnOperation(context.Background(), store, "channel", input, func(ctx context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
checkpoint := ctx.Value(model.ApnOperationCheckpointKey{}).(func(model.SimCardOperateChangeApnOutput) error)
|
||
if err := checkpoint(acceptedOperation(input)); err == nil {
|
||
t.Fatal("应模拟checkpoint失败")
|
||
}
|
||
return nil, errors.New("受理后响应断开")
|
||
})
|
||
if err != nil || output[0].ResData.OrderNum != "saved-job" || !output[0].ResData.Pending {
|
||
t.Fatalf("保存重试丢掉已取得jobId：%+v %v", output, err)
|
||
}
|
||
_, saved, _ := store.Load(context.Background(), input.ReqData.OperationID, "channel")
|
||
if !strings.Contains(saved, "saved-job") {
|
||
t.Fatalf("重试未可靠保存jobId：%s", saved)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationCheckpointCannotBeErased(t *testing.T) {
|
||
for _, failed := range []bool{false, true} {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
output, err := durableApnOperation(context.Background(), store, "channel", input, func(ctx context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
checkpoint := ctx.Value(model.ApnOperationCheckpointKey{}).(func(model.SimCardOperateChangeApnOutput) error)
|
||
if err := checkpoint(acceptedOperation(input)); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if failed {
|
||
return nil, errors.New("模拟受理后请求失败")
|
||
}
|
||
return nil, nil
|
||
})
|
||
if err != nil || len(output) != 1 || output[0].ResData.OrderNum != "saved-job" || !output[0].ResData.Pending {
|
||
t.Fatalf("后续空响应或错误抹掉jobId：%+v %v", output, err)
|
||
}
|
||
input.ReqData.RecoverOnly = true
|
||
output, err = durableApnOperation(context.Background(), store, "channel", input, nil)
|
||
if err != nil || output[0].ResData.OrderNum != "saved-job" {
|
||
t.Fatalf("持久化映射已被回退：%+v %v", output, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestApnOperationMergePreservesTerminalAndCardAssociation(t *testing.T) {
|
||
input := operationTestInput()
|
||
terminal := acceptedOperation(input)
|
||
terminal[0].ResData.Pending = false
|
||
terminal[0].Message = "明确成功"
|
||
body, _ := json.Marshal(terminal)
|
||
unknown, _ := json.Marshal(unknownApnOperation(input, "后来的未知结果"))
|
||
merged, err := mergeApnOperationJSON(string(body), string(unknown))
|
||
if err != nil || merged != string(body) {
|
||
t.Fatalf("逐卡终态被未知覆盖：%s %v", merged, err)
|
||
}
|
||
second := *input.SimKeys[0]
|
||
second.ICCID = "second"
|
||
other, _ := json.Marshal(model.SimCardOperateChangeApnOutput{&model.SimBaseRes[model.SimCardOperateChangeApnItem]{SimKey: &second, ResData: model.SimCardOperateChangeApnItem{Pending: true, OrderNum: "second-job"}}})
|
||
merged, err = mergeApnOperationJSON(merged, string(other))
|
||
var results model.SimCardOperateChangeApnOutput
|
||
_ = json.Unmarshal([]byte(merged), &results)
|
||
if err != nil || len(results) != 2 || results[0].SimKey.ICCID != "test" || results[1].SimKey.ICCID != "second" {
|
||
t.Fatalf("逐卡合并丢失卡关联：%s %v", merged, err)
|
||
}
|
||
}
|
||
|
||
type failingClaimApnStore struct{ memoryApnOperationStore }
|
||
|
||
func (s *failingClaimApnStore) Claim(context.Context, string, string, string) (bool, error) {
|
||
return false, errors.New("模拟INSERT失败")
|
||
}
|
||
func TestApnOperationClaimFailureNeverCallsCarrier(t *testing.T) {
|
||
called := false
|
||
_, err := durableApnOperation(context.Background(), &failingClaimApnStore{}, "channel", operationTestInput(), func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
called = true
|
||
return nil, nil
|
||
})
|
||
if err == nil || called {
|
||
t.Fatalf("意图INSERT失败仍调用运营商：called=%v err=%v", called, err)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationExplicitFailureWinsPendingAndUnknown(t *testing.T) {
|
||
input := operationTestInput()
|
||
pending, _ := json.Marshal(acceptedOperation(input))
|
||
failure := model.SimCardOperateChangeApnOutput{&model.SimBaseRes[model.SimCardOperateChangeApnItem]{SimKey: input.SimKeys[0], Code: 9999, Message: "运营商明确拒绝"}}
|
||
failed, _ := json.Marshal(failure)
|
||
merged, err := mergeApnOperationJSON(string(pending), string(failed))
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
unknown, _ := json.Marshal(unknownApnOperation(input, "后到的通信错误"))
|
||
merged, err = mergeApnOperationJSON(merged, string(unknown))
|
||
var output model.SimCardOperateChangeApnOutput
|
||
if err != nil || json.Unmarshal([]byte(merged), &output) != nil || len(output) != 1 || output[0].Code != 9999 || output[0].Message != "运营商明确拒绝" || output[0].ResData.Pending || output[0].ResData.Uncertain || output[0].ResData.OrderNum != "saved-job" {
|
||
t.Fatalf("明确失败被pending或未知覆盖：%s %v", merged, err)
|
||
}
|
||
}
|
||
|
||
func TestApnOperationCheckpointSurvivesCrashBeforeReturn(t *testing.T) {
|
||
store := &memoryApnOperationStore{rows: map[string][2]string{}}
|
||
input := operationTestInput()
|
||
func() {
|
||
defer func() { _ = recover() }()
|
||
_, _ = durableApnOperation(context.Background(), store, "channel", input, func(ctx context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
checkpoint := ctx.Value(model.ApnOperationCheckpointKey{}).(func(model.SimCardOperateChangeApnOutput) error)
|
||
if err := checkpoint(acceptedOperation(input)); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
panic("模拟拿jobId后进程中断")
|
||
})
|
||
}()
|
||
input.ReqData.RecoverOnly = true
|
||
output, err := durableApnOperation(context.Background(), store, "channel", input, func(context.Context) (model.SimCardOperateChangeApnOutput, error) {
|
||
t.Fatal("恢复不得重新办理")
|
||
return nil, nil
|
||
})
|
||
if err != nil || output[0].ResData.OrderNum != "saved-job" {
|
||
t.Fatalf("checkpoint未恢复：%+v %v", output, err)
|
||
}
|
||
}
|