Files
pipelines/internal/server/scheduler_test.go
T

197 lines
6.1 KiB
Go

package server
import (
"context"
"os"
"path/filepath"
"pipelines/internal/pipeline"
"pipelines/internal/stage"
"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")
}
}