Skip to content

Modern Docker Management, Designed for Everyone

17.5 KB
Raw Blame
package user_test

import (
	"context"
	"testing"
	"time"

	"github.com/getarcaneapp/arcane/types/v2/user"
	"github.com/libtnb/sqlite"
	"github.com/stretchr/testify/require"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/role"
	"github.com/getarcaneapp/arcane/backend/v2/internal/session"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	userdomain "github.com/getarcaneapp/arcane/backend/v2/internal/user"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
)

func setupAuthServiceTestDBInternal(t *testing.T) *database.DB {
	t.Helper()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(
		&settings.SettingVariable{},
		&userdomain.User{},
		&session.UserSession{},
		&role.Role{},
		&role.UserRoleAssignment{},
		&role.ApiKeyPermission{},
		&role.OidcRoleMapping{},
	))
	// Production migrations define username as UNIQUE. AutoMigrate cannot infer
	// that SQL-only constraint from the model, so mirror it in the test schema.
	require.NoError(t, db.Exec("CREATE UNIQUE INDEX idx_users_username_unique ON users(username)").Error)
	// environments and api_keys live in packages that import this one; the
	// in-package tests only need the tables to exist.
	require.NoError(
		t,
		db.Exec("CREATE TABLE IF NOT EXISTS environments (id text PRIMARY KEY, created_at datetime, updated_at dateti"+
			"me, name text, api_url text, status text, enabled numeric, is_edge numeric, hidden numeric, last_see"+
			"n datetime, last_edge_transport text, access_token text, api_key_id text, parent_environment_id text"+
			", swarm_node_id text)").Error,
	)
	require.NoError(
		t,
		db.Exec("CREATE TABLE IF NOT EXISTS api_keys (id text PRIMARY KEY, created_at datetime, updated_at datetime, "+
			"name text, description text, key_hash text, key_prefix text, kind text, user_id text, environment_id"+
			" text, managed_by text, expires_at datetime, last_used_at datetime)").Error,
	)
	return &database.DB{DB: db}
}

// setupUserAndRoleServices wires both services together the way bootstrap
// does, so the legacy-admin-guard tests exercise the real RBAC path.
func setupUserAndRoleServices(t *testing.T) (*userdomain.UserService, *role.RoleService) {
	t.Helper()
	db := setupAuthServiceTestDBInternal(t)
	localRole := role.NewRoleService(db)
	require.NoError(t, localRole.EnsureBuiltInRoles(t.Context()))
	userRecord := userdomain.NewUserService(db, localRole, session.RevokeAllUserSessionsExceptInDB)
	return userRecord, localRole
}

func createTestUser(t *testing.T, svc *userdomain.UserService, id, username string) *userdomain.User {
	t.Helper()
	created, err := svc.CreateUser(t.Context(), &userdomain.User{
		ID:       id,
		Username: username,
	})
	require.NoError(t, err)
	return created
}

// grantGlobalAdmin assigns the built-in Admin role globally to the user.
func grantGlobalAdmin(t *testing.T, roleSvc *role.RoleService, userID string) {
	t.Helper()
	require.NoError(t, roleSvc.ReplaceUserAssignments(t.Context(), userID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
		{RoleID: authz.BuiltInRoleAdmin, EnvironmentID: nil},
	}))
}

func TestDeleteUserRejectsDeletingOnlyAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)

	err := userSvc.DeleteUser(ctx, admin.ID, nil)
	require.ErrorIs(t, err, userdomain.ErrCannotRemoveLastAdmin)

	stillThere, err := userSvc.GetUserByID(ctx, admin.ID)
	require.NoError(t, err)
	require.Equal(t, admin.ID, stillThere.ID)
}

