S1 filet (backend + mobile) : corbeille 30j (deleted_at réutilisé, trash/restore récursifs, purge auto serveur), versions N=3 à chaque overwrite, ops outbox trash/restore/purge (delete legacy mappé), Room v19 (trashed_at), Deleters -> trash, écran Corbeille, walk guards. S2 extract (backend) : package extract (règles FR stdlib, corpus testé), resource_facts 000019 (origin auto/user), hook worker OCR + backfill boot, GET /files/:id/facts (viewer+). Contrat docs/api-v1.md étendu, V3.md (vision + plan).
365 lines
12 KiB
Go
365 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/kazier/backend/repository"
|
|
)
|
|
|
|
func mustInsertFile(t *testing.T, s *Resources, userID, name string) string {
|
|
t.Helper()
|
|
id := repository.NewID()
|
|
if err := s.Repository.Resources.InsertFile(userID, id, name, "", 0, nil, nil); err != nil {
|
|
t.Fatalf("insert file %q: %v", name, err)
|
|
}
|
|
return id
|
|
}
|
|
|
|
func TestTrashRestoreRoundtrip(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-roundtrip")
|
|
fileID := mustInsertFile(t, s, userID, "acte.pdf")
|
|
|
|
if _, err := s.Trash(userID, fileID); err != nil {
|
|
t.Fatalf("trash: %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("GetFile après trash : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
items, total, err := s.ListTrashed(userID, 1, 50)
|
|
if err != nil {
|
|
t.Fatalf("list trashed: %v", err)
|
|
}
|
|
if total != 1 || len(items) != 1 || items[0].ID != fileID {
|
|
t.Fatalf("corbeille: total=%d items=%+v", total, items)
|
|
}
|
|
|
|
if _, err := s.Restore(userID, fileID); err != nil {
|
|
t.Fatalf("restore: %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
|
|
t.Fatalf("GetFile après restore: %v", err)
|
|
}
|
|
if _, total, err := s.ListTrashed(userID, 1, 50); err != nil || total != 0 {
|
|
t.Fatalf("corbeille après restore: total=%d err=%v", total, err)
|
|
}
|
|
}
|
|
|
|
func TestTrashSubtree(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-subtree")
|
|
folderID := repository.NewID()
|
|
if err := s.Repository.Resources.InsertFolder(userID, folderID, "Dossier", ""); err != nil {
|
|
t.Fatalf("insert folder: %v", err)
|
|
}
|
|
childID := repository.NewID()
|
|
if err := s.Repository.Resources.InsertFile(userID, childID, "enfant.txt", folderID, 0, nil, nil); err != nil {
|
|
t.Fatalf("insert child: %v", err)
|
|
}
|
|
|
|
if _, err := s.Trash(userID, folderID); err != nil {
|
|
t.Fatalf("trash folder: %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, childID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("enfant après trash dossier : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 2 {
|
|
t.Fatalf("corbeille subtree: total=%d, attendu 2", total)
|
|
}
|
|
|
|
if _, err := s.Restore(userID, folderID); err != nil {
|
|
t.Fatalf("restore folder: %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, childID); err != nil {
|
|
t.Fatalf("enfant après restore dossier: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTrashForeignIsNotFound(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
owner := mustCreateUser(t, s.Repository, "trash-owner")
|
|
other := mustCreateUser(t, s.Repository, "trash-other")
|
|
fileID := mustInsertFile(t, s, owner, "secret.pdf")
|
|
|
|
if _, err := s.Trash(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("trash autrui : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
if _, err := s.Restore(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("restore autrui : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
if _, err := s.Purge(other, fileID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("purge autrui : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(owner, fileID); err != nil {
|
|
t.Fatalf("fichier owner intact: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestDeleteLegacyMapsToTrash(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-legacy")
|
|
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000001")
|
|
fileID := mustInsertFile(t, s, userID, "legacy.pdf")
|
|
|
|
// delete_resource → trash (restaurable, visible en corbeille).
|
|
res, err := s.ApplyBatch(userID, device, []SyncOperation{
|
|
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("apply: %v", err)
|
|
}
|
|
if res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("résultat inattendu: %+v", res)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, fileID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("GetFile après delete legacy : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
|
|
t.Fatalf("delete legacy doit apparaître en corbeille")
|
|
}
|
|
|
|
// Re-delete (déjà trashé) → no-op idempotent, pas NOT_FOUND.
|
|
res, err = s.ApplyBatch(userID, device, []SyncOperation{
|
|
syncOp(repository.NewID(), fileID, OpDeleteResource, "file", map[string]any{}),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("re-apply: %v", err)
|
|
}
|
|
if res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("re-delete trashé doit être no-op: %+v", res)
|
|
}
|
|
}
|
|
|
|
func TestSyncOpsTrashRestorePurge(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-ops")
|
|
other := mustCreateUser(t, s.Repository, "trash-ops-other")
|
|
device := mustRegisterDevice(t, s.Repository, "b0000000000000000000000000000002")
|
|
fileID := mustInsertFile(t, s, userID, "ops.pdf")
|
|
foreignID := mustInsertFile(t, s, other, "foreign.pdf")
|
|
|
|
apply := func(op, resID string) SyncResult {
|
|
t.Helper()
|
|
res, err := s.ApplyBatch(userID, device, []SyncOperation{
|
|
syncOp(repository.NewID(), resID, op, "file", map[string]any{}),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("apply %s: %v", op, err)
|
|
}
|
|
return res
|
|
}
|
|
|
|
if res := apply(OpTrashResource, fileID); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("trash op: %+v", res)
|
|
}
|
|
// Trash d'autrui → halt NOT_FOUND.
|
|
if res := apply(OpTrashResource, foreignID); res.Failed == nil || res.Failed.Code != "NOT_FOUND" {
|
|
t.Fatalf("trash autrui doit halter NOT_FOUND: %+v", res)
|
|
}
|
|
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("restore op: %+v", res)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, fileID); err != nil {
|
|
t.Fatalf("fichier restauré via op: %v", err)
|
|
}
|
|
// Restore d'un live → no-op succès.
|
|
if res := apply(OpRestoreResource, fileID); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("restore live doit être no-op: %+v", res)
|
|
}
|
|
// Restore d'inexistant → no-op (convergence).
|
|
if res := apply(OpRestoreResource, repository.NewID()); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("restore inexistant doit être no-op: %+v", res)
|
|
}
|
|
// Purge d'un live → détruit.
|
|
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("purge op: %+v", res)
|
|
}
|
|
if owned, _ := s.Repo.ExistsOwnerAny(userID, fileID); owned {
|
|
t.Fatal("purge doit détruire la ligne")
|
|
}
|
|
// Purge d'inexistant → no-op.
|
|
if res := apply(OpPurgeResource, fileID); res.Applied != 1 || res.Failed != nil {
|
|
t.Fatalf("purge inexistant doit être no-op: %+v", res)
|
|
}
|
|
}
|
|
|
|
func TestPurgeRemovesPhysicalFiles(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-physical")
|
|
|
|
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("hello")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload: %v", err)
|
|
}
|
|
live := filepath.Join(s.UploadDir, userID, dto.ID+".txt")
|
|
if _, err := os.Stat(live); err != nil {
|
|
t.Fatalf("live absent: %v", err)
|
|
}
|
|
if _, err := s.Purge(userID, dto.ID); err != nil {
|
|
t.Fatalf("purge: %v", err)
|
|
}
|
|
if _, err := os.Stat(live); !os.IsNotExist(err) {
|
|
t.Fatalf("octets live doivent être supprimés: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUploadOverwriteCreatesVersionsCappedAt3(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-versions")
|
|
|
|
v1, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload v1: %v", err)
|
|
}
|
|
// Le premier upload (création) ne crée pas de version.
|
|
if vers, err := s.ListVersions(userID, v1.ID); err != nil || len(vers) != 0 {
|
|
t.Fatalf("création ne doit pas versionner: %+v %v", vers, err)
|
|
}
|
|
|
|
contents := []string{"BBBB", "CCCCC", "DDDDDD", "EEEEEEE"}
|
|
for i, c := range contents {
|
|
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte(c)), "", v1.ID)
|
|
if err != nil {
|
|
t.Fatalf("overwrite %d: %v", i, err)
|
|
}
|
|
if dto.Size != int64(len(c)) {
|
|
t.Fatalf("overwrite %d: taille=%d", i, dto.Size)
|
|
}
|
|
}
|
|
vers, err := s.ListVersions(userID, v1.ID)
|
|
if err != nil {
|
|
t.Fatalf("list versions: %v", err)
|
|
}
|
|
if len(vers) != 3 {
|
|
t.Fatalf("versions = %d, attendu 3 (plafond N=3)", len(vers))
|
|
}
|
|
// Les 3 conservées sont les plus récentes : AAA a été élaguée.
|
|
// Ordre décroissant : version_no 4,3,2 → tailles 6,5,4.
|
|
wantSizes := []int64{6, 5, 4}
|
|
for i, v := range vers {
|
|
if v.Size != wantSizes[i] {
|
|
t.Errorf("version[%d].size = %d, attendu %d", i, v.Size, wantSizes[i])
|
|
}
|
|
}
|
|
// 3 fichiers figés sur disque (AAA élaguée avec sa ligne).
|
|
verFiles, _ := filepath.Glob(filepath.Join(s.UploadDir, userID, ".versions", v1.ID+"_v*"))
|
|
if len(verFiles) != 3 {
|
|
t.Errorf("fichiers versionnés = %d, attendu 3 (%v)", len(verFiles), verFiles)
|
|
}
|
|
}
|
|
|
|
func TestRestoreVersion(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-restore-ver")
|
|
|
|
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload v1: %v", err)
|
|
}
|
|
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBBB")), "", dto.ID); err != nil {
|
|
t.Fatalf("overwrite: %v", err)
|
|
}
|
|
vers, err := s.ListVersions(userID, dto.ID)
|
|
if err != nil || len(vers) != 1 {
|
|
t.Fatalf("versions: %+v %v", vers, err)
|
|
}
|
|
|
|
restored, err := s.RestoreVersion(userID, dto.ID, vers[0].VersionNo)
|
|
if err != nil {
|
|
t.Fatalf("restore version: %v", err)
|
|
}
|
|
if restored.Size != 3 {
|
|
t.Fatalf("live restauré taille=%d, attendu 3", restored.Size)
|
|
}
|
|
raw, err := os.ReadFile(filepath.Join(s.UploadDir, userID, dto.ID+".txt"))
|
|
if err != nil {
|
|
t.Fatalf("read live: %v", err)
|
|
}
|
|
if string(raw) != "AAA" {
|
|
t.Fatalf("contenu live = %q, attendu AAA", raw)
|
|
}
|
|
// L'ancien actuel (BBBB) a été à son tour versionné.
|
|
vers2, err := s.ListVersions(userID, dto.ID)
|
|
if err != nil || len(vers2) != 2 {
|
|
t.Fatalf("versions après restore: %+v %v", vers2, err)
|
|
}
|
|
if _, err := s.RestoreVersion(userID, dto.ID, 999); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("restore version inconnue : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUploadToTrashedIsNotFound(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-upload-guard")
|
|
|
|
dto, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("AAA")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload: %v", err)
|
|
}
|
|
if _, err := s.Trash(userID, dto.ID); err != nil {
|
|
t.Fatalf("trash: %v", err)
|
|
}
|
|
if _, err := s.Upload(userID, multipartFileHeader(t, "doc.txt", []byte("BBB")), "", dto.ID); !errors.Is(err, repository.ErrNotFound) {
|
|
t.Fatalf("upload vers trashé : attendu NOT_FOUND, got %v", err)
|
|
}
|
|
}
|
|
|
|
func backdateTrash(t *testing.T, s *Resources, resourceID string, ago time.Duration) {
|
|
t.Helper()
|
|
if _, err := s.Repository.Resources.DB.Exec(
|
|
`UPDATE resources SET deleted_at = NOW() - ($1 || ' seconds')::interval WHERE resource_id = $2`,
|
|
int(ago.Seconds()), resourceID,
|
|
); err != nil {
|
|
t.Fatalf("backdate: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPurgeExpiredTrash(t *testing.T) {
|
|
s := newServiceStore(t)
|
|
userID := mustCreateUser(t, s.Repository, "trash-expire")
|
|
|
|
old, err := s.Upload(userID, multipartFileHeader(t, "vieux.txt", []byte("old")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload vieux: %v", err)
|
|
}
|
|
fresh, err := s.Upload(userID, multipartFileHeader(t, "frais.txt", []byte("new")), "", "")
|
|
if err != nil {
|
|
t.Fatalf("upload frais: %v", err)
|
|
}
|
|
if _, err := s.Trash(userID, old.ID); err != nil {
|
|
t.Fatalf("trash vieux: %v", err)
|
|
}
|
|
if _, err := s.Trash(userID, fresh.ID); err != nil {
|
|
t.Fatalf("trash frais: %v", err)
|
|
}
|
|
backdateTrash(t, s, old.ID, 31*24*time.Hour)
|
|
|
|
n, err := s.PurgeExpiredTrash(TrashRetention)
|
|
if err != nil {
|
|
t.Fatalf("purge expired: %v", err)
|
|
}
|
|
if n != 1 {
|
|
t.Fatalf("purgés = %d, attendu 1", n)
|
|
}
|
|
if owned, _ := s.Repo.ExistsOwnerAny(userID, old.ID); owned {
|
|
t.Fatal("vieux doit être détruit")
|
|
}
|
|
if _, _, err := s.ListTrashed(userID, 1, 50); err != nil {
|
|
t.Fatalf("list: %v", err)
|
|
}
|
|
if _, err := s.Repo.GetFile(userID, fresh.ID); err == nil {
|
|
// Frais trashé mais pas expiré : invisible en lecture, présent en corbeille.
|
|
t.Fatal("frais doit rester trashé (invisible en lecture)")
|
|
}
|
|
if _, total, _ := s.ListTrashed(userID, 1, 50); total != 1 {
|
|
t.Fatalf("corbeille doit garder le frais: total=%d", total)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(s.UploadDir, userID, old.ID+".txt")); !os.IsNotExist(err) {
|
|
t.Fatal("octets du purgé doivent être supprimés")
|
|
}
|
|
}
|