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

135 lines
4.4 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"sync"
"testing"
)
func TestActivityConsumersBackend(t *testing.T) {
for _, backend := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(backend), func(t *testing.T) {
s := testNamespaceStore(t, backend)
ctx := context.Background()
for range 2 {
if err := s.EnsureActivityOutboxSchema(); err != nil {
t.Fatal(err)
}
}
// Source and its envelope share one transaction, including rollback.
appendEvents := func(commit bool) {
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
if err = s.lockTaskWriter(ctx, tx); err != nil {
t.Fatal(err)
}
for _, domain := range []string{"synthetic-a", "synthetic-b"} {
for i, typ := range []string{"task.changed", "noise", "page.changed", "task.changed"} {
e := ActivityOutboxEvent{DomainUUID: domain, EventType: typ, IdempotencyKey: fmt.Sprint(i)}
out, created, err := s.AppendActivityOutboxTx(tx, e)
if err != nil || !created || out.Sequence != int64(i+1) {
t.Fatal(out, created, err)
}
again, created, err := s.AppendActivityOutboxTx(tx, e)
if err != nil || created || again.UUID != out.UUID {
t.Fatal(again, created, err)
}
}
}
if commit {
if err = tx.Commit(); err != nil {
t.Fatal(err)
}
}
}
appendEvents(false)
sub := ActivitySubscription{ConsumerID: "consumer-a", EventTypes: []string{"task.changed", "page.changed"}}
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 0 {
t.Fatal(domains, err)
}
appendEvents(true)
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 2 {
t.Fatal(domains, err)
}
items, err := s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 2)
if err != nil || len(items) != 2 || items[0].Sequence != 1 || items[1].Sequence != 3 {
t.Fatal(items, err)
}
if err = s.CompleteActivityOutboxThrough(sub.ConsumerID, "synthetic-a", 3); err != nil {
t.Fatal(err)
}
before, err := s.ActivityOutboxCheckpoint(sub.ConsumerID, "synthetic-a")
if err != nil {
t.Fatal(err)
}
if err = s.CompleteActivityOutboxThrough(sub.ConsumerID, "synthetic-a", 1); err != nil {
t.Fatal(err)
}
after, err := s.ActivityOutboxCheckpoint(sub.ConsumerID, "synthetic-a")
if err != nil || before != after {
t.Fatal(before, after, err)
}
items, err = s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 10)
if err != nil || len(items) != 1 || items[0].Sequence != 4 {
t.Fatal(items, err)
}
// Another subscriber still sees the complete history.
sub.ConsumerID = "consumer-b"
items, err = s.ActivityOutboxForConsumer(ctx, sub, "synthetic-a", 10)
if err != nil || len(items) != 3 {
t.Fatal(items, err)
}
items, err = s.ActivityOutboxAfter(ctx, "synthetic-b", 2, 10)
if err != nil || len(items) != 2 {
t.Fatal(items, err)
}
items, err = s.PendingActivityOutbox(ctx, "synthetic-a", 10)
if err != nil || len(items) != 4 {
t.Fatal(items, err)
}
// Consumer action and checkpoint rollback together.
tx, err := s.DB.BeginTx(ctx, nil)
if err != nil {
t.Fatal(err)
}
if err = s.AdvanceActivityOutboxCheckpointTx(tx, "consumer-b", "synthetic-a", 4); err != nil {
tx.Rollback()
t.Fatal(err)
}
tx.Rollback()
checkpoint, err := s.ActivityOutboxCheckpoint("consumer-b", "synthetic-a")
if err != nil || checkpoint.LastSequence != 0 {
t.Fatal(checkpoint, err)
}
// Simultaneous acknowledgments must not lose the larger watermark.
var wg sync.WaitGroup
for _, seq := range []int64{4, 2, 3, 1} {
wg.Add(1)
go func() {
defer wg.Done()
if err := s.CompleteActivityOutboxThrough("consumer-b", "synthetic-a", seq); err != nil {
t.Error(err)
}
}()
}
wg.Wait()
checkpoint, err = s.ActivityOutboxCheckpoint("consumer-b", "synthetic-a")
if err != nil || checkpoint.LastSequence != 4 {
t.Fatal(checkpoint, err)
}
if domains, err := s.PendingActivityConsumerDomains(ctx, sub, 100); err != nil || len(domains) != 1 || domains[0] != "synthetic-b" {
t.Fatal(domains, err)
}
s.ReadOnly = true
if err = s.CompleteActivityOutboxThrough("consumer-b", "synthetic-b", 4); !errors.Is(err, ErrReadOnly) {
t.Fatal("readonly", err)
}
})
}
}