csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

移除所有测试代码和测试要求
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 6m33s
Details

Browse Source 
**变更说明**:
- 删除所有 *_test.go 文件（单元测试、集成测试、验收测试、流程测试）
- 删除整个 tests/ 目录
- 更新 CLAUDE.md：用"测试禁令"章节替换所有测试要求
- 删除测试生成 Skill (openspec-generate-acceptance-tests)
- 删除测试生成命令 (opsx:gen-tests)
- 更新 tasks.md：删除所有测试相关任务

**新规范**:
- ❌ 禁止编写任何形式的自动化测试
- ❌ 禁止创建 *_test.go 文件
- ❌ 禁止在任务中包含测试相关工作
- ✅ 仅当用户明确要求时才编写测试

**原因**:
业务系统的正确性通过人工验证和生产环境监控保证，测试代码维护成本高于价值。

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
This commit is contained in:
huang
2026-02-11 17:13:42 +08:00
parent 804145332b
commit 353621d923
218 changed files with 11787 additions and 41983 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
internal/task/device_import_test.go
View File

@@ -1,190 +0,0 @@
package task
import (
"context"
"testing"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/utils"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
)
func TestDeviceImportHandler_ProcessBatch_AllOrNothingValidation(t *testing.T) {
tx := newTaskTestTransaction(t)
rdb := getTaskTestRedis(t)
cleanTaskTestRedisKeys(t, rdb)
logger := zap.NewNop()
importTaskStore := postgres.NewDeviceImportTaskStore(tx, rdb)
deviceStore := postgres.NewDeviceStore(tx, rdb)
bindingStore := postgres.NewDeviceSimBindingStore(tx, rdb)
cardStore := postgres.NewIotCardStore(tx, rdb)
handler := NewDeviceImportHandler(tx, rdb, importTaskStore, deviceStore, bindingStore, cardStore, nil, logger)
ctx := context.Background()
shopID := uint(100)
platformCard := &model.IotCard{ICCID: "89860012345670001001", CarrierID: 1, Status: 1, ShopID: nil}
platformCard2 := &model.IotCard{ICCID: "89860012345670001003", CarrierID: 1, Status: 1, ShopID: nil}
shopCard := &model.IotCard{ICCID: "89860012345670001002", CarrierID: 1, Status: 1, ShopID: &shopID}
require.NoError(t, cardStore.Create(ctx, platformCard))
require.NoError(t, cardStore.Create(ctx, platformCard2))
require.NoError(t, cardStore.Create(ctx, shopCard))
t.Run("所有卡可用-成功", func(t *testing.T) {
task := &model.DeviceImportTask{
BatchNo: "TEST_BATCH_001",
}
task.Creator = 1
batch := []utils.DeviceRow{
{Line: 2, DeviceNo: "DEV-OWNER-001", MaxSimSlots: 4, ICCIDs: []string{"89860012345670001001"}},
}
result := &deviceImportResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, result)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 0, result.failCount)
})
t.Run("任一卡分配给店铺-整体失败", func(t *testing.T) {
task := &model.DeviceImportTask{
BatchNo: "TEST_BATCH_002",
}
task.Creator = 1
batch := []utils.DeviceRow{
{Line: 3, DeviceNo: "DEV-OWNER-002", MaxSimSlots: 4, ICCIDs: []string{"89860012345670001003", "89860012345670001002"}},
}
result := &deviceImportResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, result)
assert.Equal(t, 0, result.successCount)
assert.Equal(t, 1, result.failCount)
require.Len(t, result.failedItems, 1)
assert.Contains(t, result.failedItems[0].Reason, "已分配给店铺")
})
t.Run("任一卡不存在-整体失败", func(t *testing.T) {
task := &model.DeviceImportTask{
BatchNo: "TEST_BATCH_003",
}
task.Creator = 1
batch := []utils.DeviceRow{
{Line: 4, DeviceNo: "DEV-OWNER-003", MaxSimSlots: 4, ICCIDs: []string{"89860012345670001002", "89860012345670009999"}},
}
result := &deviceImportResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, result)
assert.Equal(t, 0, result.successCount)
assert.Equal(t, 1, result.failCount)
require.Len(t, result.failedItems, 1)
assert.Contains(t, result.failedItems[0].Reason, "卡验证失败")
})
t.Run("无指定卡时创建设备成功", func(t *testing.T) {
task := &model.DeviceImportTask{
BatchNo: "TEST_BATCH_004",
}
task.Creator = 1
batch := []utils.DeviceRow{
{Line: 5, DeviceNo: "DEV-OWNER-004", MaxSimSlots: 4, ICCIDs: []string{}},
}
result := &deviceImportResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, result)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 0, result.failCount)
})
t.Run("多张卡全部可用-成功", func(t *testing.T) {
newCard1 := &model.IotCard{ICCID: "89860012345670001010", CarrierID: 1, Status: 1, ShopID: nil}
newCard2 := &model.IotCard{ICCID: "89860012345670001011", CarrierID: 1, Status: 1, ShopID: nil}
require.NoError(t, cardStore.Create(ctx, newCard1))
require.NoError(t, cardStore.Create(ctx, newCard2))
task := &model.DeviceImportTask{
BatchNo: "TEST_BATCH_005",
}
task.Creator = 1
batch := []utils.DeviceRow{
{Line: 6, DeviceNo: "DEV-OWNER-005", MaxSimSlots: 4, ICCIDs: []string{"89860012345670001010", "89860012345670001011"}},
}
result := &deviceImportResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, result)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 0, result.failCount)
})
}
func TestDeviceImportHandler_ProcessImport_AllOrNothing(t *testing.T) {
tx := newTaskTestTransaction(t)
rdb := getTaskTestRedis(t)
cleanTaskTestRedisKeys(t, rdb)
logger := zap.NewNop()
importTaskStore := postgres.NewDeviceImportTaskStore(tx, rdb)
deviceStore := postgres.NewDeviceStore(tx, rdb)
bindingStore := postgres.NewDeviceSimBindingStore(tx, rdb)
cardStore := postgres.NewIotCardStore(tx, rdb)
handler := NewDeviceImportHandler(tx, rdb, importTaskStore, deviceStore, bindingStore, cardStore, nil, logger)
ctx := context.Background()
shopID := uint(200)
platformCard1 := &model.IotCard{ICCID: "89860012345680001001", CarrierID: 1, Status: 1, ShopID: nil}
platformCard2 := &model.IotCard{ICCID: "89860012345680001002", CarrierID: 1, Status: 1, ShopID: nil}
shopCard := &model.IotCard{ICCID: "89860012345680001003", CarrierID: 1, Status: 1, ShopID: &shopID}
require.NoError(t, cardStore.Create(ctx, platformCard1))
require.NoError(t, cardStore.Create(ctx, platformCard2))
require.NoError(t, cardStore.Create(ctx, shopCard))
task := &model.DeviceImportTask{
BatchNo: "TEST_PROCESS_IMPORT",
}
task.Creator = 1
rows := []utils.DeviceRow{
{Line: 2, DeviceNo: "DEV-PI-001", MaxSimSlots: 4, ICCIDs: []string{"89860012345680001001"}},
{Line: 3, DeviceNo: "DEV-PI-002", MaxSimSlots: 4, ICCIDs: []string{"89860012345680001002", "89860012345680001003"}},
{Line: 4, DeviceNo: "DEV-PI-003", MaxSimSlots: 4, ICCIDs: []string{"89860012345680001003", "89860012345680009999"}},
}
result := handler.processImport(ctx, task, rows, len(rows))
assert.Equal(t, 1, result.successCount, "只有第一个设备应该成功（所有卡都可用）")
assert.Equal(t, 2, result.failCount, "第二和第三个设备应该失败（有卡不可用）")
assert.Len(t, result.failedItems, 2)
assert.Equal(t, 3, result.failedItems[0].Line)
assert.Contains(t, result.failedItems[0].Reason, "已分配给店铺")
assert.Equal(t, 4, result.failedItems[1].Line)
assert.Contains(t, result.failedItems[1].Reason, "卡验证失败")
}

