package storage import ( "context" "crypto/rand" "encoding/hex" "errors" "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) } } func TestCatalogSettingsShared(t *testing.T) { db := needCatalog(t) root := uniqueRoot("settings") dirA := t.TempDir() if err := os.WriteFile(filepath.Join(dirA, settingsFile), []byte(`{"title":"Ancien"}`), 0o600); err != nil { t.Fatal(err) } open := func(dir string) *Store { s, err := New(dir) if err != nil { t.Fatal(err) } if err := s.UseCatalog(db, root); err != nil { t.Fatal(err) } return s } a, b := open(dirA), open(t.TempDir()) if st, err := b.ReadSettings(); err != nil || st.Title != "Ancien" { t.Fatalf("reprise : %v %+v", err, st) } if _, err := a.WriteTitle("Partagé"); err != nil { t.Fatal(err) } if _, err := b.WriteQuota(42); err != nil { t.Fatal(err) } st, err := a.ReadSettings() if err != nil || st.Title != "Partagé" || st.QuotaMB != 42 || st.Logo != "" { t.Fatalf("réglages : %v %+v", err, st) } if _, err := a.WriteLogo(makePNG(10, 10)); err != nil { t.Fatal(err) } if st, _ := b.ReadSettings(); st.Logo == "" { t.Error("logo non partagé") } if l, err := b.ReadLogo(); err != nil || len(l) == 0 { t.Fatalf("logo : %v", err) } if _, err := b.DeleteLogo(); err != nil { t.Fatal(err) } if _, err := a.ReadLogo(); !errors.Is(err, ErrNotFound) { t.Fatalf("logo supprimé : %v", err) } } // SHARE_SECRET=hex: garde valides les liens existants. func TestShareSecretHexKeepsLinks(t *testing.T) { dir := t.TempDir() s, err := New(dir) if err != nil { t.Fatal(err) } if err := os.MkdirAll(filepath.Join(dir, "d"), 0o755); err != nil { t.Fatal(err) } sh, err := s.CreateShare("d", ShareOptions{}) if err != nil { t.Fatal(err) } b, err := os.ReadFile(filepath.Join(dir, secretFile)) if err != nil { t.Fatal(err) } s2, _ := New(dir) if err := s2.SetShareSecret("hex:" + string(b)); err != nil { t.Fatal(err) } if _, err := s2.ResolveShare(sh.Token); err != nil { t.Fatalf("lien existant refusé : %v", err) } for _, bad := range []string{"court", "hex:zz", "hex:abcd"} { if _, err := DecodeSecret(bad); err == nil { t.Errorf("%q accepté", bad) } } }