func TestSetPasswordUpdatesHashAndClearsPasswordChangeRequirement(t *testing.T) {
	userSvc, _ := setupUserAndRoleServices(t)
	ctx := t.Context()

	oldHash, err := userSvc.HashPassword(t.Context(), "old-password")
	require.NoError(t, err)
	localUser, err := userSvc.CreateUser(ctx, &userdomain.User{
		ID:                     "password-user",
		Username:               "password-user",
		PasswordHash:           oldHash,
		RequiresPasswordChange: true,
	})
	require.NoError(t, err)

	_, err = userSvc.SetPassword(ctx, localUser, "new-password")
	require.NoError(t, err)

	updated, err := userSvc.GetUserByID(ctx, localUser.ID)
	require.NoError(t, err)
	require.NoError(t, userSvc.ValidatePassword(t.Context(), updated.PasswordHash, "new-password"))
	require.Error(t, userSvc.ValidatePassword(t.Context(), updated.PasswordHash, "old-password"))
	require.False(t, updated.RequiresPasswordChange)
}

func TestDeleteUserAllowsDeletingNonAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	nonAdmin := createTestUser(t, userSvc, "user-1", "user")

	err := userSvc.DeleteUser(ctx, nonAdmin.ID, nil)
	require.NoError(t, err)

	_, err = userSvc.GetUserByID(ctx, nonAdmin.ID)
	require.ErrorIs(t, err, common.ErrUserNotFound)
}

func TestDeleteUserAllowsDeletingAdminWhenAnotherAdminExists(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	adminToDelete := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, adminToDelete.ID)
	backup := createTestUser(t, userSvc, "admin-2", "backup")
	grantGlobalAdmin(t, roleSvc, backup.ID)

	err := userSvc.DeleteUser(ctx, adminToDelete.ID, nil)
	require.NoError(t, err)

	_, err = userSvc.GetUserByID(ctx, adminToDelete.ID)
	require.ErrorIs(t, err, common.ErrUserNotFound)
}

func TestListUsersPaginatedSetsCanDeleteFromGlobalAdminCount(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	lastAdmin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, lastAdmin.ID)
	nonAdmin := createTestUser(t, userSvc, "user-1", "user")

	users, _, err := userSvc.ListUsersPaginated(ctx, pagination.QueryParams{
		Start: 0, Limit: 20,
		Sort: "Username", Order: "asc",
		Filters: map[string]string{},
	})
	require.NoError(t, err)
	require.Len(t, users, 2)

	canDeleteByID := make(map[string]bool, len(users))
	for _, userRecord := range users {
		canDeleteByID[userRecord.ID] = userRecord.CanDelete
	}

	require.False(t, canDeleteByID[lastAdmin.ID])
	require.True(t, canDeleteByID[nonAdmin.ID])

	adminDTO, err := userSvc.ToUserResponseDto(ctx, *lastAdmin)
	require.NoError(t, err)
	require.False(t, adminDTO.CanDelete)
	userDTO, err := userSvc.ToUserResponseDto(ctx, *nonAdmin)
	require.NoError(t, err)
	require.True(t, userDTO.CanDelete)

	backup := createTestUser(t, userSvc, "admin-2", "backup")
	grantGlobalAdmin(t, roleSvc, backup.ID)
	adminDTO, err = userSvc.ToUserResponseDto(ctx, *lastAdmin)
	require.NoError(t, err)
	require.True(t, adminDTO.CanDelete)
}

func TestDeleteUserRejectsDeletingOnlyCustomAllPermissionsAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	customAdmin := createTestUser(t, userSvc, "custom-admin", "custom-admin")
	customRole, err := roleSvc.CreateRole(ctx, "Custom Admin", nil, authz.AllPermissions())
	require.NoError(t, err)
	require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, customAdmin.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
		{RoleID: customRole.ID, EnvironmentID: nil},
	}))

	err = userSvc.DeleteUser(ctx, customAdmin.ID, nil)
	require.ErrorIs(t, err, userdomain.ErrCannotRemoveLastAdmin)

	users, _, err := userSvc.ListUsersPaginated(ctx, pagination.QueryParams{
		Start: 0, Limit: 20,
		Sort: "Username", Order: "asc",
		Filters: map[string]string{},
	})
	require.NoError(t, err)
	require.Len(t, users, 1)
	require.False(t, users[0].CanDelete)
	require.True(t, users[0].IsGlobalAdmin)
	dto, err := userSvc.ToUserResponseDto(ctx, *customAdmin)
	require.NoError(t, err)
	require.False(t, dto.CanDelete)
}

