refactor(db): 增强测试事务和缓存管理

- 在 HoTimeDB 中新增 testMu 互斥锁，确保 testTx 的串行访问，解决并发冲突问题
- 在 BeginTestTx 中初始化 testMu，确保测试事务的安全性
- 在 HoTimeCache 中新增 DisableDbCache 方法，测试模式下禁用 DB 和 Redis 缓存，避免锁等待超时
- 更新 Select 方法，确保在 testTx 激活时跳过缓存逻辑，提升测试稳定性
- 优化 Swagger 生成逻辑，支持模块化输出和导航页生成
- 移除冗余的调试日志代码，提升代码整洁性

cache/cache.go

@@ -1,36 +1,11 @@
 package cache
 
 import (
-	"encoding/json"
 	"errors"
-	"os"
-	"time"
 
 	. "code.hoteas.com/golang/hotime/common"
 )
 
-const debugLogPath = `d:\work\hotimev1.5\.cursor\debug.log`
-
-// debugLog 写入调试日志
-func debugLog(hypothesisId, location, message string, data map[string]interface{}) {
-	// #region agent log
-	logFile, _ := os.OpenFile(debugLogPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
-	if logFile != nil {
-		logEntry, _ := json.Marshal(map[string]interface{}{
-			"sessionId":    "cache-debug",
-			"runId":        "test-run",
-			"hypothesisId": hypothesisId,
-			"location":     location,
-			"message":      message,
-			"data":         data,
-			"timestamp":    time.Now().UnixMilli(),
-		})
-		logFile.Write(append(logEntry, '\n'))
-		logFile.Close()
-	}
-	// #endregion
-}
-
 // HoTimeCache 可配置memory，db，redis，默认启用memory，默认优先级为memory>redis>db,memory与数据库缓存设置项一致，
 // 缓存数据填充会自动反方向反哺，加入memory缓存过期将自动从redis更新，但memory永远不会更新redis，如果是集群建议不要开启memory，配置即启用
 type HoTimeCache struct {
@@ -214,26 +189,12 @@ func (that *HoTimeCache) SessionsGet(keys []string) Map {
 		return Map{}
 	}
 
-	// #region agent log
-	debugLog("D", "cache.go:SessionsGet:start", "SessionsGet开始", map[string]interface{}{
-		"keys_count": len(keys),
-		"has_memory": that.memoryCache != nil,
-		"has_redis":  that.redisCache != nil,
-		"has_db":     that.dbCache != nil,
-	})
-	// #endregion
-
 	result := make(Map, len(keys))
 	missingKeys := keys
 
 	// 从 memory 获取
 	if that.memoryCache != nil && that.memoryCache.SessionSet {
 		memResult := that.memoryCache.CachesGet(keys)
-		// #region agent log
-		debugLog("D", "cache.go:SessionsGet:memory", "从Memory获取", map[string]interface{}{
-			"found_count": len(memResult),
-		})
-		// #endregion
 		for k, v := range memResult {
 			result[k] = v
 		}
@@ -249,20 +210,9 @@ func (that *HoTimeCache) SessionsGet(keys []string) Map {
 	// 从 redis 获取未命中的
 	if len(missingKeys) > 0 && that.redisCache != nil && that.redisCache.SessionSet {
 		redisResult := that.redisCache.CachesGet(missingKeys)
-		// #region agent log
-		debugLog("D", "cache.go:SessionsGet:redis", "从Redis获取", map[string]interface{}{
-			"missing_count": len(missingKeys),
-			"found_count":   len(redisResult),
-		})
-		// #endregion
 		// 反哺到 memory
 		if that.memoryCache != nil && that.memoryCache.SessionSet && len(redisResult) > 0 {
 			that.memoryCache.CachesSet(redisResult)
-			// #region agent log
-			debugLog("D", "cache.go:SessionsGet:backfill_redis_to_mem", "Redis数据反哺到Memory", map[string]interface{}{
-				"backfill_count": len(redisResult),
-			})
-			// #endregion
 		}
 		for k, v := range redisResult {
 			result[k] = v
@@ -280,29 +230,13 @@ func (that *HoTimeCache) SessionsGet(keys []string) Map {
 	// 从 db 获取未命中的
 	if len(missingKeys) > 0 && that.dbCache != nil && that.dbCache.SessionSet {
 		dbResult := that.dbCache.CachesGet(missingKeys)
-		// #region agent log
-		debugLog("D", "cache.go:SessionsGet:db", "从DB获取", map[string]interface{}{
-			"missing_count": len(missingKeys),
-			"found_count":   len(dbResult),
-		})
-		// #endregion
 		// 反哺到 memory 和 redis
 		if len(dbResult) > 0 {
 			if that.memoryCache != nil && that.memoryCache.SessionSet {
 				that.memoryCache.CachesSet(dbResult)
-				// #region agent log
-				debugLog("D", "cache.go:SessionsGet:backfill_db_to_mem", "DB数据反哺到Memory", map[string]interface{}{
-					"backfill_count": len(dbResult),
-				})
-				// #endregion
 			}
 			if that.redisCache != nil && that.redisCache.SessionSet {
 				that.redisCache.CachesSet(dbResult)
-				// #region agent log
-				debugLog("D", "cache.go:SessionsGet:backfill_db_to_redis", "DB数据反哺到Redis", map[string]interface{}{
-					"backfill_count": len(dbResult),
-				})
-				// #endregion
 			}
 		}
 		for k, v := range dbResult {
@@ -310,12 +244,6 @@ func (that *HoTimeCache) SessionsGet(keys []string) Map {
 		}
 	}
 
-	// #region agent log
-	debugLog("D", "cache.go:SessionsGet:end", "SessionsGet完成", map[string]interface{}{
-		"total_found": len(result),
-	})
-	// #endregion
-
 	return result
 }
 
@@ -326,37 +254,15 @@ func (that *HoTimeCache) SessionsSet(data Map) {
 		return
 	}
 
-	// #region agent log
-	debugLog("A", "cache.go:SessionsSet:start", "SessionsSet开始", map[string]interface{}{
-		"data_count": len(data),
-		"has_memory": that.memoryCache != nil,
-		"has_redis":  that.redisCache != nil,
-		"has_db":     that.dbCache != nil,
-	})
-	// #endregion
-
 	if that.memoryCache != nil && that.memoryCache.SessionSet {
 		that.memoryCache.CachesSet(data)
-		// #region agent log
-		debugLog("A", "cache.go:SessionsSet:memory", "写入Memory完成", map[string]interface{}{"count": len(data)})
-		// #endregion
 	}
 	if that.redisCache != nil && that.redisCache.SessionSet {
 		that.redisCache.CachesSet(data)
-		// #region agent log
-		debugLog("A", "cache.go:SessionsSet:redis", "写入Redis完成", map[string]interface{}{"count": len(data)})
-		// #endregion
 	}
 	if that.dbCache != nil && that.dbCache.SessionSet {
 		that.dbCache.CachesSet(data)
-		// #region agent log
-		debugLog("A", "cache.go:SessionsSet:db", "写入DB完成", map[string]interface{}{"count": len(data)})
-		// #endregion
 	}
-
-	// #region agent log
-	debugLog("A", "cache.go:SessionsSet:end", "SessionsSet完成", nil)
-	// #endregion
 }
 
 // SessionsDelete 批量删除 Session 缓存
@@ -365,37 +271,15 @@ func (that *HoTimeCache) SessionsDelete(keys []string) {
 		return
 	}
 
-	// #region agent log
-	debugLog("C", "cache.go:SessionsDelete:start", "SessionsDelete开始", map[string]interface{}{
-		"keys_count": len(keys),
-		"has_memory": that.memoryCache != nil,
-		"has_redis":  that.redisCache != nil,
-		"has_db":     that.dbCache != nil,
-	})
-	// #endregion
-
 	if that.memoryCache != nil && that.memoryCache.SessionSet {
 		that.memoryCache.CachesDelete(keys)
-		// #region agent log
-		debugLog("C", "cache.go:SessionsDelete:memory", "从Memory删除完成", map[string]interface{}{"count": len(keys)})
-		// #endregion
 	}
 	if that.redisCache != nil && that.redisCache.SessionSet {
 		that.redisCache.CachesDelete(keys)
-		// #region agent log
-		debugLog("C", "cache.go:SessionsDelete:redis", "从Redis删除完成", map[string]interface{}{"count": len(keys)})
-		// #endregion
 	}
 	if that.dbCache != nil && that.dbCache.SessionSet {
 		that.dbCache.CachesDelete(keys)
-		// #region agent log
-		debugLog("C", "cache.go:SessionsDelete:db", "从DB删除完成", map[string]interface{}{"count": len(keys)})
-		// #endregion
 	}
-
-	// #region agent log
-	debugLog("C", "cache.go:SessionsDelete:end", "SessionsDelete完成", nil)
-	// #endregion
 }
 
 // CachesGet 批量获取普通缓存
@@ -602,3 +486,8 @@ func (that *HoTimeCache) Init(config Map, hotimeDb HoTimeDBInterface, err ...*Er
 	}
 
 }
+
+func (that *HoTimeCache) DisableDbCache() {
+	that.dbCache = nil
+	that.redisCache = nil
+}