241 lines
7.6 KiB
Go
241 lines
7.6 KiB
Go
package qa
|
|
|
|
import (
|
|
"context"
|
|
"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
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|