func TestUserProfileValidationAndPersistence(t *testing.T) {
	userSvc, _ := setupUserAndRoleServices(t)
	ctx := t.Context()

	u := createTestUser(t, userSvc, "user-1", "  fontuser  ")
	require.Equal(t, "fontuser", u.Username)
	require.Nil(t, u.FontSize, "new users default to no explicit font size")

	_, err := userSvc.CreateUser(ctx, &userdomain.User{ID: "blank-user", Username: "   "})
	require.ErrorIs(t, err, userdomain.ErrUsernameRequired)

	_, err = userSvc.CreateUser(ctx, &userdomain.User{ID: "duplicate-user", Username: "fontuser"})
	require.ErrorIs(t, err, userdomain.ErrUsernameTaken)

	u.FontSize = new(16)
	_, err = userSvc.UpdateUser(ctx, u, nil)
	require.NoError(t, err)

	reloaded, err := userSvc.GetUserByID(ctx, u.ID)
	require.NoError(t, err)
	require.NotNil(t, reloaded.FontSize)
	require.Equal(t, 16, *reloaded.FontSize)

	dto, err := userSvc.ToUserResponseDto(ctx, *reloaded)
	require.NoError(t, err)
	require.NotNil(t, dto.FontSize)
	require.Equal(t, 16, *dto.FontSize)

	conflictingUser := createTestUser(t, userSvc, "user-2", "another-user")
	conflictingUser.Username = u.Username
	_, err = userSvc.UpdateUser(ctx, conflictingUser, nil)
	require.ErrorIs(t, err, userdomain.ErrUsernameTaken)
}

func TestUserDtoExposesLastLogin(t *testing.T) {
	userSvc, _ := setupUserAndRoleServices(t)
	ctx := t.Context()

	u := createTestUser(t, userSvc, "user-1", "last-login-user")

	dto, err := userSvc.ToUserResponseDto(ctx, *u)
	require.NoError(t, err)
	require.Nil(t, dto.LastLogin, "a user who has never signed in has no last login")

	loginAt := time.Date(2026, 8, 2, 15, 4, 5, 0, time.UTC)
	require.NoError(t, userSvc.TouchLastLogin(ctx, u.ID, loginAt))

	reloaded, err := userSvc.GetUserByID(ctx, u.ID)
	require.NoError(t, err)
	dto, err = userSvc.ToUserResponseDto(ctx, *reloaded)
	require.NoError(t, err)
	require.NotNil(t, dto.LastLogin)
	require.Equal(t, "2026-08-02T15:04:05Z", *dto.LastLogin)
}

func TestUpdateUserPersistsTimeFormatAndMapsToDto(t *testing.T) {
	userSvc, _ := setupUserAndRoleServices(t)
	ctx := t.Context()

	u := createTestUser(t, userSvc, "user-1", "time-format-user")
	require.Equal(t, user.TimeFormatAuto, u.TimeFormat)

	for _, timeFormat := range []user.TimeFormat{
		user.TimeFormatAuto,
		user.TimeFormat12Hour,
		user.TimeFormat24Hour,
	} {
		t.Run(string(timeFormat), func(t *testing.T) {
			u.TimeFormat = timeFormat
			_, err := userSvc.UpdateUser(ctx, u, nil)
			require.NoError(t, err)

			reloaded, err := userSvc.GetUserByID(ctx, u.ID)
			require.NoError(t, err)
			require.Equal(t, timeFormat, reloaded.TimeFormat)

			dto, err := userSvc.ToUserResponseDto(ctx, *reloaded)
			require.NoError(t, err)
			require.Equal(t, timeFormat, dto.TimeFormat)
		})
	}
}

