129 lines
3.9 KiB
Go
129 lines
3.9 KiB
Go
package storage
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestTrash(t *testing.T) {
|
|
main := newStore(t)
|
|
sp := NewSpaces(main)
|
|
u, err := sp.For("alice")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
main.Write("d/a.excalidraw", []byte(doc), "", true)
|
|
main.Write("d/b.excalidraw", []byte(doc), "", true)
|
|
u.Write(".perso/p.excalidraw", []byte(doc), "", true)
|
|
if err := u.EditTags([]string{"d/a.excalidraw"}, []string{"NSX"}, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for _, p := range []string{"d/a.excalidraw", ".perso/p.excalidraw"} {
|
|
if err := u.Delete(p, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := u.Delete("d", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
root, _ := u.List("")
|
|
if len(root) < 3 || root[2].Special != "poubelle" || root[2].Count != 3 {
|
|
t.Fatalf("racine = %+v", root)
|
|
}
|
|
items, err := u.List(TrashPrefix)
|
|
if err != nil || len(items) != 3 {
|
|
t.Fatalf("poubelle = %+v, %v", items, err)
|
|
}
|
|
// Plus récent en premier : le dossier d, puis p, puis a.
|
|
if items[0].Name != "d" || !items[0].IsDir || items[0].Origin != "d" || items[0].By != "alice" ||
|
|
items[1].Origin != ".perso/p.excalidraw" || items[2].Origin != "d/a.excalidraw" {
|
|
t.Fatalf("poubelle = %+v", items)
|
|
}
|
|
// Les éléments de la poubelle ne s'ouvrent pas.
|
|
if _, _, err := u.Read(items[2].Path); err == nil {
|
|
t.Fatal("lecture dans la poubelle acceptée")
|
|
}
|
|
|
|
// a revient dans d (recréé), avec son tag.
|
|
res := u.RestoreTrash([]string{items[2].Path})
|
|
if res[0].Error != "" || res[0].To != "d/a.excalidraw" {
|
|
t.Fatalf("restauration = %+v", res)
|
|
}
|
|
if l, _ := u.List("d"); len(l) != 1 || len(l[0].Tags) != 1 {
|
|
t.Fatalf("d = %+v", l)
|
|
}
|
|
// Le dossier d revient sous un autre nom, la place étant prise.
|
|
res = u.RestoreTrash([]string{items[0].Path})
|
|
if res[0].Error != "" || res[0].To != "d (restauré)" {
|
|
t.Fatalf("restauration = %+v", res)
|
|
}
|
|
if l, _ := u.List("d (restauré)"); len(l) != 1 || l[0].Name != "b.excalidraw" {
|
|
t.Fatalf("d (restauré) = %+v", l)
|
|
}
|
|
|
|
// Suppression définitive, puis poubelle vide.
|
|
if err := u.Delete(items[1].Path, false); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if l, _ := u.Trash(); len(l) != 0 {
|
|
t.Fatalf("poubelle = %+v", l)
|
|
}
|
|
if err := u.Delete(TrashPrefix+"/c-x", false); !errors.Is(err, ErrInvalidPath) {
|
|
t.Fatalf("élément inconnu : %v", err)
|
|
}
|
|
|
|
// Vider la poubelle.
|
|
u.Delete("d/a.excalidraw", false)
|
|
if err := u.Delete(TrashPrefix, true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if main.TrashCount() != 0 {
|
|
t.Fatal("poubelle non vidée")
|
|
}
|
|
}
|
|
|
|
func TestTrashPurge(t *testing.T) {
|
|
main := newStore(t)
|
|
sp := NewSpaces(main)
|
|
u, _ := sp.For("bob")
|
|
main.Write("old.excalidraw", []byte(doc), "", true)
|
|
main.Write("new.excalidraw", []byte(doc), "", true)
|
|
u.Write(".perso/old.excalidraw", []byte(doc), "", true)
|
|
u.Delete("old.excalidraw", false)
|
|
u.Delete(".perso/old.excalidraw", false)
|
|
// Vieillit les deux entrées de 10 jours.
|
|
for _, st := range []*Store{main, u.home} {
|
|
items, _ := st.TrashItems()
|
|
old := time.Now().UTC().Add(-240 * time.Hour).Format(trashLayout)
|
|
if err := os.Rename(st.trashAbs(items[0].ID), st.trashAbs(old)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
u.Delete("new.excalidraw", false)
|
|
|
|
// Sans durée de conservation, rien n'est purgé.
|
|
if err := sp.PurgeTrash(); err != nil || main.TrashCount() != 2 || u.home.TrashCount() != 1 {
|
|
t.Fatalf("purge sans durée : %v", err)
|
|
}
|
|
if _, err := main.WriteTrashDays(-1); err == nil {
|
|
t.Fatal("durée négative acceptée")
|
|
}
|
|
if st, err := main.WriteTrashDays(7); err != nil || st.TrashDays != 7 {
|
|
t.Fatalf("WriteTrashDays = %+v, %v", st, err)
|
|
}
|
|
if err := sp.PurgeTrash(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if main.TrashCount() != 1 || u.home.TrashCount() != 0 {
|
|
t.Fatalf("après purge : %d / %d", main.TrashCount(), u.home.TrashCount())
|
|
}
|
|
// L'historique de l'élément purgé disparaît avec lui.
|
|
if des, _ := os.ReadDir(filepath.Join(main.root, trashDir)); len(des) != 1 {
|
|
t.Fatalf("corbeille = %v", des)
|
|
}
|
|
}
|