Files
pipelines/internal/protocol/chat_test.go
T
alan f85c172dc2 Merge main into chat-close: combine the shared chat room with the server-side close
The item adds chat_close/chat_reopen to the brokered chat protocol and the
operator-session registry's closed state. main replaced the per-session claim
model with shared chat rooms (chat_subscribe, a prompt queue, one broker stream
fanned out to every watcher). This merges the two.

Resolved conflicts:
- internal/protocol/chat.go, internal/protocol/message.go: kept both additions -
  ChatClose/ChatReopen and main's ChatSubscribe/ChatQueued.
- internal/server/chat_sessions.go: kept the closed fields on a listed session;
  dropped the `Busy` assignment, because main no longer marks a session Busy (any
  number of clients may watch and write one).
- internal/server/chat_claims.go: main deleted the claim model, so the file goes;
  close's "is a turn running" check is now `chatHub.turnInFlight` in
  internal/server/chat_room.go, reading the room's `running` flag. That is the
  same question the old claim answered, against main's model.
- internal/server/chat_close.go: calls turnInFlight instead of the removed
  `active`.
- android AppViewModel.kt, ChatFormat.kt, ChatListPane.kt, Message.kt: kept both
  sides - main's search state, queued-prompt handling, `Busy`-free status label
  and row/menu shape, plus the item's close/reopen actions, closed chip and
  section, close confirmation and "Hide on this device" rename.

Also in this merge: main's new convention (AGENTS.md) that an item does not edit
a shared document; the item's stale-document record for this change lives in
docs/notes/chat-close.md, and docs/cli.md, android/README.md and
internal/author/skill/references/operations.md are left to the docs-fold writer.

Checks after resolving: gofmt clean, go build ./... and go vet ./... clean, the
Go module passes, and the app's :app:assembleDebug and :app:testDebugUnitTest
pass (--offline --no-daemon).
2026-10-18 00:19:23 +01:00

236 lines
10 KiB
Go

