MiFaZhan
549 lines
20 KiB
Go
549 lines
20 KiB
Go
package imei
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"testing"
|
||
|
||
zsetconsumer "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consumer/zset"
|
||
"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model"
|
||
queue "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/queue/zset"
|
||
imeirepo "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/repository/imei"
|
||
)
|
||
|
||
// fakeClient returns a canned response or error and records the call count.
|
||
type fakeClient struct {
|
||
output []model.SimBaseRes[model.SimImeiItem]
|
||
err error
|
||
calls int
|
||
}
|
||
|
||
func (f *fakeClient) QuerySimImei(context.Context, *model.SimImeiInput) ([]model.SimBaseRes[model.SimImeiItem], error) {
|
||
f.calls++
|
||
return f.output, f.err
|
||
}
|
||
|
||
// fakeRepo captures what the handler asked to persist.
|
||
type fakeRepo struct {
|
||
results []imeirepo.Result
|
||
calls int
|
||
err error
|
||
}
|
||
|
||
func (f *fakeRepo) ApplyBatch(_ context.Context, results []imeirepo.Result) error {
|
||
f.calls++
|
||
f.results = append(f.results, results...)
|
||
return f.err
|
||
}
|
||
|
||
func task(tempKey string) queue.Task {
|
||
return queue.Task{
|
||
TaskID: "run:imei_full_sync:1",
|
||
RunID: "run",
|
||
ChanKey: "173",
|
||
TempKey: tempKey,
|
||
CardID: 1,
|
||
ICCID: "898604F4152391115474",
|
||
MSISDN: "1064000000001",
|
||
IMSI: "460000000000001",
|
||
Operator: 1,
|
||
}
|
||
}
|
||
|
||
func item(code int, errCode, imei string) model.SimBaseRes[model.SimImeiItem] {
|
||
return model.SimBaseRes[model.SimImeiItem]{
|
||
Code: code,
|
||
ErrCode: errCode,
|
||
SimKey: &model.SimKey{ChanKey: "173", ICCID: "898604F4152391115474"},
|
||
ResData: model.SimImeiItem{Imei: imei},
|
||
}
|
||
}
|
||
|
||
func newTestHandler(t *testing.T, client ImeiClient, repo ImeiRepository, retries ...int) *Handler {
|
||
t.Helper()
|
||
h, err := NewHandler(client, repo, retries...)
|
||
if err != nil {
|
||
t.Fatalf("NewHandler: %v", err)
|
||
}
|
||
return h
|
||
}
|
||
|
||
// TestQuerySuccessWithValue 覆盖 §7 的正常命中路径。
|
||
func TestQuerySuccessWithValue(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(0, "", "865466070817587")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if !result.Success {
|
||
t.Fatalf("应成功: %+v", result)
|
||
}
|
||
if !result.ImeiSynced {
|
||
t.Fatal("ImeiSynced 应为 true")
|
||
}
|
||
if result.Imei != "865466070817587" {
|
||
t.Fatalf("imei = %q", result.Imei)
|
||
}
|
||
if result.Retryable {
|
||
t.Fatal("成功不应可重试")
|
||
}
|
||
}
|
||
|
||
// TestQueryEmptyValueIsTerminalAndSynced 覆盖 §7 T5/T6：上游成功但无值。
|
||
// 这是最关键的语义——必须记录覆盖（ImeiSynced）但不得视为失败重试。
|
||
func TestQueryEmptyValueIsTerminalAndSynced(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(0, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.Success {
|
||
t.Fatal("空值不应标记为 Success")
|
||
}
|
||
if result.Retryable {
|
||
t.Fatal("空值是终态，不应重试")
|
||
}
|
||
if !result.ImeiSynced {
|
||
t.Fatal("空值仍应记录为已同步（心跳）")
|
||
}
|
||
if !result.Covered {
|
||
t.Fatal("空值与 14000 同族，不应进失败池")
|
||
}
|
||
if result.ErrorClass != dataInvalidClass {
|
||
t.Fatalf("errorClass = %q, want %q", result.ErrorClass, dataInvalidClass)
|
||
}
|
||
if result.Imei != "" {
|
||
t.Fatalf("imei 应为空: %q", result.Imei)
|
||
}
|
||
}
|
||
|
||
// TestQueryNoRecordIsCoveredNotFailed 覆盖生产实测的主路径（2026-10-20 chan
|
||
// 220/250/251 的 4900 条“失败”全部是 code=14000）。运营商持有卡但没有 IMEI
|
||
// 记录，这是终态正常结果：记录覆盖、绝不重试、不进失败池。
|
||
func TestQueryNoRecordIsCoveredNotFailed(t *testing.T) {
|
||
for _, tempKey := range []string{"sim_yd_v5", "sim_dx_v1"} {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{
|
||
item(chanNoRecordCode, "", ""),
|
||
}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
// 14000 的 message 是运营商原文，处理逻辑不得依赖它。
|
||
client.output[0].Message = "系统无记录，请检查输入参数是否正确"
|
||
|
||
result := handler.Query(context.Background(), task(tempKey))
|
||
if result.Success {
|
||
t.Fatalf("%s: 无记录不得标记为 Success", tempKey)
|
||
}
|
||
if result.Retryable {
|
||
t.Fatalf("%s: 无记录是终态，不应重试", tempKey)
|
||
}
|
||
if !result.ImeiSynced {
|
||
t.Fatalf("%s: 无记录仍应记录覆盖（心跳）", tempKey)
|
||
}
|
||
if !result.Covered {
|
||
t.Fatalf("%s: 无记录不得计入失败池", tempKey)
|
||
}
|
||
if result.ErrorClass != noRecordClass {
|
||
t.Fatalf("%s: errorClass = %q, want %q", tempKey, result.ErrorClass, noRecordClass)
|
||
}
|
||
if result.Imei != "" {
|
||
t.Fatalf("%s: 无记录不得携带值: %q", tempKey, result.Imei)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryNoRecordBeatsMobileBusyRange 14000 不在 13000-13007 内，
|
||
// 但仍要求移动模板走同一条“无记录”分类——不能被 busy 分支或业务错误吞掉。
|
||
func TestQueryNoRecordDoesNotRetryOnMobileTemplate(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(chanNoRecordCode, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.Retryable || result.ErrorClass == mobileBusyClass || result.ErrorClass == businessClass {
|
||
t.Fatalf("14000 应为 no_record 终态: %+v", result)
|
||
}
|
||
}
|
||
|
||
// TestQueryUnsupportedTemplateSkipsUpstream 覆盖 §7 T3：
|
||
// 不支持的模板必须在不发请求的前提下直接终态，避免失败池爆炸。
|
||
func TestQueryUnsupportedTemplateSkipsUpstream(t *testing.T) {
|
||
for _, tempKey := range []string{"sim_mingqian_v3", "sim_daihe_v1", "sim_qianxun_v3"} {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(0, "", "865466070817587")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task(tempKey))
|
||
if result.Retryable {
|
||
t.Fatalf("%s: 不支持应为终态，不应重试", tempKey)
|
||
}
|
||
if result.ErrorClass != unsupportedClass {
|
||
t.Fatalf("%s: errorClass = %q, want %q", tempKey, result.ErrorClass, unsupportedClass)
|
||
}
|
||
if client.calls != 0 {
|
||
t.Fatalf("%s: 不支持模板不应发起上游请求，实际调用 %d 次", tempKey, client.calls)
|
||
}
|
||
if result.ImeiSynced {
|
||
t.Fatalf("%s: 未查询不应记录覆盖", tempKey)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryUnsupportedTemplatesAreCaseInsensitive 模板键大小写不应影响判定。
|
||
func TestQueryUnsupportedTemplatesAreCaseInsensitive(t *testing.T) {
|
||
client := &fakeClient{}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
result := handler.Query(context.Background(), task("SIM_MingQian_V3"))
|
||
if result.ErrorClass != unsupportedClass || client.calls != 0 {
|
||
t.Fatalf("大小写变体未被识别: %+v, calls=%d", result, client.calls)
|
||
}
|
||
}
|
||
|
||
// TestQuerySharedTokenTemplatesAreSupported 回归保护：
|
||
// sim_onelink_* 走 shared_token 模型 → sSimYD（支持 IMEI），
|
||
// 不得被误列入不支持白名单（这是 2026-10-12 生产基线纠正过的判断）。
|
||
func TestQuerySharedTokenTemplatesAreSupported(t *testing.T) {
|
||
for _, tempKey := range []string{
|
||
"sim_onelink_tengyu_v1",
|
||
"sim_onelink_daihe_v1",
|
||
"sim_onelink_qianxun_v1",
|
||
"sim_onelink_kedang_v1",
|
||
"sim_onelink_daliuliang_v1",
|
||
"sim_onelink_mengwang_v1",
|
||
} {
|
||
if isImeiUnsupportedTemplate(tempKey) {
|
||
t.Fatalf("%s 走 sSimYD 支持 IMEI，不应在不支持白名单", tempKey)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryMobileBusyIsRetryable 覆盖 §7 T4：移动 13000 区间跨轮重试。
|
||
func TestQueryMobileBusyIsRetryable(t *testing.T) {
|
||
for _, code := range []int{13000, 13003, 13007} {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(code, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.ErrorClass != mobileBusyClass || !result.Retryable {
|
||
t.Fatalf("code %d: errorClass=%q retryable=%v, want %q/true", code, result.ErrorClass, result.Retryable, mobileBusyClass)
|
||
}
|
||
if result.Covered {
|
||
t.Fatalf("code %d: 系统忙必须计入失败", code)
|
||
}
|
||
if result.ImeiSynced {
|
||
t.Fatalf("code %d: 系统忙不应记录覆盖", code)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryMobileBusyOnlyForMobileTemplates 13000 只对移动族判定为 busy。
|
||
func TestQueryMobileBusyOnlyForMobileTemplates(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(13000, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
// 电信模板收到 13000 不是移动系统忙语义，应按普通业务错误处理
|
||
result := handler.Query(context.Background(), task("sim_dx_v1"))
|
||
if result.ErrorClass == mobileBusyClass {
|
||
t.Fatalf("非移动模板不应判定为 mobile_busy: %+v", result)
|
||
}
|
||
if result.Retryable {
|
||
t.Fatalf("非移动模板的 13000 应为终态: %+v", result)
|
||
}
|
||
}
|
||
|
||
// TestQueryTelecomRetryableCodeIsNotTreatedAsRetryableForImei 回归保护：
|
||
// S00004 是电信「渠道限流」业务码，属于状态/流量链路的可重试语义；
|
||
// IMEI 链路没有对应的限流处理，必须按普通业务错误终态处理，
|
||
// 否则会无限重试同一张卡。
|
||
func TestQueryTelecomRetryableCodeIsNotTreatedAsRetryableForImei(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(1, "S00004", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_dx_v1"))
|
||
if result.Retryable {
|
||
t.Fatalf("IMEI 链路不应把 S00004 当作可重试: %+v", result)
|
||
}
|
||
if result.ErrorClass != businessClass {
|
||
t.Fatalf("errorClass = %q, want %q", result.ErrorClass, businessClass)
|
||
}
|
||
}
|
||
|
||
// TestQueryGatewayAndTokenErrorsAreRetryable 覆盖 §7 T8。
|
||
func TestQueryGatewayAndTokenErrorsAreRetryable(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
code int
|
||
errCode string
|
||
wantClass string
|
||
}{
|
||
{"网关内部错误", 9999, "", gatewayClass},
|
||
{"token 过期", tokenExpiredCode, "", tokenExpiredClass},
|
||
}
|
||
for _, tc := range cases {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(tc.code, tc.errCode, "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.ErrorClass != tc.wantClass || !result.Retryable {
|
||
t.Fatalf("%s: errorClass=%q retryable=%v, want %q/true", tc.name, result.ErrorClass, result.Retryable, tc.wantClass)
|
||
}
|
||
if result.Covered {
|
||
t.Fatalf("%s: 可重试错误必须计入失败", tc.name)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryBusinessErrorIsTerminal 其他业务码为终态，避免无意义重试。
|
||
func TestQueryBusinessErrorIsTerminal(t *testing.T) {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(11011, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.Retryable {
|
||
t.Fatal("11011 码号信息错误是确定性终态，不应重试")
|
||
}
|
||
if result.ErrorClass != businessClass {
|
||
t.Fatalf("errorClass = %q, want %q", result.ErrorClass, businessClass)
|
||
}
|
||
if result.Covered {
|
||
t.Fatal("11011 是真失败，必须进失败池")
|
||
}
|
||
if result.ImeiSynced {
|
||
t.Fatal("11011 未拿到运营商结果，不应记录覆盖")
|
||
}
|
||
}
|
||
|
||
// TestQueryNetworkErrorIsRetryable 网络错误跨轮重试，且受 networkRetries 控制。
|
||
func TestQueryNetworkErrorIsRetryable(t *testing.T) {
|
||
client := &fakeClient{err: errors.New("connection refused")}
|
||
handler := newTestHandler(t, client, &fakeRepo{}, 2)
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.ErrorClass != networkClass || !result.Retryable {
|
||
t.Fatalf("errorClass=%q retryable=%v, want network/true", result.ErrorClass, result.Retryable)
|
||
}
|
||
// 1 次初始 + 2 次重试
|
||
if client.calls != 3 {
|
||
t.Fatalf("calls = %d, want 3（1 次初始 + 2 次重试）", client.calls)
|
||
}
|
||
}
|
||
|
||
// TestQueryEmptyResultSliceIsProtocolError 空切片是协议异常，应重试。
|
||
func TestQueryEmptyResultSliceIsProtocolError(t *testing.T) {
|
||
client := &fakeClient{output: nil}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.ErrorClass != protocolClass || !result.Retryable {
|
||
t.Fatalf("errorClass=%q retryable=%v, want protocol/true", result.ErrorClass, result.Retryable)
|
||
}
|
||
}
|
||
|
||
// TestQueryMismatchedIdentifierIsProtocolError 防止上游串卡。
|
||
func TestQueryMismatchedIdentifierIsProtocolError(t *testing.T) {
|
||
mismatched := item(0, "", "865466070817587")
|
||
mismatched.SimKey = &model.SimKey{ChanKey: "173", ICCID: "OTHER-CARD"}
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{mismatched}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_yd_v5"))
|
||
if result.ErrorClass != protocolClass || !result.Retryable {
|
||
t.Fatalf("串卡应判为协议错误: %+v", result)
|
||
}
|
||
if result.ImeiSynced {
|
||
t.Fatal("串卡不应记录覆盖")
|
||
}
|
||
}
|
||
|
||
// TestApplyWritesValueOnlyWhenChanged 覆盖 §7 T9/T10 与 §5.2 守卫：
|
||
// - 有值 → ValueChanged=true，带值写入
|
||
// - 空值 → ValueChanged=false，且 Imei 必须被清空（不得覆盖已有值）
|
||
// - 失败 → 完全不入库
|
||
func TestApplyWritesValueOnlyWhenChanged(t *testing.T) {
|
||
repo := &fakeRepo{}
|
||
handler := newTestHandler(t, &fakeClient{}, repo)
|
||
|
||
successTask := task("sim_yd_v5")
|
||
emptyTask := task("sim_yd_v5")
|
||
emptyTask.CardID = 2
|
||
failedTask := task("sim_yd_v5")
|
||
failedTask.CardID = 3
|
||
|
||
err := handler.Apply(context.Background(), []zsetconsumer.Result{
|
||
{Task: successTask, Success: true, ImeiSynced: true, Imei: "865466070817587"},
|
||
{Task: emptyTask, Success: false, ImeiSynced: true, ErrorClass: dataInvalidClass},
|
||
{Task: failedTask, Success: false, Retryable: true, ErrorClass: networkClass, ImeiSynced: false},
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("Apply: %v", err)
|
||
}
|
||
if len(repo.results) != 2 {
|
||
t.Fatalf("应只写入 2 条（成功的 + 心跳的），实际 %d 条: %+v", len(repo.results), repo.results)
|
||
}
|
||
|
||
// 第 1 条：值变更
|
||
first := repo.results[0]
|
||
if first.CardID != 1 || !first.ValueChanged || first.Imei != "865466070817587" {
|
||
t.Fatalf("第一条应为值变更: %+v", first)
|
||
}
|
||
// 第 2 条：心跳，值必须为空（防止覆盖）
|
||
second := repo.results[1]
|
||
if second.CardID != 2 || second.ValueChanged {
|
||
t.Fatalf("第二条应为心跳: %+v", second)
|
||
}
|
||
if second.Imei != "" {
|
||
t.Fatalf("心跳结果的 Imei 必须为空，否则会覆盖已有值: %q", second.Imei)
|
||
}
|
||
// 第 3 条：失败完全不入库
|
||
for _, r := range repo.results {
|
||
if r.CardID == 3 {
|
||
t.Fatal("失败结果不应入库")
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestApplyNeverWritesEmptyOverValue 是 §5.2 的直接回归测试：
|
||
// 即使上游大面积返回空值，写路径也不得产生任何带值的更新。
|
||
func TestApplyNeverWritesEmptyOverValue(t *testing.T) {
|
||
repo := &fakeRepo{}
|
||
handler := newTestHandler(t, &fakeClient{}, repo)
|
||
|
||
results := make([]zsetconsumer.Result, 0, 50)
|
||
for i := int64(1); i <= 50; i++ {
|
||
tk := task("sim_yd_v5")
|
||
tk.CardID = i
|
||
results = append(results, zsetconsumer.Result{
|
||
Task: tk, Success: false, ImeiSynced: true, ErrorClass: dataInvalidClass,
|
||
})
|
||
}
|
||
if err := handler.Apply(context.Background(), results); err != nil {
|
||
t.Fatalf("Apply: %v", err)
|
||
}
|
||
if len(repo.results) != 50 {
|
||
t.Fatalf("50 张卡都应记录心跳，实际 %d", len(repo.results))
|
||
}
|
||
for _, r := range repo.results {
|
||
if r.ValueChanged || r.Imei != "" {
|
||
t.Fatalf("空值结果不得携带值: %+v", r)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestApplyNoRecordWritesHeartbeatOnly 14000 只能写心跳，绝不能清掉已有 IMEI。
|
||
func TestApplyNoRecordWritesHeartbeatOnly(t *testing.T) {
|
||
repo := &fakeRepo{}
|
||
handler := newTestHandler(t, &fakeClient{}, repo)
|
||
|
||
noRecord := task("sim_yd_v5")
|
||
if err := handler.Apply(context.Background(), []zsetconsumer.Result{
|
||
{Task: noRecord, Success: false, ImeiSynced: true, Covered: true, ErrorClass: noRecordClass, Code: chanNoRecordCode},
|
||
}); err != nil {
|
||
t.Fatalf("Apply: %v", err)
|
||
}
|
||
if len(repo.results) != 1 {
|
||
t.Fatalf("无记录仍应写入 1 条心跳，实际 %d: %+v", len(repo.results), repo.results)
|
||
}
|
||
got := repo.results[0]
|
||
if !got.Synced || got.ValueChanged || got.Imei != "" {
|
||
t.Fatalf("无记录应只写心跳: %+v", got)
|
||
}
|
||
}
|
||
|
||
// TestShouldRetryNextRound 覆盖重试策略。
|
||
func TestShouldRetryNextRound(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
result zsetconsumer.Result
|
||
want bool
|
||
}{
|
||
{"成功不重试", zsetconsumer.Result{Success: true}, false},
|
||
{"可重试失败", zsetconsumer.Result{Success: false, Retryable: true}, true},
|
||
{"终态失败不重试", zsetconsumer.Result{Success: false, Retryable: false}, false},
|
||
{"无记录不重试", zsetconsumer.Result{Success: false, Covered: true, ErrorClass: noRecordClass}, false},
|
||
}
|
||
for _, tc := range cases {
|
||
if got := ShouldRetryNextRound(tc.result); got != tc.want {
|
||
t.Fatalf("%s: got %v, want %v", tc.name, got, tc.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryNoDeviceIsCoveredNotFailed 覆盖 2026-10-22 生产 run
|
||
// imei-20261022000000 的 12,865 条终态失败：全部是「卡上没有绑定设备，
|
||
// 所以没有 IMEI」，不是真失败。
|
||
//
|
||
// 证据（生产日志实采）：
|
||
// - 电信 5G CMP 11,240 条：result="-1"，message=查询失败，查询不到指定卡的设备信息
|
||
// （通道 142/111/187，template sim_dx_v1）
|
||
// - Tibiot 1,612 条：HTTP 500 + body status=500，message=查询不到信息（1,494）
|
||
// 或 系统无记录（118）
|
||
//
|
||
// 三者都是终态：记录覆盖（写心跳）、不重试、不进失败池。
|
||
func TestQueryNoDeviceIsCoveredNotFailed(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
tempKey string
|
||
code int
|
||
message string
|
||
}{
|
||
{"电信无绑定设备", "sim_dx_v1", chanNoDeviceInfoCode, "查询失败，查询不到指定卡的设备信息"},
|
||
{"Tibiot 查询不到信息", "sim_tibiot_v1", chanTibiotNoInfoCode, "查询不到信息"},
|
||
{"Tibiot 系统无记录", "sim_tibiot_v1", chanTibiotNoInfoCode, "系统无记录，请检查输入参数是否正确"},
|
||
}
|
||
for _, tc := range cases {
|
||
it := item(tc.code, "", "")
|
||
it.Message = tc.message
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{it}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task(tc.tempKey))
|
||
if result.Success {
|
||
t.Fatalf("%s: 无设备不得标记为 Success", tc.name)
|
||
}
|
||
if result.Retryable {
|
||
t.Fatalf("%s: 无设备是终态，不应重试", tc.name)
|
||
}
|
||
if !result.ImeiSynced {
|
||
t.Fatalf("%s: 无设备仍应记录覆盖（心跳）", tc.name)
|
||
}
|
||
if !result.Covered {
|
||
t.Fatalf("%s: 无设备不得计入失败池", tc.name)
|
||
}
|
||
if result.ErrorClass != noRecordClass {
|
||
t.Fatalf("%s: errorClass = %q, want %q", tc.name, result.ErrorClass, noRecordClass)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryTibiotNonNoInfo500StaysBusiness 锁住 500 的边界：Tibiot 也用 500
|
||
// 表达真实故障，只有「查询不到信息/系统无记录」的文案才是终态无记录。
|
||
// 不加这道闸门会把真故障当成功覆盖掉，那是比多算失败更严重的错误。
|
||
func TestQueryTibiotNonNoInfo500StaysBusiness(t *testing.T) {
|
||
for _, message := range []string{"系统繁忙，请稍后重试", "服务异常", "internal error", ""} {
|
||
it := item(chanTibiotNoInfoCode, "", "")
|
||
it.Message = message
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{it}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_tibiot_v1"))
|
||
if result.Covered {
|
||
t.Fatalf("message=%q: 非无记录文案的 500 不得计入覆盖", message)
|
||
}
|
||
if result.ImeiSynced {
|
||
t.Fatalf("message=%q: 非无记录文案的 500 不应记录覆盖", message)
|
||
}
|
||
if result.ErrorClass != businessClass {
|
||
t.Fatalf("message=%q: errorClass = %q, want %q", message, result.ErrorClass, businessClass)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestQueryNoDeviceCodeIgnoresMessage 14000 与 -1 语义明确，不得依赖运营商文案
|
||
// （文案随时可能改写），即使 message 为空也要判为无记录。
|
||
func TestQueryNoDeviceCodeIgnoresMessage(t *testing.T) {
|
||
for _, code := range []int{chanNoRecordCode, chanNoDeviceInfoCode} {
|
||
client := &fakeClient{output: []model.SimBaseRes[model.SimImeiItem]{item(code, "", "")}}
|
||
handler := newTestHandler(t, client, &fakeRepo{})
|
||
|
||
result := handler.Query(context.Background(), task("sim_dx_v1"))
|
||
if !result.Covered || result.ErrorClass != noRecordClass {
|
||
t.Fatalf("code=%d 空 message 仍应判 no_record: %+v", code, result)
|
||
}
|
||
}
|
||
}
|