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) } }