Files
pages/internal/store/task_capture_backend_test.go
T
2026-11-15 05:47:14 +09:00

208 lines
8.3 KiB
Go

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: "日本語 <mail>", Status: "todo", Bucket: "inbox"}
target := "/mail/2026/11/" + request
body := "<script>not executable</script> {{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, "&lt;script&gt;") || !strings.Contains(rev.Body, "&#123;&#123;children&#125;&#125;") || !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: "日本語 <note>", 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 != "<h1>日本語 &lt;note&gt;</h1>\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)
}
}