Files
pages/internal/store/activity_subscriptions_test.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

179 lines
6.2 KiB
Go

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)
}
}
}