perms-system-server/internal/loaders/userDetailsLoader_contract_audit_test.go

package loaders

import (
	"context"
	"database/sql"
	"encoding/json"
	"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,
	})
	t.Cleanup(func() {
		loader.Del(ctx, userId, productCode)
		cleanTable(ctx, conn, "`sys_user`", userId)
	})

	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-1 —— dept 子步骤失败时 Load 不写 5 分钟正缓存。
//
// 通过构造"用户 DeptId 指向一个不存在的 deptId"来模拟子加载错误：SysDeptModel.FindOne 会返回
// ErrNotFound，在新契约下 loadDept 返回 error，Load 标记 !loadOk 进而不写缓存。
// （审计里 DeptId=0 是合法值不触发加载；这里取一个不存在的正数让 FindOne 确实失败。）
func TestUserDetailsLoader_Load_M1_PartialLoadDoesNotWriteCache(t *testing.T) {
	ctx := context.Background()
	loader := newTestLoader()
	conn := testConn()
	m := testModels()
	ts := now()
	uid := uniqueId()
	productCode := "pc_m1_" + uid

	// 用一个极大的 DeptId 指向不存在的部门。
	phantomDeptId := int64(999_000_000_000)
	userId := insertUser(ctx, t, m, &userModel.SysUser{
		Username: uid, Password: hashPwd("pw"), Nickname: "m1",
		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: "m1_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, "主体加载成功，Username 应被填充")

	// 断言：Redis 里没有 5 分钟正缓存 —— value 为空，或虽非空但至少不是 Username != "" 的 JSON。
	// 规范实现下应该直接没写缓存。
	val, err := loader.rds.GetCtx(ctx, loader.cacheKey(userId, productCode))
	require.NoError(t, err)
	if val != "" {
		// 如果因为某种原因仍然写了哨兵/空 ud，也不能写入"包含 Username 的正缓存"；
		// 若走到正缓存分支，说明 partial-load 被误当成 loadOk 写缓存了（M-1 回归）。
		assert.NotContains(t, val, "\"username\":\""+uid+"\"",
			"M-1/H-1/L-3：partial-load 不得把半残 UD 写进 5 分钟正缓存")
	}
}

// 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)
	}
}