235 lines
8.5 KiB
Go
235 lines
8.5 KiB
Go
package weknora
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestClientCreateSessionAndAgentChat(t *testing.T) {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/api/v1/sessions", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Header.Get("X-API-Key") != "test-key" {
|
|
t.Errorf("missing api key")
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
_, _ = w.Write([]byte(`{"success":true,"data":{"id":"session-1"}}`))
|
|
})
|
|
mux.HandleFunc("/api/v1/agent-chat/session-1", func(w http.ResponseWriter, r *http.Request) {
|
|
if r.Header.Get("Accept") != "text/event-stream" {
|
|
t.Errorf("missing SSE accept header")
|
|
}
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = w.Write([]byte("data: {\"id\":\"request-1\",\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"reference\"}]}\n\n"))
|
|
_, _ = w.Write([]byte("data: {\"id\":\"request-1\",\"response_type\":\"answer\",\"content\":\"hello \",\"done\":false}\n\n"))
|
|
_, _ = w.Write([]byte("data: {\"id\":\"request-1\",\"response_type\":\"answer\",\"content\":\"world\",\"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)
|
|
}
|
|
sessionID, err := client.CreateSession(context.Background(), "title", "description")
|
|
if err != nil {
|
|
t.Fatalf("CreateSession: %v", err)
|
|
}
|
|
result, err := client.AgentChat(context.Background(), sessionID, AgentChatRequest{Query: "question", AgentID: "agent-1", Channel: "im"})
|
|
if err != nil {
|
|
t.Fatalf("AgentChat: %v", err)
|
|
}
|
|
if result.Answer != "hello world" || result.RequestID != "request-1" || len(result.References) != 1 {
|
|
t.Fatalf("unexpected result: %+v", result)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEFailsClosedOnPrematureEOF(t *testing.T) {
|
|
_, err := parseSSE(strings.NewReader("data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n"))
|
|
if !errors.Is(err, ErrIncompleteStream) {
|
|
t.Fatalf("error=%v want ErrIncompleteStream", err)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEErrorDominatesPartialAnswer(t *testing.T) {
|
|
stream := "data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n" +
|
|
"data: {\"response_type\":\"error\",\"content\":\"vision model unavailable\",\"done\":true}\n\n"
|
|
_, err := parseSSE(strings.NewReader(stream))
|
|
if err == nil || !strings.Contains(err.Error(), "vision model unavailable") {
|
|
t.Fatalf("expected terminal vision error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAgentChatRequestJSONSerializesImages(t *testing.T) {
|
|
req := AgentChatRequest{
|
|
Query: "请描述并分析这张图片。",
|
|
AgentEnabled: true,
|
|
AgentID: "agent-1",
|
|
Channel: "im",
|
|
Images: []Image{
|
|
{Data: "data:image/png;base64,iVBORw0KGgo="},
|
|
},
|
|
}
|
|
raw, err := json.Marshal(req)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
if !strings.Contains(string(raw), `"images":[{"data":"data:image/png;base64,iVBORw0KGgo="}]`) {
|
|
t.Fatalf("images not serialized correctly: %s", raw)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEWithObserverAnswerChunks(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 := parseSSEWithObserver(strings.NewReader(stream), func(full string) {
|
|
observed = append(observed, full)
|
|
})
|
|
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)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEWithObserverReferencesDoesNotTrigger(t *testing.T) {
|
|
stream := "data: {\"response_type\":\"references\",\"knowledge_references\":[{\"knowledge_id\":\"kb-1\",\"content\":\"ref\"}]}\n\n" +
|
|
"data: {\"response_type\":\"answer\",\"content\":\"x\",\"done\":true}\n\n"
|
|
var observed []string
|
|
_, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) {
|
|
observed = append(observed, full)
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(observed) != 1 || observed[0] != "x" {
|
|
t.Fatalf("references should not trigger observer, got %v", observed)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEWithObserverDoneEmptyChunk(t *testing.T) {
|
|
// done=true but content empty — should mark terminal but not trigger observer
|
|
stream := "data: {\"response_type\":\"answer\",\"content\":\"hello\",\"done\":false}\n\n" +
|
|
"data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n"
|
|
var observed []string
|
|
result, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) {
|
|
observed = append(observed, full)
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if result.Answer != "hello" {
|
|
t.Fatalf("expected 'hello', got %q", result.Answer)
|
|
}
|
|
if len(observed) != 1 || observed[0] != "hello" {
|
|
t.Fatalf("done empty chunk should not trigger observer, got %v", observed)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEWithObserverTerminalEmptyAnswer(t *testing.T) {
|
|
stream := "data: {\"response_type\":\"answer\",\"content\":\"\",\"done\":true}\n\n"
|
|
var observed []string
|
|
_, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) {
|
|
observed = append(observed, full)
|
|
})
|
|
if !errors.Is(err, ErrEmptyAnswer) {
|
|
t.Fatalf("expected ErrEmptyAnswer, got %v", err)
|
|
}
|
|
if len(observed) != 0 {
|
|
t.Fatalf("empty answer should not trigger observer, got %v", observed)
|
|
}
|
|
}
|
|
|
|
func TestParseSSEWithObserverErrorDominatesPartial(t *testing.T) {
|
|
stream := "data: {\"response_type\":\"answer\",\"content\":\"partial\",\"done\":false}\n\n" +
|
|
"data: {\"response_type\":\"error\",\"content\":\"boom\",\"done\":true}\n\n"
|
|
var observed []string
|
|
_, err := parseSSEWithObserver(strings.NewReader(stream), func(full string) {
|
|
observed = append(observed, full)
|
|
})
|
|
if err == nil || !strings.Contains(err.Error(), "boom") {
|
|
t.Fatalf("expected error containing 'boom', got %v", err)
|
|
}
|
|
// observer should have been called once with "partial" before the error
|
|
if len(observed) != 1 || observed[0] != "partial" {
|
|
t.Fatalf("expected observer called with 'partial', got %v", observed)
|
|
}
|
|
}
|
|
|
|
func TestAgentChatStreamCallsObserver(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\":\"hello \",\"done\":false}\n\n"))
|
|
_, _ = w.Write([]byte("data: {\"response_type\":\"answer\",\"content\":\"world\",\"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 observed []string
|
|
result, err := client.AgentChatStream(context.Background(), "session-1",
|
|
AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"},
|
|
func(full string) { observed = append(observed, full) })
|
|
if err != nil {
|
|
t.Fatalf("AgentChatStream: %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)
|
|
}
|
|
}
|
|
|
|
func TestAgentChatStreamNilObserver(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\":\"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)
|
|
}
|
|
result, err := client.AgentChatStream(context.Background(), "session-1",
|
|
AgentChatRequest{Query: "q", AgentID: "agent-1", Channel: "im"}, nil)
|
|
if err != nil {
|
|
t.Fatalf("AgentChatStream with nil observer: %v", err)
|
|
}
|
|
if result.Answer != "hello" {
|
|
t.Fatalf("expected 'hello', got %q", result.Answer)
|
|
}
|
|
}
|
|
|
|
func TestAgentChatRequestJSONOmitsEmptyImages(t *testing.T) {
|
|
req := AgentChatRequest{
|
|
Query: "hello",
|
|
AgentEnabled: true,
|
|
AgentID: "agent-1",
|
|
}
|
|
raw, err := json.Marshal(req)
|
|
if err != nil {
|
|
t.Fatalf("marshal: %v", err)
|
|
}
|
|
if strings.Contains(string(raw), `"images"`) {
|
|
t.Fatalf("empty images should be omitted: %s", raw)
|
|
}
|
|
}
|