255 lines
8.6 KiB
Go
255 lines
8.6 KiB
Go
package qa
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/session"
|
|
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora"
|
|
)
|
|
|
|
type fakeEventStreamingWeKnora struct {
|
|
*fakeWeKnora
|
|
events []weknora.StreamEvent
|
|
streamResult weknora.ChatResult
|
|
streamErr error
|
|
streamCalls int
|
|
}
|
|
|
|
func (f *fakeEventStreamingWeKnora) AgentChatEvents(_ context.Context, _ string, request weknora.AgentChatRequest, observer weknora.StreamObserver) (weknora.ChatResult, error) {
|
|
f.streamCalls++
|
|
f.mu.Lock()
|
|
f.queries = append(f.queries, request.Query)
|
|
f.requests = append(f.requests, request)
|
|
f.mu.Unlock()
|
|
for _, e := range f.events {
|
|
if observer != nil {
|
|
observer(e)
|
|
}
|
|
}
|
|
return f.streamResult, f.streamErr
|
|
}
|
|
|
|
func TestAskEventsStreamFakeSequencePassesThroughAndSuccess(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
client := &fakeEventStreamingWeKnora{
|
|
fakeWeKnora: &fakeWeKnora{},
|
|
events: []weknora.StreamEvent{
|
|
{ResponseType: "thinking"},
|
|
{ResponseType: "tool_call", ToolName: "query_understand"},
|
|
{ResponseType: "tool_result", ToolName: "query_understand"},
|
|
{ResponseType: "tool_call", ToolName: "knowledge_search"},
|
|
{ResponseType: "references", ReferenceCount: 3},
|
|
{ResponseType: "answer", FullAnswer: "hello ", Done: false},
|
|
{ResponseType: "answer", FullAnswer: "hello world", Done: true},
|
|
},
|
|
streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}},
|
|
}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed []weknora.StreamEvent
|
|
req := streamQARequest("message-events")
|
|
result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) {
|
|
observed = append(observed, e)
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("AskEvents: %v", err)
|
|
}
|
|
if result.Replayed {
|
|
t.Fatal("should not be replay")
|
|
}
|
|
if result.Answer != "hello world" {
|
|
t.Fatalf("expected 'hello world', got %q", result.Answer)
|
|
}
|
|
if client.streamCalls != 1 {
|
|
t.Fatalf("expected 1 stream call, got %d", client.streamCalls)
|
|
}
|
|
if len(observed) != 7 {
|
|
t.Fatalf("expected 7 events, got %d: %+v", len(observed), observed)
|
|
}
|
|
// Verify sequence
|
|
expectedTypes := []string{"thinking", "tool_call", "tool_result", "tool_call", "references", "answer", "answer"}
|
|
for i, want := range expectedTypes {
|
|
if observed[i].ResponseType != want {
|
|
t.Fatalf("event[%d] ResponseType: want %q, got %q", i, want, observed[i].ResponseType)
|
|
}
|
|
}
|
|
// Verify turn persisted
|
|
repo.mu.Lock()
|
|
stored := repo.turns["tenant:dingtalk:message-events"]
|
|
repo.mu.Unlock()
|
|
if stored.Status != "succeeded" || stored.Answer != "hello world" {
|
|
t.Fatalf("stored=%+v", stored)
|
|
}
|
|
}
|
|
|
|
func TestAskEventsEventStreamErrorTurnFailed(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
client := &fakeEventStreamingWeKnora{
|
|
fakeWeKnora: &fakeWeKnora{},
|
|
events: []weknora.StreamEvent{
|
|
{ResponseType: "answer", FullAnswer: "partial"},
|
|
{ResponseType: "error", Done: true},
|
|
},
|
|
streamErr: errors.New("stream failed"),
|
|
}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed []weknora.StreamEvent
|
|
_, err = service.AskEvents(context.Background(), streamQARequest("message-events-error"), func(e weknora.StreamEvent) {
|
|
observed = append(observed, e)
|
|
})
|
|
if err == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
if len(observed) != 2 {
|
|
t.Fatalf("expected 2 events before error, got %d: %+v", len(observed), observed)
|
|
}
|
|
// Turn must be failed
|
|
repo.mu.Lock()
|
|
stored := repo.turns["tenant:dingtalk:message-events-error"]
|
|
repo.mu.Unlock()
|
|
if stored.Status != "failed" || stored.Answer != "" {
|
|
t.Fatalf("expected failed turn without answer, got %+v", stored)
|
|
}
|
|
}
|
|
|
|
func TestAskEventsLegacyFallbackSingleAnswerEvent(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
// fakeWeKnora only implements AgentChat (no AgentChatStream, no AgentChatEvents)
|
|
client := &fakeWeKnora{}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed []weknora.StreamEvent
|
|
req := streamQARequest("message-legacy-events")
|
|
result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) {
|
|
observed = append(observed, e)
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("AskEvents legacy: %v", err)
|
|
}
|
|
if result.Answer != "answer" {
|
|
t.Fatalf("expected 'answer', got %q", result.Answer)
|
|
}
|
|
// Legacy fallback: single final answer event
|
|
if len(observed) != 1 {
|
|
t.Fatalf("expected 1 legacy event, got %d: %+v", len(observed), observed)
|
|
}
|
|
if observed[0].ResponseType != "answer" || observed[0].FullAnswer != "answer" || !observed[0].Done {
|
|
t.Fatalf("legacy event should be answer done: %+v", observed[0])
|
|
}
|
|
}
|
|
|
|
func TestAskEventsDuplicateReplayZeroEvents(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
client := &fakeEventStreamingWeKnora{
|
|
fakeWeKnora: &fakeWeKnora{},
|
|
events: []weknora.StreamEvent{
|
|
{ResponseType: "answer", FullAnswer: "answer", Done: true},
|
|
},
|
|
streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "answer"},
|
|
}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
req := streamQARequest("message-events-replay")
|
|
// First call
|
|
firstEvents := 0
|
|
if _, err := service.AskEvents(context.Background(), req, func(weknora.StreamEvent) { firstEvents++ }); err != nil {
|
|
t.Fatalf("first AskEvents: %v", err)
|
|
}
|
|
// Second call — replay
|
|
secondEvents := 0
|
|
result, err := service.AskEvents(context.Background(), req, func(weknora.StreamEvent) { secondEvents++ })
|
|
if err != nil {
|
|
t.Fatalf("replay AskEvents: %v", err)
|
|
}
|
|
if !result.Replayed {
|
|
t.Fatal("expected replay")
|
|
}
|
|
if secondEvents != 0 {
|
|
t.Fatalf("replay must not notify events, got %d", secondEvents)
|
|
}
|
|
if firstEvents != 1 {
|
|
t.Fatalf("first call expected 1 event, got %d", firstEvents)
|
|
}
|
|
if client.streamCalls != 1 {
|
|
t.Fatalf("expected 1 weknora call, got %d", client.streamCalls)
|
|
}
|
|
}
|
|
|
|
func TestAskEventsStreamingFallbackFromAgentChatStream(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
// Client has AgentChatStream but not AgentChatEvents
|
|
client := &fakeStreamingWeKnora{
|
|
fakeWeKnora: &fakeWeKnora{},
|
|
updates: []string{"hello ", "hello world"},
|
|
streamResult: weknora.ChatResult{RequestID: "request-1", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}},
|
|
}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed []weknora.StreamEvent
|
|
req := streamQARequest("message-stream-fallback")
|
|
result, err := service.AskEvents(context.Background(), req, func(e weknora.StreamEvent) {
|
|
observed = append(observed, e)
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("AskEvents stream fallback: %v", err)
|
|
}
|
|
if result.Answer != "hello world" {
|
|
t.Fatalf("expected 'hello world', got %q", result.Answer)
|
|
}
|
|
// Each answer observer callback becomes a StreamEvent with FullAnswer
|
|
if len(observed) != 2 {
|
|
t.Fatalf("expected 2 events from stream fallback, got %d: %+v", len(observed), observed)
|
|
}
|
|
if observed[0].ResponseType != "answer" || observed[0].FullAnswer != "hello " || observed[0].Done {
|
|
t.Fatalf("event[0]: %+v", observed[0])
|
|
}
|
|
if observed[1].ResponseType != "answer" || observed[1].FullAnswer != "hello world" || observed[1].Done {
|
|
t.Fatalf("event[1]: %+v", observed[1])
|
|
}
|
|
// Turn persisted
|
|
repo.mu.Lock()
|
|
stored := repo.turns["tenant:dingtalk:message-stream-fallback"]
|
|
repo.mu.Unlock()
|
|
if stored.Status != "succeeded" || stored.Answer != "hello world" {
|
|
t.Fatalf("stored=%+v", stored)
|
|
}
|
|
}
|
|
|
|
// TestAskStreamOldRegression verifies the old AskStream still works after refactoring.
|
|
func TestAskStreamOldRegression(t *testing.T) {
|
|
repo := newMemoryRepository()
|
|
client := &fakeStreamingWeKnora{
|
|
fakeWeKnora: &fakeWeKnora{}, updates: []string{"hello ", "hello world"},
|
|
streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}},
|
|
}
|
|
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed []string
|
|
result, err := service.AskStream(context.Background(), streamQARequest("message-stream-regression"), func(full string) { observed = append(observed, full) })
|
|
if err != nil {
|
|
t.Fatalf("AskStream: %v", err)
|
|
}
|
|
if len(observed) != 2 || observed[0] != "hello " || observed[1] != "hello world" {
|
|
t.Fatalf("observed=%v", observed)
|
|
}
|
|
if result.Answer != "hello world" || result.WeKnoraRequestID != "request-stream" || client.streamCalls != 1 {
|
|
t.Fatalf("result=%+v streamCalls=%d", result, client.streamCalls)
|
|
}
|
|
}
|