移除所有测试代码和测试要求

**变更说明**:
- 删除所有 *_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>

internal/polling/data_reset_handler.go

@@ -0,0 +1,116 @@
+package polling
+
+import (
+	"context"
+	"time"
+
+	"go.uber.org/zap"
+
+	packagepkg "github.com/break/junhong_cmp_fiber/internal/service/package"
+)
+
+// DataResetHandler 流量重置调度处理器
+// 任务 20: 定期检查需要重置的套餐并调用 ResetService 执行重置
+type DataResetHandler struct {
+	resetService *packagepkg.ResetService
+	logger       *zap.Logger
+
+	// 上次执行时间（用于限流，避免重复执行）
+	lastDailyReset   time.Time
+	lastMonthlyReset time.Time
+	lastYearlyReset  time.Time
+}
+
+// NewDataResetHandler 创建流量重置调度处理器
+func NewDataResetHandler(
+	resetService *packagepkg.ResetService,
+	logger *zap.Logger,
+) *DataResetHandler {
+	return &DataResetHandler{
+		resetService: resetService,
+		logger:       logger,
+	}
+}
+
+// HandleDataReset 任务 20.2: 处理流量重置调度
+// 每 10 秒被 Scheduler 调用一次，检查是否需要执行日/月/年重置
+func (h *DataResetHandler) HandleDataReset(ctx context.Context) error {
+	now := time.Now()
+
+	// 任务 20.3: 日重置调度（每分钟检查一次，避免频繁查询数据库）
+	if now.Sub(h.lastDailyReset) >= time.Minute {
+		if err := h.processDailyReset(ctx); err != nil {
+			h.logger.Warn("日重置调度失败", zap.Error(err))
+		}
+		h.lastDailyReset = now
+	}
+
+	// 任务 20.4: 月重置调度（每分钟检查一次）
+	if now.Sub(h.lastMonthlyReset) >= time.Minute {
+		if err := h.processMonthlyReset(ctx); err != nil {
+			h.logger.Warn("月重置调度失败", zap.Error(err))
+		}
+		h.lastMonthlyReset = now
+	}
+
+	// 任务 20.5: 年重置调度（每分钟检查一次）
+	if now.Sub(h.lastYearlyReset) >= time.Minute {
+		if err := h.processYearlyReset(ctx); err != nil {
+			h.logger.Warn("年重置调度失败", zap.Error(err))
+		}
+		h.lastYearlyReset = now
+	}
+
+	return nil
+}
+
+// processDailyReset 任务 20.3: 日重置调度
+func (h *DataResetHandler) processDailyReset(ctx context.Context) error {
+	if h.resetService == nil {
+		return nil
+	}
+
+	startTime := time.Now()
+	if err := h.resetService.ResetDailyUsage(ctx); err != nil {
+		return err
+	}
+
+	h.logger.Info("日重置调度完成",
+		zap.Duration("duration", time.Since(startTime)))
+
+	return nil
+}
+
+// processMonthlyReset 任务 20.4: 月重置调度
+func (h *DataResetHandler) processMonthlyReset(ctx context.Context) error {
+	if h.resetService == nil {
+		return nil
+	}
+
+	startTime := time.Now()
+	if err := h.resetService.ResetMonthlyUsage(ctx); err != nil {
+		return err
+	}
+
+	h.logger.Info("月重置调度完成",
+		zap.Duration("duration", time.Since(startTime)))
+
+	return nil
+}
+
+// processYearlyReset 任务 20.5: 年重置调度
+func (h *DataResetHandler) processYearlyReset(ctx context.Context) error {
+	if h.resetService == nil {
+		return nil
+	}
+
+	startTime := time.Now()
+	if err := h.resetService.ResetYearlyUsage(ctx); err != nil {
+		return err
+	}
+
+	h.logger.Info("年重置调度完成",
+		zap.Duration("duration", time.Since(startTime)))
+
+	return nil
+}

internal/polling/package_activation_handler.go

