Fichiers nouveaux du commit précédent : internal/catalog/catalog.go, internal/storage/catalog.go et ses tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LNfwm4pfYR9C914C2EeiuB
163 lines
4.1 KiB
Go
163 lines
4.1 KiB
Go
package storage
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/vblogio/upandown/internal/catalog"
|
|
)
|
|
|
|
// Les tests du catalogue PostgreSQL s'exécutent quand
|
|
// UPANDOWN_TEST_DATABASE_URL est défini ; tous les tests du paquet passent
|
|
// alors par la base (newStore branche chaque Store sur une racine unique).
|
|
|
|
var (
|
|
testDBOnce sync.Once
|
|
testDB *catalog.DB
|
|
testDBErr error
|
|
)
|
|
|
|
func testCatalog(t *testing.T) *catalog.DB {
|
|
t.Helper()
|
|
dsn := os.Getenv("UPANDOWN_TEST_DATABASE_URL")
|
|
if dsn == "" {
|
|
return nil
|
|
}
|
|
testDBOnce.Do(func() {
|
|
testDB, testDBErr = catalog.Open(context.Background(), dsn, 5*time.Second)
|
|
})
|
|
if testDBErr != nil {
|
|
t.Fatal(testDBErr)
|
|
}
|
|
return testDB
|
|
}
|
|
|
|
func uniqueRoot(prefix string) string {
|
|
b := make([]byte, 6)
|
|
_, _ = rand.Read(b)
|
|
return prefix + "-" + hex.EncodeToString(b)
|
|
}
|
|
|
|
func attachTestCatalog(t *testing.T, s *Store) {
|
|
t.Helper()
|
|
if db := testCatalog(t); db != nil {
|
|
if err := s.UseCatalog(db, uniqueRoot("test")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func needCatalog(t *testing.T) *catalog.DB {
|
|
t.Helper()
|
|
db := testCatalog(t)
|
|
if db == nil {
|
|
t.Skip("UPANDOWN_TEST_DATABASE_URL non défini")
|
|
}
|
|
return db
|
|
}
|
|
|
|
// Deux instances (deux Store sur le même dossier et la même racine du
|
|
// catalogue) voient les modifications l'une de l'autre, sans perte en écriture
|
|
// concurrente.
|
|
func TestCatalogSharedBetweenInstances(t *testing.T) {
|
|
db := needCatalog(t)
|
|
dir := t.TempDir()
|
|
root := uniqueRoot("cluster")
|
|
a, _ := New(dir)
|
|
b, _ := New(dir)
|
|
if err := a.UseCatalog(db, root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := b.UseCatalog(db, root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for i := 0; i < 20; i++ {
|
|
put(t, a, "f"+string(rune('a'+i))+".txt", "x", PutOptions{})
|
|
}
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 20; i++ {
|
|
st := a
|
|
if i%2 == 1 {
|
|
st = b
|
|
}
|
|
wg.Add(1)
|
|
go func(st *Store, p, tag string) {
|
|
defer wg.Done()
|
|
if err := st.EditTags([]string{p}, []string{tag}, nil); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}(st, "f"+string(rune('a'+i))+".txt", "t"+string(rune('a'+i)))
|
|
}
|
|
wg.Wait()
|
|
tags, err := b.Tags()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(tags) != 20 {
|
|
t.Errorf("%d tags vus par l'autre instance, 20 attendus : %v", len(tags), tags)
|
|
}
|
|
if _, err := a.Move("fa.txt", "dossier/fa.txt"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
e, err := b.Stat("dossier/fa.txt")
|
|
if err != nil || !slices.Equal(e.Tags, []string{"ta"}) {
|
|
t.Errorf("tags après déplacement vus par l'autre instance : %+v, %v", e, err)
|
|
}
|
|
sh, err := a.CreateShare("fb.txt", ShareOptions{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, err := b.ResolveShare(sh.Token); err != nil || got.Path != "fb.txt" {
|
|
t.Errorf("lien créé par a, résolu par b : %+v, %v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestCatalogImportsJSONOnce(t *testing.T) {
|
|
db := needCatalog(t)
|
|
dir := t.TempDir()
|
|
s, _ := New(dir)
|
|
put(t, s, "a.txt", "a", PutOptions{By: "alice"})
|
|
if err := s.EditTags([]string{"a.txt"}, []string{"Ancien"}, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sh, err := s.CreateShare("a.txt", ShareOptions{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
root := uniqueRoot("import")
|
|
if err := s.UseCatalog(db, root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
e, err := s.Stat("a.txt")
|
|
if err != nil || !slices.Equal(e.Tags, []string{"Ancien"}) || e.EditedBy != "alice" {
|
|
t.Errorf("métadonnées reprises : %+v, %v", e, err)
|
|
}
|
|
if _, err := s.ResolveShare(sh.Token); err != nil {
|
|
t.Errorf("lien repris : %v", err)
|
|
}
|
|
for _, f := range []string{metaFile, sharesFile} {
|
|
if _, err := os.Stat(filepath.Join(dir, f)); err == nil {
|
|
t.Errorf("%s non renommé", f)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, f+".imported")); err != nil {
|
|
t.Errorf("%s.imported absent : %v", f, err)
|
|
}
|
|
}
|
|
// Un .meta.json réapparu n'est pas repris une seconde fois.
|
|
_ = os.WriteFile(filepath.Join(dir, metaFile), []byte(`{"items":{"a.txt":{"tags":["Autre"]}}}`), 0o644)
|
|
s2, _ := New(dir)
|
|
if err := s2.UseCatalog(db, root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if e, _ := s2.Stat("a.txt"); !slices.Equal(e.Tags, []string{"Ancien"}) {
|
|
t.Errorf("reprise rejouée : %v", e.Tags)
|
|
}
|
|
}
|