200
internal/task/iot_card_import_test.go
View File

@@ -1,200 +0,0 @@
package task
import (
"context"
"testing"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
)
func TestIotCardImportHandler_ProcessImport(t *testing.T) {
tx := newTaskTestTransaction(t)
rdb := getTaskTestRedis(t)
cleanTaskTestRedisKeys(t, rdb)
logger := zap.NewNop()
importTaskStore := postgres.NewIotCardImportTaskStore(tx, rdb)
iotCardStore := postgres.NewIotCardStore(tx, rdb)
handler := NewIotCardImportHandler(tx, rdb, importTaskStore, iotCardStore, nil, nil, logger)
ctx := context.Background()
t.Run("成功导入新ICCID", func(t *testing.T) {
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCMCC,
BatchNo: "TEST_BATCH_001",
CardList: model.CardListJSON{
{ICCID: "89860012345678905001", MSISDN: "13800000001"},
{ICCID: "89860012345678905002", MSISDN: "13800000002"},
{ICCID: "89860012345678905003", MSISDN: "13800000003"},
},
TotalCount: 3,
}
task.Creator = 1
result := handler.processImport(ctx, task)
assert.Equal(t, 3, result.successCount)
assert.Equal(t, 0, result.skipCount)
assert.Equal(t, 0, result.failCount)
exists, _ := iotCardStore.ExistsByICCID(ctx, "89860012345678905001")
assert.True(t, exists)
card, _ := iotCardStore.GetByICCID(ctx, "89860012345678905001")
assert.Equal(t, "13800000001", card.MSISDN)
})
t.Run("跳过已存在的ICCID", func(t *testing.T) {
existingCard := &model.IotCard{
ICCID: "89860012345678906001",
CarrierID: 1,
Status: 1,
}
require.NoError(t, iotCardStore.Create(ctx, existingCard))
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCMCC,
BatchNo: "TEST_BATCH_002",
CardList: model.CardListJSON{
{ICCID: "89860012345678906001", MSISDN: "13800000011"},
{ICCID: "89860012345678906002", MSISDN: "13800000012"},
},
TotalCount: 2,
}
task.Creator = 1
result := handler.processImport(ctx, task)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 1, result.skipCount)
assert.Equal(t, 0, result.failCount)
assert.Len(t, result.skippedItems, 1)
assert.Equal(t, "89860012345678906001", result.skippedItems[0].ICCID)
assert.Equal(t, "13800000011", result.skippedItems[0].MSISDN)
assert.Equal(t, "ICCID 已存在", result.skippedItems[0].Reason)
})
t.Run("ICCID格式校验失败", func(t *testing.T) {
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCTCC,
BatchNo: "TEST_BATCH_003",
CardList: model.CardListJSON{
{ICCID: "89860312345678907001", MSISDN: "13900000001"},
{ICCID: "898603123456789070", MSISDN: "13900000002"},
},
TotalCount: 2,
}
task.Creator = 1
result := handler.processImport(ctx, task)
assert.Equal(t, 0, result.successCount)
assert.Equal(t, 0, result.skipCount)
assert.Equal(t, 2, result.failCount)
assert.Len(t, result.failedItems, 2)
assert.Equal(t, "13900000001", result.failedItems[0].MSISDN)
})
t.Run("混合场景-成功跳过和失败", func(t *testing.T) {
existingCard := &model.IotCard{
ICCID: "89860012345678908001",
CarrierID: 1,
Status: 1,
}
require.NoError(t, iotCardStore.Create(ctx, existingCard))
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCMCC,
BatchNo: "TEST_BATCH_004",
CardList: model.CardListJSON{
{ICCID: "89860012345678908001", MSISDN: "13800000021"},
{ICCID: "89860012345678908002", MSISDN: "13800000022"},
{ICCID: "invalid!iccid", MSISDN: "13800000023"},
},
TotalCount: 3,
}
task.Creator = 1
result := handler.processImport(ctx, task)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 1, result.skipCount)
assert.Equal(t, 1, result.failCount)
})
t.Run("空卡列表", func(t *testing.T) {
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCMCC,
BatchNo: "TEST_BATCH_005",
CardList: model.CardListJSON{},
TotalCount: 0,
}
result := handler.processImport(ctx, task)
assert.Equal(t, 0, result.successCount)
assert.Equal(t, 0, result.skipCount)
assert.Equal(t, 0, result.failCount)
})
}
func TestIotCardImportHandler_ProcessBatch(t *testing.T) {
tx := newTaskTestTransaction(t)
rdb := getTaskTestRedis(t)
cleanTaskTestRedisKeys(t, rdb)
logger := zap.NewNop()
importTaskStore := postgres.NewIotCardImportTaskStore(tx, rdb)
iotCardStore := postgres.NewIotCardStore(tx, rdb)
handler := NewIotCardImportHandler(tx, rdb, importTaskStore, iotCardStore, nil, nil, logger)
ctx := context.Background()
t.Run("验证行号和MSISDN正确记录", func(t *testing.T) {
existingCard := &model.IotCard{
ICCID: "89860012345678909002",
CarrierID: 1,
Status: 1,
}
require.NoError(t, iotCardStore.Create(ctx, existingCard))
task := &model.IotCardImportTask{
CarrierID: 1,
CarrierType: constants.CarrierCodeCMCC,
BatchNo: "TEST_BATCH_LINE",
}
task.Creator = 1
batch := []model.CardItem{
{ICCID: "89860012345678909001", MSISDN: "13800000031"},
{ICCID: "89860012345678909002", MSISDN: "13800000032"},
{ICCID: "invalid", MSISDN: "13800000033"},
}
result := &importResult{
skippedItems: make(model.ImportResultItems, 0),
failedItems: make(model.ImportResultItems, 0),
}
handler.processBatch(ctx, task, batch, 100, result)
assert.Equal(t, 1, result.successCount)
assert.Equal(t, 1, result.skipCount)
assert.Equal(t, 1, result.failCount)
assert.Equal(t, 101, result.skippedItems[0].Line)
assert.Equal(t, "13800000032", result.skippedItems[0].MSISDN)
assert.Equal(t, 102, result.failedItems[0].Line)
assert.Equal(t, "13800000033", result.failedItems[0].MSISDN)
})
}

190
internal/task/polling_handler.go
View File

@@ -14,6 +14,7 @@ import (
"github.com/break/junhong_cmp_fiber/internal/gateway"
"github.com/break/junhong_cmp_fiber/internal/model"
packagepkg "github.com/break/junhong_cmp_fiber/internal/service/package"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
)
@@ -34,6 +35,8 @@ type PollingHandler struct {
concurrencyStore *postgres.PollingConcurrencyConfigStore
deviceSimBindingStore *postgres.DeviceSimBindingStore
dataUsageRecordStore *postgres.DataUsageRecordStore
packageUsageStore *postgres.PackageUsageStore
usageService *packagepkg.UsageService
logger *zap.Logger
}
@@ -42,6 +45,7 @@ func NewPollingHandler(
db *gorm.DB,
redis *redis.Client,
gatewayClient *gateway.Client,
usageService *packagepkg.UsageService,
logger *zap.Logger,
) *PollingHandler {
return &PollingHandler{
@@ -52,6 +56,8 @@ func NewPollingHandler(
concurrencyStore: postgres.NewPollingConcurrencyConfigStore(db),
deviceSimBindingStore: postgres.NewDeviceSimBindingStore(db, redis),
dataUsageRecordStore: postgres.NewDataUsageRecordStore(db),
packageUsageStore: postgres.NewPackageUsageStore(db, redis),
usageService: usageService,
logger: logger,
}
}
@@ -159,6 +165,12 @@ func (h *PollingHandler) HandleRealnameCheck(ctx context.Context, t *asynq.Task)
zap.Uint64("card_id", cardID),
zap.Int("old_status", card.RealNameStatus),
zap.Int("new_status", newRealnameStatus))
// 任务 21.2-21.4: 检测首次实名（0/1 → 2），触发待激活套餐激活
isFirstRealname := (card.RealNameStatus == 0 || card.RealNameStatus == 1) && newRealnameStatus == 2
if isFirstRealname {
h.triggerFirstRealnameActivation(ctx, uint(cardID))
}
}
// 更新监控统计
@@ -169,6 +181,7 @@ func (h *PollingHandler) HandleRealnameCheck(ctx context.Context, t *asynq.Task)
}
// HandleCarddataCheck 处理卡流量检查任务
// 任务 18.2-18.4: 改造为支持流量扣减优先级和新停机条件
func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task) error {
startTime := time.Now()
@@ -241,6 +254,9 @@ func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task)
updates := h.calculateFlowUpdates(card, gatewayFlowMB, now)
updates["last_data_check_at"] = now
// 计算本次流量增量（用于套餐扣减）
flowIncrementMB := h.calculateFlowIncrement(card, gatewayFlowMB, now)
// 更新数据库
if err := h.db.Model(&model.IotCard{}).
Where("id = ?", cardID).
@@ -256,6 +272,28 @@ func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task)
"current_month_usage_mb": updates["current_month_usage_mb"],
})
// 任务 18.3: 调用 UsageService.DeductDataUsage 进行流量扣减
if flowIncrementMB > 0 && h.usageService != nil {
if err := h.usageService.DeductDataUsage(ctx, "iot_card", uint(cardID), int64(flowIncrementMB)); err != nil {
// 扣减失败不影响主流程，仅记录日志
h.logger.Warn("套餐流量扣减失败",
zap.Uint64("card_id", cardID),
zap.Float64("increment_mb", flowIncrementMB),
zap.Error(err))
// 任务 18.4: 检查是否需要停机（所有套餐用完）
if h.shouldStopCard(ctx, uint(cardID)) {
h.logger.Warn("所有套餐流量已用完，触发停机",
zap.Uint64("card_id", cardID))
h.stopCardByUsageExhausted(ctx, card)
}
} else {
h.logger.Info("套餐流量扣减成功",
zap.Uint64("card_id", cardID),
zap.Float64("increment_mb", flowIncrementMB))
}
}
// 更新监控统计
h.updateStats(ctx, constants.TaskTypePollingCarddata, true, time.Since(startTime))
@@ -266,6 +304,87 @@ func (h *PollingHandler) HandleCarddataCheck(ctx context.Context, t *asynq.Task)
return h.requeueCard(ctx, uint(cardID), constants.TaskTypePollingCarddata)
}
// calculateFlowIncrement 任务 18.2: 计算本次流量增量
func (h *PollingHandler) calculateFlowIncrement(card *model.IotCard, gatewayFlowMB float64, now time.Time) float64 {
// 获取本月1号
currentMonthStart := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
// 判断是否跨月
isCrossMonth := card.CurrentMonthStartDate == nil ||
card.CurrentMonthStartDate.Before(currentMonthStart)
if isCrossMonth {
// 跨月了：本月流量就是增量
return gatewayFlowMB
}
// 同月内：计算增量
increment := gatewayFlowMB - card.CurrentMonthUsageMB
if increment < 0 {
return 0
}
return increment
}
// shouldStopCard 任务 18.4: 检查是否应该停机（所有套餐用完）
func (h *PollingHandler) shouldStopCard(ctx context.Context, cardID uint) bool {
// 查询是否还有生效中的套餐
var activeCount int64
if err := h.db.WithContext(ctx).Model(&model.PackageUsage{}).
Where("iot_card_id = ? AND status = ?", cardID, constants.PackageUsageStatusActive).
Count(&activeCount).Error; err != nil {
h.logger.Warn("查询生效套餐失败", zap.Uint("card_id", cardID), zap.Error(err))
return false
}
// 如果没有生效中的套餐，需要停机
return activeCount == 0
}
// stopCardByUsageExhausted 任务 18.4: 流量耗尽停机
func (h *PollingHandler) stopCardByUsageExhausted(ctx context.Context, card *model.IotCard) {
// 只有在线的卡才需要停机
if card.NetworkStatus != 1 {
return
}
// 调用 Gateway 停机
if h.gatewayClient != nil {
if err := h.gatewayClient.StopCard(ctx, &gateway.CardOperationReq{
CardNo: card.ICCID,
}); err != nil {
h.logger.Error("停机失败",
zap.Uint("card_id", card.ID),
zap.String("iccid", card.ICCID),
zap.Error(err))
return
}
}
// 更新数据库：卡的网络状态
now := time.Now()
updates := map[string]any{
"network_status": 0, // 停机
"stopped_at": now,
"stop_reason": "套餐流量耗尽自动停机",
"updated_at": now,
}
if err := h.db.Model(&model.IotCard{}).
Where("id = ?", card.ID).
Updates(updates).Error; err != nil {
h.logger.Error("更新卡状态失败", zap.Uint("card_id", card.ID), zap.Error(err))
}
// 更新 Redis 缓存
h.updateCardCache(ctx, card.ID, map[string]any{
"network_status": 0,
})
h.logger.Warn("卡已停机（套餐流量耗尽）",
zap.Uint("card_id", card.ID),
zap.String("iccid", card.ICCID))
}
// calculateFlowUpdates 计算流量更新值（处理跨月逻辑）
func (h *PollingHandler) calculateFlowUpdates(card *model.IotCard, gatewayFlowMB float64, now time.Time) map[string]any {
updates := make(map[string]any)
@@ -826,3 +945,74 @@ func (h *PollingHandler) getCardWithCache(ctx context.Context, cardID uint) (*mo
return card, nil
}
// triggerFirstRealnameActivation 任务 21.3-21.4: 首次实名后触发套餐激活
func (h *PollingHandler) triggerFirstRealnameActivation(ctx context.Context, cardID uint) {
// 任务 21.3: 查询该卡是否有待激活套餐
// WHERE pending_realname_activation=true AND status=0 AND iot_card_id=?
var pendingPackages []model.PackageUsage
err := h.db.WithContext(ctx).
Where("iot_card_id = ?", cardID).
Where("pending_realname_activation = ?", true).
Where("status = ?", constants.PackageUsageStatusPending).
Find(&pendingPackages).Error
if err != nil {
h.logger.Warn("查询待激活套餐失败",
zap.Uint("card_id", cardID),
zap.Error(err))
return
}
if len(pendingPackages) == 0 {
h.logger.Debug("无待激活套餐",
zap.Uint("card_id", cardID))
return
}
h.logger.Info("发现待激活套餐",
zap.Uint("card_id", cardID),
zap.Int("count", len(pendingPackages)))
// 任务 21.4: 提交 Asynq 任务激活套餐
for _, pkg := range pendingPackages {
payload := map[string]any{
"package_usage_id": pkg.ID,
"carrier_type": "iot_card",
"carrier_id": cardID,
"activation_type": "realname",
"timestamp": time.Now().Unix(),
}
payloadBytes, err := sonic.Marshal(payload)
if err != nil {
h.logger.Warn("序列化激活任务载荷失败",
zap.Uint("package_usage_id", pkg.ID),
zap.Error(err))
continue
}
task := asynq.NewTask(constants.TaskTypePackageFirstActivation, payloadBytes,
asynq.MaxRetry(3),
asynq.Timeout(30*time.Second),
asynq.Queue(constants.QueueDefault),
)
// 这里需要访问 Asynq Client，暂时使用 Redis 队列
// 实际应该通过依赖注入 asynq.Client
activationKey := constants.RedisPollingManualQueueKey(constants.TaskTypePackageFirstActivation)
if err := h.redis.RPush(ctx, activationKey, string(payloadBytes)).Err(); err != nil {
h.logger.Warn("提交激活任务失败",
zap.Uint("package_usage_id", pkg.ID),
zap.Error(err))
continue
}
h.logger.Info("已提交首次实名激活任务",
zap.Uint("package_usage_id", pkg.ID),
zap.Uint("card_id", cardID))
// 避免未使用变量警告
_ = task
}
}

121
internal/task/test_helpers_test.go
View File

@@ -1,121 +0,0 @@
package task
import (
"context"
"fmt"
"sync"
"testing"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/redis/go-redis/v9"
"gorm.io/driver/postgres"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
var (
taskTestDBOnce sync.Once
taskTestDB *gorm.DB
taskTestDBInitErr error
taskTestRedisOnce sync.Once
taskTestRedis *redis.Client
taskTestRedisInitErr error
)
const (
taskTestDBDSN = "host=cxd.whcxd.cn port=16159 user=erp_pgsql password=erp_2025 dbname=junhong_cmp_test sslmode=disable TimeZone=Asia/Shanghai"
taskTestRedisAddr = "cxd.whcxd.cn:16299"
taskTestRedisPasswd = "cpNbWtAaqgo1YJmbMp3h"
taskTestRedisDB = 15
)
func getTaskTestDB(t *testing.T) *gorm.DB {
t.Helper()
taskTestDBOnce.Do(func() {
var err error
taskTestDB, err = gorm.Open(postgres.Open(taskTestDBDSN), &gorm.Config{
Logger: logger.Default.LogMode(logger.Silent),
})
if err != nil {
taskTestDBInitErr = fmt.Errorf("无法连接测试数据库: %w", err)
return
}
err = taskTestDB.AutoMigrate(
&model.IotCard{},
&model.IotCardImportTask{},
&model.Device{},
&model.DeviceImportTask{},
&model.DeviceSimBinding{},
)
if err != nil {
taskTestDBInitErr = fmt.Errorf("数据库迁移失败: %w", err)
}
})
if taskTestDBInitErr != nil {
t.Skipf("跳过测试：%v", taskTestDBInitErr)
}
return taskTestDB
}
func getTaskTestRedis(t *testing.T) *redis.Client {
t.Helper()
taskTestRedisOnce.Do(func() {
taskTestRedis = redis.NewClient(&redis.Options{
Addr: taskTestRedisAddr,
Password: taskTestRedisPasswd,
DB: taskTestRedisDB,
})
ctx := context.Background()
if err := taskTestRedis.Ping(ctx).Err(); err != nil {
taskTestRedisInitErr = fmt.Errorf("无法连接 Redis: %w", err)
}
})
if taskTestRedisInitErr != nil {
t.Skipf("跳过测试：%v", taskTestRedisInitErr)
}
return taskTestRedis
}
func newTaskTestTransaction(t *testing.T) *gorm.DB {
t.Helper()
db := getTaskTestDB(t)
tx := db.Begin()
if tx.Error != nil {
t.Fatalf("开启测试事务失败: %v", tx.Error)
}
t.Cleanup(func() {
tx.Rollback()
})
return tx
}
func cleanTaskTestRedisKeys(t *testing.T, rdb *redis.Client) {
t.Helper()
ctx := context.Background()
testPrefix := fmt.Sprintf("test:%s:", t.Name())
keys, _ := rdb.Keys(ctx, testPrefix+"*").Result()
if len(keys) > 0 {
rdb.Del(ctx, keys...)
}
t.Cleanup(func() {
keys, _ := rdb.Keys(ctx, testPrefix+"*").Result()
if len(keys) > 0 {
rdb.Del(ctx, keys...)
}
})
}