6cb61578de
A session was owned by one connection: the claim map in chat_claims.go let the
first client hold it, every other client saw the session Busy and read-only, and
a second client's prompt was rejected. Replace the claim with a per-session
"room" so the operator's phone, tablet and terminal all watch and write the same
conversation, and a pending approval is a shared, exactly-once object.
Server (internal/server, internal/protocol):
- New chat_room.go: one room per session holding the session's single broker
stream, its one bounded prompt queue (8) and the fan-out to every attached
client. A chat_subscribe frame attaches a connection to a session's shared
stream and replays the still-unresolved approval requests the room holds.
- chat_stream.go: handleChatPrompt accepts a prompt from any client. It attaches
the sender, either starts a turn or queues the prompt behind the in-flight turn
and acknowledges it with chat_queued:true ("queued" is the chosen behaviour,
stated on the wire and in docs/cli.md), and echoes the user turn to every other
client attributed to the sender's label. The prompt handler no longer owns the
stream; one turn runner per room drains the queue, so two turns never
interleave. Per-connection write serialisation is unchanged (each chatSub has
its own writer goroutine and bounded buffer).
- chat_permissions.go / chat_commands.go: an approval is reserved by the first
answer and confirmed once delivered; the first answer wins, is recorded with
the answering client's label, and the resolution is pushed to every watching
client as chat_permission with resolved/decision/resolved_by so their cards
clear. A later answer is refused with an error naming the client that answered,
and never reaches the agent twice; a reservation whose reply failed is
released.
- chat_hub.go / chat_sessions.go / chat.go: the hub now owns rooms and the
user-turn id sequence; the resulting user turns are retained (role and client
carried) so a reconnect re-syncs who said what. chat_sessions no longer marks a
session Busy and its clientID parameter is gone; the protocol keeps the Busy
field for wire compatibility only. websocket.go detaches a connection's chat
subscriptions when the read loop ends.
- chat_claims.go is removed, not left vestigial: the only exclusive thing left is
a turn, and the room's queue is that.
App (android):
- PipelinesRepository carries a stable per-device client label (Build.MODEL, with
a fallback) on prompts and replies, and adds chatSubscribe; AppViewModel
subscribes on opening a chat (best-effort, an older server's error frame does
not stop history loading) and records the queued ack.
- ChatStore folds a user frame from another client into the transcript once,
attributed by the sender's label, and never receives its own prompt back, so
the sender's own message is never duplicated. ChatThread.readOnly is gone:
canSend no longer depends on another client, the composer says "Queued - it
will send when the current turn finishes." instead of disabling input, and the
status label is Running/Idle only. Scroll/follow behaviour is untouched.
- Tests: ChatProtocolTest round-trips the new wire fields, ChatFormatTest asserts
the stale Busy flag cannot produce a read-only label, MultiChatStateTest asserts
a session another client watches stays writable.
Reflected where it belongs: no packaged template changes (no bundled starter
embeds the chat protocol). Checked the packaged authoring skill references: none
of them describes the chat wire beyond operations.md, and
internal/author/skill/references/operations.md is now stale - its "Brokered
OpenCode chat" section still says chat_sessions marks "busy" when another client
holds the session and that a second client's chat_prompt is rejected, and it does
not mention chat_subscribe, the per-session prompt queue/chat_queued, the
per-client label or the shared exactly-once approval (it also still describes the
per-subscription permission poller, which the room's single poller replaced). The
supported semantics are the ones in docs/cli.md, updated in this commit; the
operations.md section needs a rewrite to match. No README or other shared
document was edited here.
Checks run on the committed tree: gofmt -l internal cmd examples (nothing), go
build ./..., go vet ./internal/... ./cmd/..., go test ./internal/server
./internal/protocol ./internal/stage ./internal/pipeline.
1797 lines
71 KiB
Go
1797 lines
71 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: "msg_1#0"}, nil),
|
|
chatFrame(protocol.ChatEventText, "world", &protocol.ChatPart{Type: protocol.ChatPartText, ID: "msg_1#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 != "msg_1#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)
|
|
}
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|