798e958cb7
The phone's chat transcript rendered one agent reply as ~36 bubbles, each with its own thinking block, and a finished tool call lost its name and its input. - Turn fold (android): ChatFormat.kt gains the pure ChatTurn / TranscriptRow / transcriptRows fold - each run of consecutive assistant messages between two of the operator's messages is one agent turn - and ChatTranscript renders one bubble per turn: the turn's single collapsible thinking block (all its reasoning, in order, growing live while it streams), then its tool-call chips, then one answer block of just the turn's text parts. AssistantParts/MessagePart are replaced by AgentTurnItem/UserMessageItem; ChatConversationPane counts the folded rows. - Delta part ids (server + client): internal/protocol/chat.go adds ChatDeltaPartID(messageID, kind, ordinal), mirrored as ChatProtocol.deltaPartId in data/protocol/Chat.kt, and NormalizeChatEvent keys a text or reasoning delta on it. OpenCode numbers a message's text and reasoning parts independently from 0, so the old "%s#%d" gave the first text delta and first reasoning part the same id: the answer was appended into the thinking block, and the server's retained state (chat_hub.go) re-collided on resume. ChatStore's upsert now routes a delta through the kind-aware deltaPartId fold, so it stays robust even against a peer that still shares one id. - Tool fields (server + client): NormalizeChatEvent takes a call's arguments from session.tool.input.ended's text as well as session.tool.called's input object (toolInput), and chat_hub.go's new mergeChatToolPart folds each tool frame onto the retained part so the progress/success frames that omit name and input never blank them. ChatFormat.kt's mergeToolPart mirrors that on the client, so the chip and panel header keep the real tool name and the panel shows INPUT beside OUTPUT. Tests: chat_v2_test.go and chat_test.go add the text/reasoning id-collision and the tool name+input retention cases; ChatReasoningTurnTest, ChatTranscriptTest and ChatRunningWorkTest cover the turn fold, the collision and the tool lifecycle. Checks: Go build, vet, gofmt and the package tests pass (go build ./... && go vet ./...; gofmt -l . empty; go test ./internal/server ./internal/opencode ./internal/protocol ./internal/stage ./internal/pipeline; go test ./...). Android passes offline with --no-daemon (assembleDebug and the full testDebugUnitTest suite, 660 tests). The on-phone observation was not performed: the device lock was held by another run and adb was not available here. Documentation inventory checked: no packaged OpenCode skill reference in internal/author/skill/references/ and no packaged template documents the app's chat transcript, this delta part-id derivation or the tool-field retention, and no internal/author/ managed file inventory entry names any touched file, so none of them needs updating. The shared android/README.md behaviour statements are made stale by this change and are recorded instead in docs/notes/chat-transcript-turn-fold.md for the docs-fold writer, per the repo rule that an item never edits a shared document itself.
1841 lines
74 KiB
Go
1841 lines
74 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/coder/websocket"
|
|
"github.com/coder/websocket/wsjson"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/opencode"
|
|
"git.a-wan.net/alan/pipelines/internal/pipeline"
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
// newOperatorStore opens a scratch store for the operator-session registry, so
|
|
// the chat tests exercise the real SQL-backed registry (record, list, delete)
|
|
// rather than a second fake of it.
|
|
func newOperatorStore(t *testing.T) *pipeline.Store {
|
|
t.Helper()
|
|
store, err := pipeline.Open(filepath.Join(t.TempDir(), "operator.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { store.Close() })
|
|
return store
|
|
}
|
|
|
|
// fakeChat is a scripted chatBroker. It counts calls and either emits a fixed
|
|
// frame sequence or blocks until the caller's context is canceled.
|
|
type fakeChat struct {
|
|
mu sync.Mutex
|
|
promptCalls int
|
|
interrupts int
|
|
replies int
|
|
replyRequest protocol.ChatReplyRequest
|
|
replyErr error
|
|
messageCalls int
|
|
messageSessionID string
|
|
messageLimit int
|
|
messages []protocol.ChatMessage
|
|
permissionCalls int
|
|
permissionSessionID string
|
|
permissions []protocol.ChatPermissionFrame
|
|
permissionErr error
|
|
sessionCalls int
|
|
sessions []protocol.ChatSession
|
|
sessionErr error
|
|
permBlock bool
|
|
permDone chan struct{}
|
|
permOnce sync.Once
|
|
script []protocol.ChatEventFrame
|
|
started chan struct{}
|
|
done chan struct{}
|
|
startOnce sync.Once
|
|
block bool
|
|
subscribed bool
|
|
promptBeforeSubscribe bool
|
|
interruptErr error
|
|
createCalls int
|
|
createTitle string
|
|
createDirectory string
|
|
created protocol.ChatSession
|
|
createErr error
|
|
sessionByIDCalls int
|
|
sessionByID string
|
|
sessionRecord protocol.ChatSession
|
|
sessionFound bool
|
|
sessionByIDErr error
|
|
}
|
|
|
|
func (f *fakeChat) Prompt(context.Context, string, string) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.promptCalls++
|
|
if !f.subscribed {
|
|
f.promptBeforeSubscribe = true
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeChat) Stream(ctx context.Context, _ string, ready func(), emit func(protocol.ChatEventFrame) error) error {
|
|
f.mu.Lock()
|
|
f.subscribed = true
|
|
f.mu.Unlock()
|
|
if ready != nil {
|
|
ready()
|
|
}
|
|
if f.started != nil {
|
|
f.startOnce.Do(func() { close(f.started) })
|
|
}
|
|
if f.block {
|
|
<-ctx.Done()
|
|
if f.done != nil {
|
|
close(f.done)
|
|
}
|
|
return ctx.Err()
|
|
}
|
|
for _, frame := range f.script {
|
|
if err := ctx.Err(); err != nil {
|
|
return err
|
|
}
|
|
if err := emit(frame); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeChat) Interrupt(context.Context, string) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.interrupts++
|
|
return f.interruptErr
|
|
}
|
|
|
|
func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.messageCalls++
|
|
f.messageSessionID = sessionID
|
|
f.messageLimit = limit
|
|
return f.messages, nil
|
|
}
|
|
|
|
// messageQuery reports the recorded chat_messages call count, session id and
|
|
// limit so a test can assert the handler forwarded the query.
|
|
func (f *fakeChat) messageQuery() (int, string, int) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.messageCalls, f.messageSessionID, f.messageLimit
|
|
}
|
|
|
|
func (f *fakeChat) Reply(_ context.Context, request protocol.ChatReplyRequest) error {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.replies++
|
|
f.replyRequest = request
|
|
return f.replyErr
|
|
}
|
|
|
|
// Permissions returns the seeded pending requests, or blocks until the caller's
|
|
// context is canceled when permBlock is set (used to prove the poller stops on
|
|
// disconnect). Every call is counted so a test can assert polling happened.
|
|
func (f *fakeChat) Permissions(ctx context.Context, sessionID string) ([]protocol.ChatPermissionFrame, error) {
|
|
f.mu.Lock()
|
|
f.permissionCalls++
|
|
f.permissionSessionID = sessionID
|
|
frames := append([]protocol.ChatPermissionFrame(nil), f.permissions...)
|
|
err := f.permissionErr
|
|
block := f.permBlock
|
|
done := f.permDone
|
|
f.mu.Unlock()
|
|
if block {
|
|
<-ctx.Done()
|
|
if done != nil {
|
|
f.permOnce.Do(func() { close(done) })
|
|
}
|
|
return nil, ctx.Err()
|
|
}
|
|
return frames, err
|
|
}
|
|
|
|
// permissionQuery reports the recorded permission poll count and session id.
|
|
func (f *fakeChat) permissionQuery() (int, string) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.permissionCalls, f.permissionSessionID
|
|
}
|
|
|
|
// Sessions returns the seeded session list and counts each call so a test can
|
|
// assert the list handler asks the broker at most once per request.
|
|
func (f *fakeChat) Sessions(context.Context) ([]protocol.ChatSession, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.sessionCalls++
|
|
return f.sessions, f.sessionErr
|
|
}
|
|
|
|
// sessionQuery reports the recorded chat_sessions call count.
|
|
func (f *fakeChat) sessionQuery() int {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.sessionCalls
|
|
}
|
|
|
|
// Create records the title and directory the handler forwarded and returns the
|
|
// seeded created session. A blank created id defaults to "ses_created" so a test
|
|
// only asserts what it cares about.
|
|
func (f *fakeChat) Create(_ context.Context, title, directory string) (protocol.ChatSession, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.createCalls++
|
|
f.createTitle = title
|
|
f.createDirectory = directory
|
|
if f.createErr != nil {
|
|
return protocol.ChatSession{}, f.createErr
|
|
}
|
|
session := f.created
|
|
if session.ID == "" {
|
|
session.ID = "ses_created"
|
|
}
|
|
return session, nil
|
|
}
|
|
|
|
// createQuery reports the recorded chat_create call count, title and directory.
|
|
func (f *fakeChat) createQuery() (int, string, string) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.createCalls, f.createTitle, f.createDirectory
|
|
}
|
|
|
|
// Session returns the seeded endpoint record of one session (or "not found")
|
|
// and counts each call, so the adopt handler can be asserted to read the
|
|
// endpoint exactly once and never invent a directory.
|
|
func (f *fakeChat) Session(_ context.Context, sessionID string) (protocol.ChatSession, bool, error) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
f.sessionByIDCalls++
|
|
f.sessionByID = sessionID
|
|
if f.sessionByIDErr != nil {
|
|
return protocol.ChatSession{}, false, f.sessionByIDErr
|
|
}
|
|
if !f.sessionFound {
|
|
return protocol.ChatSession{}, false, nil
|
|
}
|
|
session := f.sessionRecord
|
|
if session.ID == "" {
|
|
session.ID = sessionID
|
|
}
|
|
return session, true, nil
|
|
}
|
|
|
|
// sessionByIDQuery reports the recorded chat_adopt read count and last id.
|
|
func (f *fakeChat) sessionByIDQuery() (int, string) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.sessionByIDCalls, f.sessionByID
|
|
}
|
|
|
|
// replyQuery reports the recorded chat_reply count and the last forwarded
|
|
// request, so a test can assert the exact session/request/decision.
|
|
func (f *fakeChat) replyQuery() (int, protocol.ChatReplyRequest) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.replies, f.replyRequest
|
|
}
|
|
|
|
func (f *fakeChat) counts() (int, int, int) {
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
return f.promptCalls, f.interrupts, f.replies
|
|
}
|
|
|
|
func chatFrame(kind, delta string, part *protocol.ChatPart, step *protocol.ChatStep) protocol.ChatEventFrame {
|
|
return protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: kind, Delta: delta, Part: part, Step: step}
|
|
}
|
|
|
|
func scriptedChat() *fakeChat {
|
|
return &fakeChat{script: []protocol.ChatEventFrame{
|
|
chatFrame(protocol.ChatEventText, "hello ", &protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0)}, nil),
|
|
chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0)}, nil),
|
|
chatFrame(protocol.ChatEventTool, "", &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: []byte(`{"command":"ls"}`)}}, nil),
|
|
chatFrame(protocol.ChatEventStep, "", nil, &protocol.ChatStep{Status: protocol.ChatStepEnded, Index: 1}),
|
|
}}
|
|
}
|
|
|
|
func dialChat(t *testing.T, broker chatBroker) (context.Context, context.CancelFunc, *websocket.Conn) {
|
|
t.Helper()
|
|
return dialChatOptions(t, Options{Chat: broker})
|
|
}
|
|
|
|
func dialChatOptions(t *testing.T, options Options) (context.Context, context.CancelFunc, *websocket.Conn) {
|
|
t.Helper()
|
|
ctx, cancel, conns := dialChatConns(t, options, 1)
|
|
return ctx, cancel, conns[0]
|
|
}
|
|
|
|
// dialChatConns starts one server and dials n connections to the same hub, so a
|
|
// test can exercise two clients contending for one session.
|
|
func dialChatConns(t *testing.T, options Options, n int) (context.Context, context.CancelFunc, []*websocket.Conn) {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
srv := httptest.NewServer(HandlerWithOptions(ctx, options))
|
|
t.Cleanup(func() { srv.Close(); cancel() })
|
|
conns := make([]*websocket.Conn, 0, n)
|
|
for i := 0; i < n; i++ {
|
|
conn, _, err := websocket.Dial(ctx, "ws"+strings.TrimPrefix(srv.URL, "http")+"/connect", nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { conn.CloseNow() })
|
|
conns = append(conns, conn)
|
|
}
|
|
return ctx, cancel, conns
|
|
}
|
|
|
|
func readChatTurn(t *testing.T, ctx context.Context, conn *websocket.Conn) []protocol.ChatEventFrame {
|
|
t.Helper()
|
|
var frames []protocol.ChatEventFrame
|
|
for {
|
|
var message protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &message); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if message.Type == protocol.Error {
|
|
t.Fatalf("unexpected error frame: %s", message.Error)
|
|
}
|
|
if message.ChatEvent == nil {
|
|
continue
|
|
}
|
|
frames = append(frames, *message.ChatEvent)
|
|
if message.ChatEvent.Kind == protocol.ChatEventStep && message.ChatEvent.Step != nil && message.ChatEvent.Step.Status == protocol.ChatStepEnded {
|
|
return frames
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestChatPromptStreamsEvents(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "r1" {
|
|
t.Fatalf("ack = %+v", ack)
|
|
}
|
|
frames := readChatTurn(t, ctx, conn)
|
|
if len(frames) != 4 {
|
|
t.Fatalf("got %d frames, want 4", len(frames))
|
|
}
|
|
sawText, sawStep := false, false
|
|
for _, frame := range frames {
|
|
if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" {
|
|
t.Fatalf("frame missing stable ids: %+v", frame)
|
|
}
|
|
switch frame.Kind {
|
|
case protocol.ChatEventText:
|
|
sawText = true
|
|
case protocol.ChatEventStep:
|
|
sawStep = true
|
|
if frame.Step == nil || frame.Step.Status != protocol.ChatStepEnded {
|
|
t.Fatalf("step frame = %+v", frame)
|
|
}
|
|
}
|
|
}
|
|
if !sawText || !sawStep {
|
|
t.Fatalf("missing text or step frame: %+v", frames)
|
|
}
|
|
if prompts, _, _ := broker.counts(); prompts != 1 {
|
|
t.Fatalf("prompt forwarded %d times, want 1", prompts)
|
|
}
|
|
}
|
|
|
|
func TestChatPromptRejectsInvalidSession(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
for _, id := range []string{"", "not-a-session", "msg_1"} {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "bad", ChatPrompt: &protocol.ChatPromptRequest{SessionID: id, Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || response.ID != "bad" {
|
|
t.Fatalf("session %q not rejected: %+v", id, response)
|
|
}
|
|
}
|
|
if prompts, _, _ := broker.counts(); prompts != 0 {
|
|
t.Fatalf("invalid sessions reached OpenCode: %d", prompts)
|
|
}
|
|
}
|
|
|
|
func TestChatPromptRejectsOversizedText(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
oversized := strings.Repeat("x", opencode.MaxRequest+1)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "big", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: oversized}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "64 KiB") {
|
|
t.Fatalf("oversized prompt not rejected: %+v", response)
|
|
}
|
|
if prompts, _, _ := broker.counts(); prompts != 0 {
|
|
t.Fatalf("oversized prompt reached OpenCode: %d", prompts)
|
|
}
|
|
}
|
|
|
|
func TestChatPromptWithoutBroker(t *testing.T) {
|
|
ctx, _, conn := dialChat(t, nil)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") {
|
|
t.Fatalf("unconfigured chat not rejected: %+v", response)
|
|
}
|
|
}
|
|
|
|
func TestChatMessagesResumesRetainedState(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
readChatTurn(t, ctx, conn)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatMessages || response.ID != "r2" || len(response.ChatMessages) != 2 {
|
|
t.Fatalf("resume response = %+v", response)
|
|
}
|
|
// The prompt is retained as a user turn and the assistant reply beside it, so
|
|
// a reconnecting client re-syncs a conversation that still says who sent
|
|
// what. The user turn carries the sending client's label (the generic
|
|
// fallback when the prompt did not name one).
|
|
user := response.ChatMessages[0]
|
|
if user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "hi" || user.Client != chatClientLabelFallback {
|
|
t.Fatalf("resumed user turn = %+v", user)
|
|
}
|
|
message := response.ChatMessages[1]
|
|
if message.ID != "msg_1" || message.Role != protocol.ChatRoleAssistant || len(message.Parts) != 2 {
|
|
t.Fatalf("resumed message = %+v", message)
|
|
}
|
|
if message.Parts[0].Type != protocol.ChatPartText || message.Parts[0].ID != protocol.ChatDeltaPartID("msg_1", protocol.ChatPartText, 0) || message.Parts[0].Text != "hello world" {
|
|
t.Fatalf("resumed text part = %+v", message.Parts[0])
|
|
}
|
|
if message.Parts[1].Type != protocol.ChatPartTool || message.Parts[1].State == nil || message.Parts[1].State.Status != protocol.ChatToolCompleted {
|
|
t.Fatalf("resumed tool part = %+v", message.Parts[1])
|
|
}
|
|
}
|
|
|
|
// seededChatMessages is the stored user + assistant + tool session the
|
|
// chat_messages evidence tests assert on, mirroring the OpenCode V2 shape of an
|
|
// assistant turn's completed tool part (input object, text content, status).
|
|
func seededChatMessages() []protocol.ChatMessage {
|
|
return []protocol.ChatMessage{
|
|
{ID: "msg_user", SessionID: "ses_1", Role: protocol.ChatRoleUser,
|
|
Parts: []protocol.ChatPart{{Type: protocol.ChatPartText, Text: "list the files"}}},
|
|
{ID: "msg_assistant", SessionID: "ses_1", Role: protocol.ChatRoleAssistant, Model: "deepseek-v4.1-flash", Agent: "build",
|
|
Parts: []protocol.ChatPart{
|
|
{Type: protocol.ChatPartText, ID: "p1", Text: "here you go"},
|
|
{Type: protocol.ChatPartReasoning, ID: "p2", Text: "thinking"},
|
|
{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
|
|
State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`{"command":"ls"}`), Content: []protocol.ChatToolContent{{Type: "text", Text: "ok"}}},
|
|
Time: &protocol.ChatTime{Created: 1, Ran: 2, Completed: 3}},
|
|
}},
|
|
}
|
|
}
|
|
|
|
// assertSeededChatMessages fails unless the user + assistant + tool session came
|
|
// back with both roles and the completed tool part's input, content and status.
|
|
func assertSeededChatMessages(t *testing.T, messages []protocol.ChatMessage) {
|
|
t.Helper()
|
|
if len(messages) != 2 {
|
|
t.Fatalf("got %d messages, want user+assistant: %+v", len(messages), messages)
|
|
}
|
|
user, assistant := messages[0], messages[1]
|
|
if user.ID != "msg_user" || user.Role != protocol.ChatRoleUser || len(user.Parts) != 1 || user.Parts[0].Type != protocol.ChatPartText || user.Parts[0].Text != "list the files" {
|
|
t.Fatalf("user turn = %+v", user)
|
|
}
|
|
if assistant.ID != "msg_assistant" || assistant.Role != protocol.ChatRoleAssistant || len(assistant.Parts) != 3 {
|
|
t.Fatalf("assistant turn = %+v", assistant)
|
|
}
|
|
if p := assistant.Parts[0]; p.Type != protocol.ChatPartText || p.Text != "here you go" {
|
|
t.Fatalf("assistant text part = %+v", p)
|
|
}
|
|
tool := assistant.Parts[2]
|
|
if tool.Type != protocol.ChatPartTool || tool.ID != "call_1" || tool.Name != "shell" || tool.State == nil || tool.State.Status != protocol.ChatToolCompleted {
|
|
t.Fatalf("assistant tool part = %+v", tool)
|
|
}
|
|
var input struct {
|
|
Command string `json:"command"`
|
|
}
|
|
if err := json.Unmarshal(tool.State.Input, &input); err != nil || input.Command != "ls" {
|
|
t.Fatalf("tool input = %s (err %v)", tool.State.Input, err)
|
|
}
|
|
if len(tool.State.Content) != 1 || tool.State.Content[0].Text != "ok" {
|
|
t.Fatalf("tool content = %+v", tool.State.Content)
|
|
}
|
|
}
|
|
|
|
// TestChatMessagesReturnsBrokerHistory drives chat_messages through the handler
|
|
// with an empty hub, so it must fall through to broker.Messages and return the
|
|
// seeded user + assistant + tool session, forwarding the query limit unchanged.
|
|
func TestChatMessagesReturnsBrokerHistory(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.messages = seededChatMessages()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1", Limit: 7}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatMessages || response.ID != "r2" {
|
|
t.Fatalf("response = %+v", response)
|
|
}
|
|
assertSeededChatMessages(t, response.ChatMessages)
|
|
if calls, sessionID, limit := broker.messageQuery(); calls != 1 || sessionID != "ses_1" || limit != 7 {
|
|
t.Fatalf("broker query = %d/%q/%d, want 1/ses_1/7", calls, sessionID, limit)
|
|
}
|
|
}
|
|
|
|
// TestChatMessagesThroughRealAdapter loads a seeded session through the real
|
|
// opencode.Chat broker: the chat_messages handler reads the V2
|
|
// GET /api/session/{id}/message fixture once and returns the user + assistant +
|
|
// tool turns decoded from it, exercising the full handler -> adapter -> decode
|
|
// path with no scripted broker.
|
|
func TestChatMessagesThroughRealAdapter(t *testing.T) {
|
|
var messageReads atomic.Int32
|
|
fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Method != http.MethodGet || r.URL.Path != "/api/session/ses_1/message" {
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
return
|
|
}
|
|
messageReads.Add(1)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"data":[
|
|
{"id":"msg_user","time":{"created":10},"type":"user","text":"list the files"},
|
|
{"id":"msg_assistant","time":{"created":20,"completed":30},"type":"assistant","agent":"build","model":{"id":"deepseek-v4.1-flash","providerID":"opencode-go"},"content":[
|
|
{"type":"text","text":"here you go"},
|
|
{"type":"reasoning","text":"thinking"},
|
|
{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"completed","input":{"command":"ls"},"content":[{"type":"text","text":"ok"}]},"time":{"created":1,"ran":2,"completed":3}}
|
|
]}
|
|
],"cursor":{"next":null}}`))
|
|
}))
|
|
defer fixture.Close()
|
|
|
|
broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL})
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "r2", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatMessages || response.ID != "r2" {
|
|
t.Fatalf("response = %+v", response)
|
|
}
|
|
assertSeededChatMessages(t, response.ChatMessages)
|
|
if messageReads.Load() != 1 {
|
|
t.Fatalf("message endpoint read %d times, want 1", messageReads.Load())
|
|
}
|
|
}
|
|
|
|
// TestChatMessagesRejectsInvalidSession pins that a missing or malformed session
|
|
// id is rejected before any broker call.
|
|
func TestChatMessagesRejectsInvalidSession(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.messages = seededChatMessages()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
for _, query := range []*protocol.ChatQuery{nil, {SessionID: ""}, {SessionID: "not-a-session"}} {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatMessages, ID: "bad", ChatQuery: query}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(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)
|
|
}
|
|
}
|
|
if calls, _, _ := broker.messageQuery(); calls != 0 {
|
|
t.Fatalf("invalid chat_messages reached the broker: %d", calls)
|
|
}
|
|
}
|
|
|
|
func TestChatDisconnectCancelsStream(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.done = make(chan struct{})
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
select {
|
|
case <-broker.started:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("stream never started")
|
|
}
|
|
conn.CloseNow()
|
|
// The server's read loop returns on disconnect, canceling the connection
|
|
// context the subscription observes; no goroutine may keep running.
|
|
select {
|
|
case <-broker.done:
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("chat stream was not canceled on disconnect")
|
|
}
|
|
if prompts, _, _ := broker.counts(); prompts != 1 {
|
|
t.Fatalf("prompt forwarded %d times, want 1", prompts)
|
|
}
|
|
}
|
|
|
|
func TestChatInterruptAndReply(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatInterrupt || response.ID != "i1" {
|
|
t.Fatalf("interrupt response = %+v", response)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatReply || response.ID != "p1" {
|
|
t.Fatalf("reply response = %+v", response)
|
|
}
|
|
if _, interrupts, replies := broker.counts(); interrupts != 1 || replies != 1 {
|
|
t.Fatalf("interrupts=%d replies=%d, want 1/1", interrupts, replies)
|
|
}
|
|
}
|
|
|
|
// TestChatInterruptEndsRunningPrompt is the task evidence: it starts a
|
|
// long-running turn through the real opencode.Chat adapter over an httptest SSE
|
|
// fixture, sends chat_interrupt, and asserts the run ends. The fixture records
|
|
// the actual POST /api/session/ses_1/interrupt and only closes the SSE
|
|
// subscription once that request arrives, so the run genuinely terminates rather
|
|
// than completing on its own.
|
|
func TestChatInterruptEndsRunningPrompt(t *testing.T) {
|
|
var (
|
|
mu sync.Mutex
|
|
prompts int
|
|
interrupts int
|
|
interruptPath string
|
|
)
|
|
interrupted := make(chan struct{})
|
|
var interruptOnce sync.Once
|
|
fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/prompt":
|
|
mu.Lock()
|
|
prompts++
|
|
mu.Unlock()
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/permission/request":
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/event":
|
|
flusher, ok := w.(http.Flusher)
|
|
if !ok {
|
|
t.Errorf("event stream response is not flushable")
|
|
return
|
|
}
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = w.Write([]byte("data: " + `{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"working"}}` + "\n\n"))
|
|
flusher.Flush()
|
|
// Hold the turn open until the interrupt arrives so the test exercises
|
|
// a running run, not a stream that already completed.
|
|
select {
|
|
case <-interrupted:
|
|
case <-r.Context().Done():
|
|
return
|
|
}
|
|
_, _ = w.Write([]byte("data: " + `{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}` + "\n\n"))
|
|
flusher.Flush()
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/interrupt":
|
|
mu.Lock()
|
|
interrupts++
|
|
interruptPath = r.URL.Path
|
|
mu.Unlock()
|
|
interruptOnce.Do(func() { close(interrupted) })
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{}`))
|
|
default:
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
}
|
|
}))
|
|
defer fixture.Close()
|
|
|
|
broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL})
|
|
ctx, _, conn := dialChat(t, broker)
|
|
|
|
// Start a long-running turn.
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "start a long-running task"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "r1" {
|
|
t.Fatalf("prompt ack = %+v", ack)
|
|
}
|
|
// The first text delta proves the turn is live and the subscription attached.
|
|
var first protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &first); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if first.Type != protocol.ChatEvent || first.ChatEvent == nil || first.ChatEvent.Kind != protocol.ChatEventText || first.ChatEvent.Delta != "working" {
|
|
t.Fatalf("expected a live text delta, got %+v", first)
|
|
}
|
|
|
|
// Stop the running turn.
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Read until both the interrupt ack and the step.ended frame arrive, in
|
|
// whichever order the server emits them; any error frame fails the test.
|
|
var acked, ended bool
|
|
for !acked || !ended {
|
|
var message protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &message); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if message.Type == protocol.Error {
|
|
t.Fatalf("unexpected error frame: %s", message.Error)
|
|
}
|
|
if message.Type == protocol.ChatInterrupt {
|
|
if message.ID != "i1" {
|
|
t.Fatalf("interrupt ack id = %q, want i1", message.ID)
|
|
}
|
|
acked = true
|
|
}
|
|
if event := message.ChatEvent; event != nil && event.SessionID == "ses_1" && event.Kind == protocol.ChatEventStep && event.Step != nil && event.Step.Status == protocol.ChatStepEnded {
|
|
ended = true
|
|
}
|
|
}
|
|
mu.Lock()
|
|
gotPrompts, gotInterrupts, gotPath := prompts, interrupts, interruptPath
|
|
mu.Unlock()
|
|
if gotPrompts != 1 {
|
|
t.Fatalf("prompt posts = %d, want 1", gotPrompts)
|
|
}
|
|
if gotInterrupts != 1 {
|
|
t.Fatalf("interrupt posts = %d, want 1", gotInterrupts)
|
|
}
|
|
if gotPath != "/api/session/ses_1/interrupt" {
|
|
t.Fatalf("interrupt path = %q, want /api/session/ses_1/interrupt", gotPath)
|
|
}
|
|
}
|
|
|
|
// TestChatInterruptRejectsInvalidSession pins that a missing, empty or malformed
|
|
// session id is rejected with a protocol.Error before any broker call.
|
|
func TestChatInterruptRejectsInvalidSession(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
for _, query := range []*protocol.ChatQuery{nil, {}, {SessionID: "not-a-session"}} {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "bad", ChatQuery: query}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(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)
|
|
}
|
|
}
|
|
if _, interrupts, _ := broker.counts(); interrupts != 0 {
|
|
t.Fatalf("invalid interrupts reached the broker: %d", interrupts)
|
|
}
|
|
}
|
|
|
|
// TestChatInterruptWithoutBroker pins that an unconfigured server answers
|
|
// chat_interrupt with the existing "not configured" error.
|
|
func TestChatInterruptWithoutBroker(t *testing.T) {
|
|
ctx, _, conn := dialChat(t, nil)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") {
|
|
t.Fatalf("unconfigured interrupt not rejected: %+v", response)
|
|
}
|
|
}
|
|
|
|
// TestChatInterruptErrorReported pins that a broker failure is surfaced to the
|
|
// client as a protocol.Error frame carrying the echoed request id.
|
|
func TestChatInterruptErrorReported(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.interruptErr = fmt.Errorf("run is already finished")
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatInterrupt, ID: "i1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_1"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || response.ID != "i1" || !strings.Contains(response.Error, "already finished") {
|
|
t.Fatalf("interrupt failure not reported: %+v", response)
|
|
}
|
|
if _, interrupts, _ := broker.counts(); interrupts != 1 {
|
|
t.Fatalf("interrupts = %d, want 1", interrupts)
|
|
}
|
|
}
|
|
|
|
func TestChatHubAccumulatesAndEvicts(t *testing.T) {
|
|
tick := 0
|
|
hub := newChatHub()
|
|
hub.now = func() time.Time { tick++; return time.Unix(int64(tick), 0) }
|
|
for _, delta := range []string{"a", "b", "c"} {
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: delta, Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}})
|
|
}
|
|
messages := hub.snapshot("ses_1")
|
|
if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].Text != "abc" {
|
|
t.Fatalf("snapshot = %+v", messages)
|
|
}
|
|
for i := 0; i < chatMaxTurns+5; i++ {
|
|
id := fmt.Sprintf("ses_%d", i)
|
|
hub.apply(protocol.ChatEventFrame{SessionID: id, MessageID: "m", Kind: protocol.ChatEventText, Delta: "x", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: id + "#0"}})
|
|
}
|
|
if len(hub.turns) != chatMaxTurns {
|
|
t.Fatalf("retained %d turns, want %d", len(hub.turns), chatMaxTurns)
|
|
}
|
|
}
|
|
|
|
// TestChatHubKeepsMessagesSeparate pins per-message retention: a second prompt
|
|
// in one session must not fold its parts onto the first turn's message id.
|
|
func TestChatHubKeepsMessagesSeparate(t *testing.T) {
|
|
hub := newChatHub()
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventText, Delta: "one", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#0"}})
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_2", Kind: protocol.ChatEventText, Delta: "two", Part: &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_2#0"}})
|
|
messages := hub.snapshot("ses_1")
|
|
if len(messages) != 2 {
|
|
t.Fatalf("messages = %+v", messages)
|
|
}
|
|
if messages[0].ID != "msg_1" || messages[0].Parts[0].ID != "msg_1#0" || messages[0].Parts[0].Text != "one" {
|
|
t.Fatalf("first message = %+v", messages[0])
|
|
}
|
|
if messages[1].ID != "msg_2" || messages[1].Parts[0].ID != "msg_2#0" || messages[1].Parts[0].Text != "two" {
|
|
t.Fatalf("second message = %+v", messages[1])
|
|
}
|
|
}
|
|
|
|
// TestChatHubChargesToolStateBytes pins the retained-state cap: a tool part's
|
|
// input/content bytes count against it, and an upsert that would exceed the cap
|
|
// is dropped with the overflow diagnostic rather than growing memory.
|
|
func TestChatHubChargesToolStateBytes(t *testing.T) {
|
|
hub := newChatHub()
|
|
big := strings.Repeat("x", chatRetainedLimit/2)
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolStreaming, Input: json.RawMessage(`"` + big + `"`)}}})
|
|
hub.mu.Lock()
|
|
size := hub.turns["ses_1"].size
|
|
hub.mu.Unlock()
|
|
if size < len(big) {
|
|
t.Fatalf("tool input not charged: size=%d want >= %d", size, len(big))
|
|
}
|
|
huge := strings.Repeat("y", chatRetainedLimit)
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: &protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Input: json.RawMessage(`"` + huge + `"`)}}})
|
|
messages := hub.snapshot("ses_1")
|
|
if len(messages) != 1 || len(messages[0].Parts) != 1 || messages[0].Parts[0].State == nil || messages[0].Parts[0].State.Status != protocol.ChatToolStreaming {
|
|
t.Fatalf("overflowing tool state was retained: %+v", messages)
|
|
}
|
|
}
|
|
|
|
// TestChatHubRetainsToolNameAndInputAcrossLifecycle pins that a tool call keeps
|
|
// its name and its input for its whole lifecycle in the retained state a resume
|
|
// serves: the name arrives only in input.started, the arguments in input.ended's
|
|
// text or called's input, and then progress/success carry neither, so no later
|
|
// frame may blank a field the hub already learned.
|
|
func TestChatHubRetainsToolNameAndInputAcrossLifecycle(t *testing.T) {
|
|
hub := newChatHub()
|
|
apply := func(part *protocol.ChatPart) {
|
|
hub.apply(protocol.ChatEventFrame{SessionID: "ses_1", MessageID: "msg_1", Kind: protocol.ChatEventTool, Part: part})
|
|
}
|
|
// input.started: the name, no arguments yet.
|
|
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", Name: "shell", State: &protocol.ChatToolState{Status: protocol.ChatToolStreaming}})
|
|
// input.ended/called: the arguments, no name.
|
|
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolRunning, Input: json.RawMessage(`{"command":"ls"}`)}})
|
|
// progress: metadata only.
|
|
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolRunning, Metadata: map[string]any{"exit": 0}}})
|
|
// success: the output, no name and no input.
|
|
apply(&protocol.ChatPart{Type: protocol.ChatPartTool, ID: "call_1", State: &protocol.ChatToolState{Status: protocol.ChatToolCompleted, Content: []protocol.ChatToolContent{{Type: "text", Text: "ok"}}}})
|
|
|
|
messages := hub.snapshot("ses_1")
|
|
if len(messages) != 1 || len(messages[0].Parts) != 1 {
|
|
t.Fatalf("snapshot = %+v", messages)
|
|
}
|
|
part := messages[0].Parts[0]
|
|
if part.Name != "shell" {
|
|
t.Fatalf("tool name was blanked by a later frame: %+v", part)
|
|
}
|
|
if part.State == nil || part.State.Status != protocol.ChatToolCompleted {
|
|
t.Fatalf("tool state = %+v", part.State)
|
|
}
|
|
var input struct {
|
|
Command string `json:"command"`
|
|
}
|
|
if err := json.Unmarshal(part.State.Input, &input); err != nil || input.Command != "ls" {
|
|
t.Fatalf("tool input was blanked by a later frame: %s (err %v)", part.State.Input, err)
|
|
}
|
|
if len(part.State.Content) != 1 || part.State.Content[0].Text != "ok" {
|
|
t.Fatalf("tool content = %+v", part.State.Content)
|
|
}
|
|
if part.State.Metadata["exit"] == nil {
|
|
t.Fatalf("tool metadata was blanked by a later frame: %+v", part.State.Metadata)
|
|
}
|
|
}
|
|
|
|
// TestChatPromptSubscribesBeforePrompt pins the subscribe-before-prompt order:
|
|
// the firehose has no replay cursor, so the subscription must be attached before
|
|
// the prompt is posted or deltas emitted in between are lost.
|
|
func TestChatPromptSubscribesBeforePrompt(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
readChatTurn(t, ctx, conn)
|
|
broker.mu.Lock()
|
|
before := broker.promptBeforeSubscribe
|
|
broker.mu.Unlock()
|
|
if before {
|
|
t.Fatal("prompt was posted before the event subscription was attached")
|
|
}
|
|
}
|
|
|
|
// realAdapterChat posts a chat_prompt through the real opencode.Chat broker and
|
|
// HandlerWithOptions against a v2 HTTP fixture that replays frames, so the
|
|
// acceptance path forwards to an actual OpenCode-shaped stream (not a scripted
|
|
// fake) and returns the chat_event frames the server pushed. It pins exactly one
|
|
// prompt POST and one event subscription per chat_prompt, then asserts the ack
|
|
// echoes the request id; callers assert the frames themselves.
|
|
func realAdapterChat(t *testing.T, frames []string) []protocol.ChatEventFrame {
|
|
t.Helper()
|
|
var prompts, streams atomic.Int32
|
|
fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch {
|
|
case r.Method == http.MethodPost && r.URL.Path == "/api/session/ses_1/prompt":
|
|
prompts.Add(1)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"data":{"id":"msg_1","sessionID":"ses_1","type":"user"}}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/permission/request":
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"location":{"directory":"/work"},"data":[]}`))
|
|
case r.Method == http.MethodGet && r.URL.Path == "/api/event":
|
|
streams.Add(1)
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
for _, frame := range frames {
|
|
_, _ = w.Write([]byte("data: " + frame + "\n\n"))
|
|
}
|
|
default:
|
|
t.Errorf("unexpected request %s %s", r.Method, r.URL.Path)
|
|
}
|
|
}))
|
|
defer fixture.Close()
|
|
|
|
broker := opencode.NewChat(&opencode.Connection{Backend: "v2", URL: fixture.URL})
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "ping"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "r1" {
|
|
t.Fatalf("ack = %+v", ack)
|
|
}
|
|
framesIn := readChatTurn(t, ctx, conn)
|
|
if prompts.Load() != 1 || streams.Load() != 1 {
|
|
t.Fatalf("prompts=%d streams=%d, want 1/1", prompts.Load(), streams.Load())
|
|
}
|
|
return framesIn
|
|
}
|
|
|
|
// assertStableFrameIDs fails unless every frame carries the fixture's session
|
|
// and message ids: a client cannot attribute a frame without them.
|
|
func assertStableFrameIDs(t *testing.T, frames []protocol.ChatEventFrame) {
|
|
t.Helper()
|
|
for _, frame := range frames {
|
|
if frame.SessionID != "ses_1" || frame.MessageID != "msg_1" {
|
|
t.Fatalf("frame missing stable ids: %+v", frame)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatPromptThroughRealAdapter drives a text, tool and step turn end to end.
|
|
func TestChatPromptThroughRealAdapter(t *testing.T) {
|
|
framesIn := realAdapterChat(t, []string{
|
|
`{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`,
|
|
`{"id":"evt_2","type":"session.tool.called","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","id":"call_1","name":"shell","input":{"command":"ls"}}}`,
|
|
`{"id":"evt_3","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`,
|
|
})
|
|
assertStableFrameIDs(t, framesIn)
|
|
sawText, sawTool := false, false
|
|
for _, frame := range framesIn {
|
|
if frame.Kind == protocol.ChatEventText && frame.Delta == "pong" {
|
|
sawText = true
|
|
}
|
|
if frame.Kind == protocol.ChatEventTool && frame.Part != nil && frame.Part.Name == "shell" {
|
|
sawTool = true
|
|
}
|
|
}
|
|
if !sawText || !sawTool {
|
|
t.Fatalf("missing text or tool frame: %+v", framesIn)
|
|
}
|
|
}
|
|
|
|
// TestChatPromptNoToolThroughRealAdapter is the task's evidence harness: it posts
|
|
// a trivial no-tool prompt to the real opencode.Chat adapter over a v2 SSE
|
|
// fixture that emits only a text delta and a step, and asserts both arrive as
|
|
// chat_event frames with stable session/message ids. It reuses dialChat,
|
|
// readChatTurn and realAdapterChat so it pins the same ack/stream contract as the
|
|
// other chat tests, and it pins exactly one prompt POST and one event subscription.
|
|
func TestChatPromptNoToolThroughRealAdapter(t *testing.T) {
|
|
framesIn := realAdapterChat(t, []string{
|
|
`{"id":"evt_1","type":"session.text.delta","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","ordinal":0,"delta":"pong"}}`,
|
|
`{"id":"evt_2","type":"session.step.ended","data":{"sessionID":"ses_1","assistantMessageID":"msg_1","step":1}}`,
|
|
})
|
|
assertStableFrameIDs(t, framesIn)
|
|
sawText, sawStep, sawTool := false, false, false
|
|
for _, frame := range framesIn {
|
|
switch frame.Kind {
|
|
case protocol.ChatEventText:
|
|
sawText = frame.Delta == "pong"
|
|
case protocol.ChatEventStep:
|
|
sawStep = frame.Step != nil && frame.Step.Status == protocol.ChatStepEnded
|
|
case protocol.ChatEventTool:
|
|
sawTool = true
|
|
}
|
|
}
|
|
if !sawText || !sawStep {
|
|
t.Fatalf("missing text or step frame: %+v", framesIn)
|
|
}
|
|
if sawTool {
|
|
t.Fatalf("a trivial no-tool prompt produced a tool frame: %+v", framesIn)
|
|
}
|
|
}
|
|
|
|
// TestChatPromptRejectsEmptyText pins the whitespace guard: an empty or
|
|
// whitespace-only prompt is rejected before any OpenCode call.
|
|
func TestChatPromptRejectsEmptyText(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
for _, text := range []string{"", " ", "\t\n"} {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "empty", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: text}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || response.ID != "empty" {
|
|
t.Fatalf("empty text %q not rejected: %+v", text, response)
|
|
}
|
|
}
|
|
if prompts, _, _ := broker.counts(); prompts != 0 {
|
|
t.Fatalf("empty prompts reached OpenCode: %d", prompts)
|
|
}
|
|
}
|
|
|
|
// TestChatCreateRecordsOperatorSession is the chat_create acceptance test: the
|
|
// broker creates the session in the resolved directory, the handler records it in
|
|
// the operator registry with the operator tag, and the response carries the
|
|
// created session and the registry row (directory, tag). The registry can then
|
|
// list it.
|
|
func TestChatCreateRecordsOperatorSession(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.created = protocol.ChatSession{ID: "ses_new", Title: "demo"}
|
|
dir := t.TempDir()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatCreate, ID: "c1", ChatCreate: &protocol.ChatCreateRequest{Title: "demo", Directory: dir}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatCreate || response.ID != "c1" || response.ChatSession == nil {
|
|
t.Fatalf("chat_create response = %+v", response)
|
|
}
|
|
if response.ChatSession.ID != "ses_new" || response.ChatSession.Directory != dir || response.ChatSession.Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("created session = %+v", response.ChatSession)
|
|
}
|
|
if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("created session not echoed as a registry row: %+v", response.ChatSessions)
|
|
}
|
|
if calls, title, directory := broker.createQuery(); calls != 1 || title != "demo" || directory != dir {
|
|
t.Fatalf("broker.Create = %d/%q/%q, want 1/demo/%q", calls, title, directory, dir)
|
|
}
|
|
recorded, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(recorded) != 1 || recorded[0].ID != "ses_new" || recorded[0].Directory != dir || recorded[0].Tag != protocol.ChatSessionTagOperator || recorded[0].Title != "demo" {
|
|
t.Fatalf("registry row = %+v", recorded)
|
|
}
|
|
}
|
|
|
|
// TestChatCreateDirectoryResolution pins directory defaulting and rejection: an
|
|
// omitted/empty/"~"/"~/..." directory resolves to the operator's home (never the
|
|
// server's working directory), an explicit existing directory is recorded
|
|
// unchanged, and a relative or missing directory is rejected before any OpenCode
|
|
// call.
|
|
func TestChatCreateDirectoryResolution(t *testing.T) {
|
|
home, err := os.UserHomeDir()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
explicit := t.TempDir()
|
|
cases := []struct {
|
|
name string
|
|
omitted bool
|
|
directory string
|
|
wantDirectory string
|
|
wantErr string
|
|
}{
|
|
{name: "omitted", omitted: true, wantDirectory: home},
|
|
{name: "empty", directory: "", wantDirectory: home},
|
|
{name: "tilde", directory: "~", wantDirectory: home},
|
|
{name: "tilde path", directory: "~/project", wantDirectory: home},
|
|
{name: "explicit", directory: explicit, wantDirectory: explicit},
|
|
{name: "relative", directory: "relative/dir", wantErr: "absolute"},
|
|
{name: "missing", directory: filepath.Join(t.TempDir(), "missing"), wantErr: "not available"},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
request := protocol.Message{Type: protocol.ChatCreate, ID: "c1"}
|
|
if !tc.omitted {
|
|
request.ChatCreate = &protocol.ChatCreateRequest{Title: "demo", Directory: tc.directory}
|
|
}
|
|
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 tc.wantErr != "" {
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, tc.wantErr) {
|
|
t.Fatalf("directory %q not rejected: %+v", tc.directory, response)
|
|
}
|
|
if calls, _, _ := broker.createQuery(); calls != 0 {
|
|
t.Fatalf("rejected directory still reached OpenCode: %d calls", calls)
|
|
}
|
|
if recorded, err := store.OperatorSessions(ctx); err != nil || len(recorded) != 0 {
|
|
t.Fatalf("rejected directory recorded a session: %+v %v", recorded, err)
|
|
}
|
|
return
|
|
}
|
|
if response.Type != protocol.ChatCreate || response.ChatSession == nil || response.ChatSession.Directory != tc.wantDirectory {
|
|
t.Fatalf("directory %q resolved wrong: %+v", tc.directory, response)
|
|
}
|
|
if calls, _, directory := broker.createQuery(); calls != 1 || directory != tc.wantDirectory {
|
|
t.Fatalf("broker.Create = %d/%q, want 1/%q", calls, directory, tc.wantDirectory)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestChatDirectoriesHomeThenBoundedRecents pins chat_directories: the operator's
|
|
// home first, then the directories of previous operator sessions
|
|
// most-recently-used first, deduplicated and capped at the fixed bound even with
|
|
// more directory history seeded than the cap.
|
|
func TestChatDirectoriesHomeThenBoundedRecents(t *testing.T) {
|
|
home, err := os.UserHomeDir()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
store := newOperatorStore(t)
|
|
ctx, _, conn := dialChatOptions(t, Options{OperatorRegistry: store})
|
|
// Seed more directories than the bound, oldest first.
|
|
seeded := make([]string, 0, operatorDirectoryLimit+4)
|
|
for i := 0; i < operatorDirectoryLimit+4; i++ {
|
|
directory := filepath.Join(t.TempDir(), fmt.Sprintf("d%02d", i))
|
|
seeded = append(seeded, directory)
|
|
if err := store.RecordOperatorSession(ctx, fmt.Sprintf("ses_%02d", i), directory, "s", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(2 * time.Millisecond)
|
|
}
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatDirectories, ID: "d1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatDirectories || response.ID != "d1" {
|
|
t.Fatalf("chat_directories response = %+v", response)
|
|
}
|
|
if len(response.ChatDirectories) != operatorDirectoryLimit {
|
|
t.Fatalf("directories = %+v, want the bound of %d", response.ChatDirectories, operatorDirectoryLimit)
|
|
}
|
|
if response.ChatDirectories[0] != home {
|
|
t.Fatalf("home not first: %+v", response.ChatDirectories)
|
|
}
|
|
// The remainder are the most recently recorded directories, MRU first.
|
|
for i := 1; i < len(response.ChatDirectories); i++ {
|
|
want := seeded[len(seeded)-i]
|
|
if response.ChatDirectories[i] != want {
|
|
t.Fatalf("directory %d = %q, want %q (MRU order): %+v", i, response.ChatDirectories[i], want, response.ChatDirectories)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsListsOperatorSessionsOnly is the task evidence for the
|
|
// operator-session filter: the broker lists an operator-registered session, a
|
|
// genuine pipeline stage session recorded in run_steps/run_session_owners, and a
|
|
// foreign session; chat_sessions returns exactly the operator session, carrying
|
|
// its registry directory and operator tag, and asks the broker once. The stage
|
|
// session is proven to be genuinely recorded through store.OwnedSessions.
|
|
func TestChatSessionsListsOperatorSessionsOnly(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
if err := store.RecordOperatorSession(ctx, "ses_op", "/work/op", "Operator chat", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := store.Submit(ctx, "chatsrv", pipeline.Template([]string{"one"}, true)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, err := store.List(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
definition, err := store.Get(ctx, items[0].ID, 1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
run, _, err := store.CreateRun(ctx, definition, "stage-run", "/work/stage", false, nil, map[string]any{"prompt": "task"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.BeginStep(ctx, run, 1, "one", map[string]any{"prompt": "task"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := store.RunSession(ctx, run, 1, "ses_stage", true, "v2", "/work/stage"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// Prove ses_stage is a real owned pipeline session, so its exclusion is the
|
|
// operator filter at work, not an unrecorded id.
|
|
owned, err := store.OwnedSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sawStage := false
|
|
for _, owner := range owned {
|
|
if owner.ID == "ses_stage" {
|
|
sawStage = true
|
|
}
|
|
if owner.ID == "ses_op" {
|
|
t.Fatalf("operator session leaked into pipeline ownership: %+v", owner)
|
|
}
|
|
}
|
|
if !sawStage {
|
|
t.Fatalf("stage session was not recorded in run_steps: %+v", owned)
|
|
}
|
|
|
|
broker := scriptedChat()
|
|
broker.sessions = []protocol.ChatSession{
|
|
{ID: "ses_op", Title: "upstream", Directory: "/upstream"},
|
|
{ID: "ses_stage", Title: "pipeline internal", Directory: "/work/stage"},
|
|
{ID: "ses_foreign", Title: "someone else's", Directory: "/elsewhere"},
|
|
}
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatSessions || response.ID != "s1" {
|
|
t.Fatalf("chat_sessions response = %+v", response)
|
|
}
|
|
if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_op" {
|
|
t.Fatalf("non-operator session leaked into the list: %+v", response.ChatSessions)
|
|
}
|
|
got := response.ChatSessions[0]
|
|
if got.Directory != "/work/op" || got.Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("operator session shape = %+v", got)
|
|
}
|
|
if got.Busy {
|
|
t.Fatalf("inactive operator session marked busy: %+v", got)
|
|
}
|
|
if calls := broker.sessionQuery(); calls != 1 {
|
|
t.Fatalf("broker.Sessions called %d times, want 1", calls)
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsNeverListsUntagged pins that a row with no recorded tag is not
|
|
// an operator session and is never listed, even when the broker still reports it.
|
|
func TestChatSessionsNeverListsUntagged(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
if err := store.RecordOperatorSession(ctx, "ses_untagged", "/work/untagged", "no tag", ""); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
broker := scriptedChat()
|
|
broker.sessions = []protocol.ChatSession{{ID: "ses_untagged"}}
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 {
|
|
t.Fatalf("untagged session was listed: %+v", response)
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsMostRecentlyUsedFirst pins the list order: sessions come back
|
|
// most-recently-used first by registry recency (later creation wins), with the
|
|
// directory and tag from the registry.
|
|
func TestChatSessionsMostRecentlyUsedFirst(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
if err := store.RecordOperatorSession(ctx, "ses_old", "/work/old", "old", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(3 * time.Millisecond)
|
|
if err := store.RecordOperatorSession(ctx, "ses_new", "/work/new", "new", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
broker := scriptedChat()
|
|
// The broker lists them oldest-updated-first, so the handler's registry order
|
|
// is what decides the result.
|
|
broker.sessions = []protocol.ChatSession{
|
|
{ID: "ses_old", UpdatedAt: 100},
|
|
{ID: "ses_new", UpdatedAt: 50},
|
|
}
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(response.ChatSessions) != 2 {
|
|
t.Fatalf("chat_sessions = %+v, want 2", response.ChatSessions)
|
|
}
|
|
if response.ChatSessions[0].ID != "ses_new" || response.ChatSessions[1].ID != "ses_old" {
|
|
t.Fatalf("not most-recently-used first: %+v", response.ChatSessions)
|
|
}
|
|
if response.ChatSessions[0].Directory != "/work/new" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("registry fields not applied: %+v", response.ChatSessions[0])
|
|
}
|
|
}
|
|
|
|
// TestChatSessionsFailsClosedWithoutOwnership pins the default when no operator
|
|
// registry (store or injection) is available: chat_sessions returns an empty list
|
|
// without consulting the broker, never the full OpenCode machine.
|
|
func TestChatSessionsFailsClosedWithoutOwnership(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.sessions = []protocol.ChatSession{{ID: "ses_1"}, {ID: "ses_2"}}
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatSessions || len(response.ChatSessions) != 0 {
|
|
t.Fatalf("unregistered sessions were exposed: %+v", response)
|
|
}
|
|
if calls := broker.sessionQuery(); calls != 0 {
|
|
t.Fatalf("fail-closed list consulted the broker %d times, want 0", calls)
|
|
}
|
|
}
|
|
|
|
// TestChatPromptPushesPermissionAndForwardsReply is the task evidence: with a
|
|
// blocking scripted stream keeping the subscription open, a seeded pending
|
|
// approval request is pushed as a chat_permission frame carrying the seeded
|
|
// session/request id after the prompt ack, and a chat_reply with Decision "once"
|
|
// is forwarded to the broker with the matching SessionID/RequestID/Decision.
|
|
//
|
|
// The live end-to-end approval flow against the real OpenCode service is NOT
|
|
// tested: this broker is the same interface seam the production handler uses, and
|
|
// the adapter's exact reply path/body are covered by the opencode package tests
|
|
// over an httptest fixture.
|
|
func TestChatPromptPushesPermissionAndForwardsReply(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.permissions = []protocol.ChatPermissionFrame{{
|
|
SessionID: "ses_1", RequestID: "req_1", Action: "bash", Resources: []string{"rm -rf /tmp"},
|
|
}}
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "run it"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "r1" {
|
|
t.Fatalf("prompt ack = %+v", ack)
|
|
}
|
|
var permission protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &permission); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if permission.Type == protocol.Error {
|
|
t.Fatalf("unexpected error frame: %s", permission.Error)
|
|
}
|
|
if permission.Type != protocol.ChatPermission || permission.ChatPermission == nil {
|
|
t.Fatalf("expected a chat_permission frame, got %+v", permission)
|
|
}
|
|
if permission.ChatPermission.SessionID != "ses_1" || permission.ChatPermission.RequestID != "req_1" || permission.ChatPermission.Action != "bash" {
|
|
t.Fatalf("permission frame = %+v", permission.ChatPermission)
|
|
}
|
|
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatReply || response.ID != "p1" {
|
|
t.Fatalf("reply response = %+v", response)
|
|
}
|
|
count, forwarded := broker.replyQuery()
|
|
if count != 1 {
|
|
t.Fatalf("reply forwarded %d times, want 1", count)
|
|
}
|
|
if forwarded.SessionID != "ses_1" || forwarded.RequestID != "req_1" || forwarded.Decision != protocol.ChatDecisionOnce {
|
|
t.Fatalf("forwarded reply = %+v", forwarded)
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionDedupesRepeatedPolls pins that the poller pushes each
|
|
// pending request at most once even though it re-reads the same list, and that a
|
|
// foreign session's request is never surfaced.
|
|
func TestChatPermissionDedupesRepeatedPolls(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.permissions = []protocol.ChatPermissionFrame{
|
|
{SessionID: "ses_1", RequestID: "req_1", Action: "bash"},
|
|
{SessionID: "ses_other", RequestID: "req_x", Action: "edit"},
|
|
}
|
|
hub := newChatHub()
|
|
var mu sync.Mutex
|
|
var pushed []protocol.Message
|
|
write := func(message protocol.Message) error {
|
|
mu.Lock()
|
|
pushed = append(pushed, message)
|
|
mu.Unlock()
|
|
return nil
|
|
}
|
|
if sub := hub.attach("ses_1", "c1", "phone", broker, write); sub == nil {
|
|
t.Fatal("attach returned nil")
|
|
}
|
|
for i := 0; i < 3; i++ {
|
|
if err := hub.pollPermissionsOnce(context.Background(), broker, "ses_1"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for {
|
|
mu.Lock()
|
|
count := len(pushed)
|
|
mu.Unlock()
|
|
if count > 0 {
|
|
break
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("no permission frame was pushed")
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
// Give a duplicate a chance to arrive before asserting there is none.
|
|
time.Sleep(50 * time.Millisecond)
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
if len(pushed) != 1 {
|
|
t.Fatalf("pushed %d permission frames, want 1: %+v", len(pushed), pushed)
|
|
}
|
|
if pushed[0].Type != protocol.ChatPermission || pushed[0].ChatPermission == nil || pushed[0].ChatPermission.RequestID != "req_1" {
|
|
t.Fatalf("pushed frame = %+v", pushed[0])
|
|
}
|
|
if calls, sessionID := broker.permissionQuery(); calls != 3 || sessionID != "ses_1" {
|
|
t.Fatalf("permission polls = %d/%q, want 3/ses_1", calls, sessionID)
|
|
}
|
|
}
|
|
|
|
// TestChatDisconnectCancelsPermissionPoller pins that the permission poller is
|
|
// canceled on disconnect (reusing the stream's context), so it cannot leak a
|
|
// goroutine after the client goes away.
|
|
func TestChatDisconnectCancelsPermissionPoller(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.done = make(chan struct{})
|
|
broker.permBlock = true
|
|
broker.permDone = make(chan struct{})
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
select {
|
|
case <-broker.started:
|
|
case <-time.After(2 * time.Second):
|
|
t.Fatal("stream never started")
|
|
}
|
|
select {
|
|
case <-broker.permDone:
|
|
t.Fatal("permission poller returned before disconnect")
|
|
default:
|
|
}
|
|
conn.CloseNow()
|
|
select {
|
|
case <-broker.permDone:
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("permission poller was not canceled on disconnect")
|
|
}
|
|
select {
|
|
case <-broker.done:
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("chat stream was not canceled on disconnect")
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionPollErrorSurfaced pins that a malformed permission list is
|
|
// reported to the client as an error frame rather than silence.
|
|
func TestChatPermissionPollErrorSurfaced(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.permissionErr = fmt.Errorf("invalid OpenCode permission response")
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "permission poll") {
|
|
t.Fatalf("malformed permission list not surfaced: %+v", response)
|
|
}
|
|
}
|
|
|
|
// TestChatReplyRejectsInvalidInput pins that a missing session id, an empty
|
|
// request id and an invalid decision are rejected with a protocol.Error before
|
|
// any broker call.
|
|
func TestChatReplyRejectsInvalidInput(t *testing.T) {
|
|
broker := scriptedChat()
|
|
ctx, _, conn := dialChat(t, broker)
|
|
cases := []*protocol.ChatReplyRequest{
|
|
nil,
|
|
{SessionID: "", RequestID: "req_1", Decision: protocol.ChatDecisionOnce},
|
|
{SessionID: "not-a-session", RequestID: "req_1", Decision: protocol.ChatDecisionOnce},
|
|
{SessionID: "ses_1", RequestID: "", Decision: protocol.ChatDecisionOnce},
|
|
{SessionID: "ses_1", RequestID: "req_1", Decision: ""},
|
|
{SessionID: "ses_1", RequestID: "req_1", Decision: "maybe"},
|
|
}
|
|
for _, reply := range cases {
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "bad", ChatReply: reply}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || response.ID != "bad" {
|
|
t.Fatalf("reply %+v not rejected: %+v", reply, response)
|
|
}
|
|
}
|
|
if count, _ := broker.replyQuery(); count != 0 {
|
|
t.Fatalf("invalid replies reached the broker: %d", count)
|
|
}
|
|
}
|
|
|
|
// TestChatReplyWithoutBroker pins that an unconfigured server answers chat_reply
|
|
// with the existing "not configured" error.
|
|
func TestChatReplyWithoutBroker(t *testing.T) {
|
|
ctx, _, conn := dialChat(t, nil)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatReply, ID: "p1", ChatReply: &protocol.ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: protocol.ChatDecisionOnce}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "not configured") {
|
|
t.Fatalf("unconfigured reply not rejected: %+v", response)
|
|
}
|
|
}
|
|
|
|
// TestChatPermissionUnsupportedBackendIsQuiet pins that a backend which does not
|
|
// expose the approval surface (the documented native v1 limitation, reported as
|
|
// opencode.ErrPermissionUnsupported) stops the poller without writing a
|
|
// per-prompt error frame, so a working prompt is not misread as a failure.
|
|
func TestChatPermissionUnsupportedBackendIsQuiet(t *testing.T) {
|
|
broker := scriptedChat()
|
|
broker.block = true
|
|
broker.started = make(chan struct{})
|
|
broker.permissionErr = opencode.ErrPermissionUnsupported
|
|
ctx, _, conn := dialChat(t, broker)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "r1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_1", Text: "hi"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "r1" {
|
|
t.Fatalf("prompt ack = %+v", ack)
|
|
}
|
|
// No error frame may follow: a read with a short deadline must time out.
|
|
readCtx, cancel := context.WithTimeout(ctx, 300*time.Millisecond)
|
|
defer cancel()
|
|
var unexpected protocol.Message
|
|
if err := wsjson.Read(readCtx, conn, &unexpected); err == nil {
|
|
t.Fatalf("unsupported permission surface must not write a frame, got %+v", unexpected)
|
|
}
|
|
if calls, _ := broker.permissionQuery(); calls != 1 {
|
|
t.Fatalf("permission polls = %d, want 1 (the poller must stop on the documented limitation)", calls)
|
|
}
|
|
}
|
|
|
|
// TestChatAdoptRecordsEndpointSession is the chat_adopt acceptance test: the
|
|
// endpoint's own record supplies the directory and title, the handler records
|
|
// the row with the operator tag, and the response echoes the session and its
|
|
// registry row so the client can splice it into chat_sessions without a re-list.
|
|
func TestChatAdoptRecordsEndpointSession(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.sessionFound = true
|
|
broker.sessionRecord = protocol.ChatSession{ID: "ses_existing", Title: "my own work", Directory: "/work/existing"}
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "ses_existing"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.ChatAdopt || response.ID != "a1" || response.ChatSession == nil {
|
|
t.Fatalf("chat_adopt response = %+v", response)
|
|
}
|
|
if response.ChatSession.ID != "ses_existing" || response.ChatSession.Directory != "/work/existing" || response.ChatSession.Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("adopted session = %+v", response.ChatSession)
|
|
}
|
|
if len(response.ChatSessions) != 1 || response.ChatSessions[0].ID != "ses_existing" || response.ChatSessions[0].Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("adopted session not echoed as a registry row: %+v", response.ChatSessions)
|
|
}
|
|
if calls, id := broker.sessionByIDQuery(); calls != 1 || id != "ses_existing" {
|
|
t.Fatalf("broker.Session = %d/%q, want 1/ses_existing", calls, id)
|
|
}
|
|
recorded, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(recorded) != 1 || recorded[0].ID != "ses_existing" || recorded[0].Directory != "/work/existing" || recorded[0].Title != "my own work" || recorded[0].Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("registry row = %+v", recorded)
|
|
}
|
|
// chat_sessions now lists the adopted session (the endpoint still reports it),
|
|
// carrying the registry directory and operator tag.
|
|
broker.mu.Lock()
|
|
broker.sessions = []protocol.ChatSession{{ID: "ses_existing", Title: "endpoint title", Directory: "/endpoint/elsewhere"}}
|
|
broker.mu.Unlock()
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatSessions, ID: "s1"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var listed protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &listed); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if listed.Type != protocol.ChatSessions || len(listed.ChatSessions) != 1 || listed.ChatSessions[0].ID != "ses_existing" || listed.ChatSessions[0].Directory != "/work/existing" || listed.ChatSessions[0].Tag != protocol.ChatSessionTagOperator {
|
|
t.Fatalf("chat_sessions did not list the adopted session with its registry directory: %+v", listed.ChatSessions)
|
|
}
|
|
// chat_prompt can continue the adopted session: TouchOperatorSession updates
|
|
// the recorded row, so it moves to the front of the list.
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatPrompt, ID: "p1", ChatPrompt: &protocol.ChatPromptRequest{SessionID: "ses_existing", Text: "continue"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var ack protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &ack); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if ack.Type != protocol.ChatPrompt || ack.ID != "p1" {
|
|
t.Fatalf("adopted session prompt ack = %+v", ack)
|
|
}
|
|
}
|
|
|
|
// TestChatAdoptMissingIDRecordsNothing pins that an id the endpoint does not
|
|
// report is refused naming the id and leaves the registry unchanged.
|
|
func TestChatAdoptMissingIDRecordsNothing(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
// Seed one unrelated operator row so the "unchanged" claim compares the
|
|
// stored rows before and after, not merely an empty registry.
|
|
if err := store.RecordOperatorSession(ctx, "ses_other", "/work/other", "other", protocol.ChatSessionTagOperator); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
broker := scriptedChat()
|
|
broker.sessionFound = false
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "ses_missing"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "ses_missing") {
|
|
t.Fatalf("missing id not refused naming the id: %+v", response)
|
|
}
|
|
after, err := store.OperatorSessions(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(before) != 1 || len(after) != 1 || after[0].ID != before[0].ID {
|
|
t.Fatalf("missing id changed the registry: before %+v after %+v", before, after)
|
|
}
|
|
}
|
|
|
|
// TestChatAdoptRefusesEmptyDirectory pins the no-guessing rule: an endpoint
|
|
// record with an empty directory is refused and records nothing, never falling
|
|
// back to the server's working directory or the operator home.
|
|
func TestChatAdoptRefusesEmptyDirectory(t *testing.T) {
|
|
ctx := context.Background()
|
|
store := newOperatorStore(t)
|
|
broker := scriptedChat()
|
|
broker.sessionFound = true
|
|
broker.sessionRecord = protocol.ChatSession{ID: "ses_nodir"}
|
|
_, _, conn := dialChatOptions(t, Options{Chat: broker, OperatorRegistry: store})
|
|
if err := wsjson.Write(ctx, conn, protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "ses_nodir"}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error || !strings.Contains(response.Error, "directory") {
|
|
t.Fatalf("empty directory not refused: %+v", response)
|
|
}
|
|
if recorded, err := store.OperatorSessions(ctx); err != nil || len(recorded) != 0 {
|
|
t.Fatalf("empty directory recorded a session: %+v %v", recorded, err)
|
|
}
|
|
}
|
|
|
|
// TestChatAdoptRejectsInvalidInputBeforeBroker pins that a nil payload, a blank
|
|
// or foreign-shaped id, a nil registry and a nil broker are each refused before
|
|
// any endpoint call.
|
|
func TestChatAdoptRejectsInvalidInputBeforeBroker(t *testing.T) {
|
|
ctx := context.Background()
|
|
cases := []struct {
|
|
name string
|
|
request protocol.Message
|
|
options Options
|
|
wantCall int
|
|
}{
|
|
{name: "nil payload", request: protocol.Message{Type: protocol.ChatAdopt, ID: "a1"}, options: Options{Chat: scriptedChat(), OperatorRegistry: newOperatorStore(t)}, wantCall: 0},
|
|
{name: "blank id", request: protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: " "}}, options: Options{Chat: scriptedChat(), OperatorRegistry: newOperatorStore(t)}, wantCall: 0},
|
|
{name: "foreign id", request: protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "not-a-session"}}, options: Options{Chat: scriptedChat(), OperatorRegistry: newOperatorStore(t)}, wantCall: 0},
|
|
{name: "nil broker", request: protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "ses_1"}}, options: Options{OperatorRegistry: newOperatorStore(t)}, wantCall: 0},
|
|
{name: "nil registry", request: protocol.Message{Type: protocol.ChatAdopt, ID: "a1", ChatAdopt: &protocol.ChatAdoptRequest{SessionID: "ses_1"}}, options: Options{Chat: scriptedChat()}, wantCall: 0},
|
|
}
|
|
for _, tc := range cases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
broker, _ := tc.options.Chat.(*fakeChat)
|
|
_, _, conn := dialChatOptions(t, tc.options)
|
|
if err := wsjson.Write(ctx, conn, protocol.Message(tc.request)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var response protocol.Message
|
|
if err := wsjson.Read(ctx, conn, &response); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.Type != protocol.Error {
|
|
t.Fatalf("%s not refused: %+v", tc.name, response)
|
|
}
|
|
if broker != nil {
|
|
if calls, _ := broker.sessionByIDQuery(); calls != tc.wantCall {
|
|
t.Fatalf("%s reached the endpoint %d times, want %d", tc.name, calls, tc.wantCall)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|