Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package role_test
import (
"path/filepath"
"slices"
"testing"
"time"
"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"
"github.com/getarcaneapp/arcane/backend/v2/internal/user"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
)
func TestValidatePermissionsAgainstCallerRejectsEscalation(t *testing.T) {
_, roleSvc := setupUserAndRoleServices(t)
caller := authz.NewPermissionSet()
caller.AddGlobal(authz.PermRolesRead, authz.PermRolesList)
err := roleSvc.ValidatePermissionsAgainstCaller(caller, []string{
authz.PermRolesRead,
authz.PermUsersDelete,
})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrRolePermissionEscalation)
require.NoError(t, roleSvc.ValidatePermissionsAgainstCaller(caller, []string{authz.PermRolesRead}))
require.NoError(t, roleSvc.ValidatePermissionsAgainstCaller(authz.SudoPermissionSet(), []string{authz.PermUsersDelete}))
}
func TestValidatePermissionsAgainstCallerRejectsEnvOnlyGrantForGlobalRole(t *testing.T) {
_, roleSvc := setupUserAndRoleServices(t)
caller := authz.NewPermissionSet()
caller.AddEnv("env-1", authz.PermContainersStart)
err := roleSvc.ValidatePermissionsAgainstCaller(caller, []string{authz.PermContainersStart})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrRolePermissionEscalation)
}
func TestValidatePermissionsAgainstCallerRejectsUnknownPermissionBeforeEscalation(t *testing.T) {
_, roleSvc := setupUserAndRoleServices(t)
// A sudo caller would otherwise short-circuit past the escalation loop;
// unknown perms must still surface as UnknownPermissionError (→ 400),
// not as an opaque escalation 403 or a silent pass.
err := roleSvc.ValidatePermissionsAgainstCaller(authz.SudoPermissionSet(), []string{"containrs:start"})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrUnknownPermission)
require.NotErrorIs(t, err, common.ErrRolePermissionEscalation)
}
func TestBackfillLegacyRoleAssignments(t *testing.T) {
ctx := t.Context()
t.Run("no-op without legacy column", func(t *testing.T) {
db, roleSvc := setupUserAndRoleServices(t)
require.False(t, db.Migrator().HasColumn("users", "roles"))
require.NoError(t, roleSvc.BackfillLegacyRoleAssignments(ctx))
require.NoError(t, roleSvc.BackfillLegacyRoleAssignments(ctx))
})
t.Run("converts legacy roles once", func(t *testing.T) {
db, err := database.Initialize(ctx, "file:"+filepath.Join(t.TempDir(), "arcane.db"), database.MigrationOptions{})
require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, db.Close()) })
require.True(t, db.Migrator().HasColumn("users", "roles"))
roleSvc := role.NewRoleService(db)
require.NoError(t, roleSvc.EnsureBuiltInRoles(ctx))
require.NoError(t, db.Exec("INSERT INTO environments (id, name, api_url) VALUES (?, ?, ?)", "env-1", "env-1", "http://env-1").Error)
for id, roles := range map[string]string{
"seed-admin": `[]`,
"legacy-admin": `["user", " ADMIN "]`,
"legacy-user": `["user"]`,
"legacy-empty": `[]`,
"legacy-null": `null`,
"legacy-blank": `[" "]`,
"legacy-broken": `not json`,
"scoped-manual": `["admin"]`,
"global-oidc": `["admin"]`,
} {
require.NoError(t, db.Exec("INSERT INTO users (id, username, password_hash, roles) VALUES (?, ?, ?, ?)", id, id, "unused", roles).Error)
}
require.NoError(t, db.Create(&role.UserRoleAssignment{UserID: "seed-admin", RoleID: authz.BuiltInRoleAdmin, Source: role.RoleAssignmentSourceManual}).Error)
envID := "env-1"
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, "scoped-manual", role.RoleAssignmentSourceManual, []role.UserRoleAssignment{{RoleID: authz.BuiltInRoleViewer, EnvironmentID: &envID}}))
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, "global-oidc", role.RoleAssignmentSourceOidc, []role.UserRoleAssignment{{RoleID: authz.BuiltInRoleViewer}}))
require.NoError(t, roleSvc.BackfillLegacyRoleAssignments(ctx))
require.Equal(t, []string{authz.BuiltInRoleAdmin}, assignedRoleIDs(t, roleSvc, "legacy-admin"))
for _, id := range []string{"legacy-user", "legacy-empty", "legacy-null", "legacy-blank", "legacy-broken"} {
require.Equal(t, []string{authz.BuiltInRoleViewer}, assignedRoleIDs(t, roleSvc, id), id)
}
scoped, err := roleSvc.ListUserAssignments(ctx, "scoped-manual")
require.NoError(t, err)
require.Len(t, scoped, 1)
require.Equal(t, &envID, scoped[0].EnvironmentID)
oidc, err := roleSvc.ListUserAssignments(ctx, "global-oidc")
require.NoError(t, err)
require.Len(t, oidc, 1)
require.Equal(t, role.RoleAssignmentSourceOidc, oidc[0].Source)
ps, err := roleSvc.ResolveUserPermissionsInDB(ctx, db.DB, "scoped-manual")
require.NoError(t, err)
require.True(t, ps.Allows(authz.PermContainersList, "env-1"))
require.False(t, ps.Allows(authz.PermContainersList, ""))
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, "legacy-user", role.RoleAssignmentSourceManual, nil))
require.NoError(t, db.Exec("INSERT INTO users (id, username, password_hash, roles) VALUES (?, ?, ?, ?)", "later-admin", "later-admin", "unused", `["admin"]`).Error)
require.NoError(t, role.NewRoleService(db).BackfillLegacyRoleAssignments(ctx))
require.Empty(t, assignedRoleIDs(t, roleSvc, "legacy-user"))
require.Empty(t, assignedRoleIDs(t, roleSvc, "later-admin"))
})
}
func assignedRoleIDs(t *testing.T, roleSvc *role.RoleService, userID string) []string {
t.Helper()
assignments, err := roleSvc.ListUserAssignments(t.Context(), userID)
require.NoError(t, err)
ids := make([]string, 0, len(assignments))
for _, a := range assignments {
ids = append(ids, a.RoleID)
}
return ids
}
func TestEnsureBuiltInRolesMigratesVariablePermissionsWithoutBackfillingCustomGrants(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
customRole, err := roleSvc.CreateRole(ctx, "Template Reader", nil, []string{authz.PermTemplatesRead})
require.NoError(t, err)
owner := createTestUser(t, userSvc, "variable-migration-owner", "variable-migration-owner")
scopedKey := testApiKeyRow{
Name: "Custom scoped key",
KeyHash: "variable-migration-hash",
KeyPrefix: "arc_vars",
Kind: "scoped",
UserID: &owner.ID,
}
require.NoError(t, userSvc.WithContext(ctx).Create(&scopedKey).Error)
require.NoError(t, userSvc.WithContext(ctx).Create(&role.ApiKeyPermission{
ApiKeyID: scopedKey.ID,
Permission: authz.PermTemplatesRead,
}).Error)
oldEditorPermissions := slices.DeleteFunc(authz.BuiltInEditorPermissions(), func(permission string) bool {
return slices.Contains([]string{
authz.PermVariablesRead,
authz.PermVariablesCreate,
authz.PermVariablesUpdate,
authz.PermVariablesDelete,
authz.PermVariablesSync,
}, permission)
})
require.NoError(t, userSvc.WithContext(ctx).Model(&role.Role{}).
Where("id = ?", authz.BuiltInRoleEditor).
Update("permissions", database.StringSlice(oldEditorPermissions)).Error)
require.NoError(t, roleSvc.EnsureBuiltInRoles(ctx))
allVariablePermissions := []string{
authz.PermVariablesRead,
authz.PermVariablesCreate,
authz.PermVariablesUpdate,
authz.PermVariablesDelete,
authz.PermVariablesSync,
}
for _, roleID := range []string{authz.BuiltInRoleAdmin, authz.BuiltInRoleEditor, authz.BuiltInRoleNoShellEditor} {
builtIn, getErr := roleSvc.GetRole(ctx, roleID)
require.NoError(t, getErr)
for _, permission := range allVariablePermissions {
require.Contains(t, []string(builtIn.Permissions), permission, "role %s", roleID)
}
}
for _, roleID := range []string{authz.BuiltInRoleViewer, authz.BuiltInRoleDeployer} {
builtIn, getErr := roleSvc.GetRole(ctx, roleID)
require.NoError(t, getErr)
require.Contains(t, []string(builtIn.Permissions), authz.PermVariablesRead)
for _, permission := range allVariablePermissions[1:] {
require.NotContains(t, []string(builtIn.Permissions), permission, "role %s", roleID)
}
}
monitor, err := roleSvc.GetRole(ctx, authz.BuiltInRoleMonitor)
require.NoError(t, err)
for _, permission := range allVariablePermissions {
require.NotContains(t, []string(monitor.Permissions), permission)
}
preservedCustomRole, err := roleSvc.GetRole(ctx, customRole.ID)
require.NoError(t, err)
require.Equal(t, []string{authz.PermTemplatesRead}, []string(preservedCustomRole.Permissions))
var keyPermissions []role.ApiKeyPermission
require.NoError(t, userSvc.WithContext(ctx).Where("api_key_id = ?", scopedKey.ID).Find(&keyPermissions).Error)
require.Len(t, keyPermissions, 1)
require.Equal(t, authz.PermTemplatesRead, keyPermissions[0].Permission)
}
func TestSetUserAssignmentsRejectsUnknownRole(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
victim := createTestUser(t, userSvc, "victim", "victim")
err := roleSvc.ReplaceUserAssignments(ctx, victim.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
{RoleID: "role_does_not_exist"},
})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrInvalidRoleAssignment)
}
func TestReplaceUserAssignmentsOidcRejectsUnknownRole(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
oidcUser := createTestUser(t, userSvc, "oidc-user", "oidc-user")
err := roleSvc.ReplaceUserAssignments(ctx, oidcUser.ID, role.RoleAssignmentSourceOidc, []role.UserRoleAssignment{
{RoleID: "role_does_not_exist"},
})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrInvalidRoleAssignment)
}
func TestReplaceUserAssignmentsOidcRejectsUnknownEnvironment(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
oidcUser := createTestUser(t, userSvc, "oidc-user-env", "oidc-user-env")
missingEnv := "env_does_not_exist"
// A valid role scoped to a non-existent environment must fail existence
// validation (same as manual assignments) rather than attempting an insert.
err := roleSvc.ReplaceUserAssignments(ctx, oidcUser.ID, role.RoleAssignmentSourceOidc, []role.UserRoleAssignment{
{RoleID: authz.BuiltInRoleViewer, EnvironmentID: &missingEnv},
})
require.Error(t, err)
require.ErrorIs(t, err, common.ErrInvalidRoleAssignment)
}
func TestEffectiveGlobalAdminCountIncludesCustomAllPermissionsRole(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
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},
}))
count, err := roleSvc.CountGlobalAdmins(ctx, userSvc.DB, "")
require.NoError(t, err)
require.Equal(t, 1, count)
require.NoError(t, roleSvc.AssertGlobalAdminExists(ctx, userSvc.DB))
err = roleSvc.ReplaceUserAssignments(ctx, customAdmin.ID, role.RoleAssignmentSourceManual, nil)
require.Error(t, err)
require.ErrorIs(t, err, common.ErrNoGlobalAdminRemains)
}
func TestEffectiveGlobalAdminCountIgnoresEnvScopedAndServiceAccounts(t *testing.T) {
ctx := t.Context()
userSvc, roleSvc := setupUserAndRoleServices(t)
customRole, err := roleSvc.CreateRole(ctx, "Custom Admin", nil, authz.AllPermissions())
require.NoError(t, err)
envID := "env-1"
createTestEnvironment(t, userSvc, envID, "http://localhost:3552", nil)
globalAdmin := createTestUser(t, userSvc, "global-admin", "global-admin")
envScopedAdmin := createTestUser(t, userSvc, "env-scoped-admin", "env-scoped-admin")
serviceAdmin := &user.User{
ID: "service-admin",
Username: "service-admin",
IsServiceAccount: true,
}
require.NoError(t, userSvc.WithContext(ctx).Create(serviceAdmin).Error)
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, globalAdmin.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
{RoleID: customRole.ID, EnvironmentID: nil},
}))
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, envScopedAdmin.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
{RoleID: customRole.ID, EnvironmentID: &envID},
}))
require.NoError(t, roleSvc.ReplaceUserAssignments(ctx, serviceAdmin.ID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
{RoleID: customRole.ID, EnvironmentID: nil},
}))
count, err := roleSvc.CountGlobalAdmins(ctx, userSvc.DB, "")
require.NoError(t, err)
require.Equal(t, 1, count)
}
func setupAuthServiceTestDB(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{},
&user.User{},
&session.UserSession{},
&testEnvironmentRow{},
&role.Role{},
&role.UserRoleAssignment{},
&testApiKeyRow{},
&role.ApiKeyPermission{},
&role.OidcRoleMapping{},
))
return &database.DB{DB: db}
}
func setupUserAndRoleServices(t *testing.T) (*database.DB, *role.RoleService) {
t.Helper()
db := setupAuthServiceTestDB(t)
roleService := role.NewRoleService(db)
require.NoError(t, roleService.EnsureBuiltInRoles(t.Context()))
return db, roleService
}
func createTestUser(t *testing.T, db *database.DB, id, username string) *user.User {
t.Helper()
created := &user.User{ID: id, Username: username}
require.NoError(t, db.WithContext(t.Context()).Create(created).Error)
return created
}
func grantGlobalAdmin(t *testing.T, roleService *role.RoleService, userID string) {
t.Helper()
require.NoError(t, roleService.ReplaceUserAssignments(t.Context(), userID, role.RoleAssignmentSourceManual, []role.UserRoleAssignment{
{RoleID: authz.BuiltInRoleAdmin},
}))
}
func createTestEnvironment(t *testing.T, db *database.DB, id, apiURL string, accessToken *string) {
t.Helper()
now := time.Now()
require.NoError(t, db.WithContext(t.Context()).Create(&testEnvironmentRow{
ID: id, CreatedAt: now, UpdatedAt: &now,
Name: "env-" + id,
ApiUrl: apiURL,
Status: "online",
Enabled: true,
AccessToken: accessToken,
}).Error)
}
// Minimal stand-ins for the environments and api_keys rows these tests need.
type testEnvironmentRow struct {
database.BaseModel
Name string
ApiUrl string `gorm:"column:api_url"`
Status string
Enabled bool
AccessToken *string `gorm:"column:access_token"`
}
func (testEnvironmentRow) TableName() string { return "environments" }
type testApiKeyRow struct {
database.BaseModel
Name string
KeyHash string `gorm:"column:key_hash"`
KeyPrefix string `gorm:"column:key_prefix"`
Kind string
UserID *string `gorm:"column:user_id"`
EnvironmentID *string `gorm:"column:environment_id"`
ManagedBy *string `gorm:"column:managed_by"`
ExpiresAt *time.Time
}
func (testApiKeyRow) TableName() string { return "api_keys" }
func TestResolveExecutionPermissions(t *testing.T) {
t.Run("personal keys use current user permissions and explicit scope", func(t *testing.T) {
db, service := setupUserAndRoleServices(t)
owner := createTestUser(t, db, "owner", "owner")
grantGlobalAdmin(t, service, owner.ID)
environmentID := "env-1"
key := testApiKeyRow{ID: "personal", Kind: "personal", UserID: &owner.ID, EnvironmentID: &environmentID}
require.NoError(t, db.Create(&key).Error)
permissions, err := service.ResolveExecutionPermissions(t.Context(), owner.ID, key.ID)
require.NoError(t, err)
require.True(t, permissions.Allows(authz.PermJobsManage, environmentID))
require.False(t, permissions.Allows(authz.PermJobsManage, "env-2"))
require.False(t, permissions.IsGlobalAdmin())
require.NoError(t, db.Where("user_id = ?", owner.ID).Delete(&role.UserRoleAssignment{}).Error)
for _, keyID := range []string{"", key.ID} {
permissions, err = service.ResolveExecutionPermissions(t.Context(), owner.ID, keyID)
require.NoError(t, err)
require.False(t, permissions.Allows(authz.PermJobsManage, environmentID))
}
})
t.Run("scoped keys bypass cached grants", func(t *testing.T) {
db, service := setupUserAndRoleServices(t)
owner := createTestUser(t, db, "owner", "owner")
grantGlobalAdmin(t, service, owner.ID)
environmentID := "env-1"
key := testApiKeyRow{ID: "scoped", Kind: "scoped", UserID: &owner.ID, EnvironmentID: &environmentID}
require.NoError(t, db.Create(&key).Error)
require.NoError(t, service.SetApiKeyPermissions(t.Context(), key.ID, []role.ApiKeyPermission{{Permission: authz.PermJobsManage}}))
cached, err := service.ResolveApiKeyPermissions(t.Context(), key.ID)
require.NoError(t, err)
require.True(t, cached.Allows(authz.PermJobsManage, "env-2"))
permissions, err := service.ResolveExecutionPermissions(t.Context(), owner.ID, key.ID)
require.NoError(t, err)
require.True(t, permissions.Allows(authz.PermJobsManage, environmentID))
require.False(t, permissions.Allows(authz.PermJobsManage, "env-2"))
require.NoError(t, db.Where("api_key_id = ?", key.ID).Delete(&role.ApiKeyPermission{}).Error)
permissions, err = service.ResolveExecutionPermissions(t.Context(), owner.ID, key.ID)
require.NoError(t, err)
require.False(t, permissions.Allows(authz.PermJobsManage, environmentID))
})
t.Run("rejects invalid persisted identities", func(t *testing.T) {
db, service := setupUserAndRoleServices(t)
owner := createTestUser(t, db, "owner", "owner")
otherOwner := "other"
emptyEnvironment := ""
expired := time.Now().Add(-time.Minute)
for _, key := range []testApiKeyRow{
{ID: "expired", Kind: "personal", UserID: &owner.ID, ExpiresAt: &expired},
{ID: "other-owner", Kind: "personal", UserID: &otherOwner},
{ID: "ownerless", Kind: "scoped"},
{ID: "invalid-kind", Kind: "unknown", UserID: &owner.ID},
{ID: "invalid-scope", Kind: "personal", UserID: &owner.ID, EnvironmentID: &emptyEnvironment},
} {
require.NoError(t, db.Create(&key).Error)
_, err := service.ResolveExecutionPermissions(t.Context(), owner.ID, key.ID)
require.Error(t, err, key.ID)
}
_, err := service.ResolveExecutionPermissions(t.Context(), owner.ID, "deleted-key")
require.Error(t, err)
require.NoError(t, db.Delete(owner).Error)
_, err = service.ResolveExecutionPermissions(t.Context(), owner.ID, "")
require.Error(t, err)
})
}