Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
369 lines
14 KiB
Go
369 lines
14 KiB
Go
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)
|
|
}
|
|
}
|