package protocol
import (
"encoding/json"
"reflect"
"strings"
"testing"
)
// chatSamples covers every new chat type with a populated value, plus a text and
// a tool chat_event, so a round-trip loss in any field fails the test.
func chatSamples() []struct {
name string
value any
} {
return []struct {
name string
value any
}{
{"session", ChatSession{
ID: "ses_1", Title: "demo", Agent: "build", Model: "deepseek-v4.1-flash",
Directory: "/work", ParentID: "ses_0", Tag: ChatSessionTagOperator, CreatedAt: 1792112366711, UpdatedAt: 1792112367999,
}},
{"session_busy", ChatSession{ID: "ses_2", Title: "held", Busy: true}},
{"session_closed", ChatSession{ID: "ses_3", Title: "done", Closed: true, ClosedAt: 1792112367999}},
{"close_result", ChatCloseResult{SessionID: "ses_3", ClosedAt: 1792112367999, Interrupted: true}},
{"create", ChatCreateRequest{Title: "demo", Directory: "/work"}},
{"adopt", ChatAdoptRequest{SessionID: "ses_1"}},
{"query", ChatQuery{SessionID: "ses_1", Limit: 50}},
{"prompt", ChatPromptRequest{SessionID: "ses_1", Text: "hello", Model: "m", Agent: "build", Files: []string{"file:///tmp/a.png"}, Client: "Pixel 9 Pro XL"}},
{"prompt_queued_ack", Message{Type: ChatPrompt, ID: "a1", ChatQueued: true}},
{"subscribe", ChatQuery{SessionID: "ses_1"}},
{"event_user", ChatEventFrame{
SessionID: "ses_1", MessageID: "usr_1", Kind: ChatEventUser, Client: "Pixel 10 Pro Fold",
Part: &ChatPart{Type: ChatPartText, ID: "usr", Text: "from the fold"},
}},
{"message", ChatMessage{
ID: "msg_1", SessionID: "ses_1", Role: ChatRoleAssistant, Model: "m", Agent: "build", CreatedAt: 1792112366711,
Parts: []ChatPart{
{Type: ChatPartText, ID: "p1", Text: "done"},
{Type: ChatPartReasoning, ID: "p2", Text: "thinking"},
{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{
Status: ChatToolCompleted,
Input: json.RawMessage(`{"command":"ls"}`),
Content: []ChatToolContent{{Type: "text", Text: "app-debug.apk"}, {Type: "file", URI: "file:///tmp/x.png", Mime: "image/png", Name: "x.png"}},
Metadata: map[string]any{"exit": "0"},
},
Time: &ChatTime{Created: 1, Ran: 2, Completed: 3},
},
{Type: ChatPartTool, ID: "call_2", Name: "edit",
State: &ChatToolState{Status: ChatToolError, Input: json.RawMessage(`{}`), Error: &ChatError{Type: "tool", Message: "boom"}},
},
},
}},
{"event_text", ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventText, Delta: "hel",
Part: &ChatPart{Type: ChatPartText, ID: "p1"},
}},
{"event_tool", ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{Status: ChatToolRunning, Input: json.RawMessage(`{"command":"ls"}`)},
},
}},
{"event_step", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventStep, Step: &ChatStep{Status: ChatStepEnded, Index: 2}}},
{"event_usage", ChatEventFrame{SessionID: "ses_1", Kind: ChatEventUsage, Usage: &ChatUsage{InputTokens: 12, OutputTokens: 34, Cost: 0.001}}},
{"permission", ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"}, Save: []string{"bash:rm -rf /tmp"},
Metadata: map[string]any{"command": "rm -rf /tmp"},
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
Message: "wants to run a command",
}},
{"permission_resolved", ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resolved: true, Decision: ChatDecisionOnce, ResolvedBy: "Pixel 9 Pro XL",
}},
{"reply", ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionOnce, Message: "ok", Client: "Pixel 9 Pro XL"}},
}
}
func TestChatTypesGoldenRoundTrip(t *testing.T) {
for _, sample := range chatSamples() {
encoded, err := json.Marshal(sample.value)
if err != nil {
t.Fatalf("%s: marshal: %v", sample.name, err)
}
target := reflect.New(reflect.TypeOf(sample.value))
if err := json.Unmarshal(encoded, target.Interface()); err != nil {
t.Fatalf("%s: unmarshal: %v", sample.name, err)
}
decoded := target.Elem().Interface()
if !reflect.DeepEqual(decoded, sample.value) {
t.Fatalf("%s: fields lost\n got %+v\nwant %+v", sample.name, decoded, sample.value)
}
again, err := json.Marshal(decoded)
if err != nil {
t.Fatalf("%s: re-marshal: %v", sample.name, err)
}
if string(again) != string(encoded) {
t.Fatalf("%s: wire shape not stable\n got %s\nwant %s", sample.name, again, encoded)
}
}
}
// TestChatEventGoldenJSON pins the exact wire shape of a pushed frame so a JSON
// tag change cannot silently alter what the phone parses.
func TestChatEventGoldenJSON(t *testing.T) {
event := ChatEventFrame{
SessionID: "ses_1", MessageID: "msg_1", Kind: ChatEventTool,
Part: &ChatPart{Type: ChatPartTool, ID: "call_1", Name: "shell", Executed: true,
State: &ChatToolState{
Status: ChatToolStreaming,
Input: json.RawMessage(`"{\"command\":\"ls\""`),
Content: nil,
},
Time: &ChatTime{Created: 10, Ran: 11, Completed: 12},
},
}
encoded, err := json.Marshal(event)
if err != nil {
t.Fatal(err)
}
want := `{"session_id":"ses_1","message_id":"msg_1","kind":"tool","part":{"type":"tool","id":"call_1","name":"shell","executed":true,"state":{"status":"streaming","input":"{\"command\":\"ls\""},"time":{"created":10,"ran":11,"completed":12}}}`
if string(encoded) != want {
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
}
var decoded ChatEventFrame
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(decoded, event) {
t.Fatalf("golden did not decode back: %+v", decoded)
}
}
// TestChatPermissionGoldenJSON pins the exact wire shape of the pushed
// chat_permission frame so a JSON tag change cannot silently alter what the
// phone parses.
func TestChatPermissionGoldenJSON(t *testing.T) {
frame := ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash",
Resources: []string{"rm -rf /tmp"},
Source: &ChatPermissionSource{Type: "tool", MessageID: "msg_1", ID: "call_1"},
}
encoded, err := json.Marshal(frame)
if err != nil {
t.Fatal(err)
}
want := `{"session_id":"ses_1","request_id":"per_1","action":"bash","resources":["rm -rf /tmp"],"source":{"type":"tool","message_id":"msg_1","id":"call_1"}}`
if string(encoded) != want {
t.Fatalf("golden mismatch\n got %s\nwant %s", encoded, want)
}
var decoded ChatPermissionFrame
if err := json.Unmarshal([]byte(want), &decoded); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(decoded, frame) {
t.Fatalf("golden did not decode back: %+v", decoded)
}
}
func TestChatEnvelopeRoundTrip(t *testing.T) {
session := ChatSession{ID: "ses_1", Title: "demo"}
message := Message{
Type: ChatSessions, ID: "r1",
ChatSessions: []ChatSession{session},
ChatSession: &session,
ChatCreate: &ChatCreateRequest{Title: "new"},
ChatAdopt: &ChatAdoptRequest{SessionID: "ses_1"},
ChatQuery: &ChatQuery{SessionID: "ses_1", Limit: 10},
ChatPrompt: &ChatPromptRequest{SessionID: "ses_1", Text: "hi"},
ChatMessages: []ChatMessage{{ID: "msg_1", SessionID: "ses_1", Role: ChatRoleUser, Parts: []ChatPart{{Type: ChatPartText, Text: "hi"}}}},
ChatEvent: &ChatEventFrame{SessionID: "ses_1", Kind: ChatEventText, Delta: "hi"},
ChatPermission: &ChatPermissionFrame{
SessionID: "ses_1", RequestID: "per_1", Action: "bash", Resources: []string{"rm -rf /"},
},
ChatReply: &ChatReplyRequest{SessionID: "ses_1", RequestID: "req_1", Decision: ChatDecisionReject},
ChatDirectories: []string{"/home/operator", "/work/project"},
ChatClose: &ChatCloseResult{SessionID: "ses_1", ClosedAt: 1792112367999, Interrupted: true},
}
encoded, err := json.Marshal(message)
if err != nil {
t.Fatal(err)
}
var decoded Message
if err := json.Unmarshal(encoded, &decoded); err != nil {
t.Fatal(err)
}
if decoded.Type != ChatSessions || decoded.ID != "r1" {
t.Fatalf("envelope lost: %+v", decoded)
}
if !reflect.DeepEqual(decoded.ChatSessions, message.ChatSessions) ||
!reflect.DeepEqual(decoded.ChatSession, message.ChatSession) ||
!reflect.DeepEqual(decoded.ChatCreate, message.ChatCreate) ||
!reflect.DeepEqual(decoded.ChatAdopt, message.ChatAdopt) ||
!reflect.DeepEqual(decoded.ChatQuery, message.ChatQuery) ||
!reflect.DeepEqual(decoded.ChatPrompt, message.ChatPrompt) ||
!reflect.DeepEqual(decoded.ChatMessages, message.ChatMessages) ||
!reflect.DeepEqual(decoded.ChatEvent, message.ChatEvent) ||
!reflect.DeepEqual(decoded.ChatPermission, message.ChatPermission) ||
!reflect.DeepEqual(decoded.ChatReply, message.ChatReply) ||
!reflect.DeepEqual(decoded.ChatDirectories, message.ChatDirectories) ||
!reflect.DeepEqual(decoded.ChatClose, message.ChatClose) {
t.Fatalf("chat payloads lost: %+v", decoded)
}
}
func TestChatFieldsOmittedWhenUnused(t *testing.T) {
minimal, err := json.Marshal(Message{Type: List, ID: "r1"})
if err != nil {
t.Fatal(err)
}
for _, absent := range []string{"chat_sessions", "chat_session", "chat_create", "chat_adopt", "chat_query", "chat_prompt", "chat_messages", "chat_event", "chat_permission", "chat_reply", "chat_directories", "chat_close"} {
if strings.Contains(string(minimal), absent) {
t.Fatalf("absent %q must be omitted: %s", absent, minimal)
}
}
}
// TestChatOperatorTagVocabulary pins that the stored tag and the display label
// are one mapping (a wire tag plus a derived label), not a second vocabulary.
func TestChatOperatorTagVocabulary(t *testing.T) {
if ChatSessionTagOperator != "operator" || ChatSessionTagOperatorDisplay != "Operator" {
t.Fatalf("operator tag vocabulary = %q/%q, want operator/Operator", ChatSessionTagOperator, ChatSessionTagOperatorDisplay)
}
encoded, err := json.Marshal(ChatSession{ID: "ses_1", Tag: ChatSessionTagOperator})
if err != nil {
t.Fatal(err)
}
if !strings.Contains(string(encoded), `"tag":"operator"`) {
t.Fatalf("operator tag not on the wire: %s", encoded)
}
}