135 lines
4.4 KiB
Go
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)
|
|
}
|
|
})
|
|
}
|
|
}
|