Files
upandown/internal/storage/s3config_test.go
T
claude BotandClaude Opus 5.5 53972f9762 Lot 3 (3/4) : racine S3 dans les espaces, configuration env + admin
.s3 dans la vue utilisateur (mêmes droits que le commun), poubelle s-<id>,
partages, déplacements et copies entre disque et S3 (transfer + reprise
des tags et liens), pas de favoris sur S3. Configuration : variables S3_*
prioritaires champ par champ, sinon table s3_config (clé secrète chiffrée
avec SHARE_SECRET), relue toutes les 30 s par chaque instance. Endpoint
et bucket figés tant que la racine n'est pas vide.

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

90 lines
3.1 KiB
Go

package storage
import (
"context"
"errors"
"strings"
"testing"
)
// s3Instance : une instance (Spaces) avec catalogue, racine S3 configurable
// sur des buckets en mémoire.
func s3Instance(t *testing.T, env S3Config, buckets map[string]*memObjects) *Spaces {
t.Helper()
db := needCatalog(t)
main := newStore(t)
if err := main.SetShareSecret("secret-commun-de-test-0123456789"); err != nil {
t.Fatal(err)
}
sp := NewSpaces(main)
sp.Catalog = db
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
sp.ConfigureS3(ctx, env, t.TempDir())
sp.s3cf.open = func(_ context.Context, c S3Config) (ObjectStore, error) {
b := buckets[c.Bucket]
if b == nil || c.SecretKey != "bonne-cle" {
return nil, errors.New("accès refusé")
}
return b, nil
}
return sp
}
func str(s string) *string { return &s }
func TestS3ConfigAdmin(t *testing.T) {
newS3Store(t) // remet les tables S3 à zéro
buckets := map[string]*memObjects{"b1": newMemObjects(), "b2": newMemObjects(), "plein": newMemObjects()}
buckets["plein"].objs["autre"] = []byte("x")
env := S3Config{Endpoint: "https://garage:3900"} // endpoint verrouillé
a := s3Instance(t, env, buckets)
b := s3Instance(t, env, buckets)
st := a.S3Status()
if !st.Available || st.Active || len(st.Locked) != 1 || st.Locked[0] != "endpoint" {
t.Fatalf("état initial : %+v", st)
}
if _, err := a.SaveS3(S3Patch{Endpoint: str("http://ailleurs")}); err == nil {
t.Error("champ verrouillé modifié")
}
if err := a.TestS3(S3Patch{Bucket: str("b1"), AccessKey: str("ak"), SecretKey: str("mauvaise")}); err == nil {
t.Error("mauvaise clé acceptée")
}
if err := a.TestS3(S3Patch{Bucket: str("plein"), AccessKey: str("ak"), SecretKey: str("bonne-cle")}); !errors.Is(err, ErrS3NotEmpty) {
t.Errorf("bucket non vide : %v", err)
}
st, err := a.SaveS3(S3Patch{Bucket: str("b1"), AccessKey: str("ak"), SecretKey: str("bonne-cle")})
if err != nil || !st.Active || !st.SecretSet || st.Bucket != "b1" {
t.Fatalf("enregistrement : %+v %v", st, err)
}
// La clé secrète n'est ni renvoyée ni stockée en clair.
var raw string
if err := a.Catalog.Pool.QueryRow(context.Background(), "SELECT data::text FROM s3_config").Scan(&raw); err != nil {
t.Fatal(err)
}
if strings.Contains(raw, "bonne-cle") {
t.Error("clé secrète en clair dans le catalogue")
}
// L'autre instance suit sans redémarrer.
b.RefreshS3(false)
ub := space(t, b, "bob", false)
uput(t, ub, ".s3/f.txt", "F")
ua := space(t, a, "alice", false)
if e, err := ua.Stat(".s3/f.txt"); err != nil || e.Size != 1 {
t.Errorf("instance a : %+v %v", e, err)
}
// Racine non vide : bucket figé, rotation des clés permise.
if _, err := a.SaveS3(S3Patch{Bucket: str("b2")}); !errors.Is(err, ErrS3NotEmpty) {
t.Errorf("changement de bucket : %v", err)
}
if _, err := a.SaveS3(S3Patch{Bucket: str(""), AccessKey: str(""), SecretKey: str("")}); err == nil {
t.Error("racine non vide débranchée")
}
if _, err := a.SaveS3(S3Patch{AccessKey: str("ak2"), SecretKey: str("bonne-cle")}); err != nil {
t.Errorf("rotation des clés : %v", err)
}
}