Lot 1 (suite) : paquet catalog et liaison Store <-> PostgreSQL

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
This commit is contained in:
claude BotandClaude Opus 5.5 committed 2026-11-20 17:21:46 +01:00
1 parent f8801f00f9
commit 40c0c4d758
3 files changed
+694

No files matched your search

+162
View File
@@ -0,0 +1,162 @@
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)
}
}