874 lines
30 KiB
Go
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)
|
|
}
|
|
}
|