Files
upandown/internal/storage/storage_test.go
T
claude BotandClaude Opus 5.5 f8801f00f9 Lot 1 : catalogue PostgreSQL partagé pour les métadonnées et les partages
- Nouveau paquet internal/catalog : pool pgx, migrations SQL embarquées
  (sérialisées entre instances par verrou consultatif), transactions
  rejouées après conflit, interblocage ou bascule du primaire (pool vidé
  sur erreur de lecture seule ou de connexion). DSN multi-hôtes accepté
  (target_session_attrs=read-write) pour une future HA.
- Store.UseCatalog : tags, icônes, auteurs (item_meta) et liens de partage
  (shares) lus et écrits en base ; chaque modification se fait sous verrou
  consultatif par racine (« main », « home/<id> »), donc sans perte
  d'écriture entre instances. Sans DATABASE_URL, rien ne change (JSON).
- Reprise unique de .meta.json et .shares.json au premier branchement
  (table imports), fichiers renommés en *.imported.
- Serveur : DATABASE_URL / DATABASE_URL_FILE, DATABASE_WAIT (60 s).
- Compose : service postgres:16 sur un réseau interne dédié ; Traefik
  inchangé. Dockerfile : go.sum et téléchargement des modules.
- Tests : UPANDOWN_TEST_DATABASE_URL fait passer toute la suite storage par
  la base ; tests de partage entre deux instances et de reprise JSON.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
2026-11-20 17:20:16 +01:00

528 lines
16 KiB
Go

