package metadata import ( "bytes" "context" "encoding/json" "errors" "io" "strings" "sync" "testing" "time" "pageswiki/internal/documentrefs" "pageswiki/internal/geduldh" ) type faultDocuments struct { geduldh.Store putErr error verifyErr error afterPut func() } func (f faultDocuments) PutIfAbsent(ctx context.Context, h string, n int64, reader io.Reader) error { if f.putErr != nil { return f.putErr } if err := f.Store.PutIfAbsent(ctx, h, n, reader); err != nil { return err } if f.afterPut != nil { f.afterPut() } return nil } func (f faultDocuments) Verify(ctx context.Context, h string) error { if f.verifyErr != nil { return f.verifyErr } return f.Store.Verify(ctx, h) } func documentFixture(t *testing.T, r *Repository) (geduldh.Store, string, Revision) { t.Helper() ctx := context.Background() documents, err := geduldh.NewLocal(t.TempDir()) if err != nil { t.Fatal(err) } content := []byte("synthetic image") h := hash(string(content)) if err := documents.PutIfAbsent(ctx, h, int64(len(content)), bytes.NewReader(content)); err != nil { t.Fatal(err) } if _, err := r.PutAsset(ctx, Asset{DomainUUID: "test", Address: "asset:image:cover", HeadDocumentHash: h, ContentType: "image/png", SizeBytes: int64(len(content))}, "", "actor"); err != nil { t.Fatal(err) } object, err := r.CreatePage(ctx, "test", "/guide") if err != nil { t.Fatal(err) } return documents, h, Revision{ObjectUUID: object, Language: "ja", ContentType: "text/html; charset=utf-8", Message: "synthetic save"} } func TestDocumentSaveReferencesOutboxAndRestore(t *testing.T) { for _, backend := range []Backend{SQLite, PostgreSQL} { t.Run(string(backend), func(t *testing.T) { r := testRepository(t, backend) ctx := context.Background() docs, assetHash, v := documentFixture(t, r) body := []byte(`

Guide

`) if _, err := r.PutAsset(ctx, Asset{DomainUUID: "private-domain", Address: "asset:image:private", HeadDocumentHash: assetHash, ContentType: "image/png", SizeBytes: 15}, "", "actor"); err != nil { t.Fatal(err) } if _, err := r.SaveDocument(ctx, docs, "test", v, []byte(``), "", "actor"); !errors.Is(err, documentrefs.ErrUnavailable) { t.Fatal("foreign Asset resolved", err) } first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor") if err != nil { t.Fatal(err) } if !strings.Contains(string(first.Payload), "/_/obj/sha256:"+assetHash) { t.Fatal("mutable URL not frozen") } if err := docs.Verify(ctx, first.Revision.DocumentHash); err != nil { t.Fatal("metadata published without durable Document", err) } refs, err := r.revisionReferences(ctx, "test", first.Revision.UUID) if err != nil || len(refs) != 1 || refs[0] != assetHash { t.Fatal("embedded reference", err, refs) } var eventDomain, target, payload, actor string var sequence int64 if err := r.database.QueryRowContext(ctx, `SELECT domain_uuid,target_uuid,payload,actor_uuid,sequence FROM activity_outbox`).Scan(&eventDomain, &target, &payload, &actor, &sequence); err != nil { t.Fatal(err) } var envelope map[string]string if err := json.Unmarshal([]byte(payload), &envelope); err != nil || eventDomain != "test" || actor != "actor" || sequence != 1 || target != first.Revision.UUID || envelope["document_hash"] != first.Revision.DocumentHash { t.Fatal("outbox envelope mismatch", err) } newContent := []byte("next synthetic image") newHash := hash(string(newContent)) if err := docs.PutIfAbsent(ctx, newHash, int64(len(newContent)), bytes.NewReader(newContent)); err != nil { t.Fatal(err) } if _, err := r.PutAsset(ctx, Asset{DomainUUID: "test", Address: "asset:image:cover", HeadDocumentHash: newHash, ContentType: "image/png", SizeBytes: int64(len(newContent))}, assetHash, "actor"); err != nil { t.Fatal(err) } second, err := r.SaveDocument(ctx, docs, "test", v, first.Payload, first.Revision.UUID, "actor") if err != nil { t.Fatal(err) } if !strings.Contains(string(second.Payload), newHash) { t.Fatal("provenance not refreshed") } restored, err := r.RestoreRevision(ctx, "test", first.Revision.UUID, second.Revision.UUID, "restore") if err != nil { t.Fatal(err) } refs, err = r.revisionReferences(ctx, "test", restored.UUID) if err != nil || len(refs) != 1 || refs[0] != assetHash || restored.DocumentHash != first.Revision.DocumentHash { t.Fatal("restore followed new Asset HEAD instead of historical refs", err) } var count int if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM activity_outbox`).Scan(&count); err != nil || count != 3 { t.Fatal("save/restore event count", count, err) } }) } } func TestDocumentSaveFailureIsAtomic(t *testing.T) { for _, backend := range []Backend{SQLite, PostgreSQL} { for _, stage := range []string{"references", "outbox"} { t.Run(string(backend)+"/"+stage, func(t *testing.T) { r := testRepository(t, backend) ctx := context.Background() docs, _, v := documentFixture(t, r) body := []byte(``) first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor") if err != nil { t.Fatal(err) } ddl := `CREATE UNIQUE INDEX synthetic_save_failure ON revision_document_refs(document_hash)` if stage == "outbox" { ddl = `CREATE UNIQUE INDEX synthetic_save_failure ON activity_outbox(domain_uuid)` } if _, err := r.database.ExecContext(ctx, ddl); err != nil { t.Fatal(err) } if _, err := r.SaveDocument(ctx, docs, "test", v, append([]byte(`

change

`), body...), first.Revision.UUID, "actor"); !errors.Is(err, ErrConflict) { t.Fatal("injected error ignored", err) } for _, table := range []string{"revisions", "revision_document_refs", "activity_outbox"} { var n int if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM `+table).Scan(&n); err != nil || n != 1 { t.Fatal("partial commit", table, n, err) } } var last int64 if err := r.database.QueryRowContext(ctx, `SELECT last_sequence FROM activity_outbox_heads WHERE domain_uuid='test'`).Scan(&last); err != nil || last != 1 { t.Fatal("sequence advanced on failure", err) } if _, err := r.database.ExecContext(ctx, `DROP INDEX synthetic_save_failure`); err != nil { t.Fatal(err) } if _, err := r.SaveDocument(ctx, docs, "test", v, body, first.Revision.UUID, "actor"); err != nil { t.Fatal("retry after rollback", err) } }) } } } func TestDocumentSavePersistenceFailureAndConcurrentEdit(t *testing.T) { for _, backend := range []Backend{SQLite, PostgreSQL} { t.Run(string(backend), func(t *testing.T) { r := testRepository(t, backend) ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() docs, _, v := documentFixture(t, r) body := []byte(``) for _, failing := range []faultDocuments{{Store: docs, putErr: io.ErrClosedPipe}, {Store: docs, verifyErr: geduldh.ErrHashMismatch}} { if _, err := r.SaveDocument(ctx, failing, "test", v, body, "", "actor"); err == nil { t.Fatal("Document failure ignored") } var n int if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM revisions`).Scan(&n); err != nil || n != 0 { t.Fatal("failed persistence published revision", err) } } first, err := r.SaveDocument(ctx, docs, "test", v, body, "", "actor") if err != nil { t.Fatal(err) } // The callback writes using a different transaction during Document I/O. // It would deadlock if SaveDocument held SQL locks over the payload write. race := faultDocuments{Store: docs, afterPut: func() { peer, _ := New(r.database, backend) competing := v competing.DocumentHash = first.Revision.DocumentHash if _, err := peer.AppendRevision(ctx, "test", competing, first.Revision.UUID); err != nil { t.Fatal("I/O held metadata lock", err) } }} if _, err := r.SaveDocument(ctx, race, "test", v, []byte("

stale

"), first.Revision.UUID, "actor"); !errors.Is(err, ErrConflict) { t.Fatal("CAS not repeated after payload I/O", err) } var n int if err := r.database.QueryRowContext(ctx, `SELECT count(*) FROM activity_outbox`).Scan(&n); err != nil || n != 2 { t.Fatal("conflicting write emitted event", err) } }) } } func TestOutboxSequenceForConcurrentObjects(t *testing.T) { for _, backend := range []Backend{SQLite, PostgreSQL} { t.Run(string(backend), func(t *testing.T) { r := testRepository(t, backend) ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() objects := make([]string, 6) for i := range objects { var err error objects[i], err = r.CreatePage(ctx, "test", "/"+strings.Repeat("a", i+1)) if err != nil { t.Fatal(err) } } var wg sync.WaitGroup errs := make(chan error, len(objects)) for _, id := range objects { wg.Add(1) go func(id string) { defer wg.Done() peer, _ := New(r.database, backend) _, err := peer.AppendRevision(ctx, "test", Revision{ObjectUUID: id, DocumentHash: hash(id), ContentType: "text/html"}, "") errs <- err }(id) } wg.Wait() close(errs) for err := range errs { if err != nil { t.Fatal(err) } } var count int var min, max int64 if err := r.database.QueryRowContext(ctx, `SELECT count(*),min(sequence),max(sequence) FROM activity_outbox`).Scan(&count, &min, &max); err != nil || count != 6 || min != 1 || max != 6 { t.Fatal("invalid concurrent sequence", count, min, max, err) } }) } }