Files
pipelines/internal/server/schedule_websocket_test.go

184 lines
7.4 KiB
Go

package server
import (
"context"
"net/http/httptest"
"path/filepath"
"slices"
"strings"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/pipeline"
"git.a-wan.net/alan/pipelines/internal/protocol"
"github.com/coder/websocket"
"github.com/coder/websocket/wsjson"
)
func TestScheduleAPIOverWebSocket(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
s, err := pipeline.Open(filepath.Join(t.TempDir(), "ws.db"))
if err != nil {
t.Fatal(err)
}
defer s.Close()
if _, err = s.Submit(ctx, "research", pipeline.Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, _ := s.List(ctx)
handler := HandlerWithOptions(ctx, Options{}, s)
defer func() { cancel(); WaitRuns(handler) }()
srv := httptest.NewServer(handler)
defer srv.Close()
conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil)
if err != nil {
t.Fatal(err)
}
defer conn.CloseNow()
var hello protocol.Message
if err = wsjson.Read(ctx, conn, &hello); err != nil {
t.Fatal(err)
}
rpc := func(request protocol.Message) protocol.Message {
t.Helper()
request.ID = "rpc"
if err := wsjson.Write(ctx, conn, request); err != nil {
t.Fatal(err)
}
var response protocol.Message
if err := wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.ID != request.ID {
t.Fatal(response)
}
return response
}
// Saving run information is not definition authoring, and works on run-only servers.
spec := protocol.SavedSchedule{Name: "first", PipelineID: items[0].ID, Version: 1, Enabled: true, Workspace: t.TempDir(), Input: map[string]any{"prompt": "first research", "arbitrary": "retained"}, WritePaths: []string{"internal/one.go"}, AllowTools: true, Rule: protocol.Schedule{Every: "15m"}, Model: "openai/gpt", NotifyMode: "off", Title: "Research"}
response := rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"})
if response.Type != protocol.SavedScheduleReply || response.Schedule == nil || response.Schedule.ID == 0 || response.Schedule.Revision != 1 {
t.Fatal(response)
}
a := *response.Schedule
if !a.AllowTools || !slices.Equal(a.WritePaths, spec.WritePaths) {
t.Fatal("scope omitted from save reply", a)
}
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-first"})
if response.Schedule == nil || response.Schedule.ID != a.ID || response.Schedule.Revision != a.Revision {
t.Fatal("lost reply duplicated timer", response)
}
conflicting := spec
conflicting.Title = "different payload"
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &conflicting, RequestKey: "editor-first"})
if response.Type != protocol.Error {
t.Fatal("conflicting create accepted", response)
}
spec.Name = "second"
spec.Input = map[string]any{"prompt": "second research"}
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &spec, RequestKey: "editor-second"})
if response.Schedule == nil || response.Schedule.ID == a.ID {
t.Fatal(response)
}
b := *response.Schedule
response = rpc(protocol.Message{Type: protocol.ListSchedules, PipelineID: items[0].ID})
if response.Type != protocol.Schedules || len(response.Schedules) != 2 {
t.Fatal(response)
}
if !response.Schedules[0].AllowTools || !slices.Equal(response.Schedules[0].WritePaths, spec.WritePaths) {
t.Fatal("scope omitted from list reply", response)
}
a.Enabled = false
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &a})
if response.Schedule == nil || response.Schedule.Enabled || response.Schedule.Revision != 2 {
t.Fatal(response)
}
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &a})
if response.Type != protocol.Error || !strings.Contains(response.Error, "conflict") {
t.Fatal("stale edit accepted", response)
}
response = rpc(protocol.Message{Type: protocol.DeleteSchedule, ScheduleID: a.ID, ExpectedRevision: 1})
if response.Type != protocol.Error {
t.Fatal("stale delete accepted", response)
}
response = rpc(protocol.Message{Type: protocol.DeleteSchedule, ScheduleID: b.ID, ExpectedRevision: b.Revision})
if response.Type != protocol.ScheduleDeleted || response.ScheduleID != b.ID {
t.Fatal(response)
}
response = rpc(protocol.Message{Type: protocol.List})
if len(response.Pipelines) != 1 || !response.Pipelines[0].Scheduled || response.Pipelines[0].ScheduleCount != 1 || response.Pipelines[0].EnabledScheduleCount != 0 {
t.Fatal("paused schedule projection", response)
}
response = rpc(protocol.Message{Type: protocol.GetPipeline, PipelineID: items[0].ID})
if response.Detail == nil || response.Detail.ScheduleCount != 1 || !response.Detail.Scheduled {
t.Fatal(response)
}
for _, mutate := range []func(*protocol.SavedSchedule){
func(s *protocol.SavedSchedule) { s.Workspace = "" },
func(s *protocol.SavedSchedule) { s.Workspace = "relative" },
func(s *protocol.SavedSchedule) { s.Workspace = filepath.Join(t.TempDir(), "missing") },
func(s *protocol.SavedSchedule) { s.Version = 0 },
func(s *protocol.SavedSchedule) { s.Version = 999 },
func(s *protocol.SavedSchedule) { s.Input = map[string]any{"unknown": "missing prompt"} },
func(s *protocol.SavedSchedule) { s.Rule.Every = "1s" },
func(s *protocol.SavedSchedule) { s.Rule.Times = []string{"09:00"} },
func(s *protocol.SavedSchedule) { s.Rule.Timezone = "invalid/zone" },
func(s *protocol.SavedSchedule) { s.StageModels = map[string]string{"missing": "openai/gpt"} },
func(s *protocol.SavedSchedule) { s.Model = "invalid" },
func(s *protocol.SavedSchedule) { s.NotifyMode = "invalid" },
func(s *protocol.SavedSchedule) { s.OutputFormat = "invalid" },
func(s *protocol.SavedSchedule) { s.WritePaths = []string{"../outside.go"} },
func(s *protocol.SavedSchedule) { s.WritePaths = []string{"*.go"} },
} {
bad := spec
mutate(&bad)
response = rpc(protocol.Message{Type: protocol.SaveSchedule, Schedule: &bad})
if response.Type != protocol.Error {
t.Fatal("invalid config saved", bad, response)
}
}
response = rpc(protocol.Message{Type: protocol.ListRuns})
if len(response.Runs) != 0 {
t.Fatal("validation started work", response)
}
}
func TestEmbeddedSchedulesReadOnlyOverWebSocket(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
s, err := pipeline.Open(filepath.Join(t.TempDir(), "ws.db"))
if err != nil {
t.Fatal(err)
}
defer s.Close()
handler := HandlerWithOptions(ctx, Options{AllowAuthoring: true}, s)
defer func() { cancel(); WaitRuns(handler) }()
srv := httptest.NewServer(handler)
defer srv.Close()
conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil)
if err != nil {
t.Fatal(err)
}
defer conn.CloseNow()
var response protocol.Message
if err = wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
source := "# settings\n```schedule\nevery=15m\n```\n```prompt\ntask\n```\n" + pipeline.Template([]string{"one"}, true)
if _, err = pipeline.Parse(source); err != nil {
t.Fatal("legacy reader broken", err)
}
for _, command := range []string{protocol.Validate, protocol.Submit} {
if err = wsjson.Write(ctx, conn, protocol.Message{Type: command, Name: "legacy", Source: source}); err != nil {
t.Fatal(err)
}
if err = wsjson.Read(ctx, conn, &response); err != nil {
t.Fatal(err)
}
if response.Type != protocol.Error || !strings.Contains(response.Error, "separate schedule") {
t.Fatal(response)
}
}
}