V3 S1-S2 : corbeille + versions + extract générique
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).
This commit is contained in:
@@ -0,0 +1,364 @@
|
||||
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")
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user