170 lines
6.0 KiB
Go
170 lines
6.0 KiB
Go
package auth
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"hfb_sys/backend/internal/database"
|
|
"hfb_sys/backend/internal/model"
|
|
"hfb_sys/backend/internal/sitecode"
|
|
"hfb_sys/backend/internal/tenancy"
|
|
)
|
|
|
|
func authTenantContext(tenantID uint64) context.Context {
|
|
return tenancy.WithScope(context.Background(), tenancy.Scope{TenantID: tenantID})
|
|
}
|
|
|
|
func TestUserRepositoryScopesSamePhoneByTenant(t *testing.T) {
|
|
db := database.NewTestDB()
|
|
repo := NewUserRepository(db)
|
|
const phone = "13600000001"
|
|
|
|
dachuiCtx := authTenantContext(101)
|
|
jieyouCtx := authTenantContext(202)
|
|
dachuiUser, err := repo.RegisterWithPassword(dachuiCtx, phone, "hash-dachui", "")
|
|
if err != nil {
|
|
t.Fatalf("register dachui user: %v", err)
|
|
}
|
|
jieyouUser, err := repo.RegisterWithPassword(jieyouCtx, phone, "hash-jieyou", "")
|
|
if err != nil {
|
|
t.Fatalf("register jieyou user: %v", err)
|
|
}
|
|
if dachuiUser.ID == jieyouUser.ID || dachuiUser.TenantID != 101 || jieyouUser.TenantID != 202 {
|
|
t.Fatalf("tenant users = %+v / %+v", dachuiUser, jieyouUser)
|
|
}
|
|
|
|
foundDachui, err := repo.FindByPhone(dachuiCtx, phone)
|
|
if err != nil || foundDachui.PasswordHash != "hash-dachui" {
|
|
t.Fatalf("find dachui user = %+v, err=%v", foundDachui, err)
|
|
}
|
|
foundJieyou, err := repo.FindByPhone(jieyouCtx, phone)
|
|
if err != nil || foundJieyou.PasswordHash != "hash-jieyou" {
|
|
t.Fatalf("find jieyou user = %+v, err=%v", foundJieyou, err)
|
|
}
|
|
if _, err := repo.FindByID(dachuiCtx, jieyouUser.ID); err == nil {
|
|
t.Fatal("dachui context must not load jieyou user")
|
|
}
|
|
}
|
|
|
|
func TestTenantTokenClaimsAndRedisKeysAreIsolated(t *testing.T) {
|
|
manager := NewJWTManager("tenant-scope-test-secret")
|
|
pair, err := manager.GenerateTenantPairWithVersion(7, "13600000007", "user", 1, 101)
|
|
if err != nil {
|
|
t.Fatalf("generate tenant token: %v", err)
|
|
}
|
|
claims, err := manager.ParseSubject(pair.AccessToken, "access", "user")
|
|
if err != nil {
|
|
t.Fatalf("parse tenant token: %v", err)
|
|
}
|
|
if claims.TenantID != 101 || claims.Scope != "tenant" {
|
|
t.Fatalf("tenant claims = %+v", claims)
|
|
}
|
|
|
|
phone := "13600000007"
|
|
if codeKey(101, phone) == codeKey(202, phone) {
|
|
t.Fatal("sms code keys must differ by tenant")
|
|
}
|
|
if loginFailureRedisKey(101, phone, "127.0.0.1") == loginFailureRedisKey(202, phone, "127.0.0.1") {
|
|
t.Fatal("login failure keys must differ by tenant")
|
|
}
|
|
}
|
|
|
|
func TestTenantUsersRemainSeparateRows(t *testing.T) {
|
|
db := database.NewTestDB()
|
|
users := []model.User{
|
|
{TenantID: 101, Phone: "13600000002", Status: "active"},
|
|
{TenantID: 202, Phone: "13600000002", Status: "active"},
|
|
}
|
|
if err := db.Create(&users).Error; err != nil {
|
|
t.Fatalf("create same-phone tenant users: %v", err)
|
|
}
|
|
var count int64
|
|
if err := db.Model(&model.User{}).Where("phone = ?", "13600000002").Count(&count).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if count != 2 {
|
|
t.Fatalf("same phone user count = %d, want 2", count)
|
|
}
|
|
}
|
|
|
|
func TestLegacyDistributionUserCannotEnterTenantSite(t *testing.T) {
|
|
db := database.NewTestDB()
|
|
site := model.DistributionSite{
|
|
SiteCode: "legacy_auth_scope", SiteName: "历史分销测试站",
|
|
Domain: "legacy-auth-scope.example.com", Status: "active",
|
|
}
|
|
if err := db.Create(&site).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
legacy := model.User{
|
|
TenantID: 101, Phone: "13600000009", Status: "active",
|
|
DistributionSiteID: site.ID, TokenVersion: 1,
|
|
}
|
|
if err := db.Create(&legacy).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
repo := NewUserRepository(db)
|
|
ctx := authTenantContext(101)
|
|
|
|
if _, err := repo.FindByID(ctx, legacy.ID); err == nil {
|
|
t.Fatal("tenant site must not load legacy distribution user")
|
|
}
|
|
if _, err := repo.FindByPhone(ctx, legacy.Phone); !IsNotFound(err) {
|
|
t.Fatalf("tenant phone login should not resolve legacy user, got %v", err)
|
|
}
|
|
mainUser, err := repo.FindOrCreateByPhone(ctx, legacy.Phone, "")
|
|
if err != nil {
|
|
t.Fatalf("create tenant user with legacy phone: %v", err)
|
|
}
|
|
if mainUser.ID == legacy.ID || mainUser.TenantID != legacy.TenantID || mainUser.DistributionSiteID != 0 {
|
|
t.Fatalf("main user = %+v, legacy = %+v", mainUser, legacy)
|
|
}
|
|
if _, err := repo.FindByPhone(context.Background(), legacy.Phone, site.SiteCode); err != nil {
|
|
t.Fatalf("legacy distribution domain login failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLegacyDistributionUserSessionIsScopedToBoundSite(t *testing.T) {
|
|
db := database.NewTestDB()
|
|
sites := []model.DistributionSite{
|
|
{SiteCode: "legacy_session_a", SiteName: "历史分销 A", Domain: "legacy-session-a.example.com", Status: "active"},
|
|
{SiteCode: "legacy_session_b", SiteName: "历史分销 B", Domain: "legacy-session-b.example.com", Status: "active"},
|
|
}
|
|
if err := db.Create(&sites).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
legacy := model.User{
|
|
TenantID: 101, Phone: "13600000019", Status: "active",
|
|
DistributionSiteID: sites[0].ID, TokenVersion: 1,
|
|
}
|
|
if err := db.Create(&legacy).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
repo := NewUserRepository(db)
|
|
ctxA := sitecode.WithBoundSiteCode(context.Background(), sites[0].SiteCode)
|
|
ctxB := sitecode.WithBoundSiteCode(context.Background(), sites[1].SiteCode)
|
|
if _, err := repo.FindActiveForToken(ctxA, legacy.ID, legacy.TokenVersion); err != nil {
|
|
t.Fatalf("bound own site token validation failed: %v", err)
|
|
}
|
|
if _, err := repo.FindActiveForToken(ctxB, legacy.ID, legacy.TokenVersion); !IsNotFound(err) {
|
|
t.Fatalf("cross-site token validation error = %v, want not found", err)
|
|
}
|
|
if _, err := repo.FindActiveForToken(authTenantContext(legacy.TenantID), legacy.ID, legacy.TokenVersion); !IsNotFound(err) {
|
|
t.Fatalf("tenant-site token validation error = %v, want not found", err)
|
|
}
|
|
|
|
manager := NewJWTManager("legacy-distribution-session-test-secret")
|
|
pair, err := manager.GenerateTenantPairWithVersion(legacy.ID, legacy.Phone, "user", legacy.TokenVersion, legacy.TenantID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
service := NewService(repo, nil, manager, nil, nil)
|
|
if _, err := service.RefreshToken(ctxA, pair.RefreshToken); err != nil {
|
|
t.Fatalf("bound own site refresh failed: %v", err)
|
|
}
|
|
if _, err := service.RefreshToken(ctxB, pair.RefreshToken); err == nil {
|
|
t.Fatal("cross-site refresh must fail")
|
|
}
|
|
}
|