package store import ( "context" "database/sql" "errors" "fmt" "strings" "testing" "github.com/google/uuid" ) func TestTaskCaptureBackend(t *testing.T) { for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} { t.Run(fmt.Sprint(b), func(t *testing.T) { s, d, a := taskBackendFixture(t, b) ctx := context.Background() request := uuid.NewString() item := TaskRecord{Kind: "task", Title: "日本語 ", Status: "todo", Bucket: "inbox"} target := "/mail/2026/11/" + request body := " {{children}} 日本語" generation, err := s.NavigationGeneration(ctx) if err != nil { t.Fatal(err) } got, err := s.CaptureTaskWithWiki(ctx, d, a, request, "synthetic-hash", item, target, body) if err != nil || got.PageUUID == "" || got.UUID != request { t.Fatal(got, err) } if id, err := s.ResolvePathInDomain(d, target); err != nil || id != got.PageUUID { t.Fatal(id, err) } rev, err := s.GetLatestRevision(got.PageUUID) if err != nil || !strings.Contains(rev.Body, "<script>") || !strings.Contains(rev.Body, "{{children}}") || !strings.Contains(rev.Body, "日本語") { t.Fatal(rev, err) } if version, err := s.NavigationGeneration(ctx); err != nil || version <= generation { t.Fatal("cache generation", version, err) } if b == storePostgreSQL { var origin, storedBody string var primary int if err = s.DB.QueryRow(`SELECT domain_uuid FROM object_origins WHERE object_uuid=$1`, got.PageUUID).Scan(&origin); err != nil || origin != d { t.Fatal(origin, err) } if err = s.DB.QueryRow(`SELECT is_primary FROM paths WHERE domain_uuid=$1 AND path=$2`, d, target).Scan(&primary); err != nil || primary != 1 { t.Fatal(primary, err) } if err = s.DB.QueryRow(`SELECT body FROM revisions WHERE uuid=$1`, rev.UUID).Scan(&storedBody); err != nil || storedBody != "" { t.Fatal("payload in metadata", err) } if payload, err := s.readDocument(rev.DocumentHash); err != nil || payload != rev.Body { t.Fatal("canonical payload", err) } } if replay, err := s.CaptureTaskWithWiki(ctx, d, a, request, "synthetic-hash", item, target, body); err != nil || replay.PageUUID != got.PageUUID || replay.Version != got.Version { t.Fatal(replay, err) } if _, err = s.CapturedTask(ctx, d, a, request, "different"); !errors.Is(err, ErrTaskConflict) { t.Fatal(err) } collision := uuid.NewString() if _, err = s.CaptureTaskWithWiki(ctx, d, a, collision, "other", item, target, body); !errors.Is(err, ErrTaskNoteExists) { t.Fatal(err) } if _, err = s.GetTask(ctx, d, a, collision); !errors.Is(err, sql.ErrNoRows) { t.Fatal("orphan task", err) } if err = s.DeleteTask(ctx, d, a, got.UUID, got.Version); err != nil { t.Fatal(err) } if _, err = s.CapturedTask(ctx, d, a, request, "synthetic-hash"); !errors.Is(err, ErrTaskDeleted) { t.Fatal(err) } newID := TaskRecreationID(request) recreated, err := s.RecreateCapturedTask(ctx, d, a, newID, "new", item, target, "must not replace surviving wiki", request) if err != nil || recreated.PageUUID != got.PageUUID || recreated.UUID == got.UUID { t.Fatal(recreated, err) } if replay, err := s.RecreateCapturedTask(ctx, d, a, newID, "new", item, target, "", request); err != nil || replay.UUID != recreated.UUID { t.Fatal(replay, err) } if latest, err := s.GetLatestRevision(got.PageUUID); err != nil || latest.UUID != rev.UUID || latest.Body != rev.Body { t.Fatal("recreation overwrote wiki", latest, err) } var events int if err = s.DB.QueryRow(`SELECT count(*) FROM activity_outbox WHERE domain_uuid=`+s.sqlParam(1)+` AND ((event_type='page.created' AND target_uuid=`+s.sqlParam(2)+`) OR (event_type='revision.created' AND target_uuid=`+s.sqlParam(3)+`))`, d, got.PageUUID, rev.UUID).Scan(&events); err != nil || events != 2 { t.Fatal(events, err) } // A receipt without a task or tombstone must never silently recreate. orphan := uuid.NewString() if _, err = s.DB.Exec(`INSERT INTO organizer_capture_receipts(domain_uuid,owner_uuid,request_uuid,request_hash,item_uuid) VALUES(`+s.sqlValues(5)+`)`, d, a, orphan, "orphan", orphan); err != nil { t.Fatal(err) } if _, err = s.CapturedTask(ctx, d, a, orphan, "orphan"); !errors.Is(err, ErrTaskCaptureMissing) { t.Fatal(err) } }) } } func TestTaskNotesBackend(t *testing.T) { for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} { t.Run(fmt.Sprint(b), func(t *testing.T) { s, d, a := taskBackendFixture(t, b) ctx := context.Background() page, err := s.CreatePageAtPathInDomain(d, "/project") if err != nil { t.Fatal(err) } project, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "project", Title: "Project", Status: "todo", Bucket: "inbox", PageUUID: page, NotesSubpath: "notes"}, 0) if err != nil { t.Fatal(err) } item, err := s.SaveTask(ctx, d, a, TaskRecord{UUID: uuid.NewString(), Kind: "task", Title: "日本語 ", ProjectUUID: project.UUID, Status: "todo", Bucket: "inbox"}, 0) if err != nil { t.Fatal(err) } target := TaskNotePath("/project", project, item) stale := project stale.Version++ if _, err = s.CreateTaskNote(ctx, d, a, item, item.Version, stale, "/project", target); !errors.Is(err, ErrTaskConflict) { t.Fatal(err) } note, err := s.CreateTaskNote(ctx, d, a, item, item.Version, project, "/project", target) if err != nil || note.PageUUID == "" { t.Fatal(note, err) } if id, err := s.ResolvePathInDomain(d, target); err != nil || id != note.PageUUID { t.Fatal(id, err) } if rev, err := s.GetLatestRevision(note.PageUUID); err != nil || rev.Body != "

日本語 <note>

\n" { t.Fatal(rev, err) } if _, err = s.CreateTaskNote(ctx, d, a, item, item.Version, project, "/project", target); !errors.Is(err, ErrTaskConflict) { t.Fatal(err) } other := item other.UUID = uuid.NewString() other.Version = 0 other, err = s.SaveTask(ctx, d, a, other, 0) if err != nil { t.Fatal(err) } if _, err = s.CreateTaskNote(ctx, d, a, other, other.Version, project, "/project", target); !errors.Is(err, ErrTaskNoteExists) { t.Fatal(err) } if got, err := s.GetTask(ctx, d, a, other.UUID); err != nil || got.PageUUID != "" || got.Version != other.Version { t.Fatal(got, err) } }) } } func TestPostgreSQLCaptureAtomicity(t *testing.T) { s, d, a := taskBackendFixture(t, storePostgreSQL) ctx := context.Background() item := TaskRecord{Kind: "task", Title: "capture", Status: "todo", Bucket: "inbox"} counts := func() []int { out := []int{} for _, table := range []string{"organizer_items", "organizer_capture_receipts", "objects", "object_origins", "paths", "revisions", "activity_outbox"} { var n int if err := s.DB.QueryRow(`SELECT count(*) FROM ` + table).Scan(&n); err != nil { t.Fatal(err) } out = append(out, n) } return out } before := fmt.Sprint(counts()) // Fail receipt insertion after Page creation, not its initial lookup. if _, err := s.DB.Exec(`ALTER TABLE organizer_capture_receipts ADD CONSTRAINT synthetic_capture_failure CHECK(request_hash <> 'fail')`); err != nil { t.Fatal(err) } if _, err := s.CaptureTaskWithWiki(ctx, d, a, uuid.NewString(), "fail", item, "/mail/failure", "private synthetic content"); err == nil { t.Fatal("injected failure accepted") } if after := fmt.Sprint(counts()); before != after { t.Fatal("partial commit", before, after) } peer := &Store{DB: s.DB, sqlBackend: storePostgreSQL, DocumentRoot: s.DocumentRoot} type result struct { task TaskRecord err error } ch := make(chan result, 2) request := uuid.NewString() for _, w := range []*Store{s, peer} { go func(w *Store) { v, e := w.CaptureTaskWithWiki(ctx, d, a, request, "same", item, "/mail/concurrent", "body") ch <- result{v, e} }(w) } one, two := <-ch, <-ch if one.err != nil || two.err != nil || one.task.UUID != two.task.UUID || one.task.PageUUID != two.task.PageUUID { t.Fatal(one, two) } var n int if err := s.DB.QueryRow(`SELECT count(*) FROM paths WHERE domain_uuid=$1 AND path='/mail/concurrent'`, d).Scan(&n); err != nil || n != 1 { t.Fatal(n, err) } s.ReadOnly = true if _, err := s.CaptureTaskWithWiki(ctx, d, a, uuid.NewString(), "readonly", item, "/mail/readonly", "body"); !errors.Is(err, ErrReadOnly) { t.Fatal(err) } }