188 lines
7.3 KiB
Go
188 lines
7.3 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/coder/websocket"
|
|
"github.com/coder/websocket/wsjson"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// listedObservedChat is an observedChat whose endpoint lists ses_1, so
|
|
// chat_sessions returns its registry row.
|
|
type listedObservedChat struct{ *observedChat }
|
|
|
|
func (c listedObservedChat) Sessions(context.Context) ([]protocol.ChatSession, error) {
|
|
return []protocol.ChatSession{{ID: "ses_1"}}, nil
|
|
}
|
|
|
|
// readActivity reads raw frames until the next chat_activity push.
|
|
func readActivity(t *testing.T, ctx context.Context, conn *websocket.Conn) protocol.ChatActivity {
|
|
t.Helper()
|
|
for {
|
|
var message protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &message); err != nil {
|
|
t.Fatalf("read (waiting for chat_activity): %v", err)
|
|
}
|
|
if message.Type == protocol.ChatActivityChanged {
|
|
if message.ChatActivity == nil {
|
|
t.Fatal("chat_activity without a body")
|
|
}
|
|
return *message.ChatActivity
|
|
}
|
|
}
|
|
}
|
|
|
|
func shellFrame(id, status string) protocol.ChatEventFrame {
|
|
return protocol.ChatEventFrame{SessionID: "ses_1", Kind: protocol.ChatEventShell, Shell: &protocol.ChatShell{ID: id, Status: status, Command: "sleep 600"}}
|
|
}
|
|
|
|
func listActivity(t *testing.T, ctx context.Context, conn *websocket.Conn) *protocol.ChatActivity {
|
|
t.Helper()
|
|
writeChat(t, ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "list"})
|
|
reply := readUntil(t, ctx, conn, protocol.ChatSessions)
|
|
if len(reply.ChatSessions) != 1 || reply.ChatSessions[0].ID != "ses_1" {
|
|
t.Fatalf("chat_sessions = %+v", reply.ChatSessions)
|
|
}
|
|
return reply.ChatSessions[0].Activity
|
|
}
|
|
|
|
// A connection that never opened the chat still learns, from chat_activity,
|
|
// when its turn starts and ends and how many background tasks run, and the
|
|
// list carries the same summary with the same sequence. Output chunks push
|
|
// nothing. After the last viewer leaves, the session stays observed while a
|
|
// background task runs, and is released (pushing an idle summary) once the
|
|
// last one exits.
|
|
func TestChatActivityReachesEveryConnection(t *testing.T) {
|
|
fastUnattended(t)
|
|
t.Setenv("PIPELINES_NTFY_URL", "")
|
|
store := unattendedStore(t, false)
|
|
broker := newObservedChat()
|
|
server := startQueueServer(t, listedObservedChat{broker}, store)
|
|
viewer := dialChatConn(t, server.ctx, server.srv)
|
|
list := dialChatConn(t, server.ctx, server.srv)
|
|
|
|
// A session that never changed still carries a sequence (this server's
|
|
// current one), so it orders after anything kept from an earlier process.
|
|
initial := listActivity(t, server.ctx, list)
|
|
if initial == nil || initial.TurnRunning || initial.BackgroundTasks != 0 || initial.Seq == 0 {
|
|
t.Fatalf("idle row activity = %+v, want an empty summary with a sequence", initial)
|
|
}
|
|
|
|
sendPrompt(t, server.ctx, viewer, "p1", "build it", "op-1")
|
|
started := readActivity(t, server.ctx, list)
|
|
if started.SessionID != "ses_1" || !started.TurnRunning || started.BackgroundTasks != 0 || started.Seq <= initial.Seq {
|
|
t.Fatalf("turn start push = %+v", started)
|
|
}
|
|
broker.push(stepFrameFor(protocol.ChatStepStarted, "turn_1"))
|
|
broker.push(textFrame("Working on it."))
|
|
broker.push(shellFrame("sh_1", protocol.ChatShellRunning))
|
|
withTask := readActivity(t, server.ctx, list)
|
|
if !withTask.TurnRunning || withTask.BackgroundTasks != 1 || withTask.Seq <= started.Seq {
|
|
t.Fatalf("background task push = %+v (after %+v); a text chunk or the re-announced turn must push nothing", withTask, started)
|
|
}
|
|
broker.push(stepFrameFor(protocol.ChatStepEnded, "turn_1"))
|
|
ended := readActivity(t, server.ctx, list)
|
|
if ended.TurnRunning || ended.BackgroundTasks != 1 || ended.Seq <= withTask.Seq {
|
|
t.Fatalf("turn end push = %+v", ended)
|
|
}
|
|
if got := listActivity(t, server.ctx, list); got == nil || got.TurnRunning || got.BackgroundTasks != 1 || got.Seq != ended.Seq {
|
|
t.Fatalf("listed activity = %+v, want %+v", got, ended)
|
|
}
|
|
|
|
viewer.CloseNow()
|
|
time.Sleep(100 * time.Millisecond) // let the server notice the disconnect
|
|
if active, _ := broker.streams(); active != 1 {
|
|
t.Fatalf("a running background task was not observed after the viewer left: %d streams", active)
|
|
}
|
|
broker.push(shellFrame("sh_1", protocol.ChatShellExited))
|
|
idle := readActivity(t, server.ctx, list)
|
|
if idle.TurnRunning || idle.BackgroundTasks != 0 || idle.Seq <= ended.Seq {
|
|
t.Fatalf("task exit push = %+v", idle)
|
|
}
|
|
waitFor(t, "observer released", func() bool { active, _ := broker.streams(); return active == 0 })
|
|
if got := listActivity(t, server.ctx, list); got == nil || got.BackgroundTasks != 0 || got.Seq != idle.Seq {
|
|
t.Fatalf("listed activity after release = %+v, want %+v", got, idle)
|
|
}
|
|
}
|
|
|
|
// A running task is not an idle observer: the old observer TTL must not
|
|
// invent completion. A terminal event releases it and clears list activity.
|
|
func TestChatBackgroundTaskWaitsForExitBeyondObserverTTL(t *testing.T) {
|
|
fastUnattended(t)
|
|
t.Setenv("PIPELINES_NTFY_URL", "")
|
|
limit := chatUnattendedTurnLimit
|
|
chatUnattendedTurnLimit = 300 * time.Millisecond
|
|
t.Cleanup(func() { chatUnattendedTurnLimit = limit })
|
|
store := unattendedStore(t, false)
|
|
broker := newObservedChat()
|
|
server := startQueueServer(t, listedObservedChat{broker}, store)
|
|
viewer := dialChatConn(t, server.ctx, server.srv)
|
|
list := dialChatConn(t, server.ctx, server.srv)
|
|
// A reply proves the connection reached its read loop, where it is
|
|
// attached to the pushes.
|
|
listActivity(t, server.ctx, list)
|
|
sendPrompt(t, server.ctx, viewer, "p1", "build it", "op-1")
|
|
readActivity(t, server.ctx, list)
|
|
broker.push(stepFrameFor(protocol.ChatStepStarted, "turn_1"))
|
|
broker.push(shellFrame("sh_1", protocol.ChatShellRunning))
|
|
readActivity(t, server.ctx, list)
|
|
broker.push(stepFrameFor(protocol.ChatStepEnded, "turn_1"))
|
|
readActivity(t, server.ctx, list)
|
|
viewer.CloseNow()
|
|
time.Sleep(2 * chatUnattendedTurnLimit)
|
|
if active, _ := broker.streams(); active != 1 {
|
|
t.Fatalf("background observer expired: %d", active)
|
|
}
|
|
if got := listActivity(t, server.ctx, list); got == nil || got.BackgroundTasks != 1 {
|
|
t.Fatalf("invented task completion: %+v", got)
|
|
}
|
|
broker.push(shellFrame("sh_1", protocol.ChatShellExited))
|
|
released := readActivity(t, server.ctx, list)
|
|
if released.TurnRunning || released.BackgroundTasks != 0 {
|
|
t.Fatalf("release push = %+v", released)
|
|
}
|
|
waitFor(t, "observer released", func() bool { active, _ := broker.streams(); return active == 0 })
|
|
if got := listActivity(t, server.ctx, list); got == nil || got.BackgroundTasks != 0 {
|
|
t.Fatalf("listed activity after completion = %+v", got)
|
|
}
|
|
}
|
|
|
|
// The hub keeps an unattended room for background tasks only: an idle room
|
|
// with none is released when its last client leaves, a room with one is kept.
|
|
func TestChatBackgroundTasksKeepUnattendedRoom(t *testing.T) {
|
|
fastUnattended(t)
|
|
h := newChatHub()
|
|
defer func() {
|
|
h.mu.Lock()
|
|
for _, room := range h.rooms {
|
|
room.cancel()
|
|
}
|
|
h.mu.Unlock()
|
|
}()
|
|
for _, tasks := range []int{0, 1} {
|
|
id := "ses_idle"
|
|
if tasks > 0 {
|
|
id = "ses_task"
|
|
}
|
|
h.mu.Lock()
|
|
room := h.roomLocked(id)
|
|
if tasks > 0 {
|
|
h.turnLocked(id).applyShell(&protocol.ChatShell{ID: "sh_1", Status: protocol.ChatShellRunning})
|
|
}
|
|
sub := &chatSub{hub: h, room: room, clientID: "c", ch: make(chan protocol.Message, 1), done: make(chan struct{})}
|
|
room.subs["c"] = sub
|
|
h.mu.Unlock()
|
|
h.detach(id, sub)
|
|
h.mu.Lock()
|
|
kept := h.rooms[id] == room
|
|
h.mu.Unlock()
|
|
if kept != (tasks > 0) {
|
|
t.Fatalf("%d background tasks: kept=%v", tasks, kept)
|
|
}
|
|
}
|
|
}
|