package store import ( "database/sql" "errors" "fmt" "path/filepath" "sync" "testing" "time" "pageswiki/internal/db" ) func TestClaimDueEventPriorityAndReturnedState(t *testing.T) { s := newSchemaTestStore(t) if err := s.EnsureEventJobsSchema(); err != nil { t.Fatal(err) } for _, item := range []struct { key string priority int due time.Time }{ {"low", 1, time.Now().Add(-time.Hour)}, {"high", 9, time.Now().Add(-time.Minute)}, {"future", 99, time.Now().Add(time.Hour)}, } { if _, err := s.EnqueueEventWithOptions("", "test", item.key, "opaque", item.due, item.priority, 3); err != nil { t.Fatal(err) } } for _, key := range []string{"high", "low"} { job, err := s.ClaimDueEvent() if err != nil { t.Fatal(err) } if job.Key != key || job.Status != "running" || job.Attempts != 1 || job.StartedAtMS == 0 || job.UpdatedAt != job.StartedAtMS { t.Fatalf("wrong claimed state: %+v", job) } } if _, err := s.ClaimDueEvent(); !errors.Is(err, sql.ErrNoRows) { t.Fatalf("future/running claimed: %v", err) } s.ReadOnly = true if _, err := s.ClaimDueEvent(); !errors.Is(err, ErrReadOnly) { t.Fatalf("standby claim: %v", err) } } func TestClaimDueEventConcurrentWriters(t *testing.T) { path := filepath.Join(t.TempDir(), "queue.db") database, err := db.Open(path) if err != nil { t.Fatal(err) } defer database.Close() s := &Store{DB: database} if err := s.EnsureEventJobsSchema(); err != nil { t.Fatal(err) } const total = 64 for n := 0; n < total; n++ { if _, err := s.EnqueueEvent("test", fmt.Sprint(n), "opaque", time.Now().Add(-time.Second)); err != nil { t.Fatal(err) } } var wg sync.WaitGroup jobs := make(chan string, total) errs := make(chan error, 9) // Independent DB handles exercise file-level contention, not an in-process // mutex or a single sql.DB connection serializing the test for us. for range 8 { other, err := db.Open(path) if err != nil { t.Fatal(err) } wg.Add(1) go func() { defer wg.Done() defer other.Close() worker := &Store{DB: other} for { job, err := worker.ClaimDueEvent() if errors.Is(err, sql.ErrNoRows) { return } if err != nil { errs <- err return } jobs <- job.UUID } }() } wg.Add(1) go func() { defer wg.Done() for n := 0; n < 100; n++ { if _, err := database.Exec(`UPDATE event_queue_settings SET max_depth=max_depth+1 WHERE id=1`); err != nil { errs <- err return } } }() wg.Wait() close(jobs) close(errs) for err := range errs { t.Error(err) } seen := map[string]bool{} for id := range jobs { if seen[id] { t.Error("duplicate claim", id) } seen[id] = true } if len(seen) != total { t.Fatalf("claimed=%d want=%d", len(seen), total) } var once int if err := database.QueryRow(`SELECT count(*) FROM event_jobs WHERE status='running' AND attempts=1 AND started_at_ms=updated_at_ms`).Scan(&once); err != nil || once != total { t.Fatalf("persisted claims=%d err=%v", once, err) } }