425 lines
12 KiB
Go
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)
|
|
}
|
|
}
|