DEV-MERGE-LEGACY-BACKEND-2026/internal/identity/service/auth_service_test.go

// AuthService 单测（T4-3 验收）：两步登录 + me + refresh + logout + 惰性升级。
//
// 用 mock 仓储 + 真 Issuer + miniredis 票据（不连真实 DB/Redis），覆盖 Service 编排逻辑。
//
// 断言纪律（响应契约 = code-based）：
//   - Service 返回"自定义文案"的业务错误时用 errors.New(code, customMsg)（如"账号或密码错误"），
//     与 errors 包的 sentinel（如 ErrUnauth="未登录"）**指针不同但 code 相同**；
//     故对这类断言 **code**（response.Fail 只读 Code/Msg，不靠指针）；
//   - Service 返回"真 sentinel"（ErrNotFound/ErrBadParam/ErrTokenExpired 等）时断言 errors.Is。
package service

import (
	"context"
	"crypto/md5"
	"encoding/hex"
	stderrors "errors"
	"testing"

	"yuansiwei/unified-backend/internal/identity/credential"
	"yuansiwei/unified-backend/internal/identity/model"
	"yuansiwei/unified-backend/internal/identity/token"
	apperrors "yuansiwei/unified-backend/internal/infra/errors"
	orgmodel "yuansiwei/unified-backend/internal/org/model"
	"yuansiwei/unified-backend/internal/org/rbac"
)

// codeOf 取业务错误码（*AppError.Code）；非 *AppError 或 nil 时 Fatal（测试 bug）。
// 用于断言"自定义文案错误"的 code（与 sentinel 指针不同但 code 相同）。
func codeOf(t *testing.T, err error) int {
	t.Helper()
	if err == nil {
		t.Fatal("err 为 nil（期望有业务错误）")
		return 0
	}
	var ae *apperrors.AppError
	if !stderrors.As(err, &ae) {
		t.Fatalf("err 非 *AppError：类型 %T，值 %v", err, err)
		return 0
	}
	return ae.Code
}

// ---- Login（两步第一步）----

// TestLogin_Arion2 命中 argon2 密码：LoginStep1 含 loginTicket + user + memberships。
func TestLogin_Arion2(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, err := credential.HashArgon2("correct-password")
	if err != nil {
		t.Fatalf("HashArgon2: %v", err)
	}
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "testuser")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "teacher",
		Status: "active",
	})

	res, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "testuser", "correct-password")
	if err != nil {
		t.Fatalf("Login(argon2 命中): %v", err)
	}
	if res.LoginTicket == "" {
		t.Error("LoginTicket 应非空")
	}
	if res.User == nil || res.User.ID != uid {
		t.Errorf("User.ID = %v，期望 %q", res.User, uid)
	}
	if len(res.Memberships) != 1 {
		t.Fatalf("Memberships 应有 1 条，实际 %d", len(res.Memberships))
	}
	if res.Memberships[0].InstitutionID != 11 {
		t.Errorf("Membership[0].InstitutionID = %d，期望 11", res.Memberships[0].InstitutionID)
	}
}

// TestLogin_WrongPassword 密码错 → errAuthFailed(1001)。
func TestLogin_WrongPassword(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("correct-password")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "testuser")

	_, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "testuser", "wrong-password")
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("密码错应 ErrUnauth(1001)，实际 %v", err)
	}
}

// TestLogin_UnknownIdentity 账号不存在 → errAuthFailed(1001)，不泄漏"账号不存在"（防枚举）。
func TestLogin_UnknownIdentity(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	_, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "ghost-user", "any-password")
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("账号不存在应 ErrUnauth(1001)（防枚举统一文案），实际 %v", err)
	}
}

// TestLogin_DisabledUser 账号 disabled → errAuthFailed(1001)。
func TestLogin_DisabledUser(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "disabled")
	// 改 status 为 disabled（addUser 默认 active，这里手动改）
	fx.users.byUID[uid].Status = model.UserStatusDisabled

	_, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "disabled", "pw")
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("disabled 用户应 ErrUnauth(1001)，实际 %v", err)
	}
}

