Up And Down : première version

This commit is contained in:
cedric committed 2026-11-19 10:30:47 +01:00
commit 89c5430308
76 files changed
+20730

No files matched your search

+526
View File
@@ -0,0 +1,526 @@
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)
}
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)
}
}