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