// TestLogin_NoHash 无密码哈希 → errAuthFailed(1001)。
func TestLogin_NoHash(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	// hash="" 表示无哈希（addUser hashVersion="" → HashVersion=nil）
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, "", "", "", model.IdentityTypeUsername, "nohash")

	_, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "nohash", "pw")
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("无密码哈希应 ErrUnauth(1001)，实际 %v", err)
	}
}

// TestLogin_Md5Salt_LazyUpgrade md5_salt 用户命中 → 惰性升级到 argon2 + 发 ticket。
func TestLogin_Md5Salt_LazyUpgrade(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	// 造 md5("password"+"salt") 的 hex 串
	raw := md5.Sum([]byte("password" + "salt"))
	md5Hash := hex.EncodeToString(raw[:])

	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionMd5Salt, md5Hash, "salt", model.IdentityTypeUsername, "legacy")

	res, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "legacy", "password")
	if err != nil {
		t.Fatalf("Login(md5_salt 命中): %v", err)
	}
	if res.LoginTicket == "" {
		t.Error("LazyUpgrade 后应发 loginTicket")
	}

	// 断言惰性升级已写回：hashVersion 应为 argon2，salt 应为 nil
	u := fx.users.byUID[uid]
	if u.HashVersion == nil || *u.HashVersion != model.HashVersionArgon2 {
		t.Errorf("升级后 hashVersion = %v，期望 argon2", u.HashVersion)
	}
	if u.PasswordSalt != nil {
		t.Errorf("升级后 salt 应置 nil，实际 %q", *u.PasswordSalt)
	}
	if u.PasswordHash == nil || *u.PasswordHash == md5Hash {
		t.Error("升级后 password_hash 应已替换为 argon2 PHC 串（非原 md5 值）")
	}
}

// TestLogin_Phone_BadFormat phone 身份 identifier 非 11 位 → ErrBadParam(2001)。
func TestLogin_Phone_BadFormat(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	_, err := fx.svc.Login(ctx, model.IdentityTypePhone, "12345", "pw")
	if !stderrors.Is(err, apperrors.ErrBadParam) {
		t.Fatalf("phone 非 11 位应 ErrBadParam(2001)，实际 %v", err)
	}
}

// ---- Issue（两步第二步）----

// TestIssue_Happy 消费有效 ticket + 合法作用域 → TokenPair（真 access 可验签）。
func TestIssue_Happy(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "testuser")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "teacher", Status: "active",
	})

	// 第一步：Login 拿 ticket
	step1, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "testuser", "pw")
	if err != nil {
		t.Fatalf("Login: %v", err)
	}

	// 第二步：Issue 签 token
	pair, err := fx.svc.Issue(ctx, step1.LoginTicket, 11, 3)
	if err != nil {
		t.Fatalf("Issue: %v", err)
	}
	if pair.AccessToken == "" {
		t.Error("AccessToken 应非空")
	}
	if pair.RefreshToken == "" {
		t.Error("RefreshToken 应非空")
	}
	if pair.InstitutionID != 11 {
		t.Errorf("InstitutionID = %d，期望 11", pair.InstitutionID)
	}

	// 验证 access token 真可验签（RS256）
	claims, verr := token.Verify(ctx, fx.pubKeys, nil, "https://unified.test", pair.AccessToken)
	if verr != nil {
		t.Fatalf("token.Verify(新签 access): %v", verr)
	}
	if claims.Sub != uid {
		t.Errorf("claims.Sub = %q，期望 %q", claims.Sub, uid)
	}
	if claims.InstitutionID != 11 {
		t.Errorf("claims.InstitutionID = %d，期望 11", claims.InstitutionID)
	}
}

