Files
dobotai-platform/internal/qa/service_test.go
2026-08-13 12:34:05 +08:00

874 lines
30 KiB
Go

package qa
import (
"context"
"errors"
"strings"
"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
sessionTitles map[string]string
beginTurns []core.Turn
finishTurns []core.Turn
deliveries []core.DeliveryUpdate
}
func newMemoryRepository() *memoryRepository {
return &memoryRepository{
turns: map[string]core.Turn{},
sessions: map[string]string{},
sessionTitles: map[string]string{},
}
}
func (r *memoryRepository) BeginTurn(_ context.Context, turn core.Turn) (core.Turn, bool, error) {
r.mu.Lock()
defer r.mu.Unlock()
r.beginTurns = append(r.beginTurns, turn)
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
r.sessionTitles[m.SessionKey] = m.DisplayTitle
return id, nil
}
func (r *memoryRepository) SyncSessionTitle(ctx context.Context, m core.SessionMapping, title string, update core.SessionTitleUpdate) error {
r.mu.Lock()
id := r.sessions[m.SessionKey]
current := r.sessionTitles[m.SessionKey]
r.mu.Unlock()
if current == title {
return nil
}
if err := update(ctx, id, title); err != nil {
return err
}
r.mu.Lock()
r.sessionTitles[m.SessionKey] = title
r.mu.Unlock()
return nil
}
func (r *memoryRepository) InvalidateSession(_ context.Context, sessionKey, expectedSessionID string) error {
r.mu.Lock()
defer r.mu.Unlock()
if r.sessions[sessionKey] == expectedSessionID {
delete(r.sessions, sessionKey)
}
return nil
}
func (r *memoryRepository) FinishTurn(_ context.Context, turn core.Turn) error {
r.mu.Lock()
defer r.mu.Unlock()
r.finishTurns = append(r.finishTurns, turn)
r.turns[turn.TenantKey+":"+turn.Channel+":"+turn.ExternalMessageID] = turn
return nil
}
func (r *memoryRepository) RecordDelivery(_ context.Context, update core.DeliveryUpdate) error {
r.mu.Lock()
defer r.mu.Unlock()
r.deliveries = append(r.deliveries, update)
return nil
}
type fixedResolver struct{}
func (fixedResolver) Resolve(_, _ string) (string, error) { return "agent-1", nil }
type recordingResolver struct {
channel string
externalChatID string
}
func (r *recordingResolver) Resolve(channel, externalChatID string) (string, error) {
r.channel = channel
r.externalChatID = externalChatID
return "agent-1", nil
}
type fakeWeKnora struct {
mu sync.Mutex
sessions int
titles []string
updatedTitles []string
updateErrors []error
queries []string
requests []weknora.AgentChatRequest
}
func (f *fakeWeKnora) UpdateSessionTitle(_ context.Context, _, title, _ string) error {
f.mu.Lock()
defer f.mu.Unlock()
f.updatedTitles = append(f.updatedTitles, title)
if len(f.updateErrors) == 0 {
return nil
}
err := f.updateErrors[0]
f.updateErrors = f.updateErrors[1:]
return err
}
func (f *fakeWeKnora) CreateSession(_ context.Context, title, _ string) (string, error) {
f.mu.Lock()
defer f.mu.Unlock()
f.sessions++
f.titles = append(f.titles, title)
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 staleSessionWeKnora struct {
createdSessions int
chatSessions []string
}
func (f *staleSessionWeKnora) CreateSession(context.Context, string, string) (string, error) {
f.createdSessions++
return "fresh-session", nil
}
func (f *staleSessionWeKnora) UpdateSessionTitle(context.Context, string, string, string) error {
return nil
}
func (f *staleSessionWeKnora) AgentChat(_ context.Context, sessionID string, _ weknora.AgentChatRequest) (weknora.ChatResult, error) {
f.chatSessions = append(f.chatSessions, sessionID)
if sessionID == "stale-session" {
return weknora.ChatResult{}, weknora.ErrSessionNotFound
}
return weknora.ChatResult{RequestID: "request-1", Answer: "recovered"}, 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 TestAskCreatesReadableDirectSessionTitle(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
_, err = service.Ask(context.Background(), core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "staff-123456", ExternalMessageID: "message-direct-title",
SenderName: " 张三 ", Query: "question",
})
if err != nil {
t.Fatalf("Ask: %v", err)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.titles) != 1 || client.titles[0] != "张三" {
t.Fatalf("created titles = %v, want [张三]", client.titles)
}
}
func TestAskCreatesReadableGroupSessionTitle(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
_, err = service.Ask(context.Background(), core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "cid-987654", ExternalUserID: "staff-1", ExternalMessageID: "message-group-title",
SenderName: "张三", ConversationTitle: " NOVA项目群 ", Query: "question",
})
if err != nil {
t.Fatalf("Ask: %v", err)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.titles) != 1 || client.titles[0] != "NOVA项目群" {
t.Fatalf("created titles = %v, want [NOVA项目群]", client.titles)
}
}
func TestAskSynchronizesExistingSessionTitleOnlyWhenChanged(t *testing.T) {
repo := newMemoryRepository()
key := "v1:tenant:dingtalk:agent-1:user:staff-1"
repo.sessions[key] = "session-existing"
repo.sessionTitles[key] = ""
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
_, err = service.Ask(context.Background(), core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "staff-1", ExternalMessageID: "message-title-sync", SenderName: "张三", Query: "question",
})
if err != nil {
t.Fatalf("Ask: %v", err)
}
client.mu.Lock()
defer client.mu.Unlock()
if client.sessions != 0 || len(client.updatedTitles) != 1 || client.updatedTitles[0] != "张三" {
t.Fatalf("sessions=%d updatedTitles=%v", client.sessions, client.updatedTitles)
}
}
func TestAskSkipsExistingSessionTitleWhenUnchanged(t *testing.T) {
repo := newMemoryRepository()
key := "v1:tenant:dingtalk:agent-1:user:staff-1"
repo.sessions[key] = "session-existing"
repo.sessionTitles[key] = "张三"
client := &fakeWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
_, err = service.Ask(context.Background(), core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "staff-1", ExternalMessageID: "message-title-unchanged", SenderName: "张三", Query: "question",
})
if err != nil {
t.Fatalf("Ask: %v", err)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.updatedTitles) != 0 {
t.Fatalf("unexpected title updates: %v", client.updatedTitles)
}
}
func TestAskRetriesFailedSessionTitleUpdateWithoutBlockingQA(t *testing.T) {
repo := newMemoryRepository()
key := "v1:tenant:dingtalk:agent-1:user:staff-1"
repo.sessions[key] = "session-existing"
repo.sessionTitles[key] = ""
client := &fakeWeKnora{updateErrors: []error{errors.New("temporary update failure"), nil}}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
for _, messageID := range []string{"message-title-retry-1", "message-title-retry-2"} {
result, askErr := service.Ask(context.Background(), core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "staff-1", ExternalMessageID: messageID, SenderName: "张三", Query: "question",
})
if askErr != nil || result.Answer != "answer" {
t.Fatalf("Ask(%s) result=%+v error=%v", messageID, result, askErr)
}
}
client.mu.Lock()
defer client.mu.Unlock()
if client.sessions != 0 || len(client.updatedTitles) != 2 {
t.Fatalf("sessions=%d updatedTitles=%v", client.sessions, client.updatedTitles)
}
repo.mu.Lock()
defer repo.mu.Unlock()
if repo.sessionTitles[key] != "张三" {
t.Fatalf("tracked title=%q, want 张三", repo.sessionTitles[key])
}
}
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)
}
}
func TestAskBuildsDirectAuditIdentityAndMessageIDs(t *testing.T) {
repo := newMemoryRepository()
service, err := New(repo, fixedResolver{}, &fakeWeKnora{}, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-audit-direct",
SenderName: "Alice", Query: "original question", MessageType: "rich_text",
}
if _, err = service.Ask(context.Background(), req); err != nil {
t.Fatalf("Ask: %v", err)
}
repo.mu.Lock()
begin := repo.beginTurns[0]
finished := repo.finishTurns[len(repo.finishTurns)-1]
repo.mu.Unlock()
if begin.AgentID != "agent-1" || begin.ConversationType != core.ConversationDirect ||
begin.ExternalUserID != "user-1" || begin.ExternalChatID != "" || begin.SenderName != "Alice" {
t.Fatalf("direct audit identity mismatch: %+v", begin)
}
if begin.MessageType != "rich_text" || begin.Question != "original question" {
t.Fatalf("request message audit mismatch: %+v", begin)
}
ids := []string{begin.ID, begin.ActorID, begin.ConversationID, begin.RequestMessageID}
seen := map[string]bool{}
for _, id := range ids {
if id == "" || seen[id] {
t.Fatalf("audit IDs must be non-empty and distinct: %v", ids)
}
seen[id] = true
}
if finished.AnswerMessageID == "" || seen[finished.AnswerMessageID] {
t.Fatalf("answer message ID must be new and non-empty: begin=%v answer=%q", ids, finished.AnswerMessageID)
}
}
func TestAskBuildsGroupAuditWithoutPersistingSenderPrefix(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-9", ExternalMessageID: "message-audit-group",
SenderName: "Bob", Query: "raw question", MessageType: "text",
}
if _, err = service.Ask(context.Background(), req); err != nil {
t.Fatalf("Ask: %v", err)
}
repo.mu.Lock()
begin := repo.beginTurns[0]
repo.mu.Unlock()
if begin.ConversationType != core.ConversationGroup || begin.ExternalChatID != "group-1" || begin.ExternalUserID != "user-9" {
t.Fatalf("group audit identity mismatch: %+v", begin)
}
if begin.Question != "raw question" {
t.Fatalf("audit question must remain raw, got %q", begin.Question)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.queries) != 1 || client.queries[0] != "Bob: raw question" {
t.Fatalf("WeKnora query must keep sender prefix: %v", client.queries)
}
}
func TestAskDefaultsAndNormalizesAuditMessageType(t *testing.T) {
tests := []struct {
name string
messageType string
images []core.ImageInput
want string
}{
{name: "text-default", want: "text"},
{name: "image-default", images: []core.ImageInput{{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png"}}, want: "image"},
{name: "dingtalk-picture", messageType: "picture", images: []core.ImageInput{{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png"}}, want: "image"},
{name: "richtext", messageType: "richText", want: "rich_text"},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
repo := newMemoryRepository()
service, err := New(repo, fixedResolver{}, &fakeWeKnora{}, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-type-" + tc.name, Query: "question",
MessageType: tc.messageType, Images: tc.images}
if _, err = service.Ask(context.Background(), req); err != nil {
t.Fatalf("Ask: %v", err)
}
repo.mu.Lock()
got := repo.beginTurns[0].MessageType
repo.mu.Unlock()
if got != tc.want {
t.Fatalf("MessageType=%q want %q", got, tc.want)
}
})
}
}
func TestAskFailureDoesNotGenerateAnswerMessageID(t *testing.T) {
repo := newMemoryRepository()
client := &fakeStreamingWeKnora{fakeWeKnora: &fakeWeKnora{}, streamErr: errors.New("stream failed")}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
_, err = service.AskStream(context.Background(), streamQARequest("message-no-answer-audit"), func(string) {})
if err == nil {
t.Fatal("expected error")
}
repo.mu.Lock()
finished := repo.finishTurns[len(repo.finishTurns)-1]
repo.mu.Unlock()
if finished.Status != "failed" || finished.AnswerMessageID != "" {
t.Fatalf("failed turn must not generate answer message: %+v", finished)
}
}
func TestAskCanonicalizesStableIdentityBeforeIdempotency(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
resolver := &recordingResolver{}
service, err := New(repo, resolver, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
first := core.QARequest{
TenantKey: " tenant ", Channel: " dingtalk ", ConversationType: core.ConversationType(" direct "),
ExternalChatID: " dm-1 ", ExternalUserID: " user-1 ", ExternalMessageID: " message-trim ",
SenderName: " Alice ", MessageType: " Text ", Query: " preserve question whitespace ",
}
result, err := service.Ask(context.Background(), first)
if err != nil {
t.Fatalf("first Ask: %v", err)
}
second := first
second.TenantKey = "tenant"
second.Channel = "dingtalk"
second.ConversationType = core.ConversationDirect
second.ExternalChatID = "dm-1"
second.ExternalUserID = "user-1"
second.ExternalMessageID = "message-trim"
second.SenderName = "Alice"
replay, err := service.Ask(context.Background(), second)
if err != nil {
t.Fatalf("replay Ask: %v", err)
}
if !replay.Replayed || replay.TurnID != result.TurnID {
t.Fatalf("identity variants must replay the same turn: first=%+v replay=%+v", result, replay)
}
repo.mu.Lock()
begin := repo.beginTurns[0]
repo.mu.Unlock()
if begin.TenantKey != "tenant" || begin.Channel != "dingtalk" || begin.ConversationType != core.ConversationDirect ||
begin.ExternalChatID != "dm-1" || begin.ExternalUserID != "user-1" || begin.ExternalMessageID != "message-trim" ||
begin.SenderName != "Alice" {
t.Fatalf("stable identity was not canonicalized: %+v", begin)
}
if begin.Question != " preserve question whitespace " {
t.Fatalf("question content must not be identity-normalized: %q", begin.Question)
}
if resolver.channel != "dingtalk" || resolver.externalChatID != "dm-1" {
t.Fatalf("resolver received non-canonical identity: channel=%q chat=%q", resolver.channel, resolver.externalChatID)
}
client.mu.Lock()
defer client.mu.Unlock()
if len(client.requests) != 1 {
t.Fatalf("canonical duplicate must call WeKnora once, got %d", len(client.requests))
}
}
func TestAskRejectsNonQAMessageTypes(t *testing.T) {
for _, messageType := range []string{"card", "feedback"} {
t.Run(messageType, func(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.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-" + messageType,
MessageType: messageType, Query: "not a QA message",
}
if _, err = service.Ask(context.Background(), req); err == nil || !strings.Contains(err.Error(), "unsupported message_type") {
t.Fatalf("expected unsupported message_type error, got %v", err)
}
repo.mu.Lock()
beginCount := len(repo.beginTurns)
repo.mu.Unlock()
client.mu.Lock()
requestCount := len(client.requests)
client.mu.Unlock()
if beginCount != 0 || requestCount != 0 {
t.Fatalf("non-QA type must have zero DB/model side effects: begins=%d requests=%d", beginCount, requestCount)
}
})
}
}
func TestAskReturnsGeneratedDeliveryIdentityAndReplay(t *testing.T) {
repo := newMemoryRepository()
service, err := New(repo, fixedResolver{}, &fakeWeKnora{}, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-delivery", Query: "question",
}
first, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatal(err)
}
if first.AnswerMessageID == "" || first.DeliveryStatus != core.DeliveryGenerated {
t.Fatalf("new result delivery identity incomplete: %+v", first)
}
repo.mu.Lock()
key := req.TenantKey + ":" + req.Channel + ":" + req.ExternalMessageID
stored := repo.turns[key]
stored.AnswerDeliveryStatus = core.DeliverySent
repo.turns[key] = stored
repo.mu.Unlock()
replay, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatal(err)
}
if !replay.Replayed || replay.AnswerMessageID != first.AnswerMessageID || replay.DeliveryStatus != core.DeliverySent {
t.Fatalf("replay delivery identity incomplete: first=%+v replay=%+v", first, replay)
}
}
func TestAskRecoversStaleWeKnoraSessionOnce(t *testing.T) {
repo := newMemoryRepository()
client := &staleSessionWeKnora{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared)
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-stale-session", Query: "question",
}
sessionKey, _, err := session.BuildKey(session.Identity{
TenantKey: req.TenantKey, Channel: req.Channel, AgentID: "agent-1",
ConversationType: req.ConversationType, ExternalUserID: req.ExternalUserID,
GroupPolicy: session.GroupShared,
})
if err != nil {
t.Fatal(err)
}
repo.sessions[sessionKey] = "stale-session"
result, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask should recover stale session: %v", err)
}
if result.Answer != "recovered" || result.WeKnoraSessionID != "fresh-session" {
t.Fatalf("unexpected recovered result: %+v", result)
}
if client.createdSessions != 1 || len(client.chatSessions) != 2 ||
client.chatSessions[0] != "stale-session" || client.chatSessions[1] != "fresh-session" {
t.Fatalf("expected one recreate and one retry, created=%d chats=%v", client.createdSessions, client.chatSessions)
}
if repo.sessions[sessionKey] != "fresh-session" {
t.Fatalf("repository mapping was not replaced: %q", repo.sessions[sessionKey])
}
}
func TestRecordDeliveryDelegatesToRepository(t *testing.T) {
repo := newMemoryRepository()
service, err := New(repo, fixedResolver{}, &fakeWeKnora{}, session.GroupShared)
if err != nil {
t.Fatal(err)
}
update := core.DeliveryUpdate{
TenantKey: "tenant", Channel: "dingtalk", AnswerMessageID: "answer-1", CorrelationID: "turn-1",
Status: core.DeliverySent, DeliveryMethod: core.DeliveryMethodCard, ProviderMessageID: "track-1",
}
if err := service.RecordDelivery(context.Background(), update); err != nil {
t.Fatal(err)
}
repo.mu.Lock()
defer repo.mu.Unlock()
if len(repo.deliveries) != 1 || repo.deliveries[0] != update {
t.Fatalf("delivery update not delegated: %+v", repo.deliveries)
}
}