iotlcm-public/iotlcm
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
70749bea7affd7533a1e02acaa03e7277883d024
iotlcm/worker-svr/internal/service/trafficcutoffconfig/repository_test.go
T

463 lines
20 KiB
Go
Raw Blame History

package trafficcutoffconfig
import (
"context"
"testing"
_ "github.com/gogf/gf/contrib/drivers/sqlite/v2"
"github.com/gogf/gf/v2/database/gdb"
"github.com/gogf/gf/v2/encoding/gjson"
batchdomain "git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/batch"
"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/consts"
"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/dao"
"git.5iot.com/iotlcm-public/iotlcm-worker-svr/internal/model/do"
)
const (
testTenantID = "000000"
testDeptID = int64(100)
)
func TestExecuteAllSuccessUpdatesAllCardsAndFinalizesSuccess(t *testing.T) {
ctx := context.Background()
repo := newConfigTestRepository(t)
batchNo := "TCC-41-SUCCESS"
seedConfigProcessingBatch(t, ctx, repo.db, batchNo, 512)
seedConfigRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
seedConfigRunningDetail(t, ctx, repo.db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, repo.db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 1, PackageStatus: 0, PackageTotal: 0})
seedConfigCard(t, ctx, repo.db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 9, PackageStatus: 3, PackageTotal: 0})
if err := (&executor{repository: repo}).Execute(ctx, batchNo); err != nil {
t.Fatalf("Execute() error = %v", err)
}
assertConfigBatchMain(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusSuccess, consts.BatchRunResultSuccess, 2, 0)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusSuccess, 2)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusFailed, 0)
assertConfigTrafficCutoff(t, ctx, repo.db, "898600000000001", 1, 512, 7)
assertConfigTrafficCutoff(t, ctx, repo.db, "898600000000002", 1, 512, 7)
assertNoPartialSuccess(t, ctx, repo.db, batchNo)
}
func TestExecuteDuplicateRowsMarksWholeBatchFailedWithoutCardUpdate(t *testing.T) {
ctx := context.Background()
repo := newConfigTestRepository(t)
batchNo := "TCC-41-DUPLICATE"
seedConfigProcessingBatch(t, ctx, repo.db, batchNo, 512)
seedConfigRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
seedConfigRunningDetail(t, ctx, repo.db, batchNo, 2, "898600000000001", "13800000001", "460001000000001", true)
seedConfigCard(t, ctx, repo.db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
if err := (&executor{repository: repo}).Execute(ctx, batchNo); err != nil {
t.Fatalf("Execute() error = %v", err)
}
assertConfigBatchMain(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusFailed, consts.BatchRunResultFailed, 0, 2)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusSuccess, 0)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusFailed, 2)
assertAnyDetailReason(t, ctx, repo.db, batchNo, duplicateICCIDReason)
assertAllConfigTrafficCutoffUnchanged(t, ctx, repo.db)
assertNoPartialSuccess(t, ctx, repo.db, batchNo)
}
func TestExecuteInvalidRowsAllowPartialSuccess(t *testing.T) {
tests := []struct {
name string
threshold float64
validICCID string
invalidICCID string
mutate func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string)
wantReason string
}{
{
name: "unauthorized",
threshold: 512,
validICCID: "898600000000002",
invalidICCID: "898600000000001",
wantReason: unauthorizedReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", false)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
},
},
{
name: "missing",
threshold: 512,
validICCID: "898600000000002",
wantReason: cardMissingReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000404", "13800000404", "460001000000404", true)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
},
},
{
name: "MSISDN mismatch",
threshold: 512,
validICCID: "898600000000002",
invalidICCID: "898600000000001",
wantReason: msisdnMismatchReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000001", "13900009999", "460001000000001", true)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
},
},
{
name: "IMSI mismatch",
threshold: 512,
validICCID: "898600000000002",
invalidICCID: "898600000000001",
wantReason: imsiMismatchReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000001", "13800000001", "460009999999999", true)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
},
},
{
name: "flow pool",
threshold: 512,
validICCID: "898600000000002",
invalidICCID: "898600000000001",
wantReason: flowPoolCardReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024, IsFlowPool: 1})
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
},
},
{
name: "package total exceeded",
threshold: 2048,
validICCID: "898600000000002",
invalidICCID: "898600000000001",
wantReason: packageTotalExceededReason,
mutate: func(ctx context.Context, t *testing.T, db gdb.DB, batchNo string) {
seedConfigRunningDetail(t, ctx, db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
seedConfigRunningDetail(t, ctx, db, batchNo, 2, "898600000000002", "13800000002", "460001000000002", true)
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 2, PackageTotal: 1024})
seedConfigCard(t, ctx, db, cardSeed{ICCID: "898600000000002", MSISDN: "13800000002", IMSI: "460001000000002", BossStatus: 2, PackageStatus: 2, PackageTotal: 0})
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx := context.Background()
repo := newConfigTestRepository(t)
batchNo := "TCC-41-" + tt.name
seedConfigProcessingBatch(t, ctx, repo.db, batchNo, tt.threshold)
tt.mutate(ctx, t, repo.db, batchNo)
if err := (&executor{repository: repo}).Execute(ctx, batchNo); err != nil {
t.Fatalf("Execute() error = %v", err)
}
assertConfigBatchMain(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusPartialSuccess, consts.BatchRunResultPartialSuccess, 1, 1)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusSuccess, 1)
assertConfigDetailStatusCount(t, ctx, repo.db, batchNo, consts.BatchDetailStatusFailed, 1)
assertAnyDetailReason(t, ctx, repo.db, batchNo, tt.wantReason)
assertConfigTrafficCutoff(t, ctx, repo.db, tt.validICCID, 1, tt.threshold, 7)
if tt.invalidICCID != "" {
assertConfigTrafficCutoff(t, ctx, repo.db, tt.invalidICCID, 0, 0, 0)
}
})
}
}
func TestExecuteDuplicateMessageDoesNotReapplyBusinessUpdate(t *testing.T) {
ctx := context.Background()
repo := newConfigTestRepository(t)
batchNo := "TCC-41-REPLAY"
seedConfigProcessingBatch(t, ctx, repo.db, batchNo, 512)
seedConfigRunningDetail(t, ctx, repo.db, batchNo, 1, "898600000000001", "13800000001", "460001000000001", true)
seedConfigCard(t, ctx, repo.db, cardSeed{ICCID: "898600000000001", MSISDN: "13800000001", IMSI: "460001000000001", BossStatus: 2, PackageStatus: 0, PackageTotal: 0})
exec := &executor{repository: repo}
if err := exec.Execute(ctx, batchNo); err != nil {
t.Fatalf("first Execute() error = %v", err)
}
assertConfigTrafficCutoff(t, ctx, repo.db, "898600000000001", 1, 512, 7)
if _, err := repo.db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).
Where(dao.TSimCardInfo.Columns().Iccid, "898600000000001").
Data(do.TSimCardInfo{TrafficCutoffStatus: 0, TrafficCutoffThreshold: 0, UpdatedBy: 99}).
Update(); err != nil {
t.Fatalf("reset card after first execute: %v", err)
}
if err := exec.Execute(ctx, batchNo); err == nil {
t.Fatal("second Execute() error = nil, want non-nil for finalized duplicate message")
}
assertConfigBatchMain(t, ctx, repo.db, batchNo, consts.BatchAsyncStatusSuccess, consts.BatchRunResultSuccess, 1, 0)
assertConfigTrafficCutoff(t, ctx, repo.db, "898600000000001", 0, 0, 99)
}
type cardSeed struct {
ICCID string
MSISDN string
IMSI string
BossStatus int
PackageStatus int
PackageTotal float64
IsFlowPool int
}
func newConfigTestRepository(t *testing.T) *Repository {
t.Helper()
ctx := context.Background()
db, err := gdb.New(gdb.ConfigNode{
Type: "sqlite",
Link: "sqlite::@file(:memory:)",
})
if err != nil {
t.Fatalf("create sqlite database: %v", err)
}
statements := []string{
`CREATE TABLE batch_main (
source_channel TEXT NOT NULL DEFAULT 'legacy',
execution_mode INTEGER NOT NULL DEFAULT 0,
id INTEGER PRIMARY KEY AUTOINCREMENT,
batch_no TEXT NOT NULL,
batch_type INTEGER NOT NULL,
batch_async_status INTEGER NOT NULL,
run_result INTEGER NOT NULL DEFAULT 0,
total_count INTEGER NOT NULL DEFAULT 0,
valid_count INTEGER NOT NULL DEFAULT 0,
success_count INTEGER NOT NULL DEFAULT 0,
fail_count INTEGER NOT NULL DEFAULT 0,
fail_reason TEXT,
start_time DATETIME,
end_time DATETIME,
created_by INTEGER NOT NULL DEFAULT 0,
created_dept INTEGER NOT NULL DEFAULT 0,
tenant_id TEXT NOT NULL DEFAULT '',
batch_info TEXT,
updated_by INTEGER NOT NULL DEFAULT 0
)`,
`CREATE TABLE batch_detail (
id INTEGER PRIMARY KEY AUTOINCREMENT,
batch_no TEXT NOT NULL,
batch_type INTEGER NOT NULL,
detail_status INTEGER NOT NULL,
error_reason TEXT,
snapshot TEXT,
item_id TEXT,
row_no INTEGER NOT NULL DEFAULT 0,
updated_by INTEGER NOT NULL DEFAULT 0
)`,
`CREATE TABLE t_sim_card_info (
id INTEGER PRIMARY KEY AUTOINCREMENT,
iccid TEXT NOT NULL,
msisdn TEXT,
imsi TEXT,
current_package_code TEXT,
package_status INTEGER NOT NULL DEFAULT 0,
boss_card_status INTEGER NOT NULL DEFAULT 0,
is_flow_pool INTEGER NOT NULL DEFAULT 0,
package_total_flow_mb REAL NOT NULL DEFAULT 0,
traffic_cutoff_status INTEGER NOT NULL DEFAULT 0,
traffic_cutoff_threshold REAL NOT NULL DEFAULT 0,
tenant_id TEXT NOT NULL DEFAULT '',
updated_by INTEGER NOT NULL DEFAULT 0
)`,
}
for _, statement := range statements {
if _, err = db.Exec(ctx, statement); err != nil {
t.Fatalf("create test schema: %v", err)
}
}
t.Cleanup(func() { _ = db.Close(ctx) })
return &Repository{db: db}
}
func seedConfigProcessingBatch(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, threshold float64) {
t.Helper()
info := gjson.New(map[string]any{
"operation": "traffic_cutoff_config",
"trafficCutoffStatus": 1,
"trafficCutoffThreshold": threshold,
"thresholdUnit": "MB",
})
if _, err := db.Model(dao.BatchMain.Table()).Ctx(ctx).Data(do.BatchMain{
BatchNo: batchNo,
BatchType: consts.BatchTypeTrafficCutoffConfig,
BatchAsyncStatus: consts.BatchAsyncStatusProcessing,
RunResult: batchdomain.RunResultRunning,
CreatedBy: 7,
CreatedDept: testDeptID,
TenantId: testTenantID,
BatchInfo: info,
}).Insert(); err != nil {
t.Fatalf("insert batch main: %v", err)
}
}
func TestConfigFromBatchInfoValidatesThreeStateContract(t *testing.T) {
tests := []struct {
name string
info map[string]any
wantStatus int
wantErr bool
}{
{name: "unconfigured", info: map[string]any{"trafficCutoffStatus": 0, "trafficCutoffThreshold": 0}},
{name: "enabled", info: map[string]any{"trafficCutoffStatus": 1, "trafficCutoffThreshold": 1.125}, wantStatus: 1},
{name: "disabled with retained threshold", info: map[string]any{"trafficCutoffStatus": 2, "trafficCutoffThreshold": 1.125}, wantStatus: 2},
{name: "old field only", info: map[string]any{"trafficCutoffEnabled": 1, "trafficCutoffThreshold": 1}, wantErr: true},
{name: "unconfigured nonzero threshold", info: map[string]any{"trafficCutoffStatus": 0, "trafficCutoffThreshold": 1}, wantErr: true},
{name: "enabled zero threshold", info: map[string]any{"trafficCutoffStatus": 1, "trafficCutoffThreshold": 0}, wantErr: true},
{name: "negative threshold", info: map[string]any{"trafficCutoffStatus": 2, "trafficCutoffThreshold": -1}, wantErr: true},
{name: "too many decimals", info: map[string]any{"trafficCutoffStatus": 2, "trafficCutoffThreshold": 1.0001}, wantErr: true},
{name: "invalid status", info: map[string]any{"trafficCutoffStatus": 3, "trafficCutoffThreshold": 0}, wantErr: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got, err := configFromBatchInfo(gjson.New(tt.info))
if (err != nil) != tt.wantErr {
t.Fatalf("configFromBatchInfo() error = %v, wantErr %v", err, tt.wantErr)
}
if got.TrafficCutoffStatus != tt.wantStatus {
t.Fatalf("configFromBatchInfo() status = %d, want %d", got.TrafficCutoffStatus, tt.wantStatus)
}
})
}
}
func seedConfigRunningDetail(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, rowNo int, iccid, msisdn, imsi string, authorized bool) {
t.Helper()
snapshot := gjson.New(map[string]any{
"ICCID": iccid,
"MSISDN": msisdn,
"IMSI": imsi,
"authorized": authorized,
})
if _, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).Data(do.BatchDetail{
BatchNo: batchNo,
BatchType: consts.BatchTypeTrafficCutoffConfig,
DetailStatus: consts.BatchDetailStatusRunning,
RowNo: rowNo,
ItemId: iccid,
Snapshot: snapshot,
}).Insert(); err != nil {
t.Fatalf("insert batch detail: %v", err)
}
}
func seedConfigCard(t *testing.T, ctx context.Context, db gdb.DB, seed cardSeed) {
t.Helper()
if _, err := db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).Data(do.TSimCardInfo{
Iccid: seed.ICCID,
Msisdn: seed.MSISDN,
Imsi: seed.IMSI,
CurrentPackageCode: "PKG-" + seed.ICCID,
PackageStatus: seed.PackageStatus,
BossCardStatus: seed.BossStatus,
IsFlowPool: seed.IsFlowPool,
PackageTotalFlowMb: seed.PackageTotal,
TrafficCutoffStatus: 0,
TrafficCutoffThreshold: 0,
TenantId: testTenantID,
}).Insert(); err != nil {
t.Fatalf("insert sim card: %v", err)
}
}
func assertConfigBatchMain(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, wantAsync, wantRun, wantSuccess, wantFail int) {
t.Helper()
var row struct {
Async int `orm:"batch_async_status"`
Run int `orm:"run_result"`
Success int `orm:"success_count"`
Fail int `orm:"fail_count"`
}
if err := db.Model(dao.BatchMain.Table()).Ctx(ctx).
Where(dao.BatchMain.Columns().BatchNo, batchNo).
Fields(dao.BatchMain.Columns().BatchAsyncStatus, dao.BatchMain.Columns().RunResult, dao.BatchMain.Columns().SuccessCount, dao.BatchMain.Columns().FailCount).
Scan(&row); err != nil {
t.Fatalf("query batch main: %v", err)
}
if row.Async != wantAsync || row.Run != wantRun || row.Success != wantSuccess || row.Fail != wantFail {
t.Fatalf("batch main = %+v, want async=%d run=%d success=%d fail=%d", row, wantAsync, wantRun, wantSuccess, wantFail)
}
}
func assertConfigDetailStatusCount(t *testing.T, ctx context.Context, db gdb.DB, batchNo string, status, want int) {
t.Helper()
count, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).
Where(dao.BatchDetail.Columns().BatchNo, batchNo).
Where(dao.BatchDetail.Columns().DetailStatus, status).
Count()
if err != nil {
t.Fatalf("count details: %v", err)
}
if count != want {
t.Fatalf("detail status %d count = %d, want %d", status, count, want)
}
}
func assertConfigTrafficCutoff(t *testing.T, ctx context.Context, db gdb.DB, iccid string, enabled int, threshold float64, updatedBy int64) {
t.Helper()
var row struct {
Enabled int `orm:"traffic_cutoff_status"`
Threshold float64 `orm:"traffic_cutoff_threshold"`
UpdatedBy int64 `orm:"updated_by"`
}
if err := db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).
Where(dao.TSimCardInfo.Columns().Iccid, iccid).
Fields(dao.TSimCardInfo.Columns().TrafficCutoffStatus, dao.TSimCardInfo.Columns().TrafficCutoffThreshold, dao.TSimCardInfo.Columns().UpdatedBy).
Scan(&row); err != nil {
t.Fatalf("query traffic cutoff fields: %v", err)
}
if row.Enabled != enabled || row.Threshold != threshold || row.UpdatedBy != updatedBy {
t.Fatalf("%s cutoff = (%d, %v, updatedBy=%d), want (%d, %v, updatedBy=%d)", iccid, row.Enabled, row.Threshold, row.UpdatedBy, enabled, threshold, updatedBy)
}
}
func assertAllConfigTrafficCutoffUnchanged(t *testing.T, ctx context.Context, db gdb.DB) {
t.Helper()
count, err := db.Model(dao.TSimCardInfo.Table()).Ctx(ctx).
Where(dao.TSimCardInfo.Columns().TrafficCutoffStatus, 1).
Count()
if err != nil {
t.Fatalf("count updated cards: %v", err)
}
if count != 0 {
t.Fatalf("updated card count = %d, want 0", count)
}
}
func assertAnyDetailReason(t *testing.T, ctx context.Context, db gdb.DB, batchNo, want string) {
t.Helper()
count, err := db.Model(dao.BatchDetail.Table()).Ctx(ctx).
Where(dao.BatchDetail.Columns().BatchNo, batchNo).
Where(dao.BatchDetail.Columns().ErrorReason, want).
Count()
if err != nil {
t.Fatalf("count detail reason: %v", err)
}
if count == 0 {
t.Fatalf("detail reason %q count = 0, want at least 1", want)
}
}
func assertNoPartialSuccess(t *testing.T, ctx context.Context, db gdb.DB, batchNo string) {
t.Helper()
count, err := db.Model(dao.BatchMain.Table()).Ctx(ctx).
Where(dao.BatchMain.Columns().BatchNo, batchNo).
Where(dao.BatchMain.Columns().BatchAsyncStatus, consts.BatchAsyncStatusPartialSuccess).
Count()
if err != nil {
t.Fatalf("count partial success batch main: %v", err)
}
if count != 0 {
t.Fatalf("partial success batch count = %d, want 0", count)
}
}
Reference in New Issue View Git Blame Copy Permalink