package server import ( "context" "fmt" "path/filepath" "sync" "testing" "time" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" "git.a-wan.net/alan/pipelines/internal/summarise" ) func scheduleFixture(t *testing.T) (context.Context, *pipeline.Store, *runner, int64) { t.Helper() ctx, cancel := context.WithCancel(context.Background()) s, err := pipeline.Open(filepath.Join(t.TempDir(), "schedule.db")) if err != nil { t.Fatal(err) } if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } items, err := s.List(ctx) if err != nil { t.Fatal(err) } r, err := newRunner(ctx, s) if err != nil { t.Fatal(err) } t.Cleanup(func() { cancel(); r.schedulerWG.Wait(); r.wg.Wait(); s.Close() }) return ctx, s, r, items[0].ID } func saveTestSchedule(t *testing.T, ctx context.Context, s *pipeline.Store, pid int64, prompt, workspace, every string, now time.Time) *protocol.SavedSchedule { t.Helper() item, err := s.SaveSchedule(ctx, protocol.SavedSchedule{Name: prompt, PipelineID: pid, Version: 1, Enabled: true, Workspace: workspace, Input: map[string]any{"prompt": prompt, "custom": map[string]any{"nested": "kept"}}, Rule: protocol.Schedule{Every: every}, Model: "openai/default", StageModels: map[string]string{"one": "openai/override"}, NotifyMode: "off", Title: "Scheduled research", OutputFormat: "markdown"}, now) if err != nil { t.Fatal(err) } return item } func dueOf(t *testing.T, item *protocol.SavedSchedule) time.Time { t.Helper() due, err := time.Parse(time.RFC3339Nano, item.NextDue) if err != nil { t.Fatal(err) } return due } func TestIndependentScheduledRunsAndProvenance(t *testing.T) { ctx, s, r, pid := scheduleFixture(t) now := time.Now() a := saveTestSchedule(t, ctx, s, pid, "First research", t.TempDir(), "1m", now) b := saveTestSchedule(t, ctx, s, pid, "Second research", t.TempDir(), "90s", now) r.events = newRunEventHub() frames := make(chan protocol.RunEventFrame, 64) sub := r.events.subscribe("schedules", "", nil, func(m protocol.Message) error { frames <- *m.RunEvent; return nil }) sub.ready() defer sub.close() var mu sync.Mutex seen := map[string]bool{} r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { mu.Lock() seen[fmt.Sprint(input["prompt"])] = true mu.Unlock() if def.Configs["model"] != "override" || def.Configs["provider"] != "openai" { t.Error("model override missing", def.Configs) } if input["custom"] == nil { t.Error("arbitrary saved input lost") } return stage.Result{Outcome: "success", Output: stage.Values{"done": true, "markdown": "# Research report"}}, nil } for _, item := range []*protocol.SavedSchedule{a, b} { if err := r.scheduleTick(dueOf(t, item), false); err != nil { t.Fatal(err) } r.wg.Wait() } runs, err := s.ListRuns(ctx) if err != nil || len(runs) != 2 { t.Fatal(runs, err) } for _, run := range runs { if !run.Scheduled || run.ScheduleID == 0 || run.ScheduleName == "" || run.Version != 1 || run.NotifyMode != "off" || run.Title != "Scheduled research" || run.Status != "succeeded" || run.OutputFormat != "markdown" { t.Fatalf("missing provenance or spec: %+v", run) } d, err := s.GetRun(ctx, run.ID) if err != nil || !d.Scheduled || d.Input["custom"] == nil { t.Fatal(d, err) } } mu.Lock() if !seen[a.Name] || !seen[b.Name] { t.Error("independent prompts missing", seen) } mu.Unlock() terminals := 0 deadline := time.After(2 * time.Second) for terminals < 2 { select { case frame := <-frames: if !frame.Scheduled || frame.ScheduleID == 0 || frame.ScheduleName == "" { t.Fatal("frame preceded provenance", frame) } if frame.Status == "succeeded" { terminals++ } case <-deadline: t.Fatal("missing scheduled terminal frames") } } manual, err := r.start(protocol.Message{ScheduleID: a.ID, PipelineID: pid, Version: 1, Workspace: a.Workspace, RequestKey: "manual", Input: map[string]any{"prompt": "manual", "custom": true}, Model: "openai/override", NotifyMode: "off"}) if err != nil { t.Fatal(err) } r.wg.Wait() if manual.Scheduled || manual.ScheduleID != 0 { t.Fatal("manual run forged schedule origin", manual) } manual, err = s.GetRun(ctx, manual.ID) if err != nil || manual.Scheduled { t.Fatal(manual, err) } if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one", "two"}, true)); err != nil { t.Fatal(err) } entries, _ := s.ListSchedules(ctx, pid) if len(entries) != 2 || entries[0].Version != 1 { t.Fatal(entries) } if err = s.DeleteSchedule(ctx, a.ID, a.Revision); err != nil { t.Fatal(err) } for _, run := range runs { d, _ := s.GetRun(ctx, run.ID) if !d.Scheduled || d.ScheduleName != run.ScheduleName { t.Fatal("delete erased provenance", d) } } // A reconnect snapshot uses the same durable origin after deletion, while // the manually admitted run remains unscheduled. var snapshots []protocol.RunEventFrame if !handleRunEvents(protocol.Message{Type: protocol.Subscribe}, r.events, r, "snapshot", func(m protocol.Message) error { if m.RunEvent != nil { snapshots = append(snapshots, *m.RunEvent) } return nil }) { t.Fatal("subscribe not handled") } defer r.events.unsubscribeClient("snapshot") if len(snapshots) != 3 { t.Fatal("snapshot count", snapshots) } for _, frame := range snapshots { if frame.RunID == manual.ID { if frame.Scheduled { t.Fatal("manual snapshot forged", frame) } } else if !frame.Scheduled || frame.ScheduleID == 0 || frame.ScheduleName == "" { t.Fatal("snapshot lost origin", frame) } } } func TestScheduleDeletionDoesNotCancelAdmittedRun(t *testing.T) { ctx, s, r, pid := scheduleFixture(t) item := saveTestSchedule(t, ctx, s, pid, "active research", t.TempDir(), "1m", time.Now()) entered, release := make(chan struct{}), make(chan struct{}) r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { close(entered) <-release return stage.Result{Outcome: "success", Output: stage.Values{"markdown": "# Finished"}}, nil } if err := r.scheduleTick(dueOf(t, item), false); err != nil { t.Fatal(err) } <-entered if err := s.DeleteSchedule(ctx, item.ID, item.Revision); err != nil { t.Fatal(err) } if err := r.scheduleTick(dueOf(t, item).Add(time.Minute), false); err != nil { t.Fatal(err) } close(release) r.wg.Wait() runs, err := s.ListRuns(ctx) if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" || !runs[0].Scheduled || runs[0].ScheduleID != item.ID { t.Fatal(runs, err) } } func TestSavedScheduleRecoveryAndOverlap(t *testing.T) { ctx, s, r, pid := scheduleFixture(t) item := saveTestSchedule(t, ctx, s, pid, "task", t.TempDir(), "1m", time.Now()) due := dueOf(t, item) entered, release := make(chan struct{}), make(chan struct{}) r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { close(entered) <-release return stage.Result{Outcome: "success", Output: stage.Values{}}, nil } if err := r.scheduleTick(due, false); err != nil { t.Fatal(err) } <-entered if err := r.scheduleTick(due.Add(time.Minute), false); err != nil { t.Fatal(err) } close(release) r.wg.Wait() if err := r.scheduleTick(due.Add(time.Minute), false); err != nil { t.Fatal(err) } if err := r.scheduleTick(due.Add(time.Hour), true); err != nil { t.Fatal(err) } if err := r.scheduleTick(due.Add(time.Hour), false); err != nil { t.Fatal(err) } runs, err := s.ListRuns(ctx) if err != nil || len(runs) != 1 { t.Fatal("replayed or overlapping work", runs, err) } entries, _ := s.ListSchedules(ctx, pid) item = &entries[0] next := dueOf(t, item) days := []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"} item.Rule.Days = []string{days[(next.In(time.Local).Weekday()+1)%7]} item, err = s.SaveSchedule(ctx, *item, next.Add(-time.Minute)) if err != nil { t.Fatal(err) } if err = r.scheduleTick(dueOf(t, item), false); err != nil { t.Fatal(err) } runs, _ = s.ListRuns(ctx) if len(runs) != 1 { t.Fatal("excluded day dispatched", runs) } } func TestScheduleEditBetweenClaimAndAdmission(t *testing.T) { for _, operation := range []string{"disable", "edit", "delete"} { t.Run(operation, func(t *testing.T) { ctx, s, r, pid := scheduleFixture(t) item := saveTestSchedule(t, ctx, s, pid, "task", t.TempDir(), "1m", time.Now()) item.Title = "" var err error item, err = s.SaveSchedule(ctx, *item, time.Now()) if err != nil { t.Fatal(err) } r.title = func(context.Context, string) summarise.Title { if operation == "delete" { err = s.DeleteSchedule(ctx, item.ID, item.Revision) } else { if operation == "disable" { item.Enabled = false } else { item.Input["prompt"] = "new prompt" } _, err = s.SaveSchedule(ctx, *item, time.Now()) } if err != nil { t.Error(err) } return summarise.Title{Text: "title"} } r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { t.Error("invalidated occurrence executed") return stage.Result{}, nil } if err = r.scheduleTick(dueOf(t, item), false); err != nil { t.Fatal(err) } r.wg.Wait() runs, _ := s.ListRuns(ctx) if len(runs) != 0 { t.Fatal("invalidated occurrence admitted", runs) } }) } }