2307d45417
Ensure /new and chat close stop native foreground and background work before changing registry state. Preserve transcripts while surfacing release and recovery cleanup failures instead of reporting false success, with focused adapter and server regressions.
339 lines
13 KiB
Go
339 lines
13 KiB
Go
package server
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/coder/websocket/wsjson"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// TestChatCloseRecordsClosedState is the close-records-state evidence: a
|
|
// chat_close on a recorded operator session answers with the closed session, sets
|
|
// closed_at in the registry and leaves the session listed (as closed) by
|
|
// chat_sessions, so every client sees the same state.
|
|
func TestChatCloseRecordsClosedState(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.sessions = []protocol.ChatSession{{ID: "ses_1", Title: "A", Directory: "/work/a"}}
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatClose || response.ID != "cl1" {
|
|
t.Fatalf("chat_close response = %+v", response)
|
|
}
|
|
if response.ChatSession == nil || !response.ChatSession.Closed || response.ChatSession.ClosedAt <= 0 {
|
|
t.Fatalf("closed session not reported: %+v", response.ChatSession)
|
|
}
|
|
if response.ChatClose == nil || response.ChatClose.SessionID != "ses_1" || response.ChatClose.ClosedAt <= 0 {
|
|
t.Fatalf("chat_close result = %+v", response.ChatClose)
|
|
}
|
|
if response.ChatClose.Interrupted {
|
|
t.Fatalf("idle session reported an interrupted turn: %+v", response.ChatClose)
|
|
}
|
|
if _, interrupts, _ := broker.counts(); interrupts != 0 {
|
|
t.Fatalf("idle close interrupted a turn: %d", interrupts)
|
|
}
|
|
if released, _ := broker.releaseQuery(); len(released) != 1 || released[0] != "ses_1" {
|
|
t.Fatalf("released sessions = %v", released)
|
|
}
|
|
rows, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rows) != 1 || rows[0].ClosedAt <= 0 {
|
|
t.Fatalf("registry did not record the closed state: %+v", rows)
|
|
}
|
|
|
|
// The list still carries the session, marked closed, so it is reachable as
|
|
// history rather than disappearing.
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "l1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 1 {
|
|
t.Fatalf("chat_sessions = %+v", response)
|
|
}
|
|
if !response.ChatSessions[0].Closed || response.ChatSessions[0].ClosedAt <= 0 {
|
|
t.Fatalf("closed session not listed as closed: %+v", response.ChatSessions[0])
|
|
}
|
|
}
|
|
|
|
func TestChatCloseReportsReleaseFailureAndKeepsOpenState(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.releaseErr = errors.New("native runtime unavailable")
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reply := readMessage(t, ctx, conn)
|
|
if reply.Type != protocol.Error || !strings.Contains(reply.Error, "could not be released") {
|
|
t.Fatalf("release failure reply = %+v", reply)
|
|
}
|
|
row, found, err := store.OperatorSession(ctx, "ses_1")
|
|
if err != nil || !found || row.ClosedAt != 0 {
|
|
t.Fatalf("release failure changed registry: row=%+v found=%v err=%v", row, found, err)
|
|
}
|
|
}
|
|
|
|
// TestChatCloseStopsRunningTurn is the close-stops-a-running-turn evidence: a
|
|
// prompt holds the session (its stream is live), and chat_close from another
|
|
// connection interrupts it through the existing broker interrupt and reports that
|
|
// a turn was stopped.
|
|
func TestChatCloseStopsRunningTurn(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.done = make(chan struct{})
|
|
ctx, _, conns := dialChatConns(t, Options{Chat: broker, OperatorRegistry: store}, 2)
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Start a long-running turn on the first connection.
|
|
if err := wsjson.Write(ctx, conns[0], protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "long running"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := readTestFrame(ctx, conns[0], &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt {
|
|
t.Fatalf("prompt ack = %+v", ack)
|
|
}
|
|
<-broker.started
|
|
|
|
// Close from the second connection; it must interrupt the running turn.
|
|
if err := wsjson.Write(ctx, conns[1], protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conns[1], &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatClose || response.ID != "cl1" {
|
|
t.Fatalf("chat_close response = %+v", response)
|
|
}
|
|
if response.ChatClose == nil || !response.ChatClose.Interrupted {
|
|
t.Fatalf("close did not record a stopped turn: %+v", response.ChatClose)
|
|
}
|
|
if _, interrupts, _ := broker.counts(); interrupts != 1 {
|
|
t.Fatalf("interrupts = %d, want 1", interrupts)
|
|
}
|
|
rows, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rows) != 1 || rows[0].ClosedAt <= 0 {
|
|
t.Fatalf("registry did not record the closed state: %+v", rows)
|
|
}
|
|
}
|
|
|
|
// TestChatCloseKeepsSessionAndMessages pins that closing deletes nothing: the
|
|
// registry row survives (only its closed_at changes) and the session's history is
|
|
// still readable afterwards.
|
|
func TestChatCloseKeepsSessionAndMessages(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.messages = []protocol.ChatMessage{{ID: "m1", SessionID: "ses_1", Role: protocol.ChatRoleUser}}
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatClose {
|
|
t.Fatalf("close failed: %+v", response)
|
|
}
|
|
after, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(after) != 1 || after[0].ID != before[0].ID || after[0].Directory != before[0].Directory ||
|
|
after[0].Title != before[0].Title || after[0].Tag != before[0].Tag || after[0].CreatedAt != before[0].CreatedAt {
|
|
t.Fatalf("close changed the session beyond closed_at:\nbefore %+v\nafter %+v", before[0], after[0])
|
|
}
|
|
// The transcript is still readable.
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "ms1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatMessages || len(response.ChatMessages) != 1 || response.ChatMessages[0].ID != "m1" {
|
|
t.Fatalf("history lost after close: %+v", response)
|
|
}
|
|
if calls, _, _ := broker.messageQuery(); calls != 1 {
|
|
t.Fatalf("message reads = %d, want 1", calls)
|
|
}
|
|
}
|
|
|
|
// TestChatReopenClearsClosedState pins that chat_reopen is the inverse of
|
|
// chat_close: the closed state is cleared and the session is listed as active
|
|
// again.
|
|
func TestChatReopenClearsClosedState(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.CloseOperatorSession(ctx, "ses_1"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReopen, ID: "op1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatReopen || response.ID != "op1" || response.ChatSession == nil {
|
|
t.Fatalf("chat_reopen response = %+v", response)
|
|
}
|
|
if response.ChatSession.Closed || response.ChatSession.ClosedAt != 0 {
|
|
t.Fatalf("reopened session still closed: %+v", response.ChatSession)
|
|
}
|
|
rows, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rows) != 1 || rows[0].ClosedAt != 0 {
|
|
t.Fatalf("registry still closed after reopen: %+v", rows)
|
|
}
|
|
}
|
|
|
|
// TestChatPromptReopensClosedSession pins the second reopen path: simply
|
|
// prompting a closed session clears its closed state, so the operator never has
|
|
// to make an explicit reopen request.
|
|
func TestChatPromptReopensClosedSession(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := store.RecordOperatorSession(ctx, "ses_1", "/work/a", "A", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.CloseOperatorSession(ctx, "ses_1"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "resume"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := readTestFrame(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt {
|
|
t.Fatalf("prompt ack = %+v", ack)
|
|
}
|
|
_ = readChatTurn(t, ctx, conn)
|
|
rows, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rows) != 1 || rows[0].ClosedAt != 0 {
|
|
t.Fatalf("prompting did not clear the closed state: %+v", rows)
|
|
}
|
|
}
|
|
|
|
// TestChatCloseRefusesNonOperatorSession pins that a pipeline-owned run session
|
|
// (which has no operator_sessions row) is refused and nothing is written, so the
|
|
// close never touches the sessions the pipelines own.
|
|
func TestChatCloseRefusesNonOperatorSession(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "cl1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_run"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "not an operator") {
|
|
t.Fatalf("non-operator session not refused: %+v", response)
|
|
}
|
|
if _, interrupts, _ := broker.counts(); interrupts != 0 {
|
|
t.Fatalf("refused close still interrupted: %d", interrupts)
|
|
}
|
|
rows, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(rows) != 0 {
|
|
t.Fatalf("refused close wrote a registry row: %+v", rows)
|
|
}
|
|
}
|
|
|
|
// TestChatCloseRejectsInvalidInput pins that a missing/invalid session id and an
|
|
// unconfigured broker/registry are answered with an error before any write.
|
|
func TestChatCloseRejectsInvalidInput(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
for _, query := range []*protocol.ChatQuery{nil, {}, {SessionID: "not-a-session"}} {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatClose, ID: "bad", ChatQuery: query}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || response.ID != "bad" {
|
|
t.Fatalf("query %+v not rejected: %+v", query, response)
|
|
}
|
|
}
|
|
|
|
// No registry configured: refuse rather than close nothing.
|
|
noRegCtx, cancelNoReg, noRegConn := dialChatOptions(t, Options{Chat: broker})
|
|
defer cancelNoReg()
|
|
if err := wsjson.Write(noRegCtx, noRegConn, protocol.Message{Type: protocol.ChatClose, ID: "nr", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := readTestFrame(noRegCtx, noRegConn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "registry") {
|
|
t.Fatalf("close without registry = %+v", response)
|
|
}
|
|
|
|
// No broker configured: the existing "not configured" error.
|
|
noBrokerCtx, cancelNoBroker, noBrokerConn := dialChatOptions(t, Options{OperatorRegistry: store})
|
|
defer cancelNoBroker()
|
|
if err := wsjson.Write(noBrokerCtx, noBrokerConn, protocol.Message{Type: protocol.ChatClose, ID: "nb", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := readTestFrame(noBrokerCtx, noBrokerConn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") {
|
|
t.Fatalf("close without broker = %+v", response)
|
|
}
|
|
}
|