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

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