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