MiFaZhan
431 lines
16 KiB
Go
431 lines
16 KiB
Go
package iot
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.5iot.com/iotlcm-public/iotlcm-admin-svr/internal/model"
|
|
)
|
|
|
|
func TestSimCardBatchCondition(t *testing.T) {
|
|
condition, args, err := simCardBatchCondition(context.Background(), "\n iccid-1 \n\t\niccid-2 13800000000 460001234567890\n")
|
|
if err != nil {
|
|
t.Fatalf("parse batch input: %v", err)
|
|
}
|
|
if !strings.HasPrefix(condition, "((") || !strings.HasSuffix(condition, "))") {
|
|
t.Fatalf("batch conditions must be grouped: %s", condition)
|
|
}
|
|
if !strings.Contains(condition, "iccid IN (?) OR msisdn IN (?) OR imsi IN (?)") {
|
|
t.Fatalf("single values must be folded into IN lists: %s", condition)
|
|
}
|
|
if strings.Count(condition, "(iccid = ? OR msisdn = ? OR imsi = ?)") != 3 {
|
|
t.Fatalf("three-value row must require every value on the same card: %s", condition)
|
|
}
|
|
if strings.Contains(condition, " = ? AND msisdn = ? AND imsi = ?") {
|
|
t.Fatalf("field positions must not be assumed: %s", condition)
|
|
}
|
|
wantArgs := []interface{}{
|
|
"iccid-1", "iccid-1", "iccid-1",
|
|
"iccid-2", "iccid-2", "iccid-2",
|
|
"13800000000", "13800000000", "13800000000",
|
|
"460001234567890", "460001234567890", "460001234567890",
|
|
}
|
|
if len(args) != len(wantArgs) {
|
|
t.Fatalf("got %d args, want %d: %#v", len(args), len(wantArgs), args)
|
|
}
|
|
for i := range wantArgs {
|
|
if args[i] != wantArgs[i] {
|
|
t.Fatalf("arg %d = %#v, want %#v", i, args[i], wantArgs[i])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSimCardBatchConditionAcceptsAnyTwoValuesPerRow(t *testing.T) {
|
|
condition, args, err := simCardBatchCondition(context.Background(),
|
|
"89860000000000000001 13800000000\n13800000001 460001234567891\n")
|
|
if err != nil {
|
|
t.Fatalf("two values per row must be accepted: %v", err)
|
|
}
|
|
if strings.Count(condition, "(iccid = ? OR msisdn = ? OR imsi = ?)") != 4 {
|
|
t.Fatalf("each value must match any field, two rows expected four groups: %s", condition)
|
|
}
|
|
if len(args) != 12 {
|
|
t.Fatalf("got %d args, want 12: %#v", len(args), args)
|
|
}
|
|
if !strings.Contains(condition, " AND ") {
|
|
t.Fatalf("values of one row must be paired on the same card: %s", condition)
|
|
}
|
|
}
|
|
|
|
func TestSimCardBatchConditionRejectsEmptyAndInvalidInput(t *testing.T) {
|
|
for _, input := range []string{"", " \n\t ", "one two three four", "one two three four five"} {
|
|
if _, _, err := simCardBatchCondition(context.Background(), input); err == nil {
|
|
t.Errorf("expected input %q to be rejected", input)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSimCardBatchConditionLimitsNonEmptyRowsBeforeDeduplication(t *testing.T) {
|
|
input := strings.Repeat("same-number\n", simCardBatchMaxRows)
|
|
condition, args, err := simCardBatchCondition(context.Background(), input)
|
|
if err != nil {
|
|
t.Fatalf("accept exactly %d rows: %v", simCardBatchMaxRows, err)
|
|
}
|
|
if len(args) != 3 {
|
|
t.Fatalf("duplicate single values must collapse to one IN list, got %d args: %s", len(args), condition)
|
|
}
|
|
|
|
input += "one-more\n"
|
|
if _, _, err := simCardBatchCondition(context.Background(), input); err == nil {
|
|
t.Fatal("expected 1001 rows to be rejected even when values repeat")
|
|
}
|
|
}
|
|
|
|
func TestSimCardBatchInputPresenceAndExportValidation(t *testing.T) {
|
|
for _, payload := range []string{`{"batchInput":""}`, `{"batchInput":" \n\t"}`} {
|
|
var in model.TSimCardInfoListParam
|
|
if err := json.Unmarshal([]byte(payload), &in); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if in.BatchInput == nil {
|
|
t.Fatal("显式空批量输入不能视为省略字段")
|
|
}
|
|
if _, _, err := NewIotTSimCardInfo().List(context.Background(), &in); err == nil {
|
|
t.Fatal("列表应在访问数据库前拒绝空批量输入")
|
|
}
|
|
if err := NewIotTSimCardInfo().Export(context.Background(), &in); err == nil {
|
|
t.Fatal("导出应在提交任务前拒绝空批量输入")
|
|
}
|
|
}
|
|
var omitted model.TSimCardInfoListParam
|
|
if err := json.Unmarshal([]byte(`{}`), &omitted); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if omitted.BatchInput != nil {
|
|
t.Fatal("省略批量字段应保持原列表查询语义")
|
|
}
|
|
}
|
|
|
|
func TestSimCardBatchExportKeepsListReuse(t *testing.T) {
|
|
data, err := os.ReadFile("t_sim_card_info.go")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
source := string(data)
|
|
for _, fragment := range []string{"QueryParam: in,", "query := *in", "s.List(ctx, &query)", "mod := s.Model(ctx)", "mod = mod.Where(batchCondition, batchArgs...)"} {
|
|
if !strings.Contains(source, fragment) {
|
|
t.Errorf("批量查询必须保留现有权限及导出复用: %s", fragment)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCardChannelAssocExistsSQLUsesChannelKeyOnly(t *testing.T) {
|
|
query := cardChannelAssocExistsSQL("")
|
|
|
|
if !strings.Contains(query, "c.`chan_key` = a.`channel_id`") {
|
|
t.Fatalf("channel association must join by chan_key: %s", query)
|
|
}
|
|
if strings.Contains(query, "CAST(a.`channel_id`") {
|
|
t.Fatalf("channel association must not cast channel keys: %s", query)
|
|
}
|
|
if strings.Contains(query, "c.`id`") {
|
|
t.Fatalf("channel association must not join by channel primary key: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestShouldCacheDiagnoseRegionLimit(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
tempKey string
|
|
chanKey string
|
|
want bool
|
|
}{
|
|
{name: "mobile direct", tempKey: "sim_yd_v5", want: true},
|
|
{name: "mobile shared token", tempKey: "sim_onelink_daihe_v1", want: true},
|
|
{name: "shared token model", tempKey: "shared_token", want: true},
|
|
{name: "telecom", tempKey: "sim_dx_v1", want: false},
|
|
{name: "third party", tempKey: "sim_sdtywl_v1", want: false},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if got := shouldCacheDiagnoseRegionLimit(test.tempKey, test.chanKey); got != test.want {
|
|
t.Fatalf("shouldCacheDiagnoseRegionLimit(%q, %q) = %v, want %v", test.tempKey, test.chanKey, got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsDiagnoseRegionLimitCacheable(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
item *model.SimBaseRes[model.SimRegionLimitStatusItem]
|
|
want bool
|
|
}{
|
|
{name: "nil response"},
|
|
{
|
|
name: "successful region status",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 0, ResData: model.SimRegionLimitStatusItem{RegionLimitStatus: "1"}},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "successful order status",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 0, ResData: model.SimRegionLimitStatusItem{OrderStatus: "1"}},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "successful trigger status",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 0, ResData: model.SimRegionLimitStatusItem{OrderStatus: "0", LimitStatus: "0"}},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "upstream failure with populated status",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 9999, ResData: model.SimRegionLimitStatusItem{RegionLimitStatus: "1"}},
|
|
},
|
|
{
|
|
name: "unknown status placeholders",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 0, ResData: model.SimRegionLimitStatusItem{RegionLimitStatus: "2", OrderStatus: "-", LimitStatus: "-"}},
|
|
},
|
|
{
|
|
name: "details without status",
|
|
item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{Code: 0, ResData: model.SimRegionLimitStatusItem{LimitType: "1", LimitArea: "area"}},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if got := isDiagnoseRegionLimitCacheable(test.item); got != test.want {
|
|
t.Fatalf("isDiagnoseRegionLimitCacheable() = %v, want %v", got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDiagnoseRegionModuleDoesNotCooldownForInvalidCachedData(t *testing.T) {
|
|
result := &simDiagnoseRegionQueryResult{
|
|
Cached: true,
|
|
CachedAt: "2026-09-24 12:00:00",
|
|
Item: &model.SimBaseRes[model.SimRegionLimitStatusItem]{
|
|
Code: 0,
|
|
ResData: model.SimRegionLimitStatusItem{
|
|
RegionLimitStatus: "2",
|
|
LimitStatus: "-",
|
|
},
|
|
},
|
|
}
|
|
|
|
status, message, updatedAt := diagnoseRegionModule(result)
|
|
if status != "error" {
|
|
t.Fatalf("status = %q, want error", status)
|
|
}
|
|
if strings.Contains(message, "一小时内只能查询一次") || strings.Contains(message, "后可再次查看") {
|
|
t.Fatalf("invalid cached result must not show cooldown hint: %q", message)
|
|
}
|
|
if updatedAt != "" {
|
|
t.Fatalf("updatedAt = %q, want empty for invalid cached data", updatedAt)
|
|
}
|
|
}
|
|
|
|
func TestDiagnoseCachedModule(t *testing.T) {
|
|
status, message := diagnoseCachedModule(true)
|
|
if status != "cached" || !strings.Contains(message, "缓存") {
|
|
t.Fatalf("cached module = (%q, %q)", status, message)
|
|
}
|
|
status, message = diagnoseCachedModule(false)
|
|
if status != "success" || message != "" {
|
|
t.Fatalf("fresh module = (%q, %q)", status, message)
|
|
}
|
|
}
|
|
|
|
func TestApplyDiagnoseRegionLimit(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
data model.SimRegionLimitStatusItem
|
|
want model.TSimDiagnoseInfoItem
|
|
}{
|
|
{
|
|
name: "not ordered is not applicable",
|
|
data: model.SimRegionLimitStatusItem{RegionLimitStatus: "1", OrderStatus: "1", LimitStatus: "0", LimitType: "0", LimitArea: "park"},
|
|
want: model.TSimDiagnoseInfoItem{RegionLimitStatus: emptyStringPtr("2"), RegionLimitOrderStatus: emptyStringPtr("1")},
|
|
},
|
|
{
|
|
name: "ordered and disconnected is triggered",
|
|
data: model.SimRegionLimitStatusItem{RegionLimitStatus: "0", OrderStatus: "0", LimitStatus: "0", LimitType: "4", LimitArea: "park"},
|
|
want: model.TSimDiagnoseInfoItem{RegionLimitStatus: emptyStringPtr("1"), RegionLimitOrderStatus: emptyStringPtr("0"), RegionLimitTriggerStatus: emptyStringPtr("0"), RegionLimitType: emptyStringPtr("4"), RegionLimitArea: emptyStringPtr("park")},
|
|
},
|
|
{
|
|
name: "ordered and connected is not triggered",
|
|
data: model.SimRegionLimitStatusItem{RegionLimitStatus: "1", OrderStatus: "0", LimitStatus: "1", LimitType: "1", LimitArea: "province"},
|
|
want: model.TSimDiagnoseInfoItem{RegionLimitStatus: emptyStringPtr("0"), RegionLimitOrderStatus: emptyStringPtr("0"), RegionLimitTriggerStatus: emptyStringPtr("1"), RegionLimitType: emptyStringPtr("1"), RegionLimitArea: emptyStringPtr("province")},
|
|
},
|
|
{
|
|
name: "ordered network unknown",
|
|
data: model.SimRegionLimitStatusItem{OrderStatus: "0", LimitStatus: "-", LimitType: "0"},
|
|
want: model.TSimDiagnoseInfoItem{RegionLimitStatus: emptyStringPtr("2"), RegionLimitOrderStatus: emptyStringPtr("0"), RegionLimitTriggerStatus: emptyStringPtr("-")},
|
|
},
|
|
{
|
|
name: "channel without order status keeps normalized status",
|
|
data: model.SimRegionLimitStatusItem{RegionLimitStatus: "2"},
|
|
want: model.TSimDiagnoseInfoItem{RegionLimitStatus: emptyStringPtr("2")},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result := &model.TSimDiagnoseInfoOutput{Info: &model.TSimDiagnoseInfoItem{}}
|
|
applyDiagnoseRegionLimit(result, &model.SimBaseRes[model.SimRegionLimitStatusItem]{ResData: test.data})
|
|
assertStringPtrValue(t, "region status", result.Info.RegionLimitStatus, test.want.RegionLimitStatus)
|
|
assertStringPtrValue(t, "order status", result.Info.RegionLimitOrderStatus, test.want.RegionLimitOrderStatus)
|
|
assertStringPtrValue(t, "trigger status", result.Info.RegionLimitTriggerStatus, test.want.RegionLimitTriggerStatus)
|
|
assertStringPtrValue(t, "limit type", result.Info.RegionLimitType, test.want.RegionLimitType)
|
|
assertStringPtrValue(t, "limit area", result.Info.RegionLimitArea, test.want.RegionLimitArea)
|
|
})
|
|
}
|
|
}
|
|
|
|
func assertStringPtrValue(t *testing.T, name string, got *string, want *string) {
|
|
t.Helper()
|
|
if stringPtrValue(got) != stringPtrValue(want) {
|
|
t.Fatalf("%s = %q, want %q", name, stringPtrValue(got), stringPtrValue(want))
|
|
}
|
|
}
|
|
|
|
func stringPtrValue(value *string) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return *value
|
|
}
|
|
|
|
func TestValidateSimSessionResult(t *testing.T) {
|
|
t.Run("rejects empty upstream output", func(t *testing.T) {
|
|
if _, err := validateSimSessionResult(nil); err == nil {
|
|
t.Fatal("expected an error for empty output")
|
|
}
|
|
})
|
|
|
|
t.Run("rejects upstream business failure", func(t *testing.T) {
|
|
if _, err := validateSimSessionResult([]model.SimBaseRes[model.SimSessionItem]{{
|
|
Code: 1001,
|
|
Message: "upstream unavailable",
|
|
}}); err == nil {
|
|
t.Fatal("expected an error for failed output")
|
|
}
|
|
})
|
|
|
|
t.Run("returns successful session output", func(t *testing.T) {
|
|
want := model.SimSessionItem{Status: "0"}
|
|
got, err := validateSimSessionResult([]model.SimBaseRes[model.SimSessionItem]{{
|
|
Code: 0,
|
|
ResData: want,
|
|
}})
|
|
if err != nil {
|
|
t.Fatalf("validate session output: %v", err)
|
|
}
|
|
if got.ResData != want {
|
|
t.Fatalf("got %+v, want %+v", got.ResData, want)
|
|
}
|
|
})
|
|
}
|
|
|
|
// 13000 是移动 OneLink 在自身繁忙时随机返回的业务状态，属上游侧问题。
|
|
// 对用户展示时必须归属于上游，否则用户会误认为本平台故障。
|
|
func TestUpstreamBusyStatusIsAttributedToUpstream(t *testing.T) {
|
|
t.Run("busy code is rewritten to upstream message", func(t *testing.T) {
|
|
got := upstreamStatusDisplayMessage(simUpstreamBusyCode, "系统忙，请稍后再试")
|
|
if got != simUpstreamBusyMessage {
|
|
t.Fatalf("got %q, want %q", got, simUpstreamBusyMessage)
|
|
}
|
|
})
|
|
|
|
t.Run("busy message is recognized without the known code", func(t *testing.T) {
|
|
got := upstreamStatusDisplayMessage(8888, "系统忙，请稍后再试")
|
|
if got != simUpstreamBusyMessage {
|
|
t.Fatalf("got %q, want %q", got, simUpstreamBusyMessage)
|
|
}
|
|
})
|
|
|
|
t.Run("forbidden message is rewritten separately", func(t *testing.T) {
|
|
got := upstreamStatusDisplayMessage(0, "IP禁止访问")
|
|
if got != simUpstreamBusyForbiddenMessage {
|
|
t.Fatalf("got %q, want %q", got, simUpstreamBusyForbiddenMessage)
|
|
}
|
|
})
|
|
|
|
t.Run("unrelated business status keeps the original error", func(t *testing.T) {
|
|
got := upstreamStatusDisplayMessage(11011, "卡号不存在")
|
|
if got != "" {
|
|
t.Fatalf("got %q, want empty so the caller keeps the original message", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestNewSimDataUsageErrorHidesUpstreamBusy(t *testing.T) {
|
|
err := newSimDataUsageError(simUpstreamBusyCode, "系统忙，请稍后再试")
|
|
if err == nil {
|
|
t.Fatal("expected an error")
|
|
}
|
|
if err.Error() != simUpstreamBusyMessage {
|
|
t.Fatalf("got %q, want %q", err.Error(), simUpstreamBusyMessage)
|
|
}
|
|
if strings.Contains(err.Error(), "13000") {
|
|
t.Fatalf("upstream status code must not leak to users: %q", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestValidateSimCardStatusResultHidesUpstreamBusy(t *testing.T) {
|
|
_, err := validateSimCardStatusResult([]model.SimBaseRes[model.SimCardStatusItem]{{
|
|
Code: simUpstreamBusyCode,
|
|
Message: "系统忙，请稍后再试",
|
|
}}, "同步卡状态")
|
|
if err == nil {
|
|
t.Fatal("expected an error")
|
|
}
|
|
if err.Error() != simUpstreamBusyMessage {
|
|
t.Fatalf("got %q, want %q", err.Error(), simUpstreamBusyMessage)
|
|
}
|
|
}
|
|
|
|
func TestValidateSimCardStatusResultRejectsUnsupportedValue(t *testing.T) {
|
|
for _, status := range []int{-2, 3, 5, 10} {
|
|
_, err := validateSimCardStatusResult([]model.SimBaseRes[model.SimCardStatusItem]{{
|
|
Code: 0,
|
|
ResData: model.SimCardStatusItem{CardStatus: status},
|
|
}}, "sync status")
|
|
if err == nil {
|
|
t.Fatalf("unsupported status %d must not be written to card info", status)
|
|
}
|
|
}
|
|
for _, status := range []int{0, 1, 2, 4, 6, 7, 8, 9} {
|
|
_, err := validateSimCardStatusResult([]model.SimBaseRes[model.SimCardStatusItem]{{
|
|
Code: 0,
|
|
ResData: model.SimCardStatusItem{CardStatus: status},
|
|
}}, "sync status")
|
|
if err != nil {
|
|
t.Fatalf("platform status %d was rejected: %v", status, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFormatUpstreamTestMessage(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
code int
|
|
message string
|
|
want string
|
|
}{
|
|
{name: "busy code", code: simUpstreamBusyCode, message: "系统忙，请稍后再试", want: simUpstreamBusyMessage},
|
|
{name: "empty message", code: 0, message: " ", want: "上游未返回结果"},
|
|
{name: "other business message", code: 11011, message: "卡号不存在", want: "卡号不存在"},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if got := formatUpstreamTestMessage(test.code, test.message); got != test.want {
|
|
t.Fatalf("got %q, want %q", got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|