Files
2026-11-16 11:03:48 +01:00

426 lines
13 KiB
Go
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package document
import (
"bytes"
"context"
"encoding/hex"
"errors"
"testing"
)
func TestRename(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
renamed, err := service.Rename(ctx, owner.ID, folder.ID, "Aventure")
if err != nil {
t.Fatalf("Rename : %v", err)
}
if renamed.Name != "Aventure" || renamed.NameKey != "aventure" {
t.Fatalf("nom = %q/%q, attendu Aventure/aventure", renamed.Name, renamed.NameKey)
}
if renamed.Rev != folder.Rev+1 {
t.Fatalf("rev = %d, attendu %d", renamed.Rev, folder.Rev+1)
}
if _, err := service.Rename(ctx, owner.ID, folder.ID, "a/b"); !errors.Is(err, ErrInvalidName) {
t.Fatalf("erreur = %v, attendu ErrInvalidName", err)
}
other := mustFolder(t, service, owner, library.ID, "Drame")
if _, err := service.Rename(ctx, owner.ID, other.ID, "aventure"); !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
if _, err := service.Trash(ctx, owner.ID, other.ID); err != nil {
t.Fatalf("Trash : %v", err)
}
if _, err := service.Rename(ctx, owner.ID, other.ID, "Autre"); !errors.Is(err, ErrDocumentDeleted) {
t.Fatalf("erreur = %v, attendu ErrDocumentDeleted", err)
}
}
func TestMove(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
libraryA := mustLibrary(t, service, owner, "Photos")
libraryB := mustLibrary(t, service, owner, "Films")
folder := mustFolder(t, service, owner, libraryA.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
moved, err := service.Move(ctx, owner.ID, folder.ID, libraryB.ID)
if err != nil {
t.Fatalf("Move : %v", err)
}
if moved.ParentID == nil || *moved.ParentID != libraryB.ID {
t.Fatalf("parent = %v, attendu %s", moved.ParentID, libraryB.ID)
}
if moved.Path != libraryB.Path+hex.EncodeToString(folder.ID[:])+"/" {
t.Fatalf("path = %q", moved.Path)
}
if moved.Depth != 1 {
t.Fatalf("depth = %d, attendu 1", moved.Depth)
}
if moved.Rev != folder.Rev+1 {
t.Fatalf("rev = %d, attendu %d", moved.Rev, folder.Rev+1)
}
movedChild, err := service.Get(ctx, owner.ID, child.ID)
if err != nil {
t.Fatalf("Get(child) : %v", err)
}
if movedChild.ParentID == nil || *movedChild.ParentID != folder.ID {
t.Fatalf("parent enfant = %v, attendu %s", movedChild.ParentID, folder.ID)
}
if movedChild.Path != moved.Path+hex.EncodeToString(child.ID[:])+"/" {
t.Fatalf("path enfant = %q", movedChild.Path)
}
if movedChild.Depth != 2 {
t.Fatalf("depth enfant = %d, attendu 2", movedChild.Depth)
}
if movedChild.Rev != child.Rev+1 {
t.Fatalf("rev enfant = %d, attendu %d", movedChild.Rev, child.Rev+1)
}
children, err := service.ListChildren(ctx, owner.ID, libraryB.ID)
if err != nil {
t.Fatalf("ListChildren : %v", err)
}
if len(children) != 1 || children[0].ID != folder.ID {
t.Fatalf("enfants = %+v", children)
}
}
func TestMoveRootRejected(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
other := mustLibrary(t, service, owner, "Films")
_, err := service.Move(ctx, owner.ID, library.ID, other.ID)
if !errors.Is(err, ErrCannotMoveRoot) {
t.Fatalf("erreur = %v, attendu ErrCannotMoveRoot", err)
}
}
func TestMoveIntoDescendantRejected(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
_, err := service.Move(ctx, owner.ID, folder.ID, child.ID)
if !errors.Is(err, ErrInvalidMove) {
t.Fatalf("erreur = %v, attendu ErrInvalidMove", err)
}
}
func TestMoveIntoItselfRejected(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
_, err := service.Move(ctx, owner.ID, folder.ID, folder.ID)
if !errors.Is(err, ErrInvalidMove) {
t.Fatalf("erreur = %v, attendu ErrInvalidMove", err)
}
}
func TestMoveToInvalidParentRejected(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
movie := mustKindDocument(t, service, owner, library, "movie", "Film")
_, err := service.Move(ctx, owner.ID, folder.ID, movie.ID)
if !errors.Is(err, ErrInvalidParent) {
t.Fatalf("erreur = %v, attendu ErrInvalidParent", err)
}
}
func TestMoveToSameParentIsNoop(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
moved, err := service.Move(ctx, owner.ID, folder.ID, library.ID)
if err != nil {
t.Fatalf("Move : %v", err)
}
if moved.Rev != folder.Rev {
t.Fatalf("rev = %d, attendu %d", moved.Rev, folder.Rev)
}
}
func TestMoveDuplicateNameRejected(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
libraryA := mustLibrary(t, service, owner, "Photos")
libraryB := mustLibrary(t, service, owner, "Films")
folder := mustFolder(t, service, owner, libraryA.ID, "Action")
mustFolder(t, service, owner, libraryB.ID, "action")
_, err := service.Move(ctx, owner.ID, folder.ID, libraryB.ID)
if !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
func TestMoveRejectsDeletedDocument(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
libraryA := mustLibrary(t, service, owner, "Photos")
libraryB := mustLibrary(t, service, owner, "Films")
folder := mustFolder(t, service, owner, libraryA.ID, "Action")
if _, err := service.Trash(ctx, owner.ID, folder.ID); err != nil {
t.Fatalf("Trash : %v", err)
}
_, err := service.Move(ctx, owner.ID, folder.ID, libraryB.ID)
if !errors.Is(err, ErrDocumentDeleted) {
t.Fatalf("erreur = %v, attendu ErrDocumentDeleted", err)
}
}
func TestMoveRejectsDeletedParent(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
libraryA := mustLibrary(t, service, owner, "Photos")
libraryB := mustLibrary(t, service, owner, "Films")
folder := mustFolder(t, service, owner, libraryA.ID, "Action")
if _, err := service.Trash(ctx, owner.ID, libraryB.ID); err != nil {
t.Fatalf("Trash : %v", err)
}
_, err := service.Move(ctx, owner.ID, folder.ID, libraryB.ID)
if !errors.Is(err, ErrParentDeleted) {
t.Fatalf("erreur = %v, attendu ErrParentDeleted", err)
}
}
func TestTrashAndRestore(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
trashed, err := service.Trash(ctx, owner.ID, folder.ID)
if err != nil {
t.Fatalf("Trash : %v", err)
}
if trashed.DeletedAt == nil {
t.Fatal("deleted_at non renseigné")
}
if trashed.DeletedBy == nil || *trashed.DeletedBy != owner.ID {
t.Fatalf("deleted_by = %v, attendu %s", trashed.DeletedBy, owner.ID)
}
if len(trashed.TrashBatch) == 0 {
t.Fatal("trash_batch non renseigné")
}
trashedChild, err := service.Get(ctx, owner.ID, child.ID)
if err != nil {
t.Fatalf("Get(child) : %v", err)
}
if trashedChild.DeletedAt == nil {
t.Fatal("enfant non supprimé")
}
if !bytes.Equal(trashedChild.TrashBatch, trashed.TrashBatch) {
t.Fatal("l’enfant n’appartient pas au même lot de corbeille")
}
children, err := service.ListChildren(ctx, owner.ID, library.ID)
if err != nil {
t.Fatalf("ListChildren : %v", err)
}
if len(children) != 0 {
t.Fatalf("enfants = %d, attendu 0", len(children))
}
restored, err := service.Restore(ctx, owner.ID, folder.ID)
if err != nil {
t.Fatalf("Restore : %v", err)
}
if restored.DeletedAt != nil || restored.DeletedBy != nil || len(restored.TrashBatch) != 0 {
t.Fatalf("document restauré avec des champs de corbeille : %+v", restored)
}
restoredChild, err := service.Get(ctx, owner.ID, child.ID)
if err != nil {
t.Fatalf("Get(child restauré) : %v", err)
}
if restoredChild.DeletedAt != nil {
t.Fatal("enfant non restauré")
}
children, err = service.ListChildren(ctx, owner.ID, library.ID)
if err != nil {
t.Fatalf("ListChildren après restauration : %v", err)
}
if len(children) != 1 || children[0].ID != folder.ID {
t.Fatalf("enfants après restauration = %+v", children)
}
}
func TestRestoreNonDeletedIsNoop(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
restored, err := service.Restore(ctx, owner.ID, library.ID)
if err != nil {
t.Fatalf("Restore : %v", err)
}
if restored.ID != library.ID || restored.DeletedAt != nil {
t.Fatalf("document = %+v", restored)
}
}
func TestTrashAlreadyDeleted(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
if _, err := service.Trash(ctx, owner.ID, library.ID); err != nil {
t.Fatalf("Trash : %v", err)
}
if _, err := service.Trash(ctx, owner.ID, library.ID); !errors.Is(err, ErrDocumentDeleted) {
t.Fatalf("erreur = %v, attendu ErrDocumentDeleted", err)
}
}
func TestRestoreConflict(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
if _, err := service.Trash(ctx, owner.ID, folder.ID); err != nil {
t.Fatalf("Trash : %v", err)
}
mustFolder(t, service, owner, library.ID, "Action")
if _, err := service.Restore(ctx, owner.ID, folder.ID); !errors.Is(err, ErrNameTaken) {
t.Fatalf("erreur = %v, attendu ErrNameTaken", err)
}
}
func TestRestoreParentDeletedInDifferentBatch(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
if _, err := service.Trash(ctx, owner.ID, child.ID); err != nil {
t.Fatalf("Trash(child) : %v", err)
}
if _, err := service.Trash(ctx, owner.ID, folder.ID); err != nil {
t.Fatalf("Trash(folder) : %v", err)
}
if _, err := service.Restore(ctx, owner.ID, child.ID); !errors.Is(err, ErrParentDeleted) {
t.Fatalf("erreur = %v, attendu ErrParentDeleted", err)
}
}
func TestRestoreRejectsDeletedAncestor(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
folder := mustFolder(t, service, owner, library.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
if _, err := service.Trash(ctx, owner.ID, folder.ID); err != nil {
t.Fatalf("Trash(folder) : %v", err)
}
if _, err := service.Trash(ctx, owner.ID, library.ID); err != nil {
t.Fatalf("Trash(library) : %v", err)
}
if _, err := service.Restore(ctx, owner.ID, child.ID); !errors.Is(err, ErrParentDeleted) {
t.Fatalf("erreur = %v, attendu ErrParentDeleted", err)
}
}
func TestMoveUpdatesTrashedDescendants(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
libraryA := mustLibrary(t, service, owner, "Photos")
libraryB := mustLibrary(t, service, owner, "Films")
folder := mustFolder(t, service, owner, libraryA.ID, "Action")
child := mustFolder(t, service, owner, folder.ID, "Extras")
if _, err := service.Trash(ctx, owner.ID, child.ID); err != nil {
t.Fatalf("Trash(child) : %v", err)
}
moved, err := service.Move(ctx, owner.ID, folder.ID, libraryB.ID)
if err != nil {
t.Fatalf("Move : %v", err)
}
restored, err := service.Restore(ctx, owner.ID, child.ID)
if err != nil {
t.Fatalf("Restore(child) : %v", err)
}
if restored.Path != moved.Path+hex.EncodeToString(child.ID[:])+"/" {
t.Fatalf("path = %q, attendu %q", restored.Path, moved.Path+hex.EncodeToString(child.ID[:])+"/")
}
if restored.Depth != 2 {
t.Fatalf("depth = %d, attendu 2", restored.Depth)
}
}
func TestSetMetadata(t *testing.T) {
service := newTestService(t)
ctx := context.Background()
owner := mustUser(t, service, "owner")
library := mustLibrary(t, service, owner, "Photos")
video := mustKindDocument(t, service, owner, library, KindVideo, "film.mkv")
updated, err := service.SetMetadata(ctx, owner.ID, video.ID, `{"duration_ms":120000}`)
if err != nil {
t.Fatalf("SetMetadata : %v", err)
}
if updated.Metadata != `{"duration_ms":120000}` {
t.Fatalf("metadata = %q", updated.Metadata)
}
if updated.Rev != video.Rev+1 {
t.Fatalf("rev = %d, attendu %d", updated.Rev, video.Rev+1)
}
if _, err := service.SetMetadata(ctx, owner.ID, video.ID, "{"); !errors.Is(err, ErrInvalidMetadata) {
t.Fatalf("metadata invalide : erreur = %v, attendu ErrInvalidMetadata", err)
}
}