306 lines
10 KiB
Go
306 lines
10 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"path/filepath"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
"git.a-wan.net/alan/pipelines/internal/summarise"
|
|
)
|
|
|
|
func savedStoreFixture(t *testing.T) (*Store, int64, protocol.SavedSchedule, time.Time) {
|
|
t.Helper()
|
|
s, err := Open(filepath.Join(t.TempDir(), "schedules.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { s.Close() })
|
|
ctx := context.Background()
|
|
if _, err = s.Submit(ctx, "research", Template([]string{"one"}, true)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := s.List(ctx)
|
|
now := time.Date(2026, 10, 20, 12, 0, 0, 0, time.UTC)
|
|
spec := protocol.SavedSchedule{Name: "research topic", PipelineID: items[0].ID, Version: 1, Enabled: true, Input: map[string]any{"prompt": "first", "arbitrary": true}, Workspace: t.TempDir(), Rule: protocol.Schedule{Every: "15m"}}
|
|
return s, items[0].ID, spec, now
|
|
}
|
|
|
|
func TestSavedScheduleIndependentCASAndCadence(t *testing.T) {
|
|
s, pid, spec, now := savedStoreFixture(t)
|
|
ctx := context.Background()
|
|
a, err := s.SaveSchedule(ctx, spec, now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
spec.Input = map[string]any{"prompt": "second"}
|
|
spec.Workspace = t.TempDir()
|
|
spec.Rule.Every = "1h"
|
|
b, err := s.SaveSchedule(ctx, spec, now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if a.ID == b.ID || a.NextDue == b.NextDue || a.Workspace == b.Workspace {
|
|
t.Fatal(a, b)
|
|
}
|
|
originalDue := a.NextDue
|
|
stale := *a
|
|
a.Input = map[string]any{"prompt": "edited", "other": []any{"preserved"}}
|
|
a.Rule.Days = []string{}
|
|
a.Rule.Times = []string{}
|
|
a, err = s.SaveSchedule(ctx, *a, now.Add(time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if a.NextDue != originalDue || a.Revision != 2 {
|
|
t.Fatal("prompt edit changed cadence", a)
|
|
}
|
|
if _, err = s.SaveSchedule(ctx, stale, now); err == nil {
|
|
t.Fatal("stale update accepted")
|
|
}
|
|
if err = s.DeleteSchedule(ctx, a.ID, stale.Revision); err == nil {
|
|
t.Fatal("stale deletion accepted")
|
|
}
|
|
due, _ := time.Parse(time.RFC3339Nano, a.NextDue)
|
|
if ok, err := s.ClaimSavedSchedule(ctx, stale, due, due.Add(15*time.Minute), "claimed"); err != nil || ok {
|
|
t.Fatal("stale claim accepted", ok, err)
|
|
}
|
|
a.Enabled = false
|
|
a, err = s.SaveSchedule(ctx, *a, now.Add(2*time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ok, err := s.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed"); err != nil || ok {
|
|
t.Fatal("disabled claim accepted", ok, err)
|
|
}
|
|
items, _ := s.List(ctx)
|
|
if !items[0].Scheduled || items[0].ScheduleCount != 2 || items[0].EnabledScheduleCount != 1 {
|
|
t.Fatal(items)
|
|
}
|
|
a.Enabled = true
|
|
a, err = s.SaveSchedule(ctx, *a, now.Add(3*time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if a.NextDue != now.Add(18*time.Minute).Format(time.RFC3339Nano) {
|
|
t.Fatal("enable did not re-anchor", a)
|
|
}
|
|
a.Rule.Every = "30m"
|
|
a, err = s.SaveSchedule(ctx, *a, now.Add(4*time.Minute))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if a.NextDue != now.Add(34*time.Minute).Format(time.RFC3339Nano) {
|
|
t.Fatal("rule edit did not re-anchor", a)
|
|
}
|
|
if err = s.DeleteSchedule(ctx, a.ID, a.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entries, _ := s.ListSchedules(ctx, pid)
|
|
if len(entries) != 1 || entries[0].ID != b.ID || entries[0].Input["prompt"] != "second" {
|
|
t.Fatal(entries)
|
|
}
|
|
if err = s.DeleteSchedule(ctx, b.ID, b.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ = s.List(ctx)
|
|
if items[0].Scheduled || items[0].ScheduleCount != 0 {
|
|
t.Fatal(items)
|
|
}
|
|
}
|
|
|
|
func TestSavedScheduleClaimExactlyOnceAndAtomicOrigin(t *testing.T) {
|
|
s, pid, spec, now := savedStoreFixture(t)
|
|
ctx := context.Background()
|
|
a, err := s.SaveSchedule(ctx, spec, now)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
due, _ := time.Parse(time.RFC3339Nano, a.NextDue)
|
|
var claimed atomic.Int64
|
|
var wg sync.WaitGroup
|
|
for i := 0; i < 20; i++ {
|
|
wg.Add(1)
|
|
go func() {
|
|
defer wg.Done()
|
|
ok, err := s.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
if ok {
|
|
claimed.Add(1)
|
|
}
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
if claimed.Load() != 1 {
|
|
t.Fatal("claim count", claimed.Load())
|
|
}
|
|
d, err := s.Get(ctx, pid, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
origin := &ScheduleAdmission{ID: a.ID, Revision: a.Revision, Due: due, Name: a.Name}
|
|
id, created, err := s.CreateRunTitled(ctx, d, "scheduled", a.Workspace, false, nil, a.Input, RunOverrides{Schedule: origin}, summarise.Title{})
|
|
if err != nil || !created {
|
|
t.Fatal(id, created, err)
|
|
}
|
|
run, err := s.GetRun(ctx, id)
|
|
if err != nil || !run.Scheduled || run.ScheduleID != a.ID || run.ScheduleName != a.Name {
|
|
t.Fatal(run, err)
|
|
}
|
|
var eventRun int64
|
|
var status string
|
|
if err = s.db.QueryRow(`SELECT run_id,status FROM saved_schedule_events WHERE schedule_id=?`, a.ID).Scan(&eventRun, &status); err != nil || eventRun != id || status != "admitted" {
|
|
t.Fatal(eventRun, status, err)
|
|
}
|
|
if _, _, err = s.CreateRunTitled(ctx, d, "duplicate-different-key", a.Workspace, false, nil, a.Input, RunOverrides{Schedule: origin}, summarise.Title{}); err == nil {
|
|
t.Fatal("occurrence admitted twice")
|
|
}
|
|
// Durable next_due and provenance survive opening another store; neither old
|
|
// occurrences nor enabled rows may be re-imported or replayed.
|
|
other, err := Open(s.path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer other.Close()
|
|
entries, err := other.ListSchedules(ctx, pid)
|
|
if err != nil || len(entries) != 1 || entries[0].NextDue != due.Add(15*time.Minute).Format(time.RFC3339Nano) {
|
|
t.Fatal(entries, err)
|
|
}
|
|
if ok, err := other.ClaimSavedSchedule(ctx, *a, due, due.Add(15*time.Minute), "claimed"); err != nil || ok {
|
|
t.Fatal("replayed after restart", ok, err)
|
|
}
|
|
run, err = other.GetRun(ctx, id)
|
|
if err != nil || !run.Scheduled {
|
|
t.Fatal(run, err)
|
|
}
|
|
}
|
|
|
|
func TestLegacyScheduleImportPreservesHistoryAndNeverResurrects(t *testing.T) {
|
|
s, pid, _, now := savedStoreFixture(t)
|
|
ctx := context.Background()
|
|
// Construct a genuinely old published version and events directly in this
|
|
// isolated database; production APIs must reject these new publications.
|
|
source := "# settings\n```schedule\nevery=15m\n```\n```schedule\ntimes=09:00\ntimezone=Europe/London\n```\n```prompt\nLegacy research prompt\n```\n" + Template([]string{"one"}, true)
|
|
graph, err := Parse(source)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
encoded, _ := json.Marshal(graph)
|
|
if _, err = s.db.Exec(`UPDATE pipeline_versions SET source=?,graph_json=? WHERE pipeline_id=? AND version=1`, source, string(encoded), pid); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
d, err := s.Get(ctx, pid, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// A manually launched run on an embedded-schedule pipeline is NOT scheduled.
|
|
manual, _, err := s.CreateRun(ctx, d, "manual", t.TempDir(), false, nil, map[string]any{"prompt": "manual"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
historical, _, err := s.CreateRun(ctx, d, "real-old-event", t.TempDir(), false, nil, map[string]any{"prompt": "Legacy research prompt"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
due := now.Add(15 * time.Minute).Format(time.RFC3339Nano)
|
|
if _, err = s.db.Exec(`INSERT INTO schedule_state(pipeline_id,version,slot,next_due) VALUES(?,1,0,?)`, pid, due); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.db.Exec(`INSERT INTO schedule_events(pipeline_id,version,slot,due,status,run_id) VALUES(?,1,0,?,'started',?)`, pid, now.Format(time.RFC3339Nano), historical); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = s.db.Exec(`DELETE FROM schedule_migrations`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var before string
|
|
if err = s.db.QueryRow(`SELECT source || graph_json || content_hash FROM pipeline_versions WHERE pipeline_id=?`, pid).Scan(&before); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Remove only the new schema from this scratch fixture, so Open exercises
|
|
// the actual upgrade path from a pre-external-schedules database.
|
|
if _, err = s.db.Exec(`DROP TABLE schedule_create_requests; DROP TABLE run_schedule_origin; DROP TABLE saved_schedule_events; DROP TABLE saved_schedules; DROP TABLE schedule_migrations`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
migrated, err := Open(s.path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer migrated.Close()
|
|
entries, err := s.ListSchedules(ctx, pid)
|
|
if err != nil || len(entries) != 2 {
|
|
t.Fatal(entries, err)
|
|
}
|
|
if entries[0].NextDue != due || entries[0].Input["prompt"] != "Legacy research prompt" || entries[0].Workspace != "" || entries[0].Version != 1 || entries[0].Rule.Timezone == "" {
|
|
t.Fatal(entries[0])
|
|
}
|
|
if entries[0].Rule.Timezone != "Local" || entries[1].Rule.Timezone != "Europe/London" {
|
|
t.Fatal("migration changed timezone semantics", entries)
|
|
}
|
|
run, err := s.GetRun(ctx, historical)
|
|
if err != nil || !run.Scheduled || run.ScheduleID != entries[0].ID {
|
|
t.Fatal(run, err)
|
|
}
|
|
run, err = s.GetRun(ctx, manual)
|
|
if err != nil || run.Scheduled {
|
|
t.Fatal("manual history guessed as scheduled", run, err)
|
|
}
|
|
if err = s.DeleteSchedule(ctx, entries[0].ID, entries[0].Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entries[1].Enabled = false
|
|
entries[1].Workspace = t.TempDir()
|
|
if _, err = s.SaveSchedule(ctx, entries[1], now); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
beforeBind, err := s.ListSchedules(ctx, pid)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err = s.BindLegacyScheduleWorkspace(ctx, t.TempDir()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
afterBind, err := s.ListSchedules(ctx, pid)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
beforeJSON, _ := json.Marshal(beforeBind)
|
|
afterJSON, _ := json.Marshal(afterBind)
|
|
if string(beforeJSON) != string(afterJSON) {
|
|
t.Fatal("runtime binding overwrote an operator-edited paused row", beforeBind, afterBind)
|
|
}
|
|
var deletedWorkspace string
|
|
if err = s.db.QueryRow(`SELECT json_extract(spec_json,'$.workspace') FROM saved_schedules WHERE id=? AND deleted=1`, entries[0].ID).Scan(&deletedWorkspace); err != nil || deletedWorkspace != "" {
|
|
t.Fatal("binding changed a tombstone", deletedWorkspace, err)
|
|
}
|
|
other, err := Open(s.path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer other.Close()
|
|
entries, err = other.ListSchedules(ctx, pid)
|
|
if err != nil || len(entries) != 1 || entries[0].Enabled {
|
|
t.Fatal("resurrected legacy schedule", entries, err)
|
|
}
|
|
var after string
|
|
if err = other.db.QueryRow(`SELECT source || graph_json || content_hash FROM pipeline_versions WHERE pipeline_id=?`, pid).Scan(&after); err != nil || after != before {
|
|
t.Fatal("migration rewrote immutable history", err)
|
|
}
|
|
var count int
|
|
if err = other.db.QueryRow(`SELECT COUNT(*) FROM schedule_events WHERE run_id=?`, historical).Scan(&count); err != nil || count != 1 {
|
|
t.Fatal("lost legacy event", count, err)
|
|
}
|
|
run, err = other.GetRun(ctx, historical)
|
|
if err != nil || !run.Scheduled || run.ScheduleID == 0 {
|
|
t.Fatal("lost deleted schedule history", run, err)
|
|
}
|
|
if _, err = other.Submit(ctx, "legacy-new", source); err == nil {
|
|
t.Fatal("new legacy publication accepted")
|
|
}
|
|
}
|