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