Files
dobotai-platform/internal/qa/service_observer_test.go
2026-07-22 12:48:30 +08:00

296 lines
9.9 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"
)
// recordingObserver records calls to ObserveSucceededTurn.
type recordingObserver struct {
mu sync.Mutex
turns []core.Turn
err error
}
func (r *recordingObserver) ObserveSucceededTurn(_ context.Context, turn core.Turn) error {
r.mu.Lock()
defer r.mu.Unlock()
r.turns = append(r.turns, turn)
return r.err
}
// failingRepository wraps a memoryRepository and fails FinishTurn.
type failingRepository struct {
*memoryRepository
finishErr error
}
func (r *failingRepository) FinishTurn(ctx context.Context, turn core.Turn) error {
return r.finishErr
}
func TestSucceededTurnObserverCalledOnSuccess(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
observer := &recordingObserver{}
var onErrorCalls []error
onError := func(err error) { onErrorCalls = append(onErrorCalls, err) }
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, onError))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-obs-1", SenderName: "Alice", Query: "question",
}
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)
}
observer.mu.Lock()
defer observer.mu.Unlock()
if len(observer.turns) != 1 {
t.Fatalf("observer called %d times, want 1", len(observer.turns))
}
obsTurn := observer.turns[0]
if obsTurn.Status != "succeeded" {
t.Fatalf("observed turn status = %s, want succeeded", obsTurn.Status)
}
if obsTurn.ID != result.TurnID {
t.Fatalf("observed turn ID = %s, want %s", obsTurn.ID, result.TurnID)
}
if obsTurn.Answer != "answer" {
t.Fatalf("observed turn answer = %s, want answer", obsTurn.Answer)
}
if len(obsTurn.References) != 1 {
t.Fatalf("observed turn references = %d, want 1", len(obsTurn.References))
}
if len(onErrorCalls) != 0 {
t.Fatalf("onError called %d times, want 0", len(onErrorCalls))
}
}
func TestSucceededTurnObserverErrorDoesNotAffectAsk(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
observer := &recordingObserver{err: errors.New("observer failed")}
var onErrorCalls []error
onError := func(err error) { onErrorCalls = append(onErrorCalls, err) }
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, onError))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-obs-2", SenderName: "Alice", Query: "question",
}
result, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask must succeed even when observer fails: %v", err)
}
if result.Answer != "answer" {
t.Fatalf("unexpected answer: %s", result.Answer)
}
if len(onErrorCalls) != 1 {
t.Fatalf("onError called %d times, want 1", len(onErrorCalls))
}
if onErrorCalls[0] == nil || onErrorCalls[0].Error() != "observer failed" {
t.Fatalf("onError received %v, want 'observer failed'", onErrorCalls[0])
}
}
func TestSucceededTurnObserverNotCalledOnFailedWeKnora(t *testing.T) {
repo := newMemoryRepository()
client := &fakeStreamingWeKnora{fakeWeKnora: &fakeWeKnora{}, streamErr: errors.New("weknora failed")}
observer := &recordingObserver{}
var onErrorCalls []error
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, func(err error) { onErrorCalls = append(onErrorCalls, err) }))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationDirect,
ExternalUserID: "user-1", ExternalMessageID: "message-obs-3", Query: "question",
}
_, err = service.AskStream(context.Background(), req, func(string) {})
if err == nil {
t.Fatal("expected error from failed WeKnora")
}
observer.mu.Lock()
defer observer.mu.Unlock()
if len(observer.turns) != 0 {
t.Fatalf("observer called %d times on failed WeKnora, want 0", len(observer.turns))
}
if len(onErrorCalls) != 0 {
t.Fatalf("onError called %d times on failed WeKnora, want 0", len(onErrorCalls))
}
}
func TestSucceededTurnObserverNotCalledOnReplay(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
observer := &recordingObserver{}
var onErrorCalls []error
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, func(err error) { onErrorCalls = append(onErrorCalls, err) }))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-obs-4", SenderName: "Alice", Query: "question",
}
first, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("first Ask: %v", err)
}
if !first.Replayed {
_ = first // first call is not replay
}
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")
}
observer.mu.Lock()
defer observer.mu.Unlock()
if len(observer.turns) != 1 {
t.Fatalf("observer called %d times, want 1 (only first call, not replay)", len(observer.turns))
}
if len(onErrorCalls) != 0 {
t.Fatalf("onError called %d times, want 0", len(onErrorCalls))
}
}
func TestSucceededTurnObserverNilOnErrorIsSafe(t *testing.T) {
repo := newMemoryRepository()
client := &fakeWeKnora{}
observer := &recordingObserver{err: errors.New("observer failed")}
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, nil))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-obs-5", SenderName: "Alice", Query: "question",
}
result, err := service.Ask(context.Background(), req)
if err != nil {
t.Fatalf("Ask must succeed with nil onError: %v", err)
}
if result.Answer != "answer" {
t.Fatalf("unexpected answer: %s", result.Answer)
}
}
func TestSucceededTurnObserverNotCalledOnFinishTurnFailure(t *testing.T) {
repo := &failingRepository{memoryRepository: newMemoryRepository(), finishErr: errors.New("finish turn failed")}
client := &fakeWeKnora{}
observer := &recordingObserver{}
var onErrorCalls []error
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, func(err error) { onErrorCalls = append(onErrorCalls, err) }))
if err != nil {
t.Fatal(err)
}
req := core.QARequest{
TenantKey: "tenant", Channel: "dingtalk", ConversationType: core.ConversationGroup,
ExternalChatID: "group-1", ExternalUserID: "user-1",
ExternalMessageID: "message-obs-6", SenderName: "Alice", Query: "question",
}
_, err = service.Ask(context.Background(), req)
if err == nil {
t.Fatal("expected error from finish turn failure")
}
observer.mu.Lock()
defer observer.mu.Unlock()
if len(observer.turns) != 0 {
t.Fatalf("observer called %d times on finish turn failure, want 0", len(observer.turns))
}
if len(onErrorCalls) != 0 {
t.Fatalf("onError called %d times, want 0", len(onErrorCalls))
}
}
func TestWithSucceededTurnObserverRejectsNilAndTypedNil(t *testing.T) {
var typedNil *recordingObserver
for _, tc := range []struct {
name string
observer SucceededTurnObserver
}{
{name: "nil"},
{name: "typed nil", observer: typedNil},
} {
t.Run(tc.name, func(t *testing.T) {
_, err := New(newMemoryRepository(), fixedResolver{}, &fakeWeKnora{}, session.GroupShared, WithSucceededTurnObserver(tc.observer, nil))
if err == nil {
t.Fatal("expected observer configuration error")
}
})
}
}
func TestNewBackwardCompatibleWithoutObserver(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-obs-7", SenderName: "Alice", Query: "question",
}
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)
}
}
func TestSucceededTurnObserverCalledOnAskStream(t *testing.T) {
repo := newMemoryRepository()
client := &fakeStreamingWeKnora{
fakeWeKnora: &fakeWeKnora{}, updates: []string{"hello world"},
streamResult: weknora.ChatResult{RequestID: "request-stream", Answer: "hello world", References: []core.Reference{{KnowledgeID: "kb-1"}}},
}
observer := &recordingObserver{}
service, err := New(repo, fixedResolver{}, client, session.GroupShared, WithSucceededTurnObserver(observer, nil))
if err != nil {
t.Fatal(err)
}
result, err := service.AskStream(context.Background(), streamQARequest("message-obs-stream"), func(string) {})
if err != nil {
t.Fatalf("AskStream: %v", err)
}
if result.Answer != "hello world" {
t.Fatalf("unexpected answer: %s", result.Answer)
}
observer.mu.Lock()
defer observer.mu.Unlock()
if len(observer.turns) != 1 {
t.Fatalf("observer called %d times, want 1", len(observer.turns))
}
if observer.turns[0].Status != "succeeded" {
t.Fatalf("observed turn status = %s, want succeeded", observer.turns[0].Status)
}
}