package server import ( "context" "net/http/httptest" "path/filepath" "strings" "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" "github.com/coder/websocket" "github.com/coder/websocket/wsjson" ) func TestRunWebSocketRemainsResponsiveAndAuditable(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second) defer cancel() store, err := pipeline.Open(filepath.Join(t.TempDir(), "run.db")) if err != nil { t.Fatal(err) } defer store.Close() if _, err := store.Submit(ctx, "ws", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } items, _ := store.List(ctx) handler := Handler(ctx, store).(*runHandler) defer func() { cancel(); WaitRuns(handler) }() entered := make(chan struct{}) handler.runner.execute = func(ctx context.Context, _ stage.Definition, _ stage.Values) (stage.Result, error) { close(entered) <-ctx.Done() return stage.Result{}, ctx.Err() } 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 snapshot protocol.Message if err := wsjson.Read(ctx, conn, &snapshot); err != nil { t.Fatal(err) } request := func(message protocol.Message) protocol.Message { t.Helper() if err := wsjson.Write(ctx, conn, message); err != nil { t.Fatal(err) } var response protocol.Message if err := wsjson.Read(ctx, conn, &response); err != nil { t.Fatal(err) } if response.ID != message.ID { t.Fatal("response ID mismatch") } return response } invalid := request(protocol.Message{Type: protocol.RunPipeline, ID: "invalid", PipelineID: items[0].ID, RequestKey: "invalid"}) if invalid.Type != protocol.Error { t.Fatal("accepted unpinned run") } missingPrompt := request(protocol.Message{Type: protocol.RunPipeline, ID: "missing-prompt", PipelineID: items[0].ID, Version: 1, RequestKey: "missing-prompt"}) if missingPrompt.Type != protocol.Error || !strings.Contains(missingPrompt.Error, "user prompt") { t.Fatal("run accepted missing user prompt") } started := request(protocol.Message{Type: protocol.RunPipeline, ID: "start", PipelineID: items[0].ID, Version: 1, RequestKey: "ws-once", Input: map[string]any{"prompt": "test"}}) if started.Type != protocol.RunStarted || started.RunDetail == nil { t.Fatal("run not started", started) } if len(started.RunDetail.Graph.Stages) == 0 { t.Fatal("started run omitted pinned graph") } <-entered lookup := request(protocol.Message{Type: protocol.GetRun, ID: "reconcile", RequestKey: "ws-once"}) if lookup.Type != protocol.Run || lookup.RunDetail == nil || lookup.RunDetail.ID != started.RunDetail.ID { t.Fatalf("read-only admission lookup failed: %+v", lookup) } absent := request(protocol.Message{Type: protocol.GetRun, ID: "absent", RequestKey: "not-admitted"}) if absent.Type != protocol.Run || absent.RunDetail != nil { t.Fatalf("absent lookup must not invent a run: %+v", absent) } if response := request(protocol.Message{Type: protocol.Ping, ID: "ping"}); response.Type != protocol.Pong { t.Fatal("active run blocked ping") } if response := request(protocol.Message{Type: protocol.ListRuns, ID: "list"}); response.Type != protocol.Runs || len(response.Runs) != 1 { t.Fatal("run list missing") } if response := request(protocol.Message{Type: protocol.CancelRun, ID: "cancel", RunID: started.RunDetail.ID}); response.Type != protocol.Run { t.Fatal("cancel rejected") } handler.runner.wg.Wait() result := request(protocol.Message{Type: protocol.GetRun, ID: "inspect", RunID: started.RunDetail.ID}) if result.RunDetail == nil || result.RunDetail.Status != "canceled" || len(result.RunDetail.Steps) != 1 || result.RunDetail.Steps[0].Input["prompt"] != "test" { t.Fatal("missing canceled audit", result) } if len(result.RunDetail.Graph.Stages) != len(started.RunDetail.Graph.Stages) { t.Fatal("inspected run omitted pinned graph") } }