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