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") } }