Files
upandown/internal/storage/s3_test.go
T
claude BotandClaude Opus 5.5 6838c147b7 Lot 3 (5/5) : interface (entrée S3, réglages admin) et tests S3
Entrée « S3 » dans la barre latérale et à la racine (icône nuage), pas
d'historique ni de favoris sur S3 ; section « Racine S3 » dans
Administration (champs verrouillés par l'environnement, clé secrète jamais
affichée, test de connexion). Tests : Store S3 sur stockage objet en
mémoire, intégration aux espaces.

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

314 lines
8.7 KiB
Go

package storage
import (
"bytes"
"context"
"errors"
"io"
"io/fs"
"strings"
"sync"
"testing"
)
// memObjects : stockage objet en mémoire pour les tests.
type memObjects struct {
mu sync.Mutex
objs map[string][]byte
meta map[string]map[string]string
}
func newMemObjects() *memObjects {
return &memObjects{objs: map[string][]byte{}, meta: map[string]map[string]string{}}
}
type memFile struct{ *bytes.Reader }
func (memFile) Close() error { return nil }
func (m *memObjects) Put(_ context.Context, key string, r io.Reader, meta map[string]string) (int64, error) {
b, err := io.ReadAll(r)
if err != nil {
return 0, err
}
m.mu.Lock()
defer m.mu.Unlock()
m.objs[key], m.meta[key] = b, meta
return int64(len(b)), nil
}
func (m *memObjects) Get(_ context.Context, key string) (File, error) {
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.objs[key]
if !ok {
return nil, ErrNotFound
}
return memFile{bytes.NewReader(b)}, nil
}
func (m *memObjects) Copy(_ context.Context, src, dst string, meta map[string]string) error {
m.mu.Lock()
defer m.mu.Unlock()
b, ok := m.objs[src]
if !ok {
return ErrNotFound
}
m.objs[dst], m.meta[dst] = append([]byte(nil), b...), meta
return nil
}
func (m *memObjects) Remove(_ context.Context, key string) error {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.objs, key)
return nil
}
func (m *memObjects) Empty(context.Context) (bool, error) {
m.mu.Lock()
defer m.mu.Unlock()
return len(m.objs) == 0, nil
}
func (m *memObjects) count() int {
m.mu.Lock()
defer m.mu.Unlock()
return len(m.objs)
}
func newS3Store(t *testing.T) (*Store, *memObjects) {
t.Helper()
db := needCatalog(t)
ctx := context.Background()
if _, err := db.Pool.Exec(ctx, "TRUNCATE s3_nodes, s3_trash, s3_config; DELETE FROM item_meta WHERE root = 's3'; DELETE FROM shares WHERE root = 's3'"); err != nil {
t.Fatal(err)
}
objs := newMemObjects()
s, err := NewS3(t.TempDir(), db, objs)
if err != nil {
t.Fatal(err)
}
return s, objs
}
func readAll(t *testing.T, s *Store, rel string) string {
t.Helper()
f, _, err := s.Open(rel)
if err != nil {
t.Fatal(err)
}
defer f.Close()
b, _ := io.ReadAll(f)
return string(b)
}
func names(es []Entry) string {
var n []string
for _, e := range es {
n = append(n, e.Name)
}
return strings.Join(n, ",")
}
func TestS3RootBasics(t *testing.T) {
s, objs := newS3Store(t)
if _, err := s.Put("a/b/c.txt", strings.NewReader("bonjour"), PutOptions{By: "alice"}); err != nil {
t.Fatal(err)
}
if es, err := s.List(""); err != nil || names(es) != "a" {
t.Fatalf("racine : %v %v", names(es), err)
}
if es, _ := s.List("a/b"); names(es) != "c.txt" || es[0].Size != 7 || es[0].EditedBy != "alice" {
t.Fatalf("a/b : %+v", es)
}
if got := readAll(t, s, "a/b/c.txt"); got != "bonjour" {
t.Fatal(got)
}
// Conflits et remplacement.
if _, err := s.Put("a/b/c.txt", strings.NewReader("x"), PutOptions{}); !errors.Is(err, ErrExists) {
t.Fatal(err)
}
e, err := s.Put("a/b/c.txt", strings.NewReader("x"), PutOptions{Conflict: "rename"})
if err != nil || e.Path != "a/b/c (2).txt" {
t.Fatalf("rename : %v %+v", err, e)
}
_, fi, _ := s.Open("a/b/c.txt")
if _, err := s.Put("a/b/c.txt", strings.NewReader("salut"), PutOptions{Conflict: "overwrite", IfMatch: "faux"}); !errors.Is(err, ErrConflict) {
t.Fatal(err)
}
if _, err := s.Put("a/b/c.txt", strings.NewReader("salut"), PutOptions{Conflict: "overwrite", IfMatch: ETag(fi)}); err != nil {
t.Fatal(err)
}
if got := readAll(t, s, "a/b/c.txt"); got != "salut" || objs.count() != 2 {
t.Fatalf("remplacement : %q, %d objets", got, objs.count())
}
if _, err := s.Put("a/b/c.txt/d", strings.NewReader("x"), PutOptions{}); !errors.Is(err, ErrExists) {
t.Fatalf("fichier en chemin : %v", err)
}
if _, err := s.Put("big", strings.NewReader("0123456789"), PutOptions{Limit: 5}); !errors.Is(err, ErrTooLarge) || objs.count() != 2 {
t.Fatalf("limite : %v, %d objets", err, objs.count())
}
// Tags, déplacement (catalogue seul), copie (objets dupliqués).
if err := s.EditTags([]string{"a/b"}, []string{"Projet"}, nil); err != nil {
t.Fatal(err)
}
if _, err := s.Move("a/b", "x/y"); err != nil {
t.Fatal(err)
}
if _, err := s.Move("x", "x/z"); !errors.Is(err, ErrInvalidPath) {
t.Fatal(err)
}
if e, err := s.Stat("x/y"); err != nil || len(e.Tags) != 1 {
t.Fatalf("tags suivis : %v %+v", err, e)
}
if got := readAll(t, s, "x/y/c.txt"); got != "salut" || objs.count() != 2 {
t.Fatalf("déplacé : %q %d", got, objs.count())
}
if _, err := s.Copy("x", "copie"); err != nil {
t.Fatal(err)
}
if got := readAll(t, s, "copie/y/c (2).txt"); got != "x" || objs.count() != 4 {
t.Fatalf("copie : %q %d", got, objs.count())
}
var walked []string
_ = s.Walk("copie", func(rel string, e Entry) error {
walked = append(walked, rel)
return nil
})
if strings.Join(walked, "|") != "copie|copie/y|copie/y/c (2).txt|copie/y/c.txt" {
t.Fatalf("walk : %q", walked)
}
if s.Usage() != 12 {
t.Errorf("usage : %d", s.Usage())
}
// Corbeille : suppression, restauration, purge.
if err := s.Delete("x", false); !errors.Is(err, ErrNotEmpty) {
t.Fatal(err)
}
if err := s.Delete("x", true); err != nil {
t.Fatal(err)
}
if _, err := s.Stat("x/y/c.txt"); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
items, _ := s.TrashItems()
if len(items) != 1 || items[0].Path != "x" || !items[0].IsDir || s.TrashCount() != 1 {
t.Fatalf("corbeille : %+v", items)
}
if es, _ := s.List(""); names(es) != "a,copie" {
t.Fatalf("racine après suppression : %s", names(es))
}
if _, err := s.RestoreTrash(items[0].ID); err != nil {
t.Fatal(err)
}
if e, err := s.Stat("x/y"); err != nil || len(e.Tags) != 1 {
t.Fatalf("restauré : %v %+v", err, e)
}
if err := s.Delete("x", true); err != nil {
t.Fatal(err)
}
if err := s.EmptyTrash(); err != nil {
t.Fatal(err)
}
if objs.count() != 2 || s.TrashCount() != 0 {
t.Fatalf("purge : %d objets", objs.count())
}
if err := s.Remove("copie"); err != nil || objs.count() != 0 {
t.Fatalf("remove : %v %d", err, objs.count())
}
if vs, err := s.Versions("a"); err != nil || len(vs) != 0 {
t.Fatalf("versions : %v", err)
}
}
// Transfert disque -> S3 et S3 -> disque par la fonction commune.
func TestS3Transfer(t *testing.T) {
s3s, _ := newS3Store(t)
disk := newStore(t)
if _, err := disk.Put("d/f.txt", strings.NewReader("disque"), PutOptions{}); err != nil {
t.Fatal(err)
}
if _, err := transfer(disk, "d", s3s, "d", "bob"); err != nil {
t.Fatal(err)
}
if got := readAll(t, s3s, "d/f.txt"); got != "disque" {
t.Fatal(got)
}
if _, err := transfer(s3s, "d", disk, "retour", "bob"); err != nil {
t.Fatal(err)
}
if got := readAll(t, disk, "retour/f.txt"); got != "disque" {
t.Fatal(got)
}
if err := s3s.Walk("absent", func(string, Entry) error { return nil }); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
// Walk : SkipDir saute le contenu d'un dossier.
var seen []string
_ = s3s.Walk("", func(rel string, e Entry) error {
seen = append(seen, rel)
if rel == "d" {
return fs.SkipDir
}
return nil
})
if strings.Join(seen, "|") != "|d" {
t.Fatalf("SkipDir : %q", seen)
}
}
func TestS3MetaSharesSearch(t *testing.T) {
s, _ := newS3Store(t)
s.SetShareSecret("0123456789abcdef0123")
if _, err := s.Put("docs/rapport.txt", strings.NewReader("contenu"), PutOptions{}); err != nil {
t.Fatal(err)
}
if err := s.SetIcon([]string{"docs"}, ""); err != nil {
t.Fatal(err)
}
if err := s.SetIcon([]string{"docs/rapport.txt"}, ""); !errors.Is(err, ErrInvalidPath) {
t.Fatalf("icône sur fichier : %v", err)
}
if err := s.EditTags([]string{"docs/rapport.txt"}, []string{"Urgent"}, nil); err != nil {
t.Fatal(err)
}
sh, err := s.CreateShare("docs", ShareOptions{})
if err != nil || !sh.IsDir {
t.Fatalf("partage : %v %+v", err, sh)
}
if _, err := s.ResolveShare(sh.Token); err != nil {
t.Fatal(err)
}
if _, err := s.Move("docs", "archives"); err != nil {
t.Fatal(err)
}
if got, err := s.ResolveShare(sh.Token); err != nil || got.Path != "archives" {
t.Fatalf("partage suivi : %v %+v", err, got)
}
hits, err := s.Search("rapp", Filter{}, 10)
if err != nil || len(hits) != 1 || hits[0].Path != "archives/rapport.txt" {
t.Fatalf("recherche nom : %v %+v", err, hits)
}
if hits, _ := s.Search("contenu", Filter{}, 10); len(hits) != 0 {
t.Fatal("plein texte inattendu sur S3")
}
if hits, _ := s.Search("", Filter{Tag: "urgent"}, 10); len(hits) != 1 {
t.Fatalf("tag : %+v", hits)
}
if d, err := s.dirDetails("archives"); err != nil || d.Files != 1 || d.Total != 7 {
t.Fatalf("détails : %v %+v", err, d)
}
if _, _, _, err := s.Thumb("archives/rapport.txt"); !errors.Is(err, ErrNotFound) {
t.Fatal(err)
}
if _, err := s.Put("img.png", bytes.NewReader(makePNG(300, 200)), PutOptions{}); err != nil {
t.Fatal(err)
}
if b, _, _, err := s.Thumb("img.png"); err != nil || len(b) == 0 {
t.Fatalf("miniature : %v", err)
}
}