184 lines
7.4 KiB
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)
|
|
}
|
|
}
|
|
}
|