package store import ( "context" "database/sql" "fmt" "testing" _ "modernc.org/sqlite" ) func subscriptionFixture(t *testing.T) *Store { t.Helper() db, err := sql.Open("sqlite", ":memory:") if err != nil { t.Fatal(err) } db.SetMaxOpenConns(1) t.Cleanup(func() { db.Close() }) s := &Store{DB: db} if err = s.EnsureActivityOutboxSchema(); err != nil { t.Fatal(err) } return s } func appendSubscriptionEvent(t *testing.T, s *Store, domain, typ, key string) ActivityOutboxRecord { t.Helper() tx, err := s.DB.Begin() if err != nil { t.Fatal(err) } defer tx.Rollback() e, _, err := s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{DomainUUID: domain, EventType: typ, IdempotencyKey: key}) if err != nil { t.Fatal(err) } if err = tx.Commit(); err != nil { t.Fatal(err) } return e } func TestActivitySubscriptionsIndependentFilteringAndPagination(t *testing.T) { s := subscriptionFixture(t) ctx := context.Background() city := ActivitySubscription{ConsumerID: "city", EventTypes: []string{"page.created", "revision.created"}} other := ActivitySubscription{ConsumerID: "other.v1", EventTypes: []string{"page.created"}} tasks := ActivitySubscription{ConsumerID: "tasks.v1", EventTypes: []string{"organizer.task.changed"}} appendSubscriptionEvent(t, s, "d", "organizer.task.changed", "t1") if ds, err := s.PendingActivityConsumerDomains(ctx, city, 100); err != nil || len(ds) != 0 { t.Fatal(ds, err) } p1 := appendSubscriptionEvent(t, s, "d", "page.created", "p1") appendSubscriptionEvent(t, s, "other-domain", "organizer.task.changed", "o1") p2 := appendSubscriptionEvent(t, s, "d", "revision.created", "p2") p3 := appendSubscriptionEvent(t, s, "d", "page.created", "p3") for _, sub := range []ActivitySubscription{city, other, tasks} { ds, err := s.PendingActivityConsumerDomains(ctx, sub, 100) if err != nil || len(ds) == 0 { t.Fatal(sub, ds, err) } } page, err := s.ActivityOutboxForConsumer(ctx, city, "d", 2) if err != nil || len(page) != 2 || page[0].UUID != p1.UUID || page[1].UUID != p2.UUID { t.Fatal(page, err) } if err = s.CompleteActivityOutboxThrough("city", "d", p2.Sequence); err != nil { t.Fatal(err) } page, err = s.ActivityOutboxForConsumer(ctx, city, "d", 2) if err != nil || len(page) != 1 || page[0].UUID != p3.UUID { t.Fatal(page, err) } if err = s.CompleteActivityOutboxThrough("city", "d", p3.Sequence); err != nil { t.Fatal(err) } if ds, err := s.PendingActivityConsumerDomains(ctx, city, 100); err != nil || len(ds) != 0 { t.Fatal(ds, err) } // One subscriber finishing never acknowledges work for another one. page, err = s.ActivityOutboxForConsumer(ctx, other, "d", 10) if err != nil || len(page) != 2 { t.Fatal(page, err) } page, err = s.ActivityOutboxForConsumer(ctx, tasks, "d", 10) if err != nil || len(page) != 1 { t.Fatal(page, err) } if err = s.CompleteActivityOutboxThrough("city", "d", p1.Sequence); err != nil { t.Fatal(err) } cp, err := s.ActivityOutboxCheckpoint("city", "d") if err != nil || cp.LastSequence != p3.Sequence { t.Fatal(cp, err) } // Old shared processed flags also must not hide events from a late consumer. if _, err = s.DB.Exec(`UPDATE activity_outbox SET status='processed'`); err != nil { t.Fatal(err) } page, err = s.ActivityOutboxForConsumer(ctx, other, "d", 10) if err != nil || len(page) != 2 { t.Fatal(page, err) } if ds, err := s.PendingActivityConsumerDomains(ctx, other, 100); err != nil || len(ds) != 1 { t.Fatal(ds, err) } } func TestActivitySubscriptionWatermarksMigrationRollbackAndSequence(t *testing.T) { s := subscriptionFixture(t) for i := 0; i < 5; i++ { appendSubscriptionEvent(t, s, "d", "page.created", fmt.Sprint(i)) } // Emulate a pre-upgrade database, including a processed legacy event. for _, q := range []string{`DROP TRIGGER activity_outbox_advance_head`, `DROP TABLE activity_outbox_heads`, `DELETE FROM activity_outbox_migrations`, `UPDATE activity_outbox SET status='processed'`} { if _, err := s.DB.Exec(q); err != nil { t.Fatal(err) } } if err := s.EnsureActivityOutboxSchema(); err != nil { t.Fatal(err) } if err := s.EnsureActivityOutboxSchema(); err != nil { t.Fatal("idempotent migration", err) } sub := ActivitySubscription{ConsumerID: "late", EventTypes: []string{"page.created"}} if domains, err := s.PendingActivityConsumerDomains(context.Background(), sub, 100); err != nil || len(domains) != 1 { t.Fatal(domains, err) } tx, err := s.DB.Begin() if err != nil { t.Fatal(err) } if _, _, err = s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{DomainUUID: "d", EventType: "rollback", IdempotencyKey: "rollback"}); err != nil { t.Fatal(err) } tx.Rollback() var count int if err = s.DB.QueryRow(`SELECT count(*) FROM activity_outbox_heads WHERE event_type='rollback'`).Scan(&count); err != nil || count != 0 { t.Fatal(count, err) } // A future retention implementation must preserve watermarks. No automatic // retention is introduced here; this verifies sequence allocation safety. if _, err = s.DB.Exec(`DELETE FROM activity_outbox WHERE domain_uuid='d'`); err != nil { t.Fatal(err) } next := appendSubscriptionEvent(t, s, "d", "page.created", "next") if next.Sequence != 6 { t.Fatal(next) } } func TestActivitySubscriptionSkipsUnrelatedFlood(t *testing.T) { s := subscriptionFixture(t) tx, err := s.DB.Begin() if err != nil { t.Fatal(err) } for i := 0; i < 1200; i++ { if _, _, err = s.AppendActivityOutboxTx(tx, ActivityOutboxEvent{DomainUUID: "d", EventType: "organizer.task.changed", IdempotencyKey: fmt.Sprint(i)}); err != nil { t.Fatal(err) } } if err = tx.Commit(); err != nil { t.Fatal(err) } want := appendSubscriptionEvent(t, s, "d", "page.created", "page") items, err := s.ActivityOutboxForConsumer(context.Background(), ActivitySubscription{ConsumerID: "city", EventTypes: []string{"page.created"}}, "d", 1) if err != nil || len(items) != 1 || items[0].UUID != want.UUID { t.Fatal(items, err) } for _, sub := range []ActivitySubscription{{ConsumerID: "empty"}, {EventTypes: []string{"page.created"}}, {ConsumerID: "bad", EventTypes: []string{""}}} { if _, err = s.PendingActivityConsumerDomains(context.Background(), sub, 1); err != ErrActivityOutboxInput { t.Fatal("invalid subscription", err) } } }