package store import ( "context" "database/sql" "database/sql/driver" "errors" "fmt" "sync" "sync/atomic" "testing" "time" "modernc.org/sqlite" "pageswiki/internal/db" ) func zombieFixture(t *testing.T) (*Store, string) { t.Helper() filename := t.TempDir() + "/zombie.db" database, err := db.Open(filename) if err != nil { t.Fatal(err) } t.Cleanup(func() { database.Close() }) if err := db.Migrate(database); err != nil { t.Fatal(err) } return New(database), filename } func seedZombie(t *testing.T, st *Store, id, domain string) { t.Helper() if _, err := st.DB.Exec(`INSERT INTO objects(uuid,kind,created_at) VALUES(?,'page',1)`, id); err != nil { t.Fatal(err) } if domain != "" { if _, err := st.DB.Exec(`INSERT INTO object_origins(object_uuid,domain_uuid,created_at) VALUES(?,?,1)`, id, domain); err != nil { t.Fatal(err) } } } func requireGCObject(t *testing.T, st *Store, id string, want bool) { t.Helper() var exists bool if err := st.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM objects WHERE uuid=?)`, id).Scan(&exists); err != nil || exists != want { t.Fatalf("Object %s exists=%v want=%v err=%v", id, exists, want, err) } } func TestZombieGCDomainProvenanceAndGlobalReferenceProtection(t *testing.T) { st, _ := zombieFixture(t) for _, spec := range [][2]string{{"own", "local"}, {"foreign", "foreign"}, {"legacy", ""}, {"foreign-path", "local"}, {"foreign-asset", "local"}} { seedZombie(t, st, spec[0], spec[1]) } if _, err := st.DB.Exec(` INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES('foreign','/kept','foreign-path',1); INSERT INTO assets(domain_uuid,address,object_uuid,created_at_ms,updated_at_ms) VALUES('foreign','asset:file:kept','foreign-asset',1,1) `); err != nil { t.Fatal(err) } zombies, err := st.ListZombieObjectsInDomain(context.Background(), "local", 0, 100) if err != nil || len(zombies) != 1 || zombies[0].UUID != "own" { t.Fatalf("scoped list=%+v err=%v", zombies, err) } if n, err := st.PurgeZombieObjectsInDomain(context.Background(), "local", 0, 100); err != nil || n != 1 { t.Fatalf("scoped purge=%d err=%v", n, err) } requireGCObject(t, st, "own", false) for _, id := range []string{"foreign", "legacy", "foreign-path", "foreign-asset"} { requireGCObject(t, st, id, true) } if n, err := st.PurgeZombieObjects(0, 100); err != nil || n != 2 { t.Fatalf("trusted maintenance=%d err=%v", n, err) } for _, id := range []string{"foreign-path", "foreign-asset"} { requireGCObject(t, st, id, true) } var origins int if err := st.DB.QueryRow(`SELECT COUNT(*) FROM object_origins WHERE object_uuid IN ('own','foreign')`).Scan(&origins); err != nil || origins != 0 { t.Fatalf("orphan origin count=%d err=%v", origins, err) } } func TestZombieGCProtectsAllBytesHistoryAndSemanticReferences(t *testing.T) { st, _ := zombieFixture(t) ids := []string{"no-revision", "empty-inline", "empty-cas", "inconsistent-hash", "nul-byte", "nonempty-cas", "historical-body", "attachment", "spot", "inbox", "override", "editor", "grant"} for _, id := range ids { seedZombie(t, st, id, "local") } for _, spec := range []struct{ id, body, hash string }{ {"empty-inline", "", ""}, {"empty-cas", "", emptyDocumentSHA256}, {"inconsistent-hash", "keep", emptyDocumentSHA256}, {"nul-byte", "\x00", ""}, {"nonempty-cas", "", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}, {"historical-body", "keep", ""}, {"attachment", "", emptyDocumentSHA256}, } { if _, err := st.DB.Exec(`INSERT INTO revisions(uuid,object_uuid,body,document_hash,created_at_ms,created_at) VALUES(?,?,?,?,1,1)`, spec.id+"-rev", spec.id, spec.body, spec.hash); err != nil { t.Fatal(err) } } if _, err := st.DB.Exec(` INSERT INTO revisions(uuid,object_uuid,body,document_hash,created_at_ms,created_at) VALUES('head','historical-body','','',2,2); INSERT INTO revision_document_refs(revision_uuid,document_hash) VALUES('attachment-rev','attachment-hash'); INSERT INTO spot_pages(spot_uuid,page_uuid,created_at_ms) VALUES('spot-id','spot',1); INSERT INTO street_inbox_pages(street_uuid,page_uuid,created_at_ms) VALUES('street-id','inbox',1); INSERT INTO city_page_overrides(domain_uuid,page_uuid,spot_uuid) VALUES('local','override','spot-id'); INSERT INTO adapter_sessions(ticket_hash,domain_uuid,plugin_id,object_uuid,base_revision_uuid,ticket_expires_at_ms,created_at_ms) VALUES('ticket','local','editor','editor','',9999999999999,1); INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES('grant-id','role','read','object','grant',1) `); err != nil { t.Fatal(err) } if n, err := st.PurgeZombieObjects(0, 100); err != nil || n != 3 { t.Fatalf("purged=%d err=%v", n, err) } for i, id := range ids { requireGCObject(t, st, id, i >= 3) } } // Keep a second connection's write transaction open while GC starts. In WAL // mode, the old implementation read stale candidates successfully before // waiting for that writer, then deleted a newly linked/populated Object. func TestZombieGCSeesLatePathAssetAndRevisionCommit(t *testing.T) { for _, change := range []string{"path", "asset", "revision"} { t.Run(change, func(t *testing.T) { st, filename := zombieFixture(t) seedZombie(t, st, "late", "local") writer, err := db.Open(filename) if err != nil { t.Fatal(err) } defer writer.Close() tx, err := writer.Begin() if err != nil { t.Fatal(err) } defer tx.Rollback() switch change { case "path": _, err = tx.Exec(`INSERT INTO paths(domain_uuid,path,object_uuid,created_at) VALUES('foreign','/late','late',1)`) case "asset": _, err = tx.Exec(`INSERT INTO assets(domain_uuid,address,object_uuid,created_at_ms,updated_at_ms) VALUES('foreign','asset:file:late','late',1,1)`) case "revision": _, err = tx.Exec(`INSERT INTO revisions(uuid,object_uuid,body,created_at_ms,created_at) VALUES('late-revision','late','keep',1,1)`) } if err != nil { t.Fatal(err) } type outcome struct { n int err error } result := make(chan outcome, 1) go func() { n, err := st.PurgeZombieObjects(0, 100); result <- outcome{n, err} }() waitForBlockedGCWriter(t, st.DB) if err := tx.Commit(); err != nil { t.Fatal(err) } select { case got := <-result: if got.err != nil || got.n != 0 { t.Fatalf("late %s lost: purged=%d err=%v", change, got.n, got.err) } case <-time.After(5 * time.Second): t.Fatal("GC did not finish after writer committed") } requireGCObject(t, st, "late", true) }) } } func waitForBlockedGCWriter(t *testing.T, database *sql.DB) { t.Helper() deadline := time.NewTimer(2 * time.Second) defer deadline.Stop() tick := time.NewTicker(time.Millisecond) defer tick.Stop() for database.Stats().InUse == 0 { select { case <-tick.C: case <-deadline.C: t.Fatal("writer did not acquire a database connection") } } // The pending writer holds the SQLite lock for the whole interval, allowing // even the old read-then-write implementation to reach its blocked DELETE. time.Sleep(100 * time.Millisecond) } func TestZombieGCLimitsCancellationAndRollback(t *testing.T) { st, _ := zombieFixture(t) if _, err := st.DB.Exec(`WITH RECURSIVE seq(n) AS (VALUES(1) UNION ALL SELECT n+1 FROM seq WHERE n<1005) INSERT INTO objects(uuid,kind,created_at) SELECT printf('z-%04d',n),'page',1 FROM seq; INSERT INTO object_origins(object_uuid,domain_uuid,created_at) SELECT uuid,'local',1 FROM objects`); err != nil { t.Fatal(err) } zombies, err := st.ListZombieObjects(0) if err != nil || len(zombies) != ZombieGCMaxLimit { t.Fatalf("global listing not bounded: n=%d err=%v", len(zombies), err) } zombies, err = st.ListZombieObjectsInDomain(context.Background(), "local", 0, 3) if err != nil || len(zombies) != 3 || zombies[0].UUID != "z-0001" { t.Fatalf("SQL limit/order: %+v %v", zombies, err) } for _, limit := range []int{-1, ZombieGCMaxLimit + 1} { if _, err := st.PurgeZombieObjects(0, limit); !errors.Is(err, ErrZombieGCOptions) { t.Fatalf("invalid limit %d accepted: %v", limit, err) } } if _, err := st.PurgeZombieObjects(-1, 1); !errors.Is(err, ErrZombieGCOptions) { t.Fatal("negative grace accepted") } if _, err := st.PurgeZombieObjectsInDomain(context.Background(), "", 0, 1); !errors.Is(err, ErrZombieGCOptions) { t.Fatal("missing Domain became global maintenance") } ctx, cancel := context.WithCancel(context.Background()) cancel() if _, err := st.ListZombieObjectsInDomain(ctx, "local", 0, 1); !errors.Is(err, context.Canceled) { t.Fatalf("list cancellation=%v", err) } if _, err := st.PurgeZombieObjectsInDomain(ctx, "local", 0, 1); !errors.Is(err, context.Canceled) { t.Fatalf("purge cancellation=%v", err) } if _, err := st.DB.Exec(`INSERT INTO tags(object_uuid,tag) VALUES('z-0001','keep'); INSERT INTO revisions(uuid,object_uuid,body,created_at_ms,created_at) VALUES('empty-rev','z-0001','',1,1); CREATE TRIGGER reject_zombie_delete BEFORE DELETE ON objects BEGIN SELECT RAISE(ABORT,'injected failure'); END`); err != nil { t.Fatal(err) } if n, err := st.PurgeZombieObjects(0, 1); err == nil || n != 0 { t.Fatalf("partial success escaped rollback: %d %v", n, err) } for _, query := range []string{`SELECT COUNT(*) FROM objects WHERE uuid='z-0001'`, `SELECT COUNT(*) FROM tags WHERE object_uuid='z-0001'`, `SELECT COUNT(*) FROM revisions WHERE uuid='empty-rev'`, `SELECT COUNT(*) FROM object_origins WHERE object_uuid='z-0001'`} { var n int if err := st.DB.QueryRow(query).Scan(&n); err != nil || n != 1 { t.Fatalf("rollback lost %s: %d %v", query, n, err) } } if _, err := st.DB.Exec(`DROP TRIGGER reject_zombie_delete`); err != nil { t.Fatal(err) } if n, err := st.PurgeZombieObjects(0, 2); err != nil || n != 2 { t.Fatalf("purge limit=%d %v", n, err) } if n, err := st.PurgeZombieObjects(0, 0); err != nil || n != ZombieGCDefaultLimit { t.Fatalf("zero limit must be bounded default: %d %v", n, err) } } func TestObjectWritersRejectGCRaceInsteadOfCreatingOrphans(t *testing.T) { for _, operation := range []string{"path"} { t.Run(operation, func(t *testing.T) { st, filename := zombieFixture(t) seedZombie(t, st, "gone", "") seedZombie(t, st, "keeper", "") domain, err := st.GetDefaultDomain() if err != nil { t.Fatal(err) } if err := st.BindPathInDomain(domain.UUID, "/kept", "keeper"); err != nil { t.Fatal(err) } writer, err := db.Open(filename) if err != nil { t.Fatal(err) } defer writer.Close() tx, err := writer.Begin() if err != nil { t.Fatal(err) } defer tx.Rollback() if _, err = tx.Exec(`DELETE FROM objects WHERE uuid='gone'`); err != nil { t.Fatal(err) } result := make(chan error, 1) go func() { result <- st.BindPathInDomain(domain.UUID, "/kept", "gone") }() waitForBlockedGCWriter(t, st.DB) if err := tx.Commit(); err != nil { t.Fatal(err) } select { case err := <-result: if !errors.Is(err, ErrPageNotFound) { t.Fatalf("late %s write error=%v", operation, err) } case <-time.After(5 * time.Second): t.Fatal("late write did not finish") } var orphan int if err := st.DB.QueryRow(`SELECT (SELECT COUNT(*) FROM paths WHERE object_uuid='gone')+(SELECT COUNT(*) FROM revisions WHERE object_uuid='gone')`).Scan(&orphan); err != nil || orphan != 0 { t.Fatalf("orphan data=%d %v", orphan, err) } if id, err := st.ResolvePathInDomain(domain.UUID, "/kept"); err != nil || id != "keeper" { t.Fatalf("failed bind replaced existing Path: %s %v", id, err) } }) } } var zombieReadFunctionID atomic.Uint64 // Delay the external existence precheck without holding a writer lock. GC can // commit after that read snapshot, before Revision INSERT begins. This tests // the atomic INSERT guard itself, without timing assumptions or runtime hooks. func TestObjectWritersRevisionRechecksAfterZombieGC(t *testing.T) { reading, resume := make(chan struct{}), make(chan struct{}) var entered atomic.Bool var released sync.Once defer released.Do(func() { close(resume) }) functionName := fmt.Sprintf("test_zombie_precheck_%d", zombieReadFunctionID.Add(1)) if err := sqlite.RegisterScalarFunction(functionName, 1, func(_ *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) { if entered.CompareAndSwap(false, true) { close(reading) <-resume } return args[0], nil }); err != nil { t.Fatal(err) } st, filename := zombieFixture(t) seedZombie(t, st, "gone", "") if _, err := st.DB.Exec(`ALTER TABLE objects RENAME TO gc_physical_objects; CREATE VIEW objects AS SELECT ` + functionName + `(uuid) AS uuid,kind,created_at FROM gc_physical_objects`); err != nil { t.Fatal(err) } result := make(chan error, 1) go func() { _, err := st.SaveRevision("gone", "keep this", "late"); result <- err }() select { case <-reading: case <-time.After(5 * time.Second): t.Fatal("Revision did not reach its Object precheck") } writer, err := db.Open(filename) if err != nil { t.Fatal(err) } defer writer.Close() if _, err := writer.Exec(`DELETE FROM gc_physical_objects WHERE uuid='gone'`); err != nil { t.Fatal(err) } released.Do(func() { close(resume) }) select { case err := <-result: if !errors.Is(err, ErrPageNotFound) { t.Fatalf("Revision did not revalidate after Object deletion: %v", err) } case <-time.After(5 * time.Second): t.Fatal("Revision INSERT did not finish") } var count int if err := st.DB.QueryRow(`SELECT COUNT(*) FROM revisions WHERE object_uuid='gone'`).Scan(&count); err != nil || count != 0 { t.Fatalf("orphan Revision count=%d err=%v", count, err) } } func TestZombieGCSchemaAllowsDomainOnlyStore(t *testing.T) { database, err := sql.Open("sqlite", fmt.Sprintf("file:%s?mode=memory&cache=shared", t.Name())) if err != nil { t.Fatal(err) } defer database.Close() if err := (&Store{DB: database}).EnsureZombieGCSchema(); err != nil { t.Fatal(err) } }