@@ -0,0 +1,368 @@
+package polling
+
+import (
+	"context"
+	"time"
+
+	"github.com/bytedance/sonic"
+	"github.com/hibiken/asynq"
+	"github.com/redis/go-redis/v9"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+
+	"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"
+)
+
+// PackageActivationHandler 套餐激活检查处理器
+// 任务 19: 处理主套餐过期、加油包级联失效、待生效主套餐激活
+type PackageActivationHandler struct {
+	db                  *gorm.DB
+	redis               *redis.Client
+	queueClient         *asynq.Client
+	packageUsageStore   *postgres.PackageUsageStore
+	activationService   *packagepkg.ActivationService
+	logger              *zap.Logger
+}
+
+// PackageActivationPayload 套餐激活任务载荷
+type PackageActivationPayload struct {
+	PackageUsageID uint   `json:"package_usage_id"`
+	CarrierType    string `json:"carrier_type"`    // "iot_card" 或 "device"
+	CarrierID      uint   `json:"carrier_id"`
+	ActivationType string `json:"activation_type"` // "queue" 或 "realname"
+	Timestamp      int64  `json:"timestamp"`
+}
+
+// NewPackageActivationHandler 创建套餐激活检查处理器
+func NewPackageActivationHandler(
+	db *gorm.DB,
+	redis *redis.Client,
+	queueClient *asynq.Client,
+	activationService *packagepkg.ActivationService,
+	logger *zap.Logger,
+) *PackageActivationHandler {
+	return &PackageActivationHandler{
+		db:                db,
+		redis:             redis,
+		queueClient:       queueClient,
+		packageUsageStore: postgres.NewPackageUsageStore(db, redis),
+		activationService: activationService,
+		logger:            logger,
+	}
+}
+
+// HandlePackageActivationCheck 任务 19.2-19.5: 处理套餐激活检查
+// 每 10 秒调度一次，检查过期主套餐并激活下一个待生效主套餐
+func (h *PackageActivationHandler) HandlePackageActivationCheck(ctx context.Context) error {
+	startTime := time.Now()
+
+	// 任务 19.2: 查询已过期的主套餐（status=1 AND expires_at <= NOW）
+	expiredPackages, err := h.findExpiredMainPackages(ctx)
+	if err != nil {
+		h.logger.Error("查询过期主套餐失败", zap.Error(err))
+		return err
+	}
+
+	if len(expiredPackages) == 0 {
+		return nil
+	}
+
+	h.logger.Info("发现过期主套餐",
+		zap.Int("count", len(expiredPackages)),
+		zap.Duration("check_duration", time.Since(startTime)))
+
+	// 处理每个过期的主套餐
+	for _, pkg := range expiredPackages {
+		if err := h.processExpiredPackage(ctx, pkg); err != nil {
+			h.logger.Error("处理过期套餐失败",
+				zap.Uint("package_usage_id", pkg.ID),
+				zap.Error(err))
+			// 继续处理下一个，不中断
+			continue
+		}
+	}
+
+	h.logger.Info("套餐激活检查完成",
+		zap.Int("processed", len(expiredPackages)),
+		zap.Duration("total_duration", time.Since(startTime)))
+
+	return nil
+}
+
+// findExpiredMainPackages 任务 19.2: 查询已过期的主套餐
+func (h *PackageActivationHandler) findExpiredMainPackages(ctx context.Context) ([]*model.PackageUsage, error) {
+	var packages []*model.PackageUsage
+	now := time.Now()
+
+	// 查询 status=1 (生效中) AND expires_at <= NOW AND master_usage_id IS NULL (主套餐)
+	err := h.db.WithContext(ctx).
+		Where("status = ?", constants.PackageUsageStatusActive).
+		Where("expires_at <= ?", now).
+		Where("master_usage_id IS NULL"). // 主套餐没有 master_usage_id
+		Limit(1000). // 每次最多处理 1000 个，避免长事务
+		Find(&packages).Error
+
+	return packages, err
+}
+
+// processExpiredPackage 处理单个过期套餐
+func (h *PackageActivationHandler) processExpiredPackage(ctx context.Context, pkg *model.PackageUsage) error {
+	return h.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		// 任务 19.3: 更新过期主套餐状态为 Expired (status=3)
+		if err := tx.Model(pkg).Update("status", constants.PackageUsageStatusExpired).Error; err != nil {
+			return err
+		}
+
+		h.logger.Info("主套餐已过期",
+			zap.Uint("package_usage_id", pkg.ID),
+			zap.Time("expires_at", pkg.ExpiresAt))
+
+		// 任务 19.4: 加油包级联失效
+		if err := h.invalidateAddons(ctx, tx, pkg.ID); err != nil {
+			h.logger.Warn("加油包级联失效失败",
+				zap.Uint("master_usage_id", pkg.ID),
+				zap.Error(err))
+			// 不返回错误，继续处理
+		}
+
+		// 任务 19.5: 查询并激活下一个待生效主套餐
+		carrierType, carrierID := h.getCarrierInfo(pkg)
+		if carrierType != "" && carrierID > 0 {
+			if err := h.activateNextPackage(ctx, tx, carrierType, carrierID); err != nil {
+				h.logger.Warn("激活下一个待生效套餐失败",
+					zap.String("carrier_type", carrierType),
+					zap.Uint("carrier_id", carrierID),
+					zap.Error(err))
+				// 不返回错误，继续处理
+			}
+		}
+
+		return nil
+	})
+}
+
+// invalidateAddons 任务 19.4: 加油包级联失效
+func (h *PackageActivationHandler) invalidateAddons(ctx context.Context, tx *gorm.DB, masterUsageID uint) error {
+	// 查询主套餐下的所有加油包（status IN (0,1,2) 的加油包）
+	result := tx.Model(&model.PackageUsage{}).
+		Where("master_usage_id = ?", masterUsageID).
+		Where("status IN ?", []int{
+			constants.PackageUsageStatusPending,
+			constants.PackageUsageStatusActive,
+			constants.PackageUsageStatusDepleted,
+		}).
+		Update("status", constants.PackageUsageStatusInvalidated)
+
+	if result.Error != nil {
+		return result.Error
+	}
+
+	if result.RowsAffected > 0 {
+		h.logger.Info("加油包已级联失效",
+			zap.Uint("master_usage_id", masterUsageID),
+			zap.Int64("invalidated_count", result.RowsAffected))
+	}
+
+	return nil
+}
+
+// getCarrierInfo 获取载体信息
+func (h *PackageActivationHandler) getCarrierInfo(pkg *model.PackageUsage) (string, uint) {
+	if pkg.IotCardID > 0 {
+		return "iot_card", pkg.IotCardID
+	}
+	if pkg.DeviceID > 0 {
+		return "device", pkg.DeviceID
+	}
+	return "", 0
+}
+
+// activateNextPackage 任务 19.5: 激活下一个待生效主套餐
+func (h *PackageActivationHandler) activateNextPackage(ctx context.Context, tx *gorm.DB, carrierType string, carrierID uint) error {
+	// 查询下一个待生效主套餐
+	// WHERE status=0 AND master_usage_id IS NULL ORDER BY priority ASC LIMIT 1
+	var nextPkg model.PackageUsage
+	query := tx.Where("status = ?", constants.PackageUsageStatusPending).
+		Where("master_usage_id IS NULL"). // 主套餐
+		Order("priority ASC").
+		Limit(1)
+
+	if carrierType == "iot_card" {
+		query = query.Where("iot_card_id = ?", carrierID)
+	} else if carrierType == "device" {
+		query = query.Where("device_id = ?", carrierID)
+	}
+
+	if err := query.First(&nextPkg).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			// 没有待生效套餐，正常情况
+			return nil
+		}
+		return err
+	}
+
+	// 提交 Asynq 任务进行激活（避免长事务）
+	return h.enqueueActivationTask(ctx, nextPkg.ID, carrierType, carrierID, "queue")
+}
+
+// enqueueActivationTask 提交套餐激活任务到 Asynq
+func (h *PackageActivationHandler) enqueueActivationTask(ctx context.Context, packageUsageID uint, carrierType string, carrierID uint, activationType string) error {
+	payload := PackageActivationPayload{
+		PackageUsageID: packageUsageID,
+		CarrierType:    carrierType,
+		CarrierID:      carrierID,
+		ActivationType: activationType,
+		Timestamp:      time.Now().Unix(),
+	}
+
+	payloadBytes, err := sonic.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	task := asynq.NewTask(constants.TaskTypePackageQueueActivation, payloadBytes,
+		asynq.MaxRetry(3),
+		asynq.Timeout(30*time.Second),
+		asynq.Queue(constants.QueueDefault),
+	)
+
+	_, err = h.queueClient.Enqueue(task)
+	if err != nil {
+		h.logger.Error("提交套餐激活任务失败",
+			zap.Uint("package_usage_id", packageUsageID),
+			zap.Error(err))
+		return err
+	}
+
+	h.logger.Info("已提交套餐激活任务",
+		zap.Uint("package_usage_id", packageUsageID),
+		zap.String("activation_type", activationType))
+
+	return nil
+}
+
+// HandlePackageQueueActivation 处理套餐排队激活任务（Asynq Handler）
+// 任务 23: 由 Asynq 调用，执行实际的套餐激活逻辑
+func (h *PackageActivationHandler) HandlePackageQueueActivation(ctx context.Context, t *asynq.Task) error {
+	var payload PackageActivationPayload
+	if err := sonic.Unmarshal(t.Payload(), &payload); err != nil {
+		h.logger.Error("解析套餐激活任务载荷失败", zap.Error(err))
+		return nil // 不重试
+	}
+
+	h.logger.Info("开始执行套餐激活",
+		zap.Uint("package_usage_id", payload.PackageUsageID),
+		zap.String("activation_type", payload.ActivationType))
+
+	// 查询套餐使用记录
+	var pkg model.PackageUsage
+	if err := h.db.First(&pkg, payload.PackageUsageID).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			h.logger.Warn("套餐使用记录不存在", zap.Uint("package_usage_id", payload.PackageUsageID))
+			return nil
+		}
+		return err
+	}
+
+	// 幂等性检查：如果已经是生效状态，跳过
+	if pkg.Status == constants.PackageUsageStatusActive {
+		h.logger.Info("套餐已激活，跳过",
+			zap.Uint("package_usage_id", payload.PackageUsageID))
+		return nil
+	}
+
+	// 调用 ActivationService 执行激活
+	if h.activationService != nil {
+		if err := h.activationService.ActivateQueuedPackage(ctx, payload.CarrierType, payload.CarrierID); err != nil {
+			h.logger.Error("套餐激活失败",
+				zap.Uint("package_usage_id", payload.PackageUsageID),
+				zap.String("carrier_type", payload.CarrierType),
+				zap.Uint("carrier_id", payload.CarrierID),
+				zap.Error(err))
+			return err
+		}
+	} else {
+		// ActivationService 未注入，直接更新状态
+		now := time.Now()
+		if err := h.db.Model(&pkg).Updates(map[string]interface{}{
+			"status":       constants.PackageUsageStatusActive,
+			"activated_at": now,
+		}).Error; err != nil {
+			return err
+		}
+	}
+
+	h.logger.Info("套餐激活成功",
+		zap.Uint("package_usage_id", payload.PackageUsageID))
+
+	return nil
+}
+
+// HandlePackageFirstActivation 处理首次实名激活任务（Asynq Handler）
+// 任务 22: 由 Asynq 调用，执行首次实名后的套餐激活
+func (h *PackageActivationHandler) HandlePackageFirstActivation(ctx context.Context, t *asynq.Task) error {
+	var payload PackageActivationPayload
+	if err := sonic.Unmarshal(t.Payload(), &payload); err != nil {
+		h.logger.Error("解析首次实名激活任务载荷失败", zap.Error(err))
+		return nil // 不重试
+	}
+
+	h.logger.Info("开始执行首次实名激活",
+		zap.Uint("package_usage_id", payload.PackageUsageID),
+		zap.String("carrier_type", payload.CarrierType),
+		zap.Uint("carrier_id", payload.CarrierID))
+
+	// 任务 22.4: 幂等性检查
+	var pkg model.PackageUsage
+	if err := h.db.First(&pkg, payload.PackageUsageID).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			h.logger.Warn("套餐使用记录不存在", zap.Uint("package_usage_id", payload.PackageUsageID))
+			return nil
+		}
+		return err
+	}
+
+	// 检查 pending_realname_activation 是否已为 false（已处理过）
+	if !pkg.PendingRealnameActivation {
+		h.logger.Info("套餐已处理过首次实名激活，跳过",
+			zap.Uint("package_usage_id", payload.PackageUsageID))
+		return nil
+	}
+
+	// 如果已经是生效状态，跳过
+	if pkg.Status == constants.PackageUsageStatusActive {
+		h.logger.Info("套餐已激活，跳过",
+			zap.Uint("package_usage_id", payload.PackageUsageID))
+		return nil
+	}
+
+	// 任务 22.3: 调用 ActivationService.ActivateByRealname 激活套餐
+	if h.activationService != nil {
+		if err := h.activationService.ActivateByRealname(ctx, payload.CarrierType, payload.CarrierID); err != nil {
+			h.logger.Error("首次实名激活失败",
+				zap.Uint("package_usage_id", payload.PackageUsageID),
+				zap.String("carrier_type", payload.CarrierType),
+				zap.Uint("carrier_id", payload.CarrierID),
+				zap.Error(err))
+			return err
+		}
+	} else {
+		// ActivationService 未注入，直接更新状态（备用逻辑）
+		now := time.Now()
+		if err := h.db.Model(&pkg).Updates(map[string]any{
+			"status":                       constants.PackageUsageStatusActive,
+			"activated_at":                 now,
+			"pending_realname_activation":  false,
+		}).Error; err != nil {
+			return err
+		}
+	}
+
+	h.logger.Info("首次实名激活成功",
+		zap.Uint("package_usage_id", payload.PackageUsageID))
+
+	return nil
+}

