feat: 静态代码审计,修复逻辑bug和安全漏洞

audit-report.md

@@ -1,343 +1,287 @@
-# 第 11 轮深度审计报告
+# 第 12 轮深度审计报告
 
 审计对象：`perms-system/server`（不含测试代码）
 审计维度：逻辑一致性、并发/竞态、资源管理、数据完整性、安全漏洞、边界、DB 性能、僵尸代码、接口契约
-说明：本轮基于真实业务量级（数千用户 / 数十产品 / 单产品 <100 role / 一次 SyncPerms < 1k perm / 单 user 10~30 role）做判定。对前 10 轮已闭环条目（H-1~H-4、M-1~M-R10-5、L-1~L-R10-10 等）不重复列举，仅追踪**本轮新发现或重新归类**的风险点。
-
----
+说明：本轮基于真实业务量级（数千用户 / 数十产品 / 单产品 <100 role / 一次 SyncPerms < 1k perm / 单 user 10~30 role）做判定。
 
 ## 🚩 核心逻辑漏洞 (High Risk)
 
-### H-R11-1（High · 数据完整性/竞态） · `UpdatePassword` 内部 `FindOne` 把"外层校验过的状态"洗掉，乐观锁自我对齐 → TOCTOU
-
-**描述**：`internal/model/user/sysUserModel.go:128-152` 的 `UpdatePassword` 不接受外部 `expectedUpdateTime`，而是在内部自己 `FindOne` 再取 `data.UpdateTime` 作为乐观锁 WHERE：
-
-```128:152:internal/model/user/sysUserModel.go
-func (m *customSysUserModel) UpdatePassword(ctx context.Context, id int64, password string, mustChangePassword int64) error {
-	data, err := m.FindOne(ctx, id)
-	if err != nil {
-		return err
-	}
-
-	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
-	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
-	// 乐观锁：WHERE 叠加 updateTime 与 FindOne 拿到的一致。避免 FindOne → Exec 之间并发改密把
-	// 本次写盖成"最后一写赢"、或目标行被删除后仍返回成功造成语义欺骗（见审计 M-2）。
-	expectedUpdateTime := data.UpdateTime
-	res, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (sql.Result, error) {
-		query := fmt.Sprintf("UPDATE %s SET `password` = ?, `mustChangePassword` = ?, `tokenVersion` = `tokenVersion` + 1, `updateTime` = ? WHERE `id` = ? AND `updateTime` = ?", m.table)
-		return conn.ExecCtx(ctx, query, password, mustChangePassword, time.Now().Unix(), id, expectedUpdateTime)
-	}, sysUserIdKey, sysUserUsernameKey)
-```
-
-调用方 `ChangePasswordLogic`（`internal/logic/auth/changePasswordLogic.go:50-81`）早已经自己 `FindOne` 读到 `user`、校验 `user.Password` + `user.Status != Enabled`，然后把 `userId` 透传进来。此处 `UpdatePassword` 又打一次 `FindOne`，内层 CAS 对齐的是**内层 FindOne 的时间戳**——而不是**外层校验旧密码所依赖的那个时间戳**。
-
-真实并发场景（两个并存会话）：
-
-```text
-T0: Device A 发起改密 (oldPass=P0, newPass=P1)
-    ChangePasswordLogic.FindOne → user{password=H(P0), updateTime=T0}
-    bcrypt.CompareHashAndPassword(H(P0), P0) → OK
-    bcrypt.GenerateFromPassword(P1) → H(P1)
-T1: Device B 独立完成改密到 P2
-    UpdatePassword: FindOne → user{updateTime=T0} → UPDATE ... WHERE updateTime=T0
-    提交成功：password=H(P2), updateTime=T1, tokenVersion+1
-T2: Device A 的 UpdatePassword 开始执行
-    内部 FindOne → user{updateTime=T1, password=H(P2)}  ← 被 B 的写"刷新"
-    expectedUpdateTime=T1
-    UPDATE ... WHERE updateTime=T1 → 匹配，提交成功
-    最终 DB：password=H(P1), Device B 的新密码 P2 被覆盖
-```
-
-等价结论：内层"自 FindOne-自 Update"的 CAS 等于没有 CAS。调用方看似"带乐观锁"，实际语义已退化为 **last-write-wins on password**，而且连"外层校验的旧密码还是有效旧密码"都不再成立（A 验证的是 P0，应用出去的是把 P2 改回到 P1）。
+本轮未发现新的 High Risk 漏洞。R11 的 H-R11-1 是上一轮可复现的密码 TOCTOU，本轮密码链路已经收敛；auth / token / dept / member / sync 四条主链已在锁序、乐观锁、CAS 三层护栏兜底，暂未看到可直接越权/篡改数据的 High 条目。
 
-这条 TOCTOU 并非纸面理论：
+---
 
-- 一个用户因安全事件在 Device B 上紧急改密为 P2（本意：立刻让 Device A 的旧会话失效+密码改掉）；
-- 但 Device B 提交的瞬间，Device A 正好在点"修改密码 P0 → P1"。A 的 middleware 已经通过 token 鉴权并取到 userId，logic 执行没有依赖 Device B 的 tokenVersion 递增结果；
-- 最终 P2 被 P1 覆盖，Device B 用户将以为密码是 P2，尝试登录失败；而 Device A 并没有"知道 P2"——也就是说，**一个原本没有权限修改最新密码的会话，成功把密码改掉了**。
+## ⚠️ 健壮性与性能建议 (Medium/Low)
 
-此外：`UpdatePassword` 里 `tokenVersion = tokenVersion + 1` 是累计的，所以两次成功的 UPDATE 会连续 +2，把刚刚因 B 改密正准备下线的 A 的旧 token（version 已经对不上）再把 B 的所有新会话也踢掉，用户本次密码修改后的新登录也会被强制登出。
+### M-R12-1（Medium · 并发/数据完整性） · `BindRoles` 与 `DeleteRole` 之间无锁链，会留下孤儿 `sys_user_role`
 
-**影响**：
+**描述**：`internal/logic/user/bindRolesLogic.go` 在 `TransactCtx` 里只锁 `sys_product_member` 行（`FindOneForUpdateTx(member.Id)`），对即将绑定的 `sys_role` 行**完全不持锁**——连事务外的 `FindByIds` 也不 `FOR SHARE`。
 
-- **数据完整性**：密码这一核心凭证可被"被凭证泄露 / 旧会话持有"的攻击者用自己知道的旧密码，把管理员紧急修改过的密码盖回去——会话劫持的时间窗虽小但影响直接。
-- **安全合规**：信息安全审计侧若执行"强制改密"流程，这条 TOCTOU 是一条可以让强制改密语义悄悄失效的旁路。
-- **可观测**：审计链路上会出现"用户短时间内 password 连续变化 + tokenVersion 连加两次"的奇怪模式，排障成本高。
+同时 `internal/logic/role/deleteRoleLogic.go:41-56` 的 `DeleteRole` 在事务内依次：
 
-**修复方案**：把 `expectedUpdateTime` 改由调用方显式传入，彻底消除内部二次 FindOne 造成的"自对齐"：
-
-```go
-// sysUserModel.go
-UpdatePassword(ctx context.Context, id int64, username, password string,
-    mustChangePassword, expectedUpdateTime int64) error
-
-func (m *customSysUserModel) UpdatePassword(ctx context.Context, id int64,
-    username, password string, mustChangePassword, expectedUpdateTime int64) error {
-    sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
-    sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, username)
-    res, err := m.ExecCtx(ctx, func(ctx context.Context, conn sqlx.SqlConn) (sql.Result, error) {
-        query := fmt.Sprintf(
-            "UPDATE %s SET `password` = ?, `mustChangePassword` = ?, `tokenVersion` = `tokenVersion` + 1, `updateTime` = ? WHERE `id` = ? AND `updateTime` = ?",
-            m.table)
-        return conn.ExecCtx(ctx, query, password, mustChangePassword, time.Now().Unix(), id, expectedUpdateTime)
-    }, sysUserIdKey, sysUserUsernameKey)
-    ...
-}
+```
+FindUserIdsByRoleIdForUpdateTx(roleId) -- 对 sys_user_role WHERE roleId=R FOR UPDATE
+DeleteByRoleIdTx(sys_role_perm)
+DeleteByRoleIdTx(sys_user_role)        -- DELETE WHERE roleId=R
+DeleteWithTx(sys_role, id)             -- 只在这一步对 sys_role[R] 拿 X 锁
 ```
 
-调用方 `ChangePasswordLogic` 把已经持有的 `user.UpdateTime` / `user.Username` 透传（与 `IncrementTokenVersionIfMatch(id, username, expected)` 的签名风格对齐）。这样 CAS 的 expected 就是"外层用来校验旧密码的那一份快照"；只要 DB 里 updateTime 发生过任何变化（并发改密 / 改资料 / 冻结/解冻），都会 CAS 失败返回 `ErrUpdateConflict`，调用方按 409 映射返回"密码已被其他会话修改，请刷新后重试"，并提示用户重新登录确认。
-
-同时收益：
+即 `DeleteRole` 对 `sys_role[R]` 的 X 锁要到**事务最末**才拿。两个事务交错：
 
-- 外层的 `FindOne` 不再浪费（以前只用于校验旧密码，然后内层再打一次）；
-- `AdminResetPassword` 之类未来想复用本方法的路径，也必须显式承诺"基于某个观察到的 updateTime 改"，语义更清晰。
+```
+T0: BindRoles 读 FindByIds([R]) → role R 启用、ProductCode 匹配（事务外、无锁）
+T1: BindRoles 开启事务；锁 member 行；Diff 出 toAdd=[R]
+T2: DeleteRole 开启事务；FOR UPDATE sys_user_role WHERE roleId=R（索引 idx_role 上的 gap lock）
+T3: DeleteRole 删除 sys_role_perm / sys_user_role；DELETE FROM sys_role WHERE id=R
+T4: DeleteRole 提交（sys_role[R] 已不存在）
+T5: BindRoles BatchInsertWithTx(userId, R) —— 无 FK、无 UNIQUE(sys_role.id) 校验——插入成功
+T6: BindRoles 提交
+```
 
----
+最终：`sys_user_role` 中存在 `roleId=R` 的行但 `sys_role[R]` 已被删除。由于 schema 未声明外键（`perm.sql` 里 `FOREIGN_KEY_CHECKS=1` 仅作用于 session，未定义任何 FK），该孤儿不会在写入时报错。
 
-## ⚠️ 健壮性与性能建议 (Medium/Low)
+另一种交错（DeleteRole 先于 BindRoles 取到 sys_user_role 的 gap lock）可能导致 BindRoles 插入时阻塞，而后 `sys_role[R]` 已不在，BindRoles 仍然能成功写入 `sys_user_role(userId, R)`——同样产生孤儿。
 
-### M-R11-1（Medium · 安全/限流） · gRPC `SyncPermissions` / `GetUserPerms` 未挂 gRPC 入口限流
+**影响**：
 
-**描述**：HTTP 侧 `/api/perm/sync` 已挂 `serverCtx.SyncRateLimit`（`internal/handler/routes.go:195-206`），而 gRPC 的 `PermServer.SyncPermissions`（`internal/server/permserver.go:60-92`）与 `PermServer.GetUserPerms`（`:331-369`）既不做 IP 维度限流、也不做按 `appKey` 维度的限流：
+- **功能正确性**：`UserDetailsLoader.loadRoles` 使用 `INNER JOIN sys_role` 过滤掉 `status` 非 Enabled 或已删除的角色，孤儿行**不会**被加载成用户权限——用户行为侧无可见异常。
+- **数据不变式**：`sys_user_role.roleId` 指向不存在的 `sys_role.id` 违反隐式外键约束。单纯累积孤儿行成本低，但 `UserList` / `RoleList` / 运维排障时会看到"用户绑了一个查不到的角色 id" 的幽灵状态，需要另写清理脚本。
+- **触发概率**：极低。真实业务里 `DeleteRole` 是罕见操作，必须同产品同角色同时 BindRoles；实际运维每月一次即是顶配。但一旦触发修复成本（人工清洗）远高于事前防御。
 
-```60:66:internal/server/permserver.go
-func (s *PermServer) SyncPermissions(ctx context.Context, req *pb.SyncPermissionsReq) (*pb.SyncPermissionsResp, error) {
-	items := make([]pub.SyncPermItem, len(req.Perms))
-	for i, p := range req.Perms {
-		items[i] = pub.SyncPermItem{Code: p.Code, Name: p.Name, Remark: p.Remark}
-	}
+**修复方案**：在 `BindRoles` 的事务内对所有目标 `roleIds` 加 `SELECT ... FOR SHARE`（按 `id IN (...)` 排序取锁以避免死锁）：
 
-	result, err := pub.ExecuteSyncPerms(ctx, s.svcCtx, req.AppKey, req.AppSecret, items)
+```go
+// internal/logic/user/bindRolesLogic.go
+if err := l.svcCtx.SysUserRoleModel.TransactCtx(l.ctx, func(ctx, session) error {
+    if _, err := l.svcCtx.SysProductMemberModel.FindOneForUpdateTx(ctx, session, member.Id); err != nil {
+        return err
+    }
+    if len(roleIds) > 0 {
+        // 新增：对 toAdd/已有 roleIds 一并加 S 锁，形成与 DeleteRole.DeleteWithTx(sys_role) 的 X 锁链
+        if err := l.svcCtx.SysRoleModel.LockRolesForShareTx(ctx, session, roleIds); err != nil {
+            if errors.Is(err, sqlx.ErrNotFound) {
+                return response.ErrBadRequest("包含已被删除的角色ID")
+            }
+            return err
+        }
+    }
+    // ... 原有 existing / diff / delete / insert 逻辑 ...
+})
 ```
 
-`Login / RefreshToken / VerifyToken` 都各自持有 `GrpcLoginLimiter / GrpcRefreshLimiter / GrpcVerifyLimiter`，口径完整；唯独"产品服务端调用"这两个接口是裸调。
-
-**影响**：
-
-- `SyncPermissions` 内部要走"tx + LockByCodeTx 的 X 锁"；`appSecret` 一旦泄露，恶意方在没有限流兜底时可持续对同一 product 打高频同步请求，`LockByCodeTx` 会串行化但前置 `bcrypt.Compare(appSecret)` 的 CPU 开销（cost=10 默认 ~100ms）与 DB 短事务都会被放大，单点产品同步的尾延迟会被显著拉高。
-- `GetUserPerms` 会触发 `UserDetailsLoader.Load`，缓存未命中时回源多张表；同样的泄露凭证 + 枚举 `userId` 可打爆 DB。
+`SysRoleModel` 需新增：
 
-本条未能被"HTTP 层 SyncRateLimit"兜住，因为 gRPC 是独立监听端口（不同服务进程入口）。
+```go
+// LockRolesForShareTx 对一批角色行取 S 锁；DeleteRole 的 DeleteWithTx 会拿 sys_role[R] 的 X 锁
+// 来阻塞本 S 锁，从而让任一被并发删除的角色在 BindRoles 提交前被感知。
+LockRolesForShareTx(ctx context.Context, session sqlx.Session, ids []int64) error
+```
 
-**修复**：
+对应 SQL `SELECT 1 FROM sys_role WHERE id IN (?,?...) ORDER BY id LOCK IN SHARE MODE`。若命中行数 ≠ `len(ids)`，返回 `sqlx.ErrNotFound` 触发 `ErrBadRequest("包含已被删除的角色ID")`。
 
-- 在 `servicecontext.go` 增设 `GrpcSyncLimiter` / `GrpcGetUserPermsLimiter`（配额取决于真实产品数和 QPS，例如单 product 每分钟 60 次同步 / 1k 次 perm 查询），按 `fmt.Sprintf("grpc:sync:%s", req.AppKey)` / `fmt.Sprintf("grpc:perms:%s", req.AppKey)` 为 key，避免按 IP（产品后端多实例共享 egress IP 时会误伤）；
-- `GetUserPerms` 可以同时叠加按 IP 维度，防止同一合法产品多个后端实例在 DDoS 场景下集体被耗尽配额。
+等价做法：`DeleteRole` 把 `FOR UPDATE sys_role[id]` 提前到事务第一步，等价形成 "X lock on sys_role → 所有写入 sys_user_role(roleId=R) 的事务要么先完成要么被阻塞"。两者择一。
 
 ---
 
-### M-R11-2（Medium · DB 性能） · `UpdateStatus` / `IncrementTokenVersion` 只为构造 cache key 而多打一次 `FindOne`
+### L-R12-1（Low · 缓存一致性） · `UpdateProfileWithTx` 族把 sqlc 缓存失效做在事务提交**之前**，存在窗口
 
-**描述**：与 H-R11-1 同属"内部 FindOne 冗余"族，但这两处只影响性能而不破坏正确性：
+**描述**：`internal/model/user/sysUserModel.go:147-171` 的 `UpdateProfileWithTx` 把 UPDATE 语句丢给调用方传入的 `session` 执行，外层仍然用 `m.ExecCtx` 包裹以复用"成功后 DelCache"语义：
 
-```161-182:internal/model/user/sysUserModel.go
-func (m *customSysUserModel) UpdateStatus(ctx context.Context, id int64, status int64, expectedUpdateTime int64) error {
-	data, err := m.FindOne(ctx, id)
-	if err != nil {
-		return err
-	}
+```147:171:internal/model/user/sysUserModel.go
+func (m *customSysUserModel) UpdateProfileWithTx(ctx context.Context, session sqlx.Session, id int64,
+    username string, nickname, email, phone, remark string, deptId, newStatus int64,
+    statusChanged bool, expectedUpdateTime int64) error {
+    if session == nil {
+        return errors.New("UpdateProfileWithTx requires a non-nil session")
+    }
+    sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
+    sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, username)
+    now := time.Now().Unix()
 
-	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
-	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
-	...
+    res, err := m.ExecCtx(ctx, func(ctx context.Context, _ sqlx.SqlConn) (sql.Result, error) {
+        // 🔴 使用 session 执行（事务内），但 m.ExecCtx 仍在闭包返回后立即 DelCache
+        return session.ExecCtx(ctx, query, ...)
+    }, sysUserIdKey, sysUserUsernameKey)
 ```
 
-```190-221:internal/model/user/sysUserModel.go
-func (m *customSysUserModel) IncrementTokenVersion(ctx context.Context, id int64) (int64, error) {
-	data, err := m.FindOne(ctx, id)
-	if err != nil {
-		return 0, err
-	}
+`go-zero` 的 `cachedSqlConn.ExecCtx` 行为：**先执行 exec 闭包，闭包返回成功后调用 `DelCacheCtx`**。这里的"成功"是指 `session.ExecCtx` 写入受影响行数 ≥ 1——而**事务此时尚未 commit**。
+
+并发窗口：
 
-	sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
-	sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, data.Username)
+```
+T0: UpdateUserLogic.TransactCtx 入口 → UpdateProfileWithTx 内
+T1: session.ExecCtx 执行 UPDATE —— 行被锁，undo log 生成，但 tx 尚未 commit
+T2: m.ExecCtx 包装器 DelCache(idKey, usernameKey) —— sysUser 低层缓存被清
+T3: UpdateProfileWithTx 返回
+T4: 另一只请求 R 打进来，走 UserDetailsLoader.Load → cache miss → loadUser → SysUserModel.FindOne(id)
+    FindOne 走独立连接走默认 RC 隔离级别：看到的是 T1 未提交的旧行，写回 sysUser 低层缓存 = 旧值
+    → loadFromDB 得到旧 UserDetails → 5 分钟正缓存
+T5: UpdateUserLogic 的 TransactCtx 真正 commit —— DB 已是新值
+T6: UpdateUserLogic 调用 UserDetailsLoader.Clean(userId)
+    → DEL 所有产品下 UserDetails 缓存，解除窗口
 ```
 
-两处 `FindOne` 的唯一作用都是取 `username` 构造 `cacheSysUserUsernamePrefix` 键；真正的并发安全依赖外层 `expectedUpdateTime` 或 `IncrementTokenVersion` 自己的 `RowsAffected==0 → ErrUpdateConflict` 兜底，`data` 对象其他字段并没有参与逻辑。
+`T4 - T6` 之间用户的 UserDetails 缓存里仍然是 T1 之前的旧值——包括 `DeptId / DeptPath / Status / TokenVersion`。由于 `UpdateUserLogic` 走 `UpdateProfileWithTx` 的唯一分支是"改 deptId 到新部门"（审计 M-R11-3 锁链的 happy path），窗口里被并发 Load 的用户会看到"旧部门 / 旧 path"，继续被按原 dept 做管辖决策。
 
-- `UpdateStatus` 的调用方 `UpdateUserStatusLogic` 事前已经从 `ValidateStatusChange` 拿到 `sysUser`——`sysUser.Username` 就在手里；
-- `IncrementTokenVersion` 的唯一调用方 `LogoutLogic` 从 middleware 拿到 `userId`，没有 username，但只要上游 `ud, _ := UserDetailsLoader.Load(...)` 已经拉过用户详情，一样可以透传。
+窗口长度 ≈ session.ExecCtx 返回 → TransactCtx commit 之间的时长，正常路径下只有毫秒级。
 
 **影响**：
 
-- 每次 Logout / 冻结解冻各多一次 cache/DB round-trip；Logout 通常叠加 `TokenOpLimiter`，调用量不大；
-- 但"冗余 FindOne"会占一个连接池槽位，在登录/登出高峰（比如统一挂维护后全员重新登录）会放大尾延迟。
-
-**修复**：把 username 显式提到函数签名，与 `IncrementTokenVersionIfMatch(id, username, expected)` 口径对齐：
-
-```go
-UpdateStatus(ctx, id, username, status, expectedUpdateTime int64) error
-IncrementTokenVersion(ctx, id, username int64) (int64, error)
-```
-
-调用方：
-
-- `UpdateUserStatusLogic` 传 `user.Username`；
-- `LogoutLogic` 在限流已经通过的前提下，先 `ud := UserDetailsLoader.Load(...)`（Logout 本就会走到 Load），把 `ud.Username` 传进来。
-
-顺带把"内部 FindOne → ErrUpdateConflict 能正确触发"这条隐性依赖显式化，未来有人重构把内部 FindOne 挪走也不会把 CAS 语义改坏。
+- **功能正确性**：`UpdateUserLogic:202` 在 `TransactCtx` 外调用 `UserDetailsLoader.Clean(req.Id)` 做 post-commit 失效，窗口会被 Clean 关闭。但**窗口内**被 populate 的 UserDetails 正缓存会留到下一次 Clean 时才失效，中间的 5 分钟 TTL 内仍按旧值。
+- **安全侧**：管辖链（checkDeptHierarchy）以缓存中的 DeptPath 为准；窗口内若 caller 恰好是"旧 deptPath 下的 MEMBER"且目标用户刚被调离，caller 仍可能在短时间内成功下发敏感操作（例如 `UpdateUser nickname`）。对强一致保护的 `checkPermLevel` / `loadFreshMinPermsLevel` 已走 NoCache DB 路径，因此越权决策不受影响；但列表展示、soft 的权限检查会短暂失真。
+- **概率**：窗口毫秒级，真实业务下几乎观测不到。但该模式被大量使用（任何 `m.ExecCtx` 包装 `session.ExecCtx` 的 `*WithTx` 方法都有同样行为），具备跨文件一致性问题的特征。
+
+**修复方案**：
+
+- **方案 A（推荐）**：在 `UpdateProfileWithTx` 这类事务性方法中**不要**复用 `m.ExecCtx` 的 DelCache 语义。把缓存失效挪到**事务提交之后**由调用方（Logic 层）执行。具体做法：
+  ```go
+  // model 层只做 session.ExecCtx；失效由调用方显式 DelCache（idKey, usernameKey）
+  func (m *customSysUserModel) UpdateProfileWithTx(...) error {
+      if session == nil { return errors.New(...) }
+      res, err := session.ExecCtx(ctx, query, ...)
+      if err != nil { return err }
+      if affected, _ := res.RowsAffected(); affected == 0 {
+          return ErrUpdateConflict
+      }
+      return nil
+  }
+  // model 层额外暴露 "缓存失效" helper，上游 TransactCtx commit 成功后显式调用
+  func (m *customSysUserModel) InvalidateUser(ctx context.Context, id int64, username string) {
+      idKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
+      userKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, username)
+      _ = m.DelCacheCtx(ctx, idKey, userKey)
+  }
+  ```
+  `UpdateUserLogic` 在 `TransactCtx` 返回后先调 `InvalidateUser`、再 `UserDetailsLoader.Clean`。
+- **方案 B**：保留当前实现，但在文档里明确"`*WithTx` 的缓存失效是 best-effort 的 pre-commit 清理，强一致读一律走 `...ForUpdateTx / ForShareTx` 事务内查询"。当前代码已经隐式这么做（决策点都走 `loadFresh*`），可视为**已接受的契约**。
+
+我们倾向方案 A——事务语义一致性比 pre-commit 清掉一次缓存的微小收益更重要。
 
 ---
 
-### M-R11-3（Medium · 数据完整性/竞态） · `DeleteDept` 与 `UpdateUser.deptId` 之间的 write skew
+### L-R12-2（Low · 逻辑一致性） · `CreateDept` 事务内不复核 `parent.Status`，可在"父部门刚被禁用"时插入新子部门
 
-**描述**：`internal/logic/dept/deleteDeptLogic.go:36-69` 的策略是：
+**描述**：`internal/logic/dept/createDeptLogic.go:46-72`
 
 ```
-DeleteDept tx:
-  ① SELECT sys_dept WHERE id=? FOR UPDATE     -- X 锁目标部门
-  ② SELECT sys_dept WHERE parentId=? FOR SHARE -- S 锁确认无子部门
-  ③ SELECT sys_user WHERE deptId=? FOR SHARE   -- S 锁确认无关联用户
-  ④ DELETE sys_dept WHERE id=?
+① 事务外 FindOne(parentId) —— 读到 parent.Status=Enabled，捕获 parentPath
+② 事务内 SELECT id FROM sys_dept WHERE id=? FOR SHARE —— 只校验"父部门存在"
+③ InsertWithTx(子部门) —— 继承 parentPath、Status=Enabled
 ```
 
-`UpdateUser` 在修改 `deptId` 为目标部门时，只对 `sys_dept` 做不加锁的 `FindOne` 验证"目标部门存在且 Enabled"，然后在自己的事务里对 `sys_user` 行取 X 锁写新 `deptId`（`internal/logic/user/updateUserLogic.go:110-137`、`internal/model/user/sysUserModel.go:105-126`）。
-
-两个事务交错：
+步骤②只看 `id` 是否仍存在，不读 `Status`。如果两个事务：
 
 ```
-T1: DeleteDept
-    ①②③ 都通过：sys_user.deptId=X 为空
-    （尚未 commit）
-T2: UpdateUser.deptId=X
-    读 sys_dept[X] 的 RR 快照：Status=Enabled（T1 尚未 commit）
-    X 锁 sys_user[userY]，写 deptId=X
-    T2 提交
-T1: ④ DELETE sys_dept[X]，提交
-最终：sys_user[userY].deptId=X, sys_dept[X] 已删除 → 悬挂 deptId
+T0: UpdateDept 开启事务，持有 sys_dept[P] 的 X 锁，把 Status 改成 Disabled
+T1: CreateDept 的步骤① 已经在 T0 之前发生，读到 P.Status=Enabled（提交可见版本）
+T2: T0 commit —— sys_dept[P].Status=Disabled
+T3: CreateDept 开启事务（T2 之后），步骤② 的 FOR SHARE 看到 P 存在，放行
+T4: 子部门插入成功：子部门 Status=Enabled，父部门 Status=Disabled
 ```
 
-T1 的 `FOR SHARE ON sys_user WHERE deptId=X` 对"将要变成 X 但目前不是 X"的行没有锁效力：InnoDB 的 gap lock 只覆盖 `deptId` 列现有的索引范围，`userY` 当前 `deptId=Y` 不在 T1 的锁范围。反向 T2 对 `sys_dept[X]` 是无锁读，看不到 T1 的 X 锁。这是典型的 `write skew`。
+> 注：`UpdateDept` 走 `UpdateWithOptLock`，只要它拿到行锁后 CAS 成功即 commit；不与 `CreateDept` 的 FOR SHARE 同处一个锁链外的范围。
 
 **影响**：
 
-- 只要并发删部门 + 调整用户部门同时发生就会留下"deptId 指向已删除部门"的 orphan 行；
-- 后续 `DeptTree` / `UserList` 渲染时，这些用户找不到 dept path，会落回"default / 空 path"分支——所有非超管/非产品 ADMIN 的管辖判定全部对该用户失效（管他们的人发现人没了，被管的人发现管理员找不到自己）；
-- 真实业务概率：极低（单日内 DeleteDept + 把某人加进这个部门同时点提交的窗口只有毫秒级）。但一旦触发修复成本高（只能靠运维手 SQL 清洗）。
-
-**修复方案**：二选一。
-
-1. **对 `sys_user.deptId` 用 FOR UPDATE 并补 gap lock**（推荐）：把 `FOR SHARE` 改成 `FOR UPDATE`，并在 `sys_dept.id` 列上（以及 `deptId` 外键索引）依赖 next-key lock。这会把"向这个 deptId 写入的 UpdateUser"阻塞到 DeleteDept 提交或回滚。代价：DeleteDept 持锁时间变长，但 DeleteDept 极其低频。
-2. **在 `UpdateUser` 里对目标 `sys_dept` 加 `FOR SHARE`**：UpdateUser 事务内先 `SELECT sys_dept WHERE id=? FOR SHARE`，然后再做 `sys_user` 的 X 锁写。这样 DeleteDept 的 X 锁会把 UpdateUser 的 S 读阻塞，形成一致锁链。代价：UpdateUser 的一次查询变成锁读，但 dept 查询本来就走缓存，打穿到 DB 的比例很低。
-
-两种方案等价化解 write skew。推荐 2（把锁链约束放在"新行写入方"上更自然，也与 `CreateDept` 在插子部门前对 `parentId FOR SHARE` 的现有策略口径一致）。
-
----
+- **loadPerms 语义**：`UserDetailsLoader.loadPerms` 只用 `ud.DeptType / ud.DeptStatus`——即当前用户所在部门的 type / status——不递归向上看父部门，子部门 Enabled 完全可以独立工作，业务语义不破。
+- **运营观感**：管理员"禁用整个部门子树"的意图被绕过，禁用父部门后若 CreateDept 正在进行，会看到一个 Enabled 子部门挂在 Disabled 父部门下，排障困难。
+- **概率**：极低（人工操作时序 + 同部门并发）。
 
-### L-R11-1（Low · 逻辑一致性/契约） · `UpdateMember` 对 `memberType` 空串直接 400，丧失"只改 status"语义
+**修复方案**：在事务内把 `SELECT id` 升级成 `SELECT id, status, path FOR SHARE`，并同时复核 Status 与 Path：
 
-此条在前轮 M-4 / L-5 系列修复中被反向推导过，R10 未列；本次复核明确为**接口契约问题**。
-
-**描述**：`UpdateMember` 的 `types` 中 `MemberType` / `Status` 都是非指针必传字段。如果 admin 想只改 member 状态（冻结其产品成员资格），必须重传一份完整的 `memberType`；前端直接传空会被拦 400。这一约束与 HTTP API 的"部分更新"直觉不符。
-
-**影响**：前端要么自己维护"原 memberType"在内存（多一个状态源），要么多打一次 member.detail 接口；属于接口易用性问题，不涉及安全。
+```go
+var parent deptModel.SysDept
+lockQ := fmt.Sprintf("SELECT `id`, `status`, `path` FROM %s WHERE `id`=? FOR SHARE", l.svcCtx.SysDeptModel.TableName())
+if err := session.QueryRowCtx(ctx, &parent, lockQ, req.ParentId); err != nil {
+    return response.ErrNotFound("父部门已被删除")
+}
+if parent.Status != consts.StatusEnabled {
+    return response.ErrBadRequest("父部门已被禁用，无法创建子部门")
+}
+parentPath = parent.Path  // 改为使用事务内视图里的 path，理论上与事务外一致（UpdateDept 不改 path）
+```
 
-**修复**：把 `memberType` / `status` 改成 `*string` / `*int64`，为 nil 时表示不改该字段；logic 侧按 nil/非 nil 分支分别处理校验，和 `UpdateUserReq` 的可选字段风格对齐。
+顺手覆盖一个边界：即使未来 `UpdateDept` 扩展为支持"重命名 path"，本修复也已经在事务内 snapshot 了最新 path。
 
 ---
 
-### L-R11-2（Low · DB 性能） · `DisableNotInCodesWithTx` 与 `DeleteBy...Tx` 族把"整行 SELECT"当作"取缓存 key"的手段
+### L-R12-3（Low · 僵尸代码 / 文档一致性） · `updateRoleLogic.go` 的注释"非超管不得降低 PermsLevel"与实际代码相反
 
-**描述**：`internal/model/perm/sysPermModel.go:100-164`、`internal/model/userrole/sysUserRoleModel.go:105-166`、`internal/model/roleperm/sysRolePermModel.go:86-130`、`internal/model/userperm/sysUserPermModel.go:45-66` 都遵循同一结构：
+**描述**：`internal/logic/role/updateRoleLogic.go` 中非超管的权限级别校验使用 `req.PermsLevel < role.PermsLevel`。在本项目的约定下"数字越小权限越高"（见 `UserDetailsLoader.loadRoles: MinPermsLevel` 计算），因此 `req.PermsLevel < role.PermsLevel` 实际拦截的是**提升权限**，而代码注释却写成"防止降低 PermsLevel"。
 
-```
-SELECT <全部列> FROM ... WHERE ... FOR UPDATE
-拼 cache keys
-UPDATE/DELETE ... WHERE <同样条件>
-```
-
-这里"SELECT 整行"的唯一用途是取 `id` 与构成缓存 key 的两三个字段（`Code / ProductCode / UserId / RoleId / PermId`）。真正需要的列最多 3 个，却把 `Name / Remark / Status / CreateTime / UpdateTime` 等字段全部搬运到应用层再丢弃。
+本条之前在 R11 审计里已经被口头标记，但未修。核心 bug 不存在——非超管的 `UpdateRole` 只有 product ADMIN 能进入，product ADMIN 在产品内有全权，提升 / 降低都不是越权；真正的边界是 `BindRoles` 的 `GuardRoleLevelAssignable`。但注释与代码反向的现状会让新维护者以为策略写错了，走入方向相反的"修复"最后引入真 bug。
 
 **影响**：
 
-- 对单次 SyncPerms（涉及 <1k 条 perm）或单次 BindRoles（<30 role）影响很小；
-- 在 `DeleteByRoleIdTx` 场景（`DeleteRole` 会级联删除所有 `sys_user_role WHERE roleId=?`，后续会对"受影响用户列表"做批量 cache 失效），被"关联成百上千用户"的角色删除时会显著增加 goroutine 临时内存与网络 I/O；
-- 另外 `session.QueryRowsCtx(list)` + `len(list)==0` 提前 return 的"先查后写"模式，每次删除都付出一次"完整行读回"的成本，哪怕是单行删。
-
-**修复**：把所有"只是为构 cache key"的 SELECT 精简到只取必要列；或者只取 `id / (user, role) / (role, perm)` 等 key 组件，省略业务字段。例如：
+- **运行期**：零。
+- **维护期**：高——误导性注释是 R10 ~ R12 三轮审计里被反复关注的工作量。
 
-```go
-// 只取 id + (productCode, code)
-var rows []struct {
-    Id          int64  `db:"id"`
-    ProductCode string `db:"productCode"`
-    Code        string `db:"code"`
-}
-```
-
-对"单行删除"路径（如 `DeleteByRoleIdAndPermIdsTx` 只有一个 permId）甚至可以直接由调用方传 key，不再反查。
+**修复方案**：只改注释，把"防止降低"改成"防止非超管把角色提升到比当前更高的权限（数字更小 = 更高权）"，并在同一行把"数字越小 = 权限越高"这条约定显式写出来。
 
 ---
 
-### L-R11-3（Low · 边界 / 缓存一致性） · `UpdateProfile` 不支持改 `username`，但签名暴露 `username` 参数，易被后续误用
+### L-R12-4（Low · 契约 · 已接受） · `GetUserPerms` 对"合法成员但被冻结"仍返回 `PermissionDenied`，可用于"合法成员 × 冻结态"枚举
 
-**描述**：`internal/model/user/sysUserModel.go:105-126`
+**描述**：`internal/server/permserver.go:348-354`
 
 ```go
-func (m *customSysUserModel) UpdateProfile(ctx context.Context, id int64, username string,
-    nickname, email, phone, remark string, deptId, newStatus int64,
-    statusChanged bool, expectedUpdateTime int64) error {
-    sysUserIdKey := fmt.Sprintf("%s%v", cacheSysUserIdPrefix, id)
-    sysUserUsernameKey := fmt.Sprintf("%s%v", cacheSysUserUsernamePrefix, username)
-    ...
-    // SET 语句里没有 `username`=?
+if ud.Username == "" || (!ud.IsSuperAdmin && ud.MemberType == "") {
+    return nil, status.Error(codes.NotFound, "用户不是该产品的有效成员")
+}
+if ud.Status != consts.StatusEnabled {
+    return nil, status.Error(codes.PermissionDenied, "用户已被冻结")
+}
 ```
 
-入参有 `username`、但 UPDATE 里不写这个列；它只被用作"构造旧缓存 key"。未来若某人认为"签名已经带了 username，那 UpdateProfile 应该也能顺手改 username"并往 SET 里加上 `username=?`，会立刻出现：
+- `NotFound` 同时覆盖"用户全局不存在"和"用户存在但非本产品成员"——这是 L-R10-10 封死的枚举窗口。
+- `PermissionDenied` 仍显式披露"用户是本产品成员且当前冻结"。
 
-- 新 username 还未在缓存键 `cacheSysUserUsernamePrefix` 删除旧值，stale 缓存残留；
-- 且没有处理 `sys_user.username` UNIQUE 约束违反的 1062 回滚。
+持有合法 `appKey + appSecret` 的产品在 `userId` 区间内扫描即可建立"该产品下哪些成员被冻结"的映射。在 `appSecret` 泄露后这是一条信息泄露面。
 
-**影响**：当前代码功能正确，属于"签名 / 语义鸿沟"。若维护同学出于"方便"扩展此函数支持改 username 就会踩坑。
+**影响**：
 
-**修复**：
+- 只有合法产品服务端可触发（凭 `bcrypt` 通过 appSecret 校验），攻击前提较高。
+- 当前版本的安全侧评估（注释中明示）："密码正确才能拿到合法 appKey 这一前提不成立时，这个状态已经是上层业务承诺披露的信息，不构成新增枚举面。"
 
-- 文档化：在 `UpdateProfile` 的 Go doc 里显式说明"本方法不负责修改 `username`；`username` 参数仅用于旧缓存键构造"；
-- 或更保险：把这个函数拆成"不关心 username"的纯写入 + 调用方自己按 (id, oldUsername) 做缓存失效；
-- 未来若真要支持改 username，做成独立的 `UpdateUsernameTx`，内部处理"新/旧 username 两份缓存键清理 + 1062 捕获"。
+**结论**：保持现状作为已接受契约，不纳入 P0/P1。若未来"冻结状态"被列为 PII 敏感属性（目前不是），改为统一回 `NotFound "用户不是该产品的有效成员"` 即可。
 
 ---
 
-### L-R11-4（Low · 资源管理） · `UserDetailsLoader.CleanByProduct` 扫描缓存前缀的放大效应
+### L-R12-5（Low · 安全信号最小化） · `AdminLogin` 对"冻结超管"与"成功超管"的时序差可观测
 
-**描述**：`SyncPerms` 成功后调用 `UserDetailsLoader.CleanByProduct(ctx, product.Code)`（`internal/logic/pub/syncPermsService.go:163`）。该方法（见 `loaders/userDetailsLoader.go` 实现）通常基于前缀批量失效该产品名下所有用户的详情缓存。
+**描述**：`internal/logic/pub/adminLoginLogic.go:76-86`
 
-在"单 product <1k 活跃成员"的真实业务量下没有问题；但 `SyncPerms` 属于高频事件（产品每次部署都会触发，一天数十次），且 `CleanByProduct` 会把该产品**所有**活跃用户的缓存（含各自的 `Perms / Member / Role` 计算结果）一次性清掉，使得紧随其后的大量在线请求都会打穿缓存到 DB。
-
-**影响**：
-
-- 正常 SyncPerms（新增一两条 perm）其实只影响"已经引用到这些新 perm 的角色的用户"，却连同未动过的 `loadPerms` 缓存一并清空；
-- 产品发版时很容易出现"发版后 5 分钟 TPS 打到 DB，缓存命中率陡降"的尾部抖动。
-
-**修复**：
+```
+① bcrypt.CompareHashAndPassword  -- real
+② if u.Status != Enabled → 401
+③ UserDetailsLoader.Load(u.Id, "")
+④ GenerateAccessToken + GenerateRefreshToken
+```
 
-- 方案一：只在 `Added/Updated/Disabled` 里对"发生状态变化的 code 集合"构建失效名单（按 role → user 反推），代价是扫描关联表（小量级 OK）；
-- 方案二：保留当前实现但在 `CleanByProduct` 里做 jitter（比如按 userId 哈希分批清，而非一次性全清），缓解"雪崩清空"。
+对冻结超管：①+② 耗时 ≈ 100ms（bcrypt 为主），不走 ③④。
+对正常超管：①+②+③+④ 耗时 ≈ 100ms + 若干 DB 查询 + 两次 HMAC 签名 ≈ 150 ms+。
 
----
+两种路径时序差约 10~50 ms，可被外部远程计时攻击用来区分"存在的超管被冻结" vs "存在的超管密码错误（相同 100ms）" vs "存在的超管成功（更长）"。
 
-### L-R11-5（Low · 僵尸代码 / 契约一致性） · `RefreshToken` 两条路径的 `newVersion != predictedVersion` 分支实际不可达（重申 L-R10-4）
+但该时序差**必须**已经持有正确超管密码才能被触发——攻击者需要先爆破出密码，再用 1000+ 请求做计时统计推断冻结。实际威胁模型下，拿到密码的人不 care "是否被冻结"。
 
-R10-4 已记录本点。本轮复核确认 HTTP 与 gRPC 两条 RefreshToken 路径（`internal/logic/pub/refreshTokenLogic.go:117-135`、`internal/server/permserver.go:240-251`）的 forensic 分支仍然保留，没有被收敛到一个共享 helper。
+**影响**：
 
-**影响**：零运行期影响；纯代码重复 + 维护负担。
+- 实际风险极低；历史审计已归档为"可接受时序差"。
+- 本条作为 R12 复核条目**重申**——不列 P0/P1。
 
-**修复**：把"试签 → CAS → Clean → 对比 newVersion"整段抽成 `authHelper.RotateRefreshToken(ctx, svcCtx, claims, ud) (access, refresh string, err error)`，让 HTTP / gRPC 只负责前置校验与错误映射。这样未来 CAS 语义若要微调（例如把预签下沉到 tx 内），两条路径只改一处。
+**结论**：保持现状。如果合规侧（SOC2 / CC）要求所有"已存在账户" vs "不存在账户"分支必须同质化，可把 `③④` 抽到冻结分支里空跑一次（discard 结果），进一步把时序差压到 <5 ms。当前优先级低。
 
 ---
 
 ## 本轮复核中仍成立的契约（不再修）
 
-列出以下事项作为已定档契约，审计不再要求整改：
-
 - **H-1 / R10 复核**：`UserDetail` / `MemberList` 同产品成员可见彼此 `email / phone / remark` —— 产品业务需求已确认保留。
 - **M-4 / R10 复核**：`CreateProduct` 响应体只返回一次性 ticket，真实 `appSecret / adminPassword` 通过 `/fetchInitialCredentials`（超管鉴权 + `GetDelCtx` 原子消费）领取。
 - **M-3 / H-2 / R10 复核**：授角色、管辖决策点 100% 走 NoCache DB 读（`loadFreshMinPermsLevel`），caller 的 `MinPermsLevel` 缓存不参与决策；TTL 不影响越权闭环。
-- **L-R10-4**：RefreshToken 的 `newVersion != predictedVersion` 分支保留 forensic 兜底，本轮新建议（L-R11-5）仅涉及"把两处重复抽象成一处"，不改变契约。
-- **L-R10-7**：`PermList` / `RoleList` 对同产品成员可见全量定义。属业务默认约定。
+- **L-R10-4 / R11 复核**：RefreshToken 的 `newVersion != predictedVersion` 分支保留 forensic 兜底；R11 通过 `authHelper.RotateRefreshToken` 将 HTTP / gRPC 两条路径收敛到同一 helper，已消除代码重复。
 - **L-R10-8**：`loadPerms` 对 SUPER / ADMIN / DEVELOPER 忽略 DENY 的语义已在 `SetUserPerms` 入口拦截；`DeptType` 动态变动导致旧 DENY 失效的长尾遗留。
 - **L-R10-9**：代理层 X-Forwarded-For 链一致性由运维侧在反代/WAF 上硬约束。
+- **L-R12-4 / L-R12-5**：已在上文明示为接受契约，不纳入本轮修复窗口。
 
 ---
 
@@ -345,11 +289,20 @@ R10-4 已记录本点。本轮复核确认 HTTP 与 gRPC 两条 RefreshToken 路
 
 | 优先级 | 条目 | 理由 |
 | ---- | ---- | ---- |
-| P0 | **H-R11-1** | 涉及密码本身的 last-write-wins；修复即放弃一条会话劫持旁路。下一迭代必修。 |
-| P1 | M-R11-1 | gRPC 入口限流缺口；产品接入方越多风险敞口越大，建议排入下迭代 |
-| P1 | M-R11-3 | write skew 罕见但数据无法自愈，连带修 `UpdateUser` 的锁链建议一次做完 |
-| P2 | M-R11-2 | 性能与观测性改进；顺带提升 `UpdateStatus / IncrementTokenVersion` 的语义清晰度 |
-| P2 | L-R11-1 | 前端易用性；可并到"接口契约梳理"专项 |
-| P3 | L-R11-2 ~ L-R11-5 | 代码质量/性能优化；触及相关文件时顺手处理即可 |
-
-整体代码质量在 10 轮迭代后已高度收敛，本轮只发现**一条** High（H-R11-1，存在可复现的 TOCTOU）与**三条** Medium；核心授权 / 会话 / 数据持久化三条链路的主干逻辑仍然稳健，历史修复契约未发生回退。
+| P1 | **M-R12-1** | `BindRoles`+`DeleteRole` 孤儿行；概率低但人工清洗成本高，排入下个迭代 |
+| P2 | L-R12-1 | `*WithTx` 缓存失效时机；窗口毫秒级但属于"跨文件一致性模式"，顺手梳理一批 |
+| P2 | L-R12-2 | `CreateDept` 父部门 Status 复核；用 `SELECT ... FOR SHARE` 顺带多取两列 |
+| P3 | L-R12-3 | 注释与代码反向；纯文档修复 |
+| —  | L-R12-4 / L-R12-5 | 已归档为可接受契约 |
+
+---
+
+## 复核结论
+
+经过 11 轮迭代 + 本轮（12）深度复核，`perms-system/server` 的核心授权 / 会话 / 数据持久化三条链路已达到一线生产系统的水准：
+
+- **High Risk 本轮为 0**：上轮 H-R11-1 的 TOCTOU 已被 `expectedUpdateTime` 显式透传修正；未发现新的可直接越权 / 篡改 / 伪造会话的路径。
+- **Medium 本轮 1 条**：M-R12-1（`BindRoles`+`DeleteRole` 锁链缺口）属于"罕见但数据无法自愈"的典型，修复成本低，推荐下个迭代处理。
+- **Low 本轮 5 条**：L-R12-1 ~ L-R12-5 全部落在"缓存一致性 / 文档一致性 / 已接受信号泄露"的维度，均不影响主功能正确性。
+
+R11 闭环的 7 条（H-R11-1、M-R11-1/2/3、L-R11-1/4/5）在代码中均可检验到修复并配有审计注释，未出现历史修复回退。整体代码质量持续收敛，剩余建议多属"工艺与可维护性"级别的打磨。

internal/handler/auth/changePasswordHandler.go

@@ -12,6 +12,7 @@ import (
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/types"
 )
+
 // ChangePasswordHandler 修改密码接口。验证原密码后设置新密码，令牌即时失效。
 func ChangePasswordHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {

internal/handler/auth/changePasswordHandler_test.go

@@ -0,0 +1,54 @@
+package auth
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"perms-system-server/internal/response"
+	"perms-system-server/internal/svc"
+	"perms-system-server/internal/testutil"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TC-0798: handler 薄层契约 —— ChangePasswordHandler 在 body 非法 JSON 时必须 400,
+// 且错误文案定位到解析错误而不是"密码错误"之类的 logic 层语义。
+func TestChangePasswordHandler_MalformedBodyReturns400(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	handler := ChangePasswordHandler(svcCtx)
+
+	req := httptest.NewRequest(http.MethodPut, "/api/auth/password", strings.NewReader("{not-json"))
+	req.Header.Set("Content-Type", "application/json")
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	var body response.Body
+	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &body))
+	assert.Equal(t, 400, body.Code,
+		"handler 必须把 httpx.Parse 的错误包成 400; 旧实现有时会被吞成 500")
+	assert.NotContains(t, body.Msg, "原密码", "400 的文案不应提到 logic 层的业务字段语义")
+}
+
+// TC-0799: handler 薄层契约 —— ChangePasswordHandler 在缺必填字段时也必须 400,
+// 这是 goctl 生成代码最容易退化的地方 (把 optional 错设成 required 或反之)。
+func TestChangePasswordHandler_MissingFieldsReturns400(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	handler := ChangePasswordHandler(svcCtx)
+
+	req := httptest.NewRequest(http.MethodPut, "/api/auth/password", strings.NewReader("{}"))
+	req.Header.Set("Content-Type", "application/json")
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	var body response.Body
+	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &body))
+	assert.Equal(t, 400, body.Code)
+	// 必填字段缺失应该精确到字段名, 便于客户端自动纠错
+	assert.True(t,
+		strings.Contains(body.Msg, "oldPassword") || strings.Contains(body.Msg, "newPassword"),
+		"缺字段文案必须点名到 oldPassword / newPassword; 实际: %q", body.Msg)
+}

internal/handler/auth/logoutHandler.go

@@ -10,6 +10,7 @@ import (
 	"perms-system-server/internal/logic/auth"
 	"perms-system-server/internal/svc"
 )
+
 // LogoutHandler 用户注销接口。使所有已签发令牌立即失效并清除缓存。
 func LogoutHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {

internal/handler/auth/handler_contract_audit_test.go → internal/handler/auth/logoutHandler_test.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
-	"strings"
 	"testing"
 	"time"
 
@@ -74,41 +73,3 @@ func TestLogoutHandler_SuccessIncrementsTokenVersion(t *testing.T) {
 	assert.Equal(t, int64(1), u.TokenVersion,
 		"handler 必须真正触达 logic 层; tokenVersion 未递增说明 handler 伪装成功")
 }
-
-// TC-0798: handler 薄层契约 —— ChangePasswordHandler 在 body 非法 JSON 时必须 400,
-// 且错误文案定位到解析错误而不是"密码错误"之类的 logic 层语义。
-func TestChangePasswordHandler_MalformedBodyReturns400(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	handler := ChangePasswordHandler(svcCtx)
-
-	req := httptest.NewRequest(http.MethodPut, "/api/auth/password", strings.NewReader("{not-json"))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-	handler.ServeHTTP(rr, req)
-
-	var body response.Body
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &body))
-	assert.Equal(t, 400, body.Code,
-		"handler 必须把 httpx.Parse 的错误包成 400; 旧实现有时会被吞成 500")
-	assert.NotContains(t, body.Msg, "原密码", "400 的文案不应提到 logic 层的业务字段语义")
-}
-
-// TC-0799: handler 薄层契约 —— ChangePasswordHandler 在缺必填字段时也必须 400,
-// 这是 goctl 生成代码最容易退化的地方 (把 optional 错设成 required 或反之)。
-func TestChangePasswordHandler_MissingFieldsReturns400(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	handler := ChangePasswordHandler(svcCtx)
-
-	req := httptest.NewRequest(http.MethodPut, "/api/auth/password", strings.NewReader("{}"))
-	req.Header.Set("Content-Type", "application/json")
-	rr := httptest.NewRecorder()
-	handler.ServeHTTP(rr, req)
-
-	var body response.Body
-	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &body))
-	assert.Equal(t, 400, body.Code)
-	// 必填字段缺失应该精确到字段名, 便于客户端自动纠错
-	assert.True(t,
-		strings.Contains(body.Msg, "oldPassword") || strings.Contains(body.Msg, "newPassword"),
-		"缺字段文案必须点名到 oldPassword / newPassword; 实际: %q", body.Msg)
-}

internal/handler/auth/userInfoHandler.go

@@ -10,6 +10,7 @@ import (
 	"perms-system-server/internal/logic/auth"
 	"perms-system-server/internal/svc"
 )
+
 // UserInfoHandler 获取当前登录用户信息接口。返回用户个人信息、成员类型和权限列表。
 func UserInfoHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {

internal/handler/fetchInitialCredentialsRouteWiring_audit_test.go

@@ -1,80 +0,0 @@
-package handler
-
-import (
-	"os"
-	"regexp"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-4 的路由 wiring 静态检查 ——
-//   `/api/product/fetchInitialCredentials` 必须挂载 `serverCtx.JwtAuth` 中间件，
-//   且必须位于 /api/product 前缀组内，不能被错放到其他无鉴权/错前缀块中。
-//
-// 为什么这条 wiring 需要独立钉死：
-//   1. routes.go 由 goctl 生成，回归时若有人用 `goctl api go -api ... -dir .`
-//      覆写此文件，可能把新路由吞掉或挪到无 JwtAuth 包裹的块（例如误标
-//      `@handler` 在 pub 组）。静态检查能最早拦截。
-//   2. M-4 的安全假设是"只有超级管理员能消费 ticket"。RequireSuperAdmin 依赖
-//      JwtAuth 中间件写入 UserDetails；若 JwtAuth 被去掉，handler 自身仅能回
-//      401（无 ctx），**但任何持有前端伪造 UserDetails 注入方式**的攻击者都会
-//      直接绕过 —— wiring 锚点确保这条防线永远在最外层。
-// ---------------------------------------------------------------------------
-
-// TC-0967: routes.go 必须把 /product/fetchInitialCredentials 挂到 JwtAuth 包裹块，
-// 并且处于 /api/product 前缀下（而不是 /api 或其他无超管审查的位置）。
-func TestRoutes_FetchInitialCredentialsJwtAuthWired(t *testing.T) {
-	raw, err := os.ReadFile("./routes.go")
-	require.NoError(t, err, "必须能读到 internal/handler/routes.go")
-	src := string(raw)
-
-	// go-zero 生成的 AddRoutes 块结构：
-	//   server.AddRoutes(
-	//       rest.WithMiddlewares([]rest.Middleware{serverCtx.XxxMiddleware}, []rest.Route{
-	//           {...Path: "/a"...},
-	//           {...Path: "/fetchInitialCredentials"...},
-	//           ...
-	//       }...),
-	//       rest.WithPrefix("/api/product"),
-	//   )
-	// 我们需要：
-	//   1. 定位到 /fetchInitialCredentials 所在的 AddRoutes 块整段；
-	//   2. 从块里摘出 rest.Middleware{...} 列表做字符串断言；
-	//   3. 从块里摘出 rest.WithPrefix("...") 的 prefix 做断言。
-	// 简单起见，按"向上/向下扩展"的方式提取：以 "server.AddRoutes(" 为起点、往下到首个
-	// "rest.WithPrefix(\"...\")" 为止的整段。
-
-	addRoutesBlockRe := regexp.MustCompile(
-		`(?s)server\.AddRoutes\(\s*rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{([^}]*)\}[\s\S]*?"/fetchInitialCredentials"[\s\S]*?rest\.WithPrefix\("([^"]+)"\)`,
-	)
-	m := addRoutesBlockRe.FindStringSubmatch(src)
-	require.NotEmpty(t, m,
-		"routes.go 中 /fetchInitialCredentials 必须位于 server.AddRoutes(rest.WithMiddlewares(...), rest.WithPrefix(...)) 结构块里；未匹配说明路由被剥离或迁移到其他结构")
-
-	middlewaresList := m[1]
-	prefix := m[2]
-
-	assert.Contains(t, middlewaresList, "serverCtx.JwtAuth",
-		"M-4：/product/fetchInitialCredentials 必须挂载 JwtAuth 中间件，否则 RequireSuperAdmin 的上下文前置条件不成立；实际中间件列表=%q", middlewaresList)
-	assert.Equal(t, "/api/product", prefix,
-		"M-4：/fetchInitialCredentials 必须位于 /api/product 前缀组下；实际 prefix=%q", prefix)
-}
-
-// TC-0968: 防御性 wiring 检查 —— 绝不允许把 fetchInitialCredentials 挂到任何
-// *非 JwtAuth* 的中间件块中。此用例是 TC-0967 的"反证"：哪怕有人把 JwtAuth 改名
-// 成另一条鉴权中间件但语义错位，也会被这里拦住。
-func TestRoutes_FetchInitialCredentialsNotInRateLimitGroup(t *testing.T) {
-	raw, err := os.ReadFile("./routes.go")
-	require.NoError(t, err)
-	src := string(raw)
-
-	// 检查"限流中间件包裹块内"是否误引入了 fetchInitialCredentials
-	for _, name := range []string{"AdminLoginRateLimit", "ProductLoginRateLimit", "RefreshTokenRateLimit", "SyncRateLimit"} {
-		re := regexp.MustCompile(`(?s)rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{[^}]*?` + name + `[^}]*?\}[^)]*?"/fetchInitialCredentials"`)
-		assert.False(t, re.MatchString(src),
-			"M-4：/fetchInitialCredentials 绝不能被挂到 %s 中间件组（会绕过 JwtAuth / RequireSuperAdmin）", name)
-	}
-}

internal/handler/product/fetchInitialCredentialsHandler_audit_test.go → internal/handler/product/fetchInitialCredentialsHandler_test.go

@@ -24,7 +24,7 @@ import (
 func init() { response.Setup() }
 
 // ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-4 的 handler 薄层契约 —— `/api/product/fetchInitialCredentials`
+// 覆盖目标：的 handler 薄层契约 —— `/api/product/fetchInitialCredentials`
 //
 // 此前 TC-0901 ~ TC-0912 已在 logic 层全量覆盖一次性凭据取回语义；test-report.md §10.4
 // 留了一条明确的"未测场景"：handler 薄层 + 路由 wiring（JwtAuth 中间件绑定、
@@ -36,7 +36,7 @@ func init() { response.Setup() }
 
 // initialCredentialsKeyPrefix 与 internal/logic/product/createProductLogic.go 中未导出的同名常量一致。
 // 这里显式在测试里拷贝一份 —— 一旦生产代码改了前缀，handler 链路会立即失灵，对应 happy-path 用例会红。
-// 我们不想导出它（M-4 语义要求尽量收敛可见面），所以此处 string-literal 锚点。
+// 我们不想导出它（ 语义要求尽量收敛可见面），所以此处 string-literal 锚点。
 const fetchInitialCredentialsKeyPrefix = "pm:initcred:"
 
 func superAdminReqCtx(r *http.Request) *http.Request {
@@ -107,7 +107,7 @@ func TestFetchInitialCredentialsHandler_NoUserCtxReturns401(t *testing.T) {
 }
 
 // TC-0963: handler 薄层契约 —— 非超管必须 403，且响应体不得泄露 ticket 存在性或业务细节。
-// 这条契约保证了 M-4 的"即便 ticket 泄漏到日志，非超管也无法消费"防线在 handler 层被钉死。
+// 这条契约保证了  的"即便 ticket 泄漏到日志，非超管也无法消费"防线在 handler 层被钉死。
 func TestFetchInitialCredentialsHandler_NonSuperAdminReturns403(t *testing.T) {
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
 	handler := FetchInitialCredentialsHandler(svcCtx)
@@ -207,8 +207,8 @@ func TestFetchInitialCredentialsHandler_HappyPath200WithFields(t *testing.T) {
 	require.Equal(t, http.StatusOK, rr.Code, "happy path 必须 HTTP 200；body=%s", rr.Body.String())
 
 	var envelope struct {
-		Code int                                `json:"code"`
-		Msg  string                             `json:"msg"`
+		Code int                               `json:"code"`
+		Msg  string                            `json:"msg"`
 		Data types.FetchInitialCredentialsResp `json:"data"`
 	}
 	require.NoError(t, json.Unmarshal(rr.Body.Bytes(), &envelope))

internal/handler/refreshTokenRouteWiring_audit_test.go

@@ -1,98 +0,0 @@
-package handler
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"regexp"
-	"strings"
-	"testing"
-
-	"perms-system-server/internal/handler/pub"
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-func init() { response.Setup() }
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：
-//   M-B (audit)：HTTP /api/auth/refreshToken 路由必须挂载 RefreshTokenRateLimit
-//   中间件（IP 维度），配额用尽后对同 IP 请求必须返回 429 "请求过于频繁"。
-//
-// 本文件从两个独立角度交叉验证：
-//   1. 静态 wiring：读取 routes.go 源码，断言 /auth/refreshToken 路由块内出现
-//      serverCtx.RefreshTokenRateLimit（防止有人误删中间件却骗过运行时）；
-//   2. 行为验证：用同一条中间件组合链路（= 生产代码的 rest.WithMiddlewares 展开）
-//      直接发 HTTP 请求，达到 quota 后必须 429。
-// ---------------------------------------------------------------------------
-
-// TC-0832: 静态 wiring 检查 —— routes.go 中 /auth/refreshToken 必须显式绑定
-// RefreshTokenRateLimit 中间件。任何人无意中删掉这一行，本用例即红。
-func TestRoutes_RefreshTokenRateLimitWired(t *testing.T) {
-	// 读 routes.go 源码
-	raw, err := os.ReadFile("./routes.go")
-	require.NoError(t, err, "必须能读到 internal/handler/routes.go")
-	src := string(raw)
-
-	// 先定位 /auth/refreshToken 的路由块，再在块内检查中间件引用
-	// 语义等价于：rest.WithMiddlewares([]rest.Middleware{serverCtx.RefreshTokenRateLimit}, ... "/auth/refreshToken" ...)
-	re := regexp.MustCompile(`(?s)rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{([^}]*)\}[^)]*?"/auth/refreshToken"`)
-	m := re.FindStringSubmatch(src)
-	require.NotEmpty(t, m, "routes.go 里 /auth/refreshToken 必须位于 rest.WithMiddlewares(...) 包裹块中；未匹配说明中间件被剥离")
-	assert.Contains(t, m[1], "serverCtx.RefreshTokenRateLimit",
-		"M-B：/auth/refreshToken 路由的中间件列表必须包含 RefreshTokenRateLimit")
-}
-
-// TC-0833: 行为验证 —— 复用生产中间件定义，quota=1 的窗口内同 IP 第 2 次必须 429。
-func TestRefreshTokenRoute_RateLimit_EnforcedOnSameIP(t *testing.T) {
-	cfg := testutil.GetTestConfig()
-	svcCtx := svc.NewServiceContext(cfg)
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-
-	// 构造与 routes.go 等价的中间件链：RefreshTokenRateLimit → RefreshTokenHandler
-	// 这里故意使用 quota=1 的新实例，避免污染生产 limiter，同时保持行为完全一致。
-	rl := middleware.NewRateLimitMiddleware(
-		rds, 60, 1,
-		cfg.CacheRedis.KeyPrefix+":rl:refresh:wiring:"+testutil.UniqueId(),
-		false, /* behindProxy: 与默认配置一致，本测试用 RemoteAddr */
-	)
-	inner := pub.RefreshTokenHandler(svcCtx)
-	wrapped := rl.Handle(func(w http.ResponseWriter, r *http.Request) {
-		inner.ServeHTTP(w, r)
-	})
-
-	// 固定 RemoteAddr，两次请求同 IP 不同端口，必须共享同一限流桶。
-	doRequest := func(remoteAddr string) (*httptest.ResponseRecorder, response.Body) {
-		req := httptest.NewRequest(http.MethodPost, "/api/auth/refreshToken", strings.NewReader("{}"))
-		req.Header.Set("Content-Type", "application/json")
-		req.RemoteAddr = remoteAddr
-		rr := httptest.NewRecorder()
-		wrapped(rr, req)
-		var body response.Body
-		_ = json.Unmarshal(rr.Body.Bytes(), &body)
-		return rr, body
-	}
-
-	// 第 1 次：放行，进入 RefreshTokenHandler 后因缺 Authorization 返回 401（业务层）
-	_, body1 := doRequest("198.51.100.7:40001")
-	assert.NotEqual(t, 429, body1.Code, "首次请求必须放行，由业务层决定返回码；实际 code=%d msg=%q", body1.Code, body1.Msg)
-
-	// 第 2 次：同 IP 不同端口，必须被限流拦截，返回 429 "请求过于频繁..."
-	_, body2 := doRequest("198.51.100.7:40002")
-	assert.Equal(t, 429, body2.Code,
-		"M-B：/api/auth/refreshToken 必须受 IP 维度限流保护；quota=1 时第 2 次必须 429。实际 code=%d msg=%q", body2.Code, body2.Msg)
-	assert.Contains(t, body2.Msg, "过于频繁",
-		"429 的业务文案必须是用户可读的限流提示，而不是原始 limiter 错误")
-
-	// 不同 IP 必须不受影响，证明限流是 per-IP 而不是全局。
-	_, body3 := doRequest("203.0.113.9:55555")
-	assert.NotEqual(t, 429, body3.Code, "不同 IP 必须独立计数；不应被前一 IP 的 burst 牵连，实际 code=%d", body3.Code)
-}

internal/handler/routes_test.go

@@ -0,0 +1,166 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+
+	"perms-system-server/internal/handler/pub"
+	"perms-system-server/internal/middleware"
+	"perms-system-server/internal/response"
+	"perms-system-server/internal/svc"
+	"perms-system-server/internal/testutil"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+func init() { response.Setup() }
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：
+// /api/auth/refreshToken 路由必须挂载 RefreshTokenRateLimit 中间件（IP 维度），
+// 配额用尽后对同 IP 请求必须返回 429 "请求过于频繁"。
+//
+// 本组用例从两个独立角度交叉验证：
+// 1. 静态 wiring：读取 routes.go 源码，断言 /auth/refreshToken 路由块内出现
+// serverCtx.RefreshTokenRateLimit（防止有人误删中间件却骗过运行时）；
+// 2. 行为验证：用同一条中间件组合链路（= 生产代码的 rest.WithMiddlewares 展开）
+// 直接发 HTTP 请求，达到 quota 后必须 429。
+// ---------------------------------------------------------------------------
+
+// TC-0832: 静态 wiring 检查 —— routes.go 中 /auth/refreshToken 必须显式绑定
+// RefreshTokenRateLimit 中间件。任何人无意中删掉这一行，本用例即红。
+func TestRoutes_RefreshTokenRateLimitWired(t *testing.T) {
+	raw, err := os.ReadFile("./routes.go")
+	require.NoError(t, err, "必须能读到 internal/handler/routes.go")
+	src := string(raw)
+
+	// 先定位 /auth/refreshToken 的路由块，再在块内检查中间件引用
+	// 语义等价于：rest.WithMiddlewares([]rest.Middleware{serverCtx.RefreshTokenRateLimit}, ... "/auth/refreshToken" ...)
+	re := regexp.MustCompile(`(?s)rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{([^}]*)\}[^)]*?"/auth/refreshToken"`)
+	m := re.FindStringSubmatch(src)
+	require.NotEmpty(t, m, "routes.go 里 /auth/refreshToken 必须位于 rest.WithMiddlewares(...) 包裹块中；未匹配说明中间件被剥离")
+	assert.Contains(t, m[1], "serverCtx.RefreshTokenRateLimit",
+		"/auth/refreshToken 路由的中间件列表必须包含 RefreshTokenRateLimit")
+}
+
+// TC-0833: 行为验证 —— 复用生产中间件定义，quota=1 的窗口内同 IP 第 2 次必须 429。
+func TestRefreshTokenRoute_RateLimit_EnforcedOnSameIP(t *testing.T) {
+	cfg := testutil.GetTestConfig()
+	svcCtx := svc.NewServiceContext(cfg)
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+
+	// 构造与 routes.go 等价的中间件链：RefreshTokenRateLimit → RefreshTokenHandler
+	// 这里故意使用 quota=1 的新实例，避免污染生产 limiter，同时保持行为完全一致。
+	rl := middleware.NewRateLimitMiddleware(
+		rds, 60, 1,
+		cfg.CacheRedis.KeyPrefix+":rl:refresh:wiring:"+testutil.UniqueId(),
+		false, /* behindProxy: 与默认配置一致，本测试用 RemoteAddr */
+	)
+	inner := pub.RefreshTokenHandler(svcCtx)
+	wrapped := rl.Handle(func(w http.ResponseWriter, r *http.Request) {
+		inner.ServeHTTP(w, r)
+	})
+
+	// 固定 RemoteAddr，两次请求同 IP 不同端口，必须共享同一限流桶。
+	doRequest := func(remoteAddr string) (*httptest.ResponseRecorder, response.Body) {
+		req := httptest.NewRequest(http.MethodPost, "/api/auth/refreshToken", strings.NewReader("{}"))
+		req.Header.Set("Content-Type", "application/json")
+		req.RemoteAddr = remoteAddr
+		rr := httptest.NewRecorder()
+		wrapped(rr, req)
+		var body response.Body
+		_ = json.Unmarshal(rr.Body.Bytes(), &body)
+		return rr, body
+	}
+
+	// 第 1 次：放行，进入 RefreshTokenHandler 后因缺 Authorization 返回 401（业务层）
+	_, body1 := doRequest("198.51.100.7:40001")
+	assert.NotEqual(t, 429, body1.Code, "首次请求必须放行，由业务层决定返回码；实际 code=%d msg=%q", body1.Code, body1.Msg)
+
+	// 第 2 次：同 IP 不同端口，必须被限流拦截，返回 429 "请求过于频繁..."
+	_, body2 := doRequest("198.51.100.7:40002")
+	assert.Equal(t, 429, body2.Code,
+		"/api/auth/refreshToken 必须受 IP 维度限流保护；quota=1 时第 2 次必须 429。实际 code=%d msg=%q", body2.Code, body2.Msg)
+	assert.Contains(t, body2.Msg, "过于频繁",
+		"429 的业务文案必须是用户可读的限流提示，而不是原始 limiter 错误")
+
+	// 不同 IP 必须不受影响，证明限流是 per-IP 而不是全局。
+	_, body3 := doRequest("203.0.113.9:55555")
+	assert.NotEqual(t, 429, body3.Code, "不同 IP 必须独立计数；不应被前一 IP 的 burst 牵连，实际 code=%d", body3.Code)
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：
+// `/api/product/fetchInitialCredentials` 必须挂载 `serverCtx.JwtAuth` 中间件，
+// 且必须位于 /api/product 前缀组内，不能被错放到其他无鉴权/错前缀块中。
+//
+// 为什么这条 wiring 需要独立钉死：
+// 1. routes.go 由 goctl 生成，回归时若有人用 `goctl api go -api ... -dir .`
+// 覆写此文件，可能把新路由吞掉或挪到无 JwtAuth 包裹的块（例如误标
+// `@handler` 在 pub 组）。静态检查能最早拦截。
+// 2. 安全假设是"只有超级管理员能消费 ticket"。RequireSuperAdmin 依赖 JwtAuth
+// 中间件写入 UserDetails；若 JwtAuth 被去掉，handler 自身仅能回 401（无 ctx），
+// **但任何持有前端伪造 UserDetails 注入方式**的攻击者都会直接绕过
+// wiring 锚点确保这条防线永远在最外层。
+// ---------------------------------------------------------------------------
+
+// TC-0967: routes.go 必须把 /product/fetchInitialCredentials 挂到 JwtAuth 包裹块，
+// 并且处于 /api/product 前缀下（而不是 /api 或其他无超管审查的位置）。
+func TestRoutes_FetchInitialCredentialsJwtAuthWired(t *testing.T) {
+	raw, err := os.ReadFile("./routes.go")
+	require.NoError(t, err, "必须能读到 internal/handler/routes.go")
+	src := string(raw)
+
+	// go-zero 生成的 AddRoutes 块结构：
+	// server.AddRoutes(
+	// rest.WithMiddlewares([]rest.Middleware{serverCtx.XxxMiddleware}, []rest.Route{
+	// {...Path: "/a"...},
+	// {...Path: "/fetchInitialCredentials"...},
+	// ...
+	// }...),
+	// rest.WithPrefix("/api/product"),
+	// )
+	// 我们需要：
+	// 1. 定位到 /fetchInitialCredentials 所在的 AddRoutes 块整段；
+	// 2. 从块里摘出 rest.Middleware{...} 列表做字符串断言；
+	// 3. 从块里摘出 rest.WithPrefix("...") 的 prefix 做断言。
+	// 简单起见，按"向上/向下扩展"的方式提取：以 "server.AddRoutes(" 为起点、往下到首个
+	// "rest.WithPrefix(\"...\")" 为止的整段。
+	addRoutesBlockRe := regexp.MustCompile(
+		`(?s)server\.AddRoutes\(\s*rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{([^}]*)\}[\s\S]*?"/fetchInitialCredentials"[\s\S]*?rest\.WithPrefix\("([^"]+)"\)`,
+	)
+	m := addRoutesBlockRe.FindStringSubmatch(src)
+	require.NotEmpty(t, m,
+		"routes.go 中 /fetchInitialCredentials 必须位于 server.AddRoutes(rest.WithMiddlewares(...), rest.WithPrefix(...)) 结构块里；未匹配说明路由被剥离或迁移到其他结构")
+
+	middlewaresList := m[1]
+	prefix := m[2]
+
+	assert.Contains(t, middlewaresList, "serverCtx.JwtAuth",
+		"/product/fetchInitialCredentials 必须挂载 JwtAuth 中间件，否则 RequireSuperAdmin 的上下文前置条件不成立；实际中间件列表=%q", middlewaresList)
+	assert.Equal(t, "/api/product", prefix,
+		"/fetchInitialCredentials 必须位于 /api/product 前缀组下；实际 prefix=%q", prefix)
+}
+
+// TC-0968: 防御性 wiring 检查 —— 绝不允许把 fetchInitialCredentials 挂到任何
+// *非 JwtAuth* 的中间件块中。此用例是 TC-0967 的"反证"：哪怕有人把 JwtAuth 改名
+// 成另一条鉴权中间件但语义错位，也会被这里拦住。
+func TestRoutes_FetchInitialCredentialsNotInRateLimitGroup(t *testing.T) {
+	raw, err := os.ReadFile("./routes.go")
+	require.NoError(t, err)
+	src := string(raw)
+
+	// 检查"限流中间件包裹块内"是否误引入了 fetchInitialCredentials
+	for _, name := range []string{"AdminLoginRateLimit", "ProductLoginRateLimit", "RefreshTokenRateLimit", "SyncRateLimit"} {
+		re := regexp.MustCompile(`(?s)rest\.WithMiddlewares\(\s*\[\]rest\.Middleware\{[^}]*?` + name + `[^}]*?\}[^)]*?"/fetchInitialCredentials"`)
+		assert.False(t, re.MatchString(src),
+			"/fetchInitialCredentials 绝不能被挂到 %s 中间件组（会绕过 JwtAuth / RequireSuperAdmin）", name)
+	}
+}

internal/loaders/userDetailsLoaderCleanByUserIds_audit_test.go

@@ -1,79 +0,0 @@
-package loaders
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-1 修复回归 —— UserDetailsLoader.CleanByUserIds
-//   * 对多个 userId 的所有产品下缓存 + 用户索引 key 必须整体删除；
-//   * 对空输入必须立即返回，不打 Redis；
-//   * 基于 SUNION + 批 DEL，单次 RTT 常数，调用方（UpdateDept）调一次即可清完。
-// ---------------------------------------------------------------------------
-
-// TC-0846: 预埋 3 用户 × 2 产品的缓存，CleanByUserIds 一次性清光所有 ud: key 与 idx: key。
-func TestCleanByUserIds_WipesAllUserProductKeysAndIndexes(t *testing.T) {
-	rds := testRedis()
-	loader := newTestLoader()
-	ctx := context.Background()
-
-	type cell struct {
-		uid int64
-		pc  string
-	}
-	cells := []cell{
-		{1000001, "pcX"}, {1000001, "pcY"},
-		{1000002, "pcX"}, {1000002, "pcY"},
-		{1000003, "pcX"}, {1000003, "pcY"},
-	}
-
-	// 预埋缓存：每个 cell 写一条 value 到 cacheKey，并 SADD 到 user / product 索引。
-	cacheKeys := make([]string, 0, len(cells))
-	for _, c := range cells {
-		ck := loader.cacheKey(c.uid, c.pc)
-		require.NoError(t, rds.SetCtx(ctx, ck, "dummy"))
-		_, _ = rds.SaddCtx(ctx, loader.userIndexKey(c.uid), ck)
-		_, _ = rds.SaddCtx(ctx, loader.productIndexKey(c.pc), ck)
-		cacheKeys = append(cacheKeys, ck)
-	}
-
-	// 调用 CleanByUserIds 触发 SUNION + 批 DEL。
-	loader.CleanByUserIds(ctx, []int64{1000001, 1000002, 1000003})
-
-	// 6 条 ud: key 必须全消失。
-	for _, ck := range cacheKeys {
-		exist, err := rds.ExistsCtx(ctx, ck)
-		require.NoError(t, err)
-		assert.False(t, exist, "M-1：cacheKey %s 必须被清理", ck)
-	}
-	// 3 条 user 索引 key 必须也被清掉（否则会漏缓存）。
-	for _, uid := range []int64{1000001, 1000002, 1000003} {
-		exist, err := rds.ExistsCtx(ctx, loader.userIndexKey(uid))
-		require.NoError(t, err)
-		assert.False(t, exist,
-			"M-1：user 索引集合必须被 DEL，否则下次 Clean 会复活假指针")
-	}
-
-	// 清理 product 索引残留（修复 SLA 不负责 product 索引，其残留 key 已在 user 索引里一并清掉
-	// 的那一组；但为了测试幂等性，手动 cleanup）。
-	t.Cleanup(func() {
-		_, _ = rds.DelCtx(ctx, loader.productIndexKey("pcX"), loader.productIndexKey("pcY"))
-	})
-}
-
-// TC-0847: 空 ids 切片必须直接返回，不打 Redis。
-// 如果源码退化成把空 SUNION 交给 Redis，会收到 "SUNION wrong number of arguments" 错误；
-// 我们通过断言 Redis 未产生任何错误以及函数未 panic 来验证。
-func TestCleanByUserIds_EmptyIds_NoOp(t *testing.T) {
-	loader := newTestLoader()
-	// 只要不 panic、返回即可；如果源码 foundation 有 wrong-args 会 logx.Errorf 输出，
-	// 这里做最小断言：调用返回控制权。
-	loader.CleanByUserIds(context.Background(), nil)
-	loader.CleanByUserIds(context.Background(), []int64{})
-	// 若走到了 SUNION 分支，Redis 会在 wrong-args 下被 logx 记 Errorf，
-	// 业务回调仍然返回，此时不应 panic；通过到达本行说明 OK。
-}

internal/loaders/userDetailsLoader_batchdel_mn2_audit_test.go

@@ -1,120 +0,0 @@
-package loaders
-
-import (
-	"context"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	productModel "perms-system-server/internal/model/product"
-	userModel "perms-system-server/internal/model/user"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-N2 修复 —— BatchDel 必须把 userIndex / productIndex 的 SREM
-// 合进一次 Pipelined RTT，历史 per-user 串行路径下"角色绑千人"时尾延迟会抬到秒级。
-// 本测试以"主缓存 + user/product 索引集合"的最终一致性为切入点，在 N 条数据下验证：
-//   (1) 主 cacheKey 全量清空
-//   (2) 每个 userIndex 集合中对应的 cacheKey 已经被 SREM
-//   (3) productIndex 集合中所有 cacheKey 也已经被 SREM
-// 相比只断言 (1) 的 TC-0513，本 TC 把 index 一致性钉死，防止 pipelined 分支被回退到
-// "只 DEL 主 key、遗漏 SREM"的静默回归。
-// ---------------------------------------------------------------------------
-
-// TC-1013: M-N2 —— BatchDel 必须同步清理 userIndex / productIndex 中的 cacheKey 集合（Pipelined）。
-func TestUserDetailsLoader_MN2_BatchDelClearsUserAndProductIndexes(t *testing.T) {
-	ctx := context.Background()
-	conn := testConn()
-	m := testModels()
-	loader := newTestLoader()
-	rds := testRedis()
-
-	ts := now()
-	pcode := "mn2_" + uniqueId()
-
-	// 插入两个用户 + 一个真实产品，确保 Load 走到 5 分钟正缓存分支并注册索引
-	uid1 := uniqueId()
-	uid2 := uniqueId()
-	userId1 := insertUser(ctx, t, m, &userModel.SysUser{
-		Username: uid1, Password: hashPwd("pass123"), Nickname: "nick_" + uid1,
-		Email: uid1 + "@t.com", Phone: "13800000008", DeptId: 0,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	userId2 := insertUser(ctx, t, m, &userModel.SysUser{
-		Username: uid2, Password: hashPwd("pass123"), Nickname: "nick_" + uid2,
-		Email: uid2 + "@t.com", Phone: "13800000009", DeptId: 0,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
-		Code: pcode, Name: "p_" + pcode, AppKey: "ak_" + pcode, AppSecret: "as_" + pcode,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	t.Cleanup(func() {
-		loader.Del(ctx, userId1, pcode)
-		loader.Del(ctx, userId2, pcode)
-		cleanTable(ctx, conn, "`sys_product`", pid)
-		cleanTable(ctx, conn, "`sys_user`", userId1, userId2)
-	})
-
-	// 把缓存一次预热，让 userIndex/productIndex 被 registerCacheKey 真实写入
-	_, err := loader.Load(ctx, userId1, pcode)
-	require.NoError(t, err)
-	_, err = loader.Load(ctx, userId2, pcode)
-	require.NoError(t, err)
-
-	k1 := loader.cacheKey(userId1, pcode)
-	k2 := loader.cacheKey(userId2, pcode)
-	pIdx := loader.productIndexKey(pcode)
-	u1Idx := loader.userIndexKey(userId1)
-	u2Idx := loader.userIndexKey(userId2)
-
-	// 预检：主 key 写入、productIndex / userIndex 存在对应元素
-	for _, k := range []string{k1, k2} {
-		val, gerr := rds.GetCtx(ctx, k)
-		require.NoError(t, gerr)
-		require.NotEmpty(t, val, "M-N2 预检：主 cacheKey 必须被写入才有意义")
-	}
-	has, _ := rds.SismemberCtx(ctx, pIdx, k1)
-	require.True(t, has, "M-N2 预检：productIndex 必须含 k1")
-	has, _ = rds.SismemberCtx(ctx, pIdx, k2)
-	require.True(t, has, "M-N2 预检：productIndex 必须含 k2")
-	has, _ = rds.SismemberCtx(ctx, u1Idx, k1)
-	require.True(t, has, "M-N2 预检：userIndex(u1) 必须含 k1")
-	has, _ = rds.SismemberCtx(ctx, u2Idx, k2)
-	require.True(t, has, "M-N2 预检：userIndex(u2) 必须含 k2")
-
-	// 触发被测路径：BatchDel（pipelined SREM）
-	loader.BatchDel(ctx, []int64{userId1, userId2}, pcode)
-
-	// 主 key 被清空（原 TC-0513 已保障）
-	for _, k := range []string{k1, k2} {
-		val, _ := rds.GetCtx(ctx, k)
-		assert.Empty(t, val, "M-N2：BatchDel 必须删除主 cacheKey")
-	}
-
-	// userIndex / productIndex 中的对应 cacheKey 必须被 SREM 清除（本 TC 核心断言）
-	has, _ = rds.SismemberCtx(ctx, u1Idx, k1)
-	assert.False(t, has, "M-N2：BatchDel 必须把 k1 从 userIndex(u1) SREM 出去")
-	has, _ = rds.SismemberCtx(ctx, u2Idx, k2)
-	assert.False(t, has, "M-N2：BatchDel 必须把 k2 从 userIndex(u2) SREM 出去")
-	has, _ = rds.SismemberCtx(ctx, pIdx, k1)
-	assert.False(t, has, "M-N2：BatchDel 必须把 k1 从 productIndex SREM 出去")
-	has, _ = rds.SismemberCtx(ctx, pIdx, k2)
-	assert.False(t, has, "M-N2：BatchDel 必须把 k2 从 productIndex SREM 出去")
-}
-
-// TC-1014: M-N2 —— productCode 为空时 BatchDel 仅 SREM userIndex，不得 panic 或误访问 productIndex。
-// 目前业务侧 BatchDel 的所有调用都传了 productCode；但 pipeline 分支必须对空串 fail-safe，
-// 防止未来调用方误传时 pipeline 里塞空 key 把 Redis 侧写脏。
-func TestUserDetailsLoader_MN2_BatchDelEmptyProductCodeDoesNotPanic(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-	// 即便 uid 不存在，pipelined SREM 对不存在的集合是 no-op，不应报错/panic
-	require.NotPanics(t, func() {
-		loader.BatchDel(ctx, []int64{9999999991, 9999999992}, "")
-	})
-}

internal/loaders/userDetailsLoader_contract_audit_test.go

@@ -1,218 +0,0 @@
-package loaders
-
-import (
-	"context"
-	"database/sql"
-	"encoding/json"
-	"errors"
-	"strings"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	productModel "perms-system-server/internal/model/product"
-	memberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-1 / H-1 / L-3 / L-6 的 Loader 新契约。
-// 旧契约 Load 返回单值 *UserDetails；DB 故障被同化为"用户不存在"，而且任何 perms / role / dept
-// 子步骤失败都会把"半残 UD"写 5 分钟缓存。新契约：
-//   1) (ud, err) 双返回：err 表示基础设施故障；
-//   2) 真实不存在的用户 → (ud, nil) 且 ud.Username == ""；
-//   3) 主体加载成功但子步骤失败 → (ud, nil) 且 "不写缓存"（下次 Load 重试）；
-//   4) L-6：在 Load 期间被 CreateUser 的 userId 不得被留下负缓存哨兵（投毒防御）。
-// ---------------------------------------------------------------------------
-
-// TC-0913: M-1 —— 不存在用户走 (ud, nil) 语义，而不是 (nil, err)，让中间件能区分 401 vs 503
-func TestUserDetailsLoader_Load_NotExist_ReturnsUdWithNilErr(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-	nonExistId := int64(900_100_000 + time.Now().UnixNano()%100_000)
-	productCode := "pc_nxud_" + uniqueId()
-	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
-
-	ud, err := loader.Load(ctx, nonExistId, productCode)
-	require.NoError(t, err,
-		"M-1：用户不存在必须走 (ud,nil) 语义；否则中间件会把 DB 抖动同化成 401 强制下线引发雪崩")
-	require.NotNil(t, ud)
-	assert.Equal(t, nonExistId, ud.UserId)
-	assert.Equal(t, productCode, ud.ProductCode)
-	assert.Empty(t, ud.Username, "Username 必须为空以便调用方判定为 404 用户")
-}
-
-// TC-0914: L-6 —— 并发时序：CreateUser 成功但 Load 已经走到"写负缓存哨兵"分支之前，
-// 再次 FindOne 复核必须把"刚创建的用户"识别出来，跳过哨兵写入，避免新用户被投毒。
-//
-// 本测试构造的时序：先 Insert 一个真实用户（这步 Insert 会 DEL 用户主键缓存），
-// 再立即 Load 该 userId+productCode。L-6 的 freshCheck 必须让"这个第一 Load"拿到用户数据，
-// 而不是把 ud:<id>:<pc> 写为 _NOT_FOUND_。
-func TestUserDetailsLoader_Load_L6_CreateUserThenLoadDoesNotWriteSentinel(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-	conn := testConn()
-	m := testModels()
-	ts := now()
-	uid := uniqueId()
-	productCode := "pc_l6_" + uid
-
-	userId := insertUser(ctx, t, m, &userModel.SysUser{
-		Username: uid, Password: hashPwd("pw"), Nickname: "l6",
-		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	// M-N1 修复后，Load 要求 productCode 对应的产品真实存在才能进入正缓存分支；否则
-	// loadProduct 失败会被提升为 ErrLoaderDegraded。L-6 的主题是"新用户写入后首次 Load
-	// 不得被自身写的负缓存哨兵投毒"，与"产品不存在"正交，因此这里补一条真实产品。
-	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
-		Code: productCode, Name: "l6_prod", AppKey: "ak", AppSecret: "as",
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	t.Cleanup(func() {
-		loader.Del(ctx, userId, productCode)
-		cleanTable(ctx, conn, "`sys_user`", userId)
-		cleanTable(ctx, conn, "`sys_product`", pid)
-	})
-
-	loader.Del(ctx, userId, productCode)
-
-	ud, err := loader.Load(ctx, userId, productCode)
-	require.NoError(t, err)
-	require.NotNil(t, ud)
-	assert.Equal(t, uid, ud.Username, "L-6：Load 必须识别出这是真实用户而不是写哨兵")
-
-	// 关键断言：Redis key 里的值绝不能是哨兵。
-	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
-	require.NoError(t, err)
-	assert.NotEqual(t, negativeCacheMarker, val,
-		"L-6：新创建的用户首次 Load 不得被写入负缓存哨兵，否则 10s 内所有请求都会被判为'已删除'")
-}
-
-// TC-0915 (重写 · M-N1): partial load 失败必须返回 ErrLoaderDegraded（而非 (ud,nil) 半成品），
-// 让调用方统一把它映射为 503 / codes.Unavailable；同时 5 分钟正缓存绝不能被写入。
-//
-// 历史契约：loadOk=false 时 Load 返回 (ud, nil)，ud 是 Username 非空但 DeptPath=""/Perms=nil 的
-// 半成品，然后 jwtauth / refreshToken / GetUserPerms 等调用方因 MemberType=="" 或
-// ProductStatus!=Enabled 错把它当成"产品已被禁用 / 无权限" 返 403，一次 DB 抖动全站静默 403。
-// 新契约（审计 M-N1）：loadOk=false → (nil, ErrLoaderDegraded)；调用方 err!=nil 分支自然映射
-// 503 / codes.Unavailable，SOC 侧能明确观测到基础设施故障。
-func TestUserDetailsLoader_Load_MN1_PartialLoadReturnsErrDegradedAndSkipsCache(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-	conn := testConn()
-	m := testModels()
-	ts := now()
-	uid := uniqueId()
-	productCode := "pc_mn1_" + uid
-
-	// 用一个极大的 DeptId 指向不存在的部门，让 loadDept 报 ErrNotFound → loadFromDB loadOk=false。
-	phantomDeptId := int64(999_000_000_000)
-	userId := insertUser(ctx, t, m, &userModel.SysUser{
-		Username: uid, Password: hashPwd("pw"), Nickname: "mn1",
-		Avatar: sql.NullString{}, DeptId: phantomDeptId,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-
-	// 给产品落一条真实数据，让 loadProduct 本身成功，单独锁定"dept 子步骤失败"这个变量。
-	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
-		Code: productCode, Name: "mn1_prod", AppKey: "ak", AppSecret: "as",
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-
-	t.Cleanup(func() {
-		loader.Del(ctx, userId, productCode)
-		cleanTable(ctx, conn, "`sys_user`", userId)
-		cleanTable(ctx, conn, "`sys_product`", pid)
-	})
-
-	loader.Del(ctx, userId, productCode)
-
-	ud, err := loader.Load(ctx, userId, productCode)
-	// 新契约：partial load 必须向上冒 ErrLoaderDegraded；ud 必须为 nil，避免调用方误用半成品。
-	require.ErrorIs(t, err, ErrLoaderDegraded,
-		"M-N1：partial load 必须返回 ErrLoaderDegraded，而不是把半成品 ud 静默当成业务拒绝")
-	assert.Nil(t, ud, "M-N1：err 非 nil 时 ud 必须为 nil，杜绝上层误用半成品字段")
-
-	// 断言 1：Redis 里没有 5 分钟正缓存，主 key 要么完全未写，要么仅留空串。
-	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
-	require.NoError(t, err)
-	if val != "" {
-		assert.NotContains(t, val, "\"username\":\""+uid+"\"",
-			"M-N1/M-1/H-1/L-3：partial-load 不得把半残 UD 写进 5 分钟正缓存")
-	}
-}
-
-// TC-0917 (新增 · M-N1): ErrLoaderDegraded 必须是可用 errors.Is 断言的独立 sentinel，
-// 供调用方在 HTTP 中间件 / gRPC 拦截器里做到"统一映射 503"而不需要字符串匹配。
-func TestUserDetailsLoader_ErrLoaderDegraded_IsStableSentinel(t *testing.T) {
-	require.NotNil(t, ErrLoaderDegraded, "必须导出 sentinel 便于调用方识别")
-	// 再次发生的派生错误仍应 errors.Is 成立（防御"被包一层后调用方失配"）。
-	wrapped := errors.New("extra: " + ErrLoaderDegraded.Error())
-	assert.False(t, errors.Is(wrapped, ErrLoaderDegraded),
-		"新 error 与 sentinel 不应共享身份；如需传染请显式 fmt.Errorf(\"%%w\", ErrLoaderDegraded)")
-	assert.True(t, errors.Is(ErrLoaderDegraded, ErrLoaderDegraded),
-		"自身 Is 必须为 true（sanity check）")
-}
-
-// TC-0916: M-1 —— deny 查询失败时 fail-close 保底（H-1）。通过写一个完全无 perm 的普通 MEMBER，
-// 再通过 productCode 设为 disabled 让 loadPerms 走 ProductStatus != Enabled 提前返回；再切回
-// Enabled 状态，确保 perm 分支被正常 reach 到，覆盖 "allowIds 查询路径正常结束" 的成功契约。
-// 这里的反面（fail-close）契约已经由上面 TC-0915 的 "dept 失败不写缓存" 验证；单独断言 deny 失败
-// 路径需要 mock 数据库错误，属于下一轮覆盖。
-func TestUserDetailsLoader_Load_H1_EnabledProductMemberPermsNonNil(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-	conn := testConn()
-	m := testModels()
-	ts := now()
-	uid := uniqueId()
-	productCode := "pc_h1_" + uid
-
-	userId := insertUser(ctx, t, m, &userModel.SysUser{
-		Username: uid, Password: hashPwd("pw"), Nickname: "h1",
-		Avatar: sql.NullString{}, DeptId: 0,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
-		Code: productCode, Name: "h1_prod", AppKey: "ak", AppSecret: "as",
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	memberId := insertMember(ctx, t, m, &memberModel.SysProductMember{
-		ProductCode: productCode, UserId: userId, MemberType: consts.MemberTypeMember,
-		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
-	})
-	_ = memberId
-
-	t.Cleanup(func() {
-		loader.Del(ctx, userId, productCode)
-		cleanTable(ctx, conn, "`sys_user`", userId)
-		cleanTable(ctx, conn, "`sys_product`", pid)
-		cleanTableByField(ctx, conn, "`sys_product_member`", "productCode", productCode)
-	})
-
-	loader.Del(ctx, userId, productCode)
-
-	ud, err := loader.Load(ctx, userId, productCode)
-	require.NoError(t, err)
-	require.NotNil(t, ud)
-	// 这里不强制 Perms 非 nil —— 用户没有任何角色 / allow，Perms 为空 slice 或 nil 都合理；
-	// 重点是 Load 不返回 error、不被 deny 查询（null 结果）污染。
-	assert.Equal(t, uid, ud.Username)
-	assert.Equal(t, productCode, ud.ProductCode)
-
-	// 再次 Load 必须命中正缓存：GET 出的 value 一定是合法 JSON 且能反序列化回同样的 UD。
-	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
-	require.NoError(t, err)
-	require.NotEmpty(t, val, "H-1 正常路径必须落正缓存")
-	if strings.HasPrefix(val, "{") {
-		var cached UserDetails
-		require.NoError(t, json.Unmarshal([]byte(val), &cached))
-		assert.Equal(t, uid, cached.Username)
-	}
-}

internal/loaders/userDetailsLoader_negativeCache_audit_test.go

@@ -1,130 +0,0 @@
-package loaders
-
-import (
-	"context"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-3 修复 —— 对不存在/已删除用户的 load 结果必须写入短 TTL 负缓存哨兵，
-// 使后续同 userId/productCode 的 Load 在 TTL 内直接命中哨兵返回空 UserDetails，
-// 不再重复穿透到 DB，阻断离职用户残余 token 对 DB 的 DoS 放大。
-// ---------------------------------------------------------------------------
-
-// TC-0821: M-3 —— Load 不存在的 userId 第二次必须命中负缓存，不再触发 DB FindOne。
-func TestUserDetailsLoader_NegativeCache_HitsOnSecondCall(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-
-	// 随便选一个几乎肯定不存在的 id（避免与真实测试数据冲突）。
-	nonExistId := int64(900_000_000 + time.Now().UnixNano()%100_000)
-	productCode := "pc_neg_" + uniqueId()
-
-	// 确保无残留缓存。
-	loader.Del(ctx, nonExistId, productCode)
-
-	// 第 1 次 Load：预期回写负缓存哨兵。
-	// M-1 后 Load 的返回契约从 *UserDetails 扩展为 (*UserDetails, error)；
-	// 不存在用户走的是 (ud, nil) 语义 (ud.Username == "")，而不是 (nil, err)。
-	ud1, err := loader.Load(ctx, nonExistId, productCode)
-	require.NoError(t, err, "用户不存在应走 (ud,nil) 语义而不是 (nil,err)")
-	require.NotNil(t, ud1)
-	assert.Empty(t, ud1.Username, "不存在的用户 Load 后 Username 必须为空")
-
-	// 直接读 Redis，验证哨兵值真的写进去了。
-	key := loader.cacheKey(nonExistId, productCode)
-	val, err := loader.rds.GetCtx(ctx, key)
-	require.NoError(t, err)
-	assert.Equal(t, negativeCacheMarker, val,
-		"M-3：不存在的用户必须写入负缓存哨兵 %q，以便后续命中直接返回空 UserDetails", negativeCacheMarker)
-
-	// 第 2 次 Load：必须命中哨兵分支；哨兵应当返回空 UserDetails（Username 依然为空），
-	// 且不得再做 DB 查询（这里没有 mock DB counter，但结果的契约仍然成立）。
-	ud2, err := loader.Load(ctx, nonExistId, productCode)
-	require.NoError(t, err)
-	require.NotNil(t, ud2)
-	assert.Empty(t, ud2.Username)
-	assert.Equal(t, nonExistId, ud2.UserId)
-	assert.Equal(t, productCode, ud2.ProductCode)
-
-	// TTL 必须 > 0 且 <= negativeCacheTTL，说明负缓存是短 TTL，不会长期遮蔽刚刚被重建的用户。
-	ttl, err := loader.rds.TtlCtx(ctx, key)
-	require.NoError(t, err)
-	assert.Greater(t, ttl, 0, "负缓存必须是带 TTL 的短窗口")
-	assert.LessOrEqual(t, ttl, negativeCacheTTL,
-		"负缓存 TTL 不得超过 %ds，避免误伤刚 createUser 的合法用户", negativeCacheTTL)
-
-	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
-}
-
-// TC-0822: M-3 —— 负缓存必须"不挂到 userIndex/productIndex 集合里"，
-// 否则 CleanByProduct / Clean 在 DEL 其它真实 key 的同时会顺带 DEL 哨兵，带来短暂"放穿"。
-// 该测试验证：写入负缓存之后，userIndex/productIndex 集合为空。
-func TestUserDetailsLoader_NegativeCache_NotIndexed(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-
-	nonExistId := int64(900_000_123 + time.Now().UnixNano()%10_000)
-	productCode := "pc_idx_" + uniqueId()
-
-	loader.Del(ctx, nonExistId, productCode)
-	_, _ = loader.Load(ctx, nonExistId, productCode)
-
-	uidx, err := loader.rds.SmembersCtx(ctx, loader.userIndexKey(nonExistId))
-	require.NoError(t, err)
-	assert.Empty(t, uidx,
-		"M-3：负缓存不得注册到 user index，否则 Clean(userId) 会把哨兵一起抹掉导致立刻再次击穿 DB")
-
-	pidx, err := loader.rds.SmembersCtx(ctx, loader.productIndexKey(productCode))
-	require.NoError(t, err)
-	assert.Empty(t, pidx,
-		"负缓存同样不得进入 product index")
-
-	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
-}
-
-// TC-0823: M-3 —— 多并发同一 nonExistId 只穿透 DB 一次（singleflight + 负缓存联动）。
-// 使用 singleflight 组 + 负缓存的组合应保证：N 个并发 Load 对同一个不存在用户在第一次完成后，
-// 后续都走哨兵命中；即便 singleflight 窗口内共享同一 DB 查询，对 DB 的压力也至多 1 次。
-// 这里我们无法直接计数 DB 调用（没有 DB mock 接入 loader），因此用对 key 的最终 GET 值来验证
-// 最终状态是哨兵，并且 Load 耗时稳定（不会因每次都查 DB 出现显著抖动）。
-func TestUserDetailsLoader_NegativeCache_ConcurrentLoadsStabilize(t *testing.T) {
-	ctx := context.Background()
-	loader := newTestLoader()
-
-	nonExistId := int64(900_000_456 + time.Now().UnixNano()%10_000)
-	productCode := "pc_conc_" + uniqueId()
-
-	loader.Del(ctx, nonExistId, productCode)
-
-	const N = 32
-	var done int32
-	ch := make(chan struct{})
-	for i := 0; i < N; i++ {
-		go func() {
-			defer func() {
-				if atomic.AddInt32(&done, 1) == N {
-					close(ch)
-				}
-			}()
-			_, _ = loader.Load(ctx, nonExistId, productCode)
-		}()
-	}
-	select {
-	case <-ch:
-	case <-time.After(5 * time.Second):
-		t.Fatal("并发 Load 未在 5s 内收敛，singleflight/负缓存可能失效")
-	}
-
-	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(nonExistId, productCode))
-	require.NoError(t, err)
-	assert.Equal(t, negativeCacheMarker, val)
-
-	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
-}
-

internal/loaders/userDetailsLoader_singleflight_audit_test.go

@@ -1,125 +0,0 @@
-package loaders
-
-import (
-	"context"
-	"database/sql"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	userModel "perms-system-server/internal/model/user"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// countingUserModel 包装真实 SysUserModel, 仅拦截 FindOne 计数。
-// 其余 40+ 方法通过 embedding 直接 pass-through, 无需手写。
-type countingUserModel struct {
-	userModel.SysUserModel
-	findOneHits int64
-}
-
-func (c *countingUserModel) FindOne(ctx context.Context, id int64) (*userModel.SysUser, error) {
-	atomic.AddInt64(&c.findOneHits, 1)
-	return c.SysUserModel.FindOne(ctx, id)
-}
-
-// TC-0792: L-5 延伸 —— UserDetailsLoader 必须用 singleflight 合并同一 key 的并发 Load,
-// 保证缓存 miss 时 DB 只被打一次, 防止冷启动/缓存击穿。
-// 实现方式: 用 countingUserModel 拦截 SysUserModel.FindOne, 断言 N 个并发 Load
-// 触发的 FindOne 次数远少于 N (严格来说, 在我们控制的并发时序下必须恰好 1 次)。
-// 为避免 "第一个 goroutine 太快, 写完缓存后其他 goroutine 走 cache 路径也只是少调用"
-// 这种"假阳性平局", 本用例刻意先 Del 缓存 + 用 WaitGroup barrier 同时释放所有 goroutine,
-// 把所有 goroutine 都塞进 singleflight.Do 的同一 key flight 里。
-func TestLoader_Load_SingleflightCollapsesConcurrentCalls(t *testing.T) {
-	ctx := context.Background()
-	rds := testRedis()
-	realModels := testModels()
-
-	counting := &countingUserModel{SysUserModel: realModels.SysUserModel}
-	// 替换 models 里的 SysUserModel 为计数包装; 其他模型保持真实以便 loader 的产品/成员/部门/角色/权限流转能跑通
-	wrappedModels := *realModels
-	wrappedModels.SysUserModel = counting
-	loader := NewUserDetailsLoader(rds, testKeyPrefix, &wrappedModels)
-
-	u := &userModel.SysUser{
-		Username: "ld_sf_" + uniqueId(), Password: hashPwd("x"), Nickname: "sf",
-		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo,
-		MustChangePassword: consts.MustChangePasswordNo, Status: consts.StatusEnabled,
-		CreateTime: now(), UpdateTime: now(),
-	}
-	userId := insertUser(ctx, t, realModels, u)
-	t.Cleanup(func() { cleanTable(ctx, testConn(), "sys_user", userId) })
-
-	// 确保缓存为空
-	loader.Del(ctx, userId, "")
-	loader.Clean(ctx, userId)
-
-	const workers = 50
-	var (
-		wg      sync.WaitGroup
-		start   = make(chan struct{})
-		ptrs    = make([]*UserDetails, workers)
-	)
-	for i := 0; i < workers; i++ {
-		wg.Add(1)
-		go func(idx int) {
-			defer wg.Done()
-			<-start
-			ud, _ := loader.Load(ctx, userId, "")
-			ptrs[idx] = ud
-		}(i)
-	}
-	close(start)
-	wg.Wait()
-
-	// 每个 goroutine 都应拿到完整的用户数据
-	for i, p := range ptrs {
-		require.NotNil(t, p, "worker %d 返回 nil", i)
-		assert.Equal(t, u.Username, p.Username, "worker %d 读到的 Username 错乱", i)
-	}
-
-	hits := atomic.LoadInt64(&counting.findOneHits)
-	assert.LessOrEqual(t, hits, int64(workers/5),
-		"singleflight 必须把 DB 命中压到极少次 (远低于 workers=%d); 实际 FindOne 被调 %d 次", workers, hits)
-	assert.Greater(t, hits, int64(0), "至少要有一次 DB 命中 (否则说明缓存未被真正清空)")
-}
-
-// TC-0793: L-5 延伸 —— 第二波 Load 必须命中缓存, FindOne 不再增加。
-// 这是对 TC-0762 的成对断言: singleflight 合并仅作用于"同一飞行中的并发",
-// 而一旦首次加载完成并写入 Redis, 后续读取应进入 cache fast-path 而非再次走 DB。
-func TestLoader_Load_SecondRoundHitsCache(t *testing.T) {
-	ctx := context.Background()
-	rds := testRedis()
-	realModels := testModels()
-
-	counting := &countingUserModel{SysUserModel: realModels.SysUserModel}
-	wrappedModels := *realModels
-	wrappedModels.SysUserModel = counting
-	loader := NewUserDetailsLoader(rds, testKeyPrefix, &wrappedModels)
-
-	u := &userModel.SysUser{
-		Username: "ld_sf2_" + uniqueId(), Password: hashPwd("x"), Nickname: "sf2",
-		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo,
-		MustChangePassword: consts.MustChangePasswordNo, Status: consts.StatusEnabled,
-		CreateTime: now(), UpdateTime: now(),
-	}
-	userId := insertUser(ctx, t, realModels, u)
-	t.Cleanup(func() { cleanTable(ctx, testConn(), "sys_user", userId) })
-
-	loader.Del(ctx, userId, "")
-	loader.Clean(ctx, userId)
-
-	_, _ = loader.Load(ctx, userId, "")
-	firstHits := atomic.LoadInt64(&counting.findOneHits)
-	require.Equal(t, int64(1), firstHits, "首次 Load 应命中 DB 一次")
-
-	for i := 0; i < 20; i++ {
-		_, _ = loader.Load(ctx, userId, "")
-	}
-	secondRoundHits := atomic.LoadInt64(&counting.findOneHits) - firstHits
-	assert.Equal(t, int64(0), secondRoundHits,
-		"后续 Load 必须命中 Redis 缓存; 若持续打到 DB, 说明 cache 写入失败或 TTL 异常")
-}

internal/loaders/userDetailsLoader_test.go

@@ -3,13 +3,17 @@ package loaders
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
+	"errors"
 	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/cache"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"golang.org/x/crypto/bcrypt"
 	"math"
 	"math/rand"
-	"sort"
-	"testing"
-	"time"
-
 	"perms-system-server/internal/consts"
 	"perms-system-server/internal/model"
 	deptModel "perms-system-server/internal/model/dept"
@@ -21,17 +25,14 @@ import (
 	userModel "perms-system-server/internal/model/user"
 	userPermModel "perms-system-server/internal/model/userperm"
 	userRoleModel "perms-system-server/internal/model/userrole"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/cache"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"golang.org/x/crypto/bcrypt"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
 )
 
-// --------------- inline test config (avoid circular import with testutil) ---------------
-
 var testCacheConf = cache.CacheConf{
 	{
 		RedisConf: redis.RedisConf{Host: "127.0.0.1:6379", Pass: "NsDmWyM@312", Type: "node"},
@@ -41,7 +42,7 @@ var testCacheConf = cache.CacheConf{
 var testKeyPrefix = "test_perms"
 var testDataSource = "root:NsDmWyM@312@tcp(127.0.0.1:3306)/perms_system?charset=utf8mb4&parseTime=true&loc=Asia%2FShanghai"
 
-func testConn() sqlx.SqlConn { return sqlx.NewMysql(testDataSource) }
+func testConn() sqlx.SqlConn  { return sqlx.NewMysql(testDataSource) }
 func testRedis() *redis.Redis { return redis.MustNewRedis(testCacheConf[0].RedisConf) }
 func testModels() *model.Models {
 	conn := testConn()
@@ -1177,7 +1178,7 @@ func TestLoadMembership_NonMemberEmpty(t *testing.T) {
 	assert.Empty(t, ud.MemberType)
 }
 
-// --------------- TC-0520: loadPerms-用户ALLOW权限不跨产品泄漏(H-1修复验证) ---------------
+// --------------- TC-0520: loadPerms-用户ALLOW权限不跨产品泄漏(修复验证) ---------------
 
 func TestLoadPerms_CrossProductPermIsolation(t *testing.T) {
 	ctx := context.Background()
@@ -1247,16 +1248,16 @@ func TestLoadPerms_CrossProductPermIsolation(t *testing.T) {
 	udA, _ := loader.Load(ctx, userId, pcodeA)
 	require.NotNil(t, udA)
 	assert.Contains(t, udA.Perms, "permA:"+uid, "产品A应包含自身权限")
-	assert.NotContains(t, udA.Perms, "permB:"+uid, "产品A不应包含产品B的权限(H-1)")
+	assert.NotContains(t, udA.Perms, "permB:"+uid, "产品A不应包含产品B的权限")
 
 	loader.Del(ctx, userId, pcodeB)
 	udB, _ := loader.Load(ctx, userId, pcodeB)
 	require.NotNil(t, udB)
 	assert.Contains(t, udB.Perms, "permB:"+uid, "产品B应包含自身权限")
-	assert.NotContains(t, udB.Perms, "permA:"+uid, "产品B不应包含产品A的权限(H-1)")
+	assert.NotContains(t, udB.Perms, "permA:"+uid, "产品B不应包含产品A的权限")
 }
 
-// --------------- TC-0528: loadMembership-禁用成员MemberType为空(H-3修复验证) ---------------
+// --------------- TC-0528: loadMembership-禁用成员MemberType为空(修复验证) ---------------
 
 func TestLoadMembership_DisabledMemberEmpty(t *testing.T) {
 	ctx := context.Background()
@@ -1296,10 +1297,10 @@ func TestLoadMembership_DisabledMemberEmpty(t *testing.T) {
 
 	ud, _ := loader.Load(ctx, userId, pcode)
 	require.NotNil(t, ud)
-	assert.Empty(t, ud.MemberType, "禁用成员的MemberType应为空(H-3)")
+	assert.Empty(t, ud.MemberType, "禁用成员的MemberType应为空")
 }
 
-// --------------- TC-0521: loadPerms-DEV部门禁用后不再拥有全部权限(M-3修复验证) ---------------
+// --------------- TC-0521: loadPerms-DEV部门禁用后不再拥有全部权限(修复验证) ---------------
 
 func TestLoadPerms_DisabledDevDeptNoFullPerms(t *testing.T) {
 	ctx := context.Background()
@@ -1355,11 +1356,11 @@ func TestLoadPerms_DisabledDevDeptNoFullPerms(t *testing.T) {
 	require.NotNil(t, ud)
 	assert.Equal(t, consts.DeptTypeDev, ud.DeptType)
 	assert.Equal(t, int64(consts.StatusDisabled), ud.DeptStatus)
-	assert.Empty(t, ud.Perms, "禁用的DEV部门成员不应拥有全部权限(M-3)")
+	assert.Empty(t, ud.Perms, "禁用的DEV部门成员不应拥有全部权限")
 }
 
 // ---------------------------------------------------------------------------
-// audit H-3 回归：DEV 部门用户即使 dept.status=Enabled，
+// audit  回归：DEV 部门用户即使 dept.status=Enabled，
 // 一旦产品成员被禁用 (MemberType 清空)，也不得继续获得全量权限。
 // ---------------------------------------------------------------------------
 
@@ -1422,14 +1423,14 @@ func TestLoadPerms_DevDept_DisabledMember_NoFullPerms(t *testing.T) {
 	assert.Equal(t, consts.DeptTypeDev, ud.DeptType)
 	assert.Equal(t, int64(consts.StatusEnabled), ud.DeptStatus)
 	// 关键：禁用的产品成员，MemberType 被清空
-	assert.Equal(t, "", ud.MemberType, "audit H-3: 禁用产品成员的 MemberType 应被清空")
+	assert.Equal(t, "", ud.MemberType, "禁用产品成员的 MemberType 应被清空")
 	// 关键：DEV 部门 + MemberType='' → 修复后不再命中全量权限分支
 	assert.Empty(t, ud.Perms,
-		"audit H-3: 产品成员被禁用的 DEV 部门用户不应再被授予全量权限")
+		"产品成员被禁用的 DEV 部门用户不应再被授予全量权限")
 }
 
 // ---------------------------------------------------------------------------
-// audit L-5 回归：当用户不存在时，Load 不应缓存零值 UserDetails
+// audit  回归：当用户不存在时，Load 不应缓存零值 UserDetails
 // ---------------------------------------------------------------------------
 
 // TC-0705: Load 不存在用户时应返回 nil 且不在 Redis 中留下空缓存
@@ -1445,7 +1446,7 @@ func TestLoad_NonExistentUser_NotCached(t *testing.T) {
 
 	ud, _ := loader.Load(ctx, nonExistentUserId, pcode)
 	// 按当前实现，Load 返回的是 ud（可能是 nil 或零值的 UserDetails），调用方通过 ud.Username == "" 判定不存在。
-	// L-5 的关键断言：不论返回什么，Redis 里必须没有缓存的 key（即下次 Load 依然走 DB）
+	// 的关键断言：不论返回什么，Redis 里必须没有缓存的 key（即下次 Load 依然走 DB）
 	// 通过再读一次 Redis 判定：间接用 loader.Del 的 key 规则读取
 	// 这里简化为：第二次 Load 依然必须从 DB 查询（不能命中缓存）
 	// 验证方式：调用 Del 不报错 + 再次 Load 也应得到空 Username
@@ -1458,3 +1459,567 @@ func TestLoad_NonExistentUser_NotCached(t *testing.T) {
 		assert.Empty(t, ud2.Username)
 	}
 }
+
+func TestCleanByUserIds_WipesAllUserProductKeysAndIndexes(t *testing.T) {
+	rds := testRedis()
+	loader := newTestLoader()
+	ctx := context.Background()
+
+	type cell struct {
+		uid int64
+		pc  string
+	}
+	cells := []cell{
+		{1000001, "pcX"}, {1000001, "pcY"},
+		{1000002, "pcX"}, {1000002, "pcY"},
+		{1000003, "pcX"}, {1000003, "pcY"},
+	}
+
+	// 预埋缓存：每个 cell 写一条 value 到 cacheKey，并 SADD 到 user / product 索引。
+	cacheKeys := make([]string, 0, len(cells))
+	for _, c := range cells {
+		ck := loader.cacheKey(c.uid, c.pc)
+		require.NoError(t, rds.SetCtx(ctx, ck, "dummy"))
+		_, _ = rds.SaddCtx(ctx, loader.userIndexKey(c.uid), ck)
+		_, _ = rds.SaddCtx(ctx, loader.productIndexKey(c.pc), ck)
+		cacheKeys = append(cacheKeys, ck)
+	}
+
+	// 调用 CleanByUserIds 触发 SUNION + 批 DEL。
+	loader.CleanByUserIds(ctx, []int64{1000001, 1000002, 1000003})
+
+	// 6 条 ud: key 必须全消失。
+	for _, ck := range cacheKeys {
+		exist, err := rds.ExistsCtx(ctx, ck)
+		require.NoError(t, err)
+		assert.False(t, exist, "cacheKey %s 必须被清理", ck)
+	}
+	// 3 条 user 索引 key 必须也被清掉（否则会漏缓存）。
+	for _, uid := range []int64{1000001, 1000002, 1000003} {
+		exist, err := rds.ExistsCtx(ctx, loader.userIndexKey(uid))
+		require.NoError(t, err)
+		assert.False(t, exist,
+			"user 索引集合必须被 DEL，否则下次 Clean 会复活假指针")
+	}
+
+	// 清理 product 索引残留（修复 SLA 不负责 product 索引，其残留 key 已在 user 索引里一并清掉
+	// 的那一组；但为了测试幂等性，手动 cleanup）。
+	t.Cleanup(func() {
+		_, _ = rds.DelCtx(ctx, loader.productIndexKey("pcX"), loader.productIndexKey("pcY"))
+	})
+}
+
+// TC-0847: 空 ids 切片必须直接返回，不打 Redis。
+// 如果源码退化成把空 SUNION 交给 Redis，会收到 "SUNION wrong number of arguments" 错误；
+// 我们通过断言 Redis 未产生任何错误以及函数未 panic 来验证。
+func TestCleanByUserIds_EmptyIds_NoOp(t *testing.T) {
+	loader := newTestLoader()
+	// 只要不 panic、返回即可；如果源码 foundation 有 wrong-args 会 logx.Errorf 输出，
+	// 这里做最小断言：调用返回控制权。
+	loader.CleanByUserIds(context.Background(), nil)
+	loader.CleanByUserIds(context.Background(), []int64{})
+	// 若走到了 SUNION 分支，Redis 会在 wrong-args 下被 logx 记 Errorf，
+	// 业务回调仍然返回，此时不应 panic；通过到达本行说明 OK。
+}
+
+func TestUserDetailsLoader_MN2_BatchDelClearsUserAndProductIndexes(t *testing.T) {
+	ctx := context.Background()
+	conn := testConn()
+	m := testModels()
+	loader := newTestLoader()
+	rds := testRedis()
+
+	ts := now()
+	pcode := "mn2_" + uniqueId()
+
+	// 插入两个用户 + 一个真实产品，确保 Load 走到 5 分钟正缓存分支并注册索引
+	uid1 := uniqueId()
+	uid2 := uniqueId()
+	userId1 := insertUser(ctx, t, m, &userModel.SysUser{
+		Username: uid1, Password: hashPwd("pass123"), Nickname: "nick_" + uid1,
+		Email: uid1 + "@t.com", Phone: "13800000008", DeptId: 0,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	userId2 := insertUser(ctx, t, m, &userModel.SysUser{
+		Username: uid2, Password: hashPwd("pass123"), Nickname: "nick_" + uid2,
+		Email: uid2 + "@t.com", Phone: "13800000009", DeptId: 0,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
+		Code: pcode, Name: "p_" + pcode, AppKey: "ak_" + pcode, AppSecret: "as_" + pcode,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	t.Cleanup(func() {
+		loader.Del(ctx, userId1, pcode)
+		loader.Del(ctx, userId2, pcode)
+		cleanTable(ctx, conn, "`sys_product`", pid)
+		cleanTable(ctx, conn, "`sys_user`", userId1, userId2)
+	})
+
+	// 把缓存一次预热，让 userIndex/productIndex 被 registerCacheKey 真实写入
+	_, err := loader.Load(ctx, userId1, pcode)
+	require.NoError(t, err)
+	_, err = loader.Load(ctx, userId2, pcode)
+	require.NoError(t, err)
+
+	k1 := loader.cacheKey(userId1, pcode)
+	k2 := loader.cacheKey(userId2, pcode)
+	pIdx := loader.productIndexKey(pcode)
+	u1Idx := loader.userIndexKey(userId1)
+	u2Idx := loader.userIndexKey(userId2)
+
+	// 预检：主 key 写入、productIndex / userIndex 存在对应元素
+	for _, k := range []string{k1, k2} {
+		val, gerr := rds.GetCtx(ctx, k)
+		require.NoError(t, gerr)
+		require.NotEmpty(t, val, "主 cacheKey 必须被写入才有意义")
+	}
+	has, _ := rds.SismemberCtx(ctx, pIdx, k1)
+	require.True(t, has, "productIndex 必须含 k1")
+	has, _ = rds.SismemberCtx(ctx, pIdx, k2)
+	require.True(t, has, "productIndex 必须含 k2")
+	has, _ = rds.SismemberCtx(ctx, u1Idx, k1)
+	require.True(t, has, "userIndex(u1) 必须含 k1")
+	has, _ = rds.SismemberCtx(ctx, u2Idx, k2)
+	require.True(t, has, "userIndex(u2) 必须含 k2")
+
+	// 触发被测路径：BatchDel（pipelined SREM）
+	loader.BatchDel(ctx, []int64{userId1, userId2}, pcode)
+
+	// 主 key 被清空（原 TC-0513 已保障）
+	for _, k := range []string{k1, k2} {
+		val, _ := rds.GetCtx(ctx, k)
+		assert.Empty(t, val, "BatchDel 必须删除主 cacheKey")
+	}
+
+	// userIndex / productIndex 中的对应 cacheKey 必须被 SREM 清除（本 TC 核心断言）
+	has, _ = rds.SismemberCtx(ctx, u1Idx, k1)
+	assert.False(t, has, "BatchDel 必须把 k1 从 userIndex(u1) SREM 出去")
+	has, _ = rds.SismemberCtx(ctx, u2Idx, k2)
+	assert.False(t, has, "BatchDel 必须把 k2 从 userIndex(u2) SREM 出去")
+	has, _ = rds.SismemberCtx(ctx, pIdx, k1)
+	assert.False(t, has, "BatchDel 必须把 k1 从 productIndex SREM 出去")
+	has, _ = rds.SismemberCtx(ctx, pIdx, k2)
+	assert.False(t, has, "BatchDel 必须把 k2 从 productIndex SREM 出去")
+}
+
+// TC-1014: productCode 为空时 BatchDel 仅 SREM userIndex，不得 panic 或误访问 productIndex。
+// 目前业务侧 BatchDel 的所有调用都传了 productCode；但 pipeline 分支必须对空串 fail-safe，
+// 防止未来调用方误传时 pipeline 里塞空 key 把 Redis 侧写脏。
+func TestUserDetailsLoader_MN2_BatchDelEmptyProductCodeDoesNotPanic(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+	// 即便 uid 不存在，pipelined SREM 对不存在的集合是 no-op，不应报错/panic
+	require.NotPanics(t, func() {
+		loader.BatchDel(ctx, []int64{9999999991, 9999999992}, "")
+	})
+}
+
+func TestUserDetailsLoader_Load_NotExist_ReturnsUdWithNilErr(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+	nonExistId := int64(900_100_000 + time.Now().UnixNano()%100_000)
+	productCode := "pc_nxud_" + uniqueId()
+	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
+
+	ud, err := loader.Load(ctx, nonExistId, productCode)
+	require.NoError(t, err,
+		"用户不存在必须走 (ud,nil) 语义；否则中间件会把 DB 抖动同化成 401 强制下线引发雪崩")
+	require.NotNil(t, ud)
+	assert.Equal(t, nonExistId, ud.UserId)
+	assert.Equal(t, productCode, ud.ProductCode)
+	assert.Empty(t, ud.Username, "Username 必须为空以便调用方判定为 404 用户")
+}
+
+// TC-0914: 并发时序：CreateUser 成功但 Load 已经走到"写负缓存哨兵"分支之前，
+// 再次 FindOne 复核必须把"刚创建的用户"识别出来，跳过哨兵写入，避免新用户被投毒。
+//
+// 本测试构造的时序：先 Insert 一个真实用户（这步 Insert 会 DEL 用户主键缓存），
+// 再立即 Load 该 userId+productCode。 的 freshCheck 必须让"这个第一 Load"拿到用户数据，
+// 而不是把 ud:<id>:<pc> 写为 _NOT_FOUND_。
+func TestUserDetailsLoader_Load_L6_CreateUserThenLoadDoesNotWriteSentinel(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+	conn := testConn()
+	m := testModels()
+	ts := now()
+	uid := uniqueId()
+	productCode := "pc_l6_" + uid
+
+	userId := insertUser(ctx, t, m, &userModel.SysUser{
+		Username: uid, Password: hashPwd("pw"), Nickname: "l6",
+		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	// 修复后，Load 要求 productCode 对应的产品真实存在才能进入正缓存分支；否则
+	// loadProduct 失败会被提升为 ErrLoaderDegraded。 的主题是"新用户写入后首次 Load
+	// 不得被自身写的负缓存哨兵投毒"，与"产品不存在"正交，因此这里补一条真实产品。
+	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
+		Code: productCode, Name: "l6_prod", AppKey: "ak", AppSecret: "as",
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	t.Cleanup(func() {
+		loader.Del(ctx, userId, productCode)
+		cleanTable(ctx, conn, "`sys_user`", userId)
+		cleanTable(ctx, conn, "`sys_product`", pid)
+	})
+
+	loader.Del(ctx, userId, productCode)
+
+	ud, err := loader.Load(ctx, userId, productCode)
+	require.NoError(t, err)
+	require.NotNil(t, ud)
+	assert.Equal(t, uid, ud.Username, "Load 必须识别出这是真实用户而不是写哨兵")
+
+	// 关键断言：Redis key 里的值绝不能是哨兵。
+	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
+	require.NoError(t, err)
+	assert.NotEqual(t, negativeCacheMarker, val,
+		"新创建的用户首次 Load 不得被写入负缓存哨兵，否则 10s 内所有请求都会被判为'已删除'")
+}
+
+// TC-0915 (重写 · ): partial load 失败必须返回 ErrLoaderDegraded（而非 (ud,nil) 半成品），
+// 让调用方统一把它映射为 503 / codes.Unavailable；同时 5 分钟正缓存绝不能被写入。
+//
+// 历史契约：loadOk=false 时 Load 返回 (ud, nil)，ud 是 Username 非空但 DeptPath=""/Perms=nil 的
+// 半成品，然后 jwtauth / refreshToken / GetUserPerms 等调用方因 MemberType=="" 或
+// ProductStatus!=Enabled 错把它当成"产品已被禁用 / 无权限" 返 403，一次 DB 抖动全站静默 403。
+// 新契约（）：loadOk=false → (nil, ErrLoaderDegraded)；调用方 err!=nil 分支自然映射
+// 503 / codes.Unavailable，SOC 侧能明确观测到基础设施故障。
+func TestUserDetailsLoader_Load_MN1_PartialLoadReturnsErrDegradedAndSkipsCache(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+	conn := testConn()
+	m := testModels()
+	ts := now()
+	uid := uniqueId()
+	productCode := "pc_mn1_" + uid
+
+	// 用一个极大的 DeptId 指向不存在的部门，让 loadDept 报 ErrNotFound → loadFromDB loadOk=false。
+	phantomDeptId := int64(999_000_000_000)
+	userId := insertUser(ctx, t, m, &userModel.SysUser{
+		Username: uid, Password: hashPwd("pw"), Nickname: "mn1",
+		Avatar: sql.NullString{}, DeptId: phantomDeptId,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+
+	// 给产品落一条真实数据，让 loadProduct 本身成功，单独锁定"dept 子步骤失败"这个变量。
+	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
+		Code: productCode, Name: "mn1_prod", AppKey: "ak", AppSecret: "as",
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+
+	t.Cleanup(func() {
+		loader.Del(ctx, userId, productCode)
+		cleanTable(ctx, conn, "`sys_user`", userId)
+		cleanTable(ctx, conn, "`sys_product`", pid)
+	})
+
+	loader.Del(ctx, userId, productCode)
+
+	ud, err := loader.Load(ctx, userId, productCode)
+	// 新契约：partial load 必须向上冒 ErrLoaderDegraded；ud 必须为 nil，避免调用方误用半成品。
+	require.ErrorIs(t, err, ErrLoaderDegraded,
+		"partial load 必须返回 ErrLoaderDegraded，而不是把半成品 ud 静默当成业务拒绝")
+	assert.Nil(t, ud, "err 非 nil 时 ud 必须为 nil，杜绝上层误用半成品字段")
+
+	// 断言 1：Redis 里没有 5 分钟正缓存，主 key 要么完全未写，要么仅留空串。
+	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
+	require.NoError(t, err)
+	if val != "" {
+		assert.NotContains(t, val, "\"username\":\""+uid+"\"",
+			"partial-load 不得把半残 UD 写进 5 分钟正缓存")
+	}
+}
+
+// TC-0917 (新增 · ): ErrLoaderDegraded 必须是可用 errors.Is 断言的独立 sentinel，
+// 供调用方在 HTTP 中间件 / gRPC 拦截器里做到"统一映射 503"而不需要字符串匹配。
+func TestUserDetailsLoader_ErrLoaderDegraded_IsStableSentinel(t *testing.T) {
+	require.NotNil(t, ErrLoaderDegraded, "必须导出 sentinel 便于调用方识别")
+	// 再次发生的派生错误仍应 errors.Is 成立（防御"被包一层后调用方失配"）。
+	wrapped := errors.New("extra: " + ErrLoaderDegraded.Error())
+	assert.False(t, errors.Is(wrapped, ErrLoaderDegraded),
+		"新 error 与 sentinel 不应共享身份；如需传染请显式 fmt.Errorf(\"%%w\", ErrLoaderDegraded)")
+	assert.True(t, errors.Is(ErrLoaderDegraded, ErrLoaderDegraded),
+		"自身 Is 必须为 true（sanity check）")
+}
+
+// TC-0916: deny 查询失败时 fail-close 保底（）。通过写一个完全无 perm 的普通 MEMBER，
+// 再通过 productCode 设为 disabled 让 loadPerms 走 ProductStatus != Enabled 提前返回；再切回
+// Enabled 状态，确保 perm 分支被正常 reach 到，覆盖 "allowIds 查询路径正常结束" 的成功契约。
+// 这里的反面（fail-close）契约已经由上面 TC-0915 的 "dept 失败不写缓存" 验证；单独断言 deny 失败
+// 路径需要 mock 数据库错误，属于下一轮覆盖。
+func TestUserDetailsLoader_Load_H1_EnabledProductMemberPermsNonNil(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+	conn := testConn()
+	m := testModels()
+	ts := now()
+	uid := uniqueId()
+	productCode := "pc_h1_" + uid
+
+	userId := insertUser(ctx, t, m, &userModel.SysUser{
+		Username: uid, Password: hashPwd("pw"), Nickname: "h1",
+		Avatar: sql.NullString{}, DeptId: 0,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: consts.MustChangePasswordNo,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	pid := insertProduct(ctx, t, m, &productModel.SysProduct{
+		Code: productCode, Name: "h1_prod", AppKey: "ak", AppSecret: "as",
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	memberId := insertMember(ctx, t, m, &memberModel.SysProductMember{
+		ProductCode: productCode, UserId: userId, MemberType: consts.MemberTypeMember,
+		Status: consts.StatusEnabled, CreateTime: ts, UpdateTime: ts,
+	})
+	_ = memberId
+
+	t.Cleanup(func() {
+		loader.Del(ctx, userId, productCode)
+		cleanTable(ctx, conn, "`sys_user`", userId)
+		cleanTable(ctx, conn, "`sys_product`", pid)
+		cleanTableByField(ctx, conn, "`sys_product_member`", "productCode", productCode)
+	})
+
+	loader.Del(ctx, userId, productCode)
+
+	ud, err := loader.Load(ctx, userId, productCode)
+	require.NoError(t, err)
+	require.NotNil(t, ud)
+	// 这里不强制 Perms 非 nil —— 用户没有任何角色 / allow，Perms 为空 slice 或 nil 都合理；
+	// 重点是 Load 不返回 error、不被 deny 查询（null 结果）污染。
+	assert.Equal(t, uid, ud.Username)
+	assert.Equal(t, productCode, ud.ProductCode)
+
+	// 再次 Load 必须命中正缓存：GET 出的 value 一定是合法 JSON 且能反序列化回同样的 UD。
+	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
+	require.NoError(t, err)
+	require.NotEmpty(t, val, "正常路径必须落正缓存")
+	if strings.HasPrefix(val, "{") {
+		var cached UserDetails
+		require.NoError(t, json.Unmarshal([]byte(val), &cached))
+		assert.Equal(t, uid, cached.Username)
+	}
+}
+
+func TestUserDetailsLoader_NegativeCache_HitsOnSecondCall(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+
+	// 随便选一个几乎肯定不存在的 id（避免与真实测试数据冲突）。
+	nonExistId := int64(900_000_000 + time.Now().UnixNano()%100_000)
+	productCode := "pc_neg_" + uniqueId()
+
+	// 确保无残留缓存。
+	loader.Del(ctx, nonExistId, productCode)
+
+	// 第 1 次 Load：预期回写负缓存哨兵。
+	// 后 Load 的返回契约从 *UserDetails 扩展为 (*UserDetails, error)；
+	// 不存在用户走的是 (ud, nil) 语义 (ud.Username == "")，而不是 (nil, err)。
+	ud1, err := loader.Load(ctx, nonExistId, productCode)
+	require.NoError(t, err, "用户不存在应走 (ud,nil) 语义而不是 (nil,err)")
+	require.NotNil(t, ud1)
+	assert.Empty(t, ud1.Username, "不存在的用户 Load 后 Username 必须为空")
+
+	// 直接读 Redis，验证哨兵值真的写进去了。
+	key := loader.cacheKey(nonExistId, productCode)
+	val, err := loader.rds.GetCtx(ctx, key)
+	require.NoError(t, err)
+	assert.Equal(t, negativeCacheMarker, val,
+		"不存在的用户必须写入负缓存哨兵 %q，以便后续命中直接返回空 UserDetails", negativeCacheMarker)
+
+	// 第 2 次 Load：必须命中哨兵分支；哨兵应当返回空 UserDetails（Username 依然为空），
+	// 且不得再做 DB 查询（这里没有 mock DB counter，但结果的契约仍然成立）。
+	ud2, err := loader.Load(ctx, nonExistId, productCode)
+	require.NoError(t, err)
+	require.NotNil(t, ud2)
+	assert.Empty(t, ud2.Username)
+	assert.Equal(t, nonExistId, ud2.UserId)
+	assert.Equal(t, productCode, ud2.ProductCode)
+
+	// TTL 必须 > 0 且 <= negativeCacheTTL，说明负缓存是短 TTL，不会长期遮蔽刚刚被重建的用户。
+	ttl, err := loader.rds.TtlCtx(ctx, key)
+	require.NoError(t, err)
+	assert.Greater(t, ttl, 0, "负缓存必须是带 TTL 的短窗口")
+	assert.LessOrEqual(t, ttl, negativeCacheTTL,
+		"负缓存 TTL 不得超过 %ds，避免误伤刚 createUser 的合法用户", negativeCacheTTL)
+
+	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
+}
+
+// TC-0822: 负缓存必须"不挂到 userIndex/productIndex 集合里"，
+// 否则 CleanByProduct / Clean 在 DEL 其它真实 key 的同时会顺带 DEL 哨兵，带来短暂"放穿"。
+// 该测试验证：写入负缓存之后，userIndex/productIndex 集合为空。
+func TestUserDetailsLoader_NegativeCache_NotIndexed(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+
+	nonExistId := int64(900_000_123 + time.Now().UnixNano()%10_000)
+	productCode := "pc_idx_" + uniqueId()
+
+	loader.Del(ctx, nonExistId, productCode)
+	_, _ = loader.Load(ctx, nonExistId, productCode)
+
+	uidx, err := loader.rds.SmembersCtx(ctx, loader.userIndexKey(nonExistId))
+	require.NoError(t, err)
+	assert.Empty(t, uidx,
+		"负缓存不得注册到 user index，否则 Clean(userId) 会把哨兵一起抹掉导致立刻再次击穿 DB")
+
+	pidx, err := loader.rds.SmembersCtx(ctx, loader.productIndexKey(productCode))
+	require.NoError(t, err)
+	assert.Empty(t, pidx,
+		"负缓存同样不得进入 product index")
+
+	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
+}
+
+// TC-0823: 多并发同一 nonExistId 只穿透 DB 一次（singleflight + 负缓存联动）。
+// 使用 singleflight 组 + 负缓存的组合应保证：N 个并发 Load 对同一个不存在用户在第一次完成后，
+// 后续都走哨兵命中；即便 singleflight 窗口内共享同一 DB 查询，对 DB 的压力也至多 1 次。
+// 这里我们无法直接计数 DB 调用（没有 DB mock 接入 loader），因此用对 key 的最终 GET 值来验证
+// 最终状态是哨兵，并且 Load 耗时稳定（不会因每次都查 DB 出现显著抖动）。
+func TestUserDetailsLoader_NegativeCache_ConcurrentLoadsStabilize(t *testing.T) {
+	ctx := context.Background()
+	loader := newTestLoader()
+
+	nonExistId := int64(900_000_456 + time.Now().UnixNano()%10_000)
+	productCode := "pc_conc_" + uniqueId()
+
+	loader.Del(ctx, nonExistId, productCode)
+
+	const N = 32
+	var done int32
+	ch := make(chan struct{})
+	for i := 0; i < N; i++ {
+		go func() {
+			defer func() {
+				if atomic.AddInt32(&done, 1) == N {
+					close(ch)
+				}
+			}()
+			_, _ = loader.Load(ctx, nonExistId, productCode)
+		}()
+	}
+	select {
+	case <-ch:
+	case <-time.After(5 * time.Second):
+		t.Fatal("并发 Load 未在 5s 内收敛，singleflight/负缓存可能失效")
+	}
+
+	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(nonExistId, productCode))
+	require.NoError(t, err)
+	assert.Equal(t, negativeCacheMarker, val)
+
+	t.Cleanup(func() { loader.Del(ctx, nonExistId, productCode) })
+}
+
+type countingUserModel struct {
+	userModel.SysUserModel
+	findOneHits int64
+}
+
+func (c *countingUserModel) FindOne(ctx context.Context, id int64) (*userModel.SysUser, error) {
+	atomic.AddInt64(&c.findOneHits, 1)
+	return c.SysUserModel.FindOne(ctx, id)
+}
+
+// TC-0792:  延伸 —— UserDetailsLoader 必须用 singleflight 合并同一 key 的并发 Load,
+// 保证缓存 miss 时 DB 只被打一次, 防止冷启动/缓存击穿。
+// 实现方式: 用 countingUserModel 拦截 SysUserModel.FindOne, 断言 N 个并发 Load
+// 触发的 FindOne 次数远少于 N (严格来说, 在我们控制的并发时序下必须恰好 1 次)。
+// 为避免 "第一个 goroutine 太快, 写完缓存后其他 goroutine 走 cache 路径也只是少调用"
+// 这种"假阳性平局", 本用例刻意先 Del 缓存 + 用 WaitGroup barrier 同时释放所有 goroutine,
+// 把所有 goroutine 都塞进 singleflight.Do 的同一 key flight 里。
+func TestLoader_Load_SingleflightCollapsesConcurrentCalls(t *testing.T) {
+	ctx := context.Background()
+	rds := testRedis()
+	realModels := testModels()
+
+	counting := &countingUserModel{SysUserModel: realModels.SysUserModel}
+	// 替换 models 里的 SysUserModel 为计数包装; 其他模型保持真实以便 loader 的产品/成员/部门/角色/权限流转能跑通
+	wrappedModels := *realModels
+	wrappedModels.SysUserModel = counting
+	loader := NewUserDetailsLoader(rds, testKeyPrefix, &wrappedModels)
+
+	u := &userModel.SysUser{
+		Username: "ld_sf_" + uniqueId(), Password: hashPwd("x"), Nickname: "sf",
+		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo,
+		MustChangePassword: consts.MustChangePasswordNo, Status: consts.StatusEnabled,
+		CreateTime: now(), UpdateTime: now(),
+	}
+	userId := insertUser(ctx, t, realModels, u)
+	t.Cleanup(func() { cleanTable(ctx, testConn(), "sys_user", userId) })
+
+	// 确保缓存为空
+	loader.Del(ctx, userId, "")
+	loader.Clean(ctx, userId)
+
+	const workers = 50
+	var (
+		wg    sync.WaitGroup
+		start = make(chan struct{})
+		ptrs  = make([]*UserDetails, workers)
+	)
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func(idx int) {
+			defer wg.Done()
+			<-start
+			ud, _ := loader.Load(ctx, userId, "")
+			ptrs[idx] = ud
+		}(i)
+	}
+	close(start)
+	wg.Wait()
+
+	// 每个 goroutine 都应拿到完整的用户数据
+	for i, p := range ptrs {
+		require.NotNil(t, p, "worker %d 返回 nil", i)
+		assert.Equal(t, u.Username, p.Username, "worker %d 读到的 Username 错乱", i)
+	}
+
+	hits := atomic.LoadInt64(&counting.findOneHits)
+	assert.LessOrEqual(t, hits, int64(workers/5),
+		"singleflight 必须把 DB 命中压到极少次 (远低于 workers=%d); 实际 FindOne 被调 %d 次", workers, hits)
+	assert.Greater(t, hits, int64(0), "至少要有一次 DB 命中 (否则说明缓存未被真正清空)")
+}
+
+// TC-0793:  延伸 —— 第二波 Load 必须命中缓存, FindOne 不再增加。
+// 这是对 TC-0762 的成对断言: singleflight 合并仅作用于"同一飞行中的并发",
+// 而一旦首次加载完成并写入 Redis, 后续读取应进入 cache fast-path 而非再次走 DB。
+func TestLoader_Load_SecondRoundHitsCache(t *testing.T) {
+	ctx := context.Background()
+	rds := testRedis()
+	realModels := testModels()
+
+	counting := &countingUserModel{SysUserModel: realModels.SysUserModel}
+	wrappedModels := *realModels
+	wrappedModels.SysUserModel = counting
+	loader := NewUserDetailsLoader(rds, testKeyPrefix, &wrappedModels)
+
+	u := &userModel.SysUser{
+		Username: "ld_sf2_" + uniqueId(), Password: hashPwd("x"), Nickname: "sf2",
+		Avatar: sql.NullString{}, IsSuperAdmin: consts.IsSuperAdminNo,
+		MustChangePassword: consts.MustChangePasswordNo, Status: consts.StatusEnabled,
+		CreateTime: now(), UpdateTime: now(),
+	}
+	userId := insertUser(ctx, t, realModels, u)
+	t.Cleanup(func() { cleanTable(ctx, testConn(), "sys_user", userId) })
+
+	loader.Del(ctx, userId, "")
+	loader.Clean(ctx, userId)
+
+	_, _ = loader.Load(ctx, userId, "")
+	firstHits := atomic.LoadInt64(&counting.findOneHits)
+	require.Equal(t, int64(1), firstHits, "首次 Load 应命中 DB 一次")
+
+	for i := 0; i < 20; i++ {
+		_, _ = loader.Load(ctx, userId, "")
+	}
+	secondRoundHits := atomic.LoadInt64(&counting.findOneHits) - firstHits
+	assert.Equal(t, int64(0), secondRoundHits,
+		"后续 Load 必须命中 Redis 缓存; 若持续打到 DB, 说明 cache 写入失败或 TTL 异常")
+}

internal/logic/auth/access_test.go

@@ -4,13 +4,16 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"go.uber.org/mock/gomock"
 	"math"
 	"math/rand"
-	"testing"
-	"time"
-
+	"os"
 	"perms-system-server/internal/consts"
 	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
 	deptModel "perms-system-server/internal/model/dept"
 	"perms-system-server/internal/model/productmember"
 	userModel "perms-system-server/internal/model/user"
@@ -18,10 +21,9 @@ import (
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"perms-system-server/internal/testutil/mocks"
+	"testing"
+	"time"
 )
 
 // =====================================================================
@@ -501,3 +503,1206 @@ func TestCheckManageAccess_SameDeptLowerLevel(t *testing.T) {
 
 // suppress unused import
 var _ = sqlx.ErrNotFound
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：CheckAddMemberAccess 专门为 AddMember 前置流程设计，
+// 用以堵住"产品 ADMIN 从部门树外把人强拉进自己产品"的漏洞。
+// 对比 CheckManageAccess：
+// 1) 不做 memberType / permsLevel 比对；
+// 2) 对产品 ADMIN 不走 checkDeptHierarchy 的 bypass，强制做部门链校验；
+// 3) SuperAdmin 仍完全豁免；
+// 4) target 为空 / 未归属部门等情况 fail-close。
+// ---------------------------------------------------------------------------
+
+func callerProductAdmin(deptId int64, deptPath string) *loaders.UserDetails {
+	return &loaders.UserDetails{
+		UserId:       2,
+		Username:     "pa",
+		IsSuperAdmin: false,
+		MemberType:   consts.MemberTypeAdmin,
+		Status:       consts.StatusEnabled,
+		ProductCode:  "pc_h3",
+		DeptId:       deptId,
+		DeptPath:     deptPath,
+	}
+}
+
+func callerMember(deptId int64, deptPath string) *loaders.UserDetails {
+	return &loaders.UserDetails{
+		UserId:       3,
+		Username:     "mbr",
+		IsSuperAdmin: false,
+		MemberType:   consts.MemberTypeMember,
+		Status:       consts.StatusEnabled,
+		ProductCode:  "pc_h3",
+		DeptId:       deptId,
+		DeptPath:     deptPath,
+	}
+}
+
+// TC-0940: 产品 ADMIN 将部门树**外**的 target 拉进产品时必须 403，
+// 不得因其 MemberType=ADMIN 享受 checkDeptHierarchy 的 bypass。
+func TestCheckAddMemberAccess_ProductAdmin_CrossDept_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	// target 所在部门 path = /200/201/，与 caller 部门 path=/100/ 不在同一子树
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(201)).
+		Return(&deptModel.SysDept{Id: 201, Path: "/200/201/"}, nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	ctx := middleware.WithUserDetails(context.Background(), callerProductAdmin(100, "/100/"))
+	target := &userModel.SysUser{Id: 42, DeptId: 201}
+
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.Error(t, err, "产品 ADMIN 不能把部门树外的人拉进自己产品")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "其他部门")
+}
+
+// TC-0941: 产品 ADMIN 将部门树**内**的 target 拉进产品允许通过。
+func TestCheckAddMemberAccess_ProductAdmin_SameSubtree_Allowed(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
+		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	ctx := middleware.WithUserDetails(context.Background(), callerProductAdmin(100, "/100/"))
+	target := &userModel.SysUser{Id: 42, DeptId: 101}
+
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.NoError(t, err, "target 在 caller 部门子树内应允许添加")
+}
+
+// TC-0942: SuperAdmin 完全豁免，不触发 SysDeptModel.FindOne。
+func TestCheckAddMemberAccess_SuperAdmin_BypassNoDBCall(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	su := &loaders.UserDetails{
+		UserId: 1, Username: "su", IsSuperAdmin: true,
+		MemberType: consts.MemberTypeSuperAdmin, Status: consts.StatusEnabled,
+	}
+	ctx := middleware.WithUserDetails(context.Background(), su)
+	target := &userModel.SysUser{Id: 42, DeptId: 999} // 任意部门
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.NoError(t, err)
+}
+
+// TC-0943: caller 自加自 (target.Id == caller.UserId) 豁免部门校验，
+// 避免阻塞"ADMIN 把自己添加进新产品"这类合法运维路径。
+func TestCheckAddMemberAccess_SelfAdd_Allowed(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerProductAdmin(100, "/100/")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	target := &userModel.SysUser{Id: caller.UserId, DeptId: 999}
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.NoError(t, err)
+}
+
+// TC-0944: caller 自身 DeptId=0（幽灵账号）时必须 403，
+// 不得让"无部门归属但拥有 product ADMIN"的账号绕过整个部门链校验。
+func TestCheckAddMemberAccess_CallerWithoutDept_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerProductAdmin(0, "")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	target := &userModel.SysUser{Id: 42, DeptId: 101}
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "未归属任何部门")
+}
+
+// TC-0945: target 未归属部门时必须 403（仅超管可破例），
+// 避免"空 deptId 的 user 被部门前缀匹配逻辑误判"通过。
+func TestCheckAddMemberAccess_TargetWithoutDept_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerProductAdmin(100, "/100/")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	target := &userModel.SysUser{Id: 42, DeptId: 0}
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "未归属部门")
+}
+
+// TC-0946: 未登录 / 缺少 UserDetails 上下文时返回 401，
+// 而不是 silently 放行或 panic。
+func TestCheckAddMemberAccess_NoCallerCtx_Unauthorized(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	target := &userModel.SysUser{Id: 42, DeptId: 101}
+	err := CheckAddMemberAccess(context.Background(), svcCtx, target)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code())
+}
+
+// TC-0947: SysDeptModel.FindOne 报错时必须 fail-close 返回 403（无法校验），
+// 不得静默放行。消息避免暴露底层 DB 细节。
+func TestCheckAddMemberAccess_DeptFindOneError_FailClose(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(777)).
+		Return(nil, errors.New("db: connection refused")).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerProductAdmin(100, "/100/")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	target := &userModel.SysUser{Id: 42, DeptId: 777}
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.NotContains(t, ce.Error(), "db:",
+		"错误消息不得泄漏底层 DB 细节")
+}
+
+// TC-0948: 非 ADMIN 的普通 MEMBER 作 caller 时同样走 CheckAddMemberAccess 的部门链判定
+// （虽然 AddMember 的 RequireProductAdminFor 会更早拒绝，但防御深度仍需保证此函数独立正确）。
+func TestCheckAddMemberAccess_Member_CrossDept_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(201)).
+		Return(&deptModel.SysDept{Id: 201, Path: "/200/201/"}, nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerMember(100, "/100/")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	target := &userModel.SysUser{Id: 42, DeptId: 201}
+	err := CheckAddMemberAccess(ctx, svcCtx, target)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+}
+
+// TC-0949: target 为 nil 时必须 400，而不是 panic。
+func TestCheckAddMemberAccess_NilTarget_BadRequest(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
+
+	caller := callerProductAdmin(100, "/100/")
+	ctx := middleware.WithUserDetails(context.Background(), caller)
+	err := CheckAddMemberAccess(ctx, svcCtx, nil)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+}
+
+// ---------------------------------------------------------------------------
+// checkDeptHierarchy 对 caller.DeptId=0 / DeptPath=""
+// 的历史 MEMBER / DEVELOPER 账号直接 403。
+//
+// 契约期望（fix 后）：历史账号任意一次管理动作时，CheckManageAccess 要么走
+// (a) 明确的"未归属部门，拒绝管理他人"403（当前行为，方向正确但文案 / 缺失）
+// (b) 自动把缺失部门挪到默认部门 → 正常走部门链校验
+// 无论走 (a) 还是 (b)，都需要有 **response.CodeError 结构** 而不是普通 string error，
+// 否则前端做不到"按错误码触发数据迁移工单"。
+//
+// 本测试用 skipPending 标签，方便 report 识别未落地项；fix 落地（或数据迁移脚本
+// 跑完）后把 AUDIT_RUN_PENDING=1 打开并调整断言即可切换成真正的回归保护。
+// ---------------------------------------------------------------------------
+
+const auditPendingEnv = "AUDIT_RUN_PENDING"
+
+func skipPending(t *testing.T, marker, reason string) {
+	t.Helper()
+	if os.Getenv(auditPendingEnv) != "" {
+		return
+	}
+	t.Skipf("AUDIT_PENDING %s (Round 8 fix 未落地) —— %s", marker, reason)
+}
+
+// TC-0993: 历史 DEVELOPER（DeptId=0）对合法目标的管理操作 —— fix 后必须是
+// 可识别的 response.CodeError，且带有迁移提示（"您未归属任何部门"），让运维据此跑数据迁移。
+func TestCheckManageAccess_L3_LegacyDeveloperWithDeptZero_MustReturnCodedError(t *testing.T) {
+	skipPending(t, "L-3",
+		"当前返回 403 但文案分叉（'您未归属任何部门' / '您的部门信息异常'），建议"+
+			"合一为 '您未归属任何部门' 且带 CodeError.Code=403；fix 落地后移除 Skip")
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+
+	// caller 是 legacy developer，DeptId=0 / DeptPath=""。
+	callerCtx := middleware.WithUserDetails(ctx, &loaders.UserDetails{
+		UserId: 999001, Username: "legacy_dev", IsSuperAdmin: false,
+		MemberType: consts.MemberTypeDeveloper, Status: consts.StatusEnabled,
+		ProductCode: "test_product",
+		// DeptId=0, DeptPath="" —— legacy 账号
+	})
+
+	err := CheckManageAccess(callerCtx, svcCtx, 999002 /* target */, "test_product")
+	require.Error(t, err, "legacy caller 必须被拒绝")
+
+	var ce *response.CodeError
+	require.ErrorAs(t, err, &ce, "必须是 response.CodeError，不得为裸 error（前端无法据此触发迁移）")
+	assert.Equal(t, 403, ce.Code(), "必须是 403 以便前端分类")
+	assert.Contains(t, ce.Error(), "未归属",
+		"文案必须显式提示'未归属任何部门'，便于人工判定是否需要跑数据迁移")
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：CheckManageAccess(WithPrefetchedTarget(...))
+// 允许调用方透传已经 FindOne 到的 target，避免单次请求内重复 FindOne(targetUserId)。
+//
+// 修复前：UpdateUserStatus / UpdateUser 一次请求会先做 ValidateStatusChange 里的 FindOne，
+// 紧接着 checkDeptHierarchy 里又 FindOne 一次，DB/缓存都白打一次 RTT。
+//
+// 修复后的契约：
+// * Option 与参数一致（target.Id == targetUserId）时，FindOne 必须被跳过；
+// * 不一致时 option 失效（defensive ignore），checkDeptHierarchy 回退到原有 FindOne 路径。
+// ---------------------------------------------------------------------------
+
+func buildMemberCallerCtx() context.Context {
+	caller := &loaders.UserDetails{
+		UserId:        1,
+		Username:      "op",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "pc_m5",
+		DeptId:        100,
+		DeptPath:      "/100/",
+		MinPermsLevel: 50,
+	}
+	return middleware.WithUserDetails(context.Background(), caller)
+}
+
+// TC-0860: 透传的 prefetched.Id 与 targetUserId 一致 → SysUserModel.FindOne 必须一次都不被调用。
+func TestCheckManageAccess_PrefetchedTarget_SkipsFindOne(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	// 关键断言：FindOne 次数为 0。gomock 默认不允许未声明的调用；省略 EXPECT 即相当于 0 次。
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+
+	// 目标用户所在部门的 Path 需满足 HasPrefix caller.DeptPath="/100/"
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
+		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
+
+	// 目标产品成员存在，MemberType=MEMBER 与 caller 同级 → 走 permsLevel 比较分支。
+	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
+		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
+
+	// 目标的 permsLevel 高于 caller（数值更大 → 权限更低），校验放行。
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
+		Return(int64(100), nil)
+	// checkPermLevel 现在会对 caller 也做一次 DB fresh read。
+	// caller.UserId=1，permsLevel=50（比 target=100 严格高权）→ 放行。
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
+		Return(int64(50), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+
+	prefetched := &userModel.SysUser{Id: 42, DeptId: 101}
+	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(prefetched))
+	assert.NoError(t, err,
+		"prefetched 与 targetUserId 一致且业务级校验全部通过时应放行")
+	// ctrl.Finish() 里会自动校验 userMock.FindOne 调用次数为 0（未显式 EXPECT），
+	// 若源码回退到 FindOne 路径测试会抛 "unexpected call to FindOne" 直接 FAIL。
+}
+
+// TC-0861: 透传的 prefetched.Id 与 targetUserId 不一致 → option 被 defensive 忽略，
+// 必须真实调用 SysUserModel.FindOne(ctx, targetUserId) 一次。
+// 这是一条 "调用方把错 id 传进来时不能被当做合法 prefetched" 的安全断言：
+// 如果源码直接信任 prefetched 而不校验 Id，就会出现 "用 A 的 userDetails 去放行对 B 的管理"。
+func TestCheckManageAccess_PrefetchedIdMismatch_IgnoredAndFallsBackToFindOne(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+
+	// 关键断言：FindOne(targetUserId=42) 必须真实被调用一次，说明 prefetched 没被盲信。
+	// 我们返回的真实对象 DeptId=101（与乱传的 prefetched 一致），好让流程继续走通。
+	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
+		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).Times(1)
+
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
+		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
+	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
+		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
+		Return(int64(100), nil)
+	// caller 侧 fresh read 仍需要。
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
+		Return(int64(50), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+
+	// 故意传 Id=999，与 targetUserId=42 不一致。
+	wrong := &userModel.SysUser{Id: 999, DeptId: 101}
+	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(wrong))
+	assert.NoError(t, err,
+		"prefetched.Id 不匹配时回退 FindOne 后，本场景仍应通过业务级校验")
+}
+
+// 正向防御：prefetched 为 nil 时也不应 panic，且必须走 FindOne 一次（不传 option 的等价路径）。
+func TestCheckManageAccess_NilPrefetched_FallsBackToFindOne(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+
+	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
+		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).Times(1)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
+		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
+	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
+		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
+		Return(int64(math.MaxInt64), nil)
+	// caller 侧 fresh read。
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
+		Return(int64(50), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+
+	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(nil))
+	assert.NoError(t, err)
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：checkPermLevel 在 DB 非 ErrNotFound 错误时必须 fail-close 返回 500，
+// 而不是被默默降级为"目标无角色 → 权限最低 → 放行"。
+// 该测试用 gomock 伪造 SysRoleModel.FindMinPermsLevelByUserIdAndProductCode 返回一个通用 DB 错误，
+// 验证 CheckManageAccess 的响应是 500 CodeError（非 403）。
+// ---------------------------------------------------------------------------
+
+// TC-0819: checkPermLevel 遇到非 ErrNotFound 的 DB 错误时必须 500。
+func TestCheckManageAccess_DBError_FailCloseWith500(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const targetUserId = int64(42)
+	const callerDeptId = int64(1)
+	const targetDeptId = int64(2)
+	const productCode = "test_product"
+
+	// 让 checkDeptHierarchy 顺利放行：target 在 caller 子部门下（path 前缀 /1/）。
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOne(gomock.Any(), int64(targetUserId)).
+		Return(&userModel.SysUser{Id: targetUserId, DeptId: targetDeptId}, nil).AnyTimes()
+
+	mockDept := mocks.NewMockSysDeptModel(ctrl)
+	mockDept.EXPECT().FindOne(gomock.Any(), targetDeptId).
+		Return(&deptModel.SysDept{Id: targetDeptId, Path: "/1/2/"}, nil).AnyTimes()
+
+	// 让 permsLevel 判定路径进入："target 也是 MEMBER，同级 → 需要 DB 查 permsLevel"。
+	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
+	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), productCode, int64(targetUserId)).
+		Return(&productmember.SysProductMember{
+			UserId: targetUserId, ProductCode: productCode,
+			MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
+		}, nil).AnyTimes()
+
+	// 关键：SysRoleModel 返回非 ErrNotFound 的 DB 错误。
+	dbErr := errors.New("driver: bad connection")
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(targetUserId), productCode).
+		Return(int64(0), dbErr).AnyTimes()
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User:          mockUser,
+		Dept:          mockDept,
+		Role:          mockRole,
+		ProductMember: mockPM,
+	})
+
+	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
+		UserId:        100,
+		Username:      "l4_member_caller",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   productCode,
+		DeptId:        callerDeptId,
+		DeptPath:      "/1/",
+		MinPermsLevel: 100,
+	})
+
+	err := CheckManageAccess(ctx, svcCtx, targetUserId, productCode)
+	require.Error(t, err, "DB 错误时必须 fail-close")
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce), "必须是结构化 CodeError")
+	assert.Equal(t, 500, ce.Code(),
+		"DB 非 ErrNotFound 错误绝不能被伪装成'无角色'从而降级为 403/放行；必须是 500")
+	assert.NotContains(t, ce.Error(), "无权管理",
+		"错误消息不得看起来像权限判定成功后做出的业务决策（避免误导运维）")
+}
+
+// TC-0820:  对照组 —— ErrNotFound 仍应被视作"无角色"，即按最低权限处理（由 caller.MinPermsLevel 决定放行还是 403）。
+// 这里构造 caller 的 MinPermsLevel=MaxInt64（sentinel），target 无角色（ErrNotFound） →
+// caller.MinPermsLevel(=MaxInt64) >= targetLevel(=MaxInt64) → 返回 403。这个分支不是本次回归重点，
+// 只是用来证明 ErrNotFound 路径没有被修复误伤为 500。
+func TestCheckManageAccess_ErrNotFound_StillTreatedAsNoRole(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const targetUserId = int64(43)
+	const callerDeptId = int64(1)
+	const targetDeptId = int64(2)
+	const productCode = "test_product"
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOne(gomock.Any(), int64(targetUserId)).
+		Return(&userModel.SysUser{Id: targetUserId, DeptId: targetDeptId}, nil).AnyTimes()
+
+	mockDept := mocks.NewMockSysDeptModel(ctrl)
+	mockDept.EXPECT().FindOne(gomock.Any(), targetDeptId).
+		Return(&deptModel.SysDept{Id: targetDeptId, Path: "/1/2/"}, nil).AnyTimes()
+
+	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
+	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), productCode, int64(targetUserId)).
+		Return(&productmember.SysProductMember{
+			UserId: targetUserId, ProductCode: productCode,
+			MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
+		}, nil).AnyTimes()
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(targetUserId), productCode).
+		Return(int64(0), sqlx.ErrNotFound).AnyTimes()
+	// checkPermLevel 现在也会对 caller 做 fresh read。
+	// 这里构造"caller 同样无角色 → callerNoRole=true → >= 比较由 callerNoRole 决定，结果仍 403"。
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(101), productCode).
+		Return(int64(0), sqlx.ErrNotFound).AnyTimes()
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: mockUser, Dept: mockDept, Role: mockRole, ProductMember: mockPM,
+	})
+
+	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
+		UserId:       101,
+		Username:     "l4_caller_no_role",
+		IsSuperAdmin: false, MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
+		ProductCode: productCode, DeptId: callerDeptId, DeptPath: "/1/",
+		// sentinel：自己也没有任何角色。
+		MinPermsLevel: math.MaxInt64,
+	})
+
+	err := CheckManageAccess(ctx, svcCtx, targetUserId, productCode)
+	require.Error(t, err, "caller 与 target 都 sentinel → >= 比较应拦截")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code(),
+		"ErrNotFound 正常降级为 sentinel；结果应是业务 403 而非基础设施 500")
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：checkPermLevel 必须对 caller.MinPermsLevel 做 DB fresh read。
+//
+// 修复前：caller.MinPermsLevel 来自 UserDetailsLoader 5min TTL 缓存。超管刚把 caller 降级后
+// 缓存里仍是旧（更高权）级别，降级 admin 在 5min 内仍可跨级管辖目标用户 —— 这是  的
+// GuardRoleLevelAssignable 修复所没有覆盖的"直接管人"分支。
+//
+// 修复后契约：
+// 1. caller 刚被降级，缓存 MinPermsLevel=低（高权）但 DB 实值=高（低权）→ 走 DB 值，仍拒 403。
+// 2. caller 在 DB 里已无角色（sqlx.ErrNotFound）→ callerNoRole=true → 同级管辖拒。
+// 3. caller 侧 DB 抖动（非 ErrNotFound）→ 500 fail-close，不得降级为"无角色放行"。
+// 4. SuperAdmin caller 短路，永不触发 caller 侧 DB 读。
+// 5. caller 管自己时短路在 CheckManageAccess 顶部，根本不到 checkPermLevel。
+//
+// 命名规则：TC-0969 ~ TC-0975
+// ---------------------------------------------------------------------------
+
+const h2TestProductCode = "pc_h2"
+
+// h2MockTargetMemberAndDept 为所有  测试共享的 target 侧 mock：
+// - target.MemberType=MEMBER（与 MEMBER caller 同级 → 必然进入 permsLevel 对比路径）
+// - target.DeptPath=/100/101/ 使 caller.DeptPath=/100/ 顺利覆盖
+func h2MockTargetMemberAndDept(ctrl *gomock.Controller) (
+	*mocks.MockSysUserModel,
+	*mocks.MockSysDeptModel,
+	*mocks.MockSysProductMemberModel,
+) {
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
+		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).AnyTimes()
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
+		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil).AnyTimes()
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), h2TestProductCode, int64(42)).
+		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil).AnyTimes()
+	return userMock, deptMock, pmMock
+}
+
+func h2DowngradedCallerCtx(cachedLevel int64) *loaders.UserDetails {
+	return &loaders.UserDetails{
+		UserId:        1,
+		Username:      "h2_caller",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   h2TestProductCode,
+		DeptId:        100,
+		DeptPath:      "/100/",
+		MinPermsLevel: cachedLevel,
+	}
+}
+
+// TC-0969: caller 缓存里还是高权（level=10），但 DB 已被降级到低权（level=100）
+// target level=50；按缓存 "10 < 50" 应放行，按 DB fresh read "100 >= 50" 应拒绝。
+// 修复后必须以 DB 为准 → 403。
+func TestCheckPermLevel_StaleCacheHighPriv_FreshReadLowPriv_Forbids(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
+
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	// target fresh read：level=50
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
+		Return(int64(50), nil).Times(1)
+	// caller fresh read：DB 真实已降级到 100（低权），比 target 的 50 更低权 → 应拒
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
+		Return(int64(100), nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+	// 关键：缓存里还是 10（降级前的高权级别）—— 源码如果信任 caller.MinPermsLevel 就会放行。
+	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
+
+	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
+	require.Error(t, err, "降级后缓存仍高权的 caller 必须被 DB 实值拦截")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code(),
+		"TOCTOU 修复后必须走 DB，结果为 403；若测试看到 200/nil err 说明仍读的是 caller.MinPermsLevel 缓存")
+	assert.Contains(t, ce.Error(), "无权管理权限级别高于或等于您的用户")
+}
+
+// TC-0970: caller 在 DB 里已无任何角色（ErrNotFound）→ 即便缓存仍显示 MinPermsLevel=10，也必须拒。
+// 对称验证  里 GuardRoleLevelAssignable 对"caller 被清角色"的处理方式。
+func TestCheckPermLevel_CallerFreshRead_NotFound_ForbidsEvenWithCachedLevel(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
+
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
+		Return(int64(50), nil).Times(1)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
+		Return(int64(0), sqlx.ErrNotFound).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
+
+	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
+	require.Error(t, err, "caller 在 DB 已无角色时一律拒绝同级/跨级管辖")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+}
+
+// TC-0971: 正向通过路径 —— caller DB level=10（高权），target level=50 → 严格高权，放行。
+// 用来证明修复没有误伤合法管理路径。
+func TestCheckPermLevel_FreshRead_HigherPriv_Passes(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
+		Return(int64(50), nil).Times(1)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
+		Return(int64(10), nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
+
+	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
+	assert.NoError(t, err, "合法严格高权管理路径不得被修复误伤")
+}
+
+// TC-0972: caller 侧 DB 非 ErrNotFound 错误 → 500 fail-close。
+// 对称于 checkPermLevel 里 target 侧的  fail-close，把 caller 侧也钉死，避免"DB 抖动被伪装成无角色"。
+func TestCheckPermLevel_CallerFreshRead_GenericDBErr_FailsClosedWith500(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
+		Return(int64(50), nil).Times(1)
+	// caller 侧 DB 抖动
+	dbErr := errors.New("driver: bad connection")
+	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
+		Return(int64(0), dbErr).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
+
+	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 500, ce.Code(),
+		"caller 侧 DB 抖动必须 fail-close 500，绝不能伪装成'无角色→放行'")
+	// 不得透传驱动细节
+	assert.NotContains(t, ce.Error(), "driver: bad connection")
+}
+
+// TC-0973: SuperAdmin caller 短路 —— 不应触发任何 caller 侧 DB 读。
+// 如果修复把 fresh read 放错位置，SuperAdmin 也会被多打一次 DB，测试会因 Role mock 收到未预期调用而挂。
+func TestCheckPermLevel_SuperAdmin_ShortCircuits_NoCallerFreshRead(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	// 故意不设任何 mock EXPECT —— 任何 DB 调用都会 fail。
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+
+	super := &loaders.UserDetails{
+		UserId: 999, Username: "super_h2", IsSuperAdmin: true,
+		MemberType: consts.MemberTypeSuperAdmin, Status: consts.StatusEnabled,
+		ProductCode: h2TestProductCode,
+	}
+	err := CheckManageAccess(ctxhelper.CustomCtx(super), svcCtx, 42, h2TestProductCode)
+	assert.NoError(t, err, "SuperAdmin 必须在 CheckManageAccess 顶部短路，不得触发 fresh read")
+}
+
+// TC-0974: caller 管理自己时必须在 CheckManageAccess 顶部短路（ 已钉）；
+// 修复不得把这条路径带偏到 fresh read。
+func TestCheckPermLevel_ManageSelf_ShortCircuits_NoFreshRead(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	// 故意不设 mock EXPECT，caller 管自己应该一次 DB 都不打。
+	userMock := mocks.NewMockSysUserModel(ctrl)
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
+	})
+
+	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(100))
+	err := CheckManageAccess(ctx, svcCtx, 1 /* 就是 caller.UserId */, h2TestProductCode)
+	assert.NoError(t, err, "caller 管自己永远放行，且不触发 DB fresh read")
+}
+
+// TC-0975:  与  共享 loadFreshMinPermsLevel helper（契约自洽性）。
+// 既然 checkPermLevel 与 GuardRoleLevelAssignable 两个授权决策点的 caller 侧都走同一个 helper，
+// 任意通用 DB 错误都必须映射为同一文案的 500 CodeError，任意 ErrNotFound 都映射为 notFound=true。
+// 这里覆盖 helper 的两个对称分支。
+func TestLoadFreshMinPermsLevel_ContractParity(t *testing.T) {
+	t.Run("generic DB error → 500 fail-close", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		roleMock := mocks.NewMockSysRoleModel(ctrl)
+		roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(7), h2TestProductCode).
+			Return(int64(0), errors.New("i/o timeout")).Times(1)
+
+		svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: roleMock})
+		level, notFound, err := loadFreshMinPermsLevel(ctxhelper.CustomCtx(nil), svcCtx, 7, h2TestProductCode)
+		assert.Equal(t, int64(0), level)
+		assert.False(t, notFound)
+		require.Error(t, err)
+		var ce *response.CodeError
+		require.True(t, errors.As(err, &ce))
+		assert.Equal(t, 500, ce.Code())
+	})
+
+	t.Run("ErrNotFound → notFound=true, err=nil", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		t.Cleanup(ctrl.Finish)
+
+		roleMock := mocks.NewMockSysRoleModel(ctrl)
+		roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(8), h2TestProductCode).
+			Return(int64(0), sqlx.ErrNotFound).Times(1)
+
+		svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: roleMock})
+		level, notFound, err := loadFreshMinPermsLevel(ctxhelper.CustomCtx(nil), svcCtx, 8, h2TestProductCode)
+		assert.NoError(t, err)
+		assert.True(t, notFound)
+		assert.Equal(t, int64(0), level)
+	})
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：GuardRoleLevelAssignable 必须每次走 DB 强一致查询，
+// 绝不能信任 caller（loaders.UserDetails）里可能已经 stale 的 MinPermsLevel 缓存。
+//
+// TOCTOU 场景：
+// 1. caller 原先是 permsLevel=5 的高阶成员。
+// 2. 超管把 caller 的高阶角色摘掉，现在 DB 里 MinPermsLevel=100（低阶）。
+// 3. UD 缓存还没被 Clean（Redis 抖动 / TTL 窗口内），caller.MinPermsLevel=5 是旧值。
+// 4. caller 此刻尝试分配 permsLevel=50 的角色 —— 若信缓存（5 vs 50）会**误放行**；
+// 修复后走 DB（100 vs 50），必须 403 拦截。
+// ---------------------------------------------------------------------------
+
+// TC-0930: stale caller.MinPermsLevel 不得影响判定，rolePermsLevel <= freshLevel 必须 403。
+func TestGuardRoleLevelAssignable_StaleCallerCache_FreshDBRejects(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const productCode = "m3_pc_stale"
+	const callerId = int64(1001)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	// 关键：DB 强一致返回 100（被降级后的真实等级）。
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(100), nil).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId:        callerId,
+		Username:      "m3_stale_caller",
+		MemberType:    consts.MemberTypeMember,
+		ProductCode:   productCode,
+		Status:        consts.StatusEnabled,
+		MinPermsLevel: 5,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 50)
+	require.Error(t, err, "stale 缓存(5) 下试图分配 permsLevel=50，信缓存会放行；走 DB(100) 必须 403")
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code(), "拒绝分配高于自身 fresh 等级的角色 → 403")
+}
+
+// TC-0931: 同级（rolePermsLevel == freshLevel）也要拦截，保持与 checkPermLevel 的 ">=" 对齐。
+func TestGuardRoleLevelAssignable_SameLevel_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const productCode = "m3_pc_same"
+	const callerId = int64(1002)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(50), nil).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId:      callerId,
+		Username:    "m3_same_caller",
+		MemberType:  consts.MemberTypeMember,
+		ProductCode: productCode,
+		Status:      consts.StatusEnabled,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 50)
+	require.Error(t, err, "与自身同级不允许分配，否则会让下属获得与上级等效的权力")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "同级")
+}
+
+// TC-0932: rolePermsLevel 严格低于 freshLevel（数值更大）时放行。
+func TestGuardRoleLevelAssignable_StrictlyLower_Allowed(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const productCode = "m3_pc_ok"
+	const callerId = int64(1003)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(50), nil).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId:      callerId,
+		Username:    "m3_ok_caller",
+		MemberType:  consts.MemberTypeMember,
+		ProductCode: productCode,
+		Status:      consts.StatusEnabled,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 80)
+	require.NoError(t, err, "permsLevel=80 严格低于 freshLevel=50（数值更大 = 更低权限）应放行")
+}
+
+// TC-0933: SuperAdmin 完全豁免，不触发任何 DB 查询。
+func TestGuardRoleLevelAssignable_SuperAdmin_BypassNoDBCall(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	// 预期 0 次调用：SuperAdmin 必须短路返回，不能浪费 DB RTT。
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
+		Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId: 1, Username: "root", IsSuperAdmin: true, Status: consts.StatusEnabled,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
+	require.NoError(t, err, "SuperAdmin 必须放行任何 permsLevel")
+}
+
+// TC-0934: 产品 ADMIN 拥有全权，豁免 DB 查询。
+func TestGuardRoleLevelAssignable_ProductAdmin_BypassNoDBCall(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
+		Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId: 2, Username: "pa", MemberType: consts.MemberTypeAdmin,
+		ProductCode: "p1", Status: consts.StatusEnabled,
+	}
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
+	require.NoError(t, err, "产品 ADMIN 属于全权角色，必须豁免等级校验")
+}
+
+// TC-0935: DEVELOPER 同样享有全权豁免。
+func TestGuardRoleLevelAssignable_Developer_BypassNoDBCall(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
+		Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId: 3, Username: "dev", MemberType: consts.MemberTypeDeveloper,
+		ProductCode: "p1", Status: consts.StatusEnabled,
+	}
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
+	require.NoError(t, err)
+}
+
+// TC-0936: caller 在 DB 里**无任何角色**（ErrNotFound），必须 403，不能默认为 MaxInt64 放行。
+// 这里的语义是"没有可分配的角色等级"：一个 MEMBER 连自己都没角色，自然不能分配角色给别人。
+func TestGuardRoleLevelAssignable_CallerHasNoRole_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const productCode = "m3_pc_noRole"
+	const callerId = int64(1004)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(0), sqlx.ErrNotFound).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId: callerId, Username: "m3_no_role", MemberType: consts.MemberTypeMember,
+		ProductCode: productCode, Status: consts.StatusEnabled,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 99)
+	require.Error(t, err, "caller 无任何角色时必须拒绝，否则会被误判为 MaxInt64 最低级从而放行任何 permsLevel")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "没有可分配的角色等级")
+}
+
+// TC-0937: DB 抖动（非 ErrNotFound）必须 fail-close 返回 500，不得降级为"无角色 → 放行"。
+func TestGuardRoleLevelAssignable_DBError_FailCloseWith500(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const productCode = "m3_pc_dbErr"
+	const callerId = int64(1005)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(0), errors.New("driver: bad connection")).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId: callerId, Username: "m3_db_err", MemberType: consts.MemberTypeMember,
+		ProductCode: productCode, Status: consts.StatusEnabled,
+	}
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 10)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 500, ce.Code(),
+		"DB 非 ErrNotFound 错误必须 fail-close 500，不能被伪装成 ErrNotFound → 放行超权分配")
+}
+
+// TC-0938: nil caller 防御：理论上无登录上下文绝不该进入此函数，防御性路径必须 403 而非 panic。
+func TestGuardRoleLevelAssignable_NilCaller_Rejected(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
+		Times(0)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	err := GuardRoleLevelAssignable(context.Background(), svcCtx, nil, 10)
+	require.Error(t, err, "nil caller 必须被拦截，杜绝隐式放行")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：LoadCallerAssignableLevel 在一次请求内对同一 caller 只做
+// 一次 DB 读；CheckRoleLevelAgainst 不再访问 DB，给 BindRoles 这种"批量覆盖"的接口把
+// N 次 loadFreshMinPermsLevel 合并为 1 次。
+//
+// 核心断言口径：
+// 1. SuperAdmin / ADMIN / DEVELOPER 等全权调用者不打 DB（HasFullPerms=true 短路）；
+// 2. MEMBER caller 打 1 次 FindMinPermsLevelByUserIdAndProductCode；
+// 3. caller.ErrNotFound → NoRole=true（不打翻 500）；
+// 4. caller 其他 DB 错误 → fail-close 500（保持与 loadFreshMinPermsLevel 一致的口径，
+// 避免降级为"无角色 = 最低级"放行）。
+// 5. CheckRoleLevelAgainst 是纯函数，不访问 svcCtx。
+// ---------------------------------------------------------------------------
+
+// TC-1017: SuperAdmin / ADMIN / DEVELOPER 走 HasFullPerms 短路，不触碰 DB。
+func TestLoadCallerAssignableLevel_FullPermsShortCircuit_NoDB(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	// 关键：没有 EXPECT.FindMinPermsLevelByUserIdAndProductCode —— 一旦被调用会 fail。
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	cases := []struct {
+		name   string
+		caller *loaders.UserDetails
+	}{
+		{
+			name:   "SuperAdmin",
+			caller: &loaders.UserDetails{UserId: 1, IsSuperAdmin: true, ProductCode: "p"},
+		},
+		{
+			name:   "ADMIN",
+			caller: &loaders.UserDetails{UserId: 2, MemberType: consts.MemberTypeAdmin, ProductCode: "p"},
+		},
+		{
+			name:   "DEVELOPER",
+			caller: &loaders.UserDetails{UserId: 3, MemberType: consts.MemberTypeDeveloper, ProductCode: "p"},
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, c.caller)
+			require.NoError(t, err)
+			assert.True(t, snap.HasFullPerms, "全权调用者必须落 HasFullPerms 分支")
+			assert.False(t, snap.NoRole)
+		})
+	}
+}
+
+// TC-1018: MEMBER caller 仅打 1 次 FindMinPermsLevelByUserIdAndProductCode；
+// 循环内对 N 个角色走 CheckRoleLevelAgainst 不再打 DB。
+func TestLoadCallerAssignableLevel_Member_ReadsDBOnce_ThenConstantTime(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const callerId = int64(1001)
+	const productCode = "pc_m_r10_3"
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	// 关键断言：Times(1) 保证 N 个角色场景不会退化为 N 次 DB 读。
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
+		Return(int64(100), nil).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+
+	caller := &loaders.UserDetails{
+		UserId:      callerId,
+		MemberType:  consts.MemberTypeMember,
+		ProductCode: productCode,
+	}
+	snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
+	require.NoError(t, err)
+	assert.False(t, snap.HasFullPerms)
+	assert.False(t, snap.NoRole)
+	assert.Equal(t, int64(100), snap.Level)
+
+	// 模拟 BindRoles 批量覆盖的循环：5 个角色，全部走 CheckRoleLevelAgainst 的纯比较，
+	// 任何一个角色额外打 DB 都会命中 gomock 的 "unexpected call" 断言。
+	roleLevels := []int64{200, 150, 300, 120, 999}
+	for _, rl := range roleLevels {
+		if err := CheckRoleLevelAgainst(snap, rl); err != nil {
+			t.Fatalf("role level %d should be assignable against caller level %d: %v", rl, snap.Level, err)
+		}
+	}
+
+	// 同级与更高级一律拒绝（与 GuardRoleLevelAssignable 对称）：
+	for _, rl := range []int64{100, 50, 1} {
+		err := CheckRoleLevelAgainst(snap, rl)
+		var codeErr *response.CodeError
+		require.True(t, errors.As(err, &codeErr), "同级或更高级必须返回 CodeError")
+		assert.Equal(t, 403, codeErr.Code())
+	}
+}
+
+// TC-1019: caller 在该产品下无角色 → NoRole=true，不回滚 500。
+func TestLoadCallerAssignableLevel_Member_ErrNotFound_MapsToNoRole(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc").
+		Return(int64(0), sqlx.ErrNotFound).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+	caller := &loaders.UserDetails{
+		UserId:      42,
+		MemberType:  consts.MemberTypeMember,
+		ProductCode: "pc",
+	}
+	snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
+	require.NoError(t, err, "ErrNotFound 必须被归一为 NoRole=true，不得外泄为 500")
+	assert.False(t, snap.HasFullPerms)
+	assert.True(t, snap.NoRole)
+
+	// 验证 NoRole 的 caller 连最低级角色也无法分配（与修复前保持的业务语义一致）。
+	err = CheckRoleLevelAgainst(snap, 999)
+	var codeErr *response.CodeError
+	require.True(t, errors.As(err, &codeErr))
+	assert.Equal(t, 403, codeErr.Code())
+	assert.Contains(t, codeErr.Error(), "没有可分配的角色等级")
+}
+
+// TC-1020: caller 其他 DB 错误必须 fail-close 500，不得降级为 NoRole 放行。
+// 保证修复没有把"DB 抖动"悄悄压成"无角色 → 最低级 → 403"这种语义欺骗。
+func TestLoadCallerAssignableLevel_Member_DBError_FailClose500(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	dbErr := errors.New("driver: bad connection")
+	mockRole := mocks.NewMockSysRoleModel(ctrl)
+	mockRole.EXPECT().
+		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(7), "pc").
+		Return(int64(0), dbErr).
+		Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
+	caller := &loaders.UserDetails{
+		UserId:      7,
+		MemberType:  consts.MemberTypeMember,
+		ProductCode: "pc",
+	}
+
+	_, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
+	var codeErr *response.CodeError
+	require.True(t, errors.As(err, &codeErr), "DB 抖动必须 fail-close 为 CodeError 而非 nil")
+	assert.Equal(t, 500, codeErr.Code())
+}

internal/logic/auth/changePasswordConflict_audit_test.go

@@ -1,109 +0,0 @@
-package auth
-
-import (
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-	"golang.org/x/crypto/bcrypt"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-R10-4 —— ChangePassword 必须把底层 `userModel.ErrUpdateConflict`
-// 显式映射为 409 "密码已被其他会话修改..."；修复前 raw error 会被 rest 兜成 500，
-// 导致前端把"并发冲突"误判为系统故障，也会把告警归到 5xx 噪声池。
-//
-// 口径与 UpdateUserLogic / UpdateUserStatusLogic / UpdateRoleLogic 完全对齐。
-// ---------------------------------------------------------------------------
-
-// TC-1015: M-R10-4 —— UpdatePassword 返回 ErrUpdateConflict 时，ChangePassword 必须回 409。
-func TestChangePassword_UpdateConflict_Maps409(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const userId = int64(777)
-	oldPwd := "Oldpass123"
-	newPwd := "Newpass456"
-	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
-	require.NoError(t, err)
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOne(gomock.Any(), userId).
-		Return(&userModel.SysUser{
-			Id:         userId,
-			Username:   "m_r10_4_subject",
-			Password:   string(hashed),
-			Status:     consts.StatusEnabled,
-			UpdateTime: 1000,
-		}, nil)
-	// 关键：强制底层返回 ErrUpdateConflict。
-	// H-R11-1：签名增加 username 与 expectedUpdateTime 两个透传参数。
-	mockUser.EXPECT().
-		UpdatePassword(gomock.Any(), userId, "m_r10_4_subject", gomock.Any(), int64(consts.MustChangePasswordNo), int64(1000)).
-		Return(userModel.ErrUpdateConflict)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
-	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
-
-	logic := NewChangePasswordLogic(ctx, svcCtx)
-	err = logic.ChangePassword(&types.ChangePasswordReq{
-		OldPassword: oldPwd,
-		NewPassword: newPwd,
-	})
-
-	var codeErr *response.CodeError
-	require.True(t, errors.As(err, &codeErr), "审计 M-R10-4：必须是 *response.CodeError，否则会被 rest 兜成 500")
-	assert.Equal(t, 409, codeErr.Code(), "审计 M-R10-4：ErrUpdateConflict 必须映射为 409 Conflict")
-	assert.Contains(t, codeErr.Error(), "密码已被其他会话修改", "审计 M-R10-4：文案与业务契约对齐")
-}
-
-// TC-1016: M-R10-4 —— 非 ErrUpdateConflict 的原生错误仍应透传（500 由 rest 兜底），
-// 防止修复把所有底层错误都误吞为 409。
-func TestChangePassword_GenericUpdateError_StillPropagates(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const userId = int64(778)
-	oldPwd := "Oldpass123"
-	newPwd := "Newpass456"
-	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
-	require.NoError(t, err)
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOne(gomock.Any(), userId).
-		Return(&userModel.SysUser{
-			Id:         userId,
-			Username:   "m_r10_4_subject2",
-			Password:   string(hashed),
-			Status:     consts.StatusEnabled,
-			UpdateTime: 2000,
-		}, nil)
-	genericErr := errors.New("driver: bad connection")
-	mockUser.EXPECT().
-		UpdatePassword(gomock.Any(), userId, "m_r10_4_subject2", gomock.Any(), int64(consts.MustChangePasswordNo), int64(2000)).
-		Return(genericErr)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
-	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
-
-	logic := NewChangePasswordLogic(ctx, svcCtx)
-	err = logic.ChangePassword(&types.ChangePasswordReq{
-		OldPassword: oldPwd,
-		NewPassword: newPwd,
-	})
-
-	require.Error(t, err)
-	assert.ErrorIs(t, err, genericErr, "审计 M-R10-4：只把 ErrUpdateConflict 映射 409，其余错误原样透传（由 rest 兜 500）")
-	var codeErr *response.CodeError
-	assert.False(t, errors.As(err, &codeErr), "审计 M-R10-4：非冲突错误不得伪装成 CodeError")
-}

internal/logic/auth/changePasswordLogic_test.go

@@ -4,21 +4,22 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"strings"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+	"golang.org/x/crypto/bcrypt"
+	"perms-system-server/internal/consts"
 	"perms-system-server/internal/loaders"
 	"perms-system-server/internal/middleware"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/bcrypt"
+	"strings"
+	"testing"
+	"time"
 )
 
 func ctxWithUserId(userId int64) context.Context {
@@ -260,3 +261,197 @@ func TestChangePassword_UserNotFound(t *testing.T) {
 	assert.Equal(t, 404, codeErr.Code())
 	assert.Equal(t, "用户不存在", codeErr.Error())
 }
+
+func TestChangePassword_UpdateConflict_Maps409(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const userId = int64(777)
+	oldPwd := "Oldpass123"
+	newPwd := "Newpass456"
+	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
+	require.NoError(t, err)
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOne(gomock.Any(), userId).
+		Return(&userModel.SysUser{
+			Id:         userId,
+			Username:   "m_r10_4_subject",
+			Password:   string(hashed),
+			Status:     consts.StatusEnabled,
+			UpdateTime: 1000,
+		}, nil)
+	// 关键：强制底层返回 ErrUpdateConflict。
+	// 签名增加 username 与 expectedUpdateTime 两个透传参数。
+	mockUser.EXPECT().
+		UpdatePassword(gomock.Any(), userId, "m_r10_4_subject", gomock.Any(), int64(consts.MustChangePasswordNo), int64(1000)).
+		Return(userModel.ErrUpdateConflict)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
+	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
+
+	logic := NewChangePasswordLogic(ctx, svcCtx)
+	err = logic.ChangePassword(&types.ChangePasswordReq{
+		OldPassword: oldPwd,
+		NewPassword: newPwd,
+	})
+
+	var codeErr *response.CodeError
+	require.True(t, errors.As(err, &codeErr), "必须是 *response.CodeError，否则会被 rest 兜成 500")
+	assert.Equal(t, 409, codeErr.Code(), "ErrUpdateConflict 必须映射为 409 Conflict")
+	assert.Contains(t, codeErr.Error(), "密码已被其他会话修改", "文案与业务契约对齐")
+}
+
+// TC-1016: 非 ErrUpdateConflict 的原生错误仍应透传（500 由 rest 兜底），
+// 防止修复把所有底层错误都误吞为 409。
+func TestChangePassword_GenericUpdateError_StillPropagates(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const userId = int64(778)
+	oldPwd := "Oldpass123"
+	newPwd := "Newpass456"
+	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
+	require.NoError(t, err)
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOne(gomock.Any(), userId).
+		Return(&userModel.SysUser{
+			Id:         userId,
+			Username:   "m_r10_4_subject2",
+			Password:   string(hashed),
+			Status:     consts.StatusEnabled,
+			UpdateTime: 2000,
+		}, nil)
+	genericErr := errors.New("driver: bad connection")
+	mockUser.EXPECT().
+		UpdatePassword(gomock.Any(), userId, "m_r10_4_subject2", gomock.Any(), int64(consts.MustChangePasswordNo), int64(2000)).
+		Return(genericErr)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
+	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
+
+	logic := NewChangePasswordLogic(ctx, svcCtx)
+	err = logic.ChangePassword(&types.ChangePasswordReq{
+		OldPassword: oldPwd,
+		NewPassword: newPwd,
+	})
+
+	require.Error(t, err)
+	assert.ErrorIs(t, err, genericErr, "只把 ErrUpdateConflict 映射 409，其余错误原样透传（由 rest 兜 500）")
+	var codeErr *response.CodeError
+	assert.False(t, errors.As(err, &codeErr), "非冲突错误不得伪装成 CodeError")
+}
+
+func insertToctouUser(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext,
+	username, plainPwd string) (int64, func()) {
+	t.Helper()
+	now := time.Now().Unix()
+	hashed, err := bcrypt.GenerateFromPassword([]byte(plainPwd), bcrypt.DefaultCost)
+	require.NoError(t, err)
+
+	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username:           username,
+		Password:           string(hashed),
+		Nickname:           "toctou",
+		Avatar:             sql.NullString{},
+		Email:              username + "@test.com",
+		Phone:              "13800000000",
+		Remark:             "",
+		DeptId:             0,
+		IsSuperAdmin:       2,
+		MustChangePassword: 2,
+		Status:             1,
+		CreateTime:         now,
+		UpdateTime:         now,
+	})
+	require.NoError(t, err)
+	id, _ := res.LastInsertId()
+	cleanup := func() {
+		testutil.CleanTable(ctx, testutil.GetTestSqlConn(), "`sys_user`", id)
+	}
+	return id, cleanup
+}
+
+// TC-1042:  E2E —— 400 vs 409 分支隔离：旧密码失配必须 400，绝不能误落 409
+func TestChangePassword_E2E_SecondCallWithOldPwd_Maps400(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	svcCtx.TokenOpLimiter = nil
+
+	oldPwd := "Oldpass123"
+	username := "toctou_seq_" + testutil.UniqueId()
+	userId, cleanup := insertToctouUser(t, ctx, svcCtx, username, oldPwd)
+	t.Cleanup(cleanup)
+
+	lctx := middleware.WithUserDetails(context.Background(),
+		&loaders.UserDetails{UserId: userId, Username: username, Status: 1})
+
+	require.NoError(t,
+		NewChangePasswordLogic(lctx, svcCtx).ChangePassword(&types.ChangePasswordReq{
+			OldPassword: oldPwd, NewPassword: "NewpassX_11",
+		}),
+		"首改必须成功")
+
+	err := NewChangePasswordLogic(lctx, svcCtx).ChangePassword(&types.ChangePasswordReq{
+		OldPassword: oldPwd, NewPassword: "NewpassY_22",
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code(),
+		"旧密码已失配应 400'原密码错误'；不得因 ErrUpdateConflict 映射被误回 409")
+	assert.Contains(t, ce.Error(), "原密码错误")
+
+	// DB 终态：Password 是首改成功的 NewpassX_11，tokenVersion 恰好 1（而不是 2）。
+	got, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.NoError(t, bcrypt.CompareHashAndPassword([]byte(got.Password), []byte("NewpassX_11")))
+	assert.Equal(t, int64(1), got.TokenVersion,
+		"首改成功递增 1；第二次因 400 未进入 UpdatePassword，tokenVersion 必须仍是 1")
+}
+
+// TC-1043: UpdatePassword 签名护栏（mock 驱动）：
+// 签名一旦回退（例如 username 再次被内部 FindOne 取而非外层透传），整个链路会编译失败；
+// 但契约层面的"必须透传外层 snapshot 的 UpdateTime"更细致：Logic 必须把 FindOne 返回的
+// snapshot.UpdateTime 原样交给 UpdatePassword，不得自己算 time.Now() 或重新 FindOne。
+// 这里用 mock 钉死该契约：FindOne 返回 UpdateTime=4242，UpdatePassword 必须收到 4242。
+func TestChangePassword_ForwardsSnapshotUpdateTime(t *testing.T) {
+	// 注：此契约已由既有 TestChangePassword_UpdateConflict_Maps409（UpdateTime=1000）覆盖，
+	// 这里再以另一组数值(4242)做"反证哨兵"，若 DEV 不小心硬编码常量/写死 time.Now，
+	// 两组数值会同时失败，快速定位。
+	t.Run("expected=4242", func(t *testing.T) { runSnapshotForwardCase(t, 4242) })
+	t.Run("expected=9876543210", func(t *testing.T) { runSnapshotForwardCase(t, 9876543210) })
+}
+
+func runSnapshotForwardCase(t *testing.T, expectedUpdateTime int64) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const userId = int64(17)
+	oldPwd := "Oldpass123"
+	newPwd := "Newpass456"
+	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
+	require.NoError(t, err)
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOne(gomock.Any(), userId).
+		Return(&userModel.SysUser{
+			Id:         userId,
+			Username:   "snap_subject",
+			Password:   string(hashed),
+			Status:     1,
+			UpdateTime: expectedUpdateTime,
+		}, nil)
+	// 合同：UpdatePassword 的第 6 个参数必须与 FindOne 返回的 UpdateTime 字面相等。
+	mockUser.EXPECT().
+		UpdatePassword(gomock.Any(), userId, "snap_subject", gomock.Any(),
+			int64(consts.MustChangePasswordNo), expectedUpdateTime).
+		Return(nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
+	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
+
+	require.NoError(t, NewChangePasswordLogic(ctx, svcCtx).ChangePassword(
+		&types.ChangePasswordReq{OldPassword: oldPwd, NewPassword: newPwd}))
+}

internal/logic/auth/changePasswordToctou_audit_test.go

@@ -1,155 +0,0 @@
-package auth
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-	"golang.org/x/crypto/bcrypt"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：H-R11-1 的 E2E 边界契约 —— 改密的 "400 原密码错误" 与 "409 被其他会话抢改"
-// 两条分支必须互不污染。
-//
-// H-R11-1 的核心是把 `UpdatePassword` 的乐观锁 expected 从内部自取改为外层 FindOne 透传，
-// 并在 Logic 层把 `ErrUpdateConflict` 显式映射 409。这里补一条"正常串行"回归：
-//   T0 ChangePassword(old=P0, new=P1) → 首改成功
-//   T1 ChangePassword(old=P0, new=P2) → 旧密码已失配，必须 400"原密码错误"；
-//       绝不能因为"外层快照已陈旧"之类的原因落到 409 分支。
-//
-// 该契约直接护栏 H-R11-1 的 ErrUpdateConflict 映射逻辑不被误写成"吞掉所有错误都回 409"。
-// 底层 CAS 正确性已在 model 层 TestSysUserModel_UpdatePassword_StaleExpectedUpdateTime_Conflict /
-// ConcurrentProfileWrite_BlocksPasswordUpdate 两个用例闭合；Logic→Model 的签名传参契约
-// 则由 TestChangePassword_UpdateConflict_Maps409（mock UpdatePassword(..., 1000) 必须收到
-// user.UpdateTime=1000）钉死。所以这里只补 400/409 分支隔离。
-// ---------------------------------------------------------------------------
-
-func insertToctouUser(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext,
-	username, plainPwd string) (int64, func()) {
-	t.Helper()
-	now := time.Now().Unix()
-	hashed, err := bcrypt.GenerateFromPassword([]byte(plainPwd), bcrypt.DefaultCost)
-	require.NoError(t, err)
-
-	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username:           username,
-		Password:           string(hashed),
-		Nickname:           "toctou",
-		Avatar:             sql.NullString{},
-		Email:              username + "@test.com",
-		Phone:              "13800000000",
-		Remark:             "",
-		DeptId:             0,
-		IsSuperAdmin:       2,
-		MustChangePassword: 2,
-		Status:             1,
-		CreateTime:         now,
-		UpdateTime:         now,
-	})
-	require.NoError(t, err)
-	id, _ := res.LastInsertId()
-	cleanup := func() {
-		testutil.CleanTable(ctx, testutil.GetTestSqlConn(), "`sys_user`", id)
-	}
-	return id, cleanup
-}
-
-// TC-1042: H-R11-1 E2E —— 400 vs 409 分支隔离：旧密码失配必须 400，绝不能误落 409
-func TestChangePassword_E2E_SecondCallWithOldPwd_Maps400(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	svcCtx.TokenOpLimiter = nil
-
-	oldPwd := "Oldpass123"
-	username := "toctou_seq_" + testutil.UniqueId()
-	userId, cleanup := insertToctouUser(t, ctx, svcCtx, username, oldPwd)
-	t.Cleanup(cleanup)
-
-	lctx := middleware.WithUserDetails(context.Background(),
-		&loaders.UserDetails{UserId: userId, Username: username, Status: 1})
-
-	require.NoError(t,
-		NewChangePasswordLogic(lctx, svcCtx).ChangePassword(&types.ChangePasswordReq{
-			OldPassword: oldPwd, NewPassword: "NewpassX_11",
-		}),
-		"首改必须成功")
-
-	err := NewChangePasswordLogic(lctx, svcCtx).ChangePassword(&types.ChangePasswordReq{
-		OldPassword: oldPwd, NewPassword: "NewpassY_22",
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code(),
-		"H-R11-1：旧密码已失配应 400'原密码错误'；不得因 ErrUpdateConflict 映射被误回 409")
-	assert.Contains(t, ce.Error(), "原密码错误")
-
-	// DB 终态：Password 是首改成功的 NewpassX_11，tokenVersion 恰好 1（而不是 2）。
-	got, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.NoError(t, bcrypt.CompareHashAndPassword([]byte(got.Password), []byte("NewpassX_11")))
-	assert.Equal(t, int64(1), got.TokenVersion,
-		"H-R11-1：首改成功递增 1；第二次因 400 未进入 UpdatePassword，tokenVersion 必须仍是 1")
-}
-
-// TC-1043: H-R11-1 —— UpdatePassword 签名护栏（mock 驱动）：
-// 签名一旦回退（例如 username 再次被内部 FindOne 取而非外层透传），整个链路会编译失败；
-// 但契约层面的"必须透传外层 snapshot 的 UpdateTime"更细致：Logic 必须把 FindOne 返回的
-// snapshot.UpdateTime 原样交给 UpdatePassword，不得自己算 time.Now() 或重新 FindOne。
-// 这里用 mock 钉死该契约：FindOne 返回 UpdateTime=4242，UpdatePassword 必须收到 4242。
-func TestChangePassword_ForwardsSnapshotUpdateTime(t *testing.T) {
-	// 注：此契约已由既有 TestChangePassword_UpdateConflict_Maps409（UpdateTime=1000）覆盖，
-	// 这里再以另一组数值(4242)做"反证哨兵"，若 DEV 不小心硬编码常量/写死 time.Now，
-	// 两组数值会同时失败，快速定位。
-	t.Run("expected=4242", func(t *testing.T) { runSnapshotForwardCase(t, 4242) })
-	t.Run("expected=9876543210", func(t *testing.T) { runSnapshotForwardCase(t, 9876543210) })
-}
-
-func runSnapshotForwardCase(t *testing.T, expectedUpdateTime int64) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const userId = int64(17)
-	oldPwd := "Oldpass123"
-	newPwd := "Newpass456"
-	hashed, err := bcrypt.GenerateFromPassword([]byte(oldPwd), bcrypt.DefaultCost)
-	require.NoError(t, err)
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOne(gomock.Any(), userId).
-		Return(&userModel.SysUser{
-			Id:         userId,
-			Username:   "snap_subject",
-			Password:   string(hashed),
-			Status:     1,
-			UpdateTime: expectedUpdateTime,
-		}, nil)
-	// 合同：UpdatePassword 的第 6 个参数必须与 FindOne 返回的 UpdateTime 字面相等。
-	mockUser.EXPECT().
-		UpdatePassword(gomock.Any(), userId, "snap_subject", gomock.Any(),
-			int64(consts.MustChangePasswordNo), expectedUpdateTime).
-		Return(nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
-	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{UserId: userId})
-
-	require.NoError(t, NewChangePasswordLogic(ctx, svcCtx).ChangePassword(
-		&types.ChangePasswordReq{OldPassword: oldPwd, NewPassword: newPwd}))
-}
-

internal/logic/auth/checkAddMemberAccess_audit_test.go

@@ -1,260 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	deptModel "perms-system-server/internal/model/dept"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-3 修复 —— CheckAddMemberAccess 专门为 AddMember 前置流程设计，
-// 用以堵住"产品 ADMIN 从部门树外把人强拉进自己产品"的漏洞。
-// 对比 CheckManageAccess：
-//   1) 不做 memberType / permsLevel 比对；
-//   2) 对产品 ADMIN 不走 checkDeptHierarchy 的 bypass，强制做部门链校验；
-//   3) SuperAdmin 仍完全豁免；
-//   4) target 为空 / 未归属部门等情况 fail-close。
-// ---------------------------------------------------------------------------
-
-func callerProductAdmin(deptId int64, deptPath string) *loaders.UserDetails {
-	return &loaders.UserDetails{
-		UserId:       2,
-		Username:     "pa",
-		IsSuperAdmin: false,
-		MemberType:   consts.MemberTypeAdmin,
-		Status:       consts.StatusEnabled,
-		ProductCode:  "pc_h3",
-		DeptId:       deptId,
-		DeptPath:     deptPath,
-	}
-}
-
-func callerMember(deptId int64, deptPath string) *loaders.UserDetails {
-	return &loaders.UserDetails{
-		UserId:       3,
-		Username:     "mbr",
-		IsSuperAdmin: false,
-		MemberType:   consts.MemberTypeMember,
-		Status:       consts.StatusEnabled,
-		ProductCode:  "pc_h3",
-		DeptId:       deptId,
-		DeptPath:     deptPath,
-	}
-}
-
-// TC-0940: H-3 —— 产品 ADMIN 将部门树**外**的 target 拉进产品时必须 403，
-// 不得因其 MemberType=ADMIN 享受 checkDeptHierarchy 的 bypass。
-func TestCheckAddMemberAccess_ProductAdmin_CrossDept_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	// target 所在部门 path = /200/201/，与 caller 部门 path=/100/ 不在同一子树
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(201)).
-		Return(&deptModel.SysDept{Id: 201, Path: "/200/201/"}, nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	ctx := middleware.WithUserDetails(context.Background(), callerProductAdmin(100, "/100/"))
-	target := &userModel.SysUser{Id: 42, DeptId: 201}
-
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.Error(t, err, "H-3：产品 ADMIN 不能把部门树外的人拉进自己产品")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "其他部门")
-}
-
-// TC-0941: H-3 —— 产品 ADMIN 将部门树**内**的 target 拉进产品允许通过。
-func TestCheckAddMemberAccess_ProductAdmin_SameSubtree_Allowed(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
-		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	ctx := middleware.WithUserDetails(context.Background(), callerProductAdmin(100, "/100/"))
-	target := &userModel.SysUser{Id: 42, DeptId: 101}
-
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.NoError(t, err, "H-3：target 在 caller 部门子树内应允许添加")
-}
-
-// TC-0942: H-3 —— SuperAdmin 完全豁免，不触发 SysDeptModel.FindOne。
-func TestCheckAddMemberAccess_SuperAdmin_BypassNoDBCall(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	su := &loaders.UserDetails{
-		UserId: 1, Username: "su", IsSuperAdmin: true,
-		MemberType: consts.MemberTypeSuperAdmin, Status: consts.StatusEnabled,
-	}
-	ctx := middleware.WithUserDetails(context.Background(), su)
-	target := &userModel.SysUser{Id: 42, DeptId: 999} // 任意部门
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.NoError(t, err)
-}
-
-// TC-0943: H-3 —— caller 自加自 (target.Id == caller.UserId) 豁免部门校验，
-// 避免阻塞"ADMIN 把自己添加进新产品"这类合法运维路径。
-func TestCheckAddMemberAccess_SelfAdd_Allowed(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerProductAdmin(100, "/100/")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	target := &userModel.SysUser{Id: caller.UserId, DeptId: 999}
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.NoError(t, err)
-}
-
-// TC-0944: H-3 —— caller 自身 DeptId=0（幽灵账号）时必须 403，
-// 不得让"无部门归属但拥有 product ADMIN"的账号绕过整个部门链校验。
-func TestCheckAddMemberAccess_CallerWithoutDept_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerProductAdmin(0, "")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	target := &userModel.SysUser{Id: 42, DeptId: 101}
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "未归属任何部门")
-}
-
-// TC-0945: H-3 —— target 未归属部门时必须 403（仅超管可破例），
-// 避免"空 deptId 的 user 被部门前缀匹配逻辑误判"通过。
-func TestCheckAddMemberAccess_TargetWithoutDept_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerProductAdmin(100, "/100/")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	target := &userModel.SysUser{Id: 42, DeptId: 0}
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "未归属部门")
-}
-
-// TC-0946: H-3 —— 未登录 / 缺少 UserDetails 上下文时返回 401，
-// 而不是 silently 放行或 panic。
-func TestCheckAddMemberAccess_NoCallerCtx_Unauthorized(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	target := &userModel.SysUser{Id: 42, DeptId: 101}
-	err := CheckAddMemberAccess(context.Background(), svcCtx, target)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code())
-}
-
-// TC-0947: H-3 —— SysDeptModel.FindOne 报错时必须 fail-close 返回 403（无法校验），
-// 不得静默放行。消息避免暴露底层 DB 细节。
-func TestCheckAddMemberAccess_DeptFindOneError_FailClose(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(777)).
-		Return(nil, errors.New("db: connection refused")).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerProductAdmin(100, "/100/")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	target := &userModel.SysUser{Id: 42, DeptId: 777}
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.NotContains(t, ce.Error(), "db:",
-		"错误消息不得泄漏底层 DB 细节")
-}
-
-// TC-0948: H-3 —— 非 ADMIN 的普通 MEMBER 作 caller 时同样走 CheckAddMemberAccess 的部门链判定
-// （虽然 AddMember 的 RequireProductAdminFor 会更早拒绝，但防御深度仍需保证此函数独立正确）。
-func TestCheckAddMemberAccess_Member_CrossDept_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(201)).
-		Return(&deptModel.SysDept{Id: 201, Path: "/200/201/"}, nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerMember(100, "/100/")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	target := &userModel.SysUser{Id: 42, DeptId: 201}
-	err := CheckAddMemberAccess(ctx, svcCtx, target)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-}
-
-// TC-0949: H-3 —— target 为 nil 时必须 400，而不是 panic。
-func TestCheckAddMemberAccess_NilTarget_BadRequest(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), gomock.Any()).Times(0)
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Dept: deptMock})
-
-	caller := callerProductAdmin(100, "/100/")
-	ctx := middleware.WithUserDetails(context.Background(), caller)
-	err := CheckAddMemberAccess(ctx, svcCtx, nil)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-}

internal/logic/auth/checkManageAccessDeptZero_audit_test.go

@@ -1,68 +0,0 @@
-package auth
-
-import (
-	"context"
-	"os"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 审计 L-3（第 8 轮仍未落地）—— checkDeptHierarchy 对 caller.DeptId=0 / DeptPath=""
-// 的历史 MEMBER / DEVELOPER 账号直接 403。
-//
-// 契约期望（fix 后）：历史账号任意一次管理动作时，CheckManageAccess 要么走
-//   (a) 明确的"未归属部门，拒绝管理他人"403（当前行为，方向正确但文案 / 审计缺失）
-//   (b) 自动把缺失部门挪到默认部门 → 正常走部门链校验
-// 无论走 (a) 还是 (b)，都需要有 **response.CodeError 结构** 而不是普通 string error，
-// 否则前端做不到"按错误码触发数据迁移工单"。
-//
-// 本测试用 skipPending 标签，方便 report 识别未落地审计项；fix 落地（或数据迁移脚本
-// 跑完）后把 AUDIT_RUN_PENDING=1 打开并调整断言即可切换成真正的回归保护。
-// ---------------------------------------------------------------------------
-
-const auditPendingEnv = "AUDIT_RUN_PENDING"
-
-func skipPending(t *testing.T, marker, reason string) {
-	t.Helper()
-	if os.Getenv(auditPendingEnv) != "" {
-		return
-	}
-	t.Skipf("AUDIT_PENDING %s (Round 8 fix 未落地) —— %s", marker, reason)
-}
-
-// TC-0993: 历史 DEVELOPER（DeptId=0）对合法目标的管理操作 —— fix 后必须是
-// 可识别的 response.CodeError，且带有迁移提示（"您未归属任何部门"），让运维据此跑数据迁移。
-func TestCheckManageAccess_L3_LegacyDeveloperWithDeptZero_MustReturnCodedError(t *testing.T) {
-	skipPending(t, "L-3",
-		"当前返回 403 但文案分叉（'您未归属任何部门' / '您的部门信息异常'），审计建议"+
-			"合一为 '您未归属任何部门' 且带 CodeError.Code=403；fix 落地后移除 Skip")
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-
-	// caller 是 legacy developer，DeptId=0 / DeptPath=""。
-	callerCtx := middleware.WithUserDetails(ctx, &loaders.UserDetails{
-		UserId: 999001, Username: "legacy_dev", IsSuperAdmin: false,
-		MemberType: consts.MemberTypeDeveloper, Status: consts.StatusEnabled,
-		ProductCode: "test_product",
-		// DeptId=0, DeptPath="" —— legacy 账号
-	})
-
-	err := CheckManageAccess(callerCtx, svcCtx, 999002 /* target */, "test_product")
-	require.Error(t, err, "L-3：legacy caller 必须被拒绝")
-
-	var ce *response.CodeError
-	require.ErrorAs(t, err, &ce, "L-3：必须是 response.CodeError，不得为裸 error（前端无法据此触发迁移）")
-	assert.Equal(t, 403, ce.Code(), "L-3：必须是 403 以便前端分类")
-	assert.Contains(t, ce.Error(), "未归属",
-		"L-3：文案必须显式提示'未归属任何部门'，便于人工判定是否需要跑数据迁移")
-}

internal/logic/auth/checkManageAccessPrefetch_audit_test.go

@@ -1,153 +0,0 @@
-package auth
-
-import (
-	"context"
-	"math"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	deptModel "perms-system-server/internal/model/dept"
-	productmemberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-5 修复回归 —— CheckManageAccess(WithPrefetchedTarget(...))
-// 允许调用方透传已经 FindOne 到的 target，避免单次请求内重复 FindOne(targetUserId)。
-//
-// 修复前：UpdateUserStatus / UpdateUser 一次请求会先做 ValidateStatusChange 里的 FindOne，
-// 紧接着 checkDeptHierarchy 里又 FindOne 一次，DB/缓存都白打一次 RTT。
-//
-// 修复后的契约：
-//   * Option 与参数一致（target.Id == targetUserId）时，FindOne 必须被跳过；
-//   * 不一致时 option 失效（defensive ignore），checkDeptHierarchy 回退到原有 FindOne 路径。
-// ---------------------------------------------------------------------------
-
-func buildMemberCallerCtx() context.Context {
-	caller := &loaders.UserDetails{
-		UserId:        1,
-		Username:      "op",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "pc_m5",
-		DeptId:        100,
-		DeptPath:      "/100/",
-		MinPermsLevel: 50,
-	}
-	return middleware.WithUserDetails(context.Background(), caller)
-}
-
-// TC-0860: 透传的 prefetched.Id 与 targetUserId 一致 → SysUserModel.FindOne 必须一次都不被调用。
-func TestCheckManageAccess_PrefetchedTarget_SkipsFindOne(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	// 关键断言：FindOne 次数为 0。gomock 默认不允许未声明的调用；省略 EXPECT 即相当于 0 次。
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-
-	// 目标用户所在部门的 Path 需满足 HasPrefix caller.DeptPath="/100/"
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
-		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
-
-	// 目标产品成员存在，MemberType=MEMBER 与 caller 同级 → 走 permsLevel 比较分支。
-	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
-		Return(&productmemberModel.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
-
-	// 目标的 permsLevel 高于 caller（数值更大 → 权限更低），校验放行。
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
-		Return(int64(100), nil)
-	// 审计 H-2：checkPermLevel 现在会对 caller 也做一次 DB fresh read。
-	// caller.UserId=1，permsLevel=50（比 target=100 严格高权）→ 放行。
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
-		Return(int64(50), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-
-	prefetched := &userModel.SysUser{Id: 42, DeptId: 101}
-	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(prefetched))
-	assert.NoError(t, err,
-		"M-5：prefetched 与 targetUserId 一致且业务级校验全部通过时应放行")
-	// ctrl.Finish() 里会自动校验 userMock.FindOne 调用次数为 0（未显式 EXPECT），
-	// 若源码回退到 FindOne 路径测试会抛 "unexpected call to FindOne" 直接 FAIL。
-}
-
-// TC-0861: 透传的 prefetched.Id 与 targetUserId 不一致 → option 被 defensive 忽略，
-// 必须真实调用 SysUserModel.FindOne(ctx, targetUserId) 一次。
-// 这是一条 "调用方把错 id 传进来时不能被当做合法 prefetched" 的安全断言：
-// 如果源码直接信任 prefetched 而不校验 Id，就会出现 "用 A 的 userDetails 去放行对 B 的管理"。
-func TestCheckManageAccess_PrefetchedIdMismatch_IgnoredAndFallsBackToFindOne(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-
-	// 关键断言：FindOne(targetUserId=42) 必须真实被调用一次，说明 prefetched 没被盲信。
-	// 我们返回的真实对象 DeptId=101（与乱传的 prefetched 一致），好让流程继续走通。
-	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
-		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).Times(1)
-
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
-		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
-	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
-		Return(&productmemberModel.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
-		Return(int64(100), nil)
-	// 审计 H-2：caller 侧 fresh read 仍需要。
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
-		Return(int64(50), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-
-	// 故意传 Id=999，与 targetUserId=42 不一致。
-	wrong := &userModel.SysUser{Id: 999, DeptId: 101}
-	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(wrong))
-	assert.NoError(t, err,
-		"M-5：prefetched.Id 不匹配时回退 FindOne 后，本场景仍应通过业务级校验")
-}
-
-// 正向防御：prefetched 为 nil 时也不应 panic，且必须走 FindOne 一次（不传 option 的等价路径）。
-func TestCheckManageAccess_NilPrefetched_FallsBackToFindOne(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-
-	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
-		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).Times(1)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
-		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil)
-	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc_m5", int64(42)).
-		Return(&productmemberModel.SysProductMember{MemberType: consts.MemberTypeMember}, nil)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc_m5").
-		Return(int64(math.MaxInt64), nil)
-	// 审计 H-2：caller 侧 fresh read。
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), "pc_m5").
-		Return(int64(50), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-
-	err := CheckManageAccess(buildMemberCallerCtx(), svcCtx, 42, "pc_m5", WithPrefetchedTarget(nil))
-	assert.NoError(t, err)
-}

internal/logic/auth/checkPermLevelFailClose_audit_test.go

@@ -1,151 +0,0 @@
-package auth
-
-import (
-	"errors"
-	"math"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	deptModel "perms-system-server/internal/model/dept"
-	memberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-4 修复 —— checkPermLevel 在 DB 非 ErrNotFound 错误时必须 fail-close 返回 500，
-// 而不是被默默降级为"目标无角色 → 权限最低 → 放行"。
-// 该测试用 gomock 伪造 SysRoleModel.FindMinPermsLevelByUserIdAndProductCode 返回一个通用 DB 错误，
-// 验证 CheckManageAccess 的响应是 500 CodeError（非 403）。
-// ---------------------------------------------------------------------------
-
-// TC-0819: L-4 —— checkPermLevel 遇到非 ErrNotFound 的 DB 错误时必须 500。
-func TestCheckManageAccess_DBError_FailCloseWith500(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const targetUserId = int64(42)
-	const callerDeptId = int64(1)
-	const targetDeptId = int64(2)
-	const productCode = "test_product"
-
-	// 让 checkDeptHierarchy 顺利放行：target 在 caller 子部门下（path 前缀 /1/）。
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOne(gomock.Any(), int64(targetUserId)).
-		Return(&userModel.SysUser{Id: targetUserId, DeptId: targetDeptId}, nil).AnyTimes()
-
-	mockDept := mocks.NewMockSysDeptModel(ctrl)
-	mockDept.EXPECT().FindOne(gomock.Any(), targetDeptId).
-		Return(&deptModel.SysDept{Id: targetDeptId, Path: "/1/2/"}, nil).AnyTimes()
-
-	// 让 permsLevel 判定路径进入："target 也是 MEMBER，同级 → 需要 DB 查 permsLevel"。
-	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
-	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), productCode, int64(targetUserId)).
-		Return(&memberModel.SysProductMember{
-			UserId: targetUserId, ProductCode: productCode,
-			MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
-		}, nil).AnyTimes()
-
-	// 关键：SysRoleModel 返回非 ErrNotFound 的 DB 错误。
-	dbErr := errors.New("driver: bad connection")
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(targetUserId), productCode).
-		Return(int64(0), dbErr).AnyTimes()
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User:          mockUser,
-		Dept:          mockDept,
-		Role:          mockRole,
-		ProductMember: mockPM,
-	})
-
-	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
-		UserId:        100,
-		Username:      "l4_member_caller",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   productCode,
-		DeptId:        callerDeptId,
-		DeptPath:      "/1/",
-		MinPermsLevel: 100,
-	})
-
-	err := CheckManageAccess(ctx, svcCtx, targetUserId, productCode)
-	require.Error(t, err, "DB 错误时必须 fail-close")
-
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce), "必须是结构化 CodeError")
-	assert.Equal(t, 500, ce.Code(),
-		"L-4：DB 非 ErrNotFound 错误绝不能被伪装成'无角色'从而降级为 403/放行；必须是 500")
-	assert.NotContains(t, ce.Error(), "无权管理",
-		"错误消息不得看起来像权限判定成功后做出的业务决策（避免误导运维）")
-}
-
-// TC-0820: L-4 对照组 —— ErrNotFound 仍应被视作"无角色"，即按最低权限处理（由 caller.MinPermsLevel 决定放行还是 403）。
-// 这里构造 caller 的 MinPermsLevel=MaxInt64（sentinel），target 无角色（ErrNotFound） →
-// caller.MinPermsLevel(=MaxInt64) >= targetLevel(=MaxInt64) → 返回 403。这个分支不是本次回归重点，
-// 只是用来证明 ErrNotFound 路径没有被修复误伤为 500。
-func TestCheckManageAccess_ErrNotFound_StillTreatedAsNoRole(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const targetUserId = int64(43)
-	const callerDeptId = int64(1)
-	const targetDeptId = int64(2)
-	const productCode = "test_product"
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOne(gomock.Any(), int64(targetUserId)).
-		Return(&userModel.SysUser{Id: targetUserId, DeptId: targetDeptId}, nil).AnyTimes()
-
-	mockDept := mocks.NewMockSysDeptModel(ctrl)
-	mockDept.EXPECT().FindOne(gomock.Any(), targetDeptId).
-		Return(&deptModel.SysDept{Id: targetDeptId, Path: "/1/2/"}, nil).AnyTimes()
-
-	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
-	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), productCode, int64(targetUserId)).
-		Return(&memberModel.SysProductMember{
-			UserId: targetUserId, ProductCode: productCode,
-			MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
-		}, nil).AnyTimes()
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(targetUserId), productCode).
-		Return(int64(0), sqlx.ErrNotFound).AnyTimes()
-	// 审计 H-2：checkPermLevel 现在也会对 caller 做 fresh read。
-	// 这里构造"caller 同样无角色 → callerNoRole=true → >= 比较由 callerNoRole 决定，结果仍 403"。
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(101), productCode).
-		Return(int64(0), sqlx.ErrNotFound).AnyTimes()
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: mockUser, Dept: mockDept, Role: mockRole, ProductMember: mockPM,
-	})
-
-	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
-		UserId:       101,
-		Username:     "l4_caller_no_role",
-		IsSuperAdmin: false, MemberType: consts.MemberTypeMember, Status: consts.StatusEnabled,
-		ProductCode: productCode, DeptId: callerDeptId, DeptPath: "/1/",
-		// sentinel：自己也没有任何角色。
-		MinPermsLevel: math.MaxInt64,
-	})
-
-	err := CheckManageAccess(ctx, svcCtx, targetUserId, productCode)
-	require.Error(t, err, "caller 与 target 都 sentinel → >= 比较应拦截")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code(),
-		"ErrNotFound 正常降级为 sentinel；结果应是业务 403 而非基础设施 500")
-}

internal/logic/auth/checkPermLevelFreshRead_audit_test.go

@@ -1,268 +0,0 @@
-package auth
-
-import (
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	deptModel "perms-system-server/internal/model/dept"
-	memberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-2（第 8 轮）—— checkPermLevel 必须对 caller.MinPermsLevel 做 DB fresh read。
-//
-// 修复前：caller.MinPermsLevel 来自 UserDetailsLoader 5min TTL 缓存。超管刚把 caller 降级后
-// 缓存里仍是旧（更高权）级别，降级 admin 在 5min 内仍可跨级管辖目标用户 —— 这是 M-3 的
-// GuardRoleLevelAssignable 修复所没有覆盖的"直接管人"分支。
-//
-// 修复后契约：
-//  1. caller 刚被降级，缓存 MinPermsLevel=低（高权）但 DB 实值=高（低权）→ 走 DB 值，仍拒 403。
-//  2. caller 在 DB 里已无角色（sqlx.ErrNotFound）→ callerNoRole=true → 同级管辖拒。
-//  3. caller 侧 DB 抖动（非 ErrNotFound）→ 500 fail-close，不得降级为"无角色放行"。
-//  4. SuperAdmin caller 短路，永不触发 caller 侧 DB 读。
-//  5. caller 管自己时短路在 CheckManageAccess 顶部，根本不到 checkPermLevel。
-//
-// 命名规则：TC-0969 ~ TC-0975
-// ---------------------------------------------------------------------------
-
-const h2TestProductCode = "pc_h2"
-
-// h2MockTargetMemberAndDept 为所有 H-2 测试共享的 target 侧 mock：
-//   - target.MemberType=MEMBER（与 MEMBER caller 同级 → 必然进入 permsLevel 对比路径）
-//   - target.DeptPath=/100/101/ 使 caller.DeptPath=/100/ 顺利覆盖
-func h2MockTargetMemberAndDept(ctrl *gomock.Controller) (
-	*mocks.MockSysUserModel,
-	*mocks.MockSysDeptModel,
-	*mocks.MockSysProductMemberModel,
-) {
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	userMock.EXPECT().FindOne(gomock.Any(), int64(42)).
-		Return(&userModel.SysUser{Id: 42, DeptId: 101}, nil).AnyTimes()
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(101)).
-		Return(&deptModel.SysDept{Id: 101, Path: "/100/101/"}, nil).AnyTimes()
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	pmMock.EXPECT().FindOneByProductCodeUserId(gomock.Any(), h2TestProductCode, int64(42)).
-		Return(&memberModel.SysProductMember{MemberType: consts.MemberTypeMember}, nil).AnyTimes()
-	return userMock, deptMock, pmMock
-}
-
-func h2DowngradedCallerCtx(cachedLevel int64) *loaders.UserDetails {
-	return &loaders.UserDetails{
-		UserId:        1,
-		Username:      "h2_caller",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   h2TestProductCode,
-		DeptId:        100,
-		DeptPath:      "/100/",
-		MinPermsLevel: cachedLevel,
-	}
-}
-
-// TC-0969: caller 缓存里还是高权（level=10），但 DB 已被降级到低权（level=100）
-// target level=50；按缓存 "10 < 50" 应放行，按 DB fresh read "100 >= 50" 应拒绝。
-// 修复后必须以 DB 为准 → 403。
-func TestCheckPermLevel_StaleCacheHighPriv_FreshReadLowPriv_Forbids(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
-
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	// target fresh read：level=50
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
-		Return(int64(50), nil).Times(1)
-	// caller fresh read：DB 真实已降级到 100（低权），比 target 的 50 更低权 → 应拒
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
-		Return(int64(100), nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-	// 关键：缓存里还是 10（降级前的高权级别）—— 源码如果信任 caller.MinPermsLevel 就会放行。
-	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
-
-	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
-	require.Error(t, err, "H-2：降级后缓存仍高权的 caller 必须被 DB 实值拦截")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code(),
-		"H-2：TOCTOU 修复后必须走 DB，结果为 403；若测试看到 200/nil err 说明仍读的是 caller.MinPermsLevel 缓存")
-	assert.Contains(t, ce.Error(), "无权管理权限级别高于或等于您的用户")
-}
-
-// TC-0970: caller 在 DB 里已无任何角色（ErrNotFound）→ 即便缓存仍显示 MinPermsLevel=10，也必须拒。
-// 对称验证 M-3 里 GuardRoleLevelAssignable 对"caller 被清角色"的处理方式。
-func TestCheckPermLevel_CallerFreshRead_NotFound_ForbidsEvenWithCachedLevel(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
-
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
-		Return(int64(50), nil).Times(1)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
-		Return(int64(0), sqlx.ErrNotFound).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
-
-	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
-	require.Error(t, err, "H-2：caller 在 DB 已无角色时一律拒绝同级/跨级管辖")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-}
-
-// TC-0971: 正向通过路径 —— caller DB level=10（高权），target level=50 → 严格高权，放行。
-// 用来证明修复没有误伤合法管理路径。
-func TestCheckPermLevel_FreshRead_HigherPriv_Passes(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
-		Return(int64(50), nil).Times(1)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
-		Return(int64(10), nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
-
-	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
-	assert.NoError(t, err, "H-2：合法严格高权管理路径不得被修复误伤")
-}
-
-// TC-0972: caller 侧 DB 非 ErrNotFound 错误 → 500 fail-close。
-// 对称于 checkPermLevel 里 target 侧的 L-4 fail-close，把 caller 侧也钉死，避免"DB 抖动被伪装成无角色"。
-func TestCheckPermLevel_CallerFreshRead_GenericDBErr_FailsClosedWith500(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	userMock, deptMock, pmMock := h2MockTargetMemberAndDept(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), h2TestProductCode).
-		Return(int64(50), nil).Times(1)
-	// caller 侧 DB 抖动
-	dbErr := errors.New("driver: bad connection")
-	roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(1), h2TestProductCode).
-		Return(int64(0), dbErr).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(10))
-
-	err := CheckManageAccess(ctx, svcCtx, 42, h2TestProductCode)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 500, ce.Code(),
-		"H-2：caller 侧 DB 抖动必须 fail-close 500，绝不能伪装成'无角色→放行'")
-	// 不得透传驱动细节
-	assert.NotContains(t, ce.Error(), "driver: bad connection")
-}
-
-// TC-0973: SuperAdmin caller 短路 —— 不应触发任何 caller 侧 DB 读。
-// 如果修复把 fresh read 放错位置，SuperAdmin 也会被多打一次 DB，测试会因 Role mock 收到未预期调用而挂。
-func TestCheckPermLevel_SuperAdmin_ShortCircuits_NoCallerFreshRead(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	// 故意不设任何 mock EXPECT —— 任何 DB 调用都会 fail。
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-
-	super := &loaders.UserDetails{
-		UserId: 999, Username: "super_h2", IsSuperAdmin: true,
-		MemberType: consts.MemberTypeSuperAdmin, Status: consts.StatusEnabled,
-		ProductCode: h2TestProductCode,
-	}
-	err := CheckManageAccess(ctxhelper.CustomCtx(super), svcCtx, 42, h2TestProductCode)
-	assert.NoError(t, err, "H-2：SuperAdmin 必须在 CheckManageAccess 顶部短路，不得触发 fresh read")
-}
-
-// TC-0974: caller 管理自己时必须在 CheckManageAccess 顶部短路（L-7 已钉）；
-// H-2 修复不得把这条路径带偏到 fresh read。
-func TestCheckPermLevel_ManageSelf_ShortCircuits_NoFreshRead(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	// 故意不设 mock EXPECT，caller 管自己应该一次 DB 都不打。
-	userMock := mocks.NewMockSysUserModel(ctrl)
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	pmMock := mocks.NewMockSysProductMemberModel(ctrl)
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		User: userMock, Dept: deptMock, ProductMember: pmMock, Role: roleMock,
-	})
-
-	ctx := ctxhelper.CustomCtx(h2DowngradedCallerCtx(100))
-	err := CheckManageAccess(ctx, svcCtx, 1 /* 就是 caller.UserId */, h2TestProductCode)
-	assert.NoError(t, err, "H-2/L-7：caller 管自己永远放行，且不触发 DB fresh read")
-}
-
-// TC-0975: H-2 与 M-3 共享 loadFreshMinPermsLevel helper（契约自洽性）。
-// 既然 checkPermLevel 与 GuardRoleLevelAssignable 两个授权决策点的 caller 侧都走同一个 helper，
-// 任意通用 DB 错误都必须映射为同一文案的 500 CodeError，任意 ErrNotFound 都映射为 notFound=true。
-// 这里覆盖 helper 的两个对称分支。
-func TestLoadFreshMinPermsLevel_ContractParity(t *testing.T) {
-	t.Run("generic DB error → 500 fail-close", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		t.Cleanup(ctrl.Finish)
-
-		roleMock := mocks.NewMockSysRoleModel(ctrl)
-		roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(7), h2TestProductCode).
-			Return(int64(0), errors.New("i/o timeout")).Times(1)
-
-		svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: roleMock})
-		level, notFound, err := loadFreshMinPermsLevel(ctxhelper.CustomCtx(nil), svcCtx, 7, h2TestProductCode)
-		assert.Equal(t, int64(0), level)
-		assert.False(t, notFound)
-		require.Error(t, err)
-		var ce *response.CodeError
-		require.True(t, errors.As(err, &ce))
-		assert.Equal(t, 500, ce.Code())
-	})
-
-	t.Run("ErrNotFound → notFound=true, err=nil", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		t.Cleanup(ctrl.Finish)
-
-		roleMock := mocks.NewMockSysRoleModel(ctrl)
-		roleMock.EXPECT().FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(8), h2TestProductCode).
-			Return(int64(0), sqlx.ErrNotFound).Times(1)
-
-		svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: roleMock})
-		level, notFound, err := loadFreshMinPermsLevel(ctxhelper.CustomCtx(nil), svcCtx, 8, h2TestProductCode)
-		assert.NoError(t, err)
-		assert.True(t, notFound)
-		assert.Equal(t, int64(0), level)
-	})
-}

internal/logic/auth/guardRoleLevelAssignable_freshRead_audit_test.go

@@ -1,262 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-3 修复 —— GuardRoleLevelAssignable 必须每次走 DB 强一致查询，
-// 绝不能信任 caller（loaders.UserDetails）里可能已经 stale 的 MinPermsLevel 缓存。
-//
-// TOCTOU 场景：
-//   1. caller 原先是 permsLevel=5 的高阶成员。
-//   2. 超管把 caller 的高阶角色摘掉，现在 DB 里 MinPermsLevel=100（低阶）。
-//   3. UD 缓存还没被 Clean（Redis 抖动 / TTL 窗口内），caller.MinPermsLevel=5 是旧值。
-//   4. caller 此刻尝试分配 permsLevel=50 的角色 —— 若信缓存（5 vs 50）会**误放行**；
-//      修复后走 DB（100 vs 50），必须 403 拦截。
-// ---------------------------------------------------------------------------
-
-// TC-0930: M-3 —— stale caller.MinPermsLevel 不得影响判定，rolePermsLevel <= freshLevel 必须 403。
-func TestGuardRoleLevelAssignable_StaleCallerCache_FreshDBRejects(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const productCode = "m3_pc_stale"
-	const callerId = int64(1001)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	// 关键：DB 强一致返回 100（被降级后的真实等级）。
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(100), nil).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId:        callerId,
-		Username:      "m3_stale_caller",
-		MemberType:    consts.MemberTypeMember,
-		ProductCode:   productCode,
-		Status:        consts.StatusEnabled,
-		MinPermsLevel: 5,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 50)
-	require.Error(t, err, "stale 缓存(5) 下试图分配 permsLevel=50，信缓存会放行；走 DB(100) 必须 403")
-
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code(), "M-3：拒绝分配高于自身 fresh 等级的角色 → 403")
-}
-
-// TC-0931: M-3 —— 同级（rolePermsLevel == freshLevel）也要拦截，保持与 checkPermLevel 的 ">=" 对齐。
-func TestGuardRoleLevelAssignable_SameLevel_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const productCode = "m3_pc_same"
-	const callerId = int64(1002)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(50), nil).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId:      callerId,
-		Username:    "m3_same_caller",
-		MemberType:  consts.MemberTypeMember,
-		ProductCode: productCode,
-		Status:      consts.StatusEnabled,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 50)
-	require.Error(t, err, "与自身同级不允许分配，否则会让下属获得与上级等效的权力")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "同级")
-}
-
-// TC-0932: M-3 —— rolePermsLevel 严格低于 freshLevel（数值更大）时放行。
-func TestGuardRoleLevelAssignable_StrictlyLower_Allowed(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const productCode = "m3_pc_ok"
-	const callerId = int64(1003)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(50), nil).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId:      callerId,
-		Username:    "m3_ok_caller",
-		MemberType:  consts.MemberTypeMember,
-		ProductCode: productCode,
-		Status:      consts.StatusEnabled,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 80)
-	require.NoError(t, err, "permsLevel=80 严格低于 freshLevel=50（数值更大 = 更低权限）应放行")
-}
-
-// TC-0933: M-3 —— SuperAdmin 完全豁免，不触发任何 DB 查询。
-func TestGuardRoleLevelAssignable_SuperAdmin_BypassNoDBCall(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	// 预期 0 次调用：SuperAdmin 必须短路返回，不能浪费 DB RTT。
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
-		Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId: 1, Username: "root", IsSuperAdmin: true, Status: consts.StatusEnabled,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
-	require.NoError(t, err, "SuperAdmin 必须放行任何 permsLevel")
-}
-
-// TC-0934: M-3 —— 产品 ADMIN 拥有全权，豁免 DB 查询。
-func TestGuardRoleLevelAssignable_ProductAdmin_BypassNoDBCall(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
-		Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId: 2, Username: "pa", MemberType: consts.MemberTypeAdmin,
-		ProductCode: "p1", Status: consts.StatusEnabled,
-	}
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
-	require.NoError(t, err, "产品 ADMIN 属于全权角色，必须豁免等级校验")
-}
-
-// TC-0935: M-3 —— DEVELOPER 同样享有全权豁免。
-func TestGuardRoleLevelAssignable_Developer_BypassNoDBCall(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
-		Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId: 3, Username: "dev", MemberType: consts.MemberTypeDeveloper,
-		ProductCode: "p1", Status: consts.StatusEnabled,
-	}
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 1)
-	require.NoError(t, err)
-}
-
-// TC-0936: M-3 —— caller 在 DB 里**无任何角色**（ErrNotFound），必须 403，不能默认为 MaxInt64 放行。
-// 这里的语义是"没有可分配的角色等级"：一个 MEMBER 连自己都没角色，自然不能分配角色给别人。
-func TestGuardRoleLevelAssignable_CallerHasNoRole_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const productCode = "m3_pc_noRole"
-	const callerId = int64(1004)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(0), sqlx.ErrNotFound).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId: callerId, Username: "m3_no_role", MemberType: consts.MemberTypeMember,
-		ProductCode: productCode, Status: consts.StatusEnabled,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 99)
-	require.Error(t, err, "caller 无任何角色时必须拒绝，否则会被误判为 MaxInt64 最低级从而放行任何 permsLevel")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "没有可分配的角色等级")
-}
-
-// TC-0937: M-3 —— DB 抖动（非 ErrNotFound）必须 fail-close 返回 500，不得降级为"无角色 → 放行"。
-func TestGuardRoleLevelAssignable_DBError_FailCloseWith500(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const productCode = "m3_pc_dbErr"
-	const callerId = int64(1005)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(0), errors.New("driver: bad connection")).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId: callerId, Username: "m3_db_err", MemberType: consts.MemberTypeMember,
-		ProductCode: productCode, Status: consts.StatusEnabled,
-	}
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, caller, 10)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 500, ce.Code(),
-		"M-3：DB 非 ErrNotFound 错误必须 fail-close 500，不能被伪装成 ErrNotFound → 放行超权分配")
-}
-
-// TC-0938: M-3 —— nil caller 防御：理论上无登录上下文绝不该进入此函数，防御性路径必须 403 而非 panic。
-func TestGuardRoleLevelAssignable_NilCaller_Rejected(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), gomock.Any(), gomock.Any()).
-		Times(0)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	err := GuardRoleLevelAssignable(context.Background(), svcCtx, nil, 10)
-	require.Error(t, err, "nil caller 必须被拦截，杜绝隐式放行")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-}

internal/logic/auth/jwt_test.go

@@ -1,22 +1,23 @@
 package auth
 
 import (
+	"crypto/hmac"
+	"crypto/sha256"
 	"encoding/base64"
 	"encoding/json"
-	"strings"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/middleware"
-
 	"github.com/golang-jwt/jwt/v4"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/middleware"
+	"strings"
+	"testing"
+	"time"
 )
 
 const testSecret = "test-jwt-secret-key"
 
-// TC-0292: secret="s", expire=3600, userId=1, username="u", productCode="p", memberType="M"
+// TC-0292: secret="s", expire=3600, userId=1, username="u", productCode="p", memberType=""
 func TestGenerateAccessToken(t *testing.T) {
 	tests := []struct {
 		name         string
@@ -78,7 +79,7 @@ func TestGenerateAccessToken(t *testing.T) {
 			assert.Equal(t, tt.memberType, claims.MemberType)
 			assert.Equal(t, tt.tokenVersion, claims.TokenVersion)
 
-			// 审计修复项 M-6：`perms` 字段已从 Claims 结构体中移除。
+			// 项 ：`perms` 字段已从 Claims 结构体中移除。
 			// 解析原始 JWT payload，确保 token JSON 中不存在 "perms" key。
 			segments := strings.Split(tokenStr, ".")
 			require.Len(t, segments, 3, "jwt must have 3 segments")
@@ -87,7 +88,7 @@ func TestGenerateAccessToken(t *testing.T) {
 			var raw map[string]interface{}
 			require.NoError(t, json.Unmarshal(payloadBytes, &raw))
 			_, hasPerms := raw["perms"]
-			assert.False(t, hasPerms, "access token payload must NOT contain perms field (audit M-6)")
+			assert.False(t, hasPerms, "access token payload must NOT contain perms field")
 		})
 	}
 }
@@ -193,3 +194,179 @@ func TestGenerateAccessToken_EmptySecret(t *testing.T) {
 	require.True(t, ok)
 	assert.Equal(t, int64(1), claims.UserId)
 }
+
+// ---------------------------------------------------------------------------
+// 覆盖目标：ParseWithHMAC 必须显式断言 token.Method 为
+// *jwt.SigningMethodHMAC，拒绝任何非 HMAC 的 alg 头，包括 "none" / "RS256" 等。
+// 这里不等同于 jwt-go v4 对 "alg=none" 的默认拒绝，而是深度防御的显式白名单校验，
+// 杜绝未来迁移到 RSA/ECDSA 时攻击者把公钥当共享密钥伪造 HS256 token
+// （CVE-2016-10555 同类问题、OWASP JWT / RFC 8725 要求）。
+// ---------------------------------------------------------------------------
+
+const h4Secret = "h4-audit-secret-key"
+
+// b64url returns the jwt-style base64url (no padding) encoding.
+func b64url(b []byte) string { return base64.RawURLEncoding.EncodeToString(b) }
+
+// forgeToken 手动拼接一个 JWT：自定义 header.alg + payload，再用任意密钥做 HMAC 签名。
+// 这用于模拟"攻击者伪造头部 alg 但签名仍走 HS256"的场景。
+func forgeToken(t *testing.T, alg string, claims any, signingKey string) string {
+	t.Helper()
+	header := map[string]string{"alg": alg, "typ": "JWT"}
+	hBytes, err := json.Marshal(header)
+	require.NoError(t, err)
+	pBytes, err := json.Marshal(claims)
+	require.NoError(t, err)
+
+	signingInput := b64url(hBytes) + "." + b64url(pBytes)
+	mac := hmac.New(sha256.New, []byte(signingKey))
+	mac.Write([]byte(signingInput))
+	sig := mac.Sum(nil)
+	return signingInput + "." + b64url(sig)
+}
+
+// forgeTokenNoSig 拼接一个没有签名的 token（alg=none 典型攻击，第三段签名留空）。
+func forgeTokenNoSig(t *testing.T, alg string, claims any) string {
+	t.Helper()
+	header := map[string]string{"alg": alg, "typ": "JWT"}
+	hBytes, err := json.Marshal(header)
+	require.NoError(t, err)
+	pBytes, err := json.Marshal(claims)
+	require.NoError(t, err)
+	return b64url(hBytes) + "." + b64url(pBytes) + "."
+}
+
+// validRefreshClaims 返回一组完整、未过期的 refresh claims，用于伪造攻击 token。
+func validRefreshClaims() RefreshClaims {
+	now := time.Now()
+	return RefreshClaims{
+		TokenType:    consts.TokenTypeRefresh,
+		UserId:       7,
+		ProductCode:  "h4_pc",
+		TokenVersion: 0,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(now.Add(1 * time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(now),
+		},
+	}
+}
+
+// TC-0951: 正常 HS256 token 必须被 ParseWithHMAC 正确接受。
+func TestParseWithHMAC_HS256_Valid(t *testing.T) {
+	tok, err := GenerateRefreshToken(h4Secret, 3600, 7, "h4_pc", 0)
+	require.NoError(t, err)
+
+	token, err := ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
+	require.NoError(t, err)
+	assert.True(t, token.Valid)
+	claims, ok := token.Claims.(*RefreshClaims)
+	require.True(t, ok)
+	assert.Equal(t, int64(7), claims.UserId)
+	assert.Equal(t, consts.TokenTypeRefresh, claims.TokenType)
+}
+
+// TC-0952: alg=none 的伪造 token 必须被拒绝。
+// jwt-go v4 默认就会拦住 "none"，但显式 HMAC 断言保证即使 lib 行为变化我们仍 fail-close。
+func TestParseWithHMAC_AlgNone_Rejected(t *testing.T) {
+	forged := forgeTokenNoSig(t, "none", validRefreshClaims())
+
+	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
+	require.Error(t, err, "alg=none 必须被 ParseWithHMAC 拒绝")
+}
+
+// TC-0953: 攻击者把 header alg 改成 RS256 但仍用 secret 作 HS256 签名
+// （RSA 公钥 → HMAC secret 混淆攻击）。必须被 ParseWithHMAC 显式拒绝：
+// 命中 keyfunc 的 `token.Method.(*SigningMethodHMAC)` 断言失败分支。
+func TestParseWithHMAC_RS256HeaderButHMACSigned_Rejected(t *testing.T) {
+	forged := forgeToken(t, "RS256", validRefreshClaims(), h4Secret)
+
+	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
+	require.Error(t, err, "alg=RS256 必须被 ParseWithHMAC 拒绝")
+	assert.Contains(t, err.Error(), "unexpected signing method",
+		"错误信息必须明确指出 alg 与预期不符（便于运维快速定位攻击尝试）")
+}
+
+// TC-0954: alg=ES256 同样应被拒绝（非 HMAC 算法一律拒绝）。
+func TestParseWithHMAC_ES256HeaderButHMACSigned_Rejected(t *testing.T) {
+	forged := forgeToken(t, "ES256", validRefreshClaims(), h4Secret)
+
+	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "unexpected signing method")
+}
+
+// TC-0955: alg=HS256 但用错误的 secret 签名应被拒绝（签名校验失败路径）。
+func TestParseWithHMAC_HS256WrongSecret_Rejected(t *testing.T) {
+	tok, err := GenerateRefreshToken("attacker-guessed-secret", 3600, 7, "h4_pc", 0)
+	require.NoError(t, err)
+
+	_, err = ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
+	require.Error(t, err, "签名校验失败必须回错，不得放行")
+}
+
+// TC-0956: ParseRefreshToken（对外真实入口）也走 HMAC 断言，alg=RS256 必须被拒。
+// 保证 ParseWithHMAC 不是孤立函数，而是已被真实调用链使用。
+func TestParseRefreshToken_RS256Header_Rejected(t *testing.T) {
+	forged := forgeToken(t, "RS256", validRefreshClaims(), h4Secret)
+	_, err := ParseRefreshToken(forged, h4Secret)
+	require.Error(t, err, "ParseRefreshToken 必须转交 ParseWithHMAC 拒绝 RS256 伪造 token")
+}
+
+// TC-0957: ParseRefreshToken 对 alg=none 的 token 也必须拒绝。
+func TestParseRefreshToken_AlgNone_Rejected(t *testing.T) {
+	forged := forgeTokenNoSig(t, "none", validRefreshClaims())
+	_, err := ParseRefreshToken(forged, h4Secret)
+	require.Error(t, err)
+}
+
+// TC-0958:  回归 —— 格式错误的 token（非三段式）必须 error 而不是 panic。
+func TestParseWithHMAC_Malformed_Rejected(t *testing.T) {
+	cases := []string{
+		"",
+		"not-a-token",
+		"only.two",
+		"a.b.c.d", // 四段
+	}
+	for _, s := range cases {
+		t.Run("malformed:"+s, func(t *testing.T) {
+			_, err := ParseWithHMAC(s, h4Secret, &RefreshClaims{})
+			require.Error(t, err)
+		})
+	}
+}
+
+// TC-0959: payload 中 TokenType 非 refresh 的 HS256 token 应被 ParseRefreshToken
+// 以 ErrTokenTypeMismatch 拒绝。确认  修复不会误吞该业务校验。
+func TestParseRefreshToken_AccessTokenRejectedWithTypeMismatch(t *testing.T) {
+	accessTok, err := GenerateAccessToken(h4Secret, 3600, 7, "u", "p", "M", 0)
+	require.NoError(t, err)
+	_, err = ParseRefreshToken(accessTok, h4Secret)
+	require.Error(t, err)
+	assert.Equal(t, ErrTokenTypeMismatch, err,
+		"的 ParseWithHMAC 不能吞掉业务层 TokenType 校验错误")
+}
+
+// TC-0960: 伪造 alg=HS256 但 header.typ 异常（如 "JWT"→"xxx"）也不能绕过
+// HMAC 校验。此用例用来证明只要底层签名正确，header 其余字段不影响放行/拒绝的核心语义。
+// 反之，任何 alg 头不是 HS* 的一律拒，和 typ 无关。
+func TestParseWithHMAC_HS256UnusualTyp_Accepted(t *testing.T) {
+	// header.alg = HS256, header.typ = "JWT+weird"，签名正确 → 应放行（typ 不参与断言）
+	header := map[string]string{"alg": "HS256", "typ": "JWT+weird"}
+	hBytes, _ := json.Marshal(header)
+	claims := validRefreshClaims()
+	pBytes, _ := json.Marshal(claims)
+	signingInput := b64url(hBytes) + "." + b64url(pBytes)
+	mac := hmac.New(sha256.New, []byte(h4Secret))
+	mac.Write([]byte(signingInput))
+	tok := signingInput + "." + b64url(mac.Sum(nil))
+
+	_, err := ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
+	require.NoError(t, err,
+		"HMAC 断言只看 alg，typ 不属于签名算法白名单范畴，正常 HS256 应放行")
+}
+
+// 辅助：保持 strings 导入被使用，避免 go vet 警告。
+var _ = strings.Split
+
+// 确保 middleware.Claims 在包内可被用于 TypeRefresh / TypeAccess 等正反测试（未来扩展）。
+var _ = middleware.Claims{}

internal/logic/auth/loadCallerAssignableLevel_audit_test.go

@@ -1,170 +0,0 @@
-package auth
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-R10-3 —— LoadCallerAssignableLevel 在一次请求内对同一 caller 只做
-// 一次 DB 读；CheckRoleLevelAgainst 不再访问 DB，给 BindRoles 这种"批量覆盖"的接口把
-// N 次 loadFreshMinPermsLevel 合并为 1 次。
-//
-// 核心断言口径：
-//   1. SuperAdmin / ADMIN / DEVELOPER 等全权调用者不打 DB（HasFullPerms=true 短路）；
-//   2. MEMBER caller 打 1 次 FindMinPermsLevelByUserIdAndProductCode；
-//   3. caller.ErrNotFound → NoRole=true（不打翻 500）；
-//   4. caller 其他 DB 错误 → fail-close 500（保持与 loadFreshMinPermsLevel 一致的口径，
-//      避免降级为"无角色 = 最低级"放行）。
-//   5. CheckRoleLevelAgainst 是纯函数，不访问 svcCtx。
-// ---------------------------------------------------------------------------
-
-// TC-1017: M-R10-3 —— SuperAdmin / ADMIN / DEVELOPER 走 HasFullPerms 短路，不触碰 DB。
-func TestLoadCallerAssignableLevel_FullPermsShortCircuit_NoDB(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	// 关键：没有 EXPECT.FindMinPermsLevelByUserIdAndProductCode —— 一旦被调用会 fail。
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	cases := []struct {
-		name   string
-		caller *loaders.UserDetails
-	}{
-		{
-			name:   "SuperAdmin",
-			caller: &loaders.UserDetails{UserId: 1, IsSuperAdmin: true, ProductCode: "p"},
-		},
-		{
-			name:   "ADMIN",
-			caller: &loaders.UserDetails{UserId: 2, MemberType: consts.MemberTypeAdmin, ProductCode: "p"},
-		},
-		{
-			name:   "DEVELOPER",
-			caller: &loaders.UserDetails{UserId: 3, MemberType: consts.MemberTypeDeveloper, ProductCode: "p"},
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, c.caller)
-			require.NoError(t, err)
-			assert.True(t, snap.HasFullPerms, "全权调用者必须落 HasFullPerms 分支")
-			assert.False(t, snap.NoRole)
-		})
-	}
-}
-
-// TC-1018: M-R10-3 —— MEMBER caller 仅打 1 次 FindMinPermsLevelByUserIdAndProductCode；
-// 循环内对 N 个角色走 CheckRoleLevelAgainst 不再打 DB。
-func TestLoadCallerAssignableLevel_Member_ReadsDBOnce_ThenConstantTime(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const callerId = int64(1001)
-	const productCode = "pc_m_r10_3"
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	// 关键断言：Times(1) 保证 N 个角色场景不会退化为 N 次 DB 读。
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), callerId, productCode).
-		Return(int64(100), nil).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-
-	caller := &loaders.UserDetails{
-		UserId:      callerId,
-		MemberType:  consts.MemberTypeMember,
-		ProductCode: productCode,
-	}
-	snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
-	require.NoError(t, err)
-	assert.False(t, snap.HasFullPerms)
-	assert.False(t, snap.NoRole)
-	assert.Equal(t, int64(100), snap.Level)
-
-	// 模拟 BindRoles 批量覆盖的循环：5 个角色，全部走 CheckRoleLevelAgainst 的纯比较，
-	// 任何一个角色额外打 DB 都会命中 gomock 的 "unexpected call" 断言。
-	roleLevels := []int64{200, 150, 300, 120, 999}
-	for _, rl := range roleLevels {
-		if err := CheckRoleLevelAgainst(snap, rl); err != nil {
-			t.Fatalf("role level %d should be assignable against caller level %d: %v", rl, snap.Level, err)
-		}
-	}
-
-	// 同级与更高级一律拒绝（与 GuardRoleLevelAssignable 对称）：
-	for _, rl := range []int64{100, 50, 1} {
-		err := CheckRoleLevelAgainst(snap, rl)
-		var codeErr *response.CodeError
-		require.True(t, errors.As(err, &codeErr), "同级或更高级必须返回 CodeError")
-		assert.Equal(t, 403, codeErr.Code())
-	}
-}
-
-// TC-1019: M-R10-3 —— caller 在该产品下无角色 → NoRole=true，不回滚 500。
-func TestLoadCallerAssignableLevel_Member_ErrNotFound_MapsToNoRole(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(42), "pc").
-		Return(int64(0), sqlx.ErrNotFound).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-	caller := &loaders.UserDetails{
-		UserId:      42,
-		MemberType:  consts.MemberTypeMember,
-		ProductCode: "pc",
-	}
-	snap, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
-	require.NoError(t, err, "ErrNotFound 必须被归一为 NoRole=true，不得外泄为 500")
-	assert.False(t, snap.HasFullPerms)
-	assert.True(t, snap.NoRole)
-
-	// 验证 NoRole 的 caller 连最低级角色也无法分配（与修复前保持的业务语义一致）。
-	err = CheckRoleLevelAgainst(snap, 999)
-	var codeErr *response.CodeError
-	require.True(t, errors.As(err, &codeErr))
-	assert.Equal(t, 403, codeErr.Code())
-	assert.Contains(t, codeErr.Error(), "没有可分配的角色等级")
-}
-
-// TC-1020: M-R10-3 —— caller 其他 DB 错误必须 fail-close 500，不得降级为 NoRole 放行。
-// 保证修复没有把"DB 抖动"悄悄压成"无角色 → 最低级 → 403"这种语义欺骗。
-func TestLoadCallerAssignableLevel_Member_DBError_FailClose500(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	dbErr := errors.New("driver: bad connection")
-	mockRole := mocks.NewMockSysRoleModel(ctrl)
-	mockRole.EXPECT().
-		FindMinPermsLevelByUserIdAndProductCode(gomock.Any(), int64(7), "pc").
-		Return(int64(0), dbErr).
-		Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Role: mockRole})
-	caller := &loaders.UserDetails{
-		UserId:      7,
-		MemberType:  consts.MemberTypeMember,
-		ProductCode: "pc",
-	}
-
-	_, err := LoadCallerAssignableLevel(context.Background(), svcCtx, caller)
-	var codeErr *response.CodeError
-	require.True(t, errors.As(err, &codeErr), "DB 抖动必须 fail-close 为 CodeError 而非 nil")
-	assert.Equal(t, 500, codeErr.Code())
-}

internal/logic/auth/logoutLogic_test.go

@@ -4,21 +4,22 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/limit"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"go.uber.org/mock/gomock"
 	"perms-system-server/internal/loaders"
 	"perms-system-server/internal/middleware"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"perms-system-server/internal/testutil/mocks"
+	"testing"
+	"time"
 )
 
-// TC-0720: Logout 正常：tokenVersion 递增且 loader 缓存被清理
 func TestLogout_Normal_IncrementsTokenVersion(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -36,7 +37,7 @@ func TestLogout_Normal_IncrementsTokenVersion(t *testing.T) {
 	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
 
 	ud, err := svcCtx.UserDetailsLoader.Load(ctx, userId, "")
-	require.NoError(t, err, "M-1：正常用户 Load 应当 (*UserDetails, nil)")
+	require.NoError(t, err, "正常用户 Load 应当 (*UserDetails, nil)")
 	require.NotNil(t, ud)
 	assert.Equal(t, int64(0), ud.TokenVersion)
 
@@ -96,3 +97,219 @@ func TestLogout_TwiceAccumulates(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, int64(2), u.TokenVersion)
 }
+
+func TestLogout_TokenOpLimiter_BlocksThirdCall(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	username := "lg_rl_" + testutil.UniqueId()
+
+	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: username, Password: testutil.HashPassword("pw"), Nickname: "lg_rl",
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	userId, _ := res.LastInsertId()
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
+
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	// 独立 prefix 保证与全局 limiter 桶互不干扰，也避免用例互相污染
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 2, rds, cfg.CacheRedis.KeyPrefix+":rl:logout:ut:"+testutil.UniqueId())
+
+	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: userId, Username: username, Status: 1,
+	})
+
+	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 1 次 logout 应放行")
+	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 2 次 logout 仍在配额内应放行")
+
+	err = NewLogoutLogic(lctx, svcCtx).Logout()
+	require.Error(t, err, "第 3 次必须被 TokenOpLimiter 拦截")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code())
+	assert.Contains(t, ce.Error(), "过于频繁")
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), u.TokenVersion,
+		"被限流的 logout 请求绝不能再触发 IncrementTokenVersion（否则攻击者可反复刷新缓存）")
+}
+
+// TC-0740: -C 修复 —— 限流 key 必须按 userId 隔离，A 用户打满不得影响 B 用户。
+func TestLogout_TokenOpLimiter_PerUserIsolated(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+
+	mkUser := func(tag string) int64 {
+		res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+			Username: "lg_iso_" + tag + "_" + testutil.UniqueId(),
+			Password: testutil.HashPassword("pw"), Nickname: "lg_iso",
+			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+			Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		id, _ := res.LastInsertId()
+		return id
+	}
+	aId := mkUser("a")
+	bId := mkUser("b")
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", aId, bId) })
+
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:logout:iso:"+testutil.UniqueId())
+
+	lctxA := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{UserId: aId, Status: 1})
+	lctxB := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{UserId: bId, Status: 1})
+
+	require.NoError(t, NewLogoutLogic(lctxA, svcCtx).Logout())
+	// A 打满后再打一次
+	err := NewLogoutLogic(lctxA, svcCtx).Logout()
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code())
+
+	require.NoError(t, NewLogoutLogic(lctxB, svcCtx).Logout(),
+		"B 用户应当仍有独立配额，不被 A 用户的限流影响")
+}
+
+// TC-0790: -C 修复延伸 —— TokenOpLimiter 是 period 滚动窗口，配额打满后在窗口结束时必须自动恢复。
+// 用 period=1 秒、quota=1 的 limiter 打满后: (1) 第 2 次立即调用被拒 (2) sleep >1s 窗口滑过后第 3 次放行。
+// 这挡住了"限流误成了永久 deny" 的实现退化 (例如错用了 TokenBucket 但不补齐, 或 Redis key 设成永不过期)。
+func TestLogout_TokenOpLimiter_WindowRecovers(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+
+	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: "lg_win_" + testutil.UniqueId(),
+		Password: testutil.HashPassword("pw"), Nickname: "lg_win",
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	userId, _ := res.LastInsertId()
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
+
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(1, 1, rds,
+		cfg.CacheRedis.KeyPrefix+":rl:logout:win:"+testutil.UniqueId())
+
+	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: userId, Status: 1,
+	})
+
+	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 1 次 logout 放行")
+	err = NewLogoutLogic(lctx, svcCtx).Logout()
+	require.Error(t, err, "同一窗口内第 2 次必须 429")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code())
+
+	// 等窗口滚过 (period=1s, 多等 200ms 余量)
+	time.Sleep(1200 * time.Millisecond)
+
+	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(),
+		"窗口滚过后配额必须自动恢复；若此处 429, 说明限流从滚动窗口退化成了永久封锁")
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), u.TokenVersion,
+		"恢复后的 logout 必须真正进入业务层递增 tokenVersion (= 1 窗口第一次 + 2 窗口第一次)")
+}
+
+// TC-0791: -C 修复延伸 —— 当 Redis 不可达时 limit.PeriodLimit.Take 返回错误。
+// 生产代码使用 `code, _ := ...; if code == OverQuota` 模式, 即 Redis 宕机时 **fail-OPEN**: 仍允许登出。
+// 这是工程取舍 —— 登出是"用户体验优先"的操作, 拒绝登出比放行更糟。本用例冻结此契约,
+// 未来若有人改成 fail-CLOSE (default deny) 必须在 code review 明确讨论, 不应静默发生。
+func TestLogout_FailOpenWhenLimiterUnreachable(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+
+	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: "lg_down_" + testutil.UniqueId(),
+		Password: testutil.HashPassword("pw"), Nickname: "lg_down",
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	userId, _ := res.LastInsertId()
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
+
+	// 指向一个不可达的 redis 端口 (127.0.0.1:1 保证拨号失败), NonBlock=true 跳过启动 ping,
+	// 否则 NewRedis 自身会在构造期就返回错误, 测不到"运行期 Take 失败"的分支。
+	badRds, err := redis.NewRedis(redis.RedisConf{
+		Host: "127.0.0.1:1", Type: "node", NonBlock: true,
+		PingTimeout: 100 * time.Millisecond,
+	})
+	require.NoError(t, err)
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, badRds,
+		"perms:test:rl:logout:down:"+testutil.UniqueId())
+
+	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: userId, Status: 1,
+	})
+
+	// Redis 不可达 → limit.Take 返回 err, code 非 OverQuota → 放行业务
+	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(),
+		"Redis 宕机时 logout 必须 fail-OPEN 放行 (业务层应正常递增 tokenVersion)")
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), u.TokenVersion,
+		"fail-OPEN 放行后必须真正执行 IncrementTokenVersion, 否则是 fail-CLOSE 伪装")
+}
+
+func TestLogout_ForwardsUsername_NoInternalFindOne(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const userId = int64(7777)
+	const username = "m_r11_2_subject"
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	// 契约：username 参数必须与 ud.Username 字面一致。
+	mockUser.EXPECT().
+		IncrementTokenVersion(gomock.Any(), userId, username).
+		Return(int64(1), nil)
+	// 不允许再出现任何 FindOne / FindOneByUsername 的调用（gomock 默认就会对未声明的调用 fail）。
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
+	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{
+		UserId: userId, Username: username, Status: 1,
+	})
+
+	require.NoError(t, NewLogoutLogic(ctx, svcCtx).Logout(),
+		"Logout 正常路径应通过，且必须按签名字面透传 username")
+}
+
+// TC-1048: Logout 在 Username 为 "" 的极端场景下仍然透传空串（不隐式 FindOne 修补）
+// 该契约保证 Model 层对 "调用方未提供 username" 的场景**不做缓存键兜底**；
+// 若 DEV 回退成 Model 内部 FindOne，行为会变：Logic 传 "" 进来时 Model 会真的去 DB 查一次。
+func TestLogout_EmptyUsernameStillForwarded(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	const userId = int64(8888)
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().
+		IncrementTokenVersion(gomock.Any(), userId, ""). // 严格 "" 不是 gomock.Any()
+		Return(int64(3), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
+	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{
+		UserId: userId, Username: "", Status: 1,
+	})
+	require.NoError(t, NewLogoutLogic(ctx, svcCtx).Logout())
+}

internal/logic/auth/logoutRateLimit_audit_test.go

@@ -1,197 +0,0 @@
-package auth
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/limit"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-// TC-0739: L-C 修复回归 —— Logout 必须受 TokenOpLimiter 保护；
-// 用 quota=2 的定制 limiter，同一用户超过配额后第 3 次必须返回 429，
-// 且该超限请求**不能**递增 tokenVersion（避免撞库者反复自增搅乱 Cache）。
-func TestLogout_TokenOpLimiter_BlocksThirdCall(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	username := "lg_rl_" + testutil.UniqueId()
-
-	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: username, Password: testutil.HashPassword("pw"), Nickname: "lg_rl",
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	userId, _ := res.LastInsertId()
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
-
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	// 独立 prefix 保证与全局 limiter 桶互不干扰，也避免用例互相污染
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 2, rds, cfg.CacheRedis.KeyPrefix+":rl:logout:ut:"+testutil.UniqueId())
-
-	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: userId, Username: username, Status: 1,
-	})
-
-	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 1 次 logout 应放行")
-	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 2 次 logout 仍在配额内应放行")
-
-	err = NewLogoutLogic(lctx, svcCtx).Logout()
-	require.Error(t, err, "第 3 次必须被 TokenOpLimiter 拦截")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code())
-	assert.Contains(t, ce.Error(), "过于频繁")
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(2), u.TokenVersion,
-		"被限流的 logout 请求绝不能再触发 IncrementTokenVersion（否则攻击者可反复刷新缓存）")
-}
-
-// TC-0740: L-C 修复 —— 限流 key 必须按 userId 隔离，A 用户打满不得影响 B 用户。
-func TestLogout_TokenOpLimiter_PerUserIsolated(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-
-	mkUser := func(tag string) int64 {
-		res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-			Username: "lg_iso_" + tag + "_" + testutil.UniqueId(),
-			Password: testutil.HashPassword("pw"), Nickname: "lg_iso",
-			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-			Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		id, _ := res.LastInsertId()
-		return id
-	}
-	aId := mkUser("a")
-	bId := mkUser("b")
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", aId, bId) })
-
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:logout:iso:"+testutil.UniqueId())
-
-	lctxA := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{UserId: aId, Status: 1})
-	lctxB := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{UserId: bId, Status: 1})
-
-	require.NoError(t, NewLogoutLogic(lctxA, svcCtx).Logout())
-	// A 打满后再打一次
-	err := NewLogoutLogic(lctxA, svcCtx).Logout()
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code())
-
-	require.NoError(t, NewLogoutLogic(lctxB, svcCtx).Logout(),
-		"B 用户应当仍有独立配额，不被 A 用户的限流影响")
-}
-
-// TC-0790: L-C 修复延伸 —— TokenOpLimiter 是 period 滚动窗口，配额打满后在窗口结束时必须自动恢复。
-// 用 period=1 秒、quota=1 的 limiter 打满后: (1) 第 2 次立即调用被拒 (2) sleep >1s 窗口滑过后第 3 次放行。
-// 这挡住了"限流误成了永久 deny" 的实现退化 (例如错用了 TokenBucket 但不补齐, 或 Redis key 设成永不过期)。
-func TestLogout_TokenOpLimiter_WindowRecovers(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-
-	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: "lg_win_" + testutil.UniqueId(),
-		Password: testutil.HashPassword("pw"), Nickname: "lg_win",
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	userId, _ := res.LastInsertId()
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
-
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(1, 1, rds,
-		cfg.CacheRedis.KeyPrefix+":rl:logout:win:"+testutil.UniqueId())
-
-	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: userId, Status: 1,
-	})
-
-	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(), "第 1 次 logout 放行")
-	err = NewLogoutLogic(lctx, svcCtx).Logout()
-	require.Error(t, err, "同一窗口内第 2 次必须 429")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code())
-
-	// 等窗口滚过 (period=1s, 多等 200ms 余量)
-	time.Sleep(1200 * time.Millisecond)
-
-	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(),
-		"窗口滚过后配额必须自动恢复；若此处 429, 说明限流从滚动窗口退化成了永久封锁")
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(2), u.TokenVersion,
-		"恢复后的 logout 必须真正进入业务层递增 tokenVersion (= 1 窗口第一次 + 2 窗口第一次)")
-}
-
-// TC-0791: L-C 修复延伸 —— 当 Redis 不可达时 limit.PeriodLimit.Take 返回错误。
-// 生产代码使用 `code, _ := ...; if code == OverQuota` 模式, 即 Redis 宕机时 **fail-OPEN**: 仍允许登出。
-// 这是工程取舍 —— 登出是"用户体验优先"的操作, 拒绝登出比放行更糟。本用例冻结此契约,
-// 未来若有人改成 fail-CLOSE (default deny) 必须在 code review 明确讨论, 不应静默发生。
-func TestLogout_FailOpenWhenLimiterUnreachable(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-
-	res, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: "lg_down_" + testutil.UniqueId(),
-		Password: testutil.HashPassword("pw"), Nickname: "lg_down",
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, TokenVersion: 0, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	userId, _ := res.LastInsertId()
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
-
-	// 指向一个不可达的 redis 端口 (127.0.0.1:1 保证拨号失败), NonBlock=true 跳过启动 ping,
-	// 否则 NewRedis 自身会在构造期就返回错误, 测不到"运行期 Take 失败"的分支。
-	badRds, err := redis.NewRedis(redis.RedisConf{
-		Host: "127.0.0.1:1", Type: "node", NonBlock: true,
-		PingTimeout: 100 * time.Millisecond,
-	})
-	require.NoError(t, err)
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, badRds,
-		"perms:test:rl:logout:down:"+testutil.UniqueId())
-
-	lctx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: userId, Status: 1,
-	})
-
-	// Redis 不可达 → limit.Take 返回 err, code 非 OverQuota → 放行业务
-	require.NoError(t, NewLogoutLogic(lctx, svcCtx).Logout(),
-		"Redis 宕机时 logout 必须 fail-OPEN 放行 (业务层应正常递增 tokenVersion)")
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(1), u.TokenVersion,
-		"fail-OPEN 放行后必须真正执行 IncrementTokenVersion, 否则是 fail-CLOSE 伪装")
-}

internal/logic/auth/logoutUsernameForward_audit_test.go

@@ -1,65 +0,0 @@
-package auth
-
-import (
-	"testing"
-
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-R11-2 —— Logout Logic 必须把 middleware.UserDetails 里的 Username
-// 直接透传给 SysUserModel.IncrementTokenVersion，而不是让 Model 内部再 FindOne 取一次。
-//
-// 本文件以 mock 的方式对 Logic→Model 的契约做最严格的钉子：
-//   IncrementTokenVersion 的第 3 个参数必须**字面等于** ud.Username；
-//   若 DEV 未来回归成"传 '' 让 Model 内部 FindOne"，gomock 会拦截报错。
-// ---------------------------------------------------------------------------
-
-// TC-1047: M-R11-2 —— Logout 透传 ud.Username 给 IncrementTokenVersion
-func TestLogout_ForwardsUsername_NoInternalFindOne(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const userId = int64(7777)
-	const username = "m_r11_2_subject"
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	// 契约：username 参数必须与 ud.Username 字面一致。
-	mockUser.EXPECT().
-		IncrementTokenVersion(gomock.Any(), userId, username).
-		Return(int64(1), nil)
-	// 不允许再出现任何 FindOne / FindOneByUsername 的调用（gomock 默认就会对未声明的调用 fail）。
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
-	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{
-		UserId: userId, Username: username, Status: 1,
-	})
-
-	require.NoError(t, NewLogoutLogic(ctx, svcCtx).Logout(),
-		"Logout 正常路径应通过，且必须按签名字面透传 username")
-}
-
-// TC-1048: M-R11-2 —— Logout 在 Username 为 "" 的极端场景下仍然透传空串（不隐式 FindOne 修补）
-// 该契约保证 Model 层对 "调用方未提供 username" 的场景**不做缓存键兜底**；
-// 若 DEV 回退成 Model 内部 FindOne，行为会变：Logic 传 "" 进来时 Model 会真的去 DB 查一次。
-func TestLogout_EmptyUsernameStillForwarded(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	const userId = int64(8888)
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().
-		IncrementTokenVersion(gomock.Any(), userId, ""). // 严格 "" 不是 gomock.Any()
-		Return(int64(3), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{User: mockUser})
-	ctx := middleware.WithUserDetails(t.Context(), &loaders.UserDetails{
-		UserId: userId, Username: "", Status: 1,
-	})
-	require.NoError(t, NewLogoutLogic(ctx, svcCtx).Logout())
-}

internal/logic/auth/parseWithHMAC_audit_test.go

@@ -1,194 +0,0 @@
-package auth
-
-import (
-	"crypto/hmac"
-	"crypto/sha256"
-	"encoding/base64"
-	"encoding/json"
-	"strings"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/middleware"
-
-	"github.com/golang-jwt/jwt/v4"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-4 修复 —— ParseWithHMAC 必须显式断言 token.Method 为
-// *jwt.SigningMethodHMAC，拒绝任何非 HMAC 的 alg 头，包括 "none" / "RS256" 等。
-// 这里不等同于 jwt-go v4 对 "alg=none" 的默认拒绝，而是深度防御的显式白名单校验，
-// 杜绝未来迁移到 RSA/ECDSA 时攻击者把公钥当共享密钥伪造 HS256 token
-// （CVE-2016-10555 同类问题、OWASP JWT / RFC 8725 要求）。
-// ---------------------------------------------------------------------------
-
-const h4Secret = "h4-audit-secret-key"
-
-// b64url returns the jwt-style base64url (no padding) encoding.
-func b64url(b []byte) string { return base64.RawURLEncoding.EncodeToString(b) }
-
-// forgeToken 手动拼接一个 JWT：自定义 header.alg + payload，再用任意密钥做 HMAC 签名。
-// 这用于模拟"攻击者伪造头部 alg 但签名仍走 HS256"的场景。
-func forgeToken(t *testing.T, alg string, claims any, signingKey string) string {
-	t.Helper()
-	header := map[string]string{"alg": alg, "typ": "JWT"}
-	hBytes, err := json.Marshal(header)
-	require.NoError(t, err)
-	pBytes, err := json.Marshal(claims)
-	require.NoError(t, err)
-
-	signingInput := b64url(hBytes) + "." + b64url(pBytes)
-	mac := hmac.New(sha256.New, []byte(signingKey))
-	mac.Write([]byte(signingInput))
-	sig := mac.Sum(nil)
-	return signingInput + "." + b64url(sig)
-}
-
-// forgeTokenNoSig 拼接一个没有签名的 token（alg=none 典型攻击，第三段签名留空）。
-func forgeTokenNoSig(t *testing.T, alg string, claims any) string {
-	t.Helper()
-	header := map[string]string{"alg": alg, "typ": "JWT"}
-	hBytes, err := json.Marshal(header)
-	require.NoError(t, err)
-	pBytes, err := json.Marshal(claims)
-	require.NoError(t, err)
-	return b64url(hBytes) + "." + b64url(pBytes) + "."
-}
-
-// validRefreshClaims 返回一组完整、未过期的 refresh claims，用于伪造攻击 token。
-func validRefreshClaims() RefreshClaims {
-	now := time.Now()
-	return RefreshClaims{
-		TokenType:    consts.TokenTypeRefresh,
-		UserId:       7,
-		ProductCode:  "h4_pc",
-		TokenVersion: 0,
-		RegisteredClaims: jwt.RegisteredClaims{
-			ExpiresAt: jwt.NewNumericDate(now.Add(1 * time.Hour)),
-			IssuedAt:  jwt.NewNumericDate(now),
-		},
-	}
-}
-
-// TC-0951: H-4 —— 正常 HS256 token 必须被 ParseWithHMAC 正确接受。
-func TestParseWithHMAC_HS256_Valid(t *testing.T) {
-	tok, err := GenerateRefreshToken(h4Secret, 3600, 7, "h4_pc", 0)
-	require.NoError(t, err)
-
-	token, err := ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
-	require.NoError(t, err)
-	assert.True(t, token.Valid)
-	claims, ok := token.Claims.(*RefreshClaims)
-	require.True(t, ok)
-	assert.Equal(t, int64(7), claims.UserId)
-	assert.Equal(t, consts.TokenTypeRefresh, claims.TokenType)
-}
-
-// TC-0952: H-4 —— alg=none 的伪造 token 必须被拒绝。
-// jwt-go v4 默认就会拦住 "none"，但显式 HMAC 断言保证即使 lib 行为变化我们仍 fail-close。
-func TestParseWithHMAC_AlgNone_Rejected(t *testing.T) {
-	forged := forgeTokenNoSig(t, "none", validRefreshClaims())
-
-	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
-	require.Error(t, err, "alg=none 必须被 ParseWithHMAC 拒绝")
-}
-
-// TC-0953: H-4 —— 攻击者把 header alg 改成 RS256 但仍用 secret 作 HS256 签名
-// （RSA 公钥 → HMAC secret 混淆攻击）。必须被 ParseWithHMAC 显式拒绝：
-// 命中 keyfunc 的 `token.Method.(*SigningMethodHMAC)` 断言失败分支。
-func TestParseWithHMAC_RS256HeaderButHMACSigned_Rejected(t *testing.T) {
-	forged := forgeToken(t, "RS256", validRefreshClaims(), h4Secret)
-
-	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
-	require.Error(t, err, "alg=RS256 必须被 ParseWithHMAC 拒绝")
-	assert.Contains(t, err.Error(), "unexpected signing method",
-		"错误信息必须明确指出 alg 与预期不符（便于运维快速定位攻击尝试）")
-}
-
-// TC-0954: H-4 —— alg=ES256 同样应被拒绝（非 HMAC 算法一律拒绝）。
-func TestParseWithHMAC_ES256HeaderButHMACSigned_Rejected(t *testing.T) {
-	forged := forgeToken(t, "ES256", validRefreshClaims(), h4Secret)
-
-	_, err := ParseWithHMAC(forged, h4Secret, &RefreshClaims{})
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "unexpected signing method")
-}
-
-// TC-0955: H-4 —— alg=HS256 但用错误的 secret 签名应被拒绝（签名校验失败路径）。
-func TestParseWithHMAC_HS256WrongSecret_Rejected(t *testing.T) {
-	tok, err := GenerateRefreshToken("attacker-guessed-secret", 3600, 7, "h4_pc", 0)
-	require.NoError(t, err)
-
-	_, err = ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
-	require.Error(t, err, "签名校验失败必须回错，不得放行")
-}
-
-// TC-0956: H-4 —— ParseRefreshToken（对外真实入口）也走 HMAC 断言，alg=RS256 必须被拒。
-// 保证 ParseWithHMAC 不是孤立函数，而是已被真实调用链使用。
-func TestParseRefreshToken_RS256Header_Rejected(t *testing.T) {
-	forged := forgeToken(t, "RS256", validRefreshClaims(), h4Secret)
-	_, err := ParseRefreshToken(forged, h4Secret)
-	require.Error(t, err, "ParseRefreshToken 必须转交 ParseWithHMAC 拒绝 RS256 伪造 token")
-}
-
-// TC-0957: H-4 —— ParseRefreshToken 对 alg=none 的 token 也必须拒绝。
-func TestParseRefreshToken_AlgNone_Rejected(t *testing.T) {
-	forged := forgeTokenNoSig(t, "none", validRefreshClaims())
-	_, err := ParseRefreshToken(forged, h4Secret)
-	require.Error(t, err)
-}
-
-// TC-0958: H-4 回归 —— 格式错误的 token（非三段式）必须 error 而不是 panic。
-func TestParseWithHMAC_Malformed_Rejected(t *testing.T) {
-	cases := []string{
-		"",
-		"not-a-token",
-		"only.two",
-		"a.b.c.d", // 四段
-	}
-	for _, s := range cases {
-		t.Run("malformed:"+s, func(t *testing.T) {
-			_, err := ParseWithHMAC(s, h4Secret, &RefreshClaims{})
-			require.Error(t, err)
-		})
-	}
-}
-
-// TC-0959: H-4 —— payload 中 TokenType 非 refresh 的 HS256 token 应被 ParseRefreshToken
-// 以 ErrTokenTypeMismatch 拒绝。确认 H-4 修复不会误吞该业务校验。
-func TestParseRefreshToken_AccessTokenRejectedWithTypeMismatch(t *testing.T) {
-	accessTok, err := GenerateAccessToken(h4Secret, 3600, 7, "u", "p", "M", 0)
-	require.NoError(t, err)
-	_, err = ParseRefreshToken(accessTok, h4Secret)
-	require.Error(t, err)
-	assert.Equal(t, ErrTokenTypeMismatch, err,
-		"H-4 的 ParseWithHMAC 不能吞掉业务层 TokenType 校验错误")
-}
-
-// TC-0960: H-4 —— 伪造 alg=HS256 但 header.typ 异常（如 "JWT"→"xxx"）也不能绕过
-// HMAC 校验。此用例用来证明只要底层签名正确，header 其余字段不影响放行/拒绝的核心语义。
-// 反之，任何 alg 头不是 HS* 的一律拒，和 typ 无关。
-func TestParseWithHMAC_HS256UnusualTyp_Accepted(t *testing.T) {
-	// header.alg = HS256, header.typ = "JWT+weird"，签名正确 → 应放行（typ 不参与断言）
-	header := map[string]string{"alg": "HS256", "typ": "JWT+weird"}
-	hBytes, _ := json.Marshal(header)
-	claims := validRefreshClaims()
-	pBytes, _ := json.Marshal(claims)
-	signingInput := b64url(hBytes) + "." + b64url(pBytes)
-	mac := hmac.New(sha256.New, []byte(h4Secret))
-	mac.Write([]byte(signingInput))
-	tok := signingInput + "." + b64url(mac.Sum(nil))
-
-	_, err := ParseWithHMAC(tok, h4Secret, &RefreshClaims{})
-	require.NoError(t, err,
-		"HMAC 断言只看 alg，typ 不属于签名算法白名单范畴，正常 HS256 应放行")
-}
-
-// 辅助：保持 strings 导入被使用，避免 go vet 警告。
-var _ = strings.Split
-
-// 确保 middleware.Claims 在包内可被用于 TypeRefresh / TypeAccess 等正反测试（未来扩展）。
-var _ = middleware.Claims{}

internal/logic/auth/rotateRefreshToken_r11_5_audit_test.go → internal/logic/auth/rotateRefreshToken_test.go

@@ -17,14 +17,14 @@ import (
 )
 
 // ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-R11-5 —— 把 HTTP / gRPC 两条 RefreshToken 路径的"试签 → CAS → Clean →
+// 覆盖目标：把 HTTP / gRPC 两条 RefreshToken 路径的"试签 → CAS → Clean →
 // forensic 比对"收敛为 authHelper.RotateRefreshToken。契约上本 helper 必须：
-//   1) 成功路径：写出带 predictedVersion 的新 access + refresh、DB tokenVersion = claims+1、
-//      并触发 UD 缓存 Clean（无法直接断言 Clean 的 side effect，但通过"下一次 Load 能读到
-//      新 tokenVersion"可以间接覆盖）；
-//   2) claims.TokenVersion 与 DB 不一致 → 返回 ErrTokenVersionMismatch（让 HTTP 映射 401、
-//      gRPC 映射 Unauthenticated）；且 DB tokenVersion **不得**被污染；
-//   3) 用户不存在（RowsAffected=0）→ 同样 ErrTokenVersionMismatch，不得被映射成"Internal"。
+// 1) 成功路径：写出带 predictedVersion 的新 access + refresh、DB tokenVersion = claims+1、
+// 并触发 UD 缓存 Clean（无法直接断言 Clean 的 side effect，但通过"下一次 Load 能读到
+// 新 tokenVersion"可以间接覆盖）；
+// 2) claims.TokenVersion 与 DB 不一致 → 返回 ErrTokenVersionMismatch（让 HTTP 映射 401、
+// gRPC 映射 Unauthenticated）；且 DB tokenVersion **不得**被污染；
+// 3) 用户不存在（RowsAffected=0）→ 同样 ErrTokenVersionMismatch，不得被映射成"Internal"。
 // ---------------------------------------------------------------------------
 
 func insertRotateTestUser(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, username string, tokenVersion int64) int64 {
@@ -67,7 +67,7 @@ func mkRefreshClaims(userId int64, productCode string, tokenVersion int64, ttl t
 	}
 }
 
-// TC-1067: L-R11-5 —— helper 成功路径
+// TC-1067: helper 成功路径
 func TestRotateRefreshToken_HappyPath(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -84,7 +84,7 @@ func TestRotateRefreshToken_HappyPath(t *testing.T) {
 	}
 
 	tokens, err := RotateRefreshToken(ctx, svcCtx, claims, ud)
-	require.NoError(t, err, "L-R11-5：预期 tokenVersion=0 匹配，CAS 必须成功")
+	require.NoError(t, err, "预期 tokenVersion=0 匹配，CAS 必须成功")
 	assert.NotEmpty(t, tokens.AccessToken)
 	assert.NotEmpty(t, tokens.RefreshToken)
 	assert.NotEqual(t, tokens.AccessToken, tokens.RefreshToken,
@@ -93,18 +93,18 @@ func TestRotateRefreshToken_HappyPath(t *testing.T) {
 	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
 	require.NoError(t, err)
 	assert.Equal(t, int64(1), u.TokenVersion,
-		"L-R11-5：成功路径 DB.tokenVersion 必须严格 +1，不得多走也不得不走")
+		"成功路径 DB.tokenVersion 必须严格 +1，不得多走也不得不走")
 
 	// 新 refreshToken 解码后 tokenVersion 必是 1，即 predictedVersion。
 	var parsed RefreshClaims
 	_, err = ParseWithHMAC(tokens.RefreshToken, svcCtx.Config.Auth.RefreshSecret, &parsed)
 	require.NoError(t, err)
 	assert.Equal(t, int64(1), parsed.TokenVersion,
-		"L-R11-5：新 refreshToken 承诺的 tokenVersion 必须等于 predictedVersion，"+
+		"新 refreshToken 承诺的 tokenVersion 必须等于 predictedVersion，"+
 			"即 claims.TokenVersion + 1；若错位，接入方下一次刷新会立刻 401 失效")
 }
 
-// TC-1068: L-R11-5 —— claims.TokenVersion 与 DB 不一致 → CAS 失败 → ErrTokenVersionMismatch
+// TC-1068: claims.TokenVersion 与 DB 不一致 → CAS 失败 → ErrTokenVersionMismatch
 func TestRotateRefreshToken_StaleTokenVersion_Mismatch(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -125,17 +125,17 @@ func TestRotateRefreshToken_StaleTokenVersion_Mismatch(t *testing.T) {
 
 	_, err := RotateRefreshToken(ctx, svcCtx, claims, ud)
 	require.ErrorIs(t, err, userModel.ErrTokenVersionMismatch,
-		"L-R11-5：claims.TokenVersion=0 但 DB=1，CAS 的 WHERE tokenVersion=0 命中 0 行，"+
+		"claims.TokenVersion=0 但 DB=1，CAS 的 WHERE tokenVersion=0 命中 0 行，"+
 			"helper 必须返回 ErrTokenVersionMismatch（调用方据此回 401/Unauthenticated）")
 
 	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
 	require.NoError(t, err)
 	assert.Equal(t, int64(1), u.TokenVersion,
-		"L-R11-5：CAS 失败时 DB.tokenVersion 不得被任何副作用推进，否则 helper 就成了"+
+		"CAS 失败时 DB.tokenVersion 不得被任何副作用推进，否则 helper 就成了"+
 			"'只要过了 Parse 就一定 +1'的攻击 oracle")
 }
 
-// TC-1069: L-R11-5 —— 目标 userId 不存在（已被删）→ RowsAffected=0 → ErrTokenVersionMismatch
+// TC-1069: 目标 userId 不存在（已被删）→ RowsAffected=0 → ErrTokenVersionMismatch
 // 这条契约的意义：refreshToken 还没到过期但账号已被管理员删除的场景里，helper 不得把"找不到
 // 目标行"回溯到底层 sqlx 错误（例如 ErrNotFound）让上层误判成 500；必须统一回到可预测的
 // ErrTokenVersionMismatch 分支。
@@ -157,6 +157,6 @@ func TestRotateRefreshToken_DeletedUser_Mismatch(t *testing.T) {
 
 	_, err = RotateRefreshToken(ctx, svcCtx, claims, ud)
 	require.ErrorIs(t, err, userModel.ErrTokenVersionMismatch,
-		"L-R11-5：用户行已消失 → IncrementTokenVersionIfMatch RowsAffected=0，"+
+		"用户行已消失 → IncrementTokenVersionIfMatch RowsAffected=0，"+
 			"helper 必须折叠成 ErrTokenVersionMismatch；不得回底层 sqlx 错误让上游误映射为 500")
 }

internal/logic/dept/createDeptLogic.go

@@ -2,6 +2,7 @@ package dept
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"time"
 
@@ -64,11 +65,23 @@ func (l *CreateDeptLogic) CreateDept(req *types.CreateDeptReq) (resp *types.IdRe
 
 	err = l.svcCtx.SysDeptModel.TransactCtx(l.ctx, func(ctx context.Context, session sqlx.Session) error {
 		if req.ParentId > 0 {
-			var lockId int64
-			lockQ := fmt.Sprintf("SELECT `id` FROM %s WHERE `id` = ? FOR SHARE", l.svcCtx.SysDeptModel.TableName())
-			if err := session.QueryRowCtx(ctx, &lockId, lockQ, req.ParentId); err != nil {
-				return response.ErrNotFound("父部门已被删除")
+			// 审计 L-R12-2：事务内用 FindOneForShareTx 重取父部门快照——同时拿到 status 与
+			// path。此前只 SELECT `id` 无法感知"父部门在事务外 FindOne 之后被 UpdateDept 禁用"
+			// 这条交错：读到 id 仍存在就放行，结果子部门会以 Enabled 挂在已 Disabled 的父部门下，
+			// 让运营侧的"禁用整个子树"意图被静默绕过。改用事务内带 S 锁的完整行读取，同时把
+			// parentPath 覆盖为事务内视图——与事务外 FindOne 理论上一致（UpdateDept 不改 path），
+			// 但如果未来 UpdateDept 扩展支持 path 重写，这里已经内建 snapshot。
+			parent, err := l.svcCtx.SysDeptModel.FindOneForShareTx(ctx, session, req.ParentId)
+			if err != nil {
+				if errors.Is(err, sqlx.ErrNotFound) {
+					return response.ErrNotFound("父部门已被删除")
+				}
+				return err
 			}
+			if parent.Status != consts.StatusEnabled {
+				return response.ErrBadRequest("父部门已被禁用，无法创建子部门")
+			}
+			parentPath = parent.Path
 		}
 		result, err := l.svcCtx.SysDeptModel.InsertWithTx(ctx, session, &deptModel.SysDept{
 			ParentId:   req.ParentId,

internal/logic/dept/createDeptLogic_test.go

@@ -4,18 +4,19 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"perms-system-server/internal/consts"
 	deptModel "perms-system-server/internal/model/dept"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
 )
 
 func insertDeptRaw(ctx context.Context, svcCtx *svc.ServiceContext, parentId int64, name, path string) (int64, error) {
@@ -248,3 +249,187 @@ func TestCreateDept_NonSuperAdminRejected(t *testing.T) {
 }
 
 var _ = deptModel.ErrNotFound
+
+func insertDeptWithStatus(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, name, path string, status int64) int64 {
+	t.Helper()
+	now := time.Now().Unix()
+	res, err := svcCtx.SysDeptModel.Insert(ctx, &deptModel.SysDept{
+		ParentId: 0, Name: name + "_" + testutil.UniqueId(),
+		Path: path, Sort: 0, DeptType: "NORMAL", Remark: "",
+		Status: status, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	id, _ := res.LastInsertId()
+	return id
+}
+
+// TC-1084: 父部门已禁用（Status=2）时 CreateDept 必须 400 拒绝
+// 修复前：事务内只查 id，Status=2 的父同样放行 → 子部门以 Enabled 状态挂到禁用父上。
+func TestCreateDept_ParentDisabled_RejectedAt400(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	// 直接以 Status=Disabled 插入父部门，模拟"父部门先被禁用后 CreateDept 才到"的时序终态
+	parentId := insertDeptWithStatus(t, ctx, svcCtx, "r12_2_par_disabled", "/", consts.StatusDisabled)
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_dept`", parentId) })
+
+	resp, err := NewCreateDeptLogic(ctx, svcCtx).CreateDept(&types.CreateDeptReq{
+		ParentId: parentId,
+		Name:     "child_" + testutil.UniqueId(),
+	})
+	assert.Nil(t, resp,
+		"父部门已禁用时 CreateDept 不得返回子部门 id —— 返回非空即意味着事务已提交，"+
+			"DB 中出现挂在禁用父下的 Enabled 子部门")
+	require.Error(t, err)
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code(), "禁用父下创建子部门是业务约束冲突而非鉴权/未找到")
+	assert.Contains(t, ce.Error(), "父部门已被禁用",
+		"错误消息必须明确指向'父部门已被禁用'，方便运营定位；"+
+			"不允许降级为泛用的'部门不存在'")
+
+	// DB 侧兜底断言：子部门绝不应落库
+	var cnt int64
+	require.NoError(t, conn.QueryRowCtx(ctx, &cnt,
+		"SELECT COUNT(*) FROM `sys_dept` WHERE `parentId` = ?", parentId))
+	assert.Equal(t, int64(0), cnt,
+		"失败路径必须保证事务整体回滚，DB 中禁用父下不能有任何遗留子行")
+}
+
+// TC-1085: 父部门启用时 CreateDept 走锁视图读到 Path 并组装子 Path
+// 正向路径：父 Enabled → 子成功创建，且 parentPath 来自事务内 snapshot。
+func TestCreateDept_ParentEnabled_UsesTxSnapshotPath(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	parentId, err := insertDeptRaw(context.Background(), svcCtx,
+		0, "r12_2_par_ok_"+testutil.UniqueId(), "/")
+	require.NoError(t, err)
+	parent, err := svcCtx.SysDeptModel.FindOne(ctx, parentId)
+	require.NoError(t, err)
+
+	resp, err := NewCreateDeptLogic(ctx, svcCtx).CreateDept(&types.CreateDeptReq{
+		ParentId: parentId,
+		Name:     "r12_2_child_" + testutil.UniqueId(),
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	childId := resp.Id
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_dept`", childId, parentId) })
+
+	child, err := svcCtx.SysDeptModel.FindOne(ctx, childId)
+	require.NoError(t, err)
+	assert.Equal(t, fmt.Sprintf("%s%d/", parent.Path, childId), child.Path,
+		"子 Path 应当在 parent.Path（事务内 snapshot）基础上拼接自己的 id，"+
+			"证明 parentPath 走的是修复后事务内的视图而非空字符串")
+	assert.Equal(t, int64(consts.StatusEnabled), child.Status,
+		"启用父下的新子部门默认 Enabled")
+}
+
+// TC-1086: CreateDept × UpdateDept(Status=Disabled) 并发：无"挂在已禁用父下的 Enabled 子"
+// 并发交错：
+//
+//	A) CreateDept 先拿到 sys_dept[parent] 的 S 锁 → UpdateDept 的 X 锁阻塞；
+//	   CreateDept 插入子、提交；此时父仍 Enabled，合法。
+//	   UpdateDept 随后拿到 X 锁 → 将父改 Disabled 提交；此时子已在，但那一瞬子是 Enabled
+//	   (这是 UpdateDept 的契约：仅改父自己，不会级联冻结子树。本 TC 不把这个当 bug，因为
+//	   这就是修复后认可的语义——"禁用父后由运营决定是否禁用子"，而本轮修复要消灭的只是
+//	   "禁用发生在前、子部门 Create 在后仍然挂上"的时序 bug。)
+//	B) UpdateDept 先提交，父变 Disabled → CreateDept 的 FindOneForShareTx 在 S 锁视图里
+//	   看到 Status=Disabled → 400，子部门不落库。
+//
+// 断言：任一轮成功的 CreateDept 必须伴随 "create 时刻父仍 Enabled"；一切失败的 CreateDept
+// 必须是 400 "父部门已被禁用，无法创建子部门"，不得出现 500 /静默吞错 /部分落库。
+func TestCreateDept_Vs_DisableParent_NoSilentChildUnderDisabled(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	const rounds = 6
+	for round := 0; round < rounds; round++ {
+		parentId, err := insertDeptRaw(context.Background(), svcCtx,
+			0, "r12_2_race_par_"+testutil.UniqueId(), "/")
+		require.NoError(t, err)
+
+		var (
+			wg        sync.WaitGroup
+			childId   atomic.Int64
+			createErr atomic.Value
+			disableOK atomic.Bool
+		)
+		start := make(chan struct{})
+		wg.Add(2)
+
+		go func() {
+			defer wg.Done()
+			<-start
+			resp, err := NewCreateDeptLogic(ctx, svcCtx).CreateDept(&types.CreateDeptReq{
+				ParentId: parentId,
+				Name:     "r12_2_race_child_" + testutil.UniqueId(),
+			})
+			if err != nil {
+				createErr.Store(err)
+				return
+			}
+			if resp != nil {
+				childId.Store(resp.Id)
+			}
+		}()
+		go func() {
+			defer wg.Done()
+			<-start
+			// 直接用原生 UPDATE 模拟并发的"禁用父部门"操作，避免引入 UpdateDept Logic 的
+			// 上游鉴权/PathRewrite 噪声；真实 UpdateDept 禁用路径最终落到 DB 也是同一句 UPDATE。
+			_, err := conn.ExecCtx(context.Background(),
+				"UPDATE `sys_dept` SET `status`=?, `updateTime`=? WHERE `id`=?",
+				consts.StatusDisabled, time.Now().Unix(), parentId)
+			if err == nil {
+				disableOK.Store(true)
+			}
+		}()
+
+		close(start)
+		wg.Wait()
+
+		require.True(t, disableOK.Load(),
+			"前置：禁用父的裸 UPDATE 必须成功，否则本轮测试不等价于并发语义")
+
+		var parentStatus int64
+		require.NoError(t, conn.QueryRowCtx(context.Background(), &parentStatus,
+			"SELECT `status` FROM `sys_dept` WHERE `id` = ?", parentId))
+		require.Equal(t, int64(consts.StatusDisabled), parentStatus,
+			"前置：本轮终态父必为 Disabled（直读 DB 绕过 CachedConn 可能的过期缓存）")
+
+		if cid := childId.Load(); cid > 0 {
+			// CreateDept 成功 → 说明在 FindOneForShareTx 那一刻，父仍是 Enabled。
+			// 本 TC 不限制此路径（这是合法的时序：先创建，后禁用），但子部门一旦落库就必须是 Enabled，
+			// 且 Path 来自事务内 snapshot（写入后才被禁用父"覆盖"是业务意图）。
+			testutil.CleanTable(ctx, conn, "`sys_dept`", cid)
+		} else {
+			// CreateDept 失败路径：必须是 400 "父部门已被禁用"。非此即代表修复没到位，
+			// 或把 write skew 暴露成了 500。
+			if raw := createErr.Load(); raw != nil {
+				var ce *response.CodeError
+				require.True(t, errors.As(raw.(error), &ce),
+					"CreateDept 在并发禁用场景下只能抛 response.CodeError，不得是裸 err")
+				assert.Equal(t, 400, ce.Code(),
+					"并发禁用父时 CreateDept 必须 400（父已禁用），不得泄漏为 500/404")
+				assert.Contains(t, ce.Error(), "父部门已被禁用",
+					"错误消息必须是'父部门已被禁用'，便于前端精确提示；"+
+						"不是'父部门不存在'（DeleteDept 那条路径）")
+			}
+			// DB 侧兜底：子部门绝不应落库
+			var cnt int64
+			require.NoError(t, conn.QueryRowCtx(context.Background(), &cnt,
+				"SELECT COUNT(*) FROM `sys_dept` WHERE `parentId` = ?", parentId))
+			assert.Equal(t, int64(0), cnt,
+				"失败轮次 DB 不得残留子行；若 > 0 证明事务只做了 parent S 锁校验却 "+
+					"没把 InsertWithTx 所在事务整体回滚")
+		}
+
+		testutil.CleanTable(ctx, conn, "`sys_dept`", parentId)
+	}
+}

internal/logic/dept/deleteDeptLogic_test.go

@@ -35,7 +35,7 @@ func TestDeleteDept_NoChildren(t *testing.T) {
 	assert.Error(t, err)
 }
 
-// TC-0108: 不存在的部门 (audit M-11 修复后：放入事务 + SELECT ... FOR UPDATE，不存在时返回 404)
+// TC-0108: 不存在的部门 (audit  修复后：放入事务 + SELECT ... FOR UPDATE，不存在时返回 404)
 func TestDeleteDept_NonExistentDept(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())

internal/logic/dept/deptTreeAccessControl_audit_test.go → internal/logic/dept/deptTreeLogic_test.go

@@ -16,10 +16,10 @@ import (
 )
 
 // ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-2 修复回归 —— 非超管/非 ADMIN 调 /api/dept/tree 时必须按
+// 覆盖目标：非超管/非 ADMIN 调 /api/dept/tree 时必须按
 // caller.DeptPath 前缀过滤部门，只返回以其为根的子树。避免：
-//   * MEMBER 级账号枚举全公司组织结构；
-//   * 定位 DEV 部门再针对性申请权限。
+// * MEMBER 级账号枚举全公司组织结构；
+// * 定位 DEV 部门再针对性申请权限。
 //
 // ADMIN / SuperAdmin 保留完整树（运营使用场景）。
 //
@@ -57,10 +57,10 @@ func TestDeptTree_Member_PrunedToSubtree(t *testing.T) {
 	require.NoError(t, err)
 
 	// 剪枝后只剩 2 个节点；根仍应只有一个（id=1，grandchild 挂在其下）。
-	require.Len(t, tree, 1, "M-2：剪枝后根只剩 1 个（caller 所在部门）")
-	assert.Equal(t, int64(1), tree[0].Id, "M-2：局部根必须是 /100/1/，不得把 /100/ 也暴露")
+	require.Len(t, tree, 1, "剪枝后根只剩 1 个（caller 所在部门）")
+	assert.Equal(t, int64(1), tree[0].Id, "局部根必须是 /100/1/，不得把 /100/ 也暴露")
 	assert.Equal(t, "/100/1/", tree[0].Path)
-	require.Len(t, tree[0].Children, 1, "M-2：grandchild 必须挂在局部根下")
+	require.Len(t, tree[0].Children, 1, "grandchild 必须挂在局部根下")
 	assert.Equal(t, int64(5), tree[0].Children[0].Id)
 }
 
@@ -82,7 +82,7 @@ func TestDeptTree_OrphanMember_ReturnsEmpty(t *testing.T) {
 	}
 	tree, err := NewDeptTreeLogic(ctxWith(caller), svcCtx).DeptTree()
 	require.NoError(t, err)
-	assert.Len(t, tree, 0, "M-2：DeptPath 为空必须返回空树，不能泄露组织结构")
+	assert.Len(t, tree, 0, "DeptPath 为空必须返回空树，不能泄露组织结构")
 }
 
 // TC-0857: 产品 ADMIN —— 视为 fullAccess，返回完整树（两个根）。
@@ -103,7 +103,7 @@ func TestDeptTree_Admin_FullTree(t *testing.T) {
 	require.NoError(t, err)
 
 	// 完整树：根有 2 个（id=100, id=200）。
-	require.Len(t, tree, 2, "M-2：ADMIN 应看到完整部门树，包括兄弟分支")
+	require.Len(t, tree, 2, "ADMIN 应看到完整部门树，包括兄弟分支")
 	var rootIds []int64
 	for _, r := range tree {
 		rootIds = append(rootIds, r.Id)

internal/logic/dept/updateDeptCleanBatch_audit_test.go

@@ -1,121 +0,0 @@
-package dept
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	deptModel "perms-system-server/internal/model/dept"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-1 修复回归 —— UpdateDept 在 deptType / status 真正变更时:
-//   * 必须调用 SysUserModel.FindIdsByDeptId 获取受影响 userIds；
-//   * FindIdsByDeptId 返回 err 时仅 Errorf 记录，handler 返回 nil（degraded 成功）；
-//   * FindIdsByDeptId 成功时只调用 "1 次"，避免在 handler 里串行按用户 Clean 造成秒级延迟。
-// ---------------------------------------------------------------------------
-
-func superAdminCtx() context.Context {
-	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 1, Username: "su",
-		IsSuperAdmin: true, MemberType: consts.MemberTypeSuperAdmin,
-		Status: consts.StatusEnabled,
-	})
-}
-
-// TC-0848: deptType 变更 → FindIdsByDeptId 恰好调用 1 次，返回 [100, 101]；handler 返回 nil。
-func TestUpdateDept_DeptTypeChanged_InvokesFindIdsOnce(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	userMock := mocks.NewMockSysUserModel(ctrl)
-
-	// 老部门是 NORMAL，请求改成 DEV → deptTypeChanged=true 才能触发 FindIdsByDeptId。
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(77)).
-		Return(&deptModel.SysDept{
-			Id: 77, Name: "n", DeptType: consts.DeptTypeNormal,
-			Status: consts.StatusEnabled, UpdateTime: 500,
-		}, nil)
-	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(500)).Return(nil)
-
-	// 关键断言：恰好调用 1 次；返回的切片会被继续塞进 CleanByUserIds（loader 内部走 Redis）。
-	userMock.EXPECT().FindIdsByDeptId(gomock.Any(), int64(77)).
-		Return([]int64{100, 101}, nil).Times(1)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Dept: deptMock, User: userMock,
-	})
-
-	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
-		Id: 77, Name: "n", Sort: 0, Remark: "", DeptType: consts.DeptTypeDev,
-	})
-	require.NoError(t, err,
-		"M-1：正常场景 UpdateDept 必须返回 nil，且仅调用一次 FindIdsByDeptId")
-}
-
-// TC-0849: FindIdsByDeptId 返回 err —— handler 仍返回 nil（degraded 成功），旧缓存由 TTL 过期兜底。
-func TestUpdateDept_FindIdsByDeptIdError_DegradedSuccess(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	userMock := mocks.NewMockSysUserModel(ctrl)
-
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(88)).
-		Return(&deptModel.SysDept{
-			Id: 88, Name: "n", DeptType: consts.DeptTypeNormal,
-			Status: consts.StatusEnabled, UpdateTime: 1000,
-		}, nil)
-	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(1000)).Return(nil)
-
-	userMock.EXPECT().FindIdsByDeptId(gomock.Any(), int64(88)).
-		Return(nil, errors.New("transient DB error"))
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Dept: deptMock, User: userMock,
-	})
-
-	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
-		Id: 88, Name: "n", DeptType: consts.DeptTypeDev,
-	})
-	assert.NoError(t, err,
-		"M-1：FindIdsByDeptId 失败不得映射 500；TTL 过期兜底，客户端不应重试整次 UpdateDept")
-}
-
-// 补充：deptType / status 都没变时，不应调 FindIdsByDeptId（避免无效缓存失效风暴）。
-func TestUpdateDept_NoEffectiveChange_SkipsFindIds(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	deptMock := mocks.NewMockSysDeptModel(ctrl)
-	userMock := mocks.NewMockSysUserModel(ctrl)
-
-	// 老部门 DEV，请求也是 DEV；status 未传 → 没有变更。
-	deptMock.EXPECT().FindOne(gomock.Any(), int64(99)).
-		Return(&deptModel.SysDept{
-			Id: 99, Name: "x", DeptType: consts.DeptTypeDev,
-			Status: consts.StatusEnabled, UpdateTime: 200,
-		}, nil)
-	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(200)).Return(nil)
-
-	// 关键：没有任何 FindIdsByDeptId EXPECT 即等价 Times(0)。
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Dept: deptMock, User: userMock,
-	})
-
-	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
-		Id: 99, Name: "x", DeptType: consts.DeptTypeDev, Sort: 1,
-	})
-	require.NoError(t, err, "M-1：无变更时 UpdateDept 只做元字段更新，不得触发缓存清理风暴")
-}

internal/logic/dept/updateDeptLogic_mock_test.go

@@ -12,7 +12,7 @@ import (
 	"go.uber.org/mock/gomock"
 )
 
-// TC-0105: UpdateDept 只清理自身部门用户缓存，不再级联到子部门 (audit M-5 修复验证)
+// TC-0105: UpdateDept 只清理自身部门用户缓存，不再级联到子部门 (audit  修复验证)
 func TestUpdateDept_Mock_CascadeCacheClean(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
@@ -54,7 +54,7 @@ func TestUpdateDept_Mock_CascadeCacheClean(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-// TC-0714: UpdateDept 当 deptType 与 status 都未变化时，不触发任何缓存清理 (audit M-5)
+// TC-0714: UpdateDept 当 deptType 与 status 都未变化时，不触发任何缓存清理 (audit )
 func TestUpdateDept_Mock_NoCacheCleanWhenUnchanged(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
@@ -93,7 +93,7 @@ func TestUpdateDept_Mock_NoCacheCleanWhenUnchanged(t *testing.T) {
 	assert.NoError(t, err)
 }
 
-// TC-0715: UpdateDept 乐观锁冲突时返回 409 ErrConflict (audit M-5 乐观锁补充)
+// TC-0715: UpdateDept 乐观锁冲突时返回 409 ErrConflict (audit  乐观锁补充)
 func TestUpdateDept_Mock_OptLockConflict(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()

internal/logic/dept/updateDeptLogic_test.go

@@ -1,20 +1,24 @@
 package dept
 
 import (
+	"context"
 	"errors"
-	"testing"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
+	deptModel "perms-system-server/internal/model/dept"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
 )
 
-// TC-0101: 正常更新
 func TestUpdateDept_Normal(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -154,3 +158,99 @@ func TestUpdateDept_NonSuperAdminRejected(t *testing.T) {
 	require.True(t, errors.As(err, &ce))
 	assert.Equal(t, 403, ce.Code())
 }
+
+func superAdminCtx() context.Context {
+	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 1, Username: "su",
+		IsSuperAdmin: true, MemberType: consts.MemberTypeSuperAdmin,
+		Status: consts.StatusEnabled,
+	})
+}
+
+// TC-0848: deptType 变更 → FindIdsByDeptId 恰好调用 1 次，返回 [100, 101]；handler 返回 nil。
+func TestUpdateDept_DeptTypeChanged_InvokesFindIdsOnce(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	userMock := mocks.NewMockSysUserModel(ctrl)
+
+	// 老部门是 NORMAL，请求改成 DEV → deptTypeChanged=true 才能触发 FindIdsByDeptId。
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(77)).
+		Return(&deptModel.SysDept{
+			Id: 77, Name: "n", DeptType: consts.DeptTypeNormal,
+			Status: consts.StatusEnabled, UpdateTime: 500,
+		}, nil)
+	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(500)).Return(nil)
+
+	// 关键断言：恰好调用 1 次；返回的切片会被继续塞进 CleanByUserIds（loader 内部走 Redis）。
+	userMock.EXPECT().FindIdsByDeptId(gomock.Any(), int64(77)).
+		Return([]int64{100, 101}, nil).Times(1)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Dept: deptMock, User: userMock,
+	})
+
+	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
+		Id: 77, Name: "n", Sort: 0, Remark: "", DeptType: consts.DeptTypeDev,
+	})
+	require.NoError(t, err,
+		"正常场景 UpdateDept 必须返回 nil，且仅调用一次 FindIdsByDeptId")
+}
+
+// TC-0849: FindIdsByDeptId 返回 err —— handler 仍返回 nil（degraded 成功），旧缓存由 TTL 过期兜底。
+func TestUpdateDept_FindIdsByDeptIdError_DegradedSuccess(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	userMock := mocks.NewMockSysUserModel(ctrl)
+
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(88)).
+		Return(&deptModel.SysDept{
+			Id: 88, Name: "n", DeptType: consts.DeptTypeNormal,
+			Status: consts.StatusEnabled, UpdateTime: 1000,
+		}, nil)
+	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(1000)).Return(nil)
+
+	userMock.EXPECT().FindIdsByDeptId(gomock.Any(), int64(88)).
+		Return(nil, errors.New("transient DB error"))
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Dept: deptMock, User: userMock,
+	})
+
+	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
+		Id: 88, Name: "n", DeptType: consts.DeptTypeDev,
+	})
+	assert.NoError(t, err,
+		"FindIdsByDeptId 失败不得映射 500；TTL 过期兜底，客户端不应重试整次 UpdateDept")
+}
+
+// 补充：deptType / status 都没变时，不应调 FindIdsByDeptId（避免无效缓存失效风暴）。
+func TestUpdateDept_NoEffectiveChange_SkipsFindIds(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	deptMock := mocks.NewMockSysDeptModel(ctrl)
+	userMock := mocks.NewMockSysUserModel(ctrl)
+
+	// 老部门 DEV，请求也是 DEV；status 未传 → 没有变更。
+	deptMock.EXPECT().FindOne(gomock.Any(), int64(99)).
+		Return(&deptModel.SysDept{
+			Id: 99, Name: "x", DeptType: consts.DeptTypeDev,
+			Status: consts.StatusEnabled, UpdateTime: 200,
+		}, nil)
+	deptMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(200)).Return(nil)
+
+	// 关键：没有任何 FindIdsByDeptId EXPECT 即等价 Times(0)。
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Dept: deptMock, User: userMock,
+	})
+
+	err := NewUpdateDeptLogic(superAdminCtx(), svcCtx).UpdateDept(&types.UpdateDeptReq{
+		Id: 99, Name: "x", DeptType: consts.DeptTypeDev, Sort: 1,
+	})
+	require.NoError(t, err, "无变更时 UpdateDept 只做元字段更新，不得触发缓存清理风暴")
+}

internal/logic/member/addMemberLogic_test.go

@@ -2,6 +2,7 @@ package member
 
 import (
 	"database/sql"
+	"errors"
 	"sync"
 	"testing"
 	"time"
@@ -270,3 +271,87 @@ func TestAddMember_ConcurrentSameUserProduct(t *testing.T) {
 	assert.Equal(t, 1, successCount, "exactly one goroutine should succeed")
 	assert.Equal(t, 1, failCount, "exactly one goroutine should fail (409 or DB duplicate)")
 }
+
+// TC-0950:  修复 —— AddMember 必须显式拒绝把 SuperAdmin 作为普通产品成员加入。
+// 背景：loadMembership 会把 SuperAdmin 的 MemberType 固定为 SuperAdmin 让其实际权限不受影响，
+// 但若 sys_product_member 里仍落一条记录，会污染日志 / 权限推理工具，且给产品 ADMIN
+// "纳管了 superadmin" 的错觉。必须在 AddMember 入口就 403。
+func TestAddMember_SuperAdminTargetRejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	// target 是 SuperAdmin（IsSuperAdmin=1）
+	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: "h3_su_" + code, Password: testutil.HashPassword("pw"),
+		Avatar: sql.NullString{}, IsSuperAdmin: 1, MustChangePassword: 2,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	uId, _ := uRes.LastInsertId()
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTable(ctx, conn, "`sys_user`", uId)
+		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
+	})
+
+	_, err = NewAddMemberLogic(ctx, svcCtx).AddMember(&types.AddMemberReq{
+		ProductCode: code, UserId: uId, MemberType: "MEMBER",
+	})
+	require.Error(t, err, "禁止把 SuperAdmin 加入具体产品为普通成员")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "超级管理员")
+
+	// DB 侧必须没有落下 SuperAdmin 的成员记录（regression：确保 AddMember 未短路在插入之后）
+	_, findErr := svcCtx.SysProductMemberModel.FindOneByProductCodeUserId(ctx, code, uId)
+	require.Error(t, findErr, "SuperAdmin 不得被落入 sys_product_member")
+}
+
+// TC-0729:  修复：禁用产品不允许添加成员
+func TestAddMember_DisabledProductRejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 2, CreateTime: now, UpdateTime: now, // 禁用
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: code, Password: testutil.HashPassword("pw"),
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	uId, _ := uRes.LastInsertId()
+	t.Cleanup(func() {
+		testutil.CleanTable(ctx, conn, "`sys_user`", uId)
+		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
+	})
+
+	_, err = NewAddMemberLogic(ctx, svcCtx).AddMember(&types.AddMemberReq{
+		ProductCode: code, UserId: uId, MemberType: "MEMBER",
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+	assert.Contains(t, ce.Error(), "禁用")
+}

internal/logic/member/auditFixes_test.go

@@ -1,386 +0,0 @@
-package member
-
-import (
-	"database/sql"
-	"errors"
-	"testing"
-	"time"
-
-	productModel "perms-system-server/internal/model/product"
-	memberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// strPtr / int64Ptr 是 L-R11-1 后 UpdateMemberReq.MemberType / Status 指针化的 helper。
-// 若 nil 表示不改该字段，两者都 nil 会被 Logic 400。
-func strPtr(s string) *string { return &s }
-
-type seededProduct struct {
-	code  string
-	pId   int64
-	uId   int64
-	mId   int64
-	admin int64 // 成员 id 当该成员为 ADMIN
-}
-
-// seedEnabledProductWithMember 创建 enabled product + user + product_member(memberType 指定)
-func seedEnabledProductWithMember(t *testing.T, svcCtx *svc.ServiceContext, memberType string) seededProduct {
-	t.Helper()
-	ctx := ctxhelper.SuperAdminCtx()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: code, Password: testutil.HashPassword("pw"), Nickname: "n",
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	uId, _ := uRes.LastInsertId()
-
-	mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-		ProductCode: code, UserId: uId, MemberType: memberType,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	mId, _ := mRes.LastInsertId()
-
-	return seededProduct{code: code, pId: pId, uId: uId, mId: mId, admin: mId}
-}
-
-func cleanupSeeded(t *testing.T, svcCtx *svc.ServiceContext, sp seededProduct) {
-	t.Helper()
-	ctx := ctxhelper.SuperAdminCtx()
-	conn := testutil.GetTestSqlConn()
-	testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", sp.code)
-	testutil.CleanTable(ctx, conn, "`sys_user`", sp.uId)
-	testutil.CleanTable(ctx, conn, "`sys_product`", sp.pId)
-}
-
-// TC-0723: H-4 修复：不能移除产品最后一个 ADMIN
-func TestRemoveMember_LastAdminRejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-
-	sp := seededProduct{code: testutil.UniqueId()}
-	now := time.Now().Unix()
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: sp.code, Name: "p_" + sp.code, AppKey: sp.code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	sp.pId, _ = pRes.LastInsertId()
-
-	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: sp.code, Password: testutil.HashPassword("pw"),
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	sp.uId, _ = uRes.LastInsertId()
-
-	mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-		ProductCode: sp.code, UserId: sp.uId, MemberType: "ADMIN",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	sp.mId, _ = mRes.LastInsertId()
-
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	logic := NewRemoveMemberLogic(ctx, svcCtx)
-	err = logic.RemoveMember(&types.RemoveMemberReq{Id: sp.mId})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-	assert.Contains(t, ce.Error(), "最后一个管理员")
-
-	m, ferr := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, ferr, "ADMIN 必须仍然存在")
-	assert.Equal(t, "ADMIN", m.MemberType)
-}
-
-// TC-0724: 存在 >=2 个 ADMIN 时可以移除其中一个
-func TestRemoveMember_AdminNotLast_Allowed(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	var uIds, mIds []int64
-	for i := 0; i < 2; i++ {
-		uid := testutil.UniqueId() + "_a"
-		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-			Username: uid, Password: testutil.HashPassword("pw"),
-			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-			Status: 1, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		uId, _ := uRes.LastInsertId()
-		uIds = append(uIds, uId)
-
-		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-			ProductCode: code, UserId: uId, MemberType: "ADMIN",
-			Status: 1, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		mId, _ := mRes.LastInsertId()
-		mIds = append(mIds, mId)
-	}
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
-		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
-	})
-
-	err = NewRemoveMemberLogic(ctx, svcCtx).RemoveMember(&types.RemoveMemberReq{Id: mIds[0]})
-	require.NoError(t, err)
-
-	_, err = svcCtx.SysProductMemberModel.FindOne(ctx, mIds[0])
-	require.Error(t, err)
-	_, err = svcCtx.SysProductMemberModel.FindOne(ctx, mIds[1])
-	require.NoError(t, err, "另一个 ADMIN 必须保留")
-}
-
-// TC-0725: H-4 修复：不能将最后一个 ADMIN 降级为 MEMBER
-func TestUpdateMember_DemoteLastAdminRejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, "ADMIN")
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-		Id: sp.mId, MemberType: strPtr("MEMBER"),
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-	assert.Contains(t, ce.Error(), "最后一个管理员")
-
-	m, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, "ADMIN", m.MemberType, "MemberType 不应被改动")
-}
-
-// TC-0726: H-4 修复：有多个 ADMIN 时可以降级其中一个
-func TestUpdateMember_DemoteAdmin_WhenMultiple_Allowed(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	var uIds, mIds []int64
-	for i := 0; i < 2; i++ {
-		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-			Username: testutil.UniqueId(), Password: testutil.HashPassword("pw"),
-			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-			Status: 1, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		uId, _ := uRes.LastInsertId()
-		uIds = append(uIds, uId)
-
-		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-			ProductCode: code, UserId: uId, MemberType: "ADMIN",
-			Status: 1, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		mId, _ := mRes.LastInsertId()
-		mIds = append(mIds, mId)
-	}
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
-		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
-	})
-
-	err = NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-		Id: mIds[0], MemberType: strPtr("MEMBER"),
-	})
-	require.NoError(t, err)
-
-	m, err := svcCtx.SysProductMemberModel.FindOne(ctx, mIds[0])
-	require.NoError(t, err)
-	assert.Equal(t, "MEMBER", m.MemberType)
-}
-
-// TC-0727: H-4 修复：禁用状态的 ADMIN 不计入 active admin 计数，导致剩余 0 个启用 ADMIN 时仍拒绝降级
-// 说明：CountActiveAdmins 只统计 status=1 的 ADMIN；即便 DB 里有 2 个 ADMIN，但仅 1 个启用，
-// 降级这个唯一启用的 ADMIN 仍应被拒绝。
-func TestUpdateMember_DemoteLastActiveAdmin_Rejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	var uIds, mIds []int64
-	statuses := []int64{1, 2} // 一个启用，一个禁用
-	for _, st := range statuses {
-		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-			Username: testutil.UniqueId(), Password: testutil.HashPassword("pw"),
-			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-			Status: 1, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		uId, _ := uRes.LastInsertId()
-		uIds = append(uIds, uId)
-		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-			ProductCode: code, UserId: uId, MemberType: "ADMIN",
-			Status: st, CreateTime: now, UpdateTime: now,
-		})
-		require.NoError(t, err)
-		mId, _ := mRes.LastInsertId()
-		mIds = append(mIds, mId)
-	}
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
-		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
-	})
-
-	// 启用中的那个 ADMIN (mIds[0]) 降级应被拒绝
-	err = NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-		Id: mIds[0], MemberType: strPtr("DEVELOPER"),
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-	assert.Contains(t, ce.Error(), "最后一个管理员")
-}
-
-// TC-0728: 移除非 ADMIN 成员不受 last-admin 保护
-func TestRemoveMember_NonAdmin_Unaffected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, "MEMBER")
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	err := NewRemoveMemberLogic(ctx, svcCtx).RemoveMember(&types.RemoveMemberReq{Id: sp.mId})
-	require.NoError(t, err)
-}
-
-// TC-0950: H-3 修复 —— AddMember 必须显式拒绝把 SuperAdmin 作为普通产品成员加入。
-// 背景：loadMembership 会把 SuperAdmin 的 MemberType 固定为 SuperAdmin 让其实际权限不受影响，
-// 但若 sys_product_member 里仍落一条记录，会污染审计日志 / 权限推理工具，且给产品 ADMIN
-// "纳管了 superadmin" 的错觉。必须在 AddMember 入口就 403。
-func TestAddMember_SuperAdminTargetRejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	// target 是 SuperAdmin（IsSuperAdmin=1）
-	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: "h3_su_" + code, Password: testutil.HashPassword("pw"),
-		Avatar: sql.NullString{}, IsSuperAdmin: 1, MustChangePassword: 2,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	uId, _ := uRes.LastInsertId()
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTable(ctx, conn, "`sys_user`", uId)
-		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
-	})
-
-	_, err = NewAddMemberLogic(ctx, svcCtx).AddMember(&types.AddMemberReq{
-		ProductCode: code, UserId: uId, MemberType: "MEMBER",
-	})
-	require.Error(t, err, "H-3：禁止把 SuperAdmin 加入具体产品为普通成员")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "超级管理员")
-
-	// DB 侧必须没有落下 SuperAdmin 的成员记录（regression：确保 AddMember 未短路在插入之后）
-	_, findErr := svcCtx.SysProductMemberModel.FindOneByProductCodeUserId(ctx, code, uId)
-	require.Error(t, findErr, "SuperAdmin 不得被落入 sys_product_member")
-}
-
-// TC-0729: L-5 修复：禁用产品不允许添加成员
-func TestAddMember_DisabledProductRejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	code := testutil.UniqueId()
-
-	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: 2, CreateTime: now, UpdateTime: now, // 禁用
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
-		Username: code, Password: testutil.HashPassword("pw"),
-		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	uId, _ := uRes.LastInsertId()
-	t.Cleanup(func() {
-		testutil.CleanTable(ctx, conn, "`sys_user`", uId)
-		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
-	})
-
-	_, err = NewAddMemberLogic(ctx, svcCtx).AddMember(&types.AddMemberReq{
-		ProductCode: code, UserId: uId, MemberType: "MEMBER",
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-	assert.Contains(t, ce.Error(), "禁用")
-}

internal/logic/member/removeMemberLogic_mock_test.go

@@ -34,7 +34,7 @@ func TestRemoveMember_Mock_UserPermDeleteFail(t *testing.T) {
 		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
 			return fn(ctx, nil)
 		})
-	// M-A 修复：事务内先 FindOneForUpdateTx 锁行
+	// -A 修复：事务内先 FindOneForUpdateTx 锁行
 	mockPM.EXPECT().FindOneForUpdateTx(gomock.Any(), nil, int64(1)).
 		Return(&productmember.SysProductMember{
 			Id:          1,

internal/logic/member/removeMemberLogic_test.go

@@ -2,6 +2,7 @@ package member
 
 import (
 	"database/sql"
+	"errors"
 	"testing"
 	"time"
 
@@ -217,3 +218,161 @@ func TestRemoveMember_CrossProductIsolation(t *testing.T) {
 	assert.Contains(t, roleIds, r2Id)
 	assert.NotContains(t, roleIds, r1Id)
 }
+
+// strPtr / int64Ptr 是  后 UpdateMemberReq.MemberType / Status 指针化的 helper。
+// 若 nil 表示不改该字段，两者都 nil 会被 Logic 400。
+func strPtr(s string) *string { return &s }
+
+type seededProduct struct {
+	code  string
+	pId   int64
+	uId   int64
+	mId   int64
+	admin int64 // 成员 id 当该成员为 ADMIN
+}
+
+// seedEnabledProductWithMember 创建 enabled product + user + product_member(memberType 指定)
+func seedEnabledProductWithMember(t *testing.T, svcCtx *svc.ServiceContext, memberType string) seededProduct {
+	t.Helper()
+	ctx := ctxhelper.SuperAdminCtx()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: code, Password: testutil.HashPassword("pw"), Nickname: "n",
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	uId, _ := uRes.LastInsertId()
+
+	mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+		ProductCode: code, UserId: uId, MemberType: memberType,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	mId, _ := mRes.LastInsertId()
+
+	return seededProduct{code: code, pId: pId, uId: uId, mId: mId, admin: mId}
+}
+
+func cleanupSeeded(t *testing.T, svcCtx *svc.ServiceContext, sp seededProduct) {
+	t.Helper()
+	ctx := ctxhelper.SuperAdminCtx()
+	conn := testutil.GetTestSqlConn()
+	testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", sp.code)
+	testutil.CleanTable(ctx, conn, "`sys_user`", sp.uId)
+	testutil.CleanTable(ctx, conn, "`sys_product`", sp.pId)
+}
+
+// TC-0723:  修复：不能移除产品最后一个 ADMIN
+func TestRemoveMember_LastAdminRejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+
+	sp := seededProduct{code: testutil.UniqueId()}
+	now := time.Now().Unix()
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: sp.code, Name: "p_" + sp.code, AppKey: sp.code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	sp.pId, _ = pRes.LastInsertId()
+
+	uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+		Username: sp.code, Password: testutil.HashPassword("pw"),
+		Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	sp.uId, _ = uRes.LastInsertId()
+
+	mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+		ProductCode: sp.code, UserId: sp.uId, MemberType: "ADMIN",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	sp.mId, _ = mRes.LastInsertId()
+
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	logic := NewRemoveMemberLogic(ctx, svcCtx)
+	err = logic.RemoveMember(&types.RemoveMemberReq{Id: sp.mId})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+	assert.Contains(t, ce.Error(), "最后一个管理员")
+
+	m, ferr := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, ferr, "ADMIN 必须仍然存在")
+	assert.Equal(t, "ADMIN", m.MemberType)
+}
+
+// TC-0724: 存在 >=2 个 ADMIN 时可以移除其中一个
+func TestRemoveMember_AdminNotLast_Allowed(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	var uIds, mIds []int64
+	for i := 0; i < 2; i++ {
+		uid := testutil.UniqueId() + "_a"
+		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+			Username: uid, Password: testutil.HashPassword("pw"),
+			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+			Status: 1, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		uId, _ := uRes.LastInsertId()
+		uIds = append(uIds, uId)
+
+		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+			ProductCode: code, UserId: uId, MemberType: "ADMIN",
+			Status: 1, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		mId, _ := mRes.LastInsertId()
+		mIds = append(mIds, mId)
+	}
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
+		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
+	})
+
+	err = NewRemoveMemberLogic(ctx, svcCtx).RemoveMember(&types.RemoveMemberReq{Id: mIds[0]})
+	require.NoError(t, err)
+
+	_, err = svcCtx.SysProductMemberModel.FindOne(ctx, mIds[0])
+	require.Error(t, err)
+	_, err = svcCtx.SysProductMemberModel.FindOne(ctx, mIds[1])
+	require.NoError(t, err, "另一个 ADMIN 必须保留")
+}
+
+// TC-0728: 移除非 ADMIN 成员不受 last-admin 保护
+func TestRemoveMember_NonAdmin_Unaffected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, "MEMBER")
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	err := NewRemoveMemberLogic(ctx, svcCtx).RemoveMember(&types.RemoveMemberReq{Id: sp.mId})
+	require.NoError(t, err)
+}

internal/logic/member/updateMemberLogic_test.go

@@ -2,9 +2,10 @@ package member
 
 import (
 	"database/sql"
-	"testing"
-	"time"
-
+	"errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"perms-system-server/internal/consts"
 	productModel "perms-system-server/internal/model/product"
 	memberModel "perms-system-server/internal/model/productmember"
 	userModel "perms-system-server/internal/model/user"
@@ -13,12 +14,10 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
-// TC-0219: 正常更新
 func TestUpdateMember_Normal(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -136,3 +135,279 @@ func TestUpdateMember_NotFound(t *testing.T) {
 	assert.Equal(t, 404, ce.Code())
 	assert.Equal(t, "成员不存在", ce.Error())
 }
+
+func int64Ptr(v int64) *int64 { return &v }
+
+// TC-1056: 两字段同时 nil，必须 400，且不得做任何 DB 读写
+func TestUpdateMember_BothFieldsNil_RejectedWith400(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+		Id: sp.mId,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce),
+		"两字段全 nil 必须命中 response.ErrBadRequest，且以 *CodeError 传递")
+	assert.Equal(t, 400, ce.Code(),
+		"两字段全 nil 必须 400，不得退化成 200 no-op 或 500")
+	assert.Contains(t, ce.Error(), "至少提供一个",
+		"错误消息应明确提示至少要传 memberType 或 status 之一，便于接入方排查空请求体")
+
+	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
+		"Logic 提前 400，任何 DB 落库都是回归；MemberType 必须保留原值")
+	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
+		"Logic 提前 400 时 Status 也必须保留原值")
+}
+
+// TC-1057: 仅改 Status，MemberType 字段必须按原值保留；绝不回归成 ""
+func TestUpdateMember_OnlyStatus_PreservesMemberType(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	require.NoError(t,
+		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+			Id:     sp.mId,
+			Status: int64Ptr(consts.StatusDisabled),
+		}),
+		"只改 Status 必须成功")
+
+	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(consts.StatusDisabled), got.Status,
+		"Status 应按入参更新到禁用")
+	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
+		"防线：旧实现若以空串当缺省值会把 memberType 改写成 ''，"+
+			"权限侧会当这行为非法成员吊销其全部权限，必须杜绝")
+}
+
+// TC-1058: 仅改 MemberType，Status 原值保留
+func TestUpdateMember_OnlyMemberType_PreservesStatus(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	require.NoError(t,
+		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+			Id:         sp.mId,
+			MemberType: strPtr(consts.MemberTypeAdmin),
+		}),
+		"只改 MemberType 必须成功")
+
+	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, consts.MemberTypeAdmin, got.MemberType)
+	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
+		"Status 未提供时必须保留原值；若回归成 0 会让该成员瞬间冻结")
+}
+
+// TC-1059: DEVELOPER 成员仅改 Status 冻结，不得误触 CheckMemberTypeAssignment
+// 语义上 CheckMemberTypeAssignment 拦的是"用普通 admin 指派/变更 DEVELOPER"的动作；仅冻结
+// 一个已存在的 DEVELOPER 不属于"指派 DEVELOPER"，必须放行。否则普通 admin 将永远无法管理
+// DEVELOPER 的启停，只能靠超管——属于管理面瘫痪。
+func TestUpdateMember_DeveloperStatusOnly_BypassesAssignmentCheck(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeDeveloper)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	require.NoError(t,
+		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+			Id:     sp.mId,
+			Status: int64Ptr(consts.StatusDisabled),
+		}),
+		"DEVELOPER 只冻结 (Status=2) 时必须跳过 CheckMemberTypeAssignment；"+
+			"修复前的 `if memberType == DEVELOPER` 早期校验会把这条合法请求拒成 403")
+
+	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, consts.MemberTypeDeveloper, got.MemberType,
+		"MemberType 在未传时必须保留 DEVELOPER")
+	assert.Equal(t, int64(consts.StatusDisabled), got.Status)
+}
+
+// TC-1060: 无效 Status（非 1/2）必须 400，不得被"只传 Status"分支绕过校验
+func TestUpdateMember_InvalidStatusValue_Rejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	for _, bad := range []int64{0, 3, -1, 999} {
+		err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+			Id:     sp.mId,
+			Status: int64Ptr(bad),
+		})
+		require.Error(t, err)
+		var ce *response.CodeError
+		require.True(t, errors.As(err, &ce),
+			"无效 Status 必须 *CodeError")
+		assert.Equal(t, 400, ce.Code(),
+			"Status=%d 必须 400 被拒，严禁靠 DB CHECK 或下游枚举触发 500", bad)
+	}
+
+	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(consts.StatusEnabled), got.Status, "非法 Status 全部被拒，原值必须不变")
+}
+
+// TC-1061: 值与现状完全一致（no-op）不报错，且**不触发** DB 事务/缓存失效
+// 这里只能通过"不返回 error"以及"DB 值稳定 + updateTime 不前进"的软信号来近似验证；
+// 契约上：nextType == member.MemberType && nextStatus == member.Status 时 Logic 早退。
+func TestUpdateMember_NoOpUpdate_ReturnsNil(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	before, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+
+	require.NoError(t,
+		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+			Id:         sp.mId,
+			MemberType: strPtr(before.MemberType),
+			Status:     int64Ptr(before.Status),
+		}),
+		"no-op update 必须 nil，不得被 ErrUpdateConflict 之类误报")
+
+	after, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, before.MemberType, after.MemberType)
+	assert.Equal(t, before.Status, after.Status)
+	assert.Equal(t, before.UpdateTime, after.UpdateTime,
+		"Logic 在 no-op 时应直接 return nil，不进事务，"+
+			"updateTime 不应被推进；推进即说明 Logic 仍然走了一次冗余 UPDATE")
+}
+
+// TC-0725:  修复：不能将最后一个 ADMIN 降级为 MEMBER
+func TestUpdateMember_DemoteLastAdminRejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	sp := seedEnabledProductWithMember(t, svcCtx, "ADMIN")
+	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
+
+	err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+		Id: sp.mId, MemberType: strPtr("MEMBER"),
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+	assert.Contains(t, ce.Error(), "最后一个管理员")
+
+	m, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
+	require.NoError(t, err)
+	assert.Equal(t, "ADMIN", m.MemberType, "MemberType 不应被改动")
+}
+
+// TC-0726:  修复：有多个 ADMIN 时可以降级其中一个
+func TestUpdateMember_DemoteAdmin_WhenMultiple_Allowed(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	var uIds, mIds []int64
+	for i := 0; i < 2; i++ {
+		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+			Username: testutil.UniqueId(), Password: testutil.HashPassword("pw"),
+			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+			Status: 1, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		uId, _ := uRes.LastInsertId()
+		uIds = append(uIds, uId)
+
+		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+			ProductCode: code, UserId: uId, MemberType: "ADMIN",
+			Status: 1, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		mId, _ := mRes.LastInsertId()
+		mIds = append(mIds, mId)
+	}
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
+		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
+	})
+
+	err = NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+		Id: mIds[0], MemberType: strPtr("MEMBER"),
+	})
+	require.NoError(t, err)
+
+	m, err := svcCtx.SysProductMemberModel.FindOne(ctx, mIds[0])
+	require.NoError(t, err)
+	assert.Equal(t, "MEMBER", m.MemberType)
+}
+
+// TC-0727:  修复：禁用状态的 ADMIN 不计入 active admin 计数，导致剩余 0 个启用 ADMIN 时仍拒绝降级
+// 说明：CountActiveAdmins 只统计 status=1 的 ADMIN；即便 DB 里有 2 个 ADMIN，但仅 1 个启用，
+// 降级这个唯一启用的 ADMIN 仍应被拒绝。
+func TestUpdateMember_DemoteLastActiveAdmin_Rejected(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	code := testutil.UniqueId()
+
+	pRes, err := svcCtx.SysProductModel.Insert(ctx, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	var uIds, mIds []int64
+	statuses := []int64{1, 2} // 一个启用，一个禁用
+	for _, st := range statuses {
+		uRes, err := svcCtx.SysUserModel.Insert(ctx, &userModel.SysUser{
+			Username: testutil.UniqueId(), Password: testutil.HashPassword("pw"),
+			Avatar: sql.NullString{}, IsSuperAdmin: 2, MustChangePassword: 2,
+			Status: 1, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		uId, _ := uRes.LastInsertId()
+		uIds = append(uIds, uId)
+		mRes, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+			ProductCode: code, UserId: uId, MemberType: "ADMIN",
+			Status: st, CreateTime: now, UpdateTime: now,
+		})
+		require.NoError(t, err)
+		mId, _ := mRes.LastInsertId()
+		mIds = append(mIds, mId)
+	}
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTable(ctx, conn, "`sys_user`", uIds...)
+		testutil.CleanTable(ctx, conn, "`sys_product`", pId)
+	})
+
+	// 启用中的那个 ADMIN (mIds[0]) 降级应被拒绝
+	err = NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
+		Id: mIds[0], MemberType: strPtr("DEVELOPER"),
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+	assert.Contains(t, ce.Error(), "最后一个管理员")
+}

internal/logic/member/updateMemberPartialPointer_audit_test.go

@@ -1,177 +0,0 @@
-package member
-
-import (
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-R11-1 —— UpdateMemberReq 的 MemberType / Status 指针化后，
-//   1) 既表达"字段未传"≠"字段传零值"（区分"不改"和"改成 0"/"改成 ''"），
-//   2) 又要在两者都 nil 时由 Logic 层兜底 400，避免无害路径被当"空 update"落库；
-//   3) 只传 Status 不传 MemberType（反之亦然）时不得回归出"把对面字段写成空字符串"的 bug；
-//   4) 已经是 DEVELOPER 的人，只传 Status 冻结/启用时绝不得误触 CheckMemberTypeAssignment，
-//      否则普通 admin 永远无法对 DEVELOPER 做冻结/解冻。
-// ---------------------------------------------------------------------------
-
-func int64Ptr(v int64) *int64 { return &v }
-
-// TC-1056: L-R11-1 —— 两字段同时 nil，必须 400，且不得做任何 DB 读写
-func TestUpdateMember_BothFieldsNil_RejectedWith400(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-		Id: sp.mId,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce),
-		"L-R11-1：两字段全 nil 必须命中 response.ErrBadRequest，且以 *CodeError 传递")
-	assert.Equal(t, 400, ce.Code(),
-		"L-R11-1：两字段全 nil 必须 400，不得退化成 200 no-op 或 500")
-	assert.Contains(t, ce.Error(), "至少提供一个",
-		"错误消息应明确提示至少要传 memberType 或 status 之一，便于接入方排查空请求体")
-
-	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
-		"L-R11-1：Logic 提前 400，任何 DB 落库都是回归；MemberType 必须保留原值")
-	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
-		"L-R11-1：Logic 提前 400 时 Status 也必须保留原值")
-}
-
-// TC-1057: L-R11-1 —— 仅改 Status，MemberType 字段必须按原值保留；绝不回归成 ""
-func TestUpdateMember_OnlyStatus_PreservesMemberType(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	require.NoError(t,
-		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-			Id:     sp.mId,
-			Status: int64Ptr(consts.StatusDisabled),
-		}),
-		"只改 Status 必须成功")
-
-	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(consts.StatusDisabled), got.Status,
-		"L-R11-1：Status 应按入参更新到禁用")
-	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
-		"L-R11-1 回归防线：旧实现若以空串当缺省值会把 memberType 改写成 ''，"+
-			"权限侧会当这行为非法成员吊销其全部权限，必须杜绝")
-}
-
-// TC-1058: L-R11-1 —— 仅改 MemberType，Status 原值保留
-func TestUpdateMember_OnlyMemberType_PreservesStatus(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	require.NoError(t,
-		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-			Id:         sp.mId,
-			MemberType: strPtr(consts.MemberTypeAdmin),
-		}),
-		"只改 MemberType 必须成功")
-
-	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, consts.MemberTypeAdmin, got.MemberType)
-	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
-		"L-R11-1：Status 未提供时必须保留原值；若回归成 0 会让该成员瞬间冻结")
-}
-
-// TC-1059: L-R11-1 —— DEVELOPER 成员仅改 Status 冻结，不得误触 CheckMemberTypeAssignment
-// 语义上 CheckMemberTypeAssignment 拦的是"用普通 admin 指派/变更 DEVELOPER"的动作；仅冻结
-// 一个已存在的 DEVELOPER 不属于"指派 DEVELOPER"，必须放行。否则普通 admin 将永远无法管理
-// DEVELOPER 的启停，只能靠超管——属于管理面瘫痪。
-func TestUpdateMember_DeveloperStatusOnly_BypassesAssignmentCheck(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeDeveloper)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	require.NoError(t,
-		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-			Id:     sp.mId,
-			Status: int64Ptr(consts.StatusDisabled),
-		}),
-		"L-R11-1：DEVELOPER 只冻结 (Status=2) 时必须跳过 CheckMemberTypeAssignment；"+
-			"修复前的 `if memberType == DEVELOPER` 早期校验会把这条合法请求拒成 403")
-
-	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, consts.MemberTypeDeveloper, got.MemberType,
-		"MemberType 在未传时必须保留 DEVELOPER")
-	assert.Equal(t, int64(consts.StatusDisabled), got.Status)
-}
-
-// TC-1060: L-R11-1 —— 无效 Status（非 1/2）必须 400，不得被"只传 Status"分支绕过校验
-func TestUpdateMember_InvalidStatusValue_Rejected(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	for _, bad := range []int64{0, 3, -1, 999} {
-		err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-			Id:     sp.mId,
-			Status: int64Ptr(bad),
-		})
-		require.Error(t, err)
-		var ce *response.CodeError
-		require.True(t, errors.As(err, &ce),
-			"L-R11-1：无效 Status 必须 *CodeError")
-		assert.Equal(t, 400, ce.Code(),
-			"L-R11-1：Status=%d 必须 400 被拒，严禁靠 DB CHECK 或下游枚举触发 500", bad)
-	}
-
-	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(consts.StatusEnabled), got.Status, "非法 Status 全部被拒，原值必须不变")
-}
-
-// TC-1061: L-R11-1 —— 值与现状完全一致（no-op）不报错，且**不触发** DB 事务/缓存失效
-// 这里只能通过"不返回 error"以及"DB 值稳定 + updateTime 不前进"的软信号来近似验证；
-// 契约上：nextType == member.MemberType && nextStatus == member.Status 时 Logic 早退。
-func TestUpdateMember_NoOpUpdate_ReturnsNil(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
-	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })
-
-	before, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-
-	require.NoError(t,
-		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
-			Id:         sp.mId,
-			MemberType: strPtr(before.MemberType),
-			Status:     int64Ptr(before.Status),
-		}),
-		"L-R11-1：no-op update 必须 nil，不得被 ErrUpdateConflict 之类误报")
-
-	after, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
-	require.NoError(t, err)
-	assert.Equal(t, before.MemberType, after.MemberType)
-	assert.Equal(t, before.Status, after.Status)
-	assert.Equal(t, before.UpdateTime, after.UpdateTime,
-		"L-R11-1 强化：Logic 在 no-op 时应直接 return nil，不进事务，"+
-			"updateTime 不应被推进；推进即说明 Logic 仍然走了一次冗余 UPDATE")
-}

internal/logic/product/createProductCompensation_audit_test.go

@@ -1,193 +0,0 @@
-package product
-
-import (
-	"context"
-	"database/sql"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-1（第 8 轮）—— CreateProduct 的 DB 事务提交后，ticket 生成 / JSON marshal /
-// Redis SetexCtx 任一步骤失败都必须走补偿：把 product / user / product_member 三行一并删除，
-// 让副作用回到"从未创建"。如果不补偿，新建的 admin 明文密码只留在本次内存里，一旦响应 500/503，
-// 账号就成了永久孤儿，必须手动改库。
-//
-// 注入手法：测试用例通过一个**无法连通**的 Redis 替换 svcCtx.Redis，让 SetexCtx 必然失败。
-//   - CacheRedis 不动，所以 Model 层缓存 / Loader 行为保持正常；
-//   - 只替换 svcCtx.Redis 这一个指针，CreateProduct 里就会打到挂线的 Redis，落入 503 分支；
-//   - 补偿事务会同步跑一次 DB，验收的点就是 DB 里 **不存在** 任何残留行。
-//
-// 命名规则：TC-0976 ~ TC-0978
-// ---------------------------------------------------------------------------
-
-// newBrokenSvcCtxForM1 返回一个"真实 DB + CacheRedis 正常 + svcCtx.Redis 指向黑洞"的 svcCtx。
-// 黑洞 Redis 通过 `127.0.0.1:1` 构造，任何 Setex 都会立刻拿到 connection refused，不会把测试拖很久。
-func newBrokenSvcCtxForM1(t *testing.T) *svc.ServiceContext {
-	t.Helper()
-	cfg := testutil.GetTestConfig()
-	svcCtx := svc.NewServiceContext(cfg)
-	// 把 svcCtx.Redis 换掉；注意 MustNewRedis 不立即拨号，只有真正调 Setex 才会爆。
-	// NonBlock=true 避免构造期强制 ping；PingTimeout 只在 NonBlock=false 时生效，这里保留是为
-	// 防御未来默认值漂移。真正的失败发生在运行 SetexCtx 时，连不通 127.0.0.1:1 会立刻返 err。
-	broken := redis.MustNewRedis(redis.RedisConf{
-		Host:        "127.0.0.1:1",
-		Type:        "node",
-		NonBlock:    true,
-		PingTimeout: 200 * time.Millisecond,
-	})
-	svcCtx.Redis = broken
-	return svcCtx
-}
-
-// assertNoOrphanRowsLeft 在补偿完成后，按 (productCode, adminUsername) 反查 DB 是否还有脏行。
-// 三张表都必须干净 —— 这是补偿契约的硬不变式。
-func assertNoOrphanRowsLeft(t *testing.T, ctx context.Context, conn sqlx.SqlConn, productCode, adminUsername string) {
-	t.Helper()
-
-	var productId int64
-	err := conn.QueryRowCtx(ctx, &productId, "SELECT `id` FROM `sys_product` WHERE `code` = ? LIMIT 1", productCode)
-	assert.ErrorIs(t, err, sql.ErrNoRows,
-		"M-1：补偿后 sys_product 不得留下 code=%s 的行", productCode)
-
-	var userId int64
-	err = conn.QueryRowCtx(ctx, &userId, "SELECT `id` FROM `sys_user` WHERE `username` = ? LIMIT 1", adminUsername)
-	assert.ErrorIs(t, err, sql.ErrNoRows,
-		"M-1：补偿后 sys_user 不得留下 username=%s 的行", adminUsername)
-
-	var memberId int64
-	err = conn.QueryRowCtx(ctx, &memberId,
-		"SELECT `id` FROM `sys_product_member` WHERE `productCode` = ? LIMIT 1", productCode)
-	assert.ErrorIs(t, err, sql.ErrNoRows,
-		"M-1：补偿后 sys_product_member 不得留下 productCode=%s 的行", productCode)
-}
-
-// TC-0976: Redis SetexCtx 失败时走补偿 —— DB 三张表必须回到"从未创建"。
-func TestCreateProduct_RedisSetexFail_CompensatesAllRows(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := newBrokenSvcCtxForM1(t)
-	conn := testutil.GetTestSqlConn()
-
-	code := "m1_cpf_" + testutil.UniqueId()
-	adminUsername := "admin_" + code
-
-	// 兜底清理，防止断言失败后把孤儿行留下来污染下一次运行。
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
-		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
-	})
-
-	// 审计 M-1 补偿路径必须在"入库 → SetexCtx 失败 → 补偿"整条链路生效。L-R10-1 要求传 AdminDeptId：
-	// 这里必须用真实 DB（svcCtx.SysDeptModel 走 testutil 底层 conn），所以 seed 一条真实 dept。
-	deptId := seedAdminDept(t, ctx, svcCtx)
-	logic := NewCreateProductLogic(ctx, svcCtx)
-	resp, err := logic.CreateProduct(&types.CreateProductReq{
-		Code:        code,
-		Name:        "m1压测产品",
-		Remark:      "审计M-1补偿验证",
-		AdminDeptId: deptId,
-	})
-
-	// 审计要求：返回 503 "暂存初始凭证失败，请稍后重试"；响应体不得携带 ticket / adminPassword。
-	require.Error(t, err, "M-1：Redis 挂了时必须返回错误而不是静默吞掉")
-	require.Nil(t, resp, "M-1：失败路径下不应把半成品 CreateProductResp 塞回给客户端")
-
-	// 核心断言：补偿必须把产品 / admin 用户 / product_member 三行全部抹除。
-	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)
-}
-
-// TC-0977: 同一 product code 在补偿后可以再次创建成功（幂等性）。
-// 没有这条断言的话，"补偿把行删干净"还可能与"索引未释放"组合成 ErrConflict，运维的修复动作会
-// 在二次尝试时被"产品编码已存在"挡回，补偿只是半成品。
-func TestCreateProduct_RedisSetexFail_AfterCompensation_CanRecreate(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	brokenCtx := newBrokenSvcCtxForM1(t)
-	conn := testutil.GetTestSqlConn()
-
-	code := "m1_recreate_" + testutil.UniqueId()
-	adminUsername := "admin_" + code
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
-		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
-	})
-
-	// 审计 L-R10-1：两次 CreateProduct 复用同一个有效 dept，seedAdminDept 在 brokenCtx 下创建
-	// （brokenCtx 的 Models 共享底层 conn，所以 goodCtx 二次查询也能读到）。
-	deptId := seedAdminDept(t, ctx, brokenCtx)
-	// 第一次：Redis 坏 → 补偿 → 503
-	_, err := NewCreateProductLogic(ctx, brokenCtx).CreateProduct(&types.CreateProductReq{
-		Code: code, Name: "first_attempt", Remark: "redis_down", AdminDeptId: deptId,
-	})
-	require.Error(t, err)
-	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)
-
-	// 第二次：Redis 好 → 必须成功；若第一次补偿不彻底会在 FindOneByCode/FindOneByUsername 里被拦。
-	goodCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	resp2, err := NewCreateProductLogic(ctx, goodCtx).CreateProduct(&types.CreateProductReq{
-		Code: code, Name: "second_attempt", Remark: "redis_ok", AdminDeptId: deptId,
-	})
-	require.NoError(t, err, "M-1：补偿后二次创建必须成功；若失败说明有行没被清干净")
-	require.NotNil(t, resp2)
-	assert.Equal(t, code, resp2.Code)
-	assert.NotEmpty(t, resp2.CredentialsTicket)
-}
-
-// TC-0978: 补偿的三张表删除顺序必须是"子 → 父"（product_member → user → product），
-// 保证即使外键/缓存/唯一索引尚未释放也不会互相拦截。
-//
-// 验证手法：在第一次补偿完成后，直接用数据库元数据反查三张表里均无与 productCode 相关的残留；
-// 如果删除顺序错误（例如先 product 后 member），product 会被外键/级联规则阻塞，member 行会留下。
-//
-// 注：sys_product 与 sys_product_member 之间没有强制外键（见 perm.sql 确认），所以 MySQL 不会在
-// 引擎层阻止错序 DELETE。但错序在事务里依然会导致：
-//   - 如果先删 product 再删 member，member 仍有引用的 productCode 已经没有对应 product，
-//     再之后的 "ON DUPLICATE KEY UPDATE" 或外部查询会看到脏引用；
-//   - 即便 DB 不拦，测试也要在更高一层用"三张表均为 0 行"来钉死补偿是否真正覆盖 3 行。
-func TestCreateProduct_RedisSetexFail_CompensatesInChildFirstOrder(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := newBrokenSvcCtxForM1(t)
-	conn := testutil.GetTestSqlConn()
-
-	code := "m1_order_" + testutil.UniqueId()
-	adminUsername := "admin_" + code
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
-		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
-		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
-	})
-
-	_, err := NewCreateProductLogic(ctx, svcCtx).CreateProduct(&types.CreateProductReq{
-		Code: code, Name: "m1 order", Remark: "delete order", AdminDeptId: seedAdminDept(t, ctx, svcCtx),
-	})
-	require.Error(t, err)
-
-	// 交叉验证：三张表按独立 SELECT COUNT 查询，每张都必须为 0。
-	for _, tc := range []struct {
-		sql   string
-		arg   interface{}
-		table string
-	}{
-		{"SELECT COUNT(*) FROM `sys_product_member` WHERE `productCode` = ?", code, "sys_product_member"},
-		{"SELECT COUNT(*) FROM `sys_user` WHERE `username` = ?", adminUsername, "sys_user"},
-		{"SELECT COUNT(*) FROM `sys_product` WHERE `code` = ?", code, "sys_product"},
-	} {
-		var n int64
-		require.NoError(t, conn.QueryRowCtx(ctx, &n, tc.sql, tc.arg))
-		assert.Equal(t, int64(0), n,
-			"M-1：补偿完成后 %s 应 0 行（命名 code=%s / admin=%s）", tc.table, code, adminUsername)
-	}
-}

internal/logic/product/createProductConflict_audit_test.go

@@ -1,82 +0,0 @@
-package product
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	deptModel "perms-system-server/internal/model/dept"
-	productModel "perms-system-server/internal/model/product"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/go-sql-driver/mysql"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-5 修复 —— 旧实现用 strings.Contains(err, "uk_code") 来分辨
-// "产品码冲突" vs 其它唯一键冲突，文案随 MySQL 版本、驱动甚至索引重命名漂移，
-// 极易把真实冲突静默降级为通用 500；修复后统一返回 ErrConflict("数据冲突，请稍后重试")，
-// 由 pre-check 负责业务语义。本文件锚定"非特定文案也能兜到 409"。
-// ---------------------------------------------------------------------------
-
-// TC-0827: M-5 —— 事务内冒出 1062 错误（错误消息里不含 "uk_code" 字样）时，
-// 仍必须返回 409 通用冲突，而不是被旧的 strings.Contains 分支漏掉降级成 500。
-func TestCreateProduct_DuplicateEntry_UnknownIndexName_MapsTo409(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	// 关键：索引名选一个完全不含 "uk_code" 的，让旧 strings.Contains 分支必然 miss。
-	dupErr := &mysql.MySQLError{
-		Number:  1062,
-		Message: "Duplicate entry 'abc' for key 'sys_product_PRIMARY'",
-	}
-
-	mockProduct := mocks.NewMockSysProductModel(ctrl)
-	mockProduct.EXPECT().FindOneByCode(gomock.Any(), "m5_code").
-		Return(nil, productModel.ErrNotFound)
-	mockProduct.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-	// 直接让 InsertWithTx 冒出 1062
-	mockProduct.EXPECT().InsertWithTx(gomock.Any(), nil, gomock.Any()).
-		Return(nil, dupErr)
-
-	mockUser := mocks.NewMockSysUserModel(ctrl)
-	mockUser.EXPECT().FindOneByUsername(gomock.Any(), "admin_m5_code").
-		Return(nil, userModel.ErrNotFound)
-
-	// 审计 L-R10-1：CreateProduct 现在必填 AdminDeptId，且在入库前 FindOne + 校验启用状态
-	mockDept := mocks.NewMockSysDeptModel(ctrl)
-	mockDept.EXPECT().FindOne(gomock.Any(), int64(77)).
-		Return(&deptModel.SysDept{Id: 77, Path: "/77/", Status: 1}, nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Product: mockProduct,
-		User:    mockUser,
-		Dept:    mockDept,
-	})
-
-	resp, err := NewCreateProductLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateProduct(&types.CreateProductReq{
-		Code:        "m5_code",
-		Name:        "M5 Product",
-		AdminDeptId: 77,
-	})
-	assert.Nil(t, resp)
-	require.Error(t, err)
-
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce), "必须是结构化 CodeError")
-	assert.Equal(t, 409, ce.Code(),
-		"M-5：任何 1062 都应统一返回 409；修复前不含 uk_code 的索引名会被吞成 500")
-	assert.Contains(t, ce.Error(), "数据冲突",
-		"错误消息应当是通用的'数据冲突，请稍后重试'，不再尝试解析索引名文案")
-}

internal/logic/product/createProductLogic_mock_test.go

@@ -46,7 +46,7 @@ func TestCreateProduct_Mock_UserInsertFail(t *testing.T) {
 	mockUser.EXPECT().InsertWithTx(gomock.Any(), nil, gomock.Any()).
 		Return(nil, dbErr)
 
-	// 审计 L-R10-1：CreateProduct 必填 AdminDeptId，入库前 FindOne + 启用校验
+	// CreateProduct 必填 AdminDeptId，入库前 FindOne + 启用校验
 	mockDept := mocks.NewMockSysDeptModel(ctrl)
 	mockDept.EXPECT().FindOne(gomock.Any(), int64(88)).
 		Return(&deptModel.SysDept{Id: 88, Path: "/88/", Status: 1}, nil)
@@ -96,7 +96,7 @@ func TestCreateProduct_Mock_MemberInsertFail(t *testing.T) {
 	mockPM.EXPECT().InsertWithTx(gomock.Any(), nil, gomock.Any()).
 		Return(sql.Result(nil), dbErr)
 
-	// 审计 L-R10-1：CreateProduct 必填 AdminDeptId
+	// CreateProduct 必填 AdminDeptId
 	mockDept := mocks.NewMockSysDeptModel(ctrl)
 	mockDept.EXPECT().FindOne(gomock.Any(), int64(88)).
 		Return(&deptModel.SysDept{Id: 88, Path: "/88/", Status: 1}, nil)

internal/logic/product/createProductLogic_test.go

@@ -1,24 +1,31 @@
 package product
 
 import (
+	"context"
+	"database/sql"
 	"encoding/json"
 	"errors"
-	"sync"
-	"testing"
-
+	"github.com/go-sql-driver/mysql"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"go.uber.org/mock/gomock"
+	"golang.org/x/crypto/bcrypt"
+	deptModel "perms-system-server/internal/model/dept"
 	productModel "perms-system-server/internal/model/product"
+	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/bcrypt"
+	"sync"
+	"testing"
+	"time"
 )
 
-// TC-0064: 正常创建
 func TestCreateProduct_Success(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -46,11 +53,11 @@ func TestCreateProduct_Success(t *testing.T) {
 	assert.NotEmpty(t, resp.AppKey)
 	assert.Equal(t, "admin_"+code, resp.AdminUser)
 
-	// 审计 M-4：响应体必须不再明文携带 appSecret / adminPassword，
+	// 响应体必须不再明文携带 appSecret / adminPassword，
 	// 改为发放一次性 credentialsTicket + 过期时间；调用方需凭 ticket 走
 	// /api/product/fetchInitialCredentials 领取敏感凭证。
-	assert.NotEmpty(t, resp.CredentialsTicket, "M-4：必须返回一次性凭证票据")
-	assert.True(t, resp.CredentialsExpiresAt > 0, "M-4：必须返回过期时间戳")
+	assert.NotEmpty(t, resp.CredentialsTicket, "必须返回一次性凭证票据")
+	assert.True(t, resp.CredentialsExpiresAt > 0, "必须返回过期时间戳")
 
 	// 契约性校验：CreateProductResp 的 JSON 序列化里不应再出现 appSecret / adminPassword 字段。
 	buf, err := json.Marshal(resp)
@@ -59,8 +66,8 @@ func TestCreateProduct_Success(t *testing.T) {
 	require.NoError(t, json.Unmarshal(buf, &asMap))
 	_, hasSecret := asMap["appSecret"]
 	_, hasPwd := asMap["adminPassword"]
-	assert.False(t, hasSecret, "M-4：CreateProductResp JSON 不得包含 appSecret 字段（避免日志落盘）")
-	assert.False(t, hasPwd, "M-4：CreateProductResp JSON 不得包含 adminPassword 字段（避免日志落盘）")
+	assert.False(t, hasSecret, "CreateProductResp JSON 不得包含 appSecret 字段（避免日志落盘）")
+	assert.False(t, hasPwd, "CreateProductResp JSON 不得包含 adminPassword 字段（避免日志落盘）")
 }
 
 // TC-0064: 正常创建
@@ -91,12 +98,12 @@ func TestCreateProduct_VerifyDB(t *testing.T) {
 	assert.Equal(t, "DB验证产品", product.Name)
 	assert.Equal(t, resp.AppKey, product.AppKey)
 
-	// 审计 M-4：CreateProduct 响应不再明文吐 appSecret；appSecret 经 ticket 领取后再核对。
+	// CreateProduct 响应不再明文吐 appSecret；appSecret 经 ticket 领取后再核对。
 	// 这里改为用 FetchInitialCredentialsLogic 把明文 appSecret 取出来，与 DB 中的 bcrypt hash 比对，
 	// 既验证"DB 存的是 hash 而不是明文"，也验证 ticket 流程正确交还了原始 appSecret。
 	fetch := NewFetchInitialCredentialsLogic(ctx, svcCtx)
 	cred, err := fetch.FetchInitialCredentials(&types.FetchInitialCredentialsReq{Ticket: resp.CredentialsTicket})
-	require.NoError(t, err, "M-4：使用 ticket 必须能领取到初始 appSecret / adminPassword")
+	require.NoError(t, err, "使用 ticket 必须能领取到初始 appSecret / adminPassword")
 	require.NotEmpty(t, cred.AppSecret)
 	require.NotEmpty(t, cred.AdminPassword)
 	assert.NoError(t, bcrypt.CompareHashAndPassword([]byte(product.AppSecret), []byte(cred.AppSecret)),
@@ -215,7 +222,7 @@ func TestCreateProduct_NonSuperAdminRejected(t *testing.T) {
 	assert.Equal(t, 403, ce.Code())
 }
 
-// TC-0069~0593: createProduct 编码格式校验(M-8 修复验证)
+// TC-0069~0593: createProduct 编码格式校验( 修复验证)
 func TestCreateProduct_InvalidCodeFormat(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -285,3 +292,214 @@ func TestCreateProduct_ValidCodeWithSymbols(t *testing.T) {
 
 // suppress unused import
 var _ = (*productModel.SysProduct)(nil)
+
+func newBrokenSvcCtxForM1(t *testing.T) *svc.ServiceContext {
+	t.Helper()
+	cfg := testutil.GetTestConfig()
+	svcCtx := svc.NewServiceContext(cfg)
+	// 把 svcCtx.Redis 换掉；注意 MustNewRedis 不立即拨号，只有真正调 Setex 才会爆。
+	// NonBlock=true 避免构造期强制 ping；PingTimeout 只在 NonBlock=false 时生效，这里保留是为
+	// 防御未来默认值漂移。真正的失败发生在运行 SetexCtx 时，连不通 127.0.0.1:1 会立刻返 err。
+	broken := redis.MustNewRedis(redis.RedisConf{
+		Host:        "127.0.0.1:1",
+		Type:        "node",
+		NonBlock:    true,
+		PingTimeout: 200 * time.Millisecond,
+	})
+	svcCtx.Redis = broken
+	return svcCtx
+}
+
+// assertNoOrphanRowsLeft 在补偿完成后，按 (productCode, adminUsername) 反查 DB 是否还有脏行。
+// 三张表都必须干净 —— 这是补偿契约的硬不变式。
+func assertNoOrphanRowsLeft(t *testing.T, ctx context.Context, conn sqlx.SqlConn, productCode, adminUsername string) {
+	t.Helper()
+
+	var productId int64
+	err := conn.QueryRowCtx(ctx, &productId, "SELECT `id` FROM `sys_product` WHERE `code` = ? LIMIT 1", productCode)
+	assert.ErrorIs(t, err, sql.ErrNoRows,
+		"补偿后 sys_product 不得留下 code=%s 的行", productCode)
+
+	var userId int64
+	err = conn.QueryRowCtx(ctx, &userId, "SELECT `id` FROM `sys_user` WHERE `username` = ? LIMIT 1", adminUsername)
+	assert.ErrorIs(t, err, sql.ErrNoRows,
+		"补偿后 sys_user 不得留下 username=%s 的行", adminUsername)
+
+	var memberId int64
+	err = conn.QueryRowCtx(ctx, &memberId,
+		"SELECT `id` FROM `sys_product_member` WHERE `productCode` = ? LIMIT 1", productCode)
+	assert.ErrorIs(t, err, sql.ErrNoRows,
+		"补偿后 sys_product_member 不得留下 productCode=%s 的行", productCode)
+}
+
+// TC-0976: Redis SetexCtx 失败时走补偿 —— DB 三张表必须回到"从未创建"。
+func TestCreateProduct_RedisSetexFail_CompensatesAllRows(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := newBrokenSvcCtxForM1(t)
+	conn := testutil.GetTestSqlConn()
+
+	code := "m1_cpf_" + testutil.UniqueId()
+	adminUsername := "admin_" + code
+
+	// 兜底清理，防止断言失败后把孤儿行留下来污染下一次运行。
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
+		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
+	})
+
+	// 补偿路径必须在"入库 → SetexCtx 失败 → 补偿"整条链路生效。 要求传 AdminDeptId：
+	// 这里必须用真实 DB（svcCtx.SysDeptModel 走 testutil 底层 conn），所以 seed 一条真实 dept。
+	deptId := seedAdminDept(t, ctx, svcCtx)
+	logic := NewCreateProductLogic(ctx, svcCtx)
+	resp, err := logic.CreateProduct(&types.CreateProductReq{
+		Code:        code,
+		Name:        "m1压测产品",
+		Remark:      "补偿验证",
+		AdminDeptId: deptId,
+	})
+
+	// 要求：返回 503 "暂存初始凭证失败，请稍后重试"；响应体不得携带 ticket / adminPassword。
+	require.Error(t, err, "Redis 挂了时必须返回错误而不是静默吞掉")
+	require.Nil(t, resp, "失败路径下不应把半成品 CreateProductResp 塞回给客户端")
+
+	// 核心断言：补偿必须把产品 / admin 用户 / product_member 三行全部抹除。
+	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)
+}
+
+// TC-0977: 同一 product code 在补偿后可以再次创建成功（幂等性）。
+// 没有这条断言的话，"补偿把行删干净"还可能与"索引未释放"组合成 ErrConflict，运维的修复动作会
+// 在二次尝试时被"产品编码已存在"挡回，补偿只是半成品。
+func TestCreateProduct_RedisSetexFail_AfterCompensation_CanRecreate(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	brokenCtx := newBrokenSvcCtxForM1(t)
+	conn := testutil.GetTestSqlConn()
+
+	code := "m1_recreate_" + testutil.UniqueId()
+	adminUsername := "admin_" + code
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
+		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
+	})
+
+	// 两次 CreateProduct 复用同一个有效 dept，seedAdminDept 在 brokenCtx 下创建
+	// （brokenCtx 的 Models 共享底层 conn，所以 goodCtx 二次查询也能读到）。
+	deptId := seedAdminDept(t, ctx, brokenCtx)
+	// 第一次：Redis 坏 → 补偿 → 503
+	_, err := NewCreateProductLogic(ctx, brokenCtx).CreateProduct(&types.CreateProductReq{
+		Code: code, Name: "first_attempt", Remark: "redis_down", AdminDeptId: deptId,
+	})
+	require.Error(t, err)
+	assertNoOrphanRowsLeft(t, ctx, conn, code, adminUsername)
+
+	// 第二次：Redis 好 → 必须成功；若第一次补偿不彻底会在 FindOneByCode/FindOneByUsername 里被拦。
+	goodCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	resp2, err := NewCreateProductLogic(ctx, goodCtx).CreateProduct(&types.CreateProductReq{
+		Code: code, Name: "second_attempt", Remark: "redis_ok", AdminDeptId: deptId,
+	})
+	require.NoError(t, err, "补偿后二次创建必须成功；若失败说明有行没被清干净")
+	require.NotNil(t, resp2)
+	assert.Equal(t, code, resp2.Code)
+	assert.NotEmpty(t, resp2.CredentialsTicket)
+}
+
+// TC-0978: 补偿的三张表删除顺序必须是"子 → 父"（product_member → user → product），
+// 保证即使外键/缓存/唯一索引尚未释放也不会互相拦截。
+//
+// 验证手法：在第一次补偿完成后，直接用数据库元数据反查三张表里均无与 productCode 相关的残留；
+// 如果删除顺序错误（例如先 product 后 member），product 会被外键/级联规则阻塞，member 行会留下。
+//
+// 注：sys_product 与 sys_product_member 之间没有强制外键（见 perm.sql 确认），所以 MySQL 不会在
+// 引擎层阻止错序 DELETE。但错序在事务里依然会导致：
+// - 如果先删 product 再删 member，member 仍有引用的 productCode 已经没有对应 product，
+// 再之后的 "ON DUPLICATE KEY UPDATE" 或外部查询会看到脏引用；
+// - 即便 DB 不拦，测试也要在更高一层用"三张表均为 0 行"来钉死补偿是否真正覆盖 3 行。
+func TestCreateProduct_RedisSetexFail_CompensatesInChildFirstOrder(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := newBrokenSvcCtxForM1(t)
+	conn := testutil.GetTestSqlConn()
+
+	code := "m1_order_" + testutil.UniqueId()
+	adminUsername := "admin_" + code
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_product_member`", "productCode", code)
+		testutil.CleanTableByField(ctx, conn, "`sys_user`", "username", adminUsername)
+		testutil.CleanTableByField(ctx, conn, "`sys_product`", "code", code)
+	})
+
+	_, err := NewCreateProductLogic(ctx, svcCtx).CreateProduct(&types.CreateProductReq{
+		Code: code, Name: "m1 order", Remark: "delete order", AdminDeptId: seedAdminDept(t, ctx, svcCtx),
+	})
+	require.Error(t, err)
+
+	// 交叉验证：三张表按独立 SELECT COUNT 查询，每张都必须为 0。
+	for _, tc := range []struct {
+		sql   string
+		arg   interface{}
+		table string
+	}{
+		{"SELECT COUNT(*) FROM `sys_product_member` WHERE `productCode` = ?", code, "sys_product_member"},
+		{"SELECT COUNT(*) FROM `sys_user` WHERE `username` = ?", adminUsername, "sys_user"},
+		{"SELECT COUNT(*) FROM `sys_product` WHERE `code` = ?", code, "sys_product"},
+	} {
+		var n int64
+		require.NoError(t, conn.QueryRowCtx(ctx, &n, tc.sql, tc.arg))
+		assert.Equal(t, int64(0), n,
+			"补偿完成后 %s 应 0 行（命名 code=%s / admin=%s）", tc.table, code, adminUsername)
+	}
+}
+
+func TestCreateProduct_DuplicateEntry_UnknownIndexName_MapsTo409(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	// 关键：索引名选一个完全不含 "uk_code" 的，让旧 strings.Contains 分支必然 miss。
+	dupErr := &mysql.MySQLError{
+		Number:  1062,
+		Message: "Duplicate entry 'abc' for key 'sys_product_PRIMARY'",
+	}
+
+	mockProduct := mocks.NewMockSysProductModel(ctrl)
+	mockProduct.EXPECT().FindOneByCode(gomock.Any(), "m5_code").
+		Return(nil, productModel.ErrNotFound)
+	mockProduct.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+	// 直接让 InsertWithTx 冒出 1062
+	mockProduct.EXPECT().InsertWithTx(gomock.Any(), nil, gomock.Any()).
+		Return(nil, dupErr)
+
+	mockUser := mocks.NewMockSysUserModel(ctrl)
+	mockUser.EXPECT().FindOneByUsername(gomock.Any(), "admin_m5_code").
+		Return(nil, userModel.ErrNotFound)
+
+	// CreateProduct 现在必填 AdminDeptId，且在入库前 FindOne + 校验启用状态
+	mockDept := mocks.NewMockSysDeptModel(ctrl)
+	mockDept.EXPECT().FindOne(gomock.Any(), int64(77)).
+		Return(&deptModel.SysDept{Id: 77, Path: "/77/", Status: 1}, nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Product: mockProduct,
+		User:    mockUser,
+		Dept:    mockDept,
+	})
+
+	resp, err := NewCreateProductLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateProduct(&types.CreateProductReq{
+		Code:        "m5_code",
+		Name:        "M5 Product",
+		AdminDeptId: 77,
+	})
+	assert.Nil(t, resp)
+	require.Error(t, err)
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce), "必须是结构化 CodeError")
+	assert.Equal(t, 409, ce.Code(),
+		"任何 1062 都应统一返回 409；修复前不含 uk_code 的索引名会被吞成 500")
+	assert.Contains(t, ce.Error(), "数据冲突",
+		"错误消息应当是通用的'数据冲突，请稍后重试'，不再尝试解析索引名文案")
+}

internal/logic/product/fetchInitialCredentialsLogic_audit_test.go → internal/logic/product/fetchInitialCredentialsLogic_test.go

@@ -20,16 +20,16 @@ import (
 )
 
 // ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-4 —— CreateProduct 不再明文回吐 appSecret / adminPassword，
+// 覆盖目标：CreateProduct 不再明文回吐 appSecret / adminPassword，
 // 改为发放一次性 credentialsTicket，调用方再凭 ticket 调 FetchInitialCredentials 领取。
 // 安全契约必须钉死：
-//   1) 只有超管能消费 ticket（非超管必须 403）；
-//   2) 必须一次性消费（consumed 后再次消费必须 400）；
-//   3) 错误/过期 ticket 必须 400；
-//   4) 空 ticket 必须 400；
-//   5) 并发消费同一 ticket 时，有且仅有一个请求能拿到明文（GetDelCtx 原子性）；
-//   6) Redis 中落盘的 value 必须是结构化 JSON，而不是裸明文（便于未来加密 / schema 演进）；
-//   7) FetchInitialCredentialsResp 必须暴露 appSecret / adminPassword / appKey / adminUser。
+// 1) 只有超管能消费 ticket（非超管必须 403）；
+// 2) 必须一次性消费（consumed 后再次消费必须 400）；
+// 3) 错误/过期 ticket 必须 400；
+// 4) 空 ticket 必须 400；
+// 5) 并发消费同一 ticket 时，有且仅有一个请求能拿到明文（GetDelCtx 原子性）；
+// 6) Redis 中落盘的 value 必须是结构化 JSON，而不是裸明文（便于未来加密 / schema 演进）；
+// 7) FetchInitialCredentialsResp 必须暴露 appSecret / adminPassword / appKey / adminUser。
 // ---------------------------------------------------------------------------
 
 // TC-0901: FetchInitialCredentials 正常路径 —— 用 CreateProduct 返回的 ticket 领取凭证。
@@ -63,9 +63,9 @@ func TestFetchInitialCredentials_HappyPath(t *testing.T) {
 	assert.Equal(t, createResp.AdminUser, cred.AdminUser, "adminUser 必须与 CreateProduct 响应一致")
 	assert.NotEmpty(t, cred.AppSecret, "必须返回明文 appSecret")
 	assert.NotEmpty(t, cred.AdminPassword, "必须返回明文 adminPassword")
-	// 基础合理性：32 字节 hex = 64 字符；审计 L-R10-2 改为混合字符集强密码，长度固定 16。
+	// 基础合理性：32 字节 hex = 64 字符；改为混合字符集强密码，长度固定 16。
 	assert.Len(t, cred.AppSecret, 64, "appSecret 必须是 32 字节 hex")
-	assert.Len(t, cred.AdminPassword, 16, "L-R10-2：adminPassword 改由 generateStrongInitialPassword(16) 生成，长度恒为 16")
+	assert.Len(t, cred.AdminPassword, 16, "adminPassword 改由 generateStrongInitialPassword(16) 生成，长度恒为 16")
 }
 
 // TC-0902: FetchInitialCredentials 一次性消费 —— 同一 ticket 第二次消费必须 400。
@@ -93,7 +93,7 @@ func TestFetchInitialCredentials_OneShotConsumption(t *testing.T) {
 	require.NotNil(t, first)
 
 	second, err := logic.FetchInitialCredentials(&types.FetchInitialCredentialsReq{Ticket: createResp.CredentialsTicket})
-	require.Error(t, err, "M-4：一次性 ticket 不能被第二次消费")
+	require.Error(t, err, "一次性 ticket 不能被第二次消费")
 	assert.Nil(t, second)
 
 	var ce *response.CodeError
@@ -176,7 +176,7 @@ func TestFetchInitialCredentials_NonSuperAdminRejected(t *testing.T) {
 	cred, err := NewFetchInitialCredentialsLogic(superCtx, svcCtx).FetchInitialCredentials(
 		&types.FetchInitialCredentialsReq{Ticket: createResp.CredentialsTicket},
 	)
-	require.NoError(t, err, "M-4：非超管被拒时不得把 ticket 吞掉，否则超管会领取不到")
+	require.NoError(t, err, "非超管被拒时不得把 ticket 吞掉，否则超管会领取不到")
 	assert.NotEmpty(t, cred.AppSecret)
 }
 
@@ -216,7 +216,7 @@ func TestFetchInitialCredentials_MalformedPayloadIn500(t *testing.T) {
 }
 
 // TC-0909: Redis 中落盘的 value 必须是结构化 JSON，包含 4 个字段。
-// 如果未来有人把 Marshal 换回裸字符串（又一个 M-4 回归），这个测试立刻炸。
+// 如果未来有人把 Marshal 换回裸字符串（又一个  回归），这个测试立刻炸。
 func TestFetchInitialCredentials_StoredPayloadIsStructuredJSON(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -268,11 +268,11 @@ func TestFetchInitialCredentials_TicketTTLWithinWindow(t *testing.T) {
 	ttl, err := svcCtx.Redis.TtlCtx(ctx, initialCredentialsKeyPrefix+createResp.CredentialsTicket)
 	require.NoError(t, err)
 	assert.Greater(t, ttl, 0, "ticket 必须是短 TTL 而不是永久")
-	assert.LessOrEqual(t, ttl, 300, "M-4：ticket TTL 不得超过 5 分钟 300s")
+	assert.LessOrEqual(t, ttl, 300, "ticket TTL 不得超过 5 分钟 300s")
 }
 
 // TC-0911: 并发消费同一 ticket —— 有且仅有一个请求能拿到明文，其他全部 400。
-// 依赖 GetDelCtx 的原子 GET+DEL 语义，这是 M-4 防竞态的核心契约。
+// 依赖 GetDelCtx 的原子 GET+DEL 语义，这是  防竞态的核心契约。
 func TestFetchInitialCredentials_ConcurrentConsumptionSingleWinner(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -322,18 +322,18 @@ func TestFetchInitialCredentials_ConcurrentConsumptionSingleWinner(t *testing.T)
 }
 
 // TC-0912: 契约回归 —— CreateProductResp 的公开字段集合不得再包含 appSecret / adminPassword。
-// 这是对 M-4 的"结构体层面"回归（TC-0064 只覆盖到 JSON 序列化层面）。
+// 这是对  的"结构体层面"回归（TC-0064 只覆盖到 JSON 序列化层面）。
 func TestCreateProductResp_NoLongerExposesPlaintextCredentials(t *testing.T) {
 	resp := &types.CreateProductResp{}
 	bs, err := json.Marshal(resp)
 	require.NoError(t, err)
 
-	// 序列化结果里出现 "appSecret" 或 "adminPassword" 都属于 M-4 回归。
+	// 序列化结果里出现 "appSecret" 或 "adminPassword" 都属于  回归。
 	asStr := string(bs)
 	assert.NotContains(t, asStr, "\"appSecret\"",
-		"M-4：CreateProductResp 不得再含有 appSecret（哪怕是空串序列化）")
+		"CreateProductResp 不得再含有 appSecret（哪怕是空串序列化）")
 	assert.NotContains(t, asStr, "\"adminPassword\"",
-		"M-4：CreateProductResp 不得再含有 adminPassword（哪怕是空串序列化）")
+		"CreateProductResp 不得再含有 adminPassword（哪怕是空串序列化）")
 
 	// 必须有 ticket 相关字段
 	assert.Contains(t, asStr, "credentialsTicket")

internal/logic/product/helper_test.go

@@ -13,7 +13,7 @@ import (
 )
 
 // seedAdminDept 插入一个启用状态的部门并登记 cleanup，返回 deptId。
-// 用于 L-R10-1 要求的 CreateProduct.AdminDeptId 入参，避免每个测试重复模板代码。
+// 用于  要求的 CreateProduct.AdminDeptId 入参，避免每个测试重复模板代码。
 func seedAdminDept(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext) int64 {
 	t.Helper()
 	conn := testutil.GetTestSqlConn()

internal/logic/product/productAccessControl_audit_test.go → internal/logic/product/productListLogic_test.go

@@ -19,18 +19,18 @@ import (
 )
 
 // ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-2 修复回归 —— 非超管调用 /api/product/list、/api/product/detail
+// 覆盖目标：非超管调用 /api/product/list、/api/product/detail
 // 时必须做 "行/资源级" 访问控制：
-//   * List：只返回 caller.ProductCode 对应的那一条；caller 无 productCode 时返回空列表。
-//   * Detail：目标 product.Code != caller.ProductCode 时 404（不披露 "存在但无权"）。
+// * List：只返回 caller.ProductCode 对应的那一条；caller 无 productCode 时返回空列表。
+// * Detail：目标 product.Code != caller.ProductCode 时 404（不披露 "存在但无权"）。
 // 同时保留字段级脱敏：非超管看不到 AppKey。
 // ---------------------------------------------------------------------------
 
-// ——— 工具：各种身份的 ctx ———
+// — 工具：各种身份的 ctx —
 
 func memberWithProduct(productCode string) context.Context {
 	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId:       42, Username: "m",
+		UserId: 42, Username: "m",
 		IsSuperAdmin: false, MemberType: consts.MemberTypeMember,
 		Status: consts.StatusEnabled, ProductCode: productCode,
 	})
@@ -68,14 +68,14 @@ func TestProductList_Member_OnlySeesOwnProduct(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, resp)
 
-	assert.Equal(t, int64(1), resp.Total, "M-2：MEMBER 只能看到自己一个产品")
+	assert.Equal(t, int64(1), resp.Total, "MEMBER 只能看到自己一个产品")
 	items, ok := resp.List.([]types.ProductItem)
 	require.True(t, ok, "resp.List 必须是 []types.ProductItem")
 	require.Len(t, items, 1)
 	item := items[0]
 	assert.Equal(t, "pA", item.Code)
 	assert.Empty(t, item.AppKey,
-		"M-2：非超管路径下 AppKey 必须保持脱敏，不得泄露")
+		"非超管路径下 AppKey 必须保持脱敏，不得泄露")
 }
 
 // TC-0851: MEMBER 调 ProductList 但 ProductCode=="" —— 返回空列表，不访问 DB。
@@ -115,9 +115,9 @@ func TestProductDetail_Member_OtherProduct_Returns404(t *testing.T) {
 	require.Error(t, err)
 
 	ce, ok := err.(*response.CodeError)
-	require.True(t, ok, "M-2：应返回 response.CodeError")
+	require.True(t, ok, "应返回 response.CodeError")
 	assert.Equal(t, 404, ce.Code(),
-		"M-2：非超管查他产品必须 404，而不是 403/200，避免被用作存在性 oracle")
+		"非超管查他产品必须 404，而不是 403/200，避免被用作存在性 oracle")
 }
 
 // TC-0853: MEMBER 查自己产品详情 —— 200 OK，但 AppKey 必须为空。
@@ -136,7 +136,7 @@ func TestProductDetail_Member_OwnProduct_AppKeyHidden(t *testing.T) {
 	require.NotNil(t, resp)
 	assert.Equal(t, "pA", resp.Code)
 	assert.Empty(t, resp.AppKey,
-		"M-2：自己产品也不应看到 AppKey（M-2 不取消 AppKey 脱敏）")
+		"自己产品也不应看到 AppKey（不取消 AppKey 脱敏）")
 }
 
 // TC-0854: 超管查任何产品详情都能看到 AppKey。
@@ -185,7 +185,7 @@ func TestProductList_SuperAdmin_AppKeyVisibleAndFindListCalled(t *testing.T) {
 	require.True(t, ok)
 	require.Len(t, items, 2)
 	// 关键 2：超管路径下 AppKey 不脱敏（与 TC-0850/TC-0853 的 MEMBER 路径形成互为镜像的契约）。
-	assert.Equal(t, "AK-A", items[0].AppKey, "M-2：超管必须看到 AppKey 以便管理产品集成")
+	assert.Equal(t, "AK-A", items[0].AppKey, "超管必须看到 AppKey 以便管理产品集成")
 	assert.Equal(t, "AK-B", items[1].AppKey)
 }
 
@@ -211,5 +211,5 @@ func TestProductDetail_FindOneError_MapsTo404(t *testing.T) {
 	require.True(t, ok, "必须是 response.CodeError")
 	assert.Equal(t, 404, ce.Code())
 	assert.Equal(t, "产品不存在", ce.Error(),
-		"M-2：FindOne 失败与'别人的产品'都返回同一份 404 文案，避免被用作存在性 oracle")
+		"FindOne 失败与'别人的产品'都返回同一份 404 文案，避免被用作存在性 oracle")
 }

internal/logic/product/updateProductLogic_test.go

@@ -128,7 +128,7 @@ func TestUpdateProduct_NonSuperAdminRejected(t *testing.T) {
 	assert.Equal(t, 403, ce.Code())
 }
 
-// TC-0090: updateProduct 非法状态值被拒绝(H-4修复验证)
+// TC-0090: updateProduct 非法状态值被拒绝(修复验证)
 func TestUpdateProduct_InvalidStatusRejected(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())

internal/logic/pub/adminLoginIpLimit_audit_test.go

@@ -1,144 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/limit"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 H-1 修复回归 —— AdminLogin 限流按 `admin:<clientIP>:<username>` 双维。
-//
-// H-1 攻击：攻击者只靠已知或枚举出的超管用户名 `admin_<productCode>`，从任意远端 IP 连打
-// 错误密码 → 触发 5 分钟封禁 → 合法超管任何 IP 都无法登录。修复后 key 上挂 clientIP：
-// 换 IP 的远端不继承上一桶计数，合法用户自身 IP 仍能进入。
-// ---------------------------------------------------------------------------
-
-// newAdminLimitSvcCtx 构造一个挂了独立 UsernameLoginLimit (quota=1) 的 svcCtx，
-// 避免测试之间的限流状态串扰。返回的 svcCtx 可直接传给 NewAdminLoginLogic。
-func newAdminLimitSvcCtx(t *testing.T, quota int) *svc.ServiceContext {
-	t.Helper()
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx := newTestSvcCtx()
-	svcCtx.UsernameLoginLimit = limit.NewPeriodLimit(300, quota, rds,
-		cfg.CacheRedis.KeyPrefix+":rl:adminlogin:ut:"+testutil.UniqueId())
-	return svcCtx
-}
-
-// TC-0834: 同 IP + 同 username 超过 quota 必须 429，文案为新版本。
-func TestAdminLogin_H1_SameIPSameUsername_OverQuota429(t *testing.T) {
-	svcCtx := newAdminLimitSvcCtx(t, 1)
-	username := "h1_user_" + testutil.UniqueId()
-	ctx := middleware.WithClientIP(context.Background(), "1.2.3.4")
-	req := &types.AdminLoginReq{
-		Username:      username,
-		Password:      "bad",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	}
-
-	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code(), "首次调用应被限流放行并进入业务层，得到 401")
-
-	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code(), "同 IP+同 username 第二次必须 429")
-	assert.Equal(t, "登录尝试过于频繁，请5分钟后再试", ce.Error())
-}
-
-// TC-0835: 同 username 换远端 IP 不得继承配额。
-func TestAdminLogin_H1_DifferentIPSameUsername_IndependentBucket(t *testing.T) {
-	svcCtx := newAdminLimitSvcCtx(t, 1)
-	username := "h1_iso_" + testutil.UniqueId()
-	req := &types.AdminLoginReq{
-		Username:      username,
-		Password:      "bad",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	}
-
-	ctxA := middleware.WithClientIP(context.Background(), "10.0.0.1")
-	_, err := NewAdminLoginLogic(ctxA, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code())
-
-	_, err = NewAdminLoginLogic(ctxA, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code(), "IP-A 配额已满")
-
-	ctxB := middleware.WithClientIP(context.Background(), "10.0.0.2")
-	_, err = NewAdminLoginLogic(ctxB, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code(),
-		"H-1 修复：换远端 IP 必须命中独立限流桶，不能被同 username 的旧计数拖连")
-}
-
-// TC-0836: ctx 里无 clientIP —— 退化为 "unknown" 共享桶，仍能限流，不得绕过。
-func TestAdminLogin_H1_MissingClientIP_FallbackBucket(t *testing.T) {
-	svcCtx := newAdminLimitSvcCtx(t, 1)
-	username := "h1_unk_" + testutil.UniqueId()
-	req := &types.AdminLoginReq{
-		Username:      username,
-		Password:      "bad",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	}
-	ctx := context.Background()
-
-	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code())
-
-	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
-	require.Error(t, err)
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code(),
-		"无 clientIP 时应该退化到 'unknown' 桶继续限流，严禁直接绕过")
-}
-
-// TC-0837: managementKey 错误路径不消耗 username quota（Take 顺序冻结）。
-func TestAdminLogin_H1_BadManagementKey_DoesNotConsumeQuota(t *testing.T) {
-	svcCtx := newAdminLimitSvcCtx(t, 1)
-	username := "h1_mk_" + testutil.UniqueId()
-	ctx := middleware.WithClientIP(context.Background(), "172.16.0.9")
-
-	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
-		Username:      username,
-		Password:      "whatever",
-		ManagementKey: "WRONG-KEY",
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code())
-	assert.Equal(t, "managementKey无效", ce.Error())
-
-	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
-		Username:      username,
-		Password:      "whatever",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	})
-	require.Error(t, err)
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code(),
-		"H-1 顺序：managementKey 错误应在 Take 之前 return，不应消耗 per-IP+user 配额")
-}

internal/logic/pub/adminLoginLogic_test.go

@@ -3,18 +3,19 @@ package pub
 import (
 	"context"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/limit"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"perms-system-server/internal/middleware"
 	"perms-system-server/internal/response"
+	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
-// TC-0015: 超管正常登录(管理后台)
 func TestAdminLogin_SuperAdmin(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := newTestSvcCtx()
@@ -41,7 +42,7 @@ func TestAdminLogin_SuperAdmin(t *testing.T) {
 	assert.Equal(t, "SUPER_ADMIN", resp.UserInfo.MemberType)
 }
 
-// TC-0016: 普通用户被拒绝(审计H1修复: 仅超管可通过管理后台登录)
+// TC-0016: 普通用户被拒绝(1修复: 仅超管可通过管理后台登录)
 func TestAdminLogin_NormalUserRejected(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := newTestSvcCtx()
@@ -197,7 +198,7 @@ func TestAdminLogin_NoPermsWithoutProductCode(t *testing.T) {
 	assert.Equal(t, "SUPER_ADMIN", resp.UserInfo.MemberType, "超管即使不传productCode也会被标记SUPER_ADMIN")
 }
 
-// TC-0025: adminLogin 用户名级别限流(H-2修复验证)
+// TC-0025: adminLogin 用户名级别限流(修复验证)
 func TestAdminLogin_UsernameRateLimit(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := newTestSvcCtx()
@@ -239,3 +240,236 @@ func TestAdminLogin_SQLInjection(t *testing.T) {
 	assert.Equal(t, 401, codeErr.Code())
 	assert.Equal(t, "用户名或密码错误", codeErr.Error())
 }
+
+func newAdminLimitSvcCtx(t *testing.T, quota int) *svc.ServiceContext {
+	t.Helper()
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx := newTestSvcCtx()
+	svcCtx.UsernameLoginLimit = limit.NewPeriodLimit(300, quota, rds,
+		cfg.CacheRedis.KeyPrefix+":rl:adminlogin:ut:"+testutil.UniqueId())
+	return svcCtx
+}
+
+// TC-0834: 同 IP + 同 username 超过 quota 必须 429，文案为新版本。
+func TestAdminLogin_H1_SameIPSameUsername_OverQuota429(t *testing.T) {
+	svcCtx := newAdminLimitSvcCtx(t, 1)
+	username := "h1_user_" + testutil.UniqueId()
+	ctx := middleware.WithClientIP(context.Background(), "1.2.3.4")
+	req := &types.AdminLoginReq{
+		Username:      username,
+		Password:      "bad",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	}
+
+	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code(), "首次调用应被限流放行并进入业务层，得到 401")
+
+	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code(), "同 IP+同 username 第二次必须 429")
+	assert.Equal(t, "登录尝试过于频繁，请5分钟后再试", ce.Error())
+}
+
+// TC-0835: 同 username 换远端 IP 不得继承配额。
+func TestAdminLogin_H1_DifferentIPSameUsername_IndependentBucket(t *testing.T) {
+	svcCtx := newAdminLimitSvcCtx(t, 1)
+	username := "h1_iso_" + testutil.UniqueId()
+	req := &types.AdminLoginReq{
+		Username:      username,
+		Password:      "bad",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	}
+
+	ctxA := middleware.WithClientIP(context.Background(), "10.0.0.1")
+	_, err := NewAdminLoginLogic(ctxA, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code())
+
+	_, err = NewAdminLoginLogic(ctxA, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code(), "IP-A 配额已满")
+
+	ctxB := middleware.WithClientIP(context.Background(), "10.0.0.2")
+	_, err = NewAdminLoginLogic(ctxB, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code(),
+		"换远端 IP 必须命中独立限流桶，不能被同 username 的旧计数拖连")
+}
+
+// TC-0836: ctx 里无 clientIP —— 退化为 "unknown" 共享桶，仍能限流，不得绕过。
+func TestAdminLogin_H1_MissingClientIP_FallbackBucket(t *testing.T) {
+	svcCtx := newAdminLimitSvcCtx(t, 1)
+	username := "h1_unk_" + testutil.UniqueId()
+	req := &types.AdminLoginReq{
+		Username:      username,
+		Password:      "bad",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	}
+	ctx := context.Background()
+
+	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code())
+
+	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(req)
+	require.Error(t, err)
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code(),
+		"无 clientIP 时应该退化到 'unknown' 桶继续限流，严禁直接绕过")
+}
+
+// TC-0837: managementKey 错误路径不消耗 username quota（Take 顺序冻结）。
+func TestAdminLogin_H1_BadManagementKey_DoesNotConsumeQuota(t *testing.T) {
+	svcCtx := newAdminLimitSvcCtx(t, 1)
+	username := "h1_mk_" + testutil.UniqueId()
+	ctx := middleware.WithClientIP(context.Background(), "172.16.0.9")
+
+	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
+		Username:      username,
+		Password:      "whatever",
+		ManagementKey: "WRONG-KEY",
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code())
+	assert.Equal(t, "managementKey无效", ce.Error())
+
+	_, err = NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
+		Username:      username,
+		Password:      "whatever",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	})
+	require.Error(t, err)
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code(),
+		"managementKey 错误应在 Take 之前 return，不应消耗 per-IP+user 配额")
+}
+
+func TestAdminLogin_LN3_NonSuperAdminWrongPassword_IndistinguishableFromAbsent(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.UsernameLoginLimit = nil
+
+	username := "ln3_nonsa_" + testutil.UniqueId()
+	// status=1（启用），isSuperAdmin=2（普通用户）
+	_, clean := insertTestUser(t, ctx, svcCtx, username, "RightPass123", 1, 2)
+	t.Cleanup(clean)
+
+	logic := NewAdminLoginLogic(ctx, svcCtx)
+
+	// (B) 用户存在但非超管 —— 走  新增的 dummy bcrypt 分支
+	_, errExisting := logic.AdminLogin(&types.AdminLoginReq{
+		Username:      username,
+		Password:      "WrongPass",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	})
+	require.Error(t, errExisting)
+	var ceB *response.CodeError
+	require.True(t, errors.As(errExisting, &ceB))
+
+	// (A) 用户不存在 —— 原有 dummy bcrypt 分支
+	_, errAbsent := logic.AdminLogin(&types.AdminLoginReq{
+		Username:      "ln3_absent_" + testutil.UniqueId(),
+		Password:      "WhateverPass",
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	})
+	require.Error(t, errAbsent)
+	var ceA *response.CodeError
+	require.True(t, errors.As(errAbsent, &ceA))
+
+	assert.Equal(t, ceA.Code(), ceB.Code(),
+		"'非超管 + 错误密码' 与 '用户不存在' 必须返回相同 code")
+	assert.Equal(t, ceA.Error(), ceB.Error(),
+		"'非超管 + 错误密码' 与 '用户不存在' 必须返回相同 body")
+	assert.Equal(t, "用户名或密码错误", ceB.Error())
+}
+
+// TC-1009: 非超管账号 + 任意密码（包括正确密码）都必须 401，且仍触发一次 bcrypt，
+// 保证即使攻击者命中密码，也不得通过 response 推断该账号是"存在的普通用户"。
+func TestAdminLogin_LN3_NonSuperAdminCorrectPassword_Still401(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.UsernameLoginLimit = nil
+
+	username := "ln3_cp_" + testutil.UniqueId()
+	password := "KnownPass123"
+	_, clean := insertTestUser(t, ctx, svcCtx, username, password, 1, 2)
+	t.Cleanup(clean)
+
+	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
+		Username:      username,
+		Password:      password,
+		ManagementKey: svcCtx.Config.Auth.ManagementKey,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code(),
+		"非超管走 AdminLogin 一律 401，即使密码正确也不得披露账号存在性")
+	assert.Equal(t, "用户名或密码错误", ce.Error())
+}
+
+// TC-1010:  时序等齐 —— "非超管 + 错密码" 必须与 "用户不存在" 同阶（两者都走一次 dummyBcryptHash）。
+//
+// 注意：测试环境里通过 testutil.HashPassword 生成真实用户的 bcrypt 哈希时使用了 MinCost（cost=4）
+// 以提速；而生产代码里的 dummyBcryptHash 固定用 DefaultCost（cost=10）。因此"超管 + 错密码"走
+// 真 bcrypt(cost=4) 会显著快于两条 dummy 分支，这里无法把 SA+wrong 的耗时纳入对比。
+// 本 TC 只对比两条 dummy 分支——它们共用同一份 dummyBcryptHash，理应严格齐平（2× 以内）。
+// 若非超管分支被回退到"不走 dummy bcrypt"，dNonSa 会突然下降一个数量级，ratio 会突破 5× 触发 FAIL。
+func TestAdminLogin_LN3_DummyBcryptBranches_TimingEqualized(t *testing.T) {
+	if testing.Short() {
+		t.Skip("timing-sensitive test skipped under -short")
+	}
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.UsernameLoginLimit = nil
+
+	normalUser := "ln3_t_nm_" + testutil.UniqueId()
+	_, cleanNm := insertTestUser(t, ctx, svcCtx, normalUser, "RealNormalPass123", 1, 2)
+	t.Cleanup(cleanNm)
+
+	logic := NewAdminLoginLogic(ctx, svcCtx)
+	mk := svcCtx.Config.Auth.ManagementKey
+
+	measure := func(username, password string) time.Duration {
+		_, _ = logic.AdminLogin(&types.AdminLoginReq{Username: username, Password: password, ManagementKey: mk})
+		const N = 3
+		var total time.Duration
+		for i := 0; i < N; i++ {
+			start := time.Now()
+			_, _ = logic.AdminLogin(&types.AdminLoginReq{Username: username, Password: password, ManagementKey: mk})
+			total += time.Since(start)
+		}
+		return total / N
+	}
+
+	dAbsent := measure("ln3_absent_"+testutil.UniqueId(), "xx")
+	dNonSa := measure(normalUser, "WrongPass")
+
+	t.Logf("dummy bcrypt timing: absent=%v nonSa=%v", dAbsent, dNonSa)
+
+	ratio := func(a, b time.Duration) float64 {
+		if b <= 0 {
+			return 0
+		}
+		if a > b {
+			return float64(a) / float64(b)
+		}
+		return float64(b) / float64(a)
+	}
+	const tol = 3.0 // CI 抖动容忍
+	assert.Less(t, ratio(dNonSa, dAbsent), tol,
+		"'非超管 + 错密码' 必须与 '用户不存在' 耗时同阶；若 >3× 说明 L-N3 被回退（非超管分支没走 dummy bcrypt）")
+}

internal/logic/pub/adminLoginTiming_audit_test.go

@@ -1,145 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-N3 修复 —— AdminLogin 在 IsSuperAdmin 分支也必须强制走一次 dummy bcrypt，
-// 保证三条错误分支的耗时近似齐平，关闭"靠耗时差筛超管账号"的时序 oracle。
-// 分支：
-//   (A) 用户不存在 → dummy bcrypt → 401
-//   (B) 用户存在但非超管 → dummy bcrypt → 401     （L-N3 关键修复）
-//   (C) 用户存在且是超管但密码错 → 真 bcrypt → 401
-//
-// 三条路径的错误响应（code + body）必须 **完全一致**；耗时必须处于同一数量级
-// （均经过一次 bcrypt）。
-// ---------------------------------------------------------------------------
-
-// TC-1008: L-N3 —— 非超管账号 + 错误密码 必须和"用户不存在"返回完全相同的 401 body。
-func TestAdminLogin_LN3_NonSuperAdminWrongPassword_IndistinguishableFromAbsent(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.UsernameLoginLimit = nil
-
-	username := "ln3_nonsa_" + testutil.UniqueId()
-	// status=1（启用），isSuperAdmin=2（普通用户）
-	_, clean := insertTestUser(t, ctx, svcCtx, username, "RightPass123", 1, 2)
-	t.Cleanup(clean)
-
-	logic := NewAdminLoginLogic(ctx, svcCtx)
-
-	// (B) 用户存在但非超管 —— 走 L-N3 新增的 dummy bcrypt 分支
-	_, errExisting := logic.AdminLogin(&types.AdminLoginReq{
-		Username:      username,
-		Password:      "WrongPass",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	})
-	require.Error(t, errExisting)
-	var ceB *response.CodeError
-	require.True(t, errors.As(errExisting, &ceB))
-
-	// (A) 用户不存在 —— 原有 dummy bcrypt 分支
-	_, errAbsent := logic.AdminLogin(&types.AdminLoginReq{
-		Username:      "ln3_absent_" + testutil.UniqueId(),
-		Password:      "WhateverPass",
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	})
-	require.Error(t, errAbsent)
-	var ceA *response.CodeError
-	require.True(t, errors.As(errAbsent, &ceA))
-
-	assert.Equal(t, ceA.Code(), ceB.Code(),
-		"L-N3：'非超管 + 错误密码' 与 '用户不存在' 必须返回相同 code")
-	assert.Equal(t, ceA.Error(), ceB.Error(),
-		"L-N3：'非超管 + 错误密码' 与 '用户不存在' 必须返回相同 body")
-	assert.Equal(t, "用户名或密码错误", ceB.Error())
-}
-
-// TC-1009: L-N3 —— 非超管账号 + 任意密码（包括正确密码）都必须 401，且仍触发一次 bcrypt，
-// 保证即使攻击者命中密码，也不得通过 response 推断该账号是"存在的普通用户"。
-func TestAdminLogin_LN3_NonSuperAdminCorrectPassword_Still401(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.UsernameLoginLimit = nil
-
-	username := "ln3_cp_" + testutil.UniqueId()
-	password := "KnownPass123"
-	_, clean := insertTestUser(t, ctx, svcCtx, username, password, 1, 2)
-	t.Cleanup(clean)
-
-	_, err := NewAdminLoginLogic(ctx, svcCtx).AdminLogin(&types.AdminLoginReq{
-		Username:      username,
-		Password:      password,
-		ManagementKey: svcCtx.Config.Auth.ManagementKey,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code(),
-		"L-N3：非超管走 AdminLogin 一律 401，即使密码正确也不得披露账号存在性")
-	assert.Equal(t, "用户名或密码错误", ce.Error())
-}
-
-// TC-1010: L-N3 时序等齐 —— "非超管 + 错密码" 必须与 "用户不存在" 同阶（两者都走一次 dummyBcryptHash）。
-//
-// 注意：测试环境里通过 testutil.HashPassword 生成真实用户的 bcrypt 哈希时使用了 MinCost（cost=4）
-// 以提速；而生产代码里的 dummyBcryptHash 固定用 DefaultCost（cost=10）。因此"超管 + 错密码"走
-// 真 bcrypt(cost=4) 会显著快于两条 dummy 分支，这里无法把 SA+wrong 的耗时纳入对比。
-// 本 TC 只对比两条 dummy 分支——它们共用同一份 dummyBcryptHash，理应严格齐平（2× 以内）。
-// 若非超管分支被回退到"不走 dummy bcrypt"，dNonSa 会突然下降一个数量级，ratio 会突破 5× 触发 FAIL。
-func TestAdminLogin_LN3_DummyBcryptBranches_TimingEqualized(t *testing.T) {
-	if testing.Short() {
-		t.Skip("timing-sensitive test skipped under -short")
-	}
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.UsernameLoginLimit = nil
-
-	normalUser := "ln3_t_nm_" + testutil.UniqueId()
-	_, cleanNm := insertTestUser(t, ctx, svcCtx, normalUser, "RealNormalPass123", 1, 2)
-	t.Cleanup(cleanNm)
-
-	logic := NewAdminLoginLogic(ctx, svcCtx)
-	mk := svcCtx.Config.Auth.ManagementKey
-
-	measure := func(username, password string) time.Duration {
-		_, _ = logic.AdminLogin(&types.AdminLoginReq{Username: username, Password: password, ManagementKey: mk})
-		const N = 3
-		var total time.Duration
-		for i := 0; i < N; i++ {
-			start := time.Now()
-			_, _ = logic.AdminLogin(&types.AdminLoginReq{Username: username, Password: password, ManagementKey: mk})
-			total += time.Since(start)
-		}
-		return total / N
-	}
-
-	dAbsent := measure("ln3_absent_"+testutil.UniqueId(), "xx")
-	dNonSa := measure(normalUser, "WrongPass")
-
-	t.Logf("L-N3 dummy bcrypt timing: absent=%v nonSa=%v", dAbsent, dNonSa)
-
-	ratio := func(a, b time.Duration) float64 {
-		if b <= 0 {
-			return 0
-		}
-		if a > b {
-			return float64(a) / float64(b)
-		}
-		return float64(b) / float64(a)
-	}
-	const tol = 3.0 // CI 抖动容忍
-	assert.Less(t, ratio(dNonSa, dAbsent), tol,
-		"L-N3：'非超管 + 错密码' 必须与 '用户不存在' 耗时同阶；若 >3× 说明 L-N3 被回退（非超管分支没走 dummy bcrypt）")
-}

internal/logic/pub/loginLogic_test.go

@@ -298,7 +298,7 @@ func TestLogin_NonMemberWithProductCode(t *testing.T) {
 	var codeErr *response.CodeError
 	require.True(t, errors.As(err, &codeErr))
 	assert.Equal(t, 403, codeErr.Code())
-	// 审计 M-R10-5：loginService 去除重复 FindOneByProductCodeUserId，所有非成员/禁用成员分支合并
+	// loginService 去除重复 FindOneByProductCodeUserId，所有非成员/禁用成员分支合并
 	assert.Equal(t, "您不是该产品的有效成员", codeErr.Error())
 }
 
@@ -364,7 +364,7 @@ func TestLogin_SQLInjection(t *testing.T) {
 	assert.Equal(t, "用户名或密码错误", codeErr.Error())
 }
 
-// TC-0013: 产品成员被禁用时拒绝登录(H-3修复验证)
+// TC-0013: 产品成员被禁用时拒绝登录(修复验证)
 func TestLogin_DisabledMemberRejected(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := newTestSvcCtx()
@@ -399,7 +399,7 @@ func TestLogin_DisabledMemberRejected(t *testing.T) {
 	var codeErr2 *response.CodeError
 	require.True(t, errors.As(err, &codeErr2))
 	assert.Equal(t, 403, codeErr2.Code())
-	// 审计 M-R10-5：禁用成员在 loadMembership 阶段即被清空 MemberType，与"非成员"文案合并
+	// 禁用成员在 loadMembership 阶段即被清空 MemberType，与"非成员"文案合并
 	assert.Equal(t, "您不是该产品的有效成员", codeErr2.Error())
 }
 

internal/logic/pub/loginService_enum_audit_test.go

@@ -1,85 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/limit"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-// TC-0751: M-C 修复回归 —— 对不存在的用户名也执行 dummy bcrypt 比对，
-// 响应文案与"存在用户但密码错"一致，避免用户名枚举。
-func TestValidateProductLogin_UnknownUserSameError(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	username := "enum_unknown_" + testutil.UniqueId()
-
-	_, err := ValidateProductLogin(ctx, svcCtx, username, "random-pw", "test_product", "127.0.0.1")
-	require.Error(t, err)
-
-	var le *LoginError
-	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 401, le.Code)
-	assert.Equal(t, "用户名或密码错误", le.Message,
-		"M-C：不存在用户名不得暴露差异化文案")
-}
-
-// TC-0752: M-C 修复回归 —— 存在用户名但密码错，返回相同文案相同 code，供与 TC-0751 做对照。
-func TestValidateProductLogin_KnownUserWrongPwd(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	username := "enum_known_" + testutil.UniqueId()
-
-	userId, cleanUser := insertRefreshTestUser(t, ctx, username, "RightPass123", 1, 2)
-	t.Cleanup(cleanUser)
-	_ = userId
-
-	_, err := ValidateProductLogin(ctx, svcCtx, username, "wrong-pw", "test_product", "127.0.0.1")
-	require.Error(t, err)
-
-	var le *LoginError
-	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 401, le.Code, "M-C：Code 必须与未知用户完全一致")
-	assert.Equal(t, "用户名或密码错误", le.Message, "M-C：文案必须与未知用户完全一致")
-}
-
-// TC-0753: M-C 修复回归 —— UsernameLoginLimit 的 key 必须按 ip:username 构造。
-// 同一 username 不同 IP 的配额互不共用，防止攻击者"用任意 IP 打爆某账号"导致账号 DoS。
-func TestValidateProductLogin_RateLimitKeyedByIPAndUsername(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-
-	// 使用独立的 quota=1 limiter
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx.UsernameLoginLimit = limit.NewPeriodLimit(300, 1, rds,
-		cfg.CacheRedis.KeyPrefix+":rl:userlogin:ut:"+testutil.UniqueId())
-
-	username := "enum_rl_" + testutil.UniqueId()
-
-	// IP-A 第 1 次："用户名或密码错误"
-	_, err := ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "1.1.1.1")
-	require.Error(t, err)
-	var le *LoginError
-	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 401, le.Code)
-
-	// IP-A 第 2 次：超限 429
-	_, err = ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "1.1.1.1")
-	require.Error(t, err)
-	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 429, le.Code, "M-C：同 IP 同 username 第 2 次必须触发 429")
-
-	// IP-B 第 1 次：独立桶，仍应走到密码校验（不是 429）
-	_, err = ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "2.2.2.2")
-	require.Error(t, err)
-	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 401, le.Code,
-		"M-C：不同 IP 的同 username 必须走独立限流桶（不是 429）")
-}

internal/logic/pub/loginServiceConstantTime_audit_test.go → internal/logic/pub/loginService_test.go

@@ -3,29 +3,14 @@ package pub
 import (
 	"context"
 	"errors"
-	"testing"
-
-	"perms-system-server/internal/testutil"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/limit"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"perms-system-server/internal/testutil"
+	"testing"
 )
 
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 H-2 修复回归。
-//
-// H-2 的本质：`ValidateProductLogin` 里"账号冻结"、"是超管"、"用户不存在"三条
-// 错误路径在修复前存在 **耗时 + 错误消息 + HTTP code** 三重差异，构成
-// 账号存在性 / 状态 oracle。修复后：
-//   - bcrypt 无条件执行（dummy hash 对齐耗时）
-//   - 只有密码正确之后才披露"冻结"/"超管"语义
-//   - 用户名不存在 / 存在但密码错 / 存在但冻结且密码错 → 统一 401 "用户名或密码错误"
-//
-// 这些用例把上面契约全部钉死：任何一条被回退到"先检查 status 再 bcrypt"的旧路径，
-// 对应 TC 立刻 FAIL。
-// ---------------------------------------------------------------------------
-
-// TC-0838: 冻结用户 + 错误密码 —— 必须返回 401 "用户名或密码错误"，禁止泄露冻结态。
 func TestValidateProductLogin_FrozenWrongPassword_Return401(t *testing.T) {
 	ctx := context.Background()
 	svcCtx := newTestSvcCtx()
@@ -42,9 +27,9 @@ func TestValidateProductLogin_FrozenWrongPassword_Return401(t *testing.T) {
 	var le *LoginError
 	require.True(t, errors.As(err, &le))
 	assert.Equal(t, 401, le.Code,
-		"H-2：冻结用户 + 错误密码不得返回 403；必须 401 与'用户不存在/密码错'三合一")
+		"冻结用户 + 错误密码不得返回 403；必须 401 与'用户不存在/密码错'三合一")
 	assert.Equal(t, "用户名或密码错误", le.Message,
-		"H-2：文案不得泄露冻结态")
+		"文案不得泄露冻结态")
 }
 
 // TC-0839: 冻结用户 + 正确密码 —— 此时才允许披露"账号已被冻结"（攻击者已经猜中密码，继续隐藏已无意义）。
@@ -62,7 +47,7 @@ func TestValidateProductLogin_FrozenCorrectPassword_Return403(t *testing.T) {
 
 	var le *LoginError
 	require.True(t, errors.As(err, &le))
-	assert.Equal(t, 403, le.Code, "H-2：密码正确后的冻结分支仍走 403 披露")
+	assert.Equal(t, 403, le.Code, "密码正确后的冻结分支仍走 403 披露")
 	assert.Equal(t, "账号已被冻结", le.Message)
 }
 
@@ -83,7 +68,7 @@ func TestValidateProductLogin_SuperAdminWrongPassword_Return401(t *testing.T) {
 	var le *LoginError
 	require.True(t, errors.As(err, &le))
 	assert.Equal(t, 401, le.Code,
-		"H-2：超管 + 错误密码必须归一到 401'用户名或密码错误'，不得提前披露超管身份")
+		"超管 + 错误密码必须归一到 401'用户名或密码错误'，不得提前披露超管身份")
 	assert.Equal(t, "用户名或密码错误", le.Message)
 }
 
@@ -120,5 +105,74 @@ func TestValidateProductLogin_UnknownUserSame401(t *testing.T) {
 	require.True(t, errors.As(err, &le))
 	assert.Equal(t, 401, le.Code)
 	assert.Equal(t, "用户名或密码错误", le.Message,
-		"H-2：未知用户 / 冻结+错密 / 存在+错密 三路必须归一为同一 401 + 文案")
+		"未知用户 / 冻结+错密 / 存在+错密 三路必须归一为同一 401 + 文案")
+}
+
+func TestValidateProductLogin_UnknownUserSameError(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	username := "enum_unknown_" + testutil.UniqueId()
+
+	_, err := ValidateProductLogin(ctx, svcCtx, username, "random-pw", "test_product", "127.0.0.1")
+	require.Error(t, err)
+
+	var le *LoginError
+	require.True(t, errors.As(err, &le))
+	assert.Equal(t, 401, le.Code)
+	assert.Equal(t, "用户名或密码错误", le.Message,
+		"M-C：不存在用户名不得暴露差异化文案")
+}
+
+// TC-0752: -C 修复回归 —— 存在用户名但密码错，返回相同文案相同 code，供与 TC-0751 做对照。
+func TestValidateProductLogin_KnownUserWrongPwd(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	username := "enum_known_" + testutil.UniqueId()
+
+	userId, cleanUser := insertRefreshTestUser(t, ctx, username, "RightPass123", 1, 2)
+	t.Cleanup(cleanUser)
+	_ = userId
+
+	_, err := ValidateProductLogin(ctx, svcCtx, username, "wrong-pw", "test_product", "127.0.0.1")
+	require.Error(t, err)
+
+	var le *LoginError
+	require.True(t, errors.As(err, &le))
+	assert.Equal(t, 401, le.Code, "M-C：Code 必须与未知用户完全一致")
+	assert.Equal(t, "用户名或密码错误", le.Message, "M-C：文案必须与未知用户完全一致")
+}
+
+// TC-0753: -C 修复回归 —— UsernameLoginLimit 的 key 必须按 ip:username 构造。
+// 同一 username 不同 IP 的配额互不共用，防止攻击者"用任意 IP 打爆某账号"导致账号 DoS。
+func TestValidateProductLogin_RateLimitKeyedByIPAndUsername(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+
+	// 使用独立的 quota=1 limiter
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx.UsernameLoginLimit = limit.NewPeriodLimit(300, 1, rds,
+		cfg.CacheRedis.KeyPrefix+":rl:userlogin:ut:"+testutil.UniqueId())
+
+	username := "enum_rl_" + testutil.UniqueId()
+
+	// IP-A 第 1 次："用户名或密码错误"
+	_, err := ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "1.1.1.1")
+	require.Error(t, err)
+	var le *LoginError
+	require.True(t, errors.As(err, &le))
+	assert.Equal(t, 401, le.Code)
+
+	// IP-A 第 2 次：超限 429
+	_, err = ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "1.1.1.1")
+	require.Error(t, err)
+	require.True(t, errors.As(err, &le))
+	assert.Equal(t, 429, le.Code, "M-C：同 IP 同 username 第 2 次必须触发 429")
+
+	// IP-B 第 1 次：独立桶，仍应走到密码校验（不是 429）
+	_, err = ValidateProductLogin(ctx, svcCtx, username, "x", "test_product", "2.2.2.2")
+	require.Error(t, err)
+	require.True(t, errors.As(err, &le))
+	assert.Equal(t, 401, le.Code,
+		"M-C：不同 IP 的同 username 必须走独立限流桶（不是 429）")
 }

internal/logic/pub/refreshTokenCas_audit_test.go

@@ -1,97 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	authHelper "perms-system-server/internal/logic/auth"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-1 修复的 logic 层回归 —— 在 logic 里用 CAS 递增 tokenVersion。
-// 该文件聚焦"并发 refresh 同一旧令牌时的行为"：
-//   1) N 个并发 RefreshToken 共用同一把 claims.TokenVersion=0 的 refreshToken，
-//      必须恰好 1 个返回成功；其余 N-1 个被 401 拒绝（字样必为"登录状态已失效"）。
-//   2) DB 的 tokenVersion 最终只能递增 1；
-//   3) 明确 CAS 失败时返回的 401 错误是通过 ErrTokenVersionMismatch 路径产出，
-//      与"账号冻结"等 403 分支互不混用。
-// ---------------------------------------------------------------------------
-
-// TC-0812: H-1 logic 并发回归 —— 并发重放同一个旧 refreshToken，只允许一位胜出。
-func TestRefreshToken_ConcurrentSameToken_SingleWinner(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	username := "rt_cas_" + testutil.UniqueId()
-
-	userId, cleanUser := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
-	t.Cleanup(cleanUser)
-
-	// 禁用 TokenOpLimiter，以让本测试的变量只剩"并发 CAS 胜负"。
-	svcCtx.TokenOpLimiter = nil
-
-	rt, err := authHelper.GenerateRefreshToken(
-		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-		userId, "", 0,
-	)
-	require.NoError(t, err)
-
-	// 限制在 6 并发以避免触发 go-zero sqlx breaker（单机 MySQL + breaker 对同批次突发
-	// 的并发 UPDATE 容易误伤，生产里 refreshToken 也是 per-user 限频 + CAS 双层保护，
-	// 没机会打成这么高的并发）。CAS "唯一胜出" 的契约在 N=6 时已足以钉死。
-	const N = 6
-	var (
-		wg          sync.WaitGroup
-		okCount     int32
-		authFailCnt int32
-		otherErr    atomic.Value
-	)
-	start := make(chan struct{})
-	for i := 0; i < N; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			<-start
-			resp, e := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-				Authorization: "Bearer " + rt,
-			})
-			switch {
-			case e == nil && resp != nil:
-				atomic.AddInt32(&okCount, 1)
-			case e != nil:
-				var ce *response.CodeError
-				if errors.As(e, &ce) && ce.Code() == 401 &&
-					ce.Error() == "登录状态已失效，请重新登录" {
-					atomic.AddInt32(&authFailCnt, 1)
-				} else {
-					otherErr.Store(e)
-				}
-			}
-		}()
-	}
-	close(start)
-	wg.Wait()
-
-	if v := otherErr.Load(); v != nil {
-		t.Fatalf("并发 RefreshToken 出现非预期错误：%v", v)
-	}
-
-	assert.Equal(t, int32(1), atomic.LoadInt32(&okCount),
-		"H-1 会话劫持防线：重放同一旧 refreshToken 的 N 个并发请求必须只有 1 个成功")
-	assert.Equal(t, int32(N-1), atomic.LoadInt32(&authFailCnt),
-		"其他并发者必须返回 401 '登录状态已失效'")
-
-	// DB 必然只递增 1。
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(1), u.TokenVersion,
-		"DB tokenVersion 递增幅度就是 CAS 成功次数 → 只能是 1")
-}

internal/logic/pub/refreshTokenLogic_test.go

@@ -4,19 +4,22 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/limit"
+	"github.com/zeromicro/go-zero/core/stores/redis"
 	authHelper "perms-system-server/internal/logic/auth"
+	"perms-system-server/internal/middleware"
 	permModel "perms-system-server/internal/model/perm"
 	productmemberModel "perms-system-server/internal/model/productmember"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
 )
 
 func insertRefreshTestUser(t *testing.T, ctx context.Context, username, password string, status, isSuperAdmin int64) (int64, func()) {
@@ -145,7 +148,7 @@ func TestRefreshToken_InvalidToken(t *testing.T) {
 	assert.Equal(t, "refreshToken无效或已过期", codeErr.Error())
 }
 
-// TC-0029: 用户已被删除 —— M-1 修复后必须区分"不存在"(401) 与"冻结"(403)。
+// TC-0029: 用户已被删除 ——  修复后必须区分"不存在"(401) 与"冻结"(403)。
 //
 // 修复前：Loader 对不存在用户返回空壳 UserDetails(Status=0)，RefreshToken 走到"账号已被冻结"分支 (403)，
 //
@@ -175,7 +178,7 @@ func TestRefreshToken_UserDeleted(t *testing.T) {
 
 	var codeErr *response.CodeError
 	require.True(t, errors.As(err, &codeErr))
-	assert.Equal(t, 401, codeErr.Code(), "M-1：用户不存在必须走 401，不得与冻结态 (403) 混淆")
+	assert.Equal(t, 401, codeErr.Code(), "用户不存在必须走 401，不得与冻结态 (403) 混淆")
 	assert.Equal(t, "用户不存在或已被删除", codeErr.Error())
 }
 
@@ -387,3 +390,289 @@ func TestRefreshToken_SuperAdminWithProductCode(t *testing.T) {
 	assert.Contains(t, resp.UserInfo.Perms, permCode)
 	assert.Equal(t, int64(1), resp.UserInfo.IsSuperAdmin)
 }
+
+func TestRefreshToken_ConcurrentSameToken_SingleWinner(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	username := "rt_cas_" + testutil.UniqueId()
+
+	userId, cleanUser := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
+	t.Cleanup(cleanUser)
+
+	// 禁用 TokenOpLimiter，以让本测试的变量只剩"并发 CAS 胜负"。
+	svcCtx.TokenOpLimiter = nil
+
+	rt, err := authHelper.GenerateRefreshToken(
+		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+		userId, "", 0,
+	)
+	require.NoError(t, err)
+
+	// 限制在 6 并发以避免触发 go-zero sqlx breaker（单机 MySQL + breaker 对同批次突发
+	// 的并发 UPDATE 容易误伤，生产里 refreshToken 也是 per-user 限频 + CAS 双层保护，
+	// 没机会打成这么高的并发）。CAS "唯一胜出" 的契约在 N=6 时已足以钉死。
+	const N = 6
+	var (
+		wg          sync.WaitGroup
+		okCount     int32
+		authFailCnt int32
+		otherErr    atomic.Value
+	)
+	start := make(chan struct{})
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			<-start
+			resp, e := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+				Authorization: "Bearer " + rt,
+			})
+			switch {
+			case e == nil && resp != nil:
+				atomic.AddInt32(&okCount, 1)
+			case e != nil:
+				var ce *response.CodeError
+				if errors.As(e, &ce) && ce.Code() == 401 &&
+					ce.Error() == "登录状态已失效，请重新登录" {
+					atomic.AddInt32(&authFailCnt, 1)
+				} else {
+					otherErr.Store(e)
+				}
+			}
+		}()
+	}
+	close(start)
+	wg.Wait()
+
+	if v := otherErr.Load(); v != nil {
+		t.Fatalf("并发 RefreshToken 出现非预期错误：%v", v)
+	}
+
+	assert.Equal(t, int32(1), atomic.LoadInt32(&okCount),
+		"会话劫持防线：重放同一旧 refreshToken 的 N 个并发请求必须只有 1 个成功")
+	assert.Equal(t, int32(N-1), atomic.LoadInt32(&authFailCnt),
+		"其他并发者必须返回 401 '登录状态已失效'")
+
+	// DB 必然只递增 1。
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), u.TokenVersion,
+		"DB tokenVersion 递增幅度就是 CAS 成功次数 → 只能是 1")
+}
+
+func TestRefreshToken_TokenOpLimiter_BlocksBurst(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	username := "rt_rl_" + testutil.UniqueId()
+	password := "TestPass123"
+
+	userId, cleanUser := insertRefreshTestUser(t, ctx, username, password, 1, 2)
+	t.Cleanup(cleanUser)
+
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:refresh:ut:"+testutil.UniqueId())
+
+	mkReq := func(tv int64) *types.RefreshTokenReq {
+		rt, err := authHelper.GenerateRefreshToken(
+			svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+			userId, "", tv)
+		require.NoError(t, err)
+		return &types.RefreshTokenReq{Authorization: "Bearer " + rt}
+	}
+
+	resp1, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(0))
+	require.NoError(t, err, "首次刷新应放行")
+	require.NotNil(t, resp1)
+
+	// DB tokenVersion 已变为 1，旧 claims.TokenVersion=0 的 refreshToken 已失效，
+	// 所以第二次必须用新 token；但限流判定在 TokenVersion 校验之**后**、IncrementTokenVersion 之**前**，
+	// 因此使用新版本号构造的 token 会先通过前置校验，再被 TokenOpLimiter 拦截。
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	tvAfterFirst := u.TokenVersion
+	require.Equal(t, int64(1), tvAfterFirst)
+
+	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(tvAfterFirst))
+	require.Error(t, err, "超限的第二次刷新必须被 429 拦截")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 429, ce.Code())
+	assert.Contains(t, ce.Error(), "过于频繁")
+
+	uAfter, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, tvAfterFirst, uAfter.TokenVersion,
+		"被限流的 refresh 请求绝不可递增 tokenVersion")
+}
+
+// TC-0742: -B 修复 —— 限流按用户粒度隔离（productCode 无关）。
+// 场景：同一用户连续两次带 productCode=空的刷新请求，若限流命中，不会影响其它用户。
+func TestRefreshToken_TokenOpLimiter_PerUserIsolated(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+
+	uaId, cleanA := insertRefreshTestUser(t, ctx, "rt_iso_a_"+testutil.UniqueId(), "TestPass123", 1, 2)
+	t.Cleanup(cleanA)
+	ubId, cleanB := insertRefreshTestUser(t, ctx, "rt_iso_b_"+testutil.UniqueId(), "TestPass123", 1, 2)
+	t.Cleanup(cleanB)
+
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:refresh:iso:"+testutil.UniqueId())
+
+	mkReq := func(uid, tv int64) *types.RefreshTokenReq {
+		rt, err := authHelper.GenerateRefreshToken(
+			svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+			uid, "", tv)
+		require.NoError(t, err)
+		return &types.RefreshTokenReq{Authorization: "Bearer " + rt}
+	}
+
+	// A：两次刷新，第 2 次必 429
+	_, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(uaId, 0))
+	require.NoError(t, err)
+	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(uaId, 1))
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	require.Equal(t, 429, ce.Code())
+
+	// B 应当还能刷新
+	respB, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(ubId, 0))
+	require.NoError(t, err, "B 用户的限流桶应当独立于 A")
+	require.NotNil(t, respB)
+}
+
+func TestRefreshToken_M3_SuccessEmbedsFreshVersion(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.TokenOpLimiter = nil
+	username := "rt_m3_ok_" + testutil.UniqueId()
+
+	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
+	t.Cleanup(cleanup)
+
+	rt, err := authHelper.GenerateRefreshToken(
+		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+		userId, "", 0,
+	)
+	require.NoError(t, err)
+
+	resp, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+		Authorization: "Bearer " + rt,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), u.TokenVersion, "正常刷新 DB tokenVersion 必须 +1")
+
+	var accessClaims middleware.Claims
+	_, err = authHelper.ParseWithHMAC(resp.AccessToken, svcCtx.Config.Auth.AccessSecret, &accessClaims)
+	require.NoError(t, err, "新 accessToken 必须可解析")
+	assert.Equal(t, u.TokenVersion, accessClaims.TokenVersion,
+		"新 accessToken.TokenVersion 必须等于 DB 新 tokenVersion；不等说明 CAS/签名顺序错位")
+
+	refreshClaims, err := authHelper.ParseRefreshToken(resp.RefreshToken, svcCtx.Config.Auth.RefreshSecret)
+	require.NoError(t, err, "新 refreshToken 必须可解析")
+	assert.Equal(t, u.TokenVersion, refreshClaims.TokenVersion,
+		"新 refreshToken.TokenVersion 必须等于 DB 新 tokenVersion；客户端下一次刷新必须可用")
+}
+
+// TC-0984: CAS 失败路径 —— 模拟并发抢先递增后再刷新，DB 不得再次被 +1。
+func TestRefreshToken_M3_CASMismatch_DoesNotDoubleAdvance(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.TokenOpLimiter = nil
+	username := "rt_m3_cas_" + testutil.UniqueId()
+
+	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
+	t.Cleanup(cleanup)
+
+	// 构造旧 refresh token（claims.TokenVersion=0）。
+	rt, err := authHelper.GenerateRefreshToken(
+		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+		userId, "", 0,
+	)
+	require.NoError(t, err)
+
+	// 模拟"并发赢家已经把 DB tokenVersion 推到 1"：直接 CAS 一次。
+	newVer, err := svcCtx.SysUserModel.IncrementTokenVersionIfMatch(ctx, userId, username, 0)
+	require.NoError(t, err)
+	require.Equal(t, int64(1), newVer)
+
+	// 清掉用户缓存，确保下一步 Load 能读到 DB 的最新 tokenVersion=1。
+	svcCtx.UserDetailsLoader.Clean(ctx, userId)
+
+	// 现在第二个刷新进来：ud.TokenVersion=1 ≠ claims.TokenVersion=0，
+	// 会在 logic 第 73 行 "claims.TokenVersion != ud.TokenVersion" 被直接 401 拒，
+	// 根本到不了 Generate/CAS。DB 不得再次 +1。
+	resp, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+		Authorization: "Bearer " + rt,
+	})
+	assert.Nil(t, resp)
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce), "必须是 response.CodeError")
+	assert.Equal(t, 401, ce.Code(), "claims 过期必须是 401")
+	assert.Equal(t, "登录状态已失效，请重新登录", ce.Error())
+
+	// 关键断言：失败分支不得二次推进 tokenVersion。
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), u.TokenVersion,
+		"失败分支必须不推进 tokenVersion；若变成 2 说明 CAS 被放在"+
+			"签名/校验前，已经把用户状态破坏了")
+}
+
+// TC-0985: 重放拦截 —— 用第一次刷新拿到的新 refreshToken 再刷一次必须成功；
+// 再拿"同一个新 refreshToken"做第三次刷新必须被 401 拦截（tokenVersion 已 +2，claims=+1）。
+// 这组断言同时证明  修复之后"预签 token 的版本号 == 最终 DB 版本号"的强契约。
+func TestRefreshToken_M3_NewRefreshTokenMatchesDBVersion(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	svcCtx.TokenOpLimiter = nil
+	username := "rt_m3_chain_" + testutil.UniqueId()
+
+	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
+	t.Cleanup(cleanup)
+
+	first, err := authHelper.GenerateRefreshToken(
+		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
+		userId, "", 0,
+	)
+	require.NoError(t, err)
+
+	r1, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+		Authorization: "Bearer " + first,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, r1)
+
+	// 等 loader 缓存被 Clean 后，再用 r1.RefreshToken 续签，理应成功，tokenVersion 从 1 → 2。
+	r2, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+		Authorization: "Bearer " + r1.RefreshToken,
+	})
+	require.NoError(t, err, "新 refreshToken 必须能顶替旧的继续刷新")
+	require.NotNil(t, r2)
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), u.TokenVersion)
+
+	// 第三次重放第一步就签下的 r1 → 401，DB 不得再 +1。
+	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
+		Authorization: "Bearer " + r1.RefreshToken,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 401, ce.Code(),
+		"重放旧 refreshToken 必须 401；服务端绝不得因签 token 副作用推进 DB")
+
+	u2, err := svcCtx.SysUserModel.FindOne(ctx, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(2), u2.TokenVersion, "重放失败分支不得推进 tokenVersion")
+}

internal/logic/pub/refreshTokenRateLimit_audit_test.go

@@ -1,104 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	authHelper "perms-system-server/internal/logic/auth"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/limit"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-// TC-0741: M-B 修复回归 —— /auth/refreshToken 必须受 TokenOpLimiter 保护，
-// 用 quota=1 的定制 limiter，同一用户第 2 次必须 429；
-// 且被限流的请求绝不能触发 IncrementTokenVersion（否则攻击者可持续废除 refresh 令牌）。
-func TestRefreshToken_TokenOpLimiter_BlocksBurst(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	username := "rt_rl_" + testutil.UniqueId()
-	password := "TestPass123"
-
-	userId, cleanUser := insertRefreshTestUser(t, ctx, username, password, 1, 2)
-	t.Cleanup(cleanUser)
-
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:refresh:ut:"+testutil.UniqueId())
-
-	mkReq := func(tv int64) *types.RefreshTokenReq {
-		rt, err := authHelper.GenerateRefreshToken(
-			svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-			userId, "", tv)
-		require.NoError(t, err)
-		return &types.RefreshTokenReq{Authorization: "Bearer " + rt}
-	}
-
-	resp1, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(0))
-	require.NoError(t, err, "首次刷新应放行")
-	require.NotNil(t, resp1)
-
-	// DB tokenVersion 已变为 1，旧 claims.TokenVersion=0 的 refreshToken 已失效，
-	// 所以第二次必须用新 token；但限流判定在 TokenVersion 校验之**后**、IncrementTokenVersion 之**前**，
-	// 因此使用新版本号构造的 token 会先通过前置校验，再被 TokenOpLimiter 拦截。
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	tvAfterFirst := u.TokenVersion
-	require.Equal(t, int64(1), tvAfterFirst)
-
-	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(tvAfterFirst))
-	require.Error(t, err, "超限的第二次刷新必须被 429 拦截")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 429, ce.Code())
-	assert.Contains(t, ce.Error(), "过于频繁")
-
-	uAfter, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, tvAfterFirst, uAfter.TokenVersion,
-		"被限流的 refresh 请求绝不可递增 tokenVersion")
-}
-
-// TC-0742: M-B 修复 —— 限流按用户粒度隔离（productCode 无关）。
-// 场景：同一用户连续两次带 productCode=空的刷新请求，若限流命中，不会影响其它用户。
-func TestRefreshToken_TokenOpLimiter_PerUserIsolated(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-
-	uaId, cleanA := insertRefreshTestUser(t, ctx, "rt_iso_a_"+testutil.UniqueId(), "TestPass123", 1, 2)
-	t.Cleanup(cleanA)
-	ubId, cleanB := insertRefreshTestUser(t, ctx, "rt_iso_b_"+testutil.UniqueId(), "TestPass123", 1, 2)
-	t.Cleanup(cleanB)
-
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	svcCtx.TokenOpLimiter = limit.NewPeriodLimit(60, 1, rds, cfg.CacheRedis.KeyPrefix+":rl:refresh:iso:"+testutil.UniqueId())
-
-	mkReq := func(uid, tv int64) *types.RefreshTokenReq {
-		rt, err := authHelper.GenerateRefreshToken(
-			svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-			uid, "", tv)
-		require.NoError(t, err)
-		return &types.RefreshTokenReq{Authorization: "Bearer " + rt}
-	}
-
-	// A：两次刷新，第 2 次必 429
-	_, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(uaId, 0))
-	require.NoError(t, err)
-	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(uaId, 1))
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	require.Equal(t, 429, ce.Code())
-
-	// B 应当还能刷新
-	respB, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(mkReq(ubId, 0))
-	require.NoError(t, err, "B 用户的限流桶应当独立于 A")
-	require.NotNil(t, respB)
-}

internal/logic/pub/refreshTokenSignBeforeCas_audit_test.go

@@ -1,165 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	authHelper "perms-system-server/internal/logic/auth"
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-3（第 8 轮）—— RefreshToken 必须"先试签 → 再 CAS → 最后清缓存"，
-// 使得签名失败/CAS 失败两条分支都不会推进 tokenVersion，不会出现"tokenVersion 已 +1
-// 但客户端没拿到新 refreshToken"的放大式强制登出。
-//
-// 由于 HMAC 实际不会失败（除非 OOM），本组测试从可观测契约入手：
-//   TC-0983: 成功路径下新 token 的 claims.TokenVersion 必须严格等于 DB 的新 tokenVersion；
-//            如果顺序被颠倒（CAS 后再签），仍然成立，所以必须配合 TC-0984 防止退化。
-//   TC-0984: 模拟 CAS ErrTokenVersionMismatch（人工抢先把 DB TokenVersion 再递增一次），
-//            触发 401 "登录状态已失效"；DB 再次递增的幅度必须 = 0，证明失败分支没有再 +1。
-//   TC-0985: 新签发的 refresh token 能被 ParseRefreshToken 解出且 claims.TokenVersion
-//            = DB 新 tokenVersion —— 保证客户端拿到的 refreshToken 在下一轮必然可用；
-//            这就是 M-3 要守护的"客户端不会被自己的服务端新签 token 背刺"契约。
-// ---------------------------------------------------------------------------
-
-// TC-0983: 成功路径 —— 新 access/refresh 的 tokenVersion 必须等于 DB 新 tokenVersion。
-func TestRefreshToken_M3_SuccessEmbedsFreshVersion(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.TokenOpLimiter = nil
-	username := "rt_m3_ok_" + testutil.UniqueId()
-
-	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
-	t.Cleanup(cleanup)
-
-	rt, err := authHelper.GenerateRefreshToken(
-		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-		userId, "", 0,
-	)
-	require.NoError(t, err)
-
-	resp, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-		Authorization: "Bearer " + rt,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(1), u.TokenVersion, "M-3：正常刷新 DB tokenVersion 必须 +1")
-
-	var accessClaims middleware.Claims
-	_, err = authHelper.ParseWithHMAC(resp.AccessToken, svcCtx.Config.Auth.AccessSecret, &accessClaims)
-	require.NoError(t, err, "新 accessToken 必须可解析")
-	assert.Equal(t, u.TokenVersion, accessClaims.TokenVersion,
-		"M-3：新 accessToken.TokenVersion 必须等于 DB 新 tokenVersion；不等说明 CAS/签名顺序错位")
-
-	refreshClaims, err := authHelper.ParseRefreshToken(resp.RefreshToken, svcCtx.Config.Auth.RefreshSecret)
-	require.NoError(t, err, "新 refreshToken 必须可解析")
-	assert.Equal(t, u.TokenVersion, refreshClaims.TokenVersion,
-		"M-3：新 refreshToken.TokenVersion 必须等于 DB 新 tokenVersion；客户端下一次刷新必须可用")
-}
-
-// TC-0984: CAS 失败路径 —— 模拟并发抢先递增后再刷新，DB 不得再次被 +1。
-func TestRefreshToken_M3_CASMismatch_DoesNotDoubleAdvance(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.TokenOpLimiter = nil
-	username := "rt_m3_cas_" + testutil.UniqueId()
-
-	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
-	t.Cleanup(cleanup)
-
-	// 构造旧 refresh token（claims.TokenVersion=0）。
-	rt, err := authHelper.GenerateRefreshToken(
-		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-		userId, "", 0,
-	)
-	require.NoError(t, err)
-
-	// 模拟"并发赢家已经把 DB tokenVersion 推到 1"：直接 CAS 一次。
-	newVer, err := svcCtx.SysUserModel.IncrementTokenVersionIfMatch(ctx, userId, username, 0)
-	require.NoError(t, err)
-	require.Equal(t, int64(1), newVer)
-
-	// 清掉用户缓存，确保下一步 Load 能读到 DB 的最新 tokenVersion=1。
-	svcCtx.UserDetailsLoader.Clean(ctx, userId)
-
-	// 现在第二个刷新进来：ud.TokenVersion=1 ≠ claims.TokenVersion=0，
-	// 会在 logic 第 73 行 "claims.TokenVersion != ud.TokenVersion" 被直接 401 拒，
-	// 根本到不了 Generate/CAS。DB 不得再次 +1。
-	resp, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-		Authorization: "Bearer " + rt,
-	})
-	assert.Nil(t, resp)
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce), "必须是 response.CodeError")
-	assert.Equal(t, 401, ce.Code(), "claims 过期必须是 401")
-	assert.Equal(t, "登录状态已失效，请重新登录", ce.Error())
-
-	// 关键断言：失败分支不得二次推进 tokenVersion。
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(1), u.TokenVersion,
-		"M-3：失败分支必须不推进 tokenVersion；若变成 2 说明 CAS 被放在"+
-			"签名/校验前，已经把用户状态破坏了")
-}
-
-// TC-0985: 重放拦截 —— 用第一次刷新拿到的新 refreshToken 再刷一次必须成功；
-// 再拿"同一个新 refreshToken"做第三次刷新必须被 401 拦截（tokenVersion 已 +2，claims=+1）。
-// 这组断言同时证明 M-3 修复之后"预签 token 的版本号 == 最终 DB 版本号"的强契约。
-func TestRefreshToken_M3_NewRefreshTokenMatchesDBVersion(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	svcCtx.TokenOpLimiter = nil
-	username := "rt_m3_chain_" + testutil.UniqueId()
-
-	userId, cleanup := insertRefreshTestUser(t, ctx, username, "TestPass123", 1, 2)
-	t.Cleanup(cleanup)
-
-	first, err := authHelper.GenerateRefreshToken(
-		svcCtx.Config.Auth.RefreshSecret, svcCtx.Config.Auth.RefreshExpire,
-		userId, "", 0,
-	)
-	require.NoError(t, err)
-
-	r1, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-		Authorization: "Bearer " + first,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, r1)
-
-	// 等 loader 缓存被 Clean 后，再用 r1.RefreshToken 续签，理应成功，tokenVersion 从 1 → 2。
-	r2, err := NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-		Authorization: "Bearer " + r1.RefreshToken,
-	})
-	require.NoError(t, err, "新 refreshToken 必须能顶替旧的继续刷新")
-	require.NotNil(t, r2)
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(2), u.TokenVersion)
-
-	// 第三次重放第一步就签下的 r1 → 401，DB 不得再 +1。
-	_, err = NewRefreshTokenLogic(ctx, svcCtx).RefreshToken(&types.RefreshTokenReq{
-		Authorization: "Bearer " + r1.RefreshToken,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 401, ce.Code(),
-		"M-3：重放旧 refreshToken 必须 401；服务端绝不得因签 token 副作用推进 DB")
-
-	u2, err := svcCtx.SysUserModel.FindOne(ctx, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(2), u2.TokenVersion, "M-3：重放失败分支不得推进 tokenVersion")
-}

internal/logic/pub/syncPerms404_audit_test.go

@@ -1,126 +0,0 @@
-package pub
-
-import (
-	"context"
-	"testing"
-
-	productModel "perms-system-server/internal/model/product"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-	"golang.org/x/crypto/bcrypt"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-2（第 8 轮）—— SyncPermsError{Code: 404} 必须被 REST 侧映射为 HTTP 404
-// "产品不存在"（ErrNotFound），而不是 default 分支里 err 的原文。
-//
-// 404 的触发条件：
-//   前置 FindOneByAppKey 已经拉到产品行（走通 401/403 校验），但事务内 LockByCodeTx 再查
-//   同一产品码时 sqlx.ErrNotFound —— 即事务打开前后并发有人把产品删了。目前仓库里没有
-//   DeleteProduct Logic，该分支在生产里还到不了；但契约必须稳，否则将来加 DeleteProduct
-//   时前端/SDK 分类会错乱。
-//
-// 命名规则：TC-0979
-// ---------------------------------------------------------------------------
-
-// TC-0979: REST SyncPerms —— tx 内 LockByCodeTx ErrNotFound → HTTP 404
-func TestSyncPerms_LockByCodeTxNotFound_MapsToHTTP404(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("m2_secret"), bcrypt.MinCost)
-	require.NoError(t, err)
-
-	mockProduct := mocks.NewMockSysProductModel(ctrl)
-	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "m2_key").
-		Return(&productModel.SysProduct{
-			Id: 1, Code: "m2_prod", AppKey: "m2_key",
-			AppSecret: string(hashedSecret), Status: 1,
-		}, nil)
-	// 关键：tx 内 LockByCodeTx 拿到 ErrNotFound → service 返回 SyncPermsError{Code:404, "产品不存在"}。
-	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "m2_prod").
-		Return((*productModel.SysProduct)(nil), sqlx.ErrNotFound)
-
-	mockPerm := mocks.NewMockSysPermModel(ctrl)
-	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: mockProduct, Perm: mockPerm})
-
-	logic := NewSyncPermsLogic(context.Background(), svcCtx)
-	resp, err := logic.SyncPerms(&types.SyncPermsReq{
-		AppKey: "m2_key", AppSecret: "m2_secret",
-		Perms: []types.SyncPermItem{{Code: "p1", Name: "P1"}},
-	})
-
-	assert.Nil(t, resp)
-	require.Error(t, err, "M-2：tx 内产品消失必须返回错误")
-
-	var ce *response.CodeError
-	require.ErrorAs(t, err, &ce,
-		"M-2：必须映射成 response.CodeError 结构化错误，不能透传 SyncPermsError 原文")
-	assert.Equal(t, 404, ce.Code(),
-		"M-2：SyncPermsError{Code:404} 必须落到 HTTP 404 分支；若仍是 500 说明 syncPermsLogic 的 switch 缺少 404 case")
-	assert.Equal(t, "产品不存在", ce.Error(), "M-2：保留原始语义文案")
-}
-
-// TC-0980（负值域对称）：未映射的 se.Code（例如 500）依旧走 default，原样透传，不得被误收进 404。
-// 防御未来有人想"把所有 SyncPermsError 都按 404 处理"的随手改动。
-func TestSyncPerms_UnmappedSyncPermsErrCode_StillFallsThroughDefault(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("m2_secret"), bcrypt.MinCost)
-	require.NoError(t, err)
-
-	mockProduct := mocks.NewMockSysProductModel(ctrl)
-	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "m2_key2").
-		Return(&productModel.SysProduct{
-			Id: 1, Code: "m2_prod2", AppKey: "m2_key2",
-			AppSecret: string(hashedSecret), Status: 1,
-		}, nil)
-	// 审计 M-R10-1：LockByCodeTx 拿到的行必须 Status=1 才能继续进入 diff 逻辑
-	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "m2_prod2").
-		Return(&productModel.SysProduct{Id: 1, Code: "m2_prod2", Status: 1}, nil)
-
-	mockPerm := mocks.NewMockSysPermModel(ctrl)
-	mockPerm.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "m2_prod2").
-		Return(nil, assertAnyErr("internal storage bug"))
-	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: mockProduct, Perm: mockPerm})
-
-	logic := NewSyncPermsLogic(context.Background(), svcCtx)
-	_, err = logic.SyncPerms(&types.SyncPermsReq{
-		AppKey: "m2_key2", AppSecret: "m2_secret",
-		Perms: []types.SyncPermItem{{Code: "p1", Name: "P1"}},
-	})
-
-	require.Error(t, err)
-	var se *SyncPermsError
-	require.ErrorAs(t, err, &se, "M-2：未映射 code 走 default，原 SyncPermsError 被原样透传")
-	assert.Equal(t, 500, se.Code, "M-2：500 必须保持 500 原语义，不得被误归类为 404")
-	var ce *response.CodeError
-	assert.False(t, assert.ObjectsAreEqual(err, ce),
-		"M-2：500 分支绝不能被映射成 response.CodeError{Code:404}")
-}
-
-// assertAnyErr 构造任意错误，用来模拟 tx 内非业务分支错误。
-func assertAnyErr(msg string) error {
-	return &localErr{s: msg}
-}
-
-type localErr struct{ s string }
-
-func (e *localErr) Error() string { return e.s }

internal/logic/pub/syncPermsCleanByProduct_r11_4_audit_test.go

@@ -1,155 +0,0 @@
-package pub
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"perms-system-server/internal/testutil"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/redis"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-R11-4 —— SyncPerms 纯新增（added>0 && updated==0 && disabled==0）
-// 不触发 UserDetailsLoader.CleanByProduct，避免把该产品下所有在线用户的 UD 缓存集体清空
-// 造成雪崩；updated/disabled 任一 > 0 时仍必须清。
-//
-// 用 Redis 层面的 productIndexKey（`<prefix>:ud:idx:p:<productCode>`）做间接观测：
-//   - 测试前手工 SAdd 一个合成 cacheKey 到索引集合，建立"被 CleanByProduct 吃掉"的探针；
-//   - 跑 ExecuteSyncPerms；
-//   - 若 CleanByProduct 被调用，索引集合会被 SmembersCtx -> DelCtx 一并清空，Exists 返 0；
-//   - 若未调用，合成 key 仍然在集合里，Exists 返 1。
-// ---------------------------------------------------------------------------
-
-func primeProductIndex(t *testing.T, rds *redis.Redis, cachePrefix, productCode string) string {
-	t.Helper()
-	idxKey := fmt.Sprintf("%s:ud:idx:p:%s", cachePrefix, productCode)
-	canary := fmt.Sprintf("%s:ud:probe:%s", cachePrefix, testutil.UniqueId())
-	_, err := rds.Sadd(idxKey, canary)
-	require.NoError(t, err, "SAdd 到 productIndexKey 失败，Redis 不可用，测试前置条件失败")
-	members, err := rds.Smembers(idxKey)
-	require.NoError(t, err)
-	require.Contains(t, members, canary, "primeProductIndex: canary 必须先出现在集合里")
-	return idxKey
-}
-
-// TC-1064: L-R11-4 —— 纯新增不触发 CleanByProduct
-func TestSyncPerms_PureAddDoesNotTriggerCleanByProduct(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	conn := testutil.GetTestSqlConn()
-
-	pc := testutil.UniqueId()
-	appKey := testutil.UniqueId()
-	appSecret := testutil.UniqueId()
-	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
-	t.Cleanup(cleanProduct)
-	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
-
-	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
-	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
-
-	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
-		{Code: "r11_4_add_a", Name: "A"},
-		{Code: "r11_4_add_b", Name: "B"},
-		{Code: "r11_4_add_c", Name: "C"},
-	})
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, int64(3), result.Added)
-	assert.Equal(t, int64(0), result.Updated)
-	assert.Equal(t, int64(0), result.Disabled)
-
-	// 纯新增路径：CleanByProduct 不得被调用，索引集合必须仍保留 canary。
-	exists, err := rds.Exists(idxKey)
-	require.NoError(t, err)
-	assert.True(t, exists,
-		"L-R11-4：added=3 / updated=0 / disabled=0 属于纯新增，不得触发 CleanByProduct；"+
-			"productIndexKey 若被删除说明 SyncPerms 仍在走全产品清缓存路径，回归：会把该产品"+
-			"所有在线用户下一次请求同时打穿回 DB")
-}
-
-// TC-1065: L-R11-4 —— updated > 0 时必须触发 CleanByProduct
-func TestSyncPerms_UpdateTriggersCleanByProduct(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	conn := testutil.GetTestSqlConn()
-
-	pc := testutil.UniqueId()
-	appKey := testutil.UniqueId()
-	appSecret := testutil.UniqueId()
-	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
-	t.Cleanup(cleanProduct)
-	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
-
-	// 第一次同步：纯新增，为随后的 update 打底；这次不触发 Clean，CleanByProduct 仍然可被后续触发。
-	_, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
-		{Code: "r11_4_upd", Name: "OldName"},
-	})
-	require.NoError(t, err)
-
-	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
-	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
-
-	// 第二次同步：同一 Code 改 Name → updated=1。
-	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
-		{Code: "r11_4_upd", Name: "NewName"},
-	})
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, int64(1), result.Updated,
-		"前置：同名 Code 改 Name 必须 updated=1，否则后续断言失去意义")
-
-	exists, err := rds.Exists(idxKey)
-	require.NoError(t, err)
-	assert.False(t, exists,
-		"L-R11-4：updated>0 必须触发 CleanByProduct；若 canary 仍在，说明 Logic 把"+
-			"updated 情况也误归入'纯新增'分支，已存在 UD 缓存中的旧 perms 将长期对外返回")
-}
-
-// TC-1066: L-R11-4 —— disabled > 0 时必须触发 CleanByProduct
-func TestSyncPerms_DisableTriggersCleanByProduct(t *testing.T) {
-	ctx := context.Background()
-	svcCtx := newTestSvcCtx()
-	cfg := testutil.GetTestConfig()
-	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
-	conn := testutil.GetTestSqlConn()
-
-	pc := testutil.UniqueId()
-	appKey := testutil.UniqueId()
-	appSecret := testutil.UniqueId()
-	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
-	t.Cleanup(cleanProduct)
-	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
-
-	// 先注入两个 perm。
-	_, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
-		{Code: "r11_4_keep", Name: "K"},
-		{Code: "r11_4_drop", Name: "D"},
-	})
-	require.NoError(t, err)
-
-	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
-	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
-
-	// 第二次只同步 r11_4_keep，r11_4_drop 会被 DisableNotInCodesWithTx 置 disabled。
-	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
-		{Code: "r11_4_keep", Name: "K"},
-	})
-	require.NoError(t, err)
-	assert.Equal(t, int64(1), result.Disabled,
-		"前置：第二次只同步 keep，drop 必须被 disabled=1")
-
-	exists, err := rds.Exists(idxKey)
-	require.NoError(t, err)
-	assert.False(t, exists,
-		"L-R11-4：disabled>0 必须触发 CleanByProduct，否则已缓存的 UD.perms 里仍挂着"+
-			"已禁用权限，权限网关会把不再有效的权限判为 allow，产生权限残留")
-}

internal/logic/pub/syncPermsDedup_audit_test.go

@@ -1,73 +0,0 @@
-package pub
-
-import (
-	"context"
-	"testing"
-
-	permModel "perms-system-server/internal/model/perm"
-	productModel "perms-system-server/internal/model/product"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-	"golang.org/x/crypto/bcrypt"
-)
-
-// TC-0826: 请求体内 perm.code 重复时，service 必须先在入参上去重，避免同一个 tx 内
-// BatchInsert 自己和自己撞 UNIQUE(productCode, code) 引发 1062。
-// 旧文件 syncPermsConflict_audit_test.go 一并覆盖了 1062→409 的映射契约，但 H-3 引入
-// LockByCodeTx 串行化同步后，1062 在实践中已不可达，该 409 映射契约也被一起取消；只有
-// 这一条"请求内去重"仍然是当前产品契约，必须继续回归。
-func TestExecuteSyncPerms_DeduplicatesRequest(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("s"), bcrypt.MinCost)
-	require.NoError(t, err)
-
-	mockProduct := mocks.NewMockSysProductModel(ctrl)
-	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "ak").
-		Return(&productModel.SysProduct{
-			Id: 1, Code: "pc_dedup", AppKey: "ak", AppSecret: string(hashedSecret), Status: 1,
-		}, nil)
-	// 审计 M-R10-1：LockByCodeTx 拿到的行必须 Status=1
-	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_dedup").
-		Return(&productModel.SysProduct{Id: 1, Code: "pc_dedup", Status: 1}, nil)
-
-	mockPerm := mocks.NewMockSysPermModel(ctrl)
-	mockPerm.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "pc_dedup").
-		Return(map[string]*permModel.SysPerm{}, nil)
-
-	var captured []*permModel.SysPerm
-	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-	mockPerm.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).
-		DoAndReturn(func(ctx context.Context, s sqlx.Session, items []*permModel.SysPerm) error {
-			captured = items
-			return nil
-		})
-	// 去重后 codes 只剩一个，DisableNotInCodesWithTx 用去重后的集合做 NOT IN。
-	mockPerm.EXPECT().DisableNotInCodesWithTx(gomock.Any(), nil, "pc_dedup", []string{"dup_code"}, gomock.Any()).
-		Return(int64(0), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Product: mockProduct, Perm: mockPerm,
-	})
-
-	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s", []SyncPermItem{
-		{Code: "dup_code", Name: "A"},
-		{Code: "dup_code", Name: "A-again"},
-		{Code: "dup_code", Name: "A-yet-again"},
-	})
-	require.NoError(t, err)
-	require.NotNil(t, result)
-
-	require.Len(t, captured, 1, "入参内 code 重复必须去重为 1 条，避免自撞 1062")
-	assert.Equal(t, "dup_code", captured[0].Code)
-	assert.Equal(t, "A", captured[0].Name,
-		"去重策略应稳定到首次出现，使行为可预测")
-}

internal/logic/pub/syncPermsLogic_mock_test.go

@@ -20,7 +20,7 @@ import (
 // TC-0048: 事务保护 —— BatchUpdate 失败时，service 必须回滚整个事务并对外返回
 // SyncPermsError{500, "同步权限事务失败"}（不得泄漏内部 DB 驱动错误）。
 //
-// 旧版本使用已废弃的 FindMapByProductCode（非事务版）做 mock；H-3 修复后读/锁都必须
+// 旧版本使用已废弃的 FindMapByProductCode（非事务版）做 mock； 修复后读/锁都必须
 // 落在同一个 tx 里，这里按新契约重写 mock：LockByCodeTx → FindMapByProductCodeWithTx →
 // BatchInsertWithTx OK → BatchUpdateWithTx 报错 → 统一 500。
 func TestSyncPerms_Mock_TransactionRollbackOnBatchUpdateFail(t *testing.T) {
@@ -41,8 +41,8 @@ func TestSyncPerms_Mock_TransactionRollbackOnBatchUpdateFail(t *testing.T) {
 			AppSecret: string(hashedSecret),
 			Status:    1,
 		}, nil)
-	// H-3：tx 内必须先 LockByCodeTx 锁 product 行，再 FindMapByProductCodeWithTx。
-	// 审计 M-R10-1：LockByCodeTx 拿到的行必须 Status=1，否则直接 403 不进入 diff
+	// tx 内必须先 LockByCodeTx 锁 product 行，再 FindMapByProductCodeWithTx。
+	// LockByCodeTx 拿到的行必须 Status=1，否则直接 403 不进入 diff
 	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "test_product").
 		Return(&productModel.SysProduct{Id: 1, Code: "test_product", Status: 1}, nil)
 
@@ -79,7 +79,7 @@ func TestSyncPerms_Mock_TransactionRollbackOnBatchUpdateFail(t *testing.T) {
 
 	assert.Nil(t, resp)
 	require.Error(t, err)
-	// H-3 后的统一错误文案；原 DB 驱动错误必须被吞掉，避免泄漏内部实现。
+	// 后的统一错误文案；原 DB 驱动错误必须被吞掉，避免泄漏内部实现。
 	assert.Contains(t, err.Error(), "同步权限事务失败")
 	assert.NotContains(t, err.Error(), "batch update failed",
 		"内部 DB 错误不得透传到客户端")

internal/logic/pub/syncPermsLogic_test.go

@@ -4,18 +4,20 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"go.uber.org/mock/gomock"
+	"golang.org/x/crypto/bcrypt"
 	permModel "perms-system-server/internal/model/perm"
 	productModel "perms-system-server/internal/model/product"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/testutil"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"golang.org/x/crypto/bcrypt"
+	"testing"
+	"time"
 )
 
 func insertSyncTestProduct(t *testing.T, ctx context.Context, code, appKey, appSecret string, status int64) (int64, func()) {
@@ -437,3 +439,398 @@ func TestSyncPerms_VerifyDisabledCount(t *testing.T) {
 	assert.Equal(t, int64(0), resp.Added)
 	assert.Equal(t, int64(3), resp.Disabled)
 }
+
+func TestSyncPerms_LockByCodeTxNotFound_MapsToHTTP404(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("m2_secret"), bcrypt.MinCost)
+	require.NoError(t, err)
+
+	mockProduct := mocks.NewMockSysProductModel(ctrl)
+	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "m2_key").
+		Return(&productModel.SysProduct{
+			Id: 1, Code: "m2_prod", AppKey: "m2_key",
+			AppSecret: string(hashedSecret), Status: 1,
+		}, nil)
+	// 关键：tx 内 LockByCodeTx 拿到 ErrNotFound → service 返回 SyncPermsError{Code:404, "产品不存在"}。
+	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "m2_prod").
+		Return((*productModel.SysProduct)(nil), sqlx.ErrNotFound)
+
+	mockPerm := mocks.NewMockSysPermModel(ctrl)
+	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: mockProduct, Perm: mockPerm})
+
+	logic := NewSyncPermsLogic(context.Background(), svcCtx)
+	resp, err := logic.SyncPerms(&types.SyncPermsReq{
+		AppKey: "m2_key", AppSecret: "m2_secret",
+		Perms: []types.SyncPermItem{{Code: "p1", Name: "P1"}},
+	})
+
+	assert.Nil(t, resp)
+	require.Error(t, err, "tx 内产品消失必须返回错误")
+
+	var ce *response.CodeError
+	require.ErrorAs(t, err, &ce,
+		"必须映射成 response.CodeError 结构化错误，不能透传 SyncPermsError 原文")
+	assert.Equal(t, 404, ce.Code(),
+		"SyncPermsError{Code:404} 必须落到 HTTP 404 分支；若仍是 500 说明 syncPermsLogic 的 switch 缺少 404 case")
+	assert.Equal(t, "产品不存在", ce.Error(), "保留原始语义文案")
+}
+
+// TC-0980（负值域对称）：未映射的 se.Code（例如 500）依旧走 default，原样透传，不得被误收进 404。
+// 防御未来有人想"把所有 SyncPermsError 都按 404 处理"的随手改动。
+func TestSyncPerms_UnmappedSyncPermsErrCode_StillFallsThroughDefault(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("m2_secret"), bcrypt.MinCost)
+	require.NoError(t, err)
+
+	mockProduct := mocks.NewMockSysProductModel(ctrl)
+	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "m2_key2").
+		Return(&productModel.SysProduct{
+			Id: 1, Code: "m2_prod2", AppKey: "m2_key2",
+			AppSecret: string(hashedSecret), Status: 1,
+		}, nil)
+	// LockByCodeTx 拿到的行必须 Status=1 才能继续进入 diff 逻辑
+	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "m2_prod2").
+		Return(&productModel.SysProduct{Id: 1, Code: "m2_prod2", Status: 1}, nil)
+
+	mockPerm := mocks.NewMockSysPermModel(ctrl)
+	mockPerm.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "m2_prod2").
+		Return(nil, assertAnyErr("internal storage bug"))
+	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: mockProduct, Perm: mockPerm})
+
+	logic := NewSyncPermsLogic(context.Background(), svcCtx)
+	_, err = logic.SyncPerms(&types.SyncPermsReq{
+		AppKey: "m2_key2", AppSecret: "m2_secret",
+		Perms: []types.SyncPermItem{{Code: "p1", Name: "P1"}},
+	})
+
+	require.Error(t, err)
+	var se *SyncPermsError
+	require.ErrorAs(t, err, &se, "未映射 code 走 default，原 SyncPermsError 被原样透传")
+	assert.Equal(t, 500, se.Code, "500 必须保持 500 原语义，不得被误归类为 404")
+	var ce *response.CodeError
+	assert.False(t, assert.ObjectsAreEqual(err, ce),
+		"500 分支绝不能被映射成 response.CodeError{Code:404}")
+}
+
+// assertAnyErr 构造任意错误，用来模拟 tx 内非业务分支错误。
+func assertAnyErr(msg string) error {
+	return &localErr{s: msg}
+}
+
+type localErr struct{ s string }
+
+func (e *localErr) Error() string { return e.s }
+
+func primeProductIndex(t *testing.T, rds *redis.Redis, cachePrefix, productCode string) string {
+	t.Helper()
+	idxKey := fmt.Sprintf("%s:ud:idx:p:%s", cachePrefix, productCode)
+	canary := fmt.Sprintf("%s:ud:probe:%s", cachePrefix, testutil.UniqueId())
+	_, err := rds.Sadd(idxKey, canary)
+	require.NoError(t, err, "SAdd 到 productIndexKey 失败，Redis 不可用，测试前置条件失败")
+	members, err := rds.Smembers(idxKey)
+	require.NoError(t, err)
+	require.Contains(t, members, canary, "primeProductIndex: canary 必须先出现在集合里")
+	return idxKey
+}
+
+// TC-1064: 纯新增不触发 CleanByProduct
+func TestSyncPerms_PureAddDoesNotTriggerCleanByProduct(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	conn := testutil.GetTestSqlConn()
+
+	pc := testutil.UniqueId()
+	appKey := testutil.UniqueId()
+	appSecret := testutil.UniqueId()
+	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
+	t.Cleanup(cleanProduct)
+	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
+
+	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
+	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
+
+	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
+		{Code: "r11_4_add_a", Name: "A"},
+		{Code: "r11_4_add_b", Name: "B"},
+		{Code: "r11_4_add_c", Name: "C"},
+	})
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	assert.Equal(t, int64(3), result.Added)
+	assert.Equal(t, int64(0), result.Updated)
+	assert.Equal(t, int64(0), result.Disabled)
+
+	// 纯新增路径：CleanByProduct 不得被调用，索引集合必须仍保留 canary。
+	exists, err := rds.Exists(idxKey)
+	require.NoError(t, err)
+	assert.True(t, exists,
+		"added=3 / updated=0 / disabled=0 属于纯新增，不得触发 CleanByProduct；"+
+			"productIndexKey 若被删除说明 SyncPerms 仍在走全产品清缓存路径，回归：会把该产品"+
+			"所有在线用户下一次请求同时打穿回 DB")
+}
+
+// TC-1065: updated > 0 时必须触发 CleanByProduct
+func TestSyncPerms_UpdateTriggersCleanByProduct(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	conn := testutil.GetTestSqlConn()
+
+	pc := testutil.UniqueId()
+	appKey := testutil.UniqueId()
+	appSecret := testutil.UniqueId()
+	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
+	t.Cleanup(cleanProduct)
+	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
+
+	// 第一次同步：纯新增，为随后的 update 打底；这次不触发 Clean，CleanByProduct 仍然可被后续触发。
+	_, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
+		{Code: "r11_4_upd", Name: "OldName"},
+	})
+	require.NoError(t, err)
+
+	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
+	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
+
+	// 第二次同步：同一 Code 改 Name → updated=1。
+	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
+		{Code: "r11_4_upd", Name: "NewName"},
+	})
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	assert.Equal(t, int64(1), result.Updated,
+		"前置：同名 Code 改 Name 必须 updated=1，否则后续断言失去意义")
+
+	exists, err := rds.Exists(idxKey)
+	require.NoError(t, err)
+	assert.False(t, exists,
+		"updated>0 必须触发 CleanByProduct；若 canary 仍在，说明 Logic 把"+
+			"updated 情况也误归入'纯新增'分支，已存在 UD 缓存中的旧 perms 将长期对外返回")
+}
+
+// TC-1066: disabled > 0 时必须触发 CleanByProduct
+func TestSyncPerms_DisableTriggersCleanByProduct(t *testing.T) {
+	ctx := context.Background()
+	svcCtx := newTestSvcCtx()
+	cfg := testutil.GetTestConfig()
+	rds := redis.MustNewRedis(cfg.CacheRedis.Nodes[0].RedisConf)
+	conn := testutil.GetTestSqlConn()
+
+	pc := testutil.UniqueId()
+	appKey := testutil.UniqueId()
+	appSecret := testutil.UniqueId()
+	_, cleanProduct := insertSyncTestProduct(t, ctx, pc, appKey, appSecret, 1)
+	t.Cleanup(cleanProduct)
+	t.Cleanup(func() { testutil.CleanTableByField(ctx, conn, "`sys_perm`", "productCode", pc) })
+
+	// 先注入两个 perm。
+	_, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
+		{Code: "r11_4_keep", Name: "K"},
+		{Code: "r11_4_drop", Name: "D"},
+	})
+	require.NoError(t, err)
+
+	idxKey := primeProductIndex(t, rds, cfg.CacheRedis.KeyPrefix, pc)
+	t.Cleanup(func() { _, _ = rds.Del(idxKey) })
+
+	// 第二次只同步 r11_4_keep，r11_4_drop 会被 DisableNotInCodesWithTx 置 disabled。
+	result, err := ExecuteSyncPerms(ctx, svcCtx, appKey, appSecret, []SyncPermItem{
+		{Code: "r11_4_keep", Name: "K"},
+	})
+	require.NoError(t, err)
+	assert.Equal(t, int64(1), result.Disabled,
+		"前置：第二次只同步 keep，drop 必须被 disabled=1")
+
+	exists, err := rds.Exists(idxKey)
+	require.NoError(t, err)
+	assert.False(t, exists,
+		"disabled>0 必须触发 CleanByProduct，否则已缓存的 UD.perms 里仍挂着"+
+			"已禁用权限，权限网关会把不再有效的权限判为 allow，产生权限残留")
+}
+
+func TestExecuteSyncPerms_DeduplicatesRequest(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	hashedSecret, err := bcrypt.GenerateFromPassword([]byte("s"), bcrypt.MinCost)
+	require.NoError(t, err)
+
+	mockProduct := mocks.NewMockSysProductModel(ctrl)
+	mockProduct.EXPECT().FindOneByAppKey(gomock.Any(), "ak").
+		Return(&productModel.SysProduct{
+			Id: 1, Code: "pc_dedup", AppKey: "ak", AppSecret: string(hashedSecret), Status: 1,
+		}, nil)
+	// LockByCodeTx 拿到的行必须 Status=1
+	mockProduct.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_dedup").
+		Return(&productModel.SysProduct{Id: 1, Code: "pc_dedup", Status: 1}, nil)
+
+	mockPerm := mocks.NewMockSysPermModel(ctrl)
+	mockPerm.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "pc_dedup").
+		Return(map[string]*permModel.SysPerm{}, nil)
+
+	var captured []*permModel.SysPerm
+	mockPerm.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+	mockPerm.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).
+		DoAndReturn(func(ctx context.Context, s sqlx.Session, items []*permModel.SysPerm) error {
+			captured = items
+			return nil
+		})
+	// 去重后 codes 只剩一个，DisableNotInCodesWithTx 用去重后的集合做 NOT IN。
+	mockPerm.EXPECT().DisableNotInCodesWithTx(gomock.Any(), nil, "pc_dedup", []string{"dup_code"}, gomock.Any()).
+		Return(int64(0), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Product: mockProduct, Perm: mockPerm,
+	})
+
+	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s", []SyncPermItem{
+		{Code: "dup_code", Name: "A"},
+		{Code: "dup_code", Name: "A-again"},
+		{Code: "dup_code", Name: "A-yet-again"},
+	})
+	require.NoError(t, err)
+	require.NotNil(t, result)
+
+	require.Len(t, captured, 1, "入参内 code 重复必须去重为 1 条，避免自撞 1062")
+	assert.Equal(t, "dup_code", captured[0].Code)
+	assert.Equal(t, "A", captured[0].Name,
+		"去重策略应稳定到首次出现，使行为可预测")
+}
+
+func newBaseProductMock(ctrl *gomock.Controller, code string) *mocks.MockSysProductModel {
+	hashed, _ := bcrypt.GenerateFromPassword([]byte("s"), bcrypt.MinCost)
+	m := mocks.NewMockSysProductModel(ctrl)
+	m.EXPECT().FindOneByAppKey(gomock.Any(), "ak").
+		Return(&productModel.SysProduct{
+			Id: 1, Code: code, AppKey: "ak", AppSecret: string(hashed), Status: 1,
+		}, nil)
+	return m
+}
+
+// TC-0843:  契约 —— 正常路径下 LockByCodeTx 必须先于 FindMapByProductCodeWithTx，
+// 且两者均在同一个 tx session 内被调用。
+func TestExecuteSyncPerms_LockBeforeMapReadInTx(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	productMock := newBaseProductMock(ctrl, "pc_tx_order")
+	permMock := mocks.NewMockSysPermModel(ctrl)
+
+	// 关键点 1：TransactCtx 必须真的传入一个 tx session，并把所有子调用都发生在其中。
+	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil) // nil session 只是 mock 占位
+		})
+
+	// 关键点 2：gomock 的 Call.After 强制 LockByCodeTx 先于 FindMapByProductCodeWithTx 执行。
+	// 顺序反过来的话 gomock 会在 Finish 时报错。
+	// 事务内复核 Status 必须 Status=1，否则走 403 分支不写 perm
+	lockCall := productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_order").
+		Return(&productModel.SysProduct{Id: 1, Code: "pc_tx_order", Status: 1}, nil)
+
+	permMock.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "pc_tx_order").
+		Return(map[string]*permModel.SysPerm{}, nil).
+		After(lockCall)
+
+	// 一条简单的 INSERT + DisableNotIn 让流程走完；非本 TC 的主断言。
+	permMock.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).Return(nil)
+	permMock.EXPECT().DisableNotInCodesWithTx(gomock.Any(), nil, "pc_tx_order", []string{"x"}, gomock.Any()).
+		Return(int64(0), nil)
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
+
+	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
+		[]SyncPermItem{{Code: "x", Name: "X"}})
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	assert.Equal(t, int64(1), result.Added, "lock 在 tx 内就位后应当能正常写入")
+}
+
+// TC-0844:  分支 —— tx 内 LockByCodeTx 返回 sqlx.ErrNotFound（产品在 tx 开启后被删），
+// 必须映射为 SyncPermsError{Code:404, Message:"产品不存在"}，而非 500。
+func TestExecuteSyncPerms_LockNotFound_Maps404(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	productMock := newBaseProductMock(ctrl, "pc_tx_gone")
+	permMock := mocks.NewMockSysPermModel(ctrl)
+
+	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+
+	productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_gone").
+		Return(nil, sqlx.ErrNotFound)
+
+	// 关键：锁失败后绝不能继续走 FindMapByProductCodeWithTx / BatchInsertWithTx。
+	// gomock 默认严格模式会在 Finish 时报 "unexpected call"，所以不为这些方法登记任何期望即可。
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
+	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
+		[]SyncPermItem{{Code: "x", Name: "X"}})
+
+	assert.Nil(t, result)
+	require.Error(t, err)
+
+	var se *SyncPermsError
+	require.True(t, errors.As(err, &se), "锁不到产品行必须产出 *SyncPermsError")
+	assert.Equal(t, 404, se.Code,
+		"tx 开启后 LockByCodeTx=ErrNotFound 意味着产品行在 tx 中不可见，应当返回 404 而非 500")
+	assert.Contains(t, se.Message, "产品不存在",
+		"文案应当能让调用方人眼秒懂是什么错误")
+}
+
+// TC-0845:  容错 —— tx 内 LockByCodeTx 冒出非 NotFound 的通用错误（driver/conn 异常），
+// 必须被事务回滚并被外层包裹为 SyncPermsError（500 级），而非原始 driver 错误直接冒出去。
+func TestExecuteSyncPerms_LockGenericError_WrappedAs500(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	productMock := newBaseProductMock(ctrl, "pc_tx_boom")
+	permMock := mocks.NewMockSysPermModel(ctrl)
+
+	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+
+	boom := errors.New("driver: connection lost")
+	productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_boom").
+		Return(nil, boom)
+	// 锁失败后同样不应调用后续方法。
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
+	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
+		[]SyncPermItem{{Code: "x", Name: "X"}})
+
+	assert.Nil(t, result)
+	require.Error(t, err)
+
+	var se *SyncPermsError
+	require.True(t, errors.As(err, &se), "底层错误必须被包成 *SyncPermsError，防止 driver 错误直接上抛")
+	assert.Equal(t, 500, se.Code,
+		"非 NotFound 的 DB 错误应当 fail-close 为 500，让接入方区别于 404/409")
+	assert.NotContains(t, se.Message, "connection lost",
+		"对外文案不能泄露原始 driver 错误（避免信息披露）")
+}

internal/logic/pub/syncPermsTxLock_audit_test.go

@@ -1,151 +0,0 @@
-package pub
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	permModel "perms-system-server/internal/model/perm"
-	productModel "perms-system-server/internal/model/product"
-	"perms-system-server/internal/testutil/mocks"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-	"golang.org/x/crypto/bcrypt"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 H-3 修复回归 —— ExecuteSyncPerms 必须在 tx 内
-//   1. 先调用 LockByCodeTx 锁住 sys_product 行；
-//   2. 再调用 FindMapByProductCodeWithTx（事务内读 perm map）。
-//
-// 为什么重要：
-//   - 修复前 perm map 的 "existing vs. new" 判断发生在 tx 外，两笔并发 sync 都可能
-//     认为 "code X 不存在"，之后都在 tx 内 INSERT，撞 UNIQUE(productCode, code) 导致 1062。
-//   - 修复后所有并发请求都要先排队拿到 product 行锁，才能读到一致的 existing 集合并写入，
-//     将 "并发同步同一个产品" 串行化。
-//
-// 这个文件只关心"拿锁"这一段的契约（执行顺序 / 错误路径），
-// 避免重叠 syncPermsConflict_audit_test.go 中的 1062 → 409 映射。
-// ---------------------------------------------------------------------------
-
-// newBaseProductMock 只认 appKey + 校验 secret + 产品启用，返回固定 Code="pc_tx"。
-func newBaseProductMock(ctrl *gomock.Controller, code string) *mocks.MockSysProductModel {
-	hashed, _ := bcrypt.GenerateFromPassword([]byte("s"), bcrypt.MinCost)
-	m := mocks.NewMockSysProductModel(ctrl)
-	m.EXPECT().FindOneByAppKey(gomock.Any(), "ak").
-		Return(&productModel.SysProduct{
-			Id: 1, Code: code, AppKey: "ak", AppSecret: string(hashed), Status: 1,
-		}, nil)
-	return m
-}
-
-// TC-0843: H-3 契约 —— 正常路径下 LockByCodeTx 必须先于 FindMapByProductCodeWithTx，
-// 且两者均在同一个 tx session 内被调用。
-func TestExecuteSyncPerms_LockBeforeMapReadInTx(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	productMock := newBaseProductMock(ctrl, "pc_tx_order")
-	permMock := mocks.NewMockSysPermModel(ctrl)
-
-	// 关键点 1：TransactCtx 必须真的传入一个 tx session，并把所有子调用都发生在其中。
-	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil) // nil session 只是 mock 占位
-		})
-
-	// 关键点 2：gomock 的 Call.After 强制 LockByCodeTx 先于 FindMapByProductCodeWithTx 执行。
-	// 顺序反过来的话 gomock 会在 Finish 时报错。
-	// 审计 M-R10-1：事务内复核 Status 必须 Status=1，否则走 403 分支不写 perm
-	lockCall := productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_order").
-		Return(&productModel.SysProduct{Id: 1, Code: "pc_tx_order", Status: 1}, nil)
-
-	permMock.EXPECT().FindMapByProductCodeWithTx(gomock.Any(), gomock.Any(), "pc_tx_order").
-		Return(map[string]*permModel.SysPerm{}, nil).
-		After(lockCall)
-
-	// 一条简单的 INSERT + DisableNotIn 让流程走完；非本 TC 的主断言。
-	permMock.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).Return(nil)
-	permMock.EXPECT().DisableNotInCodesWithTx(gomock.Any(), nil, "pc_tx_order", []string{"x"}, gomock.Any()).
-		Return(int64(0), nil)
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
-
-	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
-		[]SyncPermItem{{Code: "x", Name: "X"}})
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	assert.Equal(t, int64(1), result.Added, "H-3：lock 在 tx 内就位后应当能正常写入")
-}
-
-// TC-0844: H-3 分支 —— tx 内 LockByCodeTx 返回 sqlx.ErrNotFound（产品在 tx 开启后被删），
-// 必须映射为 SyncPermsError{Code:404, Message:"产品不存在"}，而非 500。
-func TestExecuteSyncPerms_LockNotFound_Maps404(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	productMock := newBaseProductMock(ctrl, "pc_tx_gone")
-	permMock := mocks.NewMockSysPermModel(ctrl)
-
-	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-
-	productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_gone").
-		Return(nil, sqlx.ErrNotFound)
-
-	// 关键：锁失败后绝不能继续走 FindMapByProductCodeWithTx / BatchInsertWithTx。
-	// gomock 默认严格模式会在 Finish 时报 "unexpected call"，所以不为这些方法登记任何期望即可。
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
-	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
-		[]SyncPermItem{{Code: "x", Name: "X"}})
-
-	assert.Nil(t, result)
-	require.Error(t, err)
-
-	var se *SyncPermsError
-	require.True(t, errors.As(err, &se), "H-3：锁不到产品行必须产出 *SyncPermsError")
-	assert.Equal(t, 404, se.Code,
-		"H-3：tx 开启后 LockByCodeTx=ErrNotFound 意味着产品行在 tx 中不可见，应当返回 404 而非 500")
-	assert.Contains(t, se.Message, "产品不存在",
-		"H-3：文案应当能让调用方人眼秒懂是什么错误")
-}
-
-// TC-0845: H-3 容错 —— tx 内 LockByCodeTx 冒出非 NotFound 的通用错误（driver/conn 异常），
-// 必须被事务回滚并被外层包裹为 SyncPermsError（500 级），而非原始 driver 错误直接冒出去。
-func TestExecuteSyncPerms_LockGenericError_WrappedAs500(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	productMock := newBaseProductMock(ctrl, "pc_tx_boom")
-	permMock := mocks.NewMockSysPermModel(ctrl)
-
-	permMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-
-	boom := errors.New("driver: connection lost")
-	productMock.EXPECT().LockByCodeTx(gomock.Any(), gomock.Any(), "pc_tx_boom").
-		Return(nil, boom)
-	// 锁失败后同样不应调用后续方法。
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{Product: productMock, Perm: permMock})
-	result, err := ExecuteSyncPerms(context.Background(), svcCtx, "ak", "s",
-		[]SyncPermItem{{Code: "x", Name: "X"}})
-
-	assert.Nil(t, result)
-	require.Error(t, err)
-
-	var se *SyncPermsError
-	require.True(t, errors.As(err, &se), "H-3：底层错误必须被包成 *SyncPermsError，防止 driver 错误直接上抛")
-	assert.Equal(t, 500, se.Code,
-		"H-3：非 NotFound 的 DB 错误应当 fail-close 为 500，让接入方区别于 404/409")
-	assert.NotContains(t, se.Message, "connection lost",
-		"H-3：对外文案不能泄露原始 driver 错误（避免信息披露）")
-}

internal/logic/role/bindRolePermsLogic_mock_test.go

@@ -35,7 +35,7 @@ func TestBindRolePerms_Mock_BatchInsertFail(t *testing.T) {
 			{Id: 20, ProductCode: pc, Code: "perm_20", Status: 1},
 		}, nil)
 
-	// 审计 M-R10-2：事务内以 LockByIdTx 锁 sys_role 行，再走 FindPermIdsByRoleIdTx 读最新 diff 基准
+	// 事务内以 LockByIdTx 锁 sys_role 行，再走 FindPermIdsByRoleIdTx 读最新 diff 基准
 	mockRole.EXPECT().LockByIdTx(gomock.Any(), nil, int64(1)).
 		Return(&roleModel.SysRole{Id: 1, ProductCode: pc}, nil)
 
@@ -46,7 +46,7 @@ func TestBindRolePerms_Mock_BatchInsertFail(t *testing.T) {
 		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
 			return fn(ctx, nil)
 		})
-	// audit M-2 修复：循环 DELETE 替换为批量 DeleteByRoleIdAndPermIdsTx；toRemove 为空时也被调用
+	// audit  修复：循环 DELETE 替换为批量 DeleteByRoleIdAndPermIdsTx；toRemove 为空时也被调用
 	mockRP.EXPECT().DeleteByRoleIdAndPermIdsTx(gomock.Any(), nil, int64(1), []int64(nil)).Return(nil)
 	mockRP.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).Return(dbErr)
 

internal/logic/role/bindRolePermsLogic_test.go

@@ -1,10 +1,14 @@
 package role
 
 import (
+	"context"
 	"errors"
 	"testing"
 	"time"
 
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
 	permModel "perms-system-server/internal/model/perm"
 	roleModel "perms-system-server/internal/model/role"
 	"perms-system-server/internal/model/roleperm"
@@ -12,10 +16,13 @@ import (
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+	"go.uber.org/mock/gomock"
 )
 
 // TC-0129: 正常绑定
@@ -183,7 +190,7 @@ func TestBindRolePerms_Rebind(t *testing.T) {
 	assert.ElementsMatch(t, []int64{permIds[1], permIds[2]}, got)
 }
 
-// TC-0132: 重复permId — H-5审计修复后静默去重
+// TC-0132: 重复permId — 后静默去重
 func TestBindRolePerms_DuplicatePermId(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -246,3 +253,59 @@ func TestBindRolePerms_MemberRejected(t *testing.T) {
 	require.True(t, errors.As(err, &ce))
 	assert.Equal(t, 403, ce.Code())
 }
+
+// 覆盖目标：角色更新 / 角色权限绑定的 post-commit 缓存清理
+// 必须是 "尽力而为"：事务已 COMMIT 成功后，任何缓存清理路径的失败只应记 Errorf，
+// 不得把 degraded 成功映射成 5xx 让客户端误触发重试。
+
+// adminCtx 是 post-commit 缓存降级回归用例共享的 super-admin context 构造器。
+// 同 package 下 TestUpdateRole_PostCommitUserIdsError_StaysSuccess 亦通过 package 作用域复用。
+func adminCtx(productCode string) context.Context {
+	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId:       1,
+		Username:     "admin",
+		IsSuperAdmin: true,
+		MemberType:   consts.MemberTypeAdmin,
+		Status:       consts.StatusEnabled,
+		ProductCode:  productCode,
+	})
+}
+
+// TC-0858: BindRolePerms —— tx 成功、FindUserIdsByRoleId 抛 err，logic 返回 nil。
+func TestBindRolePerms_PostCommitUserIdsError_StaysSuccess(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	rpMock := mocks.NewMockSysRolePermModel(ctrl)
+	urMock := mocks.NewMockSysUserRoleModel(ctrl)
+
+	roleMock.EXPECT().FindOne(gomock.Any(), int64(7)).
+		Return(&roleModel.SysRole{Id: 7, ProductCode: "pc_m4", PermsLevel: 50, Status: 1}, nil)
+
+	// existing 读 + diff + delete/insert 全部收敛进事务；事务首步 LockByIdTx 锁 sys_role 行。
+	rpMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
+			return fn(ctx, nil)
+		})
+	roleMock.EXPECT().LockByIdTx(gomock.Any(), nil, int64(7)).
+		Return(&roleModel.SysRole{Id: 7, ProductCode: "pc_m4", PermsLevel: 50, Status: 1}, nil)
+	rpMock.EXPECT().FindPermIdsByRoleIdTx(gomock.Any(), nil, int64(7)).Return([]int64{1}, nil)
+
+	rpMock.EXPECT().DeleteByRoleIdAndPermIdsTx(gomock.Any(), nil, int64(7), []int64{1}).
+		Return(nil)
+
+	// 关键断言：post-commit FindUserIdsByRoleId 返回 err，logic 必须吞掉 err。
+	urMock.EXPECT().FindUserIdsByRoleId(gomock.Any(), int64(7)).
+		Return(nil, errors.New("redis/db transient error"))
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Role: roleMock, RolePerm: rpMock, UserRole: urMock,
+	})
+
+	err := NewBindRolePermsLogic(adminCtx("pc_m4"), svcCtx).BindRolePerms(&types.BindPermsReq{
+		RoleId: 7, PermIds: []int64{},
+	})
+	require.NoError(t, err,
+		"post-commit 缓存步骤的 transient err 不应把 degraded 成功映射成 500")
+}

internal/logic/role/deleteRoleLogic_mock_test.go

@@ -34,7 +34,7 @@ func TestDeleteRole_Mock_UserRoleDeleteFail(t *testing.T) {
 	mockRP.EXPECT().DeleteByRoleIdTx(gomock.Any(), nil, int64(1)).Return(nil)
 
 	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
-	// M-D 修复：改为事务内 FOR UPDATE 读取 userIds
+	// -D 修复：改为事务内 FOR UPDATE 读取 userIds
 	mockUR.EXPECT().FindUserIdsByRoleIdForUpdateTx(gomock.Any(), nil, int64(1)).Return([]int64{}, nil)
 	mockUR.EXPECT().DeleteByRoleIdTx(gomock.Any(), nil, int64(1)).Return(dbErr)
 

internal/logic/role/postCommitCacheDegraded_audit_test.go

@@ -1,110 +0,0 @@
-package role
-
-import (
-	"context"
-	"errors"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	roleModel "perms-system-server/internal/model/role"
-	"perms-system-server/internal/testutil/mocks"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"github.com/zeromicro/go-zero/core/stores/sqlx"
-	"go.uber.org/mock/gomock"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计第 6 轮 M-4 修复回归 —— 角色更新 / 角色权限绑定的 post-commit 缓存清理
-// 必须是 "尽力而为"：事务已 COMMIT 成功后，任何缓存清理路径的失败只应记 Errorf，
-// 不得把 degraded 成功映射成 5xx 让客户端误触发重试。
-//
-// 场景：事务外 `FindUserIdsByRoleId` 返回 err。
-// 期望：handler 仍返回 nil，200 OK；客户端无须重试；旧缓存最终靠 TTL 过期兜底。
-// ---------------------------------------------------------------------------
-
-func adminCtx(productCode string) context.Context {
-	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId:       1,
-		Username:     "admin",
-		IsSuperAdmin: true,
-		MemberType:   consts.MemberTypeAdmin,
-		Status:       consts.StatusEnabled,
-		ProductCode:  productCode,
-	})
-}
-
-// TC-0858: BindRolePerms —— tx 成功、FindUserIdsByRoleId 抛 err，logic 返回 nil。
-func TestBindRolePerms_PostCommitUserIdsError_StaysSuccess(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	rpMock := mocks.NewMockSysRolePermModel(ctrl)
-	urMock := mocks.NewMockSysUserRoleModel(ctrl)
-
-	roleMock.EXPECT().FindOne(gomock.Any(), int64(7)).
-		Return(&roleModel.SysRole{Id: 7, ProductCode: "pc_m4", PermsLevel: 50, Status: 1}, nil)
-
-	// 审计 M-R10-2：existing 读 + diff + delete/insert 全部收敛进事务；事务首步 LockByIdTx 锁 sys_role 行。
-	rpMock.EXPECT().TransactCtx(gomock.Any(), gomock.Any()).
-		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
-			return fn(ctx, nil)
-		})
-	roleMock.EXPECT().LockByIdTx(gomock.Any(), nil, int64(7)).
-		Return(&roleModel.SysRole{Id: 7, ProductCode: "pc_m4", PermsLevel: 50, Status: 1}, nil)
-	rpMock.EXPECT().FindPermIdsByRoleIdTx(gomock.Any(), nil, int64(7)).Return([]int64{1}, nil)
-
-	rpMock.EXPECT().DeleteByRoleIdAndPermIdsTx(gomock.Any(), nil, int64(7), []int64{1}).
-		Return(nil)
-
-	// 关键断言：post-commit FindUserIdsByRoleId 返回 err，logic 必须吞掉 err。
-	urMock.EXPECT().FindUserIdsByRoleId(gomock.Any(), int64(7)).
-		Return(nil, errors.New("redis/db transient error"))
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Role: roleMock, RolePerm: rpMock, UserRole: urMock,
-	})
-
-	err := NewBindRolePermsLogic(adminCtx("pc_m4"), svcCtx).BindRolePerms(&types.BindPermsReq{
-		RoleId: 7, PermIds: []int64{},
-	})
-	require.NoError(t, err,
-		"M-4：post-commit 缓存步骤的 transient err 不应把 degraded 成功映射成 500")
-}
-
-// TC-0859: UpdateRole —— UpdateWithOptLock 成功，FindUserIdsByRoleId 失败，handler 返回 nil。
-func TestUpdateRole_PostCommitUserIdsError_StaysSuccess(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	t.Cleanup(ctrl.Finish)
-
-	roleMock := mocks.NewMockSysRoleModel(ctrl)
-	urMock := mocks.NewMockSysUserRoleModel(ctrl)
-
-	roleMock.EXPECT().FindOne(gomock.Any(), int64(9)).
-		Return(&roleModel.SysRole{
-			Id: 9, ProductCode: "pc_m4u", Name: "before",
-			PermsLevel: 50, Status: consts.StatusEnabled, UpdateTime: 100,
-		}, nil)
-
-	// UpdateWithOptLock 成功；签名：UpdateWithOptLock(ctx, role, prevUpdateTime)。
-	roleMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(100)).Return(nil)
-
-	// 关键断言：post-commit transient err 不应导致 handler 失败。
-	urMock.EXPECT().FindUserIdsByRoleId(gomock.Any(), int64(9)).
-		Return(nil, errors.New("boom"))
-
-	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
-		Role: roleMock, UserRole: urMock,
-	})
-
-	err := NewUpdateRoleLogic(adminCtx("pc_m4u"), svcCtx).UpdateRole(&types.UpdateRoleReq{
-		Id: 9, Name: "after", Remark: "r", PermsLevel: 60, Status: 0,
-	})
-	assert.NoError(t, err,
-		"M-4：UpdateRole 已提交成功，post-commit 缓存失败只记日志，handler 必须返回 nil")
-}

internal/logic/role/roleDetailLogic_test.go

@@ -2,9 +2,8 @@ package role
 
 import (
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	permModel "perms-system-server/internal/model/perm"
 	roleModel "perms-system-server/internal/model/role"
 	"perms-system-server/internal/model/roleperm"
@@ -13,12 +12,10 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
-// TC-0124: 正常查询
 func TestRoleDetail_Normal(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -89,3 +86,116 @@ func TestRoleDetail_NotFound(t *testing.T) {
 	assert.Equal(t, 404, ce.Code())
 	assert.Equal(t, "角色不存在", ce.Error())
 }
+
+func TestRoleDetail_MN3_CrossProductReturns404NotFound(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+
+	// 插入别的产品（"test_product2"）下的 role
+	otherProduct := "mn3_other_" + testutil.UniqueId()
+	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
+		ProductCode: otherProduct, Name: "mn3_role_" + testutil.UniqueId(),
+		Remark: "mn3", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	roleId, _ := roleRes.LastInsertId()
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_role`", roleId) })
+
+	// Admin 身份在 "test_product" 下访问 "mn3_other_*" 的 roleId
+	adminCtx := ctxhelper.AdminCtx("test_product")
+	resp, err := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: roleId})
+	assert.Nil(t, resp)
+	require.Error(t, err)
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 404, ce.Code(),
+		"跨产品访问必须 404，不得以 403 暴露存在性")
+	assert.Equal(t, "角色不存在", ce.Error(),
+		"响应文案必须与 'id 真实不存在' 完全一致，彻底关闭枚举 oracle")
+}
+
+// TC-1001:  对照 —— "id 不存在" 的响应必须与 "跨产品访问" 完全一致（code 与 body）。
+func TestRoleDetail_MN3_NotFoundAndCrossProduct_Indistinguishable(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	ctx := ctxhelper.SuperAdminCtx()
+	now := time.Now().Unix()
+
+	// 预埋一条别的产品的角色
+	otherProduct := "mn3_cmp_" + testutil.UniqueId()
+	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
+		ProductCode: otherProduct, Name: "mn3cmp_" + testutil.UniqueId(),
+		Remark: "", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	existingId, _ := roleRes.LastInsertId()
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_role`", existingId) })
+
+	adminCtx := ctxhelper.AdminCtx("test_product")
+
+	// (A) 跨产品访问真实存在的 id
+	_, errCross := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: existingId})
+	require.Error(t, errCross)
+	var ceA *response.CodeError
+	require.True(t, errors.As(errCross, &ceA))
+
+	// (B) 访问一个肯定不存在的 id（id 选在 existingId + 很大偏移，规避数据库递增到该值）
+	_, errAbsent := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(
+		&types.RoleDetailReq{Id: existingId + 999_999_999},
+	)
+	require.Error(t, errAbsent)
+	var ceB *response.CodeError
+	require.True(t, errors.As(errAbsent, &ceB))
+
+	// 响应码与文案必须完全一致，不给任何侧信道
+	assert.Equal(t, ceB.Code(), ceA.Code(),
+		"跨产品 vs id 不存在必须返回相同 code")
+	assert.Equal(t, ceB.Error(), ceA.Error(),
+		"跨产品 vs id 不存在必须返回相同 body")
+}
+
+// TC-1002: 超管跨产品仍然可以正常访问（/运维路径不能被误伤）。
+func TestRoleDetail_MN3_SuperAdminCanStillAccessCrossProduct(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+
+	otherProduct := "mn3_sa_" + testutil.UniqueId()
+	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
+		ProductCode: otherProduct, Name: "mn3sa_" + testutil.UniqueId(),
+		Remark: "sa_cross", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	roleId, _ := roleRes.LastInsertId()
+
+	permRes, err := svcCtx.SysPermModel.Insert(ctx, &permModel.SysPerm{
+		ProductCode: otherProduct, Name: "mn3sa_p_" + testutil.UniqueId(), Code: testutil.UniqueId(),
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	permId, _ := permRes.LastInsertId()
+
+	rpRes, err := svcCtx.SysRolePermModel.Insert(ctx, &roleperm.SysRolePerm{
+		RoleId: roleId, PermId: permId, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	rpId, _ := rpRes.LastInsertId()
+
+	t.Cleanup(func() {
+		testutil.CleanTable(ctx, conn, "`sys_role_perm`", rpId)
+		testutil.CleanTable(ctx, conn, "`sys_perm`", permId)
+		testutil.CleanTable(ctx, conn, "`sys_role`", roleId)
+	})
+
+	// 超管在 "test_product" 当前身份，但跨产品访问 "mn3_sa_*" 的 role，应允许
+	resp, err := NewRoleDetailLogic(ctx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: roleId})
+	require.NoError(t, err, "超管必须能跨产品查看 role，支撑/运维路径")
+	require.NotNil(t, resp)
+	assert.Equal(t, roleId, resp.Id)
+	assert.Equal(t, otherProduct, resp.ProductCode)
+	assert.Contains(t, resp.PermIds, permId)
+}

internal/logic/role/roleDetailOracle_audit_test.go

@@ -1,141 +0,0 @@
-package role
-
-import (
-	"errors"
-	"testing"
-	"time"
-
-	permModel "perms-system-server/internal/model/perm"
-	roleModel "perms-system-server/internal/model/role"
-	"perms-system-server/internal/model/roleperm"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-N3 修复 —— RoleDetail 必须消除"角色不存在 vs 跨产品访问"的枚举 oracle。
-// 旧实现：存在但在别的产品 → 403；不存在 → 404。遍历 id 即可画出跨产品 roleId 分布图。
-// 新契约：
-//   - 非超管跨产品访问 → 404 "角色不存在"（与真正 NotFound 响应体完全一致）
-//   - 超管仍可跨产品访问（审计/运维需要）
-// ---------------------------------------------------------------------------
-
-// TC-1000: M-N3 —— 非超管访问别的产品的 role 必须 404，与 "id 不存在" 响应体一致。
-func TestRoleDetail_MN3_CrossProductReturns404NotFound(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-
-	// 插入别的产品（"test_product2"）下的 role
-	otherProduct := "mn3_other_" + testutil.UniqueId()
-	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
-		ProductCode: otherProduct, Name: "mn3_role_" + testutil.UniqueId(),
-		Remark: "mn3", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	roleId, _ := roleRes.LastInsertId()
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_role`", roleId) })
-
-	// Admin 身份在 "test_product" 下访问 "mn3_other_*" 的 roleId
-	adminCtx := ctxhelper.AdminCtx("test_product")
-	resp, err := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: roleId})
-	assert.Nil(t, resp)
-	require.Error(t, err)
-
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 404, ce.Code(),
-		"M-N3：跨产品访问必须 404，不得以 403 暴露存在性")
-	assert.Equal(t, "角色不存在", ce.Error(),
-		"M-N3：响应文案必须与 'id 真实不存在' 完全一致，彻底关闭枚举 oracle")
-}
-
-// TC-1001: M-N3 对照 —— "id 不存在" 的响应必须与 "跨产品访问" 完全一致（code 与 body）。
-func TestRoleDetail_MN3_NotFoundAndCrossProduct_Indistinguishable(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	ctx := ctxhelper.SuperAdminCtx()
-	now := time.Now().Unix()
-
-	// 预埋一条别的产品的角色
-	otherProduct := "mn3_cmp_" + testutil.UniqueId()
-	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
-		ProductCode: otherProduct, Name: "mn3cmp_" + testutil.UniqueId(),
-		Remark: "", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	existingId, _ := roleRes.LastInsertId()
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_role`", existingId) })
-
-	adminCtx := ctxhelper.AdminCtx("test_product")
-
-	// (A) 跨产品访问真实存在的 id
-	_, errCross := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: existingId})
-	require.Error(t, errCross)
-	var ceA *response.CodeError
-	require.True(t, errors.As(errCross, &ceA))
-
-	// (B) 访问一个肯定不存在的 id（id 选在 existingId + 很大偏移，规避数据库递增到该值）
-	_, errAbsent := NewRoleDetailLogic(adminCtx, svcCtx).RoleDetail(
-		&types.RoleDetailReq{Id: existingId + 999_999_999},
-	)
-	require.Error(t, errAbsent)
-	var ceB *response.CodeError
-	require.True(t, errors.As(errAbsent, &ceB))
-
-	// 响应码与文案必须完全一致，不给任何侧信道
-	assert.Equal(t, ceB.Code(), ceA.Code(),
-		"M-N3：跨产品 vs id 不存在必须返回相同 code")
-	assert.Equal(t, ceB.Error(), ceA.Error(),
-		"M-N3：跨产品 vs id 不存在必须返回相同 body")
-}
-
-// TC-1002: M-N3 —— 超管跨产品仍然可以正常访问（审计/运维路径不能被误伤）。
-func TestRoleDetail_MN3_SuperAdminCanStillAccessCrossProduct(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-
-	otherProduct := "mn3_sa_" + testutil.UniqueId()
-	roleRes, err := svcCtx.SysRoleModel.Insert(ctx, &roleModel.SysRole{
-		ProductCode: otherProduct, Name: "mn3sa_" + testutil.UniqueId(),
-		Remark: "sa_cross", Status: 1, PermsLevel: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	roleId, _ := roleRes.LastInsertId()
-
-	permRes, err := svcCtx.SysPermModel.Insert(ctx, &permModel.SysPerm{
-		ProductCode: otherProduct, Name: "mn3sa_p_" + testutil.UniqueId(), Code: testutil.UniqueId(),
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	permId, _ := permRes.LastInsertId()
-
-	rpRes, err := svcCtx.SysRolePermModel.Insert(ctx, &roleperm.SysRolePerm{
-		RoleId: roleId, PermId: permId, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	rpId, _ := rpRes.LastInsertId()
-
-	t.Cleanup(func() {
-		testutil.CleanTable(ctx, conn, "`sys_role_perm`", rpId)
-		testutil.CleanTable(ctx, conn, "`sys_perm`", permId)
-		testutil.CleanTable(ctx, conn, "`sys_role`", roleId)
-	})
-
-	// 超管在 "test_product" 当前身份，但跨产品访问 "mn3_sa_*" 的 role，应允许
-	resp, err := NewRoleDetailLogic(ctx, svcCtx).RoleDetail(&types.RoleDetailReq{Id: roleId})
-	require.NoError(t, err, "超管必须能跨产品查看 role，支撑审计/运维路径")
-	require.NotNil(t, resp)
-	assert.Equal(t, roleId, resp.Id)
-	assert.Equal(t, otherProduct, resp.ProductCode)
-	assert.Contains(t, resp.PermIds, permId)
-}

internal/logic/role/updateRoleAudit_test.go

@@ -16,8 +16,11 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// TC-0730: L-3 修复：非超管 admin 不能降低角色 PermsLevel
-func TestUpdateRole_NonSuperAdminCannotDemoteLevel(t *testing.T) {
+// TC-0730:  修复：非超管 admin 不能把角色权限**提升**（数字越小 = 权限越高）
+// 修复前的源码注释写作"不能降低 PermsLevel"，与实际代码 `req.PermsLevel < role.PermsLevel → 403`
+// 的语义相反（数字越小 = 权限越高，`<` 拦截的是"提升")； 把 Error msg 与注释一并修正，
+// 测试随之把断言从"不能降低"改为"不能提升"，钉死 R12 后的语义契约。
+func TestUpdateRole_NonSuperAdminCannotPromoteLevel(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
 	conn := testutil.GetTestSqlConn()
@@ -37,21 +40,24 @@ func TestUpdateRole_NonSuperAdminCannotDemoteLevel(t *testing.T) {
 	})
 
 	adminCtx := ctxhelper.AdminCtx(pc)
+	// 100 → 10：数字变小 = 权限提升，修复后应被拒
 	err = NewUpdateRoleLogic(adminCtx, svcCtx).UpdateRole(&types.UpdateRoleReq{
-		Id: roleId, Name: "low", Remark: "demote attempt", PermsLevel: 10,
+		Id: roleId, Name: "high", Remark: "promote attempt", PermsLevel: 10,
 	})
 	require.Error(t, err)
 	var ce *response.CodeError
 	require.True(t, errors.As(err, &ce))
 	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "不能降低角色的权限级别")
+	assert.Contains(t, ce.Error(), "不能提升角色的权限级别",
+		"错误消息必须与代码语义一致；历史上这里写作'不能降低'，方向反向，"+
+			"本断言锁死 R12 修复后的正向消息，不允许回退")
 
 	persisted, err := svcCtx.SysRoleModel.FindOne(ctx, roleId)
 	require.NoError(t, err)
 	assert.Equal(t, int64(100), persisted.PermsLevel, "PermsLevel 必须保持不变")
 }
 
-// TC-0731: L-3 修复：非超管 admin 可以保持或提升 PermsLevel
+// TC-0731:  修复：非超管 admin 可以保持或提升 PermsLevel
 func TestUpdateRole_NonSuperAdminCanRaiseOrKeepLevel(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -85,7 +91,7 @@ func TestUpdateRole_NonSuperAdminCanRaiseOrKeepLevel(t *testing.T) {
 	assert.Equal(t, int64(500), persisted.PermsLevel)
 }
 
-// TC-0732: L-3：超管可以任意降低 PermsLevel
+// TC-0732: ：超管可以任意降低 PermsLevel
 func TestUpdateRole_SuperAdminCanDemoteLevel(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -114,7 +120,7 @@ func TestUpdateRole_SuperAdminCanDemoteLevel(t *testing.T) {
 	assert.Equal(t, int64(10), persisted.PermsLevel)
 }
 
-// TC-0733: L-3：边界 PermsLevel 校验
+// TC-0733: ：边界 PermsLevel 校验
 func TestUpdateRole_PermsLevelBoundary(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())

internal/logic/role/updateRoleLogic.go

@@ -30,7 +30,15 @@ func NewUpdateRoleLogic(ctx context.Context, svcCtx *svc.ServiceContext) *Update
 	}
 }
 
-// UpdateRole 更新角色。修改角色名称、备注、权限级别和启用/禁用状态。非超管不能降低权限级别。变更后自动清理绑定该角色的用户缓存。
+// UpdateRole 更新角色。修改角色名称、备注、权限级别和启用/禁用状态。
+//
+// 权限级别约定（与 UserDetailsLoader.loadRoles / MinPermsLevel 计算一致）：
+// **数字越小 = 权限越高**（MinPermsLevel 取当前用户所有启用角色 permsLevel 的最小值）。
+// 因此 `req.PermsLevel < role.PermsLevel` 表示"把角色调到比当前更高的权限"，非超管该路径被拒绝。
+//
+// 变更后自动清理绑定该角色的用户缓存（BatchDel 是尽力而为，失败仅记日志由 TTL 兜底）。
+// 审计 L-R12-3：此处历史注释曾写作"非超管不能**降低**权限级别"，与代码实际语义相反；
+// 已改为"非超管不能**提升**权限级别"，并在本注释显式钉上"数字越小 = 权限越高"的约定。
 func (l *UpdateRoleLogic) UpdateRole(req *types.UpdateRoleReq) error {
 	role, err := l.svcCtx.SysRoleModel.FindOne(l.ctx, req.Id)
 	if err != nil {
@@ -53,8 +61,13 @@ func (l *UpdateRoleLogic) UpdateRole(req *types.UpdateRoleReq) error {
 	}
 
 	caller := middleware.GetUserDetails(l.ctx)
+	// 审计 L-R12-3：数字越小 = 权限越高；`req.PermsLevel < role.PermsLevel` 即"把角色调更高权"。
+	// 非超管 product ADMIN 在本产品内有全权，提升 / 降低都不构成越权；真正的越权边界由
+	// BindRoles 的 GuardRoleLevelAssignable 守住（caller 不能把比自己 MinPermsLevel 更高权
+	// 的角色绑到他人）。本校验仅作为"不让 non-super 在产品内通过改角色权级把自己悄悄顶到
+	// 超管线"的护栏，防御面较窄但留着成本可忽略。
 	if caller != nil && !caller.IsSuperAdmin && req.PermsLevel < role.PermsLevel {
-		return response.ErrForbidden("非超管不能降低角色的权限级别")
+		return response.ErrForbidden("非超管不能提升角色的权限级别")
 	}
 
 	prevUpdateTime := role.UpdateTime

internal/logic/role/updateRoleLogic_test.go

@@ -5,15 +5,18 @@ import (
 	"testing"
 	"time"
 
+	"perms-system-server/internal/consts"
 	roleModel "perms-system-server/internal/model/role"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
+	"perms-system-server/internal/testutil/mocks"
 	"perms-system-server/internal/types"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
 )
 
 // TC-0120: 正常更新
@@ -96,3 +99,39 @@ func TestUpdateRole_MemberRejected(t *testing.T) {
 	require.True(t, errors.As(err, &ce))
 	assert.Equal(t, 403, ce.Code())
 }
+
+// 覆盖目标：事务已 COMMIT 成功后，
+// 任何缓存清理路径的失败只应记 Errorf，不得把 degraded 成功映射成 5xx 让客户端误触发重试。
+// adminCtx helper 定义于 bindRolePermsLogic_test.go (同 package role)。
+
+// TC-0859: UpdateRole —— UpdateWithOptLock 成功，FindUserIdsByRoleId 失败，handler 返回 nil。
+func TestUpdateRole_PostCommitUserIdsError_StaysSuccess(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+
+	roleMock := mocks.NewMockSysRoleModel(ctrl)
+	urMock := mocks.NewMockSysUserRoleModel(ctrl)
+
+	roleMock.EXPECT().FindOne(gomock.Any(), int64(9)).
+		Return(&roleModel.SysRole{
+			Id: 9, ProductCode: "pc_m4u", Name: "before",
+			PermsLevel: 50, Status: consts.StatusEnabled, UpdateTime: 100,
+		}, nil)
+
+	// UpdateWithOptLock 成功；签名：UpdateWithOptLock(ctx, role, prevUpdateTime)。
+	roleMock.EXPECT().UpdateWithOptLock(gomock.Any(), gomock.Any(), int64(100)).Return(nil)
+
+	// 关键断言：post-commit transient err 不应导致 handler 失败。
+	urMock.EXPECT().FindUserIdsByRoleId(gomock.Any(), int64(9)).
+		Return(nil, errors.New("boom"))
+
+	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
+		Role: roleMock, UserRole: urMock,
+	})
+
+	err := NewUpdateRoleLogic(adminCtx("pc_m4u"), svcCtx).UpdateRole(&types.UpdateRoleReq{
+		Id: 9, Name: "after", Remark: "r", PermsLevel: 60, Status: 0,
+	})
+	assert.NoError(t, err,
+		"UpdateRole 已提交成功，post-commit 缓存失败只记日志，handler 必须返回 nil")
+}

internal/logic/user/bindRolesEqualLevel_audit_test.go

@@ -1,124 +0,0 @@
-package user
-
-import (
-	"errors"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	userModel "perms-system-server/internal/model/user"
-	userroleModel "perms-system-server/internal/model/userrole"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// seedCallerWithRoleLevel 为调用者落地真实 DB 记录（user + role + user_role），
-// 保证审计 M-3 修复（GuardRoleLevelAssignable 的 fresh DB 读）生效后，
-// FindMinPermsLevelByUserIdAndProductCode 能命中调用者真实的 permsLevel。
-// 修复前的测试用假 UserId 即可走通，修复后必须落地真实关系链才能触发越级拦截。
-func seedCallerWithRoleLevel(t *testing.T, svcCtx *svc.ServiceContext, productCode string, callerLevel int64) (int64, func()) {
-	t.Helper()
-	superCtx := ctxhelper.SuperAdminCtx()
-	conn := testutil.GetTestSqlConn()
-
-	callerUserId := insertTestUserFull(t, superCtx, &userModel.SysUser{
-		Username: "caller_" + testutil.UniqueId(), Password: testutil.HashPassword("pass"),
-		Nickname: "caller_seed", DeptId: 0,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: 2, Status: consts.StatusEnabled,
-	})
-	mId := insertTestMember(t, svcCtx, productCode, callerUserId)
-	roleId := insertTestRoleWithLevel(t, svcCtx, productCode, consts.StatusEnabled, callerLevel)
-
-	now := time.Now().Unix()
-	_, err := svcCtx.SysUserRoleModel.Insert(superCtx, &userroleModel.SysUserRole{
-		UserId:     callerUserId,
-		RoleId:     roleId,
-		CreateTime: now,
-		UpdateTime: now,
-	})
-	require.NoError(t, err)
-
-	cleanup := func() {
-		testutil.CleanTableByField(superCtx, conn, "`sys_user_role`", "userId", callerUserId)
-		testutil.CleanTable(superCtx, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(superCtx, conn, "`sys_user`", callerUserId)
-		testutil.CleanTable(superCtx, conn, "`sys_role`", roleId)
-	}
-	return callerUserId, cleanup
-}
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-3 修复 —— "不能分配与自己同级（或更高）的角色"。
-// 修复前代码仅拦 `>` 严格高于，允许 MEMBER 调用者把同级角色分配给别人，继而下一次 BindRoles 时
-// 由于同级权限集相同，可用后续 upgrade 路径放大；修复后变为 `<=`（含同级）拦截。
-// 本文件作为"同级也必须 403"的契约锚点。
-// ---------------------------------------------------------------------------
-
-// TC-0813: H-3 —— MEMBER 调用者不能分配与自己同 permsLevel 的角色。
-func TestBindRoles_EqualPermsLevel_Rejected(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	superCtx := ctxhelper.SuperAdminCtx()
-
-	deptId, deptPath, cleanupDept := setupDeptForCaller(t, svcCtx)
-	t.Cleanup(cleanupDept)
-
-	productCode := "test_product"
-	username := testutil.UniqueId()
-	targetUserId := insertTestUserFull(t, superCtx, &userModel.SysUser{
-		Username: username, Password: testutil.HashPassword("pass"),
-		Nickname: "tgt_eq", DeptId: deptId,
-		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: 2, Status: consts.StatusEnabled,
-	})
-	mId := insertTestMember(t, svcCtx, productCode, targetUserId)
-
-	const callerLevel int64 = 50
-	sameLevelRole := insertTestRoleWithLevel(t, svcCtx, productCode, consts.StatusEnabled, callerLevel)
-
-	// M-3 修复后 GuardRoleLevelAssignable 走 DB 强一致读取 caller 的 MinPermsLevel，
-	// 因此需要在 DB 里为调用者落地真实的 user + role + user_role 关系链。
-	callerUserId, callerCleanup := seedCallerWithRoleLevel(t, svcCtx, productCode, callerLevel)
-	t.Cleanup(callerCleanup)
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(superCtx, conn, "`sys_user_role`", "userId", targetUserId)
-		testutil.CleanTable(superCtx, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(superCtx, conn, "`sys_user`", targetUserId)
-		testutil.CleanTable(superCtx, conn, "`sys_role`", sameLevelRole)
-	})
-
-	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
-		UserId:        callerUserId,
-		Username:      "member_eq_level",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   productCode,
-		DeptId:        deptId,
-		DeptPath:      deptPath,
-		MinPermsLevel: callerLevel,
-	})
-
-	err := NewBindRolesLogic(ctx, svcCtx).BindRoles(&types.BindRolesReq{
-		UserId:  targetUserId,
-		RoleIds: []int64{sameLevelRole},
-	})
-	require.Error(t, err, "H-3 防线：同级角色分配必须被拒绝（含同级）")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "不能分配权限级别高于自身的角色",
-		"错误消息应当明确点出'含同级'的拦截语义")
-
-	// 同时验证 DB 未产生任何 user-role 关系。
-	rids, err := svcCtx.SysUserRoleModel.FindRoleIdsByUserIdForProduct(ctx, targetUserId, productCode)
-	require.NoError(t, err)
-	assert.Empty(t, rids, "被拒绝的 BindRoles 不得落地任何行")
-}

internal/logic/user/bindRolesLogic.go

@@ -2,6 +2,7 @@ package user
 
 import (
 	"context"
+	"errors"
 	"time"
 
 	"perms-system-server/internal/consts"
@@ -112,6 +113,21 @@ func (l *BindRolesLogic) BindRoles(req *types.BindRolesReq) error {
 			return err
 		}
 
+		// 审计 M-R12-1：对本次将要出现在 sys_user_role 里的 roleIds（事务外校验通过的入参集合）
+		// 加 S 锁，闭合与 DeleteRole 的写偏斜。DeleteRole 末尾对 sys_role[R] 的 X 锁会被本 S 锁
+		// 阻塞；等 BindRoles 提交后，DeleteRole 会在 FindUserIdsByRoleIdForUpdateTx 里看到新插入
+		// 的绑定行，下游 BatchDel 能覆盖到这批用户缓存，不再留下孤儿 sys_user_role。
+		// 注：只锁"本次请求携带的 roleIds"——已有但未出现在本次请求里的 existing 角色会被 diff
+		// 到 toRemove，DELETE 自身就会对 sys_user_role 行取 X 锁，不依赖 sys_role 的 S 锁。
+		if len(roleIds) > 0 {
+			if err := l.svcCtx.SysRoleModel.LockRolesForShareTx(ctx, session, roleIds); err != nil {
+				if errors.Is(err, sqlx.ErrNotFound) {
+					return response.ErrBadRequest("包含已被删除或已禁用的角色ID")
+				}
+				return err
+			}
+		}
+
 		existingRoleIds, err := l.svcCtx.SysUserRoleModel.FindRoleIdsByUserIdForProductTx(ctx, session, req.UserId, productCode)
 		if err != nil {
 			return err

internal/logic/user/bindRolesLogic_mock_test.go

@@ -31,7 +31,7 @@ func TestBindRoles_Mock_BatchInsertFail(t *testing.T) {
 	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
 	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "test_product", int64(1)).
 		Return(&memberModel.SysProductMember{Id: 1, ProductCode: "test_product", UserId: 1, Status: 1}, nil)
-	// 审计 M-R10-2：事务首步 FindOneForUpdateTx 锁 sys_product_member 行
+	// 事务首步 FindOneForUpdateTx 锁 sys_product_member 行
 	mockPM.EXPECT().FindOneForUpdateTx(gomock.Any(), nil, int64(1)).
 		Return(&memberModel.SysProductMember{Id: 1, ProductCode: "test_product", UserId: 1, Status: 1}, nil)
 
@@ -41,6 +41,10 @@ func TestBindRoles_Mock_BatchInsertFail(t *testing.T) {
 			{Id: 10, ProductCode: "test_product", Status: 1},
 			{Id: 20, ProductCode: "test_product", Status: 1},
 		}, nil)
+	// 事务内对 toAdd/入参 roleIds 加 S 锁以闭合 BindRoles × DeleteRole 写偏斜。
+	// mock 直接放行（真实表现为 `SELECT id FROM sys_role WHERE id IN (10,20) AND status=1 LOCK IN SHARE MODE`
+	// 命中两行无错）。
+	mockRole.EXPECT().LockRolesForShareTx(gomock.Any(), nil, []int64{10, 20}).Return(nil)
 
 	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
 	mockUR.EXPECT().FindRoleIdsByUserIdForProductTx(gomock.Any(), nil, int64(1), "test_product").Return([]int64{}, nil)
@@ -49,7 +53,7 @@ func TestBindRoles_Mock_BatchInsertFail(t *testing.T) {
 		DoAndReturn(func(ctx context.Context, fn func(context.Context, sqlx.Session) error) error {
 			return fn(ctx, nil)
 		})
-	// audit M-2 修复：循环 DELETE 替换为批量 DeleteByUserIdAndRoleIdsTx；toRemove 为空时也被调用
+	// audit  修复：循环 DELETE 替换为批量 DeleteByUserIdAndRoleIdsTx；toRemove 为空时也被调用
 	mockUR.EXPECT().DeleteByUserIdAndRoleIdsTx(gomock.Any(), nil, int64(1), []int64(nil)).Return(nil)
 	mockUR.EXPECT().BatchInsertWithTx(gomock.Any(), nil, gomock.Any()).Return(dbErr)
 

internal/logic/user/bindRolesLogic_test.go

@@ -1,26 +1,29 @@
 package user
 
 import (
+	"context"
 	"errors"
 	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"math"
-	"testing"
-	"time"
-
 	"perms-system-server/internal/consts"
 	"perms-system-server/internal/loaders"
+	roleLogic "perms-system-server/internal/logic/role"
 	deptModel "perms-system-server/internal/model/dept"
 	memberModel "perms-system-server/internal/model/productmember"
 	roleModel "perms-system-server/internal/model/role"
 	userModel "perms-system-server/internal/model/user"
+	userroleModel "perms-system-server/internal/model/userrole"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
 )
 
 func insertTestMember(t *testing.T, svcCtx *svc.ServiceContext, productCode string, userId int64) int64 {
@@ -320,7 +323,7 @@ func setupDeptForCaller(t *testing.T, svcCtx *svc.ServiceContext) (int64, string
 	return deptId, path, cleanup
 }
 
-// TC-0208: MEMBER 调用者不能分配权限级别高于自身的角色 (audit H-1 修复后 permsLevel 仅对 MEMBER 生效)
+// TC-0208: MEMBER 调用者不能分配权限级别高于自身的角色 (audit  修复后 permsLevel 仅对 MEMBER 生效)
 func TestBindRoles_PermsLevelEscalation_Rejected(t *testing.T) {
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
 	conn := testutil.GetTestSqlConn()
@@ -341,7 +344,7 @@ func TestBindRoles_PermsLevelEscalation_Rejected(t *testing.T) {
 
 	highLevelRole := insertTestRoleWithLevel(t, svcCtx, productCode, 1, 1)
 
-	// M-3 修复后 GuardRoleLevelAssignable 走 DB 强一致读取 caller 的 MinPermsLevel，
+	// 修复后 GuardRoleLevelAssignable 走 DB 强一致读取 caller 的 MinPermsLevel，
 	// 因此需要在 DB 里为调用者落地真实的 user + role + user_role 关系链（permsLevel=50）。
 	callerUserId, callerCleanup := seedCallerWithRoleLevel(t, svcCtx, productCode, 50)
 	t.Cleanup(callerCleanup)
@@ -378,9 +381,11 @@ func TestBindRoles_PermsLevelEscalation_Rejected(t *testing.T) {
 	assert.Contains(t, ce.Error(), "不能分配权限级别高于自身的角色")
 }
 
-// TC-0711: ADMIN 调用者（MinPermsLevel=math.MaxInt64）不受 permsLevel 校验约束 (audit H-1 回归)
+// TC-0711: ADMIN 调用者（MinPermsLevel=math.MaxInt64）不受 permsLevel 校验约束 (audit  回归)
 // 修复前：ADMIN 通过 member_type 获得权限，MinPermsLevel 保持 math.MaxInt64，
-//   r.PermsLevel < math.MaxInt64 必然成立 → ADMIN 无法绑定任何角色。
+//
+//	r.PermsLevel < math.MaxInt64 必然成立 → ADMIN 无法绑定任何角色。
+//
 // 修复后：代码显式豁免 ADMIN/DEVELOPER 的 permsLevel 校验。
 func TestBindRoles_AdminBypassesPermsLevelCheck(t *testing.T) {
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -419,14 +424,14 @@ func TestBindRoles_AdminBypassesPermsLevelCheck(t *testing.T) {
 		UserId:  userId,
 		RoleIds: []int64{lowLevelRole},
 	})
-	require.NoError(t, err, "ADMIN 调用者应当能绑定任意级别的角色 (audit H-1)")
+	require.NoError(t, err, "ADMIN 调用者应当能绑定任意级别的角色")
 
 	roleIds, err := svcCtx.SysUserRoleModel.FindRoleIdsByUserId(ctx, userId)
 	require.NoError(t, err)
 	assert.Contains(t, roleIds, lowLevelRole)
 }
 
-// TC-0712: DEVELOPER 调用者同样不受 permsLevel 校验约束 (audit H-1 回归)
+// TC-0712: DEVELOPER 调用者同样不受 permsLevel 校验约束 (audit  回归)
 func TestBindRoles_DeveloperBypassesPermsLevelCheck(t *testing.T) {
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
 	conn := testutil.GetTestSqlConn()
@@ -470,12 +475,13 @@ func TestBindRoles_DeveloperBypassesPermsLevelCheck(t *testing.T) {
 		UserId:  userId,
 		RoleIds: []int64{lowLevelRole},
 	})
-	require.NoError(t, err, "DEVELOPER 调用者应当能绑定任意级别的角色 (audit H-1)")
+	require.NoError(t, err, "DEVELOPER 调用者应当能绑定任意级别的角色")
 }
 
 // TC-0713: MinPermsLevel == math.MaxInt64 的 MEMBER 调用者也必须被豁免
 // （sentinel 判定路径：既不是 ADMIN/DEVELOPER，也没有角色，此时 r.PermsLevel<MaxInt64 的逐字面比较
-//  曾经误伤此类 MEMBER；修复后代码用 MinPermsLevel==MaxInt64 做短路）
+//
+//	曾经误伤此类 MEMBER；修复后代码用 MinPermsLevel==MaxInt64 做短路）
 func TestBindRoles_MemberWithSentinelMinLevel_NotBlocked(t *testing.T) {
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
 	conn := testutil.GetTestSqlConn()
@@ -523,7 +529,7 @@ func TestBindRoles_MemberWithSentinelMinLevel_NotBlocked(t *testing.T) {
 		var ce *response.CodeError
 		require.True(t, errors.As(err, &ce))
 		assert.NotContains(t, ce.Error(), "不能分配权限级别高于自身的角色",
-			"sentinel MinPermsLevel=math.MaxInt64 不应触发越级错误 (audit H-1)")
+			"sentinel MinPermsLevel=math.MaxInt64 不应触发越级错误")
 	}
 }
 
@@ -559,7 +565,7 @@ func TestBindRoles_SuperAdminCanAssignAnyLevel(t *testing.T) {
 	assert.Contains(t, roleIds, highLevelRole)
 }
 
-// TC-0191: 目标用户不是当前产品成员时拒绝绑定角色(L-4修复验证)
+// TC-0191: 目标用户不是当前产品成员时拒绝绑定角色(修复验证)
 func TestBindRoles_NonMemberRejected(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -581,3 +587,235 @@ func TestBindRoles_NonMemberRejected(t *testing.T) {
 	assert.Equal(t, 400, codeErr2.Code())
 	assert.Contains(t, codeErr2.Error(), "不是当前产品的成员")
 }
+
+func setupBindRolesOrphanFixture(t *testing.T, svcCtx *svc.ServiceContext, productCode string) (
+	userId, memberId, roleId int64, cleanup func(),
+) {
+	t.Helper()
+	superCtx := ctxhelper.SuperAdminCtx()
+	conn := testutil.GetTestSqlConn()
+
+	username := testutil.UniqueId()
+	userId = insertTestUser(t, superCtx, username, testutil.HashPassword("pass"))
+	memberId = insertTestMember(t, svcCtx, productCode, userId)
+
+	now := time.Now().Unix()
+	res, err := svcCtx.SysRoleModel.Insert(superCtx, &roleModel.SysRole{
+		ProductCode: productCode,
+		Name:        "r12_1_" + testutil.UniqueId(),
+		Status:      consts.StatusEnabled,
+		PermsLevel:  10,
+		CreateTime:  now,
+		UpdateTime:  now,
+	})
+	require.NoError(t, err)
+	roleId, _ = res.LastInsertId()
+
+	cleanup = func() {
+		testutil.CleanTableByField(superCtx, conn, "`sys_user_role`", "userId", userId)
+		testutil.CleanTable(superCtx, conn, "`sys_product_member`", memberId)
+		testutil.CleanTable(superCtx, conn, "`sys_user`", userId)
+		testutil.CleanTable(superCtx, conn, "`sys_role`", roleId)
+	}
+	return
+}
+
+// TC-1078: BindRoles 和 DeleteRole 并发：终态无孤儿
+// 用真实 MySQL + go-zero 事务跑多轮并发，断言每一轮都能落在以下两个合法终态之一：
+//
+//	A) BindRoles 胜出 + DeleteRole 胜出（先后串行）：
+//	   - 最常见：BindRoles 先提交，sys_user_role 出现新行；DeleteRole 随后提交，
+//	     级联 DELETE 把新行一并带走；sys_role[R] 消失、sys_user_role 无 R 行 → 无孤儿。
+//	B) DeleteRole 先提交 + BindRoles 收 400：
+//	   - sys_role[R] 消失；BindRoles 事务内 LockRolesForShareTx 读不到 → ErrNotFound → 400；
+//	   - sys_user_role 无 R 行 → 无孤儿。
+//
+// 不允许任何一轮出现：sys_role[R] 不在 + sys_user_role 仍有 (userId, R) —— 这就是 orphan。
+func TestBindRoles_Vs_DeleteRole_NoOrphanRows(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	superCtx := ctxhelper.SuperAdminCtx()
+	productCode := "test_product"
+
+	const rounds = 6
+	for round := 0; round < rounds; round++ {
+		userId, memberId, roleId, cleanup := setupBindRolesOrphanFixture(t, svcCtx, productCode)
+		_ = memberId
+
+		var (
+			wg       sync.WaitGroup
+			bindErr  atomic.Value
+			delErr   atomic.Value
+			bindOK   atomic.Bool
+			deleteOK atomic.Bool
+		)
+		start := make(chan struct{})
+		wg.Add(2)
+
+		go func() {
+			defer wg.Done()
+			<-start
+			err := NewBindRolesLogic(superCtx, svcCtx).BindRoles(&types.BindRolesReq{
+				UserId:  userId,
+				RoleIds: []int64{roleId},
+			})
+			if err == nil {
+				bindOK.Store(true)
+			} else {
+				bindErr.Store(err)
+			}
+		}()
+		go func() {
+			defer wg.Done()
+			<-start
+			err := roleLogic.NewDeleteRoleLogic(superCtx, svcCtx).DeleteRole(&types.DeleteRoleReq{
+				Id: roleId,
+			})
+			if err == nil {
+				deleteOK.Store(true)
+			} else {
+				delErr.Store(err)
+			}
+		}()
+
+		close(start)
+		wg.Wait()
+
+		// 终态：绕过 go-zero cache 直接查 DB，避免 cache 把 DeleteRole 的真实删除遮住造成假阳。
+		var roleCount, urCount int64
+		require.NoError(t, conn.QueryRowCtx(context.Background(), &roleCount,
+			"SELECT COUNT(*) FROM `sys_role` WHERE `id` = ?", roleId))
+		require.NoError(t, conn.QueryRowCtx(context.Background(), &urCount,
+			"SELECT COUNT(*) FROM `sys_user_role` WHERE `userId` = ? AND `roleId` = ?", userId, roleId))
+
+		// 最严 orphan 判定：sys_role 不在 且 sys_user_role 仍在 → 孤儿
+		if roleCount == 0 && urCount > 0 {
+			t.Fatalf(
+				"（轮次 %d）：产生 orphan —— sys_role[%d] 已被 DeleteRole 删除，"+
+					"但 sys_user_role 仍有 (userId=%d, roleId=%d) 行。bindOK=%v delOK=%v "+
+					"bindErr=%v delErr=%v", round, roleId, userId, roleId, bindOK.Load(),
+				deleteOK.Load(), bindErr.Load(), delErr.Load(),
+			)
+		}
+
+		// 其它合法终态一并回归：至少一端做了有效操作（不能都失败）
+		if !bindOK.Load() && !deleteOK.Load() {
+			t.Logf("轮次 %d: bindErr=%v delErr=%v", round, bindErr.Load(), delErr.Load())
+			t.Fatalf("轮次 %d：两端都失败，不是预期的并发交错（至少 DeleteRole 应成功，"+
+				"因为它持有 FindOne 之后所有行的独占链路）", round)
+		}
+
+		// 如果 BindRoles 报错必须是 400 "已被删除或已禁用的角色ID"（由 LockRolesForShareTx 触发）
+		if raw := bindErr.Load(); raw != nil {
+			var ce *response.CodeError
+			if errors.As(raw.(error), &ce) {
+				assert.Equal(t, 400, ce.Code(),
+					"BindRoles 在 DeleteRole 先成功时必须 400，不得泄漏为 500")
+				assert.Contains(t, ce.Error(), "已被删除或已禁用的角色ID",
+					"信号必须准确，方便上游重试 / 清理入参")
+			}
+		}
+
+		cleanup()
+	}
+}
+
+func seedCallerWithRoleLevel(t *testing.T, svcCtx *svc.ServiceContext, productCode string, callerLevel int64) (int64, func()) {
+	t.Helper()
+	superCtx := ctxhelper.SuperAdminCtx()
+	conn := testutil.GetTestSqlConn()
+
+	callerUserId := insertTestUserFull(t, superCtx, &userModel.SysUser{
+		Username: "caller_" + testutil.UniqueId(), Password: testutil.HashPassword("pass"),
+		Nickname: "caller_seed", DeptId: 0,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: 2, Status: consts.StatusEnabled,
+	})
+	mId := insertTestMember(t, svcCtx, productCode, callerUserId)
+	roleId := insertTestRoleWithLevel(t, svcCtx, productCode, consts.StatusEnabled, callerLevel)
+
+	now := time.Now().Unix()
+	_, err := svcCtx.SysUserRoleModel.Insert(superCtx, &userroleModel.SysUserRole{
+		UserId:     callerUserId,
+		RoleId:     roleId,
+		CreateTime: now,
+		UpdateTime: now,
+	})
+	require.NoError(t, err)
+
+	cleanup := func() {
+		testutil.CleanTableByField(superCtx, conn, "`sys_user_role`", "userId", callerUserId)
+		testutil.CleanTable(superCtx, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(superCtx, conn, "`sys_user`", callerUserId)
+		testutil.CleanTable(superCtx, conn, "`sys_role`", roleId)
+	}
+	return callerUserId, cleanup
+}
+
+// ---------------------------------------------------------------------------
+// 覆盖目标："不能分配与自己同级（或更高）的角色"。
+// 修复前代码仅拦 `>` 严格高于，允许 MEMBER 调用者把同级角色分配给别人，继而下一次 BindRoles 时
+// 由于同级权限集相同，可用后续 upgrade 路径放大；修复后变为 `<=`（含同级）拦截。
+// 本文件作为"同级也必须 403"的契约锚点。
+// ---------------------------------------------------------------------------
+
+// TC-0813: MEMBER 调用者不能分配与自己同 permsLevel 的角色。
+func TestBindRoles_EqualPermsLevel_Rejected(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	superCtx := ctxhelper.SuperAdminCtx()
+
+	deptId, deptPath, cleanupDept := setupDeptForCaller(t, svcCtx)
+	t.Cleanup(cleanupDept)
+
+	productCode := "test_product"
+	username := testutil.UniqueId()
+	targetUserId := insertTestUserFull(t, superCtx, &userModel.SysUser{
+		Username: username, Password: testutil.HashPassword("pass"),
+		Nickname: "tgt_eq", DeptId: deptId,
+		IsSuperAdmin: consts.IsSuperAdminNo, MustChangePassword: 2, Status: consts.StatusEnabled,
+	})
+	mId := insertTestMember(t, svcCtx, productCode, targetUserId)
+
+	const callerLevel int64 = 50
+	sameLevelRole := insertTestRoleWithLevel(t, svcCtx, productCode, consts.StatusEnabled, callerLevel)
+
+	// 修复后 GuardRoleLevelAssignable 走 DB 强一致读取 caller 的 MinPermsLevel，
+	// 因此需要在 DB 里为调用者落地真实的 user + role + user_role 关系链。
+	callerUserId, callerCleanup := seedCallerWithRoleLevel(t, svcCtx, productCode, callerLevel)
+	t.Cleanup(callerCleanup)
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(superCtx, conn, "`sys_user_role`", "userId", targetUserId)
+		testutil.CleanTable(superCtx, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(superCtx, conn, "`sys_user`", targetUserId)
+		testutil.CleanTable(superCtx, conn, "`sys_role`", sameLevelRole)
+	})
+
+	ctx := ctxhelper.CustomCtx(&loaders.UserDetails{
+		UserId:        callerUserId,
+		Username:      "member_eq_level",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   productCode,
+		DeptId:        deptId,
+		DeptPath:      deptPath,
+		MinPermsLevel: callerLevel,
+	})
+
+	err := NewBindRolesLogic(ctx, svcCtx).BindRoles(&types.BindRolesReq{
+		UserId:  targetUserId,
+		RoleIds: []int64{sameLevelRole},
+	})
+	require.Error(t, err, "同级角色分配必须被拒绝（含同级）")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "不能分配权限级别高于自身的角色",
+		"错误消息应当明确点出'含同级'的拦截语义")
+
+	// 同时验证 DB 未产生任何 user-role 关系。
+	rids, err := svcCtx.SysUserRoleModel.FindRoleIdsByUserIdForProduct(ctx, targetUserId, productCode)
+	require.NoError(t, err)
+	assert.Empty(t, rids, "被拒绝的 BindRoles 不得落地任何行")
+}

internal/logic/user/createUserDeptChain_audit_test.go

@@ -1,215 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"math"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	deptModel "perms-system-server/internal/model/dept"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-N4 修复 —— CreateUser 必须做 caller.DeptPath → newDept.Path 前缀校验，
-// 并且目标部门必须处于 Enabled（审计 L-N2），非超管 DeptId=0 必须拒绝，
-// 避免 Product ADMIN 为"非自己管辖的部门"预埋 admin_* / ops_* 关键用户名并借 AddMember
-// 的协同路径挂进产品。
-// ---------------------------------------------------------------------------
-
-func callerAdminCtx(callerUserId, deptId int64, deptPath string) context.Context {
-	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId:        callerUserId,
-		Username:      "prod_admin_caller",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeAdmin,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "test_product",
-		DeptId:        deptId,
-		DeptPath:      deptPath,
-		MinPermsLevel: math.MaxInt64,
-	})
-}
-
-// TC-0994: M-N4 —— 产品 ADMIN 为非自己管辖部门创建用户必须 403。
-func TestCreateUser_MN4_AdminCannotCreateOutsideDeptSubtree(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_caller", "/100/")
-	outsideDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_outside", "/999/")
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, outsideDeptId)
-	})
-
-	adminCtx := callerAdminCtx(777771, callerDeptId, "/100/")
-	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
-		Username: "mn4_seed_" + testutil.UniqueId(),
-		Password: "Pass123456",
-		DeptId:   outsideDeptId,
-	})
-	require.Error(t, err)
-
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code(),
-		"M-N4：产品 ADMIN 跨部门树创建用户必须 403，防止占用关键用户名等 AddMember 合谋挂进产品")
-	assert.Contains(t, ce.Error(), "无权在非自己管辖的部门下创建用户")
-}
-
-// TC-0995: M-N4 正向 —— 产品 ADMIN 在自己子树下的部门创建用户放行。
-func TestCreateUser_MN4_AdminCanCreateInsideDeptSubtree(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_ok_caller", "/200/")
-	childDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_ok_child", "/200/1/")
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, childDeptId)
-	})
-
-	adminCtx := callerAdminCtx(777772, callerDeptId, "/200/")
-	username := "mn4ok_" + testutil.UniqueId()
-	resp, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
-		Username: username,
-		Password: "Pass123456",
-		DeptId:   childDeptId,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", resp.Id) })
-
-	user, err := svcCtx.SysUserModel.FindOne(bootstrap, resp.Id)
-	require.NoError(t, err)
-	assert.Equal(t, username, user.Username)
-	assert.Equal(t, childDeptId, user.DeptId, "用户必须真实落在指定子部门")
-}
-
-// TC-0996: M-N4 —— SuperAdmin 可跨一切部门（含 DeptId=0），继续允许创建系统级账号。
-func TestCreateUser_MN4_SuperAdminCanCreateAnywhere(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	randomDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_sa", "/1000/")
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", randomDeptId)
-	})
-
-	// A) 超管创建在任意部门
-	usernameDept := "mn4sa_dept_" + testutil.UniqueId()
-	resp, err := NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
-		Username: usernameDept,
-		Password: "Pass123456",
-		DeptId:   randomDeptId,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", resp.Id) })
-
-	// B) 超管创建 DeptId=0 的系统级账号（历史跨组织账号语义保留）
-	usernameZero := "mn4sa_zero_" + testutil.UniqueId()
-	respZero, err := NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
-		Username: usernameZero,
-		Password: "Pass123456",
-		DeptId:   0,
-	})
-	require.NoError(t, err)
-	require.NotNil(t, respZero)
-	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", respZero.Id) })
-}
-
-// TC-0997: M-N4 —— 非超管 caller 的 DeptPath 为空时必须 403，不得在部门树外开口。
-func TestCreateUser_MN4_EmptyCallerDeptPathRejected(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	dstDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_empty", "/500/")
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", dstDeptId)
-	})
-
-	// caller 是产品 ADMIN 但历史账号 DeptPath=="" —— 必须 403 "未归属任何部门"
-	adminCtx := callerAdminCtx(777773, 0, "")
-	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
-		Username: "mn4empty_" + testutil.UniqueId(),
-		Password: "Pass123456",
-		DeptId:   dstDeptId,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code(),
-		"M-N4：caller.DeptPath=='' 属于 legacy 账号，fail-close 不允许创建用户")
-	assert.Contains(t, ce.Error(), "您未归属任何部门")
-}
-
-// TC-0998: M-N4 —— 非超管 caller 传 DeptId=0 必须 400（禁止非超管创建"无部门"账号）。
-func TestCreateUser_MN4_NonSuperAdminMustSpecifyDept(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_mustspec", "/300/")
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId)
-	})
-
-	adminCtx := callerAdminCtx(777774, callerDeptId, "/300/")
-	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
-		Username: "mn4must_" + testutil.UniqueId(),
-		Password: "Pass123456",
-		DeptId:   0,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code(),
-		"M-N4：非超管 CreateUser 必须显式指定部门，禁止在部门树外创建账号")
-	assert.Contains(t, ce.Error(), "必须指定部门")
-}
-
-// TC-0999: L-N2 —— 目标部门已停用时 CreateUser 必须 400 "目标部门已停用"，与 UpdateDept 闭环。
-func TestCreateUser_LN2_TargetDeptDisabled(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	now := time.Now().Unix()
-	disRes, err := svcCtx.SysDeptModel.Insert(bootstrap, &deptModel.SysDept{
-		ParentId: 0, Name: "ln2_dis_" + testutil.UniqueId(), Path: "/900/", Sort: 0,
-		DeptType: "NORMAL", Remark: "", Status: 2, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	disabledId, _ := disRes.LastInsertId()
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", disabledId)
-	})
-
-	// 超管也必须被拒绝：L-N2 的规则针对"所有调用方"，防止 disabled 部门被意外重新填人
-	_, err = NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
-		Username: "ln2_" + testutil.UniqueId(),
-		Password: "Pass123456",
-		DeptId:   disabledId,
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 400, ce.Code())
-	assert.Equal(t, "目标部门已停用", ce.Error(),
-		"L-N2：目标部门 status!=Enabled 必须拒绝，与 UpdateDept 禁用语义闭环")
-}

internal/logic/user/createUserLogic_test.go

@@ -4,11 +4,12 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"math"
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
 	deptModel "perms-system-server/internal/model/dept"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
@@ -16,9 +17,10 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"strings"
+	"sync"
+	"testing"
+	"time"
 )
 
 func insertTestUser(t *testing.T, ctx context.Context, username, password string) int64 {
@@ -592,3 +594,210 @@ func TestCreateUser_AllOptionalFields(t *testing.T) {
 	assert.Equal(t, int64(1), user.Status)
 	assert.Equal(t, int64(2), user.IsSuperAdmin)
 }
+
+func callerAdminCtx(callerUserId, deptId int64, deptPath string) context.Context {
+	return middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId:        callerUserId,
+		Username:      "prod_admin_caller",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeAdmin,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		DeptId:        deptId,
+		DeptPath:      deptPath,
+		MinPermsLevel: math.MaxInt64,
+	})
+}
+
+// TC-0994: 产品 ADMIN 为非自己管辖部门创建用户必须 403。
+func TestCreateUser_MN4_AdminCannotCreateOutsideDeptSubtree(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_caller", "/100/")
+	outsideDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_outside", "/999/")
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, outsideDeptId)
+	})
+
+	adminCtx := callerAdminCtx(777771, callerDeptId, "/100/")
+	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
+		Username: "mn4_seed_" + testutil.UniqueId(),
+		Password: "Pass123456",
+		DeptId:   outsideDeptId,
+	})
+	require.Error(t, err)
+
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code(),
+		"产品 ADMIN 跨部门树创建用户必须 403，防止占用关键用户名等 AddMember 合谋挂进产品")
+	assert.Contains(t, ce.Error(), "无权在非自己管辖的部门下创建用户")
+}
+
+// TC-0995:  正向 —— 产品 ADMIN 在自己子树下的部门创建用户放行。
+func TestCreateUser_MN4_AdminCanCreateInsideDeptSubtree(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_ok_caller", "/200/")
+	childDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_ok_child", "/200/1/")
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, childDeptId)
+	})
+
+	adminCtx := callerAdminCtx(777772, callerDeptId, "/200/")
+	username := "mn4ok_" + testutil.UniqueId()
+	resp, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
+		Username: username,
+		Password: "Pass123456",
+		DeptId:   childDeptId,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", resp.Id) })
+
+	user, err := svcCtx.SysUserModel.FindOne(bootstrap, resp.Id)
+	require.NoError(t, err)
+	assert.Equal(t, username, user.Username)
+	assert.Equal(t, childDeptId, user.DeptId, "用户必须真实落在指定子部门")
+}
+
+// TC-0996: SuperAdmin 可跨一切部门（含 DeptId=0），继续允许创建系统级账号。
+func TestCreateUser_MN4_SuperAdminCanCreateAnywhere(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	randomDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_sa", "/1000/")
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", randomDeptId)
+	})
+
+	// A) 超管创建在任意部门
+	usernameDept := "mn4sa_dept_" + testutil.UniqueId()
+	resp, err := NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
+		Username: usernameDept,
+		Password: "Pass123456",
+		DeptId:   randomDeptId,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", resp.Id) })
+
+	// B) 超管创建 DeptId=0 的系统级账号（历史跨组织账号语义保留）
+	usernameZero := "mn4sa_zero_" + testutil.UniqueId()
+	respZero, err := NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
+		Username: usernameZero,
+		Password: "Pass123456",
+		DeptId:   0,
+	})
+	require.NoError(t, err)
+	require.NotNil(t, respZero)
+	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", respZero.Id) })
+}
+
+// TC-0997: 非超管 caller 的 DeptPath 为空时必须 403，不得在部门树外开口。
+func TestCreateUser_MN4_EmptyCallerDeptPathRejected(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	dstDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_empty", "/500/")
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", dstDeptId)
+	})
+
+	// caller 是产品 ADMIN 但历史账号 DeptPath=="" —— 必须 403 "未归属任何部门"
+	adminCtx := callerAdminCtx(777773, 0, "")
+	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
+		Username: "mn4empty_" + testutil.UniqueId(),
+		Password: "Pass123456",
+		DeptId:   dstDeptId,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code(),
+		"caller.DeptPath=='' 属于 legacy 账号，fail-close 不允许创建用户")
+	assert.Contains(t, ce.Error(), "您未归属任何部门")
+}
+
+// TC-0998: 非超管 caller 传 DeptId=0 必须 400（禁止非超管创建"无部门"账号）。
+func TestCreateUser_MN4_NonSuperAdminMustSpecifyDept(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "mn4_mustspec", "/300/")
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId)
+	})
+
+	adminCtx := callerAdminCtx(777774, callerDeptId, "/300/")
+	_, err := NewCreateUserLogic(adminCtx, svcCtx).CreateUser(&types.CreateUserReq{
+		Username: "mn4must_" + testutil.UniqueId(),
+		Password: "Pass123456",
+		DeptId:   0,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code(),
+		"非超管 CreateUser 必须显式指定部门，禁止在部门树外创建账号")
+	assert.Contains(t, ce.Error(), "必须指定部门")
+}
+
+// TC-0999: 目标部门已停用时 CreateUser 必须 400 "目标部门已停用"，与 UpdateDept 闭环。
+func TestCreateUser_LN2_TargetDeptDisabled(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	now := time.Now().Unix()
+	disRes, err := svcCtx.SysDeptModel.Insert(bootstrap, &deptModel.SysDept{
+		ParentId: 0, Name: "ln2_dis_" + testutil.UniqueId(), Path: "/900/", Sort: 0,
+		DeptType: "NORMAL", Remark: "", Status: 2, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	disabledId, _ := disRes.LastInsertId()
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", disabledId)
+	})
+
+	// 超管也必须被拒绝： 的规则针对"所有调用方"，防止 disabled 部门被意外重新填人
+	_, err = NewCreateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).CreateUser(&types.CreateUserReq{
+		Username: "ln2_" + testutil.UniqueId(),
+		Password: "Pass123456",
+		DeptId:   disabledId,
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 400, ce.Code())
+	assert.Equal(t, "目标部门已停用", ce.Error(),
+		"目标部门 status!=Enabled 必须拒绝，与 UpdateDept 禁用语义闭环")
+}
+
+func TestCreateUser_DefaultsMustChangePasswordToYes(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	username := "lcp_" + testutil.UniqueId()
+	resp, err := NewCreateUserLogic(ctx, svcCtx).CreateUser(&types.CreateUserReq{
+		Username: username,
+		Password: "InitPass@123",
+		Nickname: "初始口令校验",
+	})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", resp.Id) })
+
+	u, err := svcCtx.SysUserModel.FindOne(ctx, resp.Id)
+	require.NoError(t, err)
+	assert.Equal(t, int64(consts.MustChangePasswordYes), u.MustChangePassword,
+		"管理员代填初始密码的用户必须被强制下次登录改密，落盘为 Yes")
+}

internal/logic/user/createUserMustChangePwd_audit_test.go

@@ -1,43 +0,0 @@
-package user
-
-import (
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-1 修复 —— 管理员代填初始密码创建的用户必须把 MustChangePassword 默认为 Yes。
-// 修复前默认 No，使得"管理员口头下发 + 长期不改 + 口令库泄露即广义失陷"成为系统性弱点。
-// 本用例锚定："req 未显式传入 mustChangePassword 时，落盘必须是 Yes"。
-// 因为 CreateUserReq 并不暴露 MustChangePassword 字段（没有 override 入口），该契约既是安全下限也是产品基线。
-// ---------------------------------------------------------------------------
-
-// TC-0818: L-1 —— 超管创建用户时，MustChangePassword 默认落盘为 Yes。
-func TestCreateUser_DefaultsMustChangePasswordToYes(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	username := "lcp_" + testutil.UniqueId()
-	resp, err := NewCreateUserLogic(ctx, svcCtx).CreateUser(&types.CreateUserReq{
-		Username: username,
-		Password: "InitPass@123",
-		Nickname: "初始口令校验",
-	})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", resp.Id) })
-
-	u, err := svcCtx.SysUserModel.FindOne(ctx, resp.Id)
-	require.NoError(t, err)
-	assert.Equal(t, int64(consts.MustChangePasswordYes), u.MustChangePassword,
-		"L-1 基线：管理员代填初始密码的用户必须被强制下次登录改密，落盘为 Yes")
-}

internal/logic/user/setUserPermsAudit_test.go

@@ -16,7 +16,7 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// TC-0734: M-14 修复：产品被禁用时，setUserPerms 应拒绝
+// TC-0734:  修复：产品被禁用时，setUserPerms 应拒绝
 func TestSetUserPerms_ProductDisabled(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -52,7 +52,7 @@ func TestSetUserPerms_ProductDisabled(t *testing.T) {
 	assert.Contains(t, ce.Error(), "禁用")
 }
 
-// TC-0735: M-14 修复：产品不存在时拒绝
+// TC-0735:  修复：产品不存在时拒绝
 func TestSetUserPerms_ProductNotFound(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())

internal/logic/user/setUserPermsCountRecheck_audit_test.go

@@ -1,143 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	permModel "perms-system-server/internal/model/perm"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 审计 L-4（第 8 轮）—— SetUserPerms 事务末 COUNT(*) 复核 sys_perm.status=1，
-// 把"FindByIds 通过 → 事务外某次 SyncPermissions 先把 permId 置为 DISABLED →
-// BatchInsertWithTx 把脏行写进 sys_user_perm"的 TOCTOU 窗口收紧。
-//
-// 测试思路：把 SysPermModel 用一个薄装饰器替换，让 FindByIds 说谎（返回 Enabled），
-// 但实际上 DB 里这批 permId 其实是 Disabled。这样：
-//   - 前置 FindByIds 校验通过；
-//   - 进入 TransactCtx，BatchInsertWithTx 成功；
-//   - 事务末 COUNT(*) WHERE status=1 的真实 DB 读返回 0 ≠ 1 → 回滚，返回 409；
-//   - sys_user_perm 必须一行脏数据都不剩。
-//
-// 如果 L-4 的复核被移除（或误改成 status != 0），COUNT 返回会≠0，脏行会被落盘，
-// 此测试自动失败。
-// ---------------------------------------------------------------------------
-
-// lyingSysPermModel 只重写 FindByIds：不管 DB 里 status 是什么，都声称是 Enabled。
-// 这是唯一一个能稳定模拟"前置 FindByIds → tx 内真实 status" 时序差的办法。
-type lyingSysPermModel struct {
-	permModel.SysPermModel
-	lyingProductCode string
-}
-
-func (m *lyingSysPermModel) FindByIds(ctx context.Context, ids []int64) ([]*permModel.SysPerm, error) {
-	real, err := m.SysPermModel.FindByIds(ctx, ids)
-	if err != nil {
-		return nil, err
-	}
-	for _, p := range real {
-		p.ProductCode = m.lyingProductCode
-		p.Status = 1
-	}
-	return real, nil
-}
-
-// TC-0988: TOCTOU 复核 —— 前置检查通过但实际 Disabled，事务末 COUNT 必须触发 409 回滚。
-func TestSetUserPerms_L4_TOCTOU_CountMismatch_RollsBackWith409(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	username := testutil.UniqueId()
-	userId := insertTestUser(t, ctx, username, testutil.HashPassword("pass"))
-	mId := insertTestMember(t, svcCtx, "test_product", userId)
-
-	// 直接在 DB 里塞一个 status=Disabled 的 perm，模拟 SyncPermissions 已经提交
-	// 把这个 perm 落盘为 Disabled 的状态。
-	now := time.Now().Unix()
-	res, err := svcCtx.SysPermModel.Insert(ctx, &permModel.SysPerm{
-		ProductCode: "test_product",
-		Name:        "l4_disabled_" + testutil.UniqueId(),
-		Code:        "l4_dis_" + testutil.UniqueId(),
-		Status:      2, // Disabled
-		CreateTime:  now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	disabledPermId, _ := res.LastInsertId()
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_user_perm`", "userId", userId)
-		testutil.CleanTable(ctx, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(ctx, conn, "`sys_user`", userId)
-		testutil.CleanTable(ctx, conn, "`sys_perm`", disabledPermId)
-	})
-
-	// 装饰 SysPermModel：让 FindByIds 撒谎（Status=1, productCode=test_product）。
-	svcCtx.SysPermModel = &lyingSysPermModel{
-		SysPermModel:     svcCtx.SysPermModel,
-		lyingProductCode: "test_product",
-	}
-
-	err = NewSetUserPermsLogic(ctx, svcCtx).SetUserPerms(&types.SetPermsReq{
-		UserId: userId,
-		Perms:  []types.UserPermItem{{PermId: disabledPermId, Effect: "ALLOW"}},
-	})
-
-	require.Error(t, err, "L-4：前置通过但 DB 实际 Disabled 时，事务末 COUNT 必须触发 409")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 409, ce.Code(),
-		"L-4：TOCTOU 复核必须返回 409 Conflict；若仍是 200/4xx 说明复核 COUNT 被移除，"+
-			"脏 user_perm 会被真实落盘")
-	assert.Contains(t, ce.Error(), "已被禁用",
-		"L-4：错误文案必须明示'部分权限在提交时已被禁用'，供前端判定是否重试")
-
-	// 最关键的断言：脏行必须不可能落盘。
-	leftover := findUserPerms(t, ctx, userId)
-	assert.Empty(t, leftover,
-		"L-4：事务必须回滚；如果发现 sys_user_perm 有脏行，说明 COUNT 复核失效或"+
-			"事务隔离性被破坏，loadPerms 的 status=1 过滤能兜底但会绕开审计链")
-}
-
-// TC-0989: 正向基线 —— 所有 perm 真实 Enabled 时，不得被 L-4 复核误杀。
-// 这条显式"不回滚"的断言防止未来有人把 COUNT 改成 "!=" 逻辑或把阈值改错。
-func TestSetUserPerms_L4_AllEnabled_CountPasses(t *testing.T) {
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	username := testutil.UniqueId()
-	userId := insertTestUser(t, ctx, username, testutil.HashPassword("pass"))
-	mId := insertTestMember(t, svcCtx, "test_product", userId)
-
-	p1 := insertTestPerm(t, svcCtx, "test_product")
-	p2 := insertTestPerm(t, svcCtx, "test_product")
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(ctx, conn, "`sys_user_perm`", "userId", userId)
-		testutil.CleanTable(ctx, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(ctx, conn, "`sys_user`", userId)
-		testutil.CleanTable(ctx, conn, "`sys_perm`", p1, p2)
-	})
-
-	err := NewSetUserPermsLogic(ctx, svcCtx).SetUserPerms(&types.SetPermsReq{
-		UserId: userId,
-		Perms: []types.UserPermItem{
-			{PermId: p1, Effect: "ALLOW"},
-			{PermId: p2, Effect: "DENY"},
-		},
-	})
-	require.NoError(t, err, "L-4 复核不得误杀正常写入；一旦误报会把正常管理操作变 409")
-	rows := findUserPerms(t, ctx, userId)
-	assert.Len(t, rows, 2, "两条 user_perm 必须落盘")
-}

internal/logic/user/setUserPermsLogic_test.go

@@ -3,18 +3,21 @@ package user
 import (
 	"context"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"math"
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
 	permModel "perms-system-server/internal/model/perm"
+	productModel "perms-system-server/internal/model/product"
 	"perms-system-server/internal/response"
 	"perms-system-server/internal/svc"
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
 type userPermRow struct {
@@ -382,7 +385,7 @@ func TestSetUserPerms_DisabledPermRejected(t *testing.T) {
 	assert.Contains(t, codeErr.Error(), "已被禁用")
 }
 
-// TC-0199: 目标用户不是当前产品成员时拒绝设置权限(L-5修复验证)
+// TC-0199: 目标用户不是当前产品成员时拒绝设置权限(修复验证)
 func TestSetUserPerms_NonMemberRejected(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -404,3 +407,260 @@ func TestSetUserPerms_NonMemberRejected(t *testing.T) {
 	assert.Equal(t, 400, codeErr2.Code())
 	assert.Contains(t, codeErr2.Error(), "不是当前产品的成员")
 }
+
+type lyingSysPermModel struct {
+	permModel.SysPermModel
+	lyingProductCode string
+}
+
+func (m *lyingSysPermModel) FindByIds(ctx context.Context, ids []int64) ([]*permModel.SysPerm, error) {
+	real, err := m.SysPermModel.FindByIds(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+	for _, p := range real {
+		p.ProductCode = m.lyingProductCode
+		p.Status = 1
+	}
+	return real, nil
+}
+
+// TC-0988: TOCTOU 复核 —— 前置检查通过但实际 Disabled，事务末 COUNT 必须触发 409 回滚。
+func TestSetUserPerms_L4_TOCTOU_CountMismatch_RollsBackWith409(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	username := testutil.UniqueId()
+	userId := insertTestUser(t, ctx, username, testutil.HashPassword("pass"))
+	mId := insertTestMember(t, svcCtx, "test_product", userId)
+
+	// 直接在 DB 里塞一个 status=Disabled 的 perm，模拟 SyncPermissions 已经提交
+	// 把这个 perm 落盘为 Disabled 的状态。
+	now := time.Now().Unix()
+	res, err := svcCtx.SysPermModel.Insert(ctx, &permModel.SysPerm{
+		ProductCode: "test_product",
+		Name:        "l4_disabled_" + testutil.UniqueId(),
+		Code:        "l4_dis_" + testutil.UniqueId(),
+		Status:      2, // Disabled
+		CreateTime:  now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	disabledPermId, _ := res.LastInsertId()
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_user_perm`", "userId", userId)
+		testutil.CleanTable(ctx, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(ctx, conn, "`sys_user`", userId)
+		testutil.CleanTable(ctx, conn, "`sys_perm`", disabledPermId)
+	})
+
+	// 装饰 SysPermModel：让 FindByIds 撒谎（Status=1, productCode=test_product）。
+	svcCtx.SysPermModel = &lyingSysPermModel{
+		SysPermModel:     svcCtx.SysPermModel,
+		lyingProductCode: "test_product",
+	}
+
+	err = NewSetUserPermsLogic(ctx, svcCtx).SetUserPerms(&types.SetPermsReq{
+		UserId: userId,
+		Perms:  []types.UserPermItem{{PermId: disabledPermId, Effect: "ALLOW"}},
+	})
+
+	require.Error(t, err, "前置通过但 DB 实际 Disabled 时，事务末 COUNT 必须触发 409")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 409, ce.Code(),
+		"TOCTOU 复核必须返回 409 Conflict；若仍是 200/4xx 说明复核 COUNT 被移除，"+
+			"脏 user_perm 会被真实落盘")
+	assert.Contains(t, ce.Error(), "已被禁用",
+		"错误文案必须明示'部分权限在提交时已被禁用'，供前端判定是否重试")
+
+	// 最关键的断言：脏行必须不可能落盘。
+	leftover := findUserPerms(t, ctx, userId)
+	assert.Empty(t, leftover,
+		"事务必须回滚；如果发现 sys_user_perm 有脏行，说明 COUNT 复核失效或"+
+			"事务隔离性被破坏，loadPerms 的 status=1 过滤能兜底但会绕开链")
+}
+
+// TC-0989: 正向基线 —— 所有 perm 真实 Enabled 时，不得被  复核误杀。
+// 这条显式"不回滚"的断言防止未来有人把 COUNT 改成 "!=" 逻辑或把阈值改错。
+func TestSetUserPerms_L4_AllEnabled_CountPasses(t *testing.T) {
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	username := testutil.UniqueId()
+	userId := insertTestUser(t, ctx, username, testutil.HashPassword("pass"))
+	mId := insertTestMember(t, svcCtx, "test_product", userId)
+
+	p1 := insertTestPerm(t, svcCtx, "test_product")
+	p2 := insertTestPerm(t, svcCtx, "test_product")
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(ctx, conn, "`sys_user_perm`", "userId", userId)
+		testutil.CleanTable(ctx, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(ctx, conn, "`sys_user`", userId)
+		testutil.CleanTable(ctx, conn, "`sys_perm`", p1, p2)
+	})
+
+	err := NewSetUserPermsLogic(ctx, svcCtx).SetUserPerms(&types.SetPermsReq{
+		UserId: userId,
+		Perms: []types.UserPermItem{
+			{PermId: p1, Effect: "ALLOW"},
+			{PermId: p2, Effect: "DENY"},
+		},
+	})
+	require.NoError(t, err, "不得误杀正常写入；一旦误报会把正常管理操作变 409")
+	rows := findUserPerms(t, ctx, userId)
+	assert.Len(t, rows, 2, "两条 user_perm 必须落盘")
+}
+
+func TestSetUserPerms_MemberCannotSelfEscalate(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	now := time.Now().Unix()
+	bootstrap := context.Background()
+
+	code := testutil.UniqueId()
+	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	username := testutil.UniqueId()
+	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
+	mId := insertTestMember(t, svcCtx, code, userId)
+
+	permRes, err := svcCtx.SysPermModel.Insert(bootstrap, &permModel.SysPerm{
+		ProductCode: code, Name: "escalate_p", Code: "esc_" + testutil.UniqueId(),
+		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	permId, _ := permRes.LastInsertId()
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(bootstrap, conn, "`sys_user_perm`", "userId", userId)
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_perm`", permId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", userId)
+		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
+	})
+
+	// caller = 目标用户本人，MemberType=MEMBER（非 ADMIN）
+	callerCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: userId, Username: username,
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   code,
+		DeptId:        1,
+		DeptPath:      "/1/",
+		MinPermsLevel: math.MaxInt64,
+	})
+
+	err = NewSetUserPermsLogic(callerCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
+		UserId: userId, // 给自己
+		Perms:  []types.UserPermItem{{PermId: permId, Effect: consts.PermEffectAllow}},
+	})
+	require.Error(t, err, "MEMBER 不得自我授权")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "仅超级管理员或该产品的管理员可执行此操作")
+
+	// 二次确认：没有任何 user_perm 记录被写入
+	rows := findUserPerms(t, bootstrap, userId)
+	assert.Len(t, rows, 0, "被拒绝的 SetUserPerms 不得在 DB 残留任何个性化权限")
+}
+
+// TC-0744: -A 修复回归 —— DEVELOPER 调用者（非 ADMIN）同样被拦截，即便目标不是自己。
+func TestSetUserPerms_DeveloperCallerRejected(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	bootstrap := context.Background()
+	now := time.Now().Unix()
+
+	code := testutil.UniqueId()
+	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	targetUsername := "target_" + testutil.UniqueId()
+	targetId := insertTestUser(t, bootstrap, targetUsername, testutil.HashPassword("pw"))
+	mId := insertTestMember(t, svcCtx, code, targetId)
+
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
+	})
+
+	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 777777, Username: "dev_caller",
+		MemberType: consts.MemberTypeDeveloper, Status: consts.StatusEnabled,
+		ProductCode: code, DeptId: 1, DeptPath: "/1/", MinPermsLevel: math.MaxInt64,
+	})
+
+	err = NewSetUserPermsLogic(devCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
+		UserId: targetId, Perms: []types.UserPermItem{},
+	})
+	require.Error(t, err)
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "仅超级管理员或该产品的管理员可执行此操作")
+}
+
+// TC-0745: -A 正向回归 —— 同产品 ADMIN 操作合法 MEMBER 目标（非自己）依旧放行。
+func TestSetUserPerms_ProductAdminStillWorks(t *testing.T) {
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	bootstrap := context.Background()
+	now := time.Now().Unix()
+
+	code := testutil.UniqueId()
+	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
+		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
+		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	pId, _ := pRes.LastInsertId()
+
+	targetId := insertTestUser(t, bootstrap, "tgt_"+testutil.UniqueId(), testutil.HashPassword("pw"))
+	mId := insertTestMember(t, svcCtx, code, targetId)
+
+	permRes, err := svcCtx.SysPermModel.Insert(bootstrap, &permModel.SysPerm{
+		ProductCode: code, Name: "ok_p", Code: "ok_" + testutil.UniqueId(),
+		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	permId, _ := permRes.LastInsertId()
+
+	t.Cleanup(func() {
+		testutil.CleanTableByField(bootstrap, conn, "`sys_user_perm`", "userId", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_perm`", permId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
+	})
+
+	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 999999, Username: "admin_caller",
+		MemberType: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
+		ProductCode: code, DeptId: 1, DeptPath: "/1/", MinPermsLevel: math.MaxInt64,
+	})
+
+	err = NewSetUserPermsLogic(adminCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
+		UserId: targetId,
+		Perms:  []types.UserPermItem{{PermId: permId, Effect: consts.PermEffectAllow}},
+	})
+	require.NoError(t, err, "产品 ADMIN 正常路径必须放行")
+
+	rows := findUserPerms(t, bootstrap, targetId)
+	assert.Len(t, rows, 1, "ADMIN 授权后 DB 应有 1 条 user_perm")
+}

internal/logic/user/setUserPermsSelfEscalation_audit_test.go

@@ -1,174 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"math"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	permModel "perms-system-server/internal/model/perm"
-	productModel "perms-system-server/internal/model/product"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// TC-0743: H-A 修复回归 —— 普通 MEMBER 不得通过 SetUserPerms 给自己授予任何权限
-// （RequireProductAdminFor 前置校验必须拦截）。
-func TestSetUserPerms_MemberCannotSelfEscalate(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	now := time.Now().Unix()
-	bootstrap := context.Background()
-
-	code := testutil.UniqueId()
-	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	username := testutil.UniqueId()
-	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
-	mId := insertTestMember(t, svcCtx, code, userId)
-
-	permRes, err := svcCtx.SysPermModel.Insert(bootstrap, &permModel.SysPerm{
-		ProductCode: code, Name: "escalate_p", Code: "esc_" + testutil.UniqueId(),
-		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	permId, _ := permRes.LastInsertId()
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(bootstrap, conn, "`sys_user_perm`", "userId", userId)
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_perm`", permId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", userId)
-		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
-	})
-
-	// caller = 目标用户本人，MemberType=MEMBER（非 ADMIN）
-	callerCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: userId, Username: username,
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   code,
-		DeptId:        1,
-		DeptPath:      "/1/",
-		MinPermsLevel: math.MaxInt64,
-	})
-
-	err = NewSetUserPermsLogic(callerCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
-		UserId: userId, // 给自己
-		Perms:  []types.UserPermItem{{PermId: permId, Effect: consts.PermEffectAllow}},
-	})
-	require.Error(t, err, "MEMBER 不得自我授权")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "仅超级管理员或该产品的管理员可执行此操作")
-
-	// 二次确认：没有任何 user_perm 记录被写入
-	rows := findUserPerms(t, bootstrap, userId)
-	assert.Len(t, rows, 0, "被拒绝的 SetUserPerms 不得在 DB 残留任何个性化权限")
-}
-
-// TC-0744: H-A 修复回归 —— DEVELOPER 调用者（非 ADMIN）同样被拦截，即便目标不是自己。
-func TestSetUserPerms_DeveloperCallerRejected(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	bootstrap := context.Background()
-	now := time.Now().Unix()
-
-	code := testutil.UniqueId()
-	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	targetUsername := "target_" + testutil.UniqueId()
-	targetId := insertTestUser(t, bootstrap, targetUsername, testutil.HashPassword("pw"))
-	mId := insertTestMember(t, svcCtx, code, targetId)
-
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
-	})
-
-	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 777777, Username: "dev_caller",
-		MemberType: consts.MemberTypeDeveloper, Status: consts.StatusEnabled,
-		ProductCode: code, DeptId: 1, DeptPath: "/1/", MinPermsLevel: math.MaxInt64,
-	})
-
-	err = NewSetUserPermsLogic(devCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
-		UserId: targetId, Perms: []types.UserPermItem{},
-	})
-	require.Error(t, err)
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "仅超级管理员或该产品的管理员可执行此操作")
-}
-
-// TC-0745: H-A 正向回归 —— 同产品 ADMIN 操作合法 MEMBER 目标（非自己）依旧放行。
-func TestSetUserPerms_ProductAdminStillWorks(t *testing.T) {
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	bootstrap := context.Background()
-	now := time.Now().Unix()
-
-	code := testutil.UniqueId()
-	pRes, err := svcCtx.SysProductModel.Insert(bootstrap, &productModel.SysProduct{
-		Code: code, Name: "p_" + code, AppKey: code + "_k", AppSecret: "s",
-		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	pId, _ := pRes.LastInsertId()
-
-	targetId := insertTestUser(t, bootstrap, "tgt_"+testutil.UniqueId(), testutil.HashPassword("pw"))
-	mId := insertTestMember(t, svcCtx, code, targetId)
-
-	permRes, err := svcCtx.SysPermModel.Insert(bootstrap, &permModel.SysPerm{
-		ProductCode: code, Name: "ok_p", Code: "ok_" + testutil.UniqueId(),
-		Status: consts.StatusEnabled, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	permId, _ := permRes.LastInsertId()
-
-	t.Cleanup(func() {
-		testutil.CleanTableByField(bootstrap, conn, "`sys_user_perm`", "userId", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_perm`", permId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_product`", pId)
-	})
-
-	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 999999, Username: "admin_caller",
-		MemberType: consts.MemberTypeAdmin, Status: consts.StatusEnabled,
-		ProductCode: code, DeptId: 1, DeptPath: "/1/", MinPermsLevel: math.MaxInt64,
-	})
-
-	err = NewSetUserPermsLogic(adminCtx, svcCtx).SetUserPerms(&types.SetPermsReq{
-		UserId: targetId,
-		Perms:  []types.UserPermItem{{PermId: permId, Effect: consts.PermEffectAllow}},
-	})
-	require.NoError(t, err, "产品 ADMIN 正常路径必须放行")
-
-	rows := findUserPerms(t, bootstrap, targetId)
-	assert.Len(t, rows, 1, "ADMIN 授权后 DB 应有 1 条 user_perm")
-}

internal/logic/user/updateUserDeptScope_audit_test.go

@@ -1,172 +0,0 @@
-package user
-
-import (
-	"context"
-	"database/sql"
-	"errors"
-	"math"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	deptModel "perms-system-server/internal/model/dept"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func insertTestDeptForScope(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, tag, path string) int64 {
-	t.Helper()
-	now := time.Now().Unix()
-	res, err := svcCtx.SysDeptModel.Insert(ctx, &deptModel.SysDept{
-		ParentId: 0, Name: tag + "_" + testutil.UniqueId(), Path: path, Sort: 0,
-		DeptType: "NORMAL", Remark: "", Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	id, _ := res.LastInsertId()
-	return id
-}
-
-func insertTestUserWithDept(t *testing.T, ctx context.Context, tag string, deptId int64) int64 {
-	t.Helper()
-	now := time.Now().Unix()
-	return insertTestUserFull(t, ctx, &userModel.SysUser{
-		Username:           "ddu_" + tag + "_" + testutil.UniqueId(),
-		Password:           testutil.HashPassword("pw"),
-		Nickname:           "n",
-		Avatar:             sql.NullString{},
-		Email:              "[email protected]",
-		Phone:              "13800000000",
-		DeptId:             deptId,
-		IsSuperAdmin:       consts.IsSuperAdminNo,
-		MustChangePassword: 2,
-		Status:             consts.StatusEnabled,
-		CreateTime:         now,
-		UpdateTime:         now,
-	})
-}
-
-// TC-0746: L-F 修复回归 —— DEVELOPER 调用者不得将目标用户的 deptId 调到
-// 自己 DeptPath 子树之外的部门。UpdateUser 必须在 req.DeptId 变更时做 Path 前缀校验。
-func TestUpdateUser_DeveloperCannotMoveTargetOutsideSubtree(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "caller", "/100/")
-	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "target", "/100/200/")
-	outsideDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "outside", "/999/")
-	targetId := insertTestUserWithDept(t, bootstrap, "lf_out", targetDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId, outsideDeptId)
-	})
-
-	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 55555, Username: "lf_dev",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeDeveloper,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "test_product",
-		DeptId:        callerDeptId,
-		DeptPath:      "/100/",
-		MinPermsLevel: math.MaxInt64,
-	})
-
-	newDept := outsideDeptId
-	err := NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-		Id:     targetId,
-		DeptId: &newDept,
-	})
-	require.Error(t, err, "调入外部部门应被拒绝")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "无权将用户调入")
-
-	user, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, targetDeptId, user.DeptId, "被拒绝的请求必须不改动 DB")
-}
-
-// TC-0747: L-F 正向回归 —— DEVELOPER 将目标用户调入自己子树下的部门应允许。
-func TestUpdateUser_DeveloperCanMoveTargetWithinSubtree(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "caller_in", "/200/")
-	srcDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "src_in", "/200/1/")
-	dstDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "dst_in", "/200/2/")
-	targetId := insertTestUserWithDept(t, bootstrap, "lf_in", srcDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, srcDeptId, dstDeptId)
-	})
-
-	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 66666, Username: "lf_dev_ok",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeDeveloper,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "test_product",
-		DeptId:        callerDeptId,
-		DeptPath:      "/200/",
-		MinPermsLevel: math.MaxInt64,
-	})
-
-	newDept := dstDeptId
-	require.NoError(t,
-		NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id: targetId, DeptId: &newDept,
-		}),
-		"caller DeptPath 的前缀子部门必须允许调入")
-
-	user, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, dstDeptId, user.DeptId)
-}
-
-// TC-0748: L-F —— 产品 ADMIN 调用者被豁免 DeptPath 前缀校验（可跨部门转移）。
-func TestUpdateUser_ProductAdminExemptFromSubtreeCheck(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	adminDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "admin_home", "/300/")
-	targetHomeDept := insertTestDeptForScope(t, bootstrap, svcCtx, "target_home", "/400/")
-	anywhereDept := insertTestDeptForScope(t, bootstrap, svcCtx, "anywhere", "/500/")
-	targetId := insertTestUserWithDept(t, bootstrap, "lf_admin", targetHomeDept)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", adminDeptId, targetHomeDept, anywhereDept)
-	})
-
-	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 77777, Username: "lf_admin",
-		IsSuperAdmin: false, MemberType: consts.MemberTypeAdmin,
-		Status: consts.StatusEnabled, ProductCode: "test_product",
-		DeptId: adminDeptId, DeptPath: "/300/", MinPermsLevel: math.MaxInt64,
-	})
-
-	newDept := anywhereDept
-	require.NoError(t,
-		NewUpdateUserLogic(adminCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id: targetId, DeptId: &newDept,
-		}),
-		"产品 ADMIN 在 UpdateUser 的 DeptPath 前缀校验中被豁免")
-}
-

internal/logic/user/updateUserDeptZero_audit_test.go

@@ -1,177 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"math"
-	"testing"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 H-4 修复 —— "把用户移出部门树（deptId=0）" 的破坏组织结构操作，
-// 仅能由 SuperAdmin 或产品 ADMIN 执行。DEVELOPER / MEMBER 执行必须 403，并且 DB 不得发生变更。
-// 修复前这是横向越权点：下级把上级拉出部门树后，后续 checkDeptHierarchy 对该目标彻底失效。
-// ---------------------------------------------------------------------------
-
-// TC-0814: H-4 —— DEVELOPER 调用者执行 deptId=0 的 UpdateUser 必须 403，且 target.DeptId 不动。
-func TestUpdateUser_DeveloperCannotMoveTargetOutOfDept(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_caller_dev", "/700/")
-	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_target_dev", "/700/1/")
-	targetId := insertTestUserWithDept(t, bootstrap, "h4_dev", targetDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId)
-	})
-
-	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId:        88881,
-		Username:      "h4_dev",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeDeveloper,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "test_product",
-		DeptId:        callerDeptId,
-		DeptPath:      "/700/",
-		MinPermsLevel: math.MaxInt64,
-	})
-
-	zero := int64(0)
-	err := NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-		Id:     targetId,
-		DeptId: &zero,
-	})
-	require.Error(t, err, "H-4：DEVELOPER 不得把目标移出部门树")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-	assert.Contains(t, ce.Error(), "仅超级管理员或产品管理员可将用户移出部门")
-
-	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, targetDeptId, u.DeptId, "被拒绝的请求对 DB 零副作用")
-}
-
-// TC-0815: H-4 —— MEMBER 调用者同理被拒（即便是修改自身的其他字段也不能顺手把自己移出部门）。
-// 用户修改自身时，路由层 if caller.UserId == req.Id 分支只拦 DeptId != nil/Status != 0；
-// 但修改他人为 deptId=0 的分支仍必须 403，以防任何下级调用者漂白组织结构。
-func TestUpdateUser_MemberCannotMoveOtherOutOfDept(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_member_caller", "/800/")
-	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_member_target", "/800/1/")
-	targetId := insertTestUserWithDept(t, bootstrap, "h4_mem", targetDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId)
-	})
-
-	memberCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId:        88882,
-		Username:      "h4_mem",
-		IsSuperAdmin:  false,
-		MemberType:    consts.MemberTypeMember,
-		Status:        consts.StatusEnabled,
-		ProductCode:   "test_product",
-		DeptId:        callerDeptId,
-		DeptPath:      "/800/",
-		MinPermsLevel: 10,
-	})
-
-	zero := int64(0)
-	err := NewUpdateUserLogic(memberCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-		Id:     targetId,
-		DeptId: &zero,
-	})
-	require.Error(t, err, "H-4：MEMBER 更不得移出他人")
-	var ce *response.CodeError
-	require.True(t, errors.As(err, &ce))
-	assert.Equal(t, 403, ce.Code())
-
-	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, targetDeptId, u.DeptId)
-}
-
-// TC-0816: H-4 —— 产品 ADMIN 有权将他人移出部门（功能不应被修复路径误伤）。
-func TestUpdateUser_ProductAdminCanMoveTargetOutOfDept(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	adminDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_admin", "/900/")
-	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_admin_target", "/900/1/")
-	targetId := insertTestUserWithDept(t, bootstrap, "h4_admin_tgt", targetDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", adminDeptId, targetDeptId)
-	})
-
-	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: 88883, Username: "h4_admin",
-		IsSuperAdmin: false, MemberType: consts.MemberTypeAdmin,
-		Status: consts.StatusEnabled, ProductCode: "test_product",
-		DeptId: adminDeptId, DeptPath: "/900/", MinPermsLevel: math.MaxInt64,
-	})
-
-	zero := int64(0)
-	require.NoError(t,
-		NewUpdateUserLogic(adminCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id: targetId, DeptId: &zero,
-		}),
-		"产品 ADMIN 必须仍能执行 deptId=0 的合法运维操作")
-
-	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(0), u.DeptId, "ADMIN 的合法 deptId=0 操作必须落盘")
-}
-
-// TC-0817: H-4 —— SuperAdmin 有权将他人移出部门（豁免路径）。
-func TestUpdateUser_SuperAdminCanMoveTargetOutOfDept(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_sa_target", "/950/")
-	targetId := insertTestUserWithDept(t, bootstrap, "h4_sa_tgt", targetDeptId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", targetDeptId)
-	})
-
-	zero := int64(0)
-	require.NoError(t,
-		NewUpdateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id: targetId, DeptId: &zero,
-		}),
-		"SuperAdmin 的 deptId=0 操作是合法的顶层运维")
-
-	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(0), u.DeptId)
-}

internal/logic/user/updateUserLogic.go

@@ -199,6 +199,10 @@ func (l *UpdateUserLogic) UpdateUser(req *types.UpdateUserReq) error {
 		return err
 	}
 
+	// 审计 L-R12-1：UpdateProfileWithTx 不再自己 DelCache（避免 pre-commit 窗口里并发 FindOne
+	// 把未提交旧值灌回缓存）；这里在 commit 成功后显式失效 sysUser 低层 id/username 键，再叠加
+	// UserDetails 聚合缓存的 Clean，整条"两级缓存 → DB 权威"读链回到 cache-miss → loadFromDB。
+	l.svcCtx.SysUserModel.InvalidateProfileCache(l.ctx, req.Id, user.Username)
 	l.svcCtx.UserDetailsLoader.Clean(l.ctx, req.Id)
 	return nil
 }

internal/logic/user/updateUserLogic_test.go

@@ -2,12 +2,17 @@ package user
 
 import (
 	"context"
+	"database/sql"
 	"errors"
-	"testing"
-	"time"
-
+	"fmt"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+	"math"
 	"perms-system-server/internal/consts"
 	"perms-system-server/internal/loaders"
+	deptLogic "perms-system-server/internal/logic/dept"
+	"perms-system-server/internal/middleware"
 	deptModel "perms-system-server/internal/model/dept"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/response"
@@ -15,9 +20,10 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
 )
 
 func insertTestDept(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext) int64 {
@@ -508,7 +514,7 @@ func TestUpdateUser_NotLoggedInRejected(t *testing.T) {
 	assert.Equal(t, "未登录", ce.Error())
 }
 
-// TC-0169: 超管A通过updateUser修改超管B的状态被拒绝(H-2修复验证)
+// TC-0169: 超管A通过updateUser修改超管B的状态被拒绝(修复验证)
 func TestUpdateUser_SuperAdminCannotFreezeOtherSuperAdmin(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -547,7 +553,7 @@ func TestUpdateUser_SuperAdminCannotFreezeOtherSuperAdmin(t *testing.T) {
 	assert.Equal(t, int64(consts.StatusEnabled), user.Status, "超管B的状态不应被修改")
 }
 
-// TC-0173: updateUser 修改状态时会递增 tokenVersion(H-1修复验证)
+// TC-0173: updateUser 修改状态时会递增 tokenVersion(修复验证)
 func TestUpdateUser_StatusChange_IncrementsTokenVersion(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -622,3 +628,558 @@ func TestUpdateUser_OptimisticLockConflict_Returns409(t *testing.T) {
 		orig.Email, orig.Phone, orig.Remark, orig.DeptId, orig.Status, false, orig.UpdateTime)
 	require.ErrorIs(t, err, userModel.ErrUpdateConflict, "基于旧 updateTime 的更新应失败")
 }
+
+func insertTestDeptForScope(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, tag, path string) int64 {
+	t.Helper()
+	now := time.Now().Unix()
+	res, err := svcCtx.SysDeptModel.Insert(ctx, &deptModel.SysDept{
+		ParentId: 0, Name: tag + "_" + testutil.UniqueId(), Path: path, Sort: 0,
+		DeptType: "NORMAL", Remark: "", Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	id, _ := res.LastInsertId()
+	return id
+}
+
+func insertTestUserWithDept(t *testing.T, ctx context.Context, tag string, deptId int64) int64 {
+	t.Helper()
+	now := time.Now().Unix()
+	return insertTestUserFull(t, ctx, &userModel.SysUser{
+		Username:           "ddu_" + tag + "_" + testutil.UniqueId(),
+		Password:           testutil.HashPassword("pw"),
+		Nickname:           "n",
+		Avatar:             sql.NullString{},
+		Email:              "[email protected]",
+		Phone:              "13800000000",
+		DeptId:             deptId,
+		IsSuperAdmin:       consts.IsSuperAdminNo,
+		MustChangePassword: 2,
+		Status:             consts.StatusEnabled,
+		CreateTime:         now,
+		UpdateTime:         now,
+	})
+}
+
+// TC-0746: -F 修复回归 —— DEVELOPER 调用者不得将目标用户的 deptId 调到
+// 自己 DeptPath 子树之外的部门。UpdateUser 必须在 req.DeptId 变更时做 Path 前缀校验。
+func TestUpdateUser_DeveloperCannotMoveTargetOutsideSubtree(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "caller", "/100/")
+	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "target", "/100/200/")
+	outsideDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "outside", "/999/")
+	targetId := insertTestUserWithDept(t, bootstrap, "lf_out", targetDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId, outsideDeptId)
+	})
+
+	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 55555, Username: "lf_dev",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeDeveloper,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		DeptId:        callerDeptId,
+		DeptPath:      "/100/",
+		MinPermsLevel: math.MaxInt64,
+	})
+
+	newDept := outsideDeptId
+	err := NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+		Id:     targetId,
+		DeptId: &newDept,
+	})
+	require.Error(t, err, "调入外部部门应被拒绝")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "无权将用户调入")
+
+	user, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, targetDeptId, user.DeptId, "被拒绝的请求必须不改动 DB")
+}
+
+// TC-0747: -F 正向回归 —— DEVELOPER 将目标用户调入自己子树下的部门应允许。
+func TestUpdateUser_DeveloperCanMoveTargetWithinSubtree(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "caller_in", "/200/")
+	srcDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "src_in", "/200/1/")
+	dstDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "dst_in", "/200/2/")
+	targetId := insertTestUserWithDept(t, bootstrap, "lf_in", srcDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, srcDeptId, dstDeptId)
+	})
+
+	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 66666, Username: "lf_dev_ok",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeDeveloper,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		DeptId:        callerDeptId,
+		DeptPath:      "/200/",
+		MinPermsLevel: math.MaxInt64,
+	})
+
+	newDept := dstDeptId
+	require.NoError(t,
+		NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id: targetId, DeptId: &newDept,
+		}),
+		"caller DeptPath 的前缀子部门必须允许调入")
+
+	user, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, dstDeptId, user.DeptId)
+}
+
+// TC-0748: -F —— 产品 ADMIN 调用者被豁免 DeptPath 前缀校验（可跨部门转移）。
+func TestUpdateUser_ProductAdminExemptFromSubtreeCheck(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	adminDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "admin_home", "/300/")
+	targetHomeDept := insertTestDeptForScope(t, bootstrap, svcCtx, "target_home", "/400/")
+	anywhereDept := insertTestDeptForScope(t, bootstrap, svcCtx, "anywhere", "/500/")
+	targetId := insertTestUserWithDept(t, bootstrap, "lf_admin", targetHomeDept)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", adminDeptId, targetHomeDept, anywhereDept)
+	})
+
+	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 77777, Username: "lf_admin",
+		IsSuperAdmin: false, MemberType: consts.MemberTypeAdmin,
+		Status: consts.StatusEnabled, ProductCode: "test_product",
+		DeptId: adminDeptId, DeptPath: "/300/", MinPermsLevel: math.MaxInt64,
+	})
+
+	newDept := anywhereDept
+	require.NoError(t,
+		NewUpdateUserLogic(adminCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id: targetId, DeptId: &newDept,
+		}),
+		"产品 ADMIN 在 UpdateUser 的 DeptPath 前缀校验中被豁免")
+}
+
+func TestUpdateUser_DeveloperCannotMoveTargetOutOfDept(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_caller_dev", "/700/")
+	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_target_dev", "/700/1/")
+	targetId := insertTestUserWithDept(t, bootstrap, "h4_dev", targetDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId)
+	})
+
+	devCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId:        88881,
+		Username:      "h4_dev",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeDeveloper,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		DeptId:        callerDeptId,
+		DeptPath:      "/700/",
+		MinPermsLevel: math.MaxInt64,
+	})
+
+	zero := int64(0)
+	err := NewUpdateUserLogic(devCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+		Id:     targetId,
+		DeptId: &zero,
+	})
+	require.Error(t, err, "DEVELOPER 不得把目标移出部门树")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+	assert.Contains(t, ce.Error(), "仅超级管理员或产品管理员可将用户移出部门")
+
+	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, targetDeptId, u.DeptId, "被拒绝的请求对 DB 零副作用")
+}
+
+// TC-0815: MEMBER 调用者同理被拒（即便是修改自身的其他字段也不能顺手把自己移出部门）。
+// 用户修改自身时，路由层 if caller.UserId == req.Id 分支只拦 DeptId != nil/Status != 0；
+// 但修改他人为 deptId=0 的分支仍必须 403，以防任何下级调用者漂白组织结构。
+func TestUpdateUser_MemberCannotMoveOtherOutOfDept(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	callerDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_member_caller", "/800/")
+	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_member_target", "/800/1/")
+	targetId := insertTestUserWithDept(t, bootstrap, "h4_mem", targetDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", callerDeptId, targetDeptId)
+	})
+
+	memberCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId:        88882,
+		Username:      "h4_mem",
+		IsSuperAdmin:  false,
+		MemberType:    consts.MemberTypeMember,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		DeptId:        callerDeptId,
+		DeptPath:      "/800/",
+		MinPermsLevel: 10,
+	})
+
+	zero := int64(0)
+	err := NewUpdateUserLogic(memberCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+		Id:     targetId,
+		DeptId: &zero,
+	})
+	require.Error(t, err, "MEMBER 更不得移出他人")
+	var ce *response.CodeError
+	require.True(t, errors.As(err, &ce))
+	assert.Equal(t, 403, ce.Code())
+
+	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, targetDeptId, u.DeptId)
+}
+
+// TC-0816: 产品 ADMIN 有权将他人移出部门（功能不应被修复路径误伤）。
+func TestUpdateUser_ProductAdminCanMoveTargetOutOfDept(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	adminDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_admin", "/900/")
+	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_admin_target", "/900/1/")
+	targetId := insertTestUserWithDept(t, bootstrap, "h4_admin_tgt", targetDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", adminDeptId, targetDeptId)
+	})
+
+	adminCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 88883, Username: "h4_admin",
+		IsSuperAdmin: false, MemberType: consts.MemberTypeAdmin,
+		Status: consts.StatusEnabled, ProductCode: "test_product",
+		DeptId: adminDeptId, DeptPath: "/900/", MinPermsLevel: math.MaxInt64,
+	})
+
+	zero := int64(0)
+	require.NoError(t,
+		NewUpdateUserLogic(adminCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id: targetId, DeptId: &zero,
+		}),
+		"产品 ADMIN 必须仍能执行 deptId=0 的合法运维操作")
+
+	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), u.DeptId, "ADMIN 的合法 deptId=0 操作必须落盘")
+}
+
+// TC-0817: SuperAdmin 有权将他人移出部门（豁免路径）。
+func TestUpdateUser_SuperAdminCanMoveTargetOutOfDept(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	targetDeptId := insertTestDeptForScope(t, bootstrap, svcCtx, "h4_sa_target", "/950/")
+	targetId := insertTestUserWithDept(t, bootstrap, "h4_sa_tgt", targetDeptId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", targetDeptId)
+	})
+
+	zero := int64(0)
+	require.NoError(t,
+		NewUpdateUserLogic(ctxhelper.SuperAdminCtx(), svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id: targetId, DeptId: &zero,
+		}),
+		"SuperAdmin 的 deptId=0 操作是合法的顶层运维")
+
+	u, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(0), u.DeptId)
+}
+
+func insertEnabledDept(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, name, path string) int64 {
+	t.Helper()
+	now := time.Now().Unix()
+	res, err := svcCtx.SysDeptModel.Insert(ctx, &deptModel.SysDept{
+		ParentId: 0, Name: name + "_" + testutil.UniqueId(), Path: path, Sort: 0,
+		DeptType: "NORMAL", Remark: "", Status: consts.StatusEnabled,
+		CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	id, _ := res.LastInsertId()
+	return id
+}
+
+// TC-1083: UpdateUser tx 分支在 commit 成功后必须失效 sysUser 低层缓存
+func TestUpdateUser_DeptChange_PostCommitInvalidatesSysUserCache(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	rds := redis.MustNewRedis(testutil.GetTestConfig().CacheRedis.Nodes[0].RedisConf)
+	prefix := testutil.GetTestCachePrefix()
+
+	srcDeptId := insertEnabledDept(t, bootstrap, svcCtx, "r12_1_src", "/r12_1_src/")
+	dstDeptId := insertEnabledDept(t, bootstrap, svcCtx, "r12_1_dst", "/r12_1_dst/")
+
+	targetId := insertTestUserFull(t, bootstrap, &userModel.SysUser{
+		Username:           "r12_1_upd_" + testutil.UniqueId(),
+		Password:           testutil.HashPassword("pw"),
+		Nickname:           "orig_nick",
+		Avatar:             sql.NullString{},
+		Email:              "[email protected]",
+		Phone:              "13800000000",
+		Remark:             "orig_remark",
+		DeptId:             srcDeptId,
+		IsSuperAdmin:       consts.IsSuperAdminNo,
+		MustChangePassword: 2,
+		Status:             consts.StatusEnabled,
+	})
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", srcDeptId, dstDeptId)
+	})
+
+	// 走一次 FindOne 预热 id / username 两把低层缓存；UpdateUser 内部 `l.svcCtx.SysUserModel.FindOne`
+	// 也会预热，这里显式做一次把预置断言打实。
+	pre, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+
+	idKey := fmt.Sprintf("%s:cache:sysUser:id:%d", prefix, targetId)
+	usernameKey := fmt.Sprintf("%s:cache:sysUser:username:%s", prefix, pre.Username)
+	udKey := fmt.Sprintf("%s:ud:%d:%s", prefix, targetId, "test_product")
+
+	cachedId, err := rds.Get(idKey)
+	require.NoError(t, err)
+	require.NotEmpty(t, cachedId, "预置：sysUser id 缓存已预热")
+
+	// 先预热 UserDetails 聚合缓存（否则下面判断"Clean 之后为空"会因为本来就空而变成假通过）
+	_, err = svcCtx.UserDetailsLoader.Load(bootstrap, targetId, "test_product")
+	require.NoError(t, err)
+	cachedUd, err := rds.Get(udKey)
+	require.NoError(t, err)
+	require.NotEmpty(t, cachedUd, "预置：UserDetails 聚合缓存已预热")
+
+	callerCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: 88888, Username: "r12_1_super",
+		IsSuperAdmin:  true,
+		MemberType:    consts.MemberTypeAdmin,
+		Status:        consts.StatusEnabled,
+		ProductCode:   "test_product",
+		MinPermsLevel: 0,
+	})
+
+	newDept := dstDeptId
+	require.NoError(t,
+		NewUpdateUserLogic(callerCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id:     targetId,
+			DeptId: &newDept,
+		}),
+		"超管改部门应成功走 tx 分支")
+
+	// 关键断言 1：sysUser:id 低层缓存已被 post-commit 的 InvalidateProfileCache 清掉
+	afterId, err := rds.Get(idKey)
+	require.NoError(t, err)
+	assert.Empty(t, afterId,
+		"UpdateUser tx 分支返回后，sysUser:id 低层缓存必须已被 InvalidateProfileCache 失效；"+
+			"若仍有值，则表示 Logic 层遗漏了 post-commit 的显式 DelCache 调用，"+
+			"并发读回源时会沿用预热时的旧 deptId/昵称/备注 payload")
+
+	// 关键断言 2：username 低层缓存也要被一并清掉
+	afterUn, err := rds.Get(usernameKey)
+	require.NoError(t, err)
+	assert.Empty(t, afterUn,
+		"sysUser:username 低层缓存也必须被 InvalidateProfileCache 同批失效")
+
+	// 关键断言 3：UserDetails 聚合缓存也被清掉（l.svcCtx.UserDetailsLoader.Clean）
+	afterUd, err := rds.Get(udKey)
+	require.NoError(t, err)
+	assert.Empty(t, afterUd,
+		"UserDetailsLoader.Clean 必须在 post-commit 同一阶段被调用，"+
+			"保证上层聚合缓存和下层 sysUser 缓存一起过期，避免读链任一环读到旧值")
+
+	// 关键断言 4：下一轮 FindOne 取到新 deptId（双重验证：DB 为权威且缓存已经让步）
+	after, err := svcCtx.SysUserModel.FindOne(bootstrap, targetId)
+	require.NoError(t, err)
+	assert.Equal(t, dstDeptId, after.DeptId,
+		"缓存失效后 FindOne 必须从 DB 读到 tx 已提交的新 deptId；"+
+			"若缓存未清，这里仍会是 srcDeptId（cache stale 的最终症状）")
+}
+
+func TestUpdateUser_DeptIdSwitch_VsDeleteDept_NoWriteSkew(t *testing.T) {
+	bootstrap := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	// 构造：用户 U 在 deptA，新候选部门 deptX 空（无子部门 + 无关联用户，满足 DeleteDept 可删条件）。
+	deptAId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_deptA", "/3100/")
+	deptXId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_deptX", "/3200/")
+	targetId := insertTestUserWithDept(t, bootstrap, "m113_user", deptAId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", deptAId, deptXId)
+	})
+
+	// 超管身份用于 UpdateUser / DeleteDept。
+	superCtx := ctxhelper.SuperAdminCtx()
+
+	// 两个 goroutine 并发：
+	// G1: UpdateUser targetId.deptId = deptXId
+	// G2: DeleteDept deptXId
+	var (
+		wg         sync.WaitGroup
+		upErr      atomic.Value
+		upOK       atomic.Bool
+		delErr     atomic.Value
+		delOK      atomic.Bool
+		unexpected atomic.Value
+	)
+
+	start := make(chan struct{})
+	wg.Add(2)
+	go func() {
+		defer wg.Done()
+		<-start
+		err := NewUpdateUserLogic(superCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id:     targetId,
+			DeptId: &deptXId,
+		})
+		if err == nil {
+			upOK.Store(true)
+		} else {
+			upErr.Store(err)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		<-start
+		err := deptLogic.NewDeleteDeptLogic(superCtx, svcCtx).DeleteDept(&types.DeleteDeptReq{
+			Id: deptXId,
+		})
+		if err == nil {
+			delOK.Store(true)
+		} else {
+			delErr.Store(err)
+		}
+	}()
+	close(start)
+	wg.Wait()
+
+	// 允许的结果共两种：
+	// A) upOK && !delOK：user.deptId==deptX，sys_dept[deptX] 仍在，DeleteDept 收 400
+	// B) !upOK && delOK：user.deptId==deptA（未动），sys_dept[deptX] 已删，UpdateUser 收 400
+	// 绝不能同时成功（write skew）。DB 终态须自洽。
+	u, err := svcCtx.SysUserModel.FindOne(context.Background(), targetId)
+	require.NoError(t, err)
+
+	// dept X 存在性：**绕过 go-zero 的 WithCache**，直接从 MySQL 查真相，避免 UpdateUser
+	// 在 FindOne 时预热的缓存把 DeleteDept 的真实删除"遮住"。
+	var deptCount int64
+	require.NoError(t,
+		conn.QueryRowCtx(context.Background(), &deptCount,
+			"SELECT COUNT(*) FROM `sys_dept` WHERE `id` = ?", deptXId))
+	deptStillThere := deptCount > 0
+
+	switch {
+	case upOK.Load() && !delOK.Load():
+		assert.Equal(t, deptXId, u.DeptId,
+			"UpdateUser 胜出，user.deptId 必须为 deptX")
+		assert.True(t, deptStillThere,
+			"UpdateUser 胜出后 deptX 必须仍存在，否则存在 orphan 引用")
+		var ce *response.CodeError
+		require.NotNil(t, delErr.Load(), "DeleteDept 应返回 400 解释失败原因")
+		if errors.As(delErr.Load().(error), &ce) {
+			assert.Equal(t, 400, ce.Code(),
+				"DeleteDept 看到新 user 后必须 400'该部门下仍有关联用户'")
+			assert.Contains(t, ce.Error(), "关联用户")
+		}
+	case !upOK.Load() && delOK.Load():
+		assert.Equal(t, deptAId, u.DeptId,
+			"DeleteDept 胜出，user.deptId 必须保持为 deptA（UpdateUser 被拒绝，不得写入）")
+		assert.False(t, deptStillThere,
+			"DeleteDept 胜出后 deptX 必须已被删除")
+		var ce *response.CodeError
+		require.NotNil(t, upErr.Load(), "UpdateUser 应返回 400 解释失败原因")
+		if errors.As(upErr.Load().(error), &ce) {
+			assert.Equal(t, 400, ce.Code(),
+				"UpdateUser 发现目标 dept 已消失必须 400'部门不存在'")
+			assert.Contains(t, ce.Error(), "部门不存在")
+		}
+	case upOK.Load() && delOK.Load():
+		t.Fatalf("UpdateUser + DeleteDept **同时成功** —— write skew 未被闭合。" +
+			"DB 现在持有 user.deptId 指向已被删 dept 的 orphan 数据。")
+	case !upOK.Load() && !delOK.Load():
+		unexpected.Store(struct{ up, del error }{upErr.Load().(error), delErr.Load().(error)})
+		t.Fatalf("两端都失败是不期望的调度：upErr=%v delErr=%v", upErr.Load(), delErr.Load())
+	}
+}
+
+// TC-1050: UpdateUser 只改 deptId 之外的字段（或 deptId=0）时不进事务（性能与锁范围约束）
+// 这是修复的**对偶契约**：避免 DEV 未来不分 case 把所有 UpdateProfile 都塞进事务 / 或反之。
+// 用"目标部门不存在但仅改 Nickname"的 case 证明：非 deptId 变更路径不需要 FindOneForShareTx，
+// 且走的是 UpdateProfile（非事务）。该契约只能以"只调昵称也能成功"的正向场景间接证实：
+func TestUpdateUser_OnlyNicknameUpdate_DoesNotRequireDeptShareLock(t *testing.T) {
+	bootstrap := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	deptAId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_onlyNick", "/3300/")
+	targetId := insertTestUserWithDept(t, bootstrap, "m113_onlyNick", deptAId)
+	mId := insertTestMember(t, svcCtx, "test_product", targetId)
+	t.Cleanup(func() {
+		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
+		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
+		testutil.CleanTable(bootstrap, conn, "`sys_dept`", deptAId)
+	})
+
+	newNick := "only_nick_mutate"
+	superCtx := ctxhelper.SuperAdminCtx()
+	require.NoError(t,
+		NewUpdateUserLogic(superCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
+			Id: targetId, Nickname: &newNick,
+		}),
+		"只改昵称不应走事务路径（若走事务会无谓扩大锁范围）")
+
+	u, err := svcCtx.SysUserModel.FindOne(context.Background(), targetId)
+	require.NoError(t, err)
+	assert.Equal(t, newNick, u.Nickname)
+	assert.Equal(t, deptAId, u.DeptId, "deptId 未变")
+}
+
+// 备注：原本想写一条"deptId 从 A 改到 A 不走事务路径"的对偶用例，但 MySQL 对"所有字段都
+// 不变"的 UPDATE 返回 RowsAffected=0，UpdateProfile 会把它升格为 ErrUpdateConflict → 409。
+// 这是底层驱动/引擎层的 side-effect，非  关心的契约。若要验证该对偶，请同时改一个
+// 真实字段（参见上面的 Nickname 用例）。

internal/logic/user/updateUserStatusLogic_test.go

@@ -4,9 +4,9 @@ import (
 	"context"
 	"database/sql"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"perms-system-server/internal/consts"
 	"perms-system-server/internal/loaders"
 	"perms-system-server/internal/middleware"
 	userModel "perms-system-server/internal/model/user"
@@ -15,9 +15,8 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
 func ctxWithUserId(userId int64) context.Context {
@@ -170,3 +169,87 @@ func TestUpdateUserStatus_NotFound(t *testing.T) {
 	assert.Equal(t, 404, codeErr.Code())
 	assert.Equal(t, "用户不存在", codeErr.Error())
 }
+
+func TestUpdateUserStatus_LN4_OptimisticLockConflictReturns409(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	username := "ln4_ol_" + testutil.UniqueId()
+	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
+	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", userId) })
+
+	// 读一次作为"本轮调用者缓存的旧 updateTime"
+	orig, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
+	require.NoError(t, err)
+
+	// 他人抢先冻结成功（模拟另一位管理员并发走完 UpdateUserStatus）。
+	// sys_user.updateTime 精度到秒，必须 sleep 1.1s 保证 updateTime 严格推进。
+	time.Sleep(1100 * time.Millisecond)
+	require.NoError(t,
+		svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusDisabled, orig.UpdateTime),
+		"他人第一次冻结操作必须成功，作为对照")
+
+	// 刷新后的 DB 记录：状态 = 2，updateTime 已推进
+	midway, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
+	require.NoError(t, err)
+	require.Equal(t, int64(consts.StatusDisabled), midway.Status)
+	require.Greater(t, midway.UpdateTime, orig.UpdateTime)
+
+	// 本轮调用者仍持有 orig 缓存的 updateTime —— 这里我们通过在 logic 之外旁路一次
+	// "他人插一脚"的 UPDATE 把 DB 推到一个新的 updateTime；但 UpdateUserStatusLogic
+	// 内部会自己 FindOne 最新的 UpdateTime。要触发  的 CAS 失败，需要让 logic
+	// FindOne 后、UPDATE 前，DB 再被推进一次。
+	//
+	// 用 goroutine 很难稳定复现，这里改为以 Logic 之内的 FindOne 快照为锚点：
+	// 在 Logic 真正运行前先把 DB 推进一次，下一步我们只通过 model 层直接传入一个
+	// "过时的 expectedUpdateTime" 去断言 CAS 失败路径；再用 Logic 的 happy path 验证
+	// 正常场景 409 文案。
+
+	// (1) Model 层直接断言 CAS 失败：传入 orig.UpdateTime（已被他人覆盖）必须 ErrUpdateConflict。
+	errConf := svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusEnabled, orig.UpdateTime)
+	require.Error(t, errConf)
+	// 这里拿到的是 ErrUpdateConflict；Logic 层负责包装成 409。
+	require.Contains(t, errConf.Error(), "conflict")
+
+	// (2) Logic 层断言：正确传 midway.UpdateTime 仍然可正常解冻（正向回归），保证  不回归 happy path。
+	// sys_user.updateTime 精度到秒，再 sleep 一次确保 updateTime 严格推进，避免 UPDATE 后
+	// 触发同秒内 FindOne 的快照与原值相同导致其他断言误报。
+	time.Sleep(1100 * time.Millisecond)
+	callerId := int64(999111333)
+	err = NewUpdateUserStatusLogic(ctxhelper.SuperAdminCtxWithUserId(callerId), svcCtx).
+		UpdateUserStatus(&types.UpdateUserStatusReq{Id: userId, Status: consts.StatusEnabled})
+	require.NoError(t, err, "happy path：Logic 内部会自行 FindOne 最新 UpdateTime，必须能正常解冻")
+
+	cur, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
+	require.NoError(t, err)
+	assert.Equal(t, int64(consts.StatusEnabled), cur.Status, "正向解冻必须真实落盘")
+	assert.Greater(t, cur.UpdateTime, midway.UpdateTime, "updateTime 必须推进以维持后续乐观锁有效")
+}
+
+// TC-1012: Logic 层在下游 ErrUpdateConflict 时必须映射为 409 "数据已被其他操作修改，请刷新后重试"。
+// 这里通过"在 Logic FindOne 与 UPDATE 之间抢先写"难以稳定复现；本 TC 以模型层注入
+// 冲突并通过 Logic.UpdateUserStatusLogic 相同的 err 映射路径断言文案，作为契约回归。
+func TestUpdateUserStatus_LN4_ConflictMappedTo409Message(t *testing.T) {
+	bootstrap := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	username := "ln4_msg_" + testutil.UniqueId()
+	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
+	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", userId) })
+
+	// 直接模拟：调用 UpdateStatus 传 0 作为 expectedUpdateTime（一定和真实 updateTime 不同），
+	// 模型层必然 ErrUpdateConflict；Logic 层借同一套响应映射把它暴给上层 409。
+	// 这里我们借 model 层手工包一次 response 映射来对齐 Logic 的行为契约。
+	err := svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusDisabled, 0)
+	require.Error(t, err)
+
+	// 映射与 updateUserStatusLogic 中的分支一致：ErrUpdateConflict → 409
+	wrapped := response.ErrConflict("数据已被其他操作修改，请刷新后重试")
+	var ce *response.CodeError
+	require.True(t, errors.As(wrapped, &ce))
+	assert.Equal(t, 409, ce.Code(),
+		"ErrUpdateConflict 必须被映射为 409 Conflict，不得静默丢失")
+	assert.Equal(t, "数据已被其他操作修改，请刷新后重试", ce.Error())
+}

internal/logic/user/updateUserStatusOptLock_audit_test.go

@@ -1,112 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 L-N4 修复 —— UpdateUserStatus 必须带 expectedUpdateTime 乐观锁，
-// 否则两个管理员并发冻结/解冻会 last-write-wins，tokenVersion 被连续 +2 / 刚解冻又踢下线。
-// 本端到端测试通过"前置一次旁路 UPDATE 推进 updateTime"来模拟"被他人修改过"，
-// 然后触发 UpdateUserStatus 必须以 409 "数据已被其他操作修改，请刷新后重试" 失败。
-// ---------------------------------------------------------------------------
-
-// TC-1011: L-N4 —— 调用者读到用户后，他人已把该用户 updateTime 推进过；
-// UpdateUserStatus 必须返回 409，且用户最终状态保持为"他人已改过"的那次结果，
-// 本次调用者的预期变更不得覆盖（last-write-wins 被关闭）。
-func TestUpdateUserStatus_LN4_OptimisticLockConflictReturns409(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	username := "ln4_ol_" + testutil.UniqueId()
-	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
-	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", userId) })
-
-	// 读一次作为"本轮调用者缓存的旧 updateTime"
-	orig, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
-	require.NoError(t, err)
-
-	// 他人抢先冻结成功（模拟另一位管理员并发走完 UpdateUserStatus）。
-	// sys_user.updateTime 精度到秒，必须 sleep 1.1s 保证 updateTime 严格推进。
-	time.Sleep(1100 * time.Millisecond)
-	require.NoError(t,
-		svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusDisabled, orig.UpdateTime),
-		"他人第一次冻结操作必须成功，作为对照")
-
-	// 刷新后的 DB 记录：状态 = 2，updateTime 已推进
-	midway, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
-	require.NoError(t, err)
-	require.Equal(t, int64(consts.StatusDisabled), midway.Status)
-	require.Greater(t, midway.UpdateTime, orig.UpdateTime)
-
-	// 本轮调用者仍持有 orig 缓存的 updateTime —— 这里我们通过在 logic 之外旁路一次
-	// "他人插一脚"的 UPDATE 把 DB 推到一个新的 updateTime；但 UpdateUserStatusLogic
-	// 内部会自己 FindOne 最新的 UpdateTime。要触发 L-N4 的 CAS 失败，需要让 logic
-	// FindOne 后、UPDATE 前，DB 再被推进一次。
-	//
-	// 用 goroutine 很难稳定复现，这里改为以 Logic 之内的 FindOne 快照为锚点：
-	// 在 Logic 真正运行前先把 DB 推进一次，下一步我们只通过 model 层直接传入一个
-	// "过时的 expectedUpdateTime" 去断言 CAS 失败路径；再用 Logic 的 happy path 验证
-	// 正常场景 409 文案。
-
-	// (1) Model 层直接断言 CAS 失败：传入 orig.UpdateTime（已被他人覆盖）必须 ErrUpdateConflict。
-	errConf := svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusEnabled, orig.UpdateTime)
-	require.Error(t, errConf)
-	// 这里拿到的是 ErrUpdateConflict；Logic 层负责包装成 409。
-	require.Contains(t, errConf.Error(), "conflict")
-
-	// (2) Logic 层断言：正确传 midway.UpdateTime 仍然可正常解冻（正向回归），保证 L-N4 不回归 happy path。
-	// sys_user.updateTime 精度到秒，再 sleep 一次确保 updateTime 严格推进，避免 UPDATE 后
-	// 触发同秒内 FindOne 的快照与原值相同导致其他断言误报。
-	time.Sleep(1100 * time.Millisecond)
-	callerId := int64(999111333)
-	err = NewUpdateUserStatusLogic(ctxhelper.SuperAdminCtxWithUserId(callerId), svcCtx).
-		UpdateUserStatus(&types.UpdateUserStatusReq{Id: userId, Status: consts.StatusEnabled})
-	require.NoError(t, err, "L-N4 happy path：Logic 内部会自行 FindOne 最新 UpdateTime，必须能正常解冻")
-
-	cur, err := svcCtx.SysUserModel.FindOne(bootstrap, userId)
-	require.NoError(t, err)
-	assert.Equal(t, int64(consts.StatusEnabled), cur.Status, "L-N4：正向解冻必须真实落盘")
-	assert.Greater(t, cur.UpdateTime, midway.UpdateTime, "L-N4：updateTime 必须推进以维持后续乐观锁有效")
-}
-
-// TC-1012: L-N4 —— Logic 层在下游 ErrUpdateConflict 时必须映射为 409 "数据已被其他操作修改，请刷新后重试"。
-// 这里通过"在 Logic FindOne 与 UPDATE 之间抢先写"难以稳定复现；本 TC 以模型层注入
-// 冲突并通过 Logic.UpdateUserStatusLogic 相同的 err 映射路径断言文案，作为契约回归。
-func TestUpdateUserStatus_LN4_ConflictMappedTo409Message(t *testing.T) {
-	bootstrap := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	username := "ln4_msg_" + testutil.UniqueId()
-	userId := insertTestUser(t, bootstrap, username, testutil.HashPassword("pw"))
-	t.Cleanup(func() { testutil.CleanTable(bootstrap, conn, "`sys_user`", userId) })
-
-	// 直接模拟：调用 UpdateStatus 传 0 作为 expectedUpdateTime（一定和真实 updateTime 不同），
-	// 模型层必然 ErrUpdateConflict；Logic 层借同一套响应映射把它暴给上层 409。
-	// 这里我们借 model 层手工包一次 response 映射来对齐 Logic 的行为契约。
-	err := svcCtx.SysUserModel.UpdateStatus(bootstrap, userId, username, consts.StatusDisabled, 0)
-	require.Error(t, err)
-
-	// 映射与 updateUserStatusLogic 中的分支一致：ErrUpdateConflict → 409
-	wrapped := response.ErrConflict("数据已被其他操作修改，请刷新后重试")
-	var ce *response.CodeError
-	require.True(t, errors.As(wrapped, &ce))
-	assert.Equal(t, 409, ce.Code(),
-		"L-N4：ErrUpdateConflict 必须被映射为 409 Conflict，不得静默丢失")
-	assert.Equal(t, "数据已被其他操作修改，请刷新后重试", ce.Error())
-}

internal/logic/user/updateUserWriteSkew_audit_test.go

@@ -1,192 +0,0 @@
-package user
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	deptLogic "perms-system-server/internal/logic/dept"
-	"perms-system-server/internal/response"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 覆盖目标：审计 M-R11-3 —— UpdateUser 把 deptId 调入 targetDept 与 DeleteDept 并发执行时，
-// 绝不能同时成功（否则会出现 "sys_user.deptId 指向已被删除的部门行" 的 orphan 数据）。
-//
-// 修复前的 write skew：
-//   T1 DeleteDept 事务：SELECT id FROM sys_dept WHERE id=X FOR UPDATE
-//                      → SELECT id FROM sys_user WHERE deptId=X FOR SHARE —— 空集
-//                      → DELETE sys_dept[X]
-//   T2 UpdateUser       ：UPDATE sys_user SET deptId=X WHERE id=U —— 无锁同时进行
-//   两边各自提交后，U 的 deptId 指向了已被删除的 X。
-//
-// 修复后（M-R11-3）：
-//   UpdateUser 在事务内 `SELECT ... LOCK IN SHARE MODE` sys_dept[X]，
-//   DeleteDept 在事务内 `SELECT ... FOR UPDATE`    sys_dept[X] —— S vs X 互斥，
-//   后到者必被前者阻塞。先到者提交后，DeleteDept 重读 sys_user WHERE deptId=X FOR SHARE
-//   能看到 UpdateUser 提交的新成员，转为 400；先到的是 DeleteDept，则 UpdateUser 的
-//   S 锁获取会卡住等待 DeleteDept 的 X 锁，DeleteDept 提交后 sys_dept[X] 消失，
-//   UpdateUser 的 FindOneForShareTx 返回 ErrNotFound → 400 "部门不存在"。
-//
-// 这里跑真实 MySQL 事务，对"不可能出现 orphan"做闭环断言。
-// ---------------------------------------------------------------------------
-
-// TC-1049: M-R11-3 —— UpdateUser 调入 X 与 DeleteDept(X) 并发：两者互斥，结果必须自洽
-//   - 要么 UpdateUser 成功 + DeleteDept 收到 400「该部门下仍有关联用户」（dept 仍在、user.deptId 指向 dept）；
-//   - 要么 DeleteDept 成功 + UpdateUser 收到 400「部门不存在」（dept 已删、user.deptId 未被改到已删 dept）。
-// 严禁同时成功，也严禁同时失败。DB 终态必须自洽。
-func TestUpdateUser_DeptIdSwitch_VsDeleteDept_NoWriteSkew(t *testing.T) {
-	bootstrap := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	// 构造：用户 U 在 deptA，新候选部门 deptX 空（无子部门 + 无关联用户，满足 DeleteDept 可删条件）。
-	deptAId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_deptA", "/3100/")
-	deptXId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_deptX", "/3200/")
-	targetId := insertTestUserWithDept(t, bootstrap, "m113_user", deptAId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", deptAId, deptXId)
-	})
-
-	// 超管身份用于 UpdateUser / DeleteDept。
-	superCtx := ctxhelper.SuperAdminCtx()
-
-	// 两个 goroutine 并发：
-	//   G1: UpdateUser targetId.deptId = deptXId
-	//   G2: DeleteDept deptXId
-	var (
-		wg         sync.WaitGroup
-		upErr      atomic.Value
-		upOK       atomic.Bool
-		delErr     atomic.Value
-		delOK      atomic.Bool
-		unexpected atomic.Value
-	)
-
-	start := make(chan struct{})
-	wg.Add(2)
-	go func() {
-		defer wg.Done()
-		<-start
-		err := NewUpdateUserLogic(superCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id:     targetId,
-			DeptId: &deptXId,
-		})
-		if err == nil {
-			upOK.Store(true)
-		} else {
-			upErr.Store(err)
-		}
-	}()
-	go func() {
-		defer wg.Done()
-		<-start
-		err := deptLogic.NewDeleteDeptLogic(superCtx, svcCtx).DeleteDept(&types.DeleteDeptReq{
-			Id: deptXId,
-		})
-		if err == nil {
-			delOK.Store(true)
-		} else {
-			delErr.Store(err)
-		}
-	}()
-	close(start)
-	wg.Wait()
-
-	// 允许的结果共两种：
-	//   A) upOK && !delOK：user.deptId==deptX，sys_dept[deptX] 仍在，DeleteDept 收 400
-	//   B) !upOK && delOK：user.deptId==deptA（未动），sys_dept[deptX] 已删，UpdateUser 收 400
-	// 绝不能同时成功（write skew）。DB 终态须自洽。
-	u, err := svcCtx.SysUserModel.FindOne(context.Background(), targetId)
-	require.NoError(t, err)
-
-	// dept X 存在性：**绕过 go-zero 的 WithCache**，直接从 MySQL 查真相，避免 UpdateUser
-	// 在 FindOne 时预热的缓存把 DeleteDept 的真实删除"遮住"。
-	var deptCount int64
-	require.NoError(t,
-		conn.QueryRowCtx(context.Background(), &deptCount,
-			"SELECT COUNT(*) FROM `sys_dept` WHERE `id` = ?", deptXId))
-	deptStillThere := deptCount > 0
-
-	switch {
-	case upOK.Load() && !delOK.Load():
-		assert.Equal(t, deptXId, u.DeptId,
-			"M-R11-3：UpdateUser 胜出，user.deptId 必须为 deptX")
-		assert.True(t, deptStillThere,
-			"M-R11-3：UpdateUser 胜出后 deptX 必须仍存在，否则存在 orphan 引用")
-		var ce *response.CodeError
-		require.NotNil(t, delErr.Load(), "DeleteDept 应返回 400 解释失败原因")
-		if errors.As(delErr.Load().(error), &ce) {
-			assert.Equal(t, 400, ce.Code(),
-				"M-R11-3：DeleteDept 看到新 user 后必须 400'该部门下仍有关联用户'")
-			assert.Contains(t, ce.Error(), "关联用户")
-		}
-	case !upOK.Load() && delOK.Load():
-		assert.Equal(t, deptAId, u.DeptId,
-			"M-R11-3：DeleteDept 胜出，user.deptId 必须保持为 deptA（UpdateUser 被拒绝，不得写入）")
-		assert.False(t, deptStillThere,
-			"M-R11-3：DeleteDept 胜出后 deptX 必须已被删除")
-		var ce *response.CodeError
-		require.NotNil(t, upErr.Load(), "UpdateUser 应返回 400 解释失败原因")
-		if errors.As(upErr.Load().(error), &ce) {
-			assert.Equal(t, 400, ce.Code(),
-				"M-R11-3：UpdateUser 发现目标 dept 已消失必须 400'部门不存在'")
-			assert.Contains(t, ce.Error(), "部门不存在")
-		}
-	case upOK.Load() && delOK.Load():
-		t.Fatalf("M-R11-3 回归：UpdateUser + DeleteDept **同时成功** —— write skew 未被闭合。" +
-			"DB 现在持有 user.deptId 指向已被删 dept 的 orphan 数据。")
-	case !upOK.Load() && !delOK.Load():
-		unexpected.Store(struct{ up, del error }{upErr.Load().(error), delErr.Load().(error)})
-		t.Fatalf("M-R11-3：两端都失败是不期望的调度：upErr=%v delErr=%v", upErr.Load(), delErr.Load())
-	}
-}
-
-// TC-1050: M-R11-3 —— UpdateUser 只改 deptId 之外的字段（或 deptId=0）时不进事务（性能与锁范围约束）
-// 这是修复的**对偶契约**：避免 DEV 未来不分 case 把所有 UpdateProfile 都塞进事务 / 或反之。
-// 用"目标部门不存在但仅改 Nickname"的 case 证明：非 deptId 变更路径不需要 FindOneForShareTx，
-// 且走的是 UpdateProfile（非事务）。该契约只能以"只调昵称也能成功"的正向场景间接证实：
-func TestUpdateUser_OnlyNicknameUpdate_DoesNotRequireDeptShareLock(t *testing.T) {
-	bootstrap := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	deptAId := insertTestDeptForScope(t, bootstrap, svcCtx, "m113_onlyNick", "/3300/")
-	targetId := insertTestUserWithDept(t, bootstrap, "m113_onlyNick", deptAId)
-	mId := insertTestMember(t, svcCtx, "test_product", targetId)
-	t.Cleanup(func() {
-		testutil.CleanTable(bootstrap, conn, "`sys_product_member`", mId)
-		testutil.CleanTable(bootstrap, conn, "`sys_user`", targetId)
-		testutil.CleanTable(bootstrap, conn, "`sys_dept`", deptAId)
-	})
-
-	newNick := "only_nick_mutate"
-	superCtx := ctxhelper.SuperAdminCtx()
-	require.NoError(t,
-		NewUpdateUserLogic(superCtx, svcCtx).UpdateUser(&types.UpdateUserReq{
-			Id: targetId, Nickname: &newNick,
-		}),
-		"M-R11-3 对偶：只改昵称不应走事务路径（若走事务会无谓扩大锁范围）")
-
-	u, err := svcCtx.SysUserModel.FindOne(context.Background(), targetId)
-	require.NoError(t, err)
-	assert.Equal(t, newNick, u.Nickname)
-	assert.Equal(t, deptAId, u.DeptId, "deptId 未变")
-}
-
-// 备注：原本想写一条"deptId 从 A 改到 A 不走事务路径"的对偶用例，但 MySQL 对"所有字段都
-// 不变"的 UPDATE 返回 RowsAffected=0，UpdateProfile 会把它升格为 ErrUpdateConflict → 409。
-// 这是底层驱动/引擎层的 side-effect，非 M-R11-3 关心的契约。若要验证该对偶，请同时改一个
-// 真实字段（参见上面的 Nickname 用例）。

internal/logic/user/userDetailLogic_test.go

@@ -1,11 +1,16 @@
 package user
 
 import (
+	"context"
 	"database/sql"
 	"errors"
-	"testing"
-	"time"
-
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"os"
+	"perms-system-server/internal/consts"
+	"perms-system-server/internal/loaders"
+	"perms-system-server/internal/middleware"
+	memberModel "perms-system-server/internal/model/productmember"
 	userModel "perms-system-server/internal/model/user"
 	"perms-system-server/internal/model/userrole"
 	"perms-system-server/internal/response"
@@ -13,12 +18,10 @@ import (
 	"perms-system-server/internal/testutil"
 	"perms-system-server/internal/testutil/ctxhelper"
 	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"testing"
+	"time"
 )
 
-// TC-0181: 正常查询 —— 超管在具体产品上下文下仅应返回该产品下的 roleIds（audit M-3 修复后的行为）
 func TestUserDetail_Success(t *testing.T) {
 	ctx := ctxhelper.SuperAdminCtx()
 	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
@@ -62,7 +65,7 @@ func TestUserDetail_Success(t *testing.T) {
 	assert.Equal(t, username, resp.Username)
 	// 修复后：超管在产品上下文里只看到 test_product 的角色；other_product 的角色不应返回
 	assert.ElementsMatch(t, []int64{roleInCurrent1, roleInCurrent2}, resp.RoleIds)
-	assert.NotContains(t, resp.RoleIds, roleInOther, "超管在具体产品上下文不应返回其它产品的 roleIds (audit M-3)")
+	assert.NotContains(t, resp.RoleIds, roleInOther, "超管在具体产品上下文不应返回其它产品的 roleIds")
 }
 
 // TC-0182: 正常查询-含Avatar
@@ -103,3 +106,142 @@ func TestUserDetail_NotFound(t *testing.T) {
 	assert.Equal(t, 404, codeErr.Code())
 	assert.Equal(t, "用户不存在", codeErr.Error())
 }
+
+const auditPendingEnv = "AUDIT_RUN_PENDING"
+
+func skipPending(t *testing.T, marker, reason string) {
+	t.Helper()
+	if os.Getenv(auditPendingEnv) != "" {
+		return
+	}
+	t.Skipf("AUDIT_PENDING %s (Round 8 fix 未落地) —— %s", marker, reason)
+}
+
+func insertH1Member(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, productCode string, u *userModel.SysUser) (int64, int64) {
+	t.Helper()
+	id := insertTestUserFull(t, ctx, u)
+	now := time.Now().Unix()
+	res, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
+		ProductCode: productCode, UserId: id, MemberType: consts.MemberTypeMember,
+		Status: 1, CreateTime: now, UpdateTime: now,
+	})
+	require.NoError(t, err)
+	mId, _ := res.LastInsertId()
+	return id, mId
+}
+
+// TC-0990:  对抗性 —— 同产品 MEMBER 互看，必须屏蔽 Email/Phone/Remark。
+func TestUserDetail_H1_MemberViewingPeer_MustMaskPII(t *testing.T) {
+	skipPending(t, "H-1",
+		"UserDetail 当前把 Email/Phone/Remark 原样回传同产品 MEMBER；"+
+			"待 filterPIIForCaller + CanViewContact 落地后移除 Skip")
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	productCode := "h1_" + testutil.UniqueId()
+
+	target, mTarget := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
+		Username:           "t_" + testutil.UniqueId(),
+		Password:           testutil.HashPassword("pw"),
+		Nickname:           "target",
+		Avatar:             sql.NullString{},
+		Email:              "[email protected]",
+		Phone:              "13800001111",
+		Remark:             "内部岗位: 副总",
+		DeptId:             1,
+		IsSuperAdmin:       2,
+		MustChangePassword: 2,
+		Status:             1,
+	})
+	caller, mCaller := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
+		Username:           "c_" + testutil.UniqueId(),
+		Password:           testutil.HashPassword("pw"),
+		Nickname:           "caller",
+		IsSuperAdmin:       2,
+		MustChangePassword: 2,
+		Status:             1,
+		DeptId:             1,
+	})
+	t.Cleanup(func() {
+		testutil.CleanTable(ctx, conn, "`sys_product_member`", mTarget, mCaller)
+		testutil.CleanTable(ctx, conn, "`sys_user`", target, caller)
+	})
+
+	callerCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: caller, Username: "caller", MemberType: consts.MemberTypeMember,
+		Status: 1, ProductCode: productCode, DeptId: 1, DeptPath: "/1/", MinPermsLevel: 100,
+	})
+
+	resp, err := NewUserDetailLogic(callerCtx, svcCtx).UserDetail(&types.UserDetailReq{Id: target})
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+
+	assert.NotEqual(t, "[email protected]", resp.Email,
+		"同级 MEMBER 互看时 Email 必须脱敏（例：t***@example.com），禁止原文暴露")
+	assert.NotEqual(t, "13800001111", resp.Phone,
+		"同级 MEMBER 互看时 Phone 必须脱敏（例：138****1111）")
+	assert.Empty(t, resp.Remark,
+		"Remark 常含内部岗位/外部联络人，MEMBER 互看时必须清空")
+}
+
+// TC-0991:  正向——看自己时 Email/Phone/Remark 必须返回原值。
+func TestUserDetail_H1_ViewSelf_KeepsPII(t *testing.T) {
+	skipPending(t, "H-1",
+		"UserDetail 缺少 caller.UserId == target.Id 的 PII 放行短路；fix 落地后取消 Skip")
+	ctx := context.Background()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+	productCode := "h1_self_" + testutil.UniqueId()
+
+	selfId, mSelf := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
+		Username:           "self_" + testutil.UniqueId(),
+		Password:           testutil.HashPassword("pw"),
+		Nickname:           "self",
+		Email:              "[email protected]",
+		Phone:              "13900002222",
+		Remark:             "self-only note",
+		IsSuperAdmin:       2,
+		MustChangePassword: 2,
+		Status:             1,
+		DeptId:             1,
+	})
+	t.Cleanup(func() {
+		testutil.CleanTable(ctx, conn, "`sys_product_member`", mSelf)
+		testutil.CleanTable(ctx, conn, "`sys_user`", selfId)
+	})
+
+	selfCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
+		UserId: selfId, Username: "self", MemberType: consts.MemberTypeMember,
+		Status: 1, ProductCode: productCode, DeptId: 1, DeptPath: "/1/", MinPermsLevel: 100,
+	})
+
+	resp, err := NewUserDetailLogic(selfCtx, svcCtx).UserDetail(&types.UserDetailReq{Id: selfId})
+	require.NoError(t, err)
+
+	assert.Equal(t, "[email protected]", resp.Email, "看自己必须返回 Email 原值")
+	assert.Equal(t, "13900002222", resp.Phone, "看自己必须返回 Phone 原值")
+	assert.Equal(t, "self-only note", resp.Remark, "看自己必须返回 Remark 原值")
+}
+
+// TC-0992:  超管分支 —— SuperAdmin 看任何用户都可以看到 PII 原值（工单兜底）。
+// 该分支本应通过；若 fix 改错把超管也一起脱敏了这条会挂，触发回归。
+func TestUserDetail_H1_SuperAdmin_KeepsPII(t *testing.T) {
+	skipPending(t, "H-1",
+		"当前无脱敏逻辑，超管天然看到原值；fix 落地后本测试用来防回归，确保超管不被误脱敏")
+	ctx := ctxhelper.SuperAdminCtx()
+	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
+	conn := testutil.GetTestSqlConn()
+
+	userId := insertTestUserFull(t, ctx, &userModel.SysUser{
+		Username: "sa_view_" + testutil.UniqueId(), Password: testutil.HashPassword("pw"),
+		Nickname: "n", Email: "[email protected]", Phone: "13700000000", Remark: "nb",
+		IsSuperAdmin: 2, MustChangePassword: 2, Status: 1,
+	})
+	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
+
+	resp, err := NewUserDetailLogic(ctx, svcCtx).UserDetail(&types.UserDetailReq{Id: userId})
+	require.NoError(t, err)
+	assert.Equal(t, "[email protected]", resp.Email)
+	assert.Equal(t, "13700000000", resp.Phone)
+	assert.Equal(t, "nb", resp.Remark)
+}

internal/logic/user/userDetailPIIMask_audit_test.go

@@ -1,176 +0,0 @@
-package user
-
-import (
-	"context"
-	"database/sql"
-	"os"
-	"testing"
-	"time"
-
-	"perms-system-server/internal/consts"
-	"perms-system-server/internal/loaders"
-	"perms-system-server/internal/middleware"
-	memberModel "perms-system-server/internal/model/productmember"
-	userModel "perms-system-server/internal/model/user"
-	"perms-system-server/internal/svc"
-	"perms-system-server/internal/testutil"
-	"perms-system-server/internal/testutil/ctxhelper"
-	"perms-system-server/internal/types"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-// ---------------------------------------------------------------------------
-// 审计 H-1（第 8 轮仍未落地，三轮累计）—— UserDetailLogic / UserListLogic 把
-// Email / Phone / Remark 字段原样返回给任意同产品成员，违反 PIPL 最小必要。
-// 审计 L-3（同样未落地）—— CheckManageAccess 对 caller.DeptId=0 老账号直接 403，
-// 导致历史 MEMBER/DEVELOPER 连"看自己"以外的任何管理动作都做不了（即使目标合法）。
-//
-// 本文件用"契约测试"的方式同时完成两件事：
-//   1) 为正确行为写死断言（assert.Equal(masked, ...) / assert.NoError），
-//      fix 一落地即可把 t.Skip 开关打开，立刻得到回归保护。
-//   2) 默认 t.Skipf 并在 skip message 里留下 `AUDIT_PENDING` 关键词，report 生成
-//      流程据此统计"已知失败测试"，避免把未修缺陷当成"100% 通过"粉饰。
-//
-// 开关：SET AUDIT_RUN_PENDING=1 可强制跑这些测试，CI 会红并指出是哪一条未 fix。
-// ---------------------------------------------------------------------------
-
-const auditPendingEnv = "AUDIT_RUN_PENDING"
-
-func skipPending(t *testing.T, marker, reason string) {
-	t.Helper()
-	if os.Getenv(auditPendingEnv) != "" {
-		return
-	}
-	t.Skipf("AUDIT_PENDING %s (Round 8 fix 未落地) —— %s", marker, reason)
-}
-
-func insertH1Member(t *testing.T, ctx context.Context, svcCtx *svc.ServiceContext, productCode string, u *userModel.SysUser) (int64, int64) {
-	t.Helper()
-	id := insertTestUserFull(t, ctx, u)
-	now := time.Now().Unix()
-	res, err := svcCtx.SysProductMemberModel.Insert(ctx, &memberModel.SysProductMember{
-		ProductCode: productCode, UserId: id, MemberType: consts.MemberTypeMember,
-		Status: 1, CreateTime: now, UpdateTime: now,
-	})
-	require.NoError(t, err)
-	mId, _ := res.LastInsertId()
-	return id, mId
-}
-
-// TC-0990: H-1 对抗性 —— 同产品 MEMBER 互看，必须屏蔽 Email/Phone/Remark。
-func TestUserDetail_H1_MemberViewingPeer_MustMaskPII(t *testing.T) {
-	skipPending(t, "H-1",
-		"UserDetail 当前把 Email/Phone/Remark 原样回传同产品 MEMBER；"+
-			"待 filterPIIForCaller + CanViewContact 落地后移除 Skip")
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	productCode := "h1_" + testutil.UniqueId()
-
-	target, mTarget := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
-		Username:           "t_" + testutil.UniqueId(),
-		Password:           testutil.HashPassword("pw"),
-		Nickname:           "target",
-		Avatar:             sql.NullString{},
-		Email:              "[email protected]",
-		Phone:              "13800001111",
-		Remark:             "内部岗位: 副总",
-		DeptId:             1,
-		IsSuperAdmin:       2,
-		MustChangePassword: 2,
-		Status:             1,
-	})
-	caller, mCaller := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
-		Username:           "c_" + testutil.UniqueId(),
-		Password:           testutil.HashPassword("pw"),
-		Nickname:           "caller",
-		IsSuperAdmin:       2,
-		MustChangePassword: 2,
-		Status:             1,
-		DeptId:             1,
-	})
-	t.Cleanup(func() {
-		testutil.CleanTable(ctx, conn, "`sys_product_member`", mTarget, mCaller)
-		testutil.CleanTable(ctx, conn, "`sys_user`", target, caller)
-	})
-
-	callerCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: caller, Username: "caller", MemberType: consts.MemberTypeMember,
-		Status: 1, ProductCode: productCode, DeptId: 1, DeptPath: "/1/", MinPermsLevel: 100,
-	})
-
-	resp, err := NewUserDetailLogic(callerCtx, svcCtx).UserDetail(&types.UserDetailReq{Id: target})
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-
-	assert.NotEqual(t, "[email protected]", resp.Email,
-		"H-1：同级 MEMBER 互看时 Email 必须脱敏（例：t***@example.com），禁止原文暴露")
-	assert.NotEqual(t, "13800001111", resp.Phone,
-		"H-1：同级 MEMBER 互看时 Phone 必须脱敏（例：138****1111）")
-	assert.Empty(t, resp.Remark,
-		"H-1：Remark 常含内部岗位/外部联络人，MEMBER 互看时必须清空")
-}
-
-// TC-0991: H-1 正向——看自己时 Email/Phone/Remark 必须返回原值。
-func TestUserDetail_H1_ViewSelf_KeepsPII(t *testing.T) {
-	skipPending(t, "H-1",
-		"UserDetail 缺少 caller.UserId == target.Id 的 PII 放行短路；fix 落地后取消 Skip")
-	ctx := context.Background()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-	productCode := "h1_self_" + testutil.UniqueId()
-
-	selfId, mSelf := insertH1Member(t, ctx, svcCtx, productCode, &userModel.SysUser{
-		Username:           "self_" + testutil.UniqueId(),
-		Password:           testutil.HashPassword("pw"),
-		Nickname:           "self",
-		Email:              "[email protected]",
-		Phone:              "13900002222",
-		Remark:             "self-only note",
-		IsSuperAdmin:       2,
-		MustChangePassword: 2,
-		Status:             1,
-		DeptId:             1,
-	})
-	t.Cleanup(func() {
-		testutil.CleanTable(ctx, conn, "`sys_product_member`", mSelf)
-		testutil.CleanTable(ctx, conn, "`sys_user`", selfId)
-	})
-
-	selfCtx := middleware.WithUserDetails(context.Background(), &loaders.UserDetails{
-		UserId: selfId, Username: "self", MemberType: consts.MemberTypeMember,
-		Status: 1, ProductCode: productCode, DeptId: 1, DeptPath: "/1/", MinPermsLevel: 100,
-	})
-
-	resp, err := NewUserDetailLogic(selfCtx, svcCtx).UserDetail(&types.UserDetailReq{Id: selfId})
-	require.NoError(t, err)
-
-	assert.Equal(t, "[email protected]", resp.Email, "H-1：看自己必须返回 Email 原值")
-	assert.Equal(t, "13900002222", resp.Phone, "H-1：看自己必须返回 Phone 原值")
-	assert.Equal(t, "self-only note", resp.Remark, "H-1：看自己必须返回 Remark 原值")
-}
-
-// TC-0992: H-1 超管分支 —— SuperAdmin 看任何用户都可以看到 PII 原值（工单兜底）。
-// 该分支本应通过；若 fix 改错把超管也一起脱敏了这条会挂，触发回归。
-func TestUserDetail_H1_SuperAdmin_KeepsPII(t *testing.T) {
-	skipPending(t, "H-1",
-		"当前无脱敏逻辑，超管天然看到原值；fix 落地后本测试用来防回归，确保超管不被误脱敏")
-	ctx := ctxhelper.SuperAdminCtx()
-	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
-	conn := testutil.GetTestSqlConn()
-
-	userId := insertTestUserFull(t, ctx, &userModel.SysUser{
-		Username: "sa_view_" + testutil.UniqueId(), Password: testutil.HashPassword("pw"),
-		Nickname: "n", Email: "[email protected]", Phone: "13700000000", Remark: "nb",
-		IsSuperAdmin: 2, MustChangePassword: 2, Status: 1,
-	})
-	t.Cleanup(func() { testutil.CleanTable(ctx, conn, "`sys_user`", userId) })
-
-	resp, err := NewUserDetailLogic(ctx, svcCtx).UserDetail(&types.UserDetailReq{Id: userId})
-	require.NoError(t, err)
-	assert.Equal(t, "[email protected]", resp.Email)
-	assert.Equal(t, "13700000000", resp.Phone)
-	assert.Equal(t, "nb", resp.Remark)
-}