296 lines
9.9 KiB
Go
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)
|
|
}
|
|
}
|