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) } }