270 lines
11 KiB
Go
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])
|
|
}
|
|
}
|