forked from baron/baron-sso
204 lines
6.7 KiB
Go
204 lines
6.7 KiB
Go
package bootstrap
|
|
|
|
import (
|
|
"baron-sso-backend/internal/domain"
|
|
"baron-sso-backend/internal/testsupport"
|
|
"context"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/testcontainers/testcontainers-go"
|
|
postgres_module "github.com/testcontainers/testcontainers-go/modules/postgres"
|
|
"github.com/testcontainers/testcontainers-go/wait"
|
|
gorm_postgres "gorm.io/driver/postgres"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func TestSanitizeLegacyUserMetadataRemovesClassificationFlags(t *testing.T) {
|
|
db := openBootstrapPostgresTestDB(t)
|
|
if err := db.AutoMigrate(&domain.User{}); err != nil {
|
|
t.Fatalf("failed to migrate users table: %v", err)
|
|
}
|
|
|
|
user := domain.User{
|
|
ID: "10000000-0000-0000-0000-000000000001",
|
|
Email: "legacy@example.com",
|
|
Name: "Legacy User",
|
|
Role: domain.RoleUser,
|
|
Status: domain.UserStatusActive,
|
|
Metadata: domain.JSONMap{
|
|
"hanmacFamily": true,
|
|
"userType": "hanmac",
|
|
"employeeId": "E001",
|
|
"nested": map[string]any{
|
|
"userType": "must stay nested",
|
|
},
|
|
},
|
|
}
|
|
if err := db.Create(&user).Error; err != nil {
|
|
t.Fatalf("failed to create user: %v", err)
|
|
}
|
|
|
|
if err := SanitizeLegacyUserMetadata(db); err != nil {
|
|
t.Fatalf("SanitizeLegacyUserMetadata returned error: %v", err)
|
|
}
|
|
if err := SanitizeLegacyUserMetadata(db); err != nil {
|
|
t.Fatalf("SanitizeLegacyUserMetadata must be idempotent: %v", err)
|
|
}
|
|
|
|
var got domain.User
|
|
if err := db.First(&got, "id = ?", user.ID).Error; err != nil {
|
|
t.Fatalf("failed to load sanitized user: %v", err)
|
|
}
|
|
if _, ok := got.Metadata["hanmacFamily"]; ok {
|
|
t.Fatalf("hanmacFamily must be removed from metadata: %#v", got.Metadata)
|
|
}
|
|
if _, ok := got.Metadata["userType"]; ok {
|
|
t.Fatalf("userType must be removed from metadata: %#v", got.Metadata)
|
|
}
|
|
if got.Metadata["employeeId"] != "E001" {
|
|
t.Fatalf("employeeId = %#v, want E001", got.Metadata["employeeId"])
|
|
}
|
|
nested, ok := got.Metadata["nested"].(map[string]any)
|
|
if !ok || nested["userType"] != "must stay nested" {
|
|
t.Fatalf("nested metadata must be preserved: %#v", got.Metadata["nested"])
|
|
}
|
|
}
|
|
|
|
func TestCanonicalizeLegacyUserStatuses(t *testing.T) {
|
|
db := openBootstrapPostgresTestDB(t)
|
|
if err := db.AutoMigrate(&domain.User{}); err != nil {
|
|
t.Fatalf("failed to migrate users table: %v", err)
|
|
}
|
|
|
|
users := []domain.User{
|
|
{ID: "11000000-0000-0000-0000-000000000001", Email: "inactive@example.com", Name: "Inactive", Role: domain.RoleUser, Status: "inactive"},
|
|
{ID: "11000000-0000-0000-0000-000000000002", Email: "leave@example.com", Name: "Leave", Role: domain.RoleUser, Status: "leave_of_absence"},
|
|
{ID: "11000000-0000-0000-0000-000000000003", Email: "baron-only@example.com", Name: "Baron Only", Role: domain.RoleUser, Status: "baron_only"},
|
|
{ID: "11000000-0000-0000-0000-000000000004", Email: "active@example.com", Name: "Active", Role: domain.RoleUser, Status: domain.UserStatusActive},
|
|
}
|
|
if err := db.Create(&users).Error; err != nil {
|
|
t.Fatalf("failed to create users: %v", err)
|
|
}
|
|
|
|
if err := CanonicalizeLegacyUserStatuses(db); err != nil {
|
|
t.Fatalf("CanonicalizeLegacyUserStatuses returned error: %v", err)
|
|
}
|
|
if err := CanonicalizeLegacyUserStatuses(db); err != nil {
|
|
t.Fatalf("CanonicalizeLegacyUserStatuses must be idempotent: %v", err)
|
|
}
|
|
|
|
got := map[string]string{}
|
|
var loaded []domain.User
|
|
if err := db.Find(&loaded).Error; err != nil {
|
|
t.Fatalf("failed to load users: %v", err)
|
|
}
|
|
for _, user := range loaded {
|
|
got[user.Email] = user.Status
|
|
}
|
|
|
|
if got["inactive@example.com"] != domain.UserStatusPreboarding {
|
|
t.Fatalf("inactive status = %q, want %q", got["inactive@example.com"], domain.UserStatusPreboarding)
|
|
}
|
|
if got["leave@example.com"] != domain.UserStatusTemporaryLeave {
|
|
t.Fatalf("leave status = %q, want %q", got["leave@example.com"], domain.UserStatusTemporaryLeave)
|
|
}
|
|
if got["baron-only@example.com"] != domain.UserStatusBaronGuest {
|
|
t.Fatalf("baron_only status = %q, want %q", got["baron-only@example.com"], domain.UserStatusBaronGuest)
|
|
}
|
|
if got["active@example.com"] != domain.UserStatusActive {
|
|
t.Fatalf("active status = %q, want %q", got["active@example.com"], domain.UserStatusActive)
|
|
}
|
|
}
|
|
|
|
func TestRunSanitizesLegacyUserMetadata(t *testing.T) {
|
|
db := openBootstrapPostgresTestDB(t)
|
|
if err := db.AutoMigrate(&domain.User{}); err != nil {
|
|
t.Fatalf("failed to migrate users table: %v", err)
|
|
}
|
|
|
|
user := domain.User{
|
|
ID: "20000000-0000-0000-0000-000000000001",
|
|
Email: "run-legacy@example.com",
|
|
Name: "Run Legacy User",
|
|
Role: domain.RoleUser,
|
|
Status: domain.UserStatusActive,
|
|
Metadata: domain.JSONMap{
|
|
"hanmacFamily": true,
|
|
"userType": "external",
|
|
"employeeId": "E002",
|
|
},
|
|
}
|
|
if err := db.Create(&user).Error; err != nil {
|
|
t.Fatalf("failed to create user: %v", err)
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "seed-tenant.csv")
|
|
csv := "id,name,type,parent_tenant_slug,slug,memo,email_domain\n" +
|
|
"30000000-0000-0000-0000-000000000001,Seed Root,COMPANY_GROUP,,seed-root,seed root,\n"
|
|
if err := os.WriteFile(path, []byte(csv), 0o600); err != nil {
|
|
t.Fatalf("failed to write seed csv: %v", err)
|
|
}
|
|
t.Setenv(seedTenantCSVPathEnv, path)
|
|
|
|
if err := Run(db); err != nil {
|
|
t.Fatalf("Run returned error: %v", err)
|
|
}
|
|
|
|
var got domain.User
|
|
if err := db.First(&got, "id = ?", user.ID).Error; err != nil {
|
|
t.Fatalf("failed to load sanitized user: %v", err)
|
|
}
|
|
if _, ok := got.Metadata["hanmacFamily"]; ok {
|
|
t.Fatalf("Run must remove hanmacFamily from metadata: %#v", got.Metadata)
|
|
}
|
|
if _, ok := got.Metadata["userType"]; ok {
|
|
t.Fatalf("Run must remove userType from metadata: %#v", got.Metadata)
|
|
}
|
|
if got.Metadata["employeeId"] != "E002" {
|
|
t.Fatalf("employeeId = %#v, want E002", got.Metadata["employeeId"])
|
|
}
|
|
}
|
|
|
|
func openBootstrapPostgresTestDB(t *testing.T) *gorm.DB {
|
|
t.Helper()
|
|
if !testsupport.DockerAvailable() {
|
|
t.Skip("Docker provider is unavailable in this environment")
|
|
}
|
|
|
|
ctx := context.Background()
|
|
postgresContainer, err := postgres_module.Run(ctx,
|
|
"postgres:16-alpine",
|
|
postgres_module.WithDatabase("testdb"),
|
|
postgres_module.WithUsername("user"),
|
|
postgres_module.WithPassword("password"),
|
|
testcontainers.WithWaitStrategy(
|
|
wait.ForLog("database system is ready to accept connections").
|
|
WithOccurrence(2).
|
|
WithStartupTimeout(30*time.Second),
|
|
),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("failed to start postgres container: %v", err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := postgresContainer.Terminate(ctx); err != nil {
|
|
log.Printf("failed to terminate postgres container: %v", err)
|
|
}
|
|
})
|
|
|
|
connStr, err := postgresContainer.ConnectionString(ctx, "sslmode=disable")
|
|
if err != nil {
|
|
t.Fatalf("failed to get postgres connection string: %v", err)
|
|
}
|
|
db, err := gorm.Open(gorm_postgres.Open(connStr), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatalf("failed to open postgres connection: %v", err)
|
|
}
|
|
return db
|
|
}
|