// TestIssue_InvalidTicket 无效/不存在的 ticket → ErrUnauth(1001)。
func TestIssue_InvalidTicket(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	_, err := fx.svc.Issue(ctx, "invalid-ticket-hex", 11, 3)
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("无效 ticket 应 ErrUnauth(1001)，实际 %v", err)
	}
}

// TestIssue_ReplayTicket ticket 已消费（重放）→ ErrUnauth(1001)。
func TestIssue_ReplayTicket(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "replay")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 22, CampusID: 5, Role: "academic", Status: "active",
	})

	step1, _ := fx.svc.Login(ctx, model.IdentityTypeUsername, "replay", "pw")
	// 第一次 Issue（成功）
	if _, err := fx.svc.Issue(ctx, step1.LoginTicket, 22, 5); err != nil {
		t.Fatalf("第一次 Issue: %v", err)
	}
	// 第二次 Issue（重放 → 票据已 GETDEL 删除 → 拒绝）
	_, err := fx.svc.Issue(ctx, step1.LoginTicket, 22, 5)
	if codeOf(t, err) != apperrors.CodeUnauth {
		t.Fatalf("重放 ticket 应 ErrUnauth(1001)，实际 %v", err)
	}
}

// TestIssue_ScopeNotBelong 作用域不属于该用户 → ErrForbidden(1003)。
func TestIssue_ScopeNotBelong(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "scopetest")
	// 用户只有 instA/campus1 的 membership
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 1, Role: "teacher", Status: "active",
	})

	step1, _ := fx.svc.Login(ctx, model.IdentityTypeUsername, "scopetest", "pw")
	// 试图签 instB/campus99（不属于该用户）
	_, err := fx.svc.Issue(ctx, step1.LoginTicket, 99, 99)
	if codeOf(t, err) != apperrors.CodeForbidden {
		t.Fatalf("作用域越权应 ErrForbidden(1003)，实际 %v", err)
	}
}

// ---- Me ----

// TestMe_Happy 登录态自查：凭 claims 回读 user + memberships。
func TestMe_Happy(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "meuser")
	fx.memberships.add(uid,
		orgmodel.Membership{MembershipID: 1, CanonicalUserID: uid, InstitutionID: 11, CampusID: 3, Role: "teacher", Status: "active"},
		orgmodel.Membership{MembershipID: 2, CanonicalUserID: uid, InstitutionID: 11, CampusID: 5, Role: "finance", Status: "active"},
	)

	claims := token.Claims{Sub: uid, Roles: []string{"teacher"}, InstitutionID: 11, CampusID: 3}
	me, err := fx.svc.Me(ctx, claims)
	if err != nil {
		t.Fatalf("Me: %v", err)
	}
	if me.UserView == nil || me.UserView.ID != uid {
		t.Errorf("Me.UserView.ID = %v，期望 %q", me.UserView, uid)
	}
	if len(me.Memberships) != 2 {
		t.Errorf("Me.Memberships 应有 2 条，实际 %d", len(me.Memberships))
	}
}

// TestMe_UnknownSub claims.Sub 对应用户不存在 → ErrNotFound(3001)。
func TestMe_UnknownSub(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	claims := token.Claims{Sub: "00000000000000000000000000"}
	_, err := fx.svc.Me(ctx, claims)
	if !stderrors.Is(err, apperrors.ErrNotFound) {
		t.Fatalf("Me(未知 sub) 应 ErrNotFound(3001)，实际 %v", err)
	}
}

// ---- T6.5-d：MenuProvider 注入后 Issue/Me 下发 menuTree + permissions ----

// fakeMenuProvider MenuProvider 测试假实现（按角色返回固定菜单树/权限码集；不连 DB）。
type fakeMenuProvider struct {
	codes map[string][]string
	tree  map[string][]rbac.MenuNode
}

