diff --git a/internal/opencode/chat_test.go b/internal/opencode/chat_test.go index fca96c4d..63edb2b4 100644 --- a/internal/opencode/chat_test.go +++ b/internal/opencode/chat_test.go @@ -7,6 +7,7 @@ import ( "net/http" "net/http/httptest" "strings" + "sync" "sync/atomic" "testing" "time" @@ -165,6 +166,59 @@ func TestChatRejectsInvalidSessionWithoutCalling(t *testing.T) { } } +// TestChatInterruptPostsInterruptEndpoint pins the outbound interrupt call: the +// adapter must POST an empty JSON body to /api/session/{id}/interrupt exactly +// once and return nil, and it must surface a non-nil error when the endpoint +// fails. One interrupter request, no probing beyond what the call needs. +func TestChatInterruptPostsInterruptEndpoint(t *testing.T) { + t.Run("success", func(t *testing.T) { + type request struct{ method, path, body string } + var mu sync.Mutex + var requests []request + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + data, _ := io.ReadAll(r.Body) + mu.Lock() + requests = append(requests, request{method: r.Method, path: r.URL.Path, body: string(data)}) + mu.Unlock() + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{}`)) + })) + defer srv.Close() + + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := chat.Interrupt(ctx, "ses_1"); err != nil { + t.Fatalf("interrupt: %v", err) + } + mu.Lock() + got := append([]request(nil), requests...) + mu.Unlock() + if len(got) != 1 { + t.Fatalf("interrupt requests = %d, want 1: %+v", len(got), got) + } + if got[0].method != http.MethodPost || got[0].path != "/api/session/ses_1/interrupt" { + t.Fatalf("interrupt request = %+v", got[0]) + } + if got[0].body != "{}" { + t.Fatalf("interrupt body = %q, want {}", got[0].body) + } + }) + + t.Run("failure", func(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + })) + defer srv.Close() + chat := NewChat(&Connection{Backend: "v2", URL: srv.URL}) + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := chat.Interrupt(ctx, "ses_1"); err == nil { + t.Fatal("a failing interrupt endpoint must return an error") + } + }) +} + // TestDecodeChatMessages loads a seeded user + assistant session in both // response envelopes the two surfaces return and asserts the turns come back // with role, id, part order, part ids and the completed tool's input, content diff --git a/internal/server/chat_test.go b/internal/server/chat_test.go index 38778702..7516faa1 100644 --- a/internal/server/chat_test.go +++ b/internal/server/chat_test.go @@ -37,6 +37,7 @@ type fakeChat struct { block bool subscribed bool promptBeforeSubscribe bool + interruptErr error } func (f *fakeChat) Prompt(context.Context, string, string) error { @@ -81,7 +82,7 @@ func (f *fakeChat) Interrupt(context.Context, string) error { f.mu.Lock() defer f.mu.Unlock() f.interrupts++ - return nil + return f.interruptErr } func (f *fakeChat) Messages(_ context.Context, sessionID string, limit int) ([]protocol.ChatMessage, error) { @@ -484,6 +485,183 @@ func TestChatInterruptAndReply(t *testing.T) { } } +// 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/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()