Files
dobotai-platform/internal/weknora/stream_event_test.go
2026-07-20 23:10:08 +08:00

270 lines
11 KiB
Go

package weknora
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
)
// TestStreamEventSequence verifies the full event sequence:
// thinking → tool_call(query_understand) → tool_result → tool_call(knowledge_search) →
// references(count=3) → answer cumulative → answer done.
// It also asserts that no thinking/tool content leaks into StreamEvent (type has no Content field).
func TestStreamEventSequence(t *testing.T) {
stream := "data: {\"response_type\":\"thinking\",\"content\":\"inner monologue\",\"done\":false}\n\n" +
"data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"query_understand\",\"arguments\":{\"query\":\"test\"}},\"done\":false}\n\n" +
"data: {\"response_type\":\"tool_result\",\"data\":{\"tool_name\":\"query_understand\",\"result\":\"understood\"},\"done\":false}\n\n" +
"data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"knowledge_search\",\"arguments\":{\"query\":\"test\"}},\"done\":false}\n\n" +
"data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref1\"},{\"knowledge_id\":\"kb-2\",\"content\":\"ref2\"},{\"knowledge_id\":\"kb-3\",\"content\":\"ref3\"}]}\n\n" +
"data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n" +
"data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n"
var events []StreamEvent
result, err := parseSSEWithEventObserver(strings.NewReader(stream), nil, func(e StreamEvent) {
events = append(events, e)
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result.Answer != "hello world" {
t.Fatalf("expected 'hello world', got %q", result.Answer)
}
if len(result.References) != 3 {
t.Fatalf("expected 3 references, got %d", len(result.References))
}
// Expected sequence: thinking, tool_call(query_understand), tool_result, tool_call(knowledge_search), references, answer(hello ), answer(hello world)
expectedTypes := []string{"thinking", "tool_call", "tool_result", "tool_call", "references", "answer", "answer"}
if len(events) != len(expectedTypes) {
t.Fatalf("expected %d events, got %d: %+v", len(expectedTypes), len(events), events)
}
for i, want := range expectedTypes {
if events[i].ResponseType != want {
t.Fatalf("event[%d] ResponseType: want %q, got %q", i, want, events[i].ResponseType)
}
}
// thinking: must not carry Content
if events[0].ToolName != "" || events[0].FullAnswer != "" || events[0].ReferenceCount != 0 {
t.Fatalf("thinking event must not leak content: %+v", events[0])
}
// tool_call(query_understand): ToolName must be "query_understand"
if events[1].ToolName != "query_understand" {
t.Fatalf("tool_call expected ToolName 'query_understand', got %q", events[1].ToolName)
}
if events[1].FullAnswer != "" || events[1].ReferenceCount != 0 {
t.Fatalf("tool_call must not leak other fields: %+v", events[1])
}
// tool_result: ToolName must be "query_understand"
if events[2].ToolName != "query_understand" {
t.Fatalf("tool_result expected ToolName 'query_understand', got %q", events[2].ToolName)
}
// tool_call(knowledge_search): ToolName must be "knowledge_search"
if events[3].ToolName != "knowledge_search" {
t.Fatalf("tool_call expected ToolName 'knowledge_search', got %q", events[3].ToolName)
}
// references: ReferenceCount must be 3
if events[4].ReferenceCount != 3 {
t.Fatalf("references expected ReferenceCount=3, got %d", events[4].ReferenceCount)
}
// answer(hello): Done=false, FullAnswer="hello "
if events[5].FullAnswer != "hello " || events[5].Done {
t.Fatalf("answer chunk 1: expected FullAnswer='hello ' Done=false, got %+v", events[5])
}
// answer(hello world): Done=true, FullAnswer="hello world"
if events[6].FullAnswer != "hello world" || !events[6].Done {
t.Fatalf("answer chunk 2: expected FullAnswer='hello world' Done=true, got %+v", events[6])
}
// Verify no event has any raw content field (StreamEvent struct has no Content/Data field)
// This is a compile-time guarantee — if StreamEvent had Content, we'd have a compilation error.
// Runtime: ensure events don't leak thinking content or tool Data content.
for i, e := range events {
if e.ResponseType == "thinking" && e.FullAnswer != "" {
t.Fatalf("event[%d]: thinking must not leak content", i)
}
}
}
// TestStreamEventErrorDoesNotLeakContent verifies error events notify but do not expose error content.
func TestStreamEventErrorDoesNotLeakContent(t *testing.T) {
stream := "data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n" +
"data: {\"response_type\":\"error\",\"content\":\"secret internal error details\",\"done\":true}\n\n"
var events []StreamEvent
_, err := parseSSEWithEventObserver(strings.NewReader(stream), nil, func(e StreamEvent) {
events = append(events, e)
})
if err == nil {
t.Fatal("expected error from error event")
}
// The error event notification should have been sent before the error returned.
// It should only have ResponseType="error" and Done=true, no Content.
if len(events) < 2 {
t.Fatalf("expected at least 2 events (answer + error notification), got %d: %+v", len(events), events)
}
last := events[len(events)-1]
if last.ResponseType != "error" {
t.Fatalf("expected last event to be error, got %+v", last)
}
if !last.Done {
t.Fatal("error event should have Done=true")
}
// Error content must NOT leak into the event
if last.FullAnswer != "" || last.ToolName != "" || last.ReferenceCount != 0 {
t.Fatalf("error event must not leak content: %+v", last)
}
}
// TestStreamEventAnswerObserverRegression verifies the old AnswerObserver still works correctly.
func TestStreamEventAnswerObserverRegression(t *testing.T) {
stream := "data: {\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n" +
"data: {\"response_type\":\"answer\",\"content\":\"world\",\"done\":true}\n\n"
var observed []string
result, err := parseSSEWithEventObserver(strings.NewReader(stream), func(full string) {
observed = append(observed, full)
}, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result.Answer != "hello world" {
t.Fatalf("expected 'hello world', got %q", result.Answer)
}
if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" {
t.Fatalf("unexpected observed: %v", observed)
}
}
// TestStreamEventAnswerObserverDoneEmptyChunk verifies done empty chunk
// notifies StreamEvent but does NOT trigger old AnswerObserver.
func TestStreamEventAnswerObserverDoneEmptyChunk(t *testing.T) {
stream := "data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":false}\n\n" +
"data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n"
var observed []string
var events []StreamEvent
result, err := parseSSEWithEventObserver(strings.NewReader(stream), func(full string) {
observed = append(observed, full)
}, func(e StreamEvent) {
events = append(events, e)
})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if result.Answer != "hello" {
t.Fatalf("expected 'hello', got %q", result.Answer)
}
// Old AnswerObserver: only called for non-empty content chunks
if len(observed) != 1 || observed[0] != "hello" {
t.Fatalf("old observer should only see non-empty chunks, got %v", observed)
}
// StreamEvent: should include the done empty chunk (FullAnswer is accumulated)
if len(events) < 2 {
t.Fatalf("expected at least 2 stream events, got %d: %+v", len(events), events)
}
last := events[len(events)-1]
if !last.Done || last.FullAnswer != "hello" {
t.Fatalf("last event should have Done=true FullAnswer='hello', got %+v", last)
}
}
// TestAgentChatEventsRunner verifies the AgentChatEvents HTTP method reuses HTTP logic.
func TestAgentChatEventsRunner(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
_, _ = w.Write([]byte("data: {\"response_type\":\"thinking\",\"content\":\"think\",\"done\":false}\n\n"))
_, _ = w.Write([]byte("data: {\"response_type\":\"tool_call\",\"data\":{\"tool_name\":\"knowledge_search\"},\"done\":false}\n\n"))
_, _ = w.Write([]byte("data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref\"}]}\n\n"))
_, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":true}\n\n"))
})
server := httptest.NewServer(mux)
defer server.Close()
client, err := NewClient(server.URL, "test-key", 5*time.Second)
if err != nil {
t.Fatalf("NewClient: %v", err)
}
var events []StreamEvent
result, err := client.AgentChatEvents(context.Background(), "session-1",
AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"},
func(e StreamEvent) { events = append(events, e) })
if err != nil {
t.Fatalf("AgentChatEvents: %v", err)
}
if result.Answer != "hello" {
t.Fatalf("expected 'hello', got %q", result.Answer)
}
if len(events) != 4 {
t.Fatalf("expected 4 events, got %d: %+v", len(events), events)
}
}
// TestAgentChatEventsNilObserver verifies nil observer is safe.
func TestAgentChatEventsNilObserver(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
_, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"ok\",\"done\":true}\n\n"))
})
server := httptest.NewServer(mux)
defer server.Close()
client, err := NewClient(server.URL, "test-key", 5*time.Second)
if err != nil {
t.Fatalf("NewClient: %v", err)
}
result, err := client.AgentChatEvents(context.Background(), "session-1",
AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, nil)
if err != nil {
t.Fatalf("AgentChatEvents with nil observer: %v", err)
}
if result.Answer != "ok" {
t.Fatalf("expected 'ok', got %q", result.Answer)
}
}
// TestAgentChatEventsErrorTurn verifies error event returns error but notifies first.
func TestAgentChatEventsErrorTurn(t *testing.T) {
mux := http.NewServeMux()
mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
_, _ = w.Write([]byte("data: {\"response_type\":\"error\",\"content\":\"boom\",\"done\":true}\n\n"))
})
server := httptest.NewServer(mux)
defer server.Close()
client, err := NewClient(server.URL, "test-key", 5*time.Second)
if err != nil {
t.Fatalf("NewClient: %v", err)
}
var events []StreamEvent
_, err = client.AgentChatEvents(context.Background(), "session-1",
AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"},
func(e StreamEvent) { events = append(events, e) })
if err == nil {
t.Fatal("expected error")
}
if !errors.Is(err, errors.New("boom")) && !strings.Contains(err.Error(), "boom") {
t.Fatalf("expected error containing 'boom', got %v", err)
}
// error event should have notified with type="error", done=true, no content
if len(events) != 1 {
t.Fatalf("expected 1 error notification event, got %d: %+v", len(events), events)
}
if events[0].ResponseType != "error" || !events[0].Done {
t.Fatalf("expected error done event, got %+v", events[0])
}
}