func (f *fakeMenuProvider) Permissions(_ context.Context, role string) ([]string, error) {
	if c, ok := f.codes[role]; ok {
		return c, nil
	}
	return []string{}, nil
}
func (f *fakeMenuProvider) MenuTree(_ context.Context, role string) ([]rbac.MenuNode, error) {
	if tr, ok := f.tree[role]; ok {
		return tr, nil
	}
	return []rbac.MenuNode{}, nil
}

// TestIssue_WithMenuProvider 注入 MenuProvider 后 Issue 出参含 menuTree + permissions（按角色）。
func TestIssue_WithMenuProvider(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "menuser")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "academic", Status: "active",
	})

	// 注入假解析器：academic 角色 2 权限码 + 1 菜单节点
	fx.svc.menuProvider = &fakeMenuProvider{
		codes: map[string][]string{"academic": {"org.institution.list", "org.campus.list"}},
		tree: map[string][]rbac.MenuNode{
			"academic": {{Code: "org.institution.list", Label: "机构管理", Path: strPtr("/org/institutions")}},
		},
	}

	step1, err := fx.svc.Login(ctx, model.IdentityTypeUsername, "menuser", "pw")
	if err != nil {
		t.Fatalf("Login: %v", err)
	}
	pair, err := fx.svc.Issue(ctx, step1.LoginTicket, 11, 3)
	if err != nil {
		t.Fatalf("Issue: %v", err)
	}
	if len(pair.Permissions) != 2 || pair.Permissions[0] != "org.institution.list" {
		t.Fatalf("Issue.Permissions=%v（期望 2 个 org 权限码）", pair.Permissions)
	}
	if len(pair.MenuTree) != 1 || pair.MenuTree[0].Code != "org.institution.list" {
		t.Fatalf("Issue.MenuTree=%+v（期望 1 个机构管理菜单）", pair.MenuTree)
	}
}

// TestMe_WithMenuProvider 注入 MenuProvider 后 Me 出参含 menuTree + permissions（菜单刷新恢复）。
func TestMe_WithMenuProvider(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "memuuser")
	fx.svc.menuProvider = &fakeMenuProvider{
		codes: map[string][]string{"super_admin": {"org.institution.list", "org.campus.list", "sys.menu"}},
		tree: map[string][]rbac.MenuNode{
			"super_admin": {
				{Code: "org.institution.list", Label: "机构管理"},
				{Code: "org.campus.list", Label: "校区管理"},
			},
		},
	}

	claims := token.Claims{Sub: uid, Roles: []string{"super_admin"}, InstitutionID: 0, CampusID: 0}
	me, err := fx.svc.Me(ctx, claims)
	if err != nil {
		t.Fatalf("Me: %v", err)
	}
	if len(me.Permissions) != 3 {
		t.Fatalf("Me.Permissions=%v（超管期望 3 个权限码）", me.Permissions)
	}
	if len(me.MenuTree) != 2 {
		t.Fatalf("Me.MenuTree=%+v（超管期望 2 个顶级菜单）", me.MenuTree)
	}
}

// TestIssue_NilMenuProvider MenuProvider 未注入（默认 fixture）：menuTree/permissions 非 nil 空集（不阻断）。
func TestIssue_NilMenuProvider(t *testing.T) {
	fx := newFixture(t) // 不注入 menuProvider
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "nilmenu")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "teacher", Status: "active",
	})
	step1, _ := fx.svc.Login(ctx, model.IdentityTypeUsername, "nilmenu", "pw")
	pair, err := fx.svc.Issue(ctx, step1.LoginTicket, 11, 3)
	if err != nil {
		t.Fatalf("Issue: %v", err)
	}
	if pair.MenuTree == nil || pair.Permissions == nil {
		t.Fatalf("MenuTree/Permissions 必须非 nil（实际 %v / %v），空集应是 [] 而非 null", pair.MenuTree, pair.Permissions)
	}
	if len(pair.MenuTree) != 0 || len(pair.Permissions) != 0 {
		t.Fatalf("nil MenuProvider 时 menuTree/permissions 应空集（实际 %d / %d）", len(pair.MenuTree), len(pair.Permissions))
	}
}