package storage
import (
"archive/zip"
"bytes"
"errors"
"image"
"image/color"
"image/png"
"io"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func newStore(t *testing.T) *Store {
t.Helper()
s, err := New(t.TempDir())
if err != nil {
t.Fatal(err)
}
attachTestCatalog(t, s)
return s
}
func put(t *testing.T, s *Store, p, content string, o PutOptions) Entry {
t.Helper()
e, err := s.Put(p, strings.NewReader(content), o)
if err != nil {
t.Fatalf("Put(%s) : %v", p, err)
}
return e
}
func read(t *testing.T, s *Store, p string) string {
t.Helper()
f, _, err := s.Open(p)
if err != nil {
t.Fatalf("Open(%s) : %v", p, err)
}
defer f.Close()
b, _ := io.ReadAll(f)
return string(b)
}
func TestCleanRejectsHiddenAndTraversal(t *testing.T) {
for _, bad := range []string{".trash", "a/.history/x", ".meta.json", "a/\x00b", `a\b`, "a/ b", strings.Repeat("x", 300), "a/\x01"} {
if _, err := Clean(bad); err == nil {
t.Errorf("Clean(%q) aurait dû échouer", bad)
}
}
if c, err := Clean("/a/../b//c/"); err != nil || c != "b/c" {
t.Errorf("Clean = %q, %v", c, err)
}
}
func TestPutOpenListAnyFileType(t *testing.T) {
s := newStore(t)
put(t, s, "docs/rapport.pdf", "%PDF-1.4", PutOptions{By: "alice"})
put(t, s, "docs/archive.tar.gz", "\x1f\x8b", PutOptions{})
put(t, s, "docs/sans-extension", "x", PutOptions{})
es, err := s.List("docs")
if err != nil || len(es) != 3 {
t.Fatalf("List = %v, %v", es, err)
}
if got := read(t, s, "docs/rapport.pdf"); got != "%PDF-1.4" {
t.Errorf("contenu = %q", got)
}
if es[0].Name != "archive.tar.gz" || es[2].Name != "sans-extension" {
t.Errorf("tri : %v", es)
}
st, _ := s.Stat("docs/rapport.pdf")
if st.EditedBy != "alice" {
t.Errorf("EditedBy = %q", st.EditedBy)
}
// Les fichiers temporaires et internes n'apparaissent jamais.
root, _ := s.List("")
for _, e := range root {
if strings.HasPrefix(e.Name, ".") {
t.Errorf("entrée cachée visible : %s", e.Name)
}
}
}
func TestPutConflictModes(t *testing.T) {
s := newStore(t)
put(t, s, "a.txt", "un", PutOptions{})
if _, err := s.Put("a.txt", strings.NewReader("deux"), PutOptions{}); !errors.Is(err, ErrExists) {
t.Fatalf("fail : %v", err)
}
e := put(t, s, "a.txt", "trois", PutOptions{Conflict: "rename"})
if e.Path != "a (2).txt" {
t.Errorf("rename -> %q", e.Path)
}
e = put(t, s, "a.txt", "quatre", PutOptions{Conflict: "rename"})
if e.Path != "a (3).txt" {
t.Errorf("rename 2 -> %q", e.Path)
}
put(t, s, "a.txt", "cinq", PutOptions{Conflict: "overwrite"})
if read(t, s, "a.txt") != "cinq" || read(t, s, "a (2).txt") != "trois" {
t.Error("contenus inattendus après écrasement")
}
// Un dossier ne peut pas être écrasé par un fichier.
if _, err := s.Mkdir("dir"); err != nil {
t.Fatal(err)
}
if _, err := s.Put("dir", strings.NewReader("x"), PutOptions{Conflict: "overwrite"}); !errors.Is(err, ErrExists) {
t.Errorf("dossier écrasé : %v", err)
}
// Un fichier ne peut pas servir de dossier parent.
if _, err := s.Put("a.txt/enfant", strings.NewReader("x"), PutOptions{}); err == nil {
t.Error("fichier utilisé comme dossier")
}
}
func TestPutIfMatchAndLimit(t *testing.T) {
s := newStore(t)
e := put(t, s, "f.bin", "abc", PutOptions{})
fi, _ := os.Stat(filepath.Join(s.root, "f.bin"))
if _, err := s.Put("f.bin", strings.NewReader("zz"), PutOptions{Conflict: "overwrite", IfMatch: `W/"nope"`}); !errors.Is(err, ErrConflict) {
t.Errorf("If-Match faux : %v", err)
}
if _, err := s.Put("f.bin", strings.NewReader("zz"), PutOptions{Conflict: "overwrite", IfMatch: ETag(fi)}); err != nil {
t.Errorf("If-Match juste : %v", err)
}
_ = e
_, err := s.Put("big.bin", strings.NewReader("0123456789"), PutOptions{Limit: 5, LimitErr: ErrQuota})
if !errors.Is(err, ErrQuota) {
t.Errorf("limite : %v", err)
}
if _, err := os.Stat(filepath.Join(s.root, "big.bin")); err == nil {
t.Error("fichier partiel conservé")
}
// Aucun fichier temporaire ne traîne.
des, _ := os.ReadDir(s.root)
for _, d := range des {
if strings.HasPrefix(d.Name(), ".tmp-") {
t.Errorf("temporaire : %s", d.Name())
}
}
}
func TestPutPreservesModTime(t *testing.T) {
s := newStore(t)
want := time.Date(2020, 5, 17, 10, 0, 0, 0, time.UTC)
e := put(t, s, "photo.jpg", "x", PutOptions{ModTime: want})
if !e.ModTime.Equal(want) {
t.Errorf("ModTime = %v", e.ModTime)
}
// Une date dans le futur lointain est ignorée.
e = put(t, s, "futur.txt", "x", PutOptions{ModTime: time.Now().AddDate(10, 0, 0)})
if e.ModTime.After(time.Now().Add(time.Hour)) {
t.Errorf("date future acceptée : %v", e.ModTime)
}
}
func TestHistoryOnOverwrite(t *testing.T) {
s := newStore(t)
put(t, s, "n.txt", "v1", PutOptions{ModTime: time.Now().Add(-3 * time.Hour)})
put(t, s, "n.txt", "v2", PutOptions{Conflict: "overwrite", ModTime: time.Now().Add(-2 * time.Hour)})
put(t, s, "n.txt", "v3", PutOptions{Conflict: "overwrite"})
vs, err := s.Versions("n.txt")
if err != nil || len(vs) != 2 {
t.Fatalf("versions = %v, %v", vs, err)
}
f, _, err := s.OpenVersion("n.txt", vs[1].ID)
if err != nil {
t.Fatal(err)
}
b, _ := io.ReadAll(f)
f.Close()
if string(b) != "v1" {
t.Errorf("plus ancienne version = %q", b)
}
if _, err := s.Restore("n.txt", vs[1].ID); err != nil {
t.Fatal(err)
}
if read(t, s, "n.txt") != "v1" {
t.Error("restauration inopérante")
}
if vs, _ = s.Versions("n.txt"); len(vs) != 3 {
t.Errorf("la restauration doit conserver l'état remplacé : %d versions", len(vs))
}
// Rétention.
s.History.Keep = 2
put(t, s, "n.txt", "v4", PutOptions{Conflict: "overwrite"})
if vs, _ = s.Versions("n.txt"); len(vs) != 2 {
t.Errorf("rétention : %d versions", len(vs))
}
// Historique désactivé.
s.History.Keep = 0
put(t, s, "z.txt", "a", PutOptions{})
put(t, s, "z.txt", "b", PutOptions{Conflict: "overwrite"})
if vs, _ = s.Versions("z.txt"); len(vs) != 0 {
t.Errorf("historique désactivé : %d versions", len(vs))
}
}
func TestMoveCopyFolders(t *testing.T) {
s := newStore(t)
put(t, s, "src/a.txt", "A", PutOptions{})
put(t, s, "src/sub/b.txt", "B", PutOptions{})
if _, err := s.Copy("src", "copie"); err != nil {
t.Fatal(err)
}
if read(t, s, "copie/sub/b.txt") != "B" {
t.Error("copie récursive")
}
if _, err := s.Copy("src", "src/dans"); !errors.Is(err, ErrInvalidPath) {
t.Errorf("copie dans soi-même : %v", err)
}
if _, err := s.Move("src", "src/sub/x"); !errors.Is(err, ErrInvalidPath) {
t.Errorf("déplacement dans soi-même : %v", err)
}
if _, err := s.Move("src", "copie"); !errors.Is(err, ErrExists) {
t.Errorf("destination existante : %v", err)
}
if _, err := s.Move("src/a.txt", "deplace/renomme.txt"); err != nil {
t.Fatal(err)
}
if read(t, s, "deplace/renomme.txt") != "A" {
t.Error("déplacement")
}
if _, _, err := s.Open("src/a.txt"); !errors.Is(err, ErrNotFound) {
t.Errorf("ancien emplacement : %v", err)
}
}
func TestTagsFollowMove(t *testing.T) {
s := newStore(t)
put(t, s, "a.txt", "x", PutOptions{})
if err := s.EditTags([]string{"a.txt"}, []string{"Rapport", "rapport", "#Urgent"}, nil); err != nil {
t.Fatal(err)
}
es, _ := s.List("")
if len(es[0].Tags) != 2 {
t.Fatalf("tags = %v", es[0].Tags)
}
if _, err := s.Move("a.txt", "b.txt"); err != nil {
t.Fatal(err)
}
es, _ = s.List("")
if len(es[0].Tags) != 2 {
t.Errorf("tags perdus au déplacement : %v", es[0])
}
ts, _ := s.Tags()
if len(ts) != 2 {
t.Errorf("Tags() = %v", ts)
}
}
func TestTrashRestoreAndName(t *testing.T) {
s := newStore(t)
put(t, s, "d/a.txt", "A", PutOptions{})
if err := s.Delete("d/a.txt", false); err != nil {
t.Fatal(err)
}
if _, _, err := s.Open("d/a.txt"); !errors.Is(err, ErrNotFound) {
t.Fatal("fichier encore présent")
}
put(t, s, "d/a.txt", "nouveau", PutOptions{}) // la place est prise
items, _ := s.TrashItems()
if len(items) != 1 {
t.Fatalf("poubelle : %v", items)
}
e, err := s.RestoreTrash(items[0].ID)
if err != nil {
t.Fatal(err)
}
if e.Path != "d/a (restauré 2).txt" || read(t, s, e.Path) != "A" {
t.Errorf("restauration : %v", e)
}
// Dossier non vide : refus sans récursivité.
if err := s.Delete("d", false); !errors.Is(err, ErrNotEmpty) {
t.Errorf("dossier non vide : %v", err)
}
if err := s.Delete("d", true); err != nil {
t.Fatal(err)
}
}
func TestSymlinkEscapeRefused(t *testing.T) {
s := newStore(t)
outside := t.TempDir()
_ = os.WriteFile(filepath.Join(outside, "secret.txt"), []byte("secret"), 0o644)
if err := os.Symlink(outside, filepath.Join(s.root, "lien")); err != nil {
t.Skip("liens symboliques indisponibles")
}
if _, _, err := s.Open("lien/secret.txt"); err == nil {
t.Error("lecture hors racine via lien symbolique")
}
if _, err := s.Put("lien/nouveau.txt", strings.NewReader("x"), PutOptions{}); err == nil {
t.Error("écriture hors racine via lien symbolique")
}
es, _ := s.List("")
for _, e := range es {
if e.Name == "lien" {
t.Error("lien symbolique listé")
}
}
// Lien interne vers un dossier caché.
_ = os.MkdirAll(filepath.Join(s.root, ".history"), 0o755)
_ = os.Symlink(filepath.Join(s.root, ".history"), filepath.Join(s.root, "cache"))
if _, err := s.List("cache"); err == nil {
t.Error("accès aux dossiers internes via lien symbolique")
}
}
func TestSearchNamesTagsAndText(t *testing.T) {
s := newStore(t)
put(t, s, "notes/Réseau.md", "# Plan\nLe VLAN 172.27.207.0/24 est routé", PutOptions{})
put(t, s, "notes/photo.jpg", "VLAN dans un binaire", PutOptions{})
put(t, s, "autre/budget.txt", "rien", PutOptions{})
_ = s.EditTags([]string{"autre/budget.txt"}, []string{"Finance"}, nil)
hits, _ := s.Search("172.27.207", Filter{}, 10)
if len(hits) != 1 || hits[0].Name != "Réseau.md" || hits[0].Snippet == "" {
t.Errorf("contenu : %v", hits)
}
if hits, _ = s.Search("reseau", Filter{}, 10); len(hits) != 1 {
t.Errorf("nom sans accent : %v", hits)
}
if hits, _ = s.Search("vlan", Filter{}, 10); len(hits) != 1 { // le .jpg n'est pas indexé comme texte
t.Errorf("binaire indexé : %v", hits)
}
if hits, _ = s.Search("", Filter{Tag: "finance"}, 10); len(hits) != 1 || hits[0].Name != "budget.txt" {
t.Errorf("tag : %v", hits)
}
}
func TestShareFileAndFolder(t *testing.T) {
s := newStore(t)
put(t, s, "pub/a.txt", "A", PutOptions{})
put(t, s, "pub/sub/b.txt", "B", PutOptions{})
sh, err := s.CreateShare("pub", ShareOptions{TTL: time.Hour})
if err != nil || !sh.IsDir || sh.Protected {
t.Fatalf("CreateShare = %+v, %v", sh, err)
}
got, err := s.ResolveShare(sh.Token)
if err != nil || got.Path != "pub" {
t.Fatalf("ResolveShare = %+v, %v", got, err)
}
if p, err := SharedPath(got, "sub/b.txt"); err != nil || p != "pub/sub/b.txt" {
t.Errorf("SharedPath = %q, %v", p, err)
}
for _, evil := range []string{"../secret", "sub/../../x", ".trash", "a/.history"} {
if p, err := SharedPath(got, evil); err == nil && !strings.HasPrefix(p, "pub/") {
t.Errorf("SharedPath(%q) = %q", evil, p)
} else if err == nil && strings.Contains(p, "..") {
t.Errorf("SharedPath(%q) = %q", evil, p)
}
}
// Signature altérée, jeton inconnu.
bad := sh.Token[:len(sh.Token)-2] + "xx"
if _, err := s.ResolveShare(bad); !errors.Is(err, ErrNotFound) {
t.Errorf("signature fausse : %v", err)
}
// Le lien suit un renommage et disparaît à la suppression.
if _, err := s.Move("pub", "public"); err != nil {
t.Fatal(err)
}
if got, err = s.ResolveShare(sh.Token); err != nil || got.Path != "public" {
t.Errorf("après déplacement : %+v, %v", got, err)
}
if err := s.Delete("public", true); err != nil {
t.Fatal(err)
}
if _, err := s.ResolveShare(sh.Token); !errors.Is(err, ErrNotFound) {
t.Errorf("après suppression : %v", err)
}
}
func TestSharePasswordAndExpiry(t *testing.T) {
s := newStore(t)
put(t, s, "f.txt", "x", PutOptions{})
sh, err := s.CreateShare("f.txt", ShareOptions{Password: "s3cret-mot-de-passe"})
if err != nil {
t.Fatal(err)
}
got, _ := s.ResolveShare(sh.Token)
if !got.Protected || !got.CheckPassword("s3cret-mot-de-passe") || got.CheckPassword("autre") {
t.Error("mot de passe du lien")
}
if sh.IsDir {
t.Error("IsDir")
}
c1, _ := s.UnlockCookie(got)
c2, _ := s.UnlockCookie(got)
if c1 == "" || c1 != c2 {
t.Error("cookie de déverrouillage instable")
}
s.CountDownload(sh.ID)
s.CountDownload(sh.ID)
if got, _ = s.ResolveShare(sh.Token); got.Downloads != 2 {
t.Errorf("téléchargements = %d", got.Downloads)
}
// Expiration.
exp, _ := s.CreateShare("f.txt", ShareOptions{TTL: time.Millisecond})
time.Sleep(5 * time.Millisecond)
if _, err := s.ResolveShare(exp.Token); !errors.Is(err, ErrNotFound) {
t.Errorf("lien expiré : %v", err)
}
// Tout révoquer change la clé : les anciens liens deviennent invalides.
if err := s.RevokeAllShares(); err != nil {
t.Fatal(err)
}
if _, err := s.ResolveShare(sh.Token); !errors.Is(err, ErrNotFound) {
t.Errorf("après révocation générale : %v", err)
}
}
func TestZip(t *testing.T) {
s := newStore(t)
put(t, s, "d/a.txt", "AAA", PutOptions{})
put(t, s, "d/sub/b.png", "BBB", PutOptions{})
_ = os.WriteFile(filepath.Join(s.root, "d", ".cache"), []byte("interne"), 0o644)
var buf bytes.Buffer
item, err := s.SharedZipItem("d")
if err != nil {
t.Fatal(err)
}
if err := WriteZip(&buf, []ZipItem{item}); err != nil {
t.Fatal(err)
}
zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
if err != nil {
t.Fatal(err)
}
names := map[string]string{}
for _, f := range zr.File {
rc, _ := f.Open()
b, _ := io.ReadAll(rc)
rc.Close()
names[f.Name] = string(b)
}
if names["d/a.txt"] != "AAA" || names["d/sub/b.png"] != "BBB" {
t.Errorf("contenu : %v", names)
}
for n := range names {
if strings.Contains(n, ".cache") {
t.Errorf("fichier interne archivé : %s", n)
}
}
}
func makePNG(w, h int) []byte {
img := image.NewRGBA(image.Rect(0, 0, w, h))
for y := 0; y < h; y++ {
for x := 0; x < w; x++ {
img.Set(x, y, color.RGBA{uint8(x), uint8(y), 128, 255})
}
}
var buf bytes.Buffer
_ = png.Encode(&buf, img)
return buf.Bytes()
}
func TestThumbs(t *testing.T) {
s := newStore(t)
put(t, s, "grande.png", string(makePNG(1200, 600)), PutOptions{})
b, typ, _, err := s.Thumb("grande.png")
if err != nil || typ != "image/png" {
t.Fatalf("Thumb : %v %q", err, typ)
}
cfg, err := png.DecodeConfig(bytes.NewReader(b))
if err != nil || cfg.Width != ThumbSize || cfg.Height != ThumbSize/2 {
t.Errorf("dimensions = %v, %v", cfg, err)
}
// Seconde lecture : servie depuis .thumbs/.
if _, err := os.Stat(filepath.Join(s.root, ".thumbs", "grande.png.thumb")); err != nil {
t.Error("miniature non conservée")
}
// Une petite image n'est pas agrandie.
put(t, s, "petite.png", string(makePNG(40, 20)), PutOptions{})
b, _, _, _ = s.Thumb("petite.png")
if cfg, _ := png.DecodeConfig(bytes.NewReader(b)); cfg.Width != 40 {
t.Errorf("agrandissement : %v", cfg)
}
// Remplacement : la miniature est régénérée.
put(t, s, "petite.png", string(makePNG(80, 80)), PutOptions{Conflict: "overwrite"})
b, _, _, _ = s.Thumb("petite.png")
if cfg, _ := png.DecodeConfig(bytes.NewReader(b)); cfg.Width != 80 {
t.Errorf("miniature périmée : %v", cfg)
}
// Pas une image décodable.
put(t, s, "x.pdf", "pdf", PutOptions{})
if _, _, _, err := s.Thumb("x.pdf"); !errors.Is(err, ErrNotFound) {
t.Errorf("PDF : %v", err)
}
put(t, s, "faux.png", "pas une image", PutOptions{})
if _, _, _, err := s.Thumb("faux.png"); !errors.Is(err, ErrNotFound) {
t.Errorf("image corrompue : %v", err)
}
}
func TestOrient(t *testing.T) {
src := image.NewRGBA(image.Rect(0, 0, 2, 1))
src.Set(0, 0, color.RGBA{255, 0, 0, 255})
src.Set(1, 0, color.RGBA{0, 0, 255, 255})
got := orient(src, 6) // 90° horaire : 1 colonne de 2 lignes, rouge en haut
if got.Bounds().Dx() != 1 || got.Bounds().Dy() != 2 || got.RGBAAt(0, 0).R != 255 || got.RGBAAt(0, 1).B != 255 {
t.Errorf("rotation 6 : %v", got.Pix)
}
if o := exifOrientation([]byte("II*\x00\x08\x00\x00\x00\x01\x00\x12\x01\x03\x00\x01\x00\x00\x00\x06\x00\x00\x00")); o != 6 {
t.Errorf("orientation EXIF = %d", o)
}
}
func TestUsageAndDetails(t *testing.T) {
s := newStore(t)
put(t, s, "a/x.bin", strings.Repeat("x", 1000), PutOptions{})
put(t, s, "a/b/y.bin", strings.Repeat("y", 500), PutOptions{})
// 1500 octets de contenu, plus .meta.json (auteurs).
if u := s.Usage(); u < 1500 || u > 2500 {
t.Errorf("Usage = %d", u)
}
d, err := s.dirDetails("a")
if err != nil || d.Files != 1 || d.Dirs != 1 || d.Total != 1500 || d.Count != 2 {
t.Errorf("dirDetails = %+v, %v", d, err)
}
put(t, s, "img.png", string(makePNG(30, 10)), PutOptions{})
fd, _ := s.fileDetails("img.png", s.metaSnapshot(), nil)
if fd.Width != 30 || fd.Height != 10 {
t.Errorf("fileDetails = %+v", fd)
}
}