Files
Mediarr/acl/permissions_test.go
T
2026-11-14 10:53:22 +01:00

425 lines
12 KiB
Go

package acl
import (
"context"
"errors"
"testing"
"time"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
)
func TestPermissionValidAndHas(t *testing.T) {
if !PermissionAll.Valid() {
t.Fatal("PermissionAll devrait être valide")
}
if Permission(0).Valid() {
t.Fatal("Permission(0) devrait être invalide")
}
if (PermissionAll + 1).Valid() {
t.Fatal("PermissionAll+1 devrait être invalide")
}
if !PermissionAdmin.Has(PermissionRead) {
t.Fatal("PermissionAdmin devrait impliquer PermissionRead")
}
if !PermissionAll.Has(PermissionManage) {
t.Fatal("PermissionAll devrait contenir PermissionManage")
}
if PermissionRead.Has(PermissionWrite) {
t.Fatal("PermissionRead ne devrait pas impliquer PermissionWrite")
}
if PermissionAdmin.Has(PermissionAll + 1) {
t.Fatal("une permission requise invalide ne devrait pas être satisfaite")
}
if !Permission(0).Has(0) {
t.Fatal("aucune permission requise devrait toujours être satisfaite")
}
}
func TestOwnerHasAllPermissions(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
permissions, err := service.Effective(ctx, owner.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionAll {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionAll)
}
allowed, err := service.Can(ctx, owner.ID, documentID, PermissionAdmin)
if err != nil {
t.Fatalf("Can : %v", err)
}
if !allowed {
t.Fatal("le propriétaire devrait avoir PermissionAdmin")
}
}
func TestEffectiveDirectAndGroup(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
group := mustGroup(t, service, "family")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
addMember(t, service, group.ID, alice.ID)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: group.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(groupe) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(alice) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionRead|PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionRead|PermissionWrite)
}
}
func TestEffectiveDisabledGroup(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
group := mustGroup(t, service, "family")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
addMember(t, service, group.ID, alice.ID)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: group.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
disablePrincipal(t, service, group.ID)
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveAdminImpliesAll(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionAdmin,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
allowed, err := service.Can(ctx, alice.ID, documentID, PermissionRead|PermissionDelete)
if err != nil {
t.Fatalf("Can : %v", err)
}
if !allowed {
t.Fatal("PermissionAdmin devrait impliquer toutes les permissions")
}
}
func TestEffectiveInheritance(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
folder := mustDocument(t, service, owner.ID, &root, "Folder", "", true)
child := mustDocument(t, service, owner.ID, &folder, "Child", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(root) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: folder,
SubjectID: alice.ID,
Permissions: PermissionWrite,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(folder) : %v", err)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: child,
SubjectID: alice.ID,
Permissions: PermissionDelete,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(child) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, child)
if err != nil {
t.Fatalf("Effective : %v", err)
}
expected := PermissionRead | PermissionWrite | PermissionDelete
if permissions != expected {
t.Fatalf("permissions = %d, attendu %d", permissions, expected)
}
}
func TestEffectivePropagationDisabled(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
child := mustDocument(t, service, owner.ID, &root, "Child", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: false,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, child)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveAclInheritBreak(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
root := mustDocument(t, service, owner.ID, nil, "Root", "", true)
middle := mustDocument(t, service, owner.ID, &root, "Middle", "", false)
leaf := mustDocument(t, service, owner.ID, &middle, "Leaf", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: root,
SubjectID: alice.ID,
Permissions: PermissionRead,
Propagate: true,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(root) : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, leaf)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
if _, err := service.Grant(ctx, GrantParams{
DocumentID: leaf,
SubjectID: alice.ID,
Permissions: PermissionWrite,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant(leaf) : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, leaf)
if err != nil {
t.Fatalf("Effective après grant direct : %v", err)
}
if permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionWrite)
}
}
func TestEffectiveExpiredAndRevoked(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
expiredAt := time.Now().Add(-time.Hour)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
ExpiresAt: &expiredAt,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant expiré : %v", err)
}
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
future := time.Now().Add(time.Hour)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionWrite,
ExpiresAt: &future,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant futur : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != PermissionWrite {
t.Fatalf("permissions = %d, attendu %d", permissions, PermissionWrite)
}
if err := service.Revoke(ctx, documentID, alice.ID); err != nil {
t.Fatalf("Revoke : %v", err)
}
permissions, err = service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective après révocation : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveVisibility(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
guest := mustPrincipal(t, service, identity.KindGuest, "jean")
system := mustPrincipal(t, service, identity.KindSystem, "system-test")
clusterDoc := mustDocument(t, service, owner.ID, nil, "Cluster", document.VisibilityCluster, true)
privateDoc := mustDocument(t, service, owner.ID, nil, "Private", document.VisibilityPrivate, true)
publicDoc := mustDocument(t, service, owner.ID, nil, "Public", document.VisibilityPublic, true)
federatedDoc := mustDocument(t, service, owner.ID, nil, "Federated", document.VisibilityFederated, true)
cases := []struct {
name string
principalID ident.UUID
documentID ident.UUID
expected Permission
}{
{"cluster/user", alice.ID, clusterDoc, PermissionRead},
{"cluster/guest", guest.ID, clusterDoc, PermissionRead},
{"cluster/system", system.ID, clusterDoc, 0},
{"private/user", alice.ID, privateDoc, 0},
{"public/system", system.ID, publicDoc, PermissionRead},
{"federated/user", alice.ID, federatedDoc, 0},
}
for _, testCase := range cases {
permissions, err := service.Effective(ctx, testCase.principalID, testCase.documentID)
if err != nil {
t.Fatalf("%s : Effective : %v", testCase.name, err)
}
if permissions != testCase.expected {
t.Fatalf("%s : permissions = %d, attendu %d", testCase.name, permissions, testCase.expected)
}
}
}
func TestEffectiveInactivePrincipal(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
alice := mustUser(t, service, "alice")
documentID := mustDocument(t, service, owner.ID, nil, "Photos", "", true)
if _, err := service.Grant(ctx, GrantParams{
DocumentID: documentID,
SubjectID: alice.ID,
Permissions: PermissionRead,
GrantedBy: owner.ID,
}); err != nil {
t.Fatalf("Grant : %v", err)
}
disablePrincipal(t, service, alice.ID)
permissions, err := service.Effective(ctx, alice.ID, documentID)
if err != nil {
t.Fatalf("Effective : %v", err)
}
if permissions != 0 {
t.Fatalf("permissions = %d, attendu 0", permissions)
}
}
func TestEffectiveMissingDocument(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
alice := mustUser(t, service, "alice")
missing, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
_, err = service.Effective(ctx, alice.ID, missing)
if !errors.Is(err, ErrDocumentNotFound) {
t.Fatalf("erreur = %v, attendu ErrDocumentNotFound", err)
}
}