Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package authz_test
import (
"os"
"path/filepath"
"regexp"
"strings"
"testing"
"github.com/stretchr/testify/require"
"github.com/getarcaneapp/arcane/backend/v2/internal/search"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
)
func TestAccessSurfaceRegistryDefinesSettingsCustomizeAndLandingSemantics(t *testing.T) {
webhooks := requireAccessSurfaceInternal(t, "settings.category.webhooks")
require.Equal(t, authz.AccessSurfaceKindSettingsCategory, webhooks.Kind)
require.Equal(t, "/settings/webhooks", webhooks.URL)
require.Equal(t, authz.AccessModePermissions, webhooks.AccessMode)
require.Equal(t, authz.AccessMatchModeAnyOf, webhooks.MatchMode)
require.Equal(t, authz.AccessScopeModeSelectedEnvPlusGlobal, webhooks.ScopeMode)
require.ElementsMatch(t, []string{authz.PermWebhooksList}, webhooks.Permissions)
apiKeys := requireAccessSurfaceInternal(t, "settings.category.apikeys")
require.Equal(t, authz.AccessScopeModeGlobalOnly, apiKeys.ScopeMode)
require.ElementsMatch(t, []string{authz.PermApiKeysList, authz.PermApiKeysRead}, apiKeys.Permissions)
jobSchedule := requireAccessSurfaceInternal(t, "settings.category.jobschedule")
require.Equal(t, authz.AccessScopeModeSelectedEnvPlusGlobal, jobSchedule.ScopeMode)
require.Equal(t, "/settings/jobs", jobSchedule.URL)
require.ElementsMatch(t, []string{authz.PermJobsManage}, jobSchedule.Permissions)
notifications := requireAccessSurfaceInternal(t, "settings.category.notifications")
require.Equal(t, authz.AccessScopeModeGlobalOnly, notifications.ScopeMode)
require.ElementsMatch(t, []string{authz.PermNotificationsManage}, notifications.Permissions)
templates := requireAccessSurfaceInternal(t, "customize.category.templates")
require.Equal(t, authz.AccessSurfaceKindCustomizeCategory, templates.Kind)
require.Equal(t, authz.AccessScopeModeGlobalOnly, templates.ScopeMode)
require.ElementsMatch(t, []string{authz.PermCustomizeManage, authz.PermTemplatesList, authz.PermTemplatesRead}, templates.Permissions)
variables := requireAccessSurfaceInternal(t, "customize.category.variables")
require.Equal(t, authz.AccessSurfaceKindCustomizeCategory, variables.Kind)
require.Equal(t, authz.AccessScopeModeGlobalOnly, variables.ScopeMode)
require.Equal(t, authz.AccessMatchModeAnyOf, variables.MatchMode)
require.ElementsMatch(t, []string{authz.PermVariablesRead}, variables.Permissions)
require.NotContains(t, variables.Permissions, authz.PermTemplatesRead)
activities := requireAccessSurfaceInternal(t, "route.activities")
require.Equal(t, authz.AccessSurfaceKindRoute, activities.Kind)
require.Empty(t, activities.URL)
require.Equal(t, authz.AccessScopeModeAnyEffectiveScope, activities.ScopeMode)
require.ElementsMatch(t, []string{authz.PermActivitiesRead}, activities.Permissions)
oidcRoleMappings := requireAccessSurfaceInternal(t, "route.oidc-role-mappings")
require.Equal(t, authz.AccessSurfaceKindRoute, oidcRoleMappings.Kind)
require.Empty(t, oidcRoleMappings.URL)
require.Equal(t, authz.AccessScopeModeGlobalOnly, oidcRoleMappings.ScopeMode)
require.Equal(t, authz.AccessMatchModeAllOf, oidcRoleMappings.MatchMode)
require.ElementsMatch(t, authz.AllPermissions(), oidcRoleMappings.Permissions)
settingsLanding := requireAccessSurfaceInternal(t, "landing.settings")
require.Equal(t, authz.AccessSurfaceKindLanding, settingsLanding.Kind)
require.Equal(t, "/settings", settingsLanding.URL)
require.Equal(t, authz.AccessModeAnyChild, settingsLanding.AccessMode)
require.Contains(t, settingsLanding.Children, "settings.category.webhooks")
require.Contains(t, settingsLanding.Children, "settings.category.apikeys")
require.Contains(t, settingsLanding.Children, "settings.category.jobschedule")
dashboard := requireAccessSurfaceInternal(t, "route.dashboard")
require.Equal(t, authz.AccessSurfaceKindRoute, dashboard.Kind)
require.Equal(t, "/dashboard", dashboard.URL)
require.Positive(t, dashboard.FallbackOrder)
}
func TestCanAccessSurfaceEvaluatesScopeModesAndLandingChildren(t *testing.T) {
ps := authz.NewPermissionSet()
ps.AddEnv("env-a", authz.PermWebhooksList)
require.True(t, authz.CanAccessSurface(ps, "settings.category.webhooks", "env-a"))
require.True(t, authz.CanAccessSurface(ps, "landing.settings", "env-a"))
require.False(t, authz.CanAccessSurface(ps, "settings.category.webhooks", "env-b"))
require.False(t, authz.CanAccessSurface(ps, "landing.settings", "env-b"))
ps.AddGlobal(authz.PermApiKeysRead)
require.True(t, authz.CanAccessSurface(ps, "settings.category.apikeys", "env-b"))
require.True(t, authz.CanAccessSurface(ps, "landing.settings", "env-b"))
jobsPS := authz.NewPermissionSet()
jobsPS.AddEnv("env-a", authz.PermJobsManage)
require.True(t, authz.CanAccessSurface(jobsPS, "settings.category.jobschedule", "env-a"))
require.True(t, authz.CanAccessSurface(jobsPS, "landing.settings", "env-a"))
require.False(t, authz.CanAccessSurface(jobsPS, "settings.category.jobschedule", "env-b"))
notificationPS := authz.NewPermissionSet()
notificationPS.AddEnv("env-a", authz.PermNotificationsManage)
require.False(t, authz.CanAccessSurface(notificationPS, "settings.category.notifications", "env-a"))
notificationPS.AddGlobal(authz.PermNotificationsManage)
require.True(t, authz.CanAccessSurface(notificationPS, "settings.category.notifications", "env-a"))
customizePS := authz.NewPermissionSet()
customizePS.AddGlobal(authz.PermCustomizeManage)
require.True(t, authz.CanAccessSurface(customizePS, "customize.category.registries", "env-a"))
require.True(t, authz.CanAccessSurface(customizePS, "landing.customize", "env-a"))
variablePS := authz.NewPermissionSet()
variablePS.AddGlobal(authz.PermVariablesRead)
require.True(t, authz.CanAccessSurface(variablePS, "customize.category.variables", "env-a"))
require.True(t, authz.CanAccessSurface(variablePS, "landing.customize", "env-a"))
templatePS := authz.NewPermissionSet()
templatePS.AddGlobal(authz.PermTemplatesRead)
require.False(t, authz.CanAccessSurface(templatePS, "customize.category.variables", "env-a"))
activitiesPS := authz.NewPermissionSet()
activitiesPS.AddEnv("env-a", authz.PermActivitiesRead)
require.True(t, authz.CanAccessSurface(activitiesPS, "route.activities", "env-b"))
require.False(t, authz.CanAccessSurface(authz.NewPermissionSet(), "route.activities", "env-a"))
globalAdminPS := authz.NewPermissionSet()
globalAdminPS.AddGlobal(authz.AllPermissions()...)
require.True(t, authz.CanAccessSurface(globalAdminPS, "route.oidc-role-mappings", "env-a"))
require.True(t, authz.CanAccessSurface(authz.SudoPermissionSet(), "route.oidc-role-mappings", "env-a"))
nonAdminPS := authz.NewPermissionSet()
nonAdminPS.AddGlobal(authz.BuiltInEditorPermissions()...)
require.False(t, authz.CanAccessSurface(nonAdminPS, "route.oidc-role-mappings", "env-a"))
environmentAdminPS := authz.NewPermissionSet()
environmentAdminPS.AddEnv("env-a", authz.AllPermissions()...)
require.False(t, authz.CanAccessSurface(environmentAdminPS, "route.oidc-role-mappings", "env-a"))
require.False(t, authz.CanAccessSurface(authz.NewPermissionSet(), "missing.surface", "env-a"))
}
func TestAccessSurfaceRegistryIsDefensiveAndInternallyConsistent(t *testing.T) {
surfaces := authz.AccessSurfaces()
require.NotEmpty(t, surfaces)
surfaces[0].Permissions = append(surfaces[0].Permissions, "unknown:permission")
surfaces[0].Children = append(surfaces[0].Children, "missing.child")
fresh := authz.AccessSurfaces()
require.NotContains(t, fresh[0].Permissions, "unknown:permission")
require.NotContains(t, fresh[0].Children, "missing.child")
for _, surface := range fresh {
for _, perm := range surface.Permissions {
require.True(t, authz.IsKnownPermission(perm), "surface %s references unknown permission %s", surface.ID, perm)
}
for _, childID := range surface.Children {
_, ok := findAccessSurfaceInternal(childID)
require.True(t, ok, "surface %s references unknown child %s", surface.ID, childID)
}
}
}
func TestAccessSurfaceCategoryRegistryCoversBackendCategories(t *testing.T) {
hiddenSettingsCategories := map[string]struct{}{
"security": {},
}
for _, category := range settings.NewSettingsSearchService().GetSettingsCategories() {
if _, hidden := hiddenSettingsCategories[category.ID]; hidden {
continue
}
_, ok := findAccessSurfaceInternal("settings.category." + category.ID)
require.True(t, ok, "settings category %s must have an access surface", category.ID)
}
for _, category := range search.NewCustomizeSearchService().GetCustomizeCategories() {
_, ok := findAccessSurfaceInternal("customize.category." + category.ID)
require.True(t, ok, "customize category %s must have an access surface", category.ID)
}
}
func TestPublishedAccessSurfaceURLsHaveFrontendRoutes(t *testing.T) {
routesRoot := filepath.Join(repoRootInternal(t), "frontend", "src", "routes", "(app)")
for _, surface := range authz.AccessSurfaces() {
if surface.URL == "" {
continue
}
routePath := frontendRoutePathInternal(routesRoot, surface.URL)
_, err := os.Stat(routePath)
require.NoError(t, err, "access surface %s URL %s must map to frontend route %s", surface.ID, surface.URL, routePath)
}
}
func TestFrontendNavigationReferencesKnownAccessSurfaces(t *testing.T) {
navPath := filepath.Join(repoRootInternal(t), "frontend", "src", "lib", "config", "navigation-config.ts")
body, err := os.ReadFile(navPath)
require.NoError(t, err)
matches := regexp.MustCompile(`accessSurfaceId:\s*'([^']+)'`).FindAllStringSubmatch(string(body), -1)
require.NotEmpty(t, matches)
for _, match := range matches {
require.Len(t, match, 2)
_, ok := findAccessSurfaceInternal(match[1])
require.True(t, ok, "frontend navigation references unknown access surface %s", match[1])
}
}
func requireAccessSurfaceInternal(t *testing.T, id string) authz.AccessSurface {
t.Helper()
surface, ok := findAccessSurfaceInternal(id)
require.True(t, ok, "expected access surface %s to exist", id)
return surface
}
func findAccessSurfaceInternal(id string) (authz.AccessSurface, bool) {
for _, surface := range authz.AccessSurfaces() {
if surface.ID == id {
return surface, true
}
}
return authz.AccessSurface{}, false
}
func repoRootInternal(t *testing.T) string {
t.Helper()
// go test runs in the package directory; runtime.Caller breaks under -trimpath.
wd, err := os.Getwd()
require.NoError(t, err)
return filepath.Clean(filepath.Join(wd, "..", "..", ".."))
}
func frontendRoutePathInternal(routesRoot, url string) string {
parts := strings.Split(strings.Trim(url, "/"), "/")
for i, part := range parts {
if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
parts[i] = "[" + strings.Trim(part, "{}") + "]"
continue
}
if after, ok := strings.CutPrefix(part, ":"); ok {
parts[i] = "[" + after + "]"
}
}
return filepath.Join(append([]string{routesRoot}, parts...)...)
}