// strPtr 字符串指针辅助（测试用）。
func strPtr(s string) *string { return &s }

// ---- Refresh ----

// TestRefresh_Happy 用有效 refresh 轮换 → 新 TokenPair。
func TestRefresh_Happy(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "refreshuser")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "teacher", Status: "active",
	})

	step1, _ := fx.svc.Login(ctx, model.IdentityTypeUsername, "refreshuser", "pw")
	pair1, err := fx.svc.Issue(ctx, step1.LoginTicket, 11, 3)
	if err != nil {
		t.Fatalf("Issue: %v", err)
	}

	// 用 pair1.RefreshToken 轮换
	pair2, err := fx.svc.Refresh(ctx, pair1.RefreshToken)
	if err != nil {
		t.Fatalf("Refresh: %v", err)
	}
	if pair2.AccessToken == "" {
		t.Error("Refresh 后 AccessToken 应非空")
	}
	if pair2.AccessToken == pair1.AccessToken {
		t.Error("Refresh 后 access 应换新（jti 不同）")
	}
	if pair2.User == nil || pair2.User.ID != uid {
		t.Errorf("Refresh 后 User.ID = %v，期望 %q", pair2.User, uid)
	}

	// 旧 refresh 应已失效（轮换后旧 jti 已删）
	_, err = fx.svc.Refresh(ctx, pair1.RefreshToken)
	if !stderrors.Is(err, apperrors.ErrTokenExpired) {
		t.Fatalf("旧 refresh 重放应 ErrTokenExpired(1002)，实际 %v", err)
	}
}

// TestRefresh_InvalidRefresh 无效 refresh → ErrTokenExpired(1002)。
func TestRefresh_InvalidRefresh(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	_, err := fx.svc.Refresh(ctx, "not-a-valid-refresh-token")
	if !stderrors.Is(err, apperrors.ErrTokenExpired) {
		t.Fatalf("无效 refresh 应 ErrTokenExpired(1002)，实际 %v", err)
	}
}

// ---- Logout ----

// TestLogout_Happy 登出：删 refresh + 吊销 access（幂等，返回 nil）。
func TestLogout_Happy(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	argon2Hash, _ := credential.HashArgon2("pw")
	uid := "01GAQF0Z6C1V9Y3E5H7K2M8B4T"
	fx.addUser(uid, model.HashVersionArgon2, argon2Hash, "", model.IdentityTypeUsername, "logoutuser")
	fx.memberships.add(uid, orgmodel.Membership{
		MembershipID: 1, CanonicalUserID: uid,
		InstitutionID: 11, CampusID: 3, Role: "teacher", Status: "active",
	})

	step1, _ := fx.svc.Login(ctx, model.IdentityTypeUsername, "logoutuser", "pw")
	pair, _ := fx.svc.Issue(ctx, step1.LoginTicket, 11, 3)

	// 登出（传 refresh + 一个 jti + 剩余 TTL）
	err := fx.svc.Logout(ctx, pair.RefreshToken, "some-jti", 30*60*1e9) // 30min = 1.8e9 ns
	if err != nil {
		t.Fatalf("Logout: %v", err)
	}

	// 登出后旧 refresh 应失效（已删白名单）
	_, err = fx.svc.Refresh(ctx, pair.RefreshToken)
	if !stderrors.Is(err, apperrors.ErrTokenExpired) {
		t.Errorf("Logout 后旧 refresh 应 ErrTokenExpired(1002)，实际 %v", err)
	}
}

// TestLogout_EmptyArgs 空参登出（幂等，不报错）。
func TestLogout_EmptyArgs(t *testing.T) {
	fx := newFixture(t)
	ctx := context.Background()

	err := fx.svc.Logout(ctx, "", "", 0)
	if err != nil {
		t.Fatalf("Logout(空参) 应 nil（幂等），实际 %v", err)
	}
}