package server import ( "context" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/stage" "os" "path/filepath" "strings" "testing" "time" ) func TestScheduledExecutionPersistenceAndSkipping(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() path := filepath.Join(t.TempDir(), "schedule.db") store, err := pipeline.Open(path) if err != nil { t.Fatal(err) } defer func() { store.Close() }() source := "# settings\n```schedule\nevery=15m\ndays=everyday\n```\n```prompt\nScheduled task\n```\n" + pipeline.Template([]string{"one"}, true) if _, err := store.Submit(ctx, "scheduled", source); err != nil { t.Fatal(err) } items, _ := store.List(ctx) d, _ := store.Get(ctx, items[0].ID, 0) rule := d.Graph.Settings.Schedules[0] now := time.Now() due, err := store.ScheduleDue(ctx, d, 0, rule, now) if err != nil { t.Fatal(err) } // Reopening must retain the activation/cadence, not reset the timer. store.Close() store, err = pipeline.Open(path) if err != nil { t.Fatal(err) } persisted, err := store.ScheduleDue(ctx, d, 0, rule, now.Add(time.Minute)) if err != nil || !persisted.Equal(due) { t.Fatal("timer reset on restart", persisted, due, err) } r, err := newRunner(ctx, store) if err != nil { t.Fatal(err) } calls := 0 r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { calls++ if input["prompt"] != "Scheduled task" { t.Error("wrong scheduled prompt") } return stage.Result{Outcome: "success", Output: stage.Values{"done": true}}, nil } if err := r.scheduleTick(due, false); err != nil { t.Fatal(err) } r.wg.Wait() runs, err := store.ListRuns(ctx) if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" || calls != 1 { t.Fatal("scheduled execution", runs, calls, err) } detail, _ := store.GetRun(ctx, runs[0].ID) if detail.AllowTools { t.Fatal("scheduled run granted tools") } if err := r.scheduleTick(due, false); err != nil { t.Fatal(err) } if calls != 1 { t.Fatal("duplicate occurrence") } next, _ := store.ScheduleDue(ctx, d, 0, rule, due) if err := r.scheduleTick(next.Add(time.Hour), true); err != nil { t.Fatal(err) } runs, _ = store.ListRuns(ctx) if len(runs) != 1 { t.Fatal("replayed downtime backlog") } // A new manual-only version disables the old schedule. if _, err := store.Submit(ctx, "scheduled", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } next, _ = store.ScheduleDue(ctx, d, 0, rule, due) claimed, err := store.ClaimSchedule(ctx, d, 0, next, next.Add(time.Minute), "claimed") if err != nil || claimed { t.Fatal("obsolete schedule claimed", err) } if err := r.scheduleTick(next, false); err != nil { t.Fatal(err) } runs, _ = store.ListRuns(ctx) if len(runs) != 1 { t.Fatal("disabled schedule executed") } } // Opt-in wall-clock integration: no clock injection, no external model calls. func TestLiveScheduleLoop(t *testing.T) { if os.Getenv("PIPELINES_LIVE_SCHEDULE_TEST") != "1" { t.Skip("set PIPELINES_LIVE_SCHEDULE_TEST=1 for the one-minute wall-clock check") } ctx, cancel := context.WithCancel(context.Background()) store, err := pipeline.Open(filepath.Join(t.TempDir(), "live.db")) if err != nil { t.Fatal(err) } defer store.Close() r, err := newRunner(ctx, store) if err != nil { t.Fatal(err) } executed := make(chan stage.Values, 1) r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { executed <- input return stage.Result{Outcome: "success", Output: stage.Values{"done": true}}, nil } r.schedulerWG.Add(1) go r.scheduleLoop() defer func() { cancel(); r.schedulerWG.Wait(); r.wg.Wait() }() source := "# settings\n```schedule\nevery=1m\n```\n```prompt\nwall-clock task\n```\n" + pipeline.Template([]string{"one"}, true) if _, err := store.Submit(ctx, "live", source); err != nil { t.Fatal(err) } select { case input := <-executed: if input["prompt"] != "wall-clock task" { t.Fatal("wrong prompt", input) } case <-time.After(75 * time.Second): t.Fatal("wall-clock scheduler did not dispatch") } r.wg.Wait() runs, err := store.ListRuns(ctx) if err != nil || len(runs) != 1 || runs[0].Status != "succeeded" { t.Fatal("scheduled audit missing", runs, err) } } func TestSchedulerSkipsOverlapAndExcludedDays(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() store, err := pipeline.Open(filepath.Join(t.TempDir(), "schedule.db")) if err != nil { t.Fatal(err) } defer store.Close() source := "# settings\n```schedule\nevery=15m\n```\n```prompt\ntask\n```\n" + pipeline.Template([]string{"one"}, true) if _, err := store.Submit(ctx, "test", source); err != nil { t.Fatal(err) } items, _ := store.List(ctx) d, _ := store.Get(ctx, items[0].ID, 0) rule := d.Graph.Settings.Schedules[0] due, _ := store.ScheduleDue(ctx, d, 0, rule, time.Now()) r, _ := newRunner(ctx, store) entered, release := make(chan struct{}), make(chan struct{}) r.execute = func(ctx context.Context, def stage.Definition, input 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(15*time.Minute), false); err != nil { t.Fatal(err) } runs, _ := store.ListRuns(ctx) if len(runs) != 1 { t.Fatal("overlap started") } close(release) r.wg.Wait() // A weekday different from the upcoming due date must exclude that occurrence. days := []string{"sun", "mon", "tue", "wed", "thu", "fri", "sat"} excluded := days[(time.Now().Add(15*time.Minute).In(time.Local).Weekday()+1)%7] source = strings.Replace(source, "every=15m", "every=15m\ndays="+excluded, 1) if _, err := store.Submit(ctx, "test", source); err != nil { t.Fatal(err) } d, _ = store.Get(ctx, d.ID, 0) rule = d.Graph.Settings.Schedules[0] due, _ = store.ScheduleDue(ctx, d, 0, rule, time.Now()) if err := r.scheduleTick(due, false); err != nil { t.Fatal(err) } runs, _ = store.ListRuns(ctx) if len(runs) != 1 { t.Fatal("excluded day executed") } }