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

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)
}
}