426 lines
13 KiB
Go
426 lines
13 KiB
Go
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)
|
||
}
|
||
}
|