Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
125 lines
3.0 KiB
Go
125 lines
3.0 KiB
Go
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)
|
|
}
|
|
}
|