Files
pipelines/internal/pipeline/saved_schedules_test.go
T

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