diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 6a292a7..a9fb25c 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -1,5 +1,5 @@ import { useCallback, useEffect, useRef, useState } from "react"; -import { api, FAVORIS, PERSO, POUBELLE, type Entry, type Me } from "./api"; +import { api, FAVORIS, PERSO, POUBELLE, S3, type Entry, type Me } from "./api"; import { ActionMenu } from "./ActionMenu"; import { Explorer } from "./Explorer"; import { FolderTree } from "./FolderTree"; @@ -9,6 +9,7 @@ import { Splitter } from "./Splitter"; import { UploadPanel } from "./UploadPanel"; import { fmtSize, initials } from "./format"; import { + CloudIcon, CloudUpIcon, FolderIcon, KeyIcon, @@ -187,7 +188,8 @@ function Shell({ me, reloadMe }: { me: Me; reloadMe: () => Promise }) { const trash = places.find((p) => p.special === "poubelle"); const user = me.user!; const root = dir.split("/")[0]; - const current = root === PERSO || root === FAVORIS || root === POUBELLE ? root : ""; + const hasS3 = places.some((p) => p.special === "s3"); + const current = root === PERSO || root === FAVORIS || root === POUBELLE || root === S3 ? root : ""; const navItem = (id: string, text: string, icon: React.ReactNode, active: boolean, badge?: number) => ( - {!e.isDir && ( + {!e.isDir && !inS3(e.path) && ( )} - + {!inS3(e.path) && ( + + )}
@@ -175,7 +177,7 @@ export function DetailsPanel({ entry: e, onClose, onOpen, onShare, onHistory, on
{!e.isDir && (
- {e.path.startsWith(".perso") ? "Espace personnel" : "Arborescence commune"} + {e.path.startsWith(".perso") ? "Espace personnel" : inS3(e.path) ? "Racine S3" : "Arborescence commune"}
)} diff --git a/frontend/src/Explorer.tsx b/frontend/src/Explorer.tsx index 8d7098a..ce6ece2 100644 --- a/frontend/src/Explorer.tsx +++ b/frontend/src/Explorer.tsx @@ -9,6 +9,7 @@ import { displayPath, inFavoris, inPoubelle, + inS3, join, label, POUBELLE, @@ -18,6 +19,7 @@ import { type TagCount, } from "./api"; import { + CloudIcon, CloseIcon, ClockIcon, CopyIcon, @@ -565,7 +567,7 @@ export function Explorer({ me, refreshKey, goto, onDirChange, onMutated, toolbar const icon = (e: Entry) => e.special ? ( - {e.special === "favoris" ? : e.special === "poubelle" ? e.count ? : : } + {e.special === "favoris" ? : e.special === "poubelle" ? e.count ? : : e.special === "s3" ? : } ) : e.broken ? ( @@ -679,13 +681,13 @@ export function Explorer({ me, refreshKey, goto, onDirChange, onMutated, toolbar )} - {!e.isDir && !e.broken && ( + {!e.isDir && !e.broken && !inS3(e.path) && ( )} - {!e.broken && !favView && ( + {!e.broken && !favView && !inS3(e.path) && ( + + ); } +// --- Racine S3 (administrateur) ----------------------------------------------------------- + +const s3Fields: { id: keyof S3Patch; label: string; placeholder?: string }[] = [ + { id: "endpoint", label: "Endpoint", placeholder: "https://garage:3900" }, + { id: "region", label: "Région", placeholder: "garage" }, + { id: "bucket", label: "Bucket" }, + { id: "accessKey", label: "Clé d'accès" }, + { id: "secretKey", label: "Clé secrète" }, +]; + +/** Connexion au bucket : un champ fixé par une variable S3_* est verrouillé ; + * la clé secrète n'est jamais affichée (vide : inchangée). */ +function S3Section({ onError, onChanged }: { onError: (m: string | null) => void; onChanged: () => void }) { + const [st, setSt] = useState(null); + const [form, setForm] = useState>({}); + const [insecure, setInsecure] = useState(false); + const [busy, setBusy] = useState(false); + const [note, setNote] = useState(null); + + const reset = (s: S3Status) => { + setSt(s); + setForm({ endpoint: s.endpoint, region: s.region, bucket: s.bucket, accessKey: s.accessKey, secretKey: "" }); + setInsecure(s.insecure); + }; + useEffect(() => { + api.s3Status().then(reset).catch((e) => onError(msg(e))); + }, [onError]); + + if (!st) return null; + const locked = (k: string) => st.locked.includes(k); + const patch = (): S3Patch => { + const p: S3Patch = {}; + for (const f of s3Fields) { + if (locked(f.id) || f.id === "secretKey") continue; + const v = form[f.id] ?? ""; + if (v !== (st[f.id as keyof S3Status] ?? "")) (p as Record)[f.id] = v; + } + if (!locked("secretKey") && form.secretKey) p.secretKey = form.secretKey; + if (!locked("insecure") && insecure !== st.insecure) p.insecure = insecure; + return p; + }; + const run = async (save: boolean) => { + onError(null); + setNote(null); + setBusy(true); + try { + if (save) { + reset(await api.saveS3(patch())); + setNote("Configuration S3 enregistrée."); + onChanged(); + } else { + await api.testS3(patch()); + setNote("Connexion au bucket réussie."); + } + } catch (e) { + onError(msg(e)); + } finally { + setBusy(false); + } + }; + + return ( + <> +

Racine S3

+ {!st.available ? ( +

Disponible avec le catalogue PostgreSQL (DATABASE_URL).

+ ) : ( +
{ + e.preventDefault(); + run(true); + }} + > +

+ {st.active ? "Branchée." : "Non branchée."} Bucket vide attendu au départ ; l'endpoint et le bucket ne changent plus une + fois la racine utilisée. Les champs grisés sont fixés par les variables S3_*. +

+ {st.error &&

{st.error}

} + {s3Fields.map((f) => ( + + ))} + + {note && ( +
+ {note} +
+ )} +
+ + +
+
+ )} + + ); +} + // --- Utilisateurs (administrateur) --------------------------------------------------------- const statusLabel: Record = { active: "Actif", pending: "En attente", disabled: "Désactivé" }; diff --git a/frontend/src/api.ts b/frontend/src/api.ts index 9e5d71b..e03862b 100644 --- a/frontend/src/api.ts +++ b/frontend/src/api.ts @@ -11,7 +11,7 @@ export interface Entry { /** Dossier : icône choisie (voir folderIcons.tsx). */ icon?: string; /** Entrée virtuelle de la racine : "favoris", "perso" (espace personnel) ou "poubelle". */ - special?: "favoris" | "perso" | "poubelle"; + special?: "favoris" | "perso" | "poubelle" | "s3"; /** Entrée « poubelle » de la racine : nombre d'éléments qu'elle contient. */ count?: number; /** Élément de la poubelle : chemin d'origine (modTime = date de suppression). */ @@ -91,6 +91,25 @@ export interface PreviewSettings { shares: boolean; } +/** Racine S3 (administrateur) : la clé secrète n'est jamais renvoyée ; + * locked liste les champs fixés par les variables d'environnement. */ +export interface S3Status { + available: boolean; + active: boolean; + error?: string; + endpoint: string; + region: string; + bucket: string; + accessKey: string; + secretSet: boolean; + insecure: boolean; + locked: string[]; + empty: boolean; +} + +/** Modification de la racine S3 ; secretKey vide : clé conservée. */ +export type S3Patch = Partial> & { secretKey?: string }; + /** Version enregistrée d'un fichier (time : date de ce contenu). */ export interface Version { id: string; @@ -426,6 +445,12 @@ export const api = { removeLogo: async (): Promise => (await request("/api/logo", { method: "DELETE" })).json(), logoUrl: (v: string) => `/api/logo?v=${q(v)}`, + + s3Status: async (): Promise => (await request("/api/admin/s3")).json(), + saveS3: async (p: S3Patch): Promise => (await request("/api/admin/s3", json(p, "PUT"))).json(), + testS3: async (p: S3Patch): Promise => { + await request("/api/admin/s3/test", json(p, "POST")); + }, }; export type Conflict = "fail" | "overwrite" | "rename"; @@ -471,7 +496,9 @@ export const join = (dir: string, name: string) => (dir ? `${dir}/${name}` : nam export const PERSO = ".perso"; export const FAVORIS = ".favoris"; export const POUBELLE = ".poubelle"; -const SPECIAL_LABELS: Record = { [PERSO]: "Personnel", [FAVORIS]: "Favoris", [POUBELLE]: "Poubelle" }; +/** Racine commune sur stockage objet (si configurée) : ni favoris ni historique. */ +export const S3 = ".s3"; +const SPECIAL_LABELS: Record = { [PERSO]: "Personnel", [FAVORIS]: "Favoris", [POUBELLE]: "Poubelle", [S3]: "S3" }; /** Libellé d'un composant de chemin (".perso" → "Personnel"). */ export const label = (part: string) => SPECIAL_LABELS[part] ?? part; /** Chemin affiché : "Personnel/projets" pour ".perso/projets". */ @@ -479,6 +506,7 @@ export const displayPath = (p: string) => p.split("/").map(label).join("/"); export const inFavoris = (p: string) => p === FAVORIS || p.startsWith(FAVORIS + "/"); export const inPoubelle = (p: string) => p === POUBELLE || p.startsWith(POUBELLE + "/"); export const inPerso = (p: string) => p === PERSO || p.startsWith(PERSO + "/"); +export const inS3 = (p: string) => p === S3 || p.startsWith(S3 + "/"); /** Extension (sans le point, minuscules) ; vide si aucune. */ export const extOf = (name: string) => { diff --git a/internal/storage/s3_test.go b/internal/storage/s3_test.go new file mode 100644 index 0000000..296880a --- /dev/null +++ b/internal/storage/s3_test.go @@ -0,0 +1,313 @@ +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) + } +} diff --git a/internal/storage/s3space_test.go b/internal/storage/s3space_test.go new file mode 100644 index 0000000..067216d --- /dev/null +++ b/internal/storage/s3space_test.go @@ -0,0 +1,138 @@ +package storage + +import ( + "errors" + "io" + "strings" + "testing" +) + +func uread(t *testing.T, u *Space, p string) string { + t.Helper() + f, _, err := u.Open(p) + if err != nil { + t.Fatalf("Open(%s) : %v", p, err) + } + defer f.Close() + b, _ := io.ReadAll(f) + return string(b) +} + +func TestSpaceS3Root(t *testing.T) { + s3, _ := newS3Store(t) + sp := newSpaces(t) + sp.SetS3(s3) + alice := space(t, sp, "alice", false) + admin := space(t, sp, "admin", true) + + es, err := alice.List("") + if err != nil { + t.Fatal(err) + } + found := false + for _, e := range es { + found = found || (e.Special == "s3" && e.Path == S3Prefix) + } + if !found { + t.Fatalf("entrée S3 absente de la racine : %v", es) + } + + e := uput(t, alice, ".s3/docs/a.txt", "AAA") + if e.Path != ".s3/docs/a.txt" { + t.Errorf("chemin virtuel %q", e.Path) + } + if got := uread(t, alice, ".s3/docs/a.txt"); got != "AAA" { + t.Errorf("contenu %q", got) + } + if l, _ := alice.List(".s3/docs"); len(l) != 1 || l[0].Path != ".s3/docs/a.txt" { + t.Errorf("liste .s3/docs : %v", l) + } + + // Copie et déplacement entre disque et S3, dans les deux sens. + uput(t, alice, "commun/b.txt", "BB") + if err := alice.EditTags([]string{"commun/b.txt"}, []string{"rouge"}, nil); err != nil { + t.Fatal(err) + } + if _, err := alice.Copy("commun", ".s3/copie"); err != nil { + t.Fatal(err) + } + if got := uread(t, alice, ".s3/copie/b.txt"); got != "BB" { + t.Errorf("copie vers S3 : %q", got) + } + if _, err := alice.Move("commun/b.txt", ".s3/b.txt"); err != nil { + t.Fatal(err) + } + if _, err := alice.Stat("commun/b.txt"); !errors.Is(err, ErrNotFound) { + t.Errorf("original toujours présent : %v", err) + } + st, err := alice.Stat(".s3/b.txt") + if err != nil || len(st.Tags) != 1 || st.Tags[0] != "rouge" { + t.Errorf("tags non repris : %+v %v", st, err) + } + if _, err := alice.Move(".s3/docs", ".perso/docs"); err != nil { + t.Fatal(err) + } + if got := uread(t, alice, ".perso/docs/a.txt"); got != "AAA" { + t.Errorf("S3 → perso : %q", got) + } + if _, err := alice.Stat(".s3/docs"); !errors.Is(err, ErrNotFound) { + t.Errorf("dossier S3 toujours présent : %v", err) + } + if res, err := alice.MoveMany([]string{".perso/docs/a.txt"}, ".s3/copie"); err != nil || res[0].Error != "" { + t.Errorf("MoveMany vers S3 : %v %+v", err, res) + } + + // Pas de favoris sur S3. + if err := alice.SetFavorite([]string{".s3/b.txt"}, true); !errors.Is(err, ErrInvalidPath) { + t.Errorf("favori S3 accepté : %v", err) + } + + // Poubelle : s-, restauration. + if err := alice.Delete(".s3/b.txt", false); err != nil { + t.Fatal(err) + } + tr, _ := alice.Trash() + var item string + for _, e := range tr { + if strings.HasPrefix(e.Path, TrashPrefix+"/s-") { + item = e.Path + if e.Origin != ".s3/b.txt" { + t.Errorf("origine %q", e.Origin) + } + } + } + if item == "" { + t.Fatalf("élément S3 absent de la poubelle : %v", tr) + } + if r := alice.RestoreTrash([]string{item}); r[0].Error != "" || r[0].To != ".s3/b.txt" { + t.Errorf("restauration : %+v", r) + } + + // Partage d'un fichier S3, résolu par Spaces. + sh, err := alice.CreateShare(".s3/b.txt", ShareOptions{}) + if err != nil { + t.Fatal(err) + } + if sh.Path != ".s3/b.txt" { + t.Errorf("chemin du partage %q", sh.Path) + } + if _, store, err := sp.ResolveShare(sh.Token); err != nil || store != s3 { + t.Errorf("ResolveShare : %v", err) + } + + // Lecture seule : mêmes règles que l'arborescence commune. + if _, err := sp.Main.WriteCommonReadonly(true); err != nil { + t.Fatal(err) + } + if _, err := alice.Put(".s3/x.txt", strings.NewReader("x"), 1, PutOptions{}); !errors.Is(err, ErrForbidden) { + t.Errorf("écriture S3 en lecture seule : %v", err) + } + uput(t, admin, ".s3/x.txt", "x") + + // Racine S3 absente : .s3 introuvable. + sp.SetS3(nil) + alice = space(t, sp, "alice", false) + if _, err := alice.List(".s3"); !errors.Is(err, ErrNotFound) { + t.Errorf("sans S3 : %v", err) + } +}