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
314 lines
8.7 KiB
Go
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)
|
|
}
|
|
}
|