add acl
This commit is contained in:
@@ -0,0 +1,424 @@
|
||||
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)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user