internal/polling/scheduler.go

@@ -28,6 +28,11 @@ type Scheduler struct {
 	iotCardStore      *postgres.IotCardStore
 	concurrencyStore  *postgres.PollingConcurrencyConfigStore
 
+	// 任务 19: 套餐激活检查处理器
+	packageActivationHandler *PackageActivationHandler
+	// 任务 20: 流量重置调度处理器
+	dataResetHandler *DataResetHandler
+
 	// 配置缓存
 	configCache     []*model.PollingConfig
 	configCacheLock sync.RWMutex
@@ -87,13 +92,15 @@ func NewScheduler(
 	logger *zap.Logger,
 ) *Scheduler {
 	return &Scheduler{
-		db:               db,
-		redis:            redisClient,
-		queueClient:      queueClient,
-		logger:           logger,
-		configStore:      postgres.NewPollingConfigStore(db),
-		iotCardStore:     postgres.NewIotCardStore(db, redisClient),
-		concurrencyStore: postgres.NewPollingConcurrencyConfigStore(db),
+		db:                       db,
+		redis:                    redisClient,
+		queueClient:              queueClient,
+		logger:                   logger,
+		configStore:              postgres.NewPollingConfigStore(db),
+		iotCardStore:             postgres.NewIotCardStore(db, redisClient),
+		concurrencyStore:         postgres.NewPollingConcurrencyConfigStore(db),
+		packageActivationHandler: NewPackageActivationHandler(db, redisClient, queueClient, nil, logger),
+		dataResetHandler:         NewDataResetHandler(nil, logger), // ResetService 需要通过 SetResetService 注入
 		initProgress: &InitProgress{
 			Status: "pending",
 		},
@@ -241,6 +248,20 @@ func (s *Scheduler) processSchedule(ctx context.Context) {
 	s.processTimedQueue(ctx, constants.RedisPollingQueueRealnameKey(), constants.TaskTypePollingRealname, now)
 	s.processTimedQueue(ctx, constants.RedisPollingQueueCarddataKey(), constants.TaskTypePollingCarddata, now)
 	s.processTimedQueue(ctx, constants.RedisPollingQueuePackageKey(), constants.TaskTypePollingPackage, now)
+
+	// 任务 19.6: 套餐激活检查（每次调度都执行，内部会限流）
+	if s.packageActivationHandler != nil {
+		if err := s.packageActivationHandler.HandlePackageActivationCheck(ctx); err != nil {
+			s.logger.Warn("套餐激活检查失败", zap.Error(err))
+		}
+	}
+
+	// 任务 20.6: 流量重置调度（每次调度都执行，内部会限流）
+	if s.dataResetHandler != nil {
+		if err := s.dataResetHandler.HandleDataReset(ctx); err != nil {
+			s.logger.Warn("流量重置调度失败", zap.Error(err))
+		}
+	}
 }
 
 // processManualQueue 处理手动触发队列
@@ -709,3 +730,15 @@ func (s *Scheduler) IsInitCompleted() bool {
 func (s *Scheduler) RefreshConfigs(ctx context.Context) error {
 	return s.loadConfigs(ctx)
 }
+
+// SetResetService 设置流量重置服务（用于依赖注入）
+func (s *Scheduler) SetResetService(resetService interface{}) {
+	if rs, ok := resetService.(*DataResetHandler); ok {
+		s.dataResetHandler = rs
+	}
+}
+
+// SetActivationService 设置套餐激活服务（用于依赖注入）
+func (s *Scheduler) SetActivationService(activationHandler *PackageActivationHandler) {
+	s.packageActivationHandler = activationHandler
+}