Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
package api
import (
"os"
"path/filepath"
"strings"
"testing"
"github.com/rcourtman/pulse-go-rewrite/pkg/auth"
)
func TestTenantRBACProvider_DefaultOrg(t *testing.T) {
baseDir := t.TempDir()
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
manager, err := provider.GetManager("default")
if err != nil {
t.Fatalf("GetManager(default) failed: %v", err)
}
assertBuiltInRolesPresent(t, manager)
dbPath := filepath.Join(baseDir, "rbac", "rbac.db")
if _, err := os.Stat(dbPath); err != nil {
t.Fatalf("expected default rbac db at %s: %v", dbPath, err)
}
}
func TestTenantRBACProvider_DefaultOrgMigratesLegacyState(t *testing.T) {
baseDir := t.TempDir()
legacy, err := auth.NewFileManager(baseDir)
if err != nil {
t.Fatalf("NewFileManager: %v", err)
}
if err := legacy.SaveRole(auth.Role{
ID: "legacy-readonly",
Name: "Legacy read only",
Permissions: []auth.Permission{{Action: "read", Resource: "*"}},
}); err != nil {
t.Fatalf("save legacy role: %v", err)
}
if err := legacy.UpdateUserRoles("legacy-local", []string{"legacy-readonly"}); err != nil {
t.Fatalf("save legacy assignment: %v", err)
}
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() { _ = provider.Close() })
manager, err := provider.GetManager("default")
if err != nil {
t.Fatalf("GetManager(default): %v", err)
}
if _, ok := manager.GetRole("legacy-readonly"); !ok {
t.Fatal("default organization did not migrate the legacy role")
}
assignment, ok := manager.GetUserAssignment("legacy-local")
if !ok || len(assignment.RoleIDs) != 1 || assignment.RoleIDs[0] != "legacy-readonly" {
t.Fatalf("default organization did not migrate assignment: %#v, exists=%v", assignment, ok)
}
}
func TestTenantRBACProvider_NonDefaultOrg(t *testing.T) {
baseDir := t.TempDir()
orgID := "acme"
createOrgDir(t, baseDir, orgID)
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
manager, err := provider.GetManager(orgID)
if err != nil {
t.Fatalf("GetManager(%s) failed: %v", orgID, err)
}
assertBuiltInRolesPresent(t, manager)
dbPath := filepath.Join(baseDir, "orgs", orgID, "rbac", "rbac.db")
if _, err := os.Stat(dbPath); err != nil {
t.Fatalf("expected tenant rbac db at %s: %v", dbPath, err)
}
}
func TestTenantRBACProvider_NonDefaultOrgDoesNotConsumeLegacyState(t *testing.T) {
baseDir := t.TempDir()
legacy, err := auth.NewFileManager(baseDir)
if err != nil {
t.Fatalf("NewFileManager: %v", err)
}
if err := legacy.SaveRole(auth.Role{
ID: "default-only",
Name: "Default only",
Permissions: []auth.Permission{{Action: "read", Resource: "*"}},
}); err != nil {
t.Fatalf("save legacy role: %v", err)
}
createOrgDir(t, baseDir, "other-org")
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() { _ = provider.Close() })
manager, err := provider.GetManager("other-org")
if err != nil {
t.Fatalf("GetManager(other-org): %v", err)
}
if _, ok := manager.GetRole("default-only"); ok {
t.Fatal("legacy default-organization role leaked into another organization")
}
if _, err := os.Stat(filepath.Join(baseDir, "rbac_roles.json")); err != nil {
t.Fatalf("non-default organization consumed legacy source: %v", err)
}
}
func TestTenantRBACProvider_Isolation(t *testing.T) {
baseDir := t.TempDir()
orgA := "org-a"
orgB := "org-b"
createOrgDir(t, baseDir, orgA)
createOrgDir(t, baseDir, orgB)
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
managerA, err := provider.GetManager(orgA)
if err != nil {
t.Fatalf("GetManager(%s) failed: %v", orgA, err)
}
managerB, err := provider.GetManager(orgB)
if err != nil {
t.Fatalf("GetManager(%s) failed: %v", orgB, err)
}
roleID := "custom-org-a"
if err := managerA.SaveRole(auth.Role{
ID: roleID,
Name: "Custom Org A",
Description: "Role for org A only",
Permissions: []auth.Permission{
{Action: "read", Resource: "nodes"},
},
}); err != nil {
t.Fatalf("SaveRole in %s failed: %v", orgA, err)
}
if _, ok := managerA.GetRole(roleID); !ok {
t.Fatalf("expected role %s in %s", roleID, orgA)
}
if _, ok := managerB.GetRole(roleID); ok {
t.Fatalf("role %s leaked into %s", roleID, orgB)
}
}
func TestTenantRBACProvider_CachesManager(t *testing.T) {
baseDir := t.TempDir()
orgID := "cached-org"
createOrgDir(t, baseDir, orgID)
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
manager1, err := provider.GetManager(orgID)
if err != nil {
t.Fatalf("first GetManager(%s) failed: %v", orgID, err)
}
manager2, err := provider.GetManager(orgID)
if err != nil {
t.Fatalf("second GetManager(%s) failed: %v", orgID, err)
}
if sqliteManagerPointer(t, manager1) != sqliteManagerPointer(t, manager2) {
t.Fatalf("expected cached manager instance for org %s", orgID)
}
}
func TestTenantRBACProvider_RemoveTenant(t *testing.T) {
baseDir := t.TempDir()
orgID := "remove-org"
createOrgDir(t, baseDir, orgID)
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
manager1, err := provider.GetManager(orgID)
if err != nil {
t.Fatalf("initial GetManager(%s) failed: %v", orgID, err)
}
firstPtr := sqliteManagerPointer(t, manager1)
if err := provider.RemoveTenant(orgID); err != nil {
t.Fatalf("RemoveTenant(%s) failed: %v", orgID, err)
}
manager2, err := provider.GetManager(orgID)
if err != nil {
t.Fatalf("GetManager(%s) after remove failed: %v", orgID, err)
}
secondPtr := sqliteManagerPointer(t, manager2)
if firstPtr == secondPtr {
t.Fatalf("expected a new manager instance after RemoveTenant(%s)", orgID)
}
}
func TestTenantRBACProvider_Close(t *testing.T) {
baseDir := t.TempDir()
createOrgDir(t, baseDir, "org-a")
createOrgDir(t, baseDir, "org-b")
provider := NewTenantRBACProvider(baseDir)
if _, err := provider.GetManager("default"); err != nil {
t.Fatalf("GetManager(default) failed: %v", err)
}
if _, err := provider.GetManager("org-a"); err != nil {
t.Fatalf("GetManager(org-a) failed: %v", err)
}
if _, err := provider.GetManager("org-b"); err != nil {
t.Fatalf("GetManager(org-b) failed: %v", err)
}
if err := provider.Close(); err != nil {
t.Fatalf("Close() failed: %v", err)
}
if err := provider.Close(); err != nil {
t.Fatalf("second Close() failed: %v", err)
}
}
func TestTenantRBACProvider_InvalidOrgIDsRejected(t *testing.T) {
baseDir := t.TempDir()
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
invalidIDs := []string{
".",
"..",
"../evil",
"evil/../org",
"org one",
"org\tone",
"org\none",
"org\\one",
"org:one",
strings.Repeat("x", 65),
}
for _, orgID := range invalidIDs {
if _, err := provider.GetManager(orgID); err == nil {
t.Fatalf("expected invalid orgID %q to be rejected", orgID)
}
}
if len(provider.managers) != 0 {
t.Fatalf("expected no managers cached for invalid org IDs, got %d", len(provider.managers))
}
}
func assertBuiltInRolesPresent(t *testing.T, manager auth.ExtendedManager) {
t.Helper()
roles := manager.GetRoles()
if len(roles) < 4 {
t.Fatalf("expected at least 4 roles, got %d", len(roles))
}
roleSet := make(map[string]struct{}, len(roles))
for _, role := range roles {
roleSet[role.ID] = struct{}{}
}
required := []string{
auth.RoleAdmin,
auth.RoleOperator,
auth.RoleViewer,
auth.RoleAuditor,
}
for _, roleID := range required {
if _, ok := roleSet[roleID]; !ok {
t.Fatalf("missing built-in role %q", roleID)
}
}
}
func createOrgDir(t *testing.T, baseDir, orgID string) {
t.Helper()
orgDir := filepath.Join(baseDir, "orgs", orgID)
if err := os.MkdirAll(orgDir, 0700); err != nil {
t.Fatalf("failed to create org dir %s: %v", orgDir, err)
}
}
func sqliteManagerPointer(t *testing.T, manager auth.ExtendedManager) *auth.SQLiteManager {
t.Helper()
sqliteManager, ok := manager.(*auth.SQLiteManager)
if !ok {
t.Fatalf("expected *auth.SQLiteManager, got %T", manager)
}
return sqliteManager
}
// PeekManager is the read-only accessor used by background readers such as the
// usage telemetry snapshot. It must never provision a store, or a periodic read
// would create RBAC state for every org that has never used RBAC.
func TestTenantRBACProvider_PeekManagerDoesNotProvision(t *testing.T) {
baseDir := t.TempDir()
provider := NewTenantRBACProvider(baseDir)
t.Cleanup(func() {
if err := provider.Close(); err != nil {
t.Errorf("cleanup close failed: %v", err)
}
})
if manager, ok := provider.PeekManager("default"); ok || manager != nil {
t.Fatalf("PeekManager returned a manager before one was created: ok=%v manager=%v", ok, manager != nil)
}
if got := provider.ManagerCount(); got != 0 {
t.Fatalf("PeekManager provisioned %d manager(s); it must be side-effect free", got)
}
created, err := provider.GetManager("default")
if err != nil {
t.Fatalf("GetManager(default) failed: %v", err)
}
peeked, ok := provider.PeekManager("default")
if !ok || peeked == nil {
t.Fatal("PeekManager did not return the existing manager")
}
if peeked != created {
t.Fatal("PeekManager returned a different manager than GetManager cached")
}
if got := provider.ManagerCount(); got != 1 {
t.Fatalf("manager count = %d, want 1", got)
}
}
// A nil provider must be safe: the telemetry snapshot runs before every
// dependency is guaranteed to be wired.
func TestTenantRBACProvider_PeekManagerNilProviderIsSafe(t *testing.T) {
var provider *TenantRBACProvider
if manager, ok := provider.PeekManager("default"); ok || manager != nil {
t.Fatalf("nil provider must report no manager: ok=%v manager=%v", ok, manager != nil)
}
}