perms-system-server/internal/logic/auth/logoutRateLimit_audit_test.go

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 伪装")
}