139 lines
4.4 KiB
Go
139 lines
4.4 KiB
Go
package storage
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/alicebob/miniredis/v2"
|
|
)
|
|
|
|
// newTestClient spins an in-memory Redis and returns a connected Client with
|
|
// the given namespace prefix. The server is torn down with the test.
|
|
func newTestClient(t *testing.T, prefix string) (*Client, *miniredis.Miniredis) {
|
|
t.Helper()
|
|
|
|
s := miniredis.RunT(t)
|
|
c := NewClient(prefix)
|
|
if err := c.Connect("redis://" + s.Addr()); err != nil {
|
|
t.Fatalf("connect to miniredis: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = c.Close() })
|
|
return c, s
|
|
}
|
|
|
|
// TestClearAllMetadata_PurgesCIDReverseIndex is the regression test for the
|
|
// leak: ClearAllMetadata used to delete every file:<root>/* key and the
|
|
// file:__index__ set, but left the cid:<cid> → root reverse-index entries
|
|
// behind. Those stale aliases are not cosmetic — ResolveRoot consults them, so
|
|
// a surviving entry silently redirects a later write into a deleted root.
|
|
func TestClearAllMetadata_PurgesCIDReverseIndex(t *testing.T) {
|
|
for _, prefix := range []string{"", "mm:"} {
|
|
name := "no-prefix"
|
|
if prefix != "" {
|
|
name = "prefixed"
|
|
}
|
|
t.Run(name, func(t *testing.T) {
|
|
c, s := newTestClient(t, prefix)
|
|
|
|
// Two records, each with several CID aliases (a midhash plus
|
|
// siblings) — exactly what the watcher produces.
|
|
aliases := map[string][]string{}
|
|
for i, f := range []string{"watch/a.mkv", "watch/b.mkv"} {
|
|
uuid, err := c.Mint(f, int64(100+i), int64(1000+i))
|
|
if err != nil {
|
|
t.Fatalf("mint: %v", err)
|
|
}
|
|
cids := []string{
|
|
"bafkmid" + uuid,
|
|
"bafkfull" + uuid,
|
|
}
|
|
for _, cidStr := range cids {
|
|
if err := c.AddAlias(uuid, cidStr); err != nil {
|
|
t.Fatalf("add alias %s: %v", cidStr, err)
|
|
}
|
|
}
|
|
aliases[uuid] = cids
|
|
}
|
|
|
|
// An entry already orphaned by a previous (buggy) clear: a
|
|
// reverse-index key whose root no longer exists. The sweep is
|
|
// expected to collect it too.
|
|
if err := s.Set(c.buildCIDIndexKey("bafkorphan"), "01OLDDEADROOT"); err != nil {
|
|
t.Fatalf("seed orphan: %v", err)
|
|
}
|
|
|
|
// Sanity: the aliases resolve before the clear.
|
|
for uuid, cids := range aliases {
|
|
for _, cidStr := range cids {
|
|
if got := c.ResolveRoot(cidStr); got != uuid {
|
|
t.Fatalf("pre-clear ResolveRoot(%s) = %q, want %q", cidStr, got, uuid)
|
|
}
|
|
}
|
|
}
|
|
|
|
deleted, err := c.ClearAllMetadata()
|
|
if err != nil {
|
|
t.Fatalf("ClearAllMetadata: %v", err)
|
|
}
|
|
// deletedCount counts files, not keys.
|
|
if deleted != 2 {
|
|
t.Errorf("deletedCount = %d, want 2 (files, not keys)", deleted)
|
|
}
|
|
|
|
// No reverse-index key may survive — not for the cleared records,
|
|
// not the pre-existing orphan.
|
|
if leaked := s.Keys(); len(leaked) != 0 {
|
|
t.Errorf("keys survived the clear: %v", leaked)
|
|
}
|
|
|
|
// And the aliases must no longer resolve: ResolveRoot returns the
|
|
// hash unchanged when there is no index entry.
|
|
for _, cids := range aliases {
|
|
for _, cidStr := range cids {
|
|
if got := c.ResolveRoot(cidStr); got != cidStr {
|
|
t.Errorf("post-clear ResolveRoot(%s) = %q, want the hash unchanged (stale alias)", cidStr, got)
|
|
}
|
|
}
|
|
}
|
|
if got, err := c.GetByCID("bafkorphan"); err != nil || got != "" {
|
|
t.Errorf("post-clear GetByCID(bafkorphan) = %q (err %v), want \"\"", got, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestClearAllMetadata_LeavesForeignKeysAlone guards the sweep's blast radius:
|
|
// it must key off buildCIDIndexKey (namespace-aware), not a hardcoded "cid:",
|
|
// so a clear on a prefixed client cannot reach another namespace's index.
|
|
func TestClearAllMetadata_LeavesForeignKeysAlone(t *testing.T) {
|
|
c, s := newTestClient(t, "mm:")
|
|
|
|
uuid, err := c.Mint("watch/a.mkv", 100, 1000)
|
|
if err != nil {
|
|
t.Fatalf("mint: %v", err)
|
|
}
|
|
if err := c.AddAlias(uuid, "bafkmine"); err != nil {
|
|
t.Fatalf("add alias: %v", err)
|
|
}
|
|
|
|
// Another namespace's reverse-index entry, plus an unrelated key.
|
|
if err := s.Set("other:cid:bafktheirs", "01THEIRROOT"); err != nil {
|
|
t.Fatalf("seed foreign cid: %v", err)
|
|
}
|
|
if err := s.Set("unrelated", "keep-me"); err != nil {
|
|
t.Fatalf("seed unrelated: %v", err)
|
|
}
|
|
|
|
if _, err := c.ClearAllMetadata(); err != nil {
|
|
t.Fatalf("ClearAllMetadata: %v", err)
|
|
}
|
|
|
|
for _, k := range []string{"other:cid:bafktheirs", "unrelated"} {
|
|
if !s.Exists(k) {
|
|
t.Errorf("clear deleted foreign key %q — the cid sweep is not namespace-aware", k)
|
|
}
|
|
}
|
|
if s.Exists(c.buildCIDIndexKey("bafkmine")) {
|
|
t.Errorf("own reverse-index entry survived the clear")
|
|
}
|
|
}
|