func TestUpdateUserRejectsNonAdminActorEditingAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	manager := createTestUser(t, userSvc, "mgr-1", "manager")
	managerRole, err := roleSvc.CreateRole(ctx, "User Manager", nil, []string{authz.PermUsersUpdate})
	require.NoError(t, err)
	require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, manager.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
		{RoleID: managerRole.ID, EnvironmentID: nil},
	}))
	managerPerms, err := roleSvc.ResolvePermissions(ctx, manager.ID)
	require.NoError(t, err)

	admin.PasswordHash = "attacker-controlled-hash"
	_, err = userSvc.UpdateUser(ctx, admin, managerPerms)
	require.ErrorIs(t, err, userdomain.ErrInsufficientPrivilege)

	reloaded, err := userSvc.GetUserByID(ctx, admin.ID)
	require.NoError(t, err)
	require.NotEqual(t, "attacker-controlled-hash", reloaded.PasswordHash)
}

func TestUpdateUserAllowsGlobalAdminActorEditingAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	other := createTestUser(t, userSvc, "admin-2", "backup")
	grantGlobalAdmin(t, roleSvc, other.ID)
	otherPerms, err := roleSvc.ResolvePermissions(ctx, other.ID)
	require.NoError(t, err)

	admin.DisplayName = new("Renamed Admin")
	actorCtx := context.WithValue(ctx, user.CurrentUserContextKey{}, other)
	_, err = userSvc.UpdateUser(actorCtx, admin, otherPerms)
	require.NoError(t, err)
}

func TestUpdateUserAllowsNonAdminActorEditingNonAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	manager := createTestUser(t, userSvc, "mgr-1", "manager")
	managerRole, err := roleSvc.CreateRole(ctx, "User Manager", nil, []string{authz.PermUsersUpdate})
	require.NoError(t, err)
	require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, manager.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
		{RoleID: managerRole.ID, EnvironmentID: nil},
	}))
	managerPerms, err := roleSvc.ResolvePermissions(ctx, manager.ID)
	require.NoError(t, err)

	target := createTestUser(t, userSvc, "user-1", "plain-user")
	target.DisplayName = new("New Name")
	_, err = userSvc.UpdateUser(ctx, target, managerPerms)
	require.NoError(t, err)
}

func TestUpdateUserAllowsSelfEditByNonAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	adminPerms, err := roleSvc.ResolvePermissions(ctx, admin.ID)
	require.NoError(t, err)

	admin.DisplayName = new("Self Rename")
	actorCtx := context.WithValue(ctx, user.CurrentUserContextKey{}, admin)
	_, err = userSvc.UpdateUser(actorCtx, admin, adminPerms)
	require.NoError(t, err)
}

func TestDeleteUserRejectsNonAdminActorDeletingAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	backup := createTestUser(t, userSvc, "admin-2", "backup")
	grantGlobalAdmin(t, roleSvc, backup.ID)
	manager := createTestUser(t, userSvc, "mgr-1", "manager")
	managerRole, err := roleSvc.CreateRole(ctx, "User Manager", nil, []string{authz.PermUsersDelete})
	require.NoError(t, err)
	require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, manager.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
		{RoleID: managerRole.ID, EnvironmentID: nil},
	}))
	managerPerms, err := roleSvc.ResolvePermissions(ctx, manager.ID)
	require.NoError(t, err)

	// Two admins exist, so the last-admin guard would not fire — the
	// actor-vs-target privilege check is what must block this delete.
	err = userSvc.DeleteUser(ctx, admin.ID, managerPerms)
	require.ErrorIs(t, err, userdomain.ErrInsufficientPrivilege)

	stillThere, err := userSvc.GetUserByID(ctx, admin.ID)
	require.NoError(t, err)
	require.Equal(t, admin.ID, stillThere.ID)
}

func TestDeleteUserAllowsGlobalAdminActorDeletingAdmin(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "arcane")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	other := createTestUser(t, userSvc, "admin-2", "backup")
	grantGlobalAdmin(t, roleSvc, other.ID)
	otherPerms, err := roleSvc.ResolvePermissions(ctx, other.ID)
	require.NoError(t, err)

	actorCtx := context.WithValue(ctx, user.CurrentUserContextKey{}, other)
	require.NoError(t, userSvc.DeleteUser(actorCtx, admin.ID, otherPerms))
}

func TestCreateDefaultAdminDoesNotPromoteRenamedArcaneUser(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	admin := createTestUser(t, userSvc, "admin-1", "boss")
	grantGlobalAdmin(t, roleSvc, admin.ID)
	imposter := createTestUser(t, userSvc, "user-2", "arcane")

	require.NoError(t, userSvc.CreateDefaultAdmin(ctx))

	assignments, err := roleSvc.ListUserAssignments(ctx, imposter.ID)
	require.NoError(t, err)
	require.Empty(t, assignments)
}

func TestCreateDefaultAdminRecoversArcaneUserWhenNoGlobalAdminExists(t *testing.T) {
	userSvc, roleSvc := setupUserAndRoleServices(t)
	ctx := t.Context()

	orphan := createTestUser(t, userSvc, "user-1", "arcane")

	require.NoError(t, userSvc.CreateDefaultAdmin(ctx))

	assignments, err := roleSvc.ListUserAssignments(ctx, orphan.ID)
	require.NoError(t, err)
	require.Len(t, assignments, 1)
	require.Equal(t, authz.BuiltInRoleAdmin, assignments[0].RoleID)
	require.Nil(t, assignments[0].EnvironmentID)
}

func TestUserDisplayNameNormalization(t *testing.T) {
	svc := userdomain.NewUserService(setupAuthServiceTestDBInternal(t), nil, session.RevokeAllUserSessionsExceptInDB)
	ctx := t.Context()
	created, err := svc.CreateUser(ctx, &userdomain.User{ID: "normalized", Username: " Jose\u0301 ", Email: new(" Jose\u0301@example.com "), DisplayName: new(" Jose\u0301 ")})
	require.NoError(t, err)
	require.Equal(t, "Jose\u0301", created.Username)
	require.Equal(t, " Jose\u0301@example.com ", *created.Email)
	require.Equal(t, "José", *created.DisplayName)
	created.DisplayName = new(" Andre\u0301 ")
	profile, err := svc.UpdateUser(ctx, created, nil)
	require.NoError(t, err)
	require.Equal(t, "André", *profile.DisplayName)
	require.Equal(t, "Jose\u0301", profile.Username)
	require.Equal(t, " Jose\u0301@example.com ", *profile.Email)
	created.Username = " Andre\u0301 "
	created.DisplayName = nil
	updated, err := svc.UpdateUser(ctx, created, nil)
	require.NoError(t, err)
	require.Equal(t, " Andre\u0301 ", updated.Username)
	require.Nil(t, updated.DisplayName)
	reloaded, err := svc.GetUserByID(ctx, updated.ID)
	require.NoError(t, err)
	require.Equal(t, " Andre\u0301 ", reloaded.Username)
	require.Equal(t, " Jose\u0301@example.com ", *reloaded.Email)
	_, err = svc.GetUserByUsername(ctx, " Andre\u0301 ")
	require.NoError(t, err)
	_, err = svc.CreateUser(ctx, &userdomain.User{ID: "empty", Username: " \t "})
	require.ErrorIs(t, err, userdomain.ErrUsernameRequired)
}