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