Files
dobotai-platform/internal/qa/service_test.go
T
2026-07-20 22:35:13 +08:00

364 lines
12 KiB
Go

package qa
import (
"context"
"errors"
"sync"
"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 memoryRepository struct {
mu sync.Mutex
turns map[string]core.Turn
sessions map[string]string
}
func newMemoryRepository() *memoryRepository {
return &memoryRepository{turns: map[string]core.Turn{}, sessions: map[string]string{}}
}
func (r *memoryRepository) BeginTurn(_ context.Context, turn core.Turn) (core.Turn, bool, error) {
r.mu.Lock()
defer r.mu.Unlock()
key := turn.TenantKey + ":" + turn.Channel + ":" + turn.ExternalMessageID
if old, ok := r.turns[key]; ok {
return old, false, nil
}
r.turns[key] = turn
return turn, true, nil
}
func (r *memoryRepository) ResolveSession(ctx context.Context, m core.SessionMapping, create func(context.Context) (string, error)) (string, error) {
r.mu.Lock()
if id := r.sessions[m.SessionKey]; id != "" {
r.mu.Unlock()
return id, nil
}
r.mu.Unlock()
id, err := create(ctx)
if err != nil {
return "", err
}
r.mu.Lock()
defer r.mu.Unlock()
if old := r.sessions[m.SessionKey]; old != "" {
return old, nil
}
r.sessions[m.SessionKey] = id
return id, nil
}
func (r *memoryRepository) FinishTurn(_ context.Context, turn core.Turn) error {
r.mu.Lock()
defer r.mu.Unlock()
r.turns[turn.TenantKey+":"+turn.Channel+":"+turn.ExternalMessageID] = turn
return nil
}
type fixedResolver struct{}
func (fixedResolver) Resolve(_, _ string) (string, error) { return "agent-1", nil }
type fakeWeKnora struct {
mu sync.Mutex
sessions int
queries []string
requests []weknora.AgentChatRequest
}
func (f *fakeWeKnora) CreateSession(context.Context, string, string) (string, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.sessions++
return "session-1", nil
}
func (f *fakeWeKnora) AgentChat(_ context.Context, sessionID string, request weknora.AgentChatRequest) (weknora.ChatResult, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.queries = append(f.queries, request.Query)
f.requests = append(f.requests, request)
return weknora.ChatResult{RequestID: "request-1", Answer: "answer", References: []core.Reference{{KnowledgeID: "kb-1"}}}, nil
}
type fakeStreamingWeKnora struct {
*fakeWeKnora
updates []string
streamResult weknora.ChatResult
streamErr error
streamCalls int
}
func (f *fakeStreamingWeKnora) AgentChatStream(_ context.Context, _ string, request weknora.AgentChatRequest, observer weknora.AnswerObserver) (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 _, update := range f.updates {
if observer != nil {
observer(update)
}
}
return f.streamResult, f.streamErr
}
func TestAskUsesSharedGroupSessionAndReplaysDuplicate(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
base := core.QARequest{TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup, ExternalChatID: "group-1", ExternalUserID: "user-1", ExternalMessageID: "message-1", SenderName: "Alice", Query: "question"}
first, err := service.Ask(context.Background(), base)
if err != nil {
t.Fatalf("Ask: %v", err)
}
second, err := service.Ask(context.Background(), base)
if err != nil {
t.Fatalf("replay: %v", err)
}
if first.Answer != "answer" || !second.Replayed || first.TurnID != second.TurnID {
t.Fatalf("first=%+v second=%+v", first, second)
}
client.mu.Lock()
defer client.mu.Unlock()
if client.sessions != 1 || len(client.queries) != 1 || client.queries[0] != "Alice: question" {
t.Fatalf("sessions=%d queries=%v", client.sessions, client.queries)
}
// sender prefix must not regress
if len(client.requests) != 1 {
t.Fatalf("expected 1 weknora request, got %d", len(client.requests))
}
if client.requests[0].Query != "Alice: question" {
t.Fatalf("sender prefix regression: got %q", client.requests[0].Query)
}
// Turn.Media must be empty for no-image request
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-1"]
repo.mu.Unlock()
if len(stored.Media) != 0 {
t.Fatalf("expected empty Media, got %+v", stored.Media)
}
}
func TestAskPropagatesImagesToWeKnora(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-img", SenderName: "Alice", Query: "describe this",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 1024, Width: 640, Height: 480},
},
}
result, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask: %v", err)
}
if result.Answer != "answer" {
t.Fatalf("unexpected answer: %s", result.Answer)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.requests) != 1 {
t.Fatalf("expected 1 weknora request, got %d", len(client.requests))
}
chatReq := client.requests[0]
if len(chatReq.Images) != 1 {
t.Fatalf("expected 1 image in weknora request, got %d", len(chatReq.Images))
}
if chatReq.Images[0].Data != "data:image/png;base64,AAAA" {
t.Fatalf("image Data not propagated: %q", chatReq.Images[0].Data)
}
// sender prefix must still work
if chatReq.Query != "Alice: describe this" {
t.Fatalf("sender prefix regression: %q", chatReq.Query)
}
}
func TestAskDerivesTurnMediaFromImages(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-media", SenderName: "Alice", Query: "q",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 2048, Width: 640, Height: 480},
},
}
_, err = service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask: %v", err)
}
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-media"]
repo.mu.Unlock()
if len(stored.Media) != 1 {
t.Fatalf("expected 1 MediaAudit, got %d", len(stored.Media))
}
m := stored.Media[0]
if m.Type != "image" || m.MIMEType != "image/png" || m.SizeBytes != 2048 || m.Width != 640 || m.Height != 480 {
t.Fatalf("MediaAudit metadata mismatch: %+v", m)
}
// DataURI must NOT be in Turn.Media
if m.Type == "data:image/png;base64,AAAA" {
t.Fatal("MediaAudit must not contain DataURI")
}
}
func TestAskDuplicateReplayDoesNotCallWeKnoraAgain(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-replay", SenderName: "Alice", Query: "q",
Images: []core.ImageInput{
{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 1024, Width: 640, Height: 480},
},
}
first, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("first Ask: %v", err)
}
second, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("replay Ask: %v", err)
}
if !second.Replayed {
t.Fatal("second should be replayed")
}
if first.Answer != second.Answer {
t.Fatal("replay must return same answer")
}
client.mu.Lock()
defer client.mu.Unlock()
// WeKnora must be called exactly once
if len(client.requests) != 1 {
t.Fatalf("duplicate must not call WeKnora again; got %d requests", len(client.requests))
}
// Turn.Media must be preserved on replay
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-replay"]
repo.mu.Unlock()
if len(stored.Media) != 1 {
t.Fatalf("replay must preserve Turn.Media: %+v", stored.Media)
}
}
func streamQARequest(messageID string) core.QARequest {
return core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: messageID, Query: "question",
}
}
func TestAskStreamUsesStreamingObserverAndPersistsFinal(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"), 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)
}
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-stream"]
repo.mu.Unlock()
if stored.Status != "succeeded" || stored.Answer != "hello world" {
t.Fatalf("stored=%+v", stored)
}
}
func TestAskStreamFailurePersistsFailedWithoutPartialAnswer(t *testing.T) {
repo := newMemoryRepository()
client := &fakeStreamingWeKnora{fakeWeKnora: &fakeWeKnora{}, updates: []string{"partial"}, streamErr: errors.New("stream failed")}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
var observed []string
_, err = service.AskStream(context.Background(), streamQARequest("message-stream-error"), func(full string) { observed = append(observed, full) })
if err == nil {
t.Fatal("expected stream error")
}
if len(observed) != 1 || observed[0] != "partial" {
t.Fatalf("observed=%v", observed)
}
repo.mu.Lock()
stored := repo.turns["tenant:dingtalk:message-stream-error"]
repo.mu.Unlock()
if stored.Status != "failed" || stored.Answer != "" {
t.Fatalf("partial answer must not be persisted as success: %+v", stored)
}
}
func TestAskStreamFallsBackToFinalObserverForLegacyClient(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
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-legacy"), func(full string) { observed = append(observed, full) })
if err != nil {
t.Fatalf("AskStream: %v", err)
}
if result.Answer != "answer" || len(observed) != 1 || observed[0] != "answer" {
t.Fatalf("result=%+v observed=%v", result, observed)
}
}
func TestAskStreamDuplicateReplayDoesNotNotifyAgain(t *testing.T) {
repo := newMemoryRepository()
client := &fakeStreamingWeKnora{
fakeWeKnora: &fakeWeKnora{}, updates: []string{"answer"},
streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "answer"},
}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := streamQARequest("message-stream-replay")
if _, err = service.AskStream(context.Background(), req, func(string) {}); err != nil {
t.Fatalf("first AskStream: %v", err)
}
secondCalls := 0
result, err := service.AskStream(context.Background(), req, func(string) { secondCalls++ })
if err != nil {
t.Fatalf("replay AskStream: %v", err)
}
if !result.Replayed || secondCalls != 0 || client.streamCalls != 1 {
t.Fatalf("result=%+v secondCalls=%d streamCalls=%d", result, secondCalls, client.streamCalls)
}
}