Files
dobotai-platform/internal/channels/dingtalk/handler_test.go

2227 lines
71 KiB
Go

package dingtalk
import (
"context"
"errors"
"reflect"
"strings"
"testing"
"time"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/core"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/directory"
"gitea.zheromiku.top/Weknora/dobotai-platform/internal/weknora"
)
type fakeQA struct {
called bool
lastReq core.QARequest
result core.QAResult
err error
deliveries []core.DeliveryUpdate
deliveryErr error
}
func (f *fakeQA) Ask(_ context.Context, req core.QARequest) (core.QAResult, error) {
f.called = true
f.lastReq = req
return f.result, f.err
}
func (f *fakeQA) RecordDelivery(_ context.Context, update core.DeliveryUpdate) error {
f.deliveries = append(f.deliveries, update)
return f.deliveryErr
}
type fakeDirectory struct {
profile directory.Profile
err error
calls int
}
func (f *fakeDirectory) ResolveUser(context.Context, string, string, string) (directory.Profile, error) {
f.calls++
return f.profile, f.err
}
type fakeReply struct {
called bool
lastURL string
lastTitle string
lastText string
err error
}
func (f *fakeReply) SendMarkdown(_ context.Context, url, title, text string) error {
f.called = true
f.lastURL = url
f.lastTitle = title
f.lastText = text
return f.err
}
type fakeImageDownloader struct {
called bool
code string
image core.ImageInput
err error
}
func (f *fakeImageDownloader) Download(_ context.Context, code string) (core.ImageInput, error) {
f.called = true
f.code = code
return f.image, f.err
}
// fakeCard implements FinalCardSender for tests. It must not log err, outTrackID,
// or content. All fields are test-observable and never leak sensitive values.
type fakeCard struct {
called bool
lastReq CardRequest
returnID string
err error
}
func (f *fakeCard) SendFinalCard(_ context.Context, req CardRequest) (string, error) {
f.called = true
f.lastReq = req
return f.returnID, f.err
}
func newTestHandler(t *testing.T, qa QAAsker, reply *fakeReply) *Handler {
return newTestHandlerWithDownloader(t, qa, reply, nil)
}
func newTestHandlerWithDownloader(t *testing.T, qa QAAsker, reply *fakeReply, downloader ImageDownloader) *Handler {
t.Helper()
cfg := TenantConfig{
TenantKey: "tenant-a",
Channel: "dingtalk",
}
h, err := NewHandler(cfg, qa, reply, downloader)
if err != nil {
t.Fatalf("NewHandler: %v", err)
}
return h
}
func newTestHandlerWithCard(t *testing.T, qa QAAsker, reply *fakeReply, card *fakeCard) *Handler {
t.Helper()
cfg := TenantConfig{
TenantKey: "tenant-a",
Channel: "dingtalk",
}
h, err := NewHandlerWithOptions(cfg, qa, reply, HandlerOptions{CardSender: card})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
return h
}
func directTextCallback() BotCallback {
return BotCallback{
ConversationType: "1",
Msgtype: "text",
MsgID: "msg-1",
SenderNick: "Alice",
SenderStaffID: "staff-123",
SenderID: "user-abc",
SessionWebhook: "https://oapi.dingtalk.com/robot/send?access_token=x",
Text: " hello world ",
}
}
func groupTextCallback() BotCallback {
return BotCallback{
ConversationType: "2",
ConversationID: "cid-group-1",
Msgtype: "text",
MsgID: "msg-2",
SenderNick: "Bob",
SenderStaffID: "staff-456",
SenderID: "user-def",
IsInAtList: true,
SessionWebhook: "https://oapi.dingtalk.com/robot/send?access_token=x",
Text: " group question ",
}
}
func directPictureCallback() BotCallback {
data := directTextCallback()
data.Msgtype = "picture"
data.Text = ""
data.DownloadCode = "temporary-download-code"
return data
}
// --- A: direct text ---
func TestHandleDirectTextCallsQAAndRepliesAnswer(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "**answer**"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.called {
t.Fatal("QA.Ask was not called")
}
req := qa.lastReq
if req.TenantKey != "tenant-a" || req.Channel != "dingtalk" {
t.Fatalf("unexpected TenantKey/Channel: %+v", req)
}
if req.ConversationType != core.ConversationDirect {
t.Fatalf("ConversationType = %q, want direct", req.ConversationType)
}
if req.ExternalUserID != "staff-123" {
t.Fatalf("ExternalUserID = %q, want staff-123", req.ExternalUserID)
}
if req.ExternalMessageID != "msg-1" {
t.Fatalf("ExternalMessageID = %q, want msg-1", req.ExternalMessageID)
}
if req.SenderName != "Alice" {
t.Fatalf("SenderName = %q, want Alice", req.SenderName)
}
if req.Query != "hello world" {
t.Fatalf("Query = %q, want trimmed 'hello world'", req.Query)
}
if req.MessageType != "text" {
t.Fatalf("MessageType = %q, want text", req.MessageType)
}
if req.ExternalChatID != "" {
t.Fatalf("ExternalChatID should be empty for direct, got %q", req.ExternalChatID)
}
if !reply.called {
t.Fatal("Reply.SendMarkdown was not called")
}
if reply.lastText != "**answer**" {
t.Fatalf("reply text = %q, want answer", reply.lastText)
}
if reply.lastURL == "" {
t.Fatal("reply URL should not be empty")
}
}
func TestHandleDirectUsesDirectoryProfile(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{profile: directory.Profile{Name: "张三", DepartmentName: "技术支持部", Region: "APAC"}}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if profiles.calls != 1 || qa.lastReq.SenderName != "张三" || qa.lastReq.Department != "技术支持部" || qa.lastReq.Region != "APAC" {
t.Fatalf("calls=%d request=%+v", profiles.calls, qa.lastReq)
}
}
// TestHandleDirectoryFailureFallsBackToSenderNick validates that when directory
// resolution fails, SenderName falls back to the callback SenderNick.
func TestHandleDirectoryFailureFallsBackToSenderNick(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{err: errors.New("directory unavailable")}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = " 回调昵称 "
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.SenderName != "回调昵称" || qa.lastReq.Department != "" || qa.lastReq.Region != "" {
t.Fatalf("request=%+v", qa.lastReq)
}
}
func TestHandleDirectTextFallsBackToSenderID(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.SenderStaffID = ""
err := h.Handle(context.Background(), data)
if err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ExternalUserID != "user-abc" {
t.Fatalf("ExternalUserID = %q, want fallback to senderId user-abc", qa.lastReq.ExternalUserID)
}
}
func TestHandleDirectTextTrimsQuery(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.Text = " padded "
_ = h.Handle(context.Background(), data)
if qa.lastReq.Query != "padded" {
t.Fatalf("Query = %q, want trimmed 'padded'", qa.lastReq.Query)
}
}
// --- B: group text, @bot ---
func TestHandleGroupTextAtBotCallsQAAndReplies(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "group answer"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
err := h.Handle(context.Background(), groupTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.called {
t.Fatal("QA.Ask was not called")
}
req := qa.lastReq
if req.ConversationType != core.ConversationGroup {
t.Fatalf("ConversationType = %q, want group", req.ConversationType)
}
if req.ExternalChatID != "cid-group-1" {
t.Fatalf("ExternalChatID = %q, want cid-group-1", req.ExternalChatID)
}
if req.Query != "group question" {
t.Fatalf("Query = %q, want trimmed 'group question'", req.Query)
}
if !reply.called {
t.Fatal("Reply.SendMarkdown was not called")
}
}
func TestHandleGroupTextNotAtBotSilentlyIgnored(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := groupTextCallback()
data.IsInAtList = false
err := h.Handle(context.Background(), data)
if err != nil {
t.Fatalf("Handle: expected nil error for non-@bot group message, got %v", err)
}
if qa.called {
t.Fatal("QA.Ask should not be called for non-@bot group message")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called for non-@bot group message")
}
}
// --- C: non-text message ---
func TestHandleNonTextRepliesUnsupported(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.Msgtype = "audio"
err := h.Handle(context.Background(), data)
if err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.called {
t.Fatal("QA.Ask should not be called for non-text message")
}
if !reply.called {
t.Fatal("Reply.SendMarkdown should be called for non-text message")
}
if !strings.Contains(reply.lastText, "暂仅支持文字消息") {
t.Fatalf("reply text = %q, want unsupported-message notice", reply.lastText)
}
}
func TestHandlePictureDownloadsAndCallsQA(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "图片回答"}}
reply := &fakeReply{}
image := core.ImageInput{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 4, Width: 1, Height: 1}
downloader := &fakeImageDownloader{image: image}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
if err := h.Handle(context.Background(), directPictureCallback()); err != nil {
t.Fatalf("Handle picture: %v", err)
}
if !downloader.called || downloader.code != "temporary-download-code" {
t.Fatalf("download called=%v code=%q", downloader.called, downloader.code)
}
if !qa.called || len(qa.lastReq.Images) != 1 || qa.lastReq.Images[0] != image {
t.Fatalf("QA request did not receive image: %+v", qa.lastReq)
}
if qa.lastReq.Query != "请描述并分析这张图片。" {
t.Fatalf("picture query=%q", qa.lastReq.Query)
}
if !reply.called || reply.lastText != "图片回答" {
t.Fatalf("reply=%+v", reply)
}
}
func TestHandlePicturePreparationFailuresAreFriendlyAndDoNotCallQA(t *testing.T) {
tests := []struct {
name string
code string
downloader ImageDownloader
}{
{name: "missing download code", code: "", downloader: &fakeImageDownloader{}},
{name: "missing downloader", code: "code", downloader: nil},
{name: "download error", code: "secret-code", downloader: &fakeImageDownloader{err: errors.New("signed URL and token must not leak")}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandlerWithDownloader(t, qa, reply, tt.downloader)
data := directPictureCallback()
data.DownloadCode = tt.code
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.called {
t.Fatal("QA must not be called")
}
if !reply.called || reply.lastText != "图片识别暂时不可用,请稍后重试或发送文字。" {
t.Fatalf("friendly reply=%q", reply.lastText)
}
})
}
}
func TestHandleGroupPictureWithoutMentionDoesNothing(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
downloader := &fakeImageDownloader{}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
data := directPictureCallback()
data.ConversationType = conversationTypeGroup
data.IsInAtList = false
data.SessionWebhook = "not even validated"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if downloader.called || qa.called || reply.called {
t.Fatalf("unexpected side effects: downloader=%v qa=%v reply=%v", downloader.called, qa.called, reply.called)
}
}
func TestHandlePictureRejectsWebhookBeforeDownload(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
downloader := &fakeImageDownloader{}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
data := directPictureCallback()
data.SessionWebhook = "http://127.0.0.1/steal"
if err := h.Handle(context.Background(), data); err == nil {
t.Fatal("expected invalid webhook error")
}
if downloader.called || qa.called || reply.called {
t.Fatalf("invalid webhook caused side effects: downloader=%v qa=%v reply=%v", downloader.called, qa.called, reply.called)
}
}
// --- D: QA error ---
func TestHandleQAErrorRepliesFriendlyMessage(t *testing.T) {
qa := &fakeQA{err: errors.New("weknora connection timeout: internal stack trace")}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !reply.called {
t.Fatal("Reply.SendMarkdown should be called on QA error")
}
if !strings.Contains(reply.lastText, "暂时无法完成回答") {
t.Fatalf("reply text = %q, want friendly error message", reply.lastText)
}
if strings.Contains(reply.lastText, "weknora") || strings.Contains(reply.lastText, "timeout") || strings.Contains(reply.lastText, "stack") {
t.Fatalf("reply text leaks internal error: %q", reply.lastText)
}
}
// --- E: invalid input ---
func TestHandleEmptyTextReturnsError(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.Text = " "
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for empty text")
}
if qa.called {
t.Fatal("QA.Ask should not be called for empty text")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called for empty text")
}
}
func TestHandleMissingMsgIDReturnsError(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.MsgID = ""
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for missing MsgId")
}
if qa.called {
t.Fatal("QA.Ask should not be called for missing MsgId")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called for missing MsgId")
}
}
func TestHandleMissingUserReturnsError(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.SenderStaffID = ""
data.SenderID = ""
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for missing user")
}
if qa.called {
t.Fatal("QA.Ask should not be called for missing user")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called for missing user")
}
}
func TestHandleGroupMissingConversationIDReturnsError(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := groupTextCallback()
data.ConversationID = ""
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for group missing ConversationId")
}
if qa.called {
t.Fatal("QA.Ask should not be called for group missing ConversationId")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called for group missing ConversationId")
}
}
// --- F: missing sessionWebhook ---
func TestHandleMissingSessionWebhookReturnsError(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.SessionWebhook = ""
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for missing sessionWebhook")
}
if qa.called {
t.Fatal("QA.Ask should not be called when sessionWebhook is missing (model call would be wasted)")
}
if reply.called {
t.Fatal("Reply.SendMarkdown should not be called when sessionWebhook is missing")
}
}
func TestHandleNonTextMissingSessionWebhookReturnsError(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.Msgtype = "picture"
data.SessionWebhook = ""
err := h.Handle(context.Background(), data)
if err == nil {
t.Fatal("expected error for non-text with missing sessionWebhook")
}
}
// --- reply send failure ---
// --- F: richText mixed (text + picture) ---
func TestHandleRichTextMixedDownloadsAndCallsQAWithRealQuery(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "图文回答"}}
reply := &fakeReply{}
image := core.ImageInput{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 4, Width: 1, Height: 1}
downloader := &fakeImageDownloader{image: image}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
// Simulate richText mixed: text + picture
data := directTextCallback()
data.Msgtype = "picture"
data.DownloadCode = "temporary-download-code"
data.Text = " 请分析这张截图中的错误 "
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle richText mixed: %v", err)
}
if !downloader.called || downloader.code != "temporary-download-code" {
t.Fatalf("download called=%v code=%q", downloader.called, downloader.code)
}
if !qa.called || len(qa.lastReq.Images) != 1 || qa.lastReq.Images[0] != image {
t.Fatalf("QA request did not receive image: %+v", qa.lastReq)
}
if qa.lastReq.MessageType != "picture" {
t.Fatalf("MessageType=%q, want raw DingTalk type picture", qa.lastReq.MessageType)
}
// Key assert: mixed uses real query, not default imageQuery
if qa.lastReq.Query != "请分析这张截图中的错误" {
t.Fatalf("richText mixed query=%q, want real query", qa.lastReq.Query)
}
if !reply.called || reply.lastText != "图文回答" {
t.Fatalf("reply=%+v", reply)
}
}
func TestHandleRichTextMixedEmptyQueryFallsBackToDefault(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "默认回答"}}
reply := &fakeReply{}
image := core.ImageInput{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 4, Width: 1, Height: 1}
downloader := &fakeImageDownloader{image: image}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
data := directTextCallback()
data.Msgtype = "picture"
data.DownloadCode = "code"
data.Text = " "
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
// When Text is empty after trim, falls back to default imageQuery
if qa.lastReq.Query != imageQuery {
t.Fatalf("query=%q, want default imageQuery=%q", qa.lastReq.Query, imageQuery)
}
}
func TestHandleIndependentPictureStillUsesDefaultQuery(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "图片回答"}}
reply := &fakeReply{}
image := core.ImageInput{DataURI: "data:image/png;base64,AAAA", MIMEType: "image/png", SizeBytes: 4, Width: 1, Height: 1}
downloader := &fakeImageDownloader{image: image}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
// Independent picture: Text is empty (as A1 produces)
data := directPictureCallback()
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle picture: %v", err)
}
// Independent picture should still use default query
if qa.lastReq.Query != imageQuery {
t.Fatalf("picture query=%q, want default imageQuery=%q", qa.lastReq.Query, imageQuery)
}
}
func TestHandleGroupRichTextMixedWithoutMentionDoesNothing(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
downloader := &fakeImageDownloader{}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
data := directTextCallback()
data.Msgtype = "picture"
data.DownloadCode = "code"
data.Text = "忽略这条"
data.ConversationType = conversationTypeGroup
data.IsInAtList = false
data.SessionWebhook = "not even validated"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if downloader.called || qa.called || reply.called {
t.Fatalf("unexpected side effects: downloader=%v qa=%v reply=%v", downloader.called, qa.called, reply.called)
}
}
func TestHandleRichTextMixedDownloadFailureFriendlyReplyNoQA(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
downloader := &fakeImageDownloader{err: errors.New("download failed")}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
data := directTextCallback()
data.Msgtype = "picture"
data.DownloadCode = "broken-code"
data.Text = "帮我看看这张图"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.called {
t.Fatal("QA must not be called on download failure")
}
if !reply.called || reply.lastText != imageErrorReply {
t.Fatalf("friendly reply=%q, want %q", reply.lastText, imageErrorReply)
}
}
func TestHandleReplySendFailureReturnsError(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{err: errors.New("webhook timeout")}
h := newTestHandler(t, qa, reply)
err := h.Handle(context.Background(), directTextCallback())
if err == nil {
t.Fatal("expected error when reply send fails")
}
}
// --- A3.1: AI card priority / markdown fallback ---
func TestHandleCardSuccessDirectFieldsCorrectNoMarkdown(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "**card answer**"}}
reply := &fakeReply{}
card := &fakeCard{returnID: "out-track-123"}
h := newTestHandlerWithCard(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !card.called {
t.Fatal("card.SendFinalCard was not called")
}
if card.lastReq.ConversationType != core.ConversationDirect {
t.Fatalf("card ConversationType = %q, want direct", card.lastReq.ConversationType)
}
if card.lastReq.ExternalUserID != "staff-123" {
t.Fatalf("card ExternalUserID = %q, want staff-123", card.lastReq.ExternalUserID)
}
if card.lastReq.Content != "**card answer**" {
t.Fatalf("card Content = %q, want answer", card.lastReq.Content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called when card succeeds")
}
}
func TestHandleNonStreamingRewritesFinalCardAndMarkdownFallback(t *testing.T) {
resource := "resource://AbCdEfGhIjKlMnOpQrStUv"
signed := "https://img.example/signed.jpg"
answer := "说明\n![图](" + resource + ")"
for _, tc := range []struct {
name string
cardErr error
wantReply bool
}{
{name: "card"},
{name: "markdown fallback", cardErr: errors.New("card failed"), wantReply: true},
} {
t.Run(tc.name, func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: answer}}
reply := &fakeReply{}
card := &fakeCard{returnID: "track", err: tc.cardErr}
h := newTestHandlerWithCard(t, qa, reply, card)
rewriter := &fakeOutboundRewriter{from: resource, to: signed}
h.outboundRewriter = rewriter
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if !card.called || reply.called != tc.wantReply {
t.Fatalf("card=%t reply=%t", card.called, reply.called)
}
content := card.lastReq.Content
if tc.wantReply {
content = reply.lastText
}
if strings.Contains(content, resource) || !strings.Contains(content, signed) {
t.Fatalf("outbound content=%q", content)
}
if rewriter.calls != 1 {
t.Fatalf("rewrite calls=%d, want 1", rewriter.calls)
}
})
}
}
func TestHandleCardSuccessGroupChatIDCorrect(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "group card answer"}}
reply := &fakeReply{}
card := &fakeCard{returnID: "out-track-group"}
h := newTestHandlerWithCard(t, qa, reply, card)
err := h.Handle(context.Background(), groupTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !card.called {
t.Fatal("card.SendFinalCard was not called")
}
if card.lastReq.ConversationType != core.ConversationGroup {
t.Fatalf("card ConversationType = %q, want group", card.lastReq.ConversationType)
}
if card.lastReq.ExternalChatID != "cid-group-1" {
t.Fatalf("card ExternalChatID = %q, want cid-group-1", card.lastReq.ExternalChatID)
}
if reply.called {
t.Fatal("SendMarkdown must not be called when card succeeds")
}
}
func TestHandleCardFailureFallsBackToMarkdown(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "**fallback answer**"}}
reply := &fakeReply{}
card := &fakeCard{err: errors.New("card API 500")}
h := newTestHandlerWithCard(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !card.called {
t.Fatal("card.SendFinalCard was not called")
}
if !reply.called {
t.Fatal("SendMarkdown must be called when card fails (fallback)")
}
if reply.lastText != "**fallback answer**" {
t.Fatalf("fallback reply text = %q, want answer", reply.lastText)
}
}
func TestHandleQAFailureNoCardAndFriendlyMarkdown(t *testing.T) {
qa := &fakeQA{err: errors.New("internal weknora error")}
reply := &fakeReply{}
card := &fakeCard{}
h := newTestHandlerWithCard(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if card.called {
t.Fatal("card.SendFinalCard must not be called on QA failure")
}
if !reply.called {
t.Fatal("SendMarkdown must be called on QA failure")
}
if !strings.Contains(reply.lastText, "暂时无法完成回答") {
t.Fatalf("friendly reply text = %q", reply.lastText)
}
if strings.Contains(reply.lastText, "weknora") {
t.Fatalf("reply text leaks internal error: %q", reply.lastText)
}
}
func TestHandleNilCardNormalTextRegression(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "**plain markdown**"}}
reply := &fakeReply{}
// Use NewHandler (no card) — must behave exactly as before
h := newTestHandler(t, qa, reply)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !reply.called {
t.Fatal("SendMarkdown must be called when no card sender")
}
if reply.lastText != "**plain markdown**" {
t.Fatalf("reply text = %q, want answer", reply.lastText)
}
}
func TestHandleImageDownloadFailureNoCard(t *testing.T) {
qa := &fakeQA{}
reply := &fakeReply{}
card := &fakeCard{}
downloader := &fakeImageDownloader{err: errors.New("download failed")}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
// Inject card via options — test that download failure short-circuits before card
h.card = card
data := directPictureCallback()
data.DownloadCode = "broken-code"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if card.called {
t.Fatal("card.SendFinalCard must not be called on image download failure")
}
if qa.called {
t.Fatal("QA must not be called on download failure")
}
if !reply.called || reply.lastText != imageErrorReply {
t.Fatalf("friendly reply=%q, want %q", reply.lastText, imageErrorReply)
}
}
func TestHandleNewHandlerBackwardCompat(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
// one downloader
h, err := NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply, &fakeImageDownloader{})
if err != nil {
t.Fatalf("NewHandler with one downloader: %v", err)
}
if h.downloader == nil {
t.Fatal("downloader should be set")
}
if h.card != nil {
t.Fatal("card should be nil when using NewHandler")
}
// zero downloader
h2, err := NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply)
if err != nil {
t.Fatalf("NewHandler with zero downloader: %v", err)
}
if h2.downloader != nil {
t.Fatal("downloader should be nil when not provided")
}
if h2.card != nil {
t.Fatal("card should be nil when using NewHandler")
}
// two downloaders — must error
_, err = NewHandler(TenantConfig{TenantKey: "t", Channel: "c"}, qa, reply, &fakeImageDownloader{}, &fakeImageDownloader{})
if err == nil {
t.Fatal("NewHandler with two downloaders should error")
}
}
// --- A3.2: Streaming QA + Card integration ---
// fakeStreamingQA implements both QAAsker and StreamingQAAsker.
// The observer is called synchronously with cumulative content during AskStream.
type fakeStreamingQA struct {
called bool
lastReq core.QARequest
result core.QAResult
err error
// streaming
streamCalled bool
chunks []string // observer receives cumulated content after each chunk
observerCaptured weknora.AnswerObserver
deliveries []core.DeliveryUpdate
deliveryErr error
}
func (f *fakeStreamingQA) Ask(_ context.Context, req core.QARequest) (core.QAResult, error) {
f.called = true
f.lastReq = req
return f.result, f.err
}
func (f *fakeStreamingQA) AskStream(_ context.Context, req core.QARequest, observer weknora.AnswerObserver) (core.QAResult, error) {
f.streamCalled = true
f.lastReq = req
f.observerCaptured = observer
var accumulated string
for _, ch := range f.chunks {
accumulated += ch
if observer != nil {
observer(accumulated)
}
}
return f.result, f.err
}
func (f *fakeStreamingQA) RecordDelivery(_ context.Context, update core.DeliveryUpdate) error {
f.deliveries = append(f.deliveries, update)
return f.deliveryErr
}
// fakeStreamingCard implements both FinalCardSender and StreamingCardSender.
type fakeStreamingCard struct {
// FinalCardSender
finalCalled bool
finalReq CardRequest
finalID string
finalErr error
// StreamingCardSender
startCalled bool
startReq CardRequest
startID string
startErr error
updates []cardUpdate
updateErr error
}
type cardUpdate struct {
id string
content string
isFinalize bool
isError bool
}
type fakeOutboundRewriter struct {
calls int
partialCalls int
from string
to string
}
func (f *fakeOutboundRewriter) Rewrite(_ context.Context, content string) string {
f.calls++
return strings.ReplaceAll(content, f.from, f.to)
}
func (f *fakeOutboundRewriter) SanitizePartial(content string) string {
f.partialCalls++
return strings.ReplaceAll(content, f.from, "")
}
func (f *fakeStreamingCard) SendFinalCard(_ context.Context, req CardRequest) (string, error) {
f.finalCalled = true
f.finalReq = req
return f.finalID, f.finalErr
}
func (f *fakeStreamingCard) StartCard(_ context.Context, req CardRequest) (string, error) {
f.startCalled = true
f.startReq = req
return f.startID, f.startErr
}
func (f *fakeStreamingCard) UpdateCard(_ context.Context, id, content string, isFinalize, isError bool) error {
f.updates = append(f.updates, cardUpdate{id: id, content: content, isFinalize: isFinalize, isError: isError})
return f.updateErr
}
func newTestHandlerWithStreaming(t *testing.T, qa QAAsker, reply *fakeReply, card FinalCardSender) *Handler {
t.Helper()
cfg := TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}
h, err := NewHandlerWithOptions(cfg, qa, reply, HandlerOptions{CardSender: card})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
return h
}
func TestHandleStreamingHappyPathDirect(t *testing.T) {
card := &fakeStreamingCard{startID: "track-happy-1"}
qa := &fakeStreamingQA{
chunks: []string{"Hello", " World", "!"},
result: core.QAResult{Answer: "Hello World!"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// StartCard called once with placeholder
if !card.startCalled {
t.Fatal("StartCard was not called")
}
if card.startReq.Content != streamingPlaceholder {
t.Fatalf("StartCard Content = %q, want %q", card.startReq.Content, streamingPlaceholder)
}
if card.startReq.ConversationType != core.ConversationDirect {
t.Fatalf("StartCard ConversationType = %q, want direct", card.startReq.ConversationType)
}
if card.startReq.ExternalUserID != "staff-123" {
t.Fatalf("StartCard ExternalUserID = %q, want staff-123", card.startReq.ExternalUserID)
}
// AskStream called, not Ask
if !qa.streamCalled {
t.Fatal("AskStream was not called")
}
// First non-empty chunk → immediate update (not finalize)
if len(card.updates) < 1 {
t.Fatal("expected at least one update")
}
first := card.updates[0]
if first.id != "track-happy-1" {
t.Fatalf("first update id = %q, want track-happy-1", first.id)
}
if first.content != "Hello" {
t.Fatalf("first update content = %q, want Hello", first.content)
}
if first.isFinalize || first.isError {
t.Fatal("first update should not be finalize or error")
}
// Final update must be the last one: content=full answer, isFinalize=true, isError=false
last := card.updates[len(card.updates)-1]
if last.content != "Hello World!" {
t.Fatalf("final update content = %q, want full answer", last.content)
}
if !last.isFinalize {
t.Fatal("final update must be finalize")
}
if last.isError {
t.Fatal("final update must not be error")
}
// No markdown fallback
if reply.called {
t.Fatal("SendMarkdown must not be called on streaming success")
}
}
func TestHandleStreamingThrottleSecondUpdate(t *testing.T) {
card := &fakeStreamingCard{startID: "track-throttle"}
qa := &fakeStreamingQA{
chunks: []string{"A", "B", "C"},
result: core.QAResult{Answer: "ABC"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
// Simulate clock advancing past interval
base := int64(0)
h.now = func() time.Time { return time.Unix(0, base) }
h.cardUpdateInterval = time.Millisecond
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// All updates happen in the same goroutine, so the clock never advances
// during the single observer call chain. The first chunk fires immediately,
// subsequent chunks are throttled (clock hasn't advanced).
// The final update always fires.
if len(card.updates) < 2 {
t.Fatalf("expected at least first + final update, got %d", len(card.updates))
}
// First update is immediate
if card.updates[0].isFinalize || card.updates[0].isError {
t.Fatal("first update must not be finalize/error")
}
// Last update is final
last := card.updates[len(card.updates)-1]
if !last.isFinalize || last.isError {
t.Fatal("last update must be finalize, not error")
}
if last.content != "ABC" {
t.Fatalf("final content = %q, want ABC", last.content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
func TestHandleStreamingThrottleClockAdvances(t *testing.T) {
card := &fakeStreamingCard{startID: "track-adv"}
qa := &fakeStreamingQA{
chunks: []string{"X", "Y", "Z"},
result: core.QAResult{Answer: "XYZ"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
callCount := int64(0)
h.now = func() time.Time {
c := callCount
callCount++
// Each call advances by 800ms to cross the 750ms interval
return time.Unix(0, c*800_000_000)
}
h.cardUpdateInterval = 750 * time.Millisecond
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// First chunk fires immediately (1 update), then each subsequent observer call
// sees clock advanced past interval → fires another update.
// So we should see: first("X"), second("XY"), final("XYZ")
nonFinal := 0
for _, u := range card.updates {
if !u.isFinalize && !u.isError {
nonFinal++
}
}
if nonFinal < 2 {
t.Fatalf("expected at least 2 intermediate updates with clock advance, got %d (updates=%+v)", nonFinal, card.updates)
}
last := card.updates[len(card.updates)-1]
if !last.isFinalize || last.isError {
t.Fatal("last update must be finalize")
}
if last.content != "XYZ" {
t.Fatalf("final content = %q, want XYZ", last.content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
func TestHandleStreamingStartFailsFallbackAskMarkdown(t *testing.T) {
card := &fakeStreamingCard{startErr: errors.New("card API unavailable")}
resource := "resource://AbCdEfGhIjKlMnOpQrStUv"
qa := &fakeStreamingQA{
result: core.QAResult{Answer: "**fallback markdown**\n![图](" + resource + ")"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
rewriter := &fakeOutboundRewriter{from: resource, to: "https://img.example/signed.jpg"}
h.outboundRewriter = rewriter
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// StartCard was attempted
if !card.startCalled {
t.Fatal("StartCard was not called")
}
// Fallback: Ask (not AskStream) was called
if !qa.called {
t.Fatal("Ask (fallback) was not called")
}
if qa.streamCalled {
t.Fatal("AskStream must not be called on Start failure")
}
// No SendFinalCard
if card.finalCalled {
t.Fatal("SendFinalCard must not be called on Start failure")
}
// Markdown fallback
if !reply.called {
t.Fatal("SendMarkdown must be called on Start failure")
}
if strings.Contains(reply.lastText, resource) || !strings.Contains(reply.lastText, "https://img.example/signed.jpg") {
t.Fatalf("markdown text = %q, want rewritten fallback markdown", reply.lastText)
}
if rewriter.calls != 1 {
t.Fatalf("rewrite calls=%d, want 1", rewriter.calls)
}
// No card updates
if len(card.updates) > 0 {
t.Fatal("no card updates expected on Start failure")
}
}
func TestHandleStreamingIntermediateUpdateFailsContinuesQA(t *testing.T) {
card := &fakeStreamingCard{startID: "track-midfail", updateErr: errors.New("update HTTP 500")}
qa := &fakeStreamingQA{
chunks: []string{"Hello", " World"},
result: core.QAResult{Answer: "Hello World"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// QA still completed (AskStream must have been called and returned)
if !qa.streamCalled {
t.Fatal("AskStream must be called")
}
// There must be a final update attempt (even though intermediate failed)
foundFinal := false
for _, u := range card.updates {
if u.isFinalize && !u.isError {
foundFinal = true
}
}
if !foundFinal {
t.Fatal("final update must be attempted even after intermediate failures")
}
// Since updateErr is set, the final update also fails → markdown fallback
if !reply.called {
t.Fatal("SendMarkdown must be called when final update fails")
}
if reply.lastText != "Hello World" {
t.Fatalf("markdown text = %q, want full answer", reply.lastText)
}
}
func TestHandleStreamingFinalUpdateFailsMarkdown(t *testing.T) {
card := &fakeStreamingCard{startID: "track-finalfail"}
qa := &fakeStreamingQA{
chunks: []string{"OK"},
result: core.QAResult{Answer: "OK"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
// Make only the final update fail by using a counter in updateErr
updateCount := 0
card.updateErr = nil // will be set per-call via a wrapper
// We'll use a different approach: make the final call fail by checking content
// Actually, simplest: set updateErr to an error, and the test checks markdown fallback
card.updateErr = errors.New("finalize API error")
_ = updateCount
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.streamCalled {
t.Fatal("AskStream must be called")
}
// Markdown fallback with full answer
if !reply.called {
t.Fatal("SendMarkdown must be called when final update fails")
}
if reply.lastText != "OK" {
t.Fatalf("markdown text = %q, want OK", reply.lastText)
}
}
func TestHandleStreamingQAErrorConvergesErrorCard(t *testing.T) {
card := &fakeStreamingCard{startID: "track-errcard"}
qa := &fakeStreamingQA{
chunks: []string{"Partial"},
err: errors.New("secret weknora internal failure"),
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.streamCalled {
t.Fatal("AskStream must be called")
}
// Last update must be error card: isFinalize=true, isError=true, content=qaErrorReply
last := card.updates[len(card.updates)-1]
if !last.isFinalize {
t.Fatal("error card must be finalize")
}
if !last.isError {
t.Fatal("error card must be isError")
}
if last.content != qaErrorReply {
t.Fatalf("error card content = %q, want %q", last.content, qaErrorReply)
}
// Must not leak QA error
if strings.Contains(last.content, "weknora") || strings.Contains(last.content, "secret") {
t.Fatalf("error card leaks internal error: %q", last.content)
}
// No markdown (error card succeeded)
if reply.called {
t.Fatal("SendMarkdown must not be called when error card succeeds")
}
// QA error was not leaked in any update content
for _, u := range card.updates {
if strings.Contains(u.content, "weknora") || strings.Contains(u.content, "secret") {
t.Fatalf("update leaks internal error: %q", u.content)
}
}
}
func TestHandleStreamingErrorCardFinalizeFailsMarkdown(t *testing.T) {
card := &fakeStreamingCard{startID: "track-errfinalfail", updateErr: errors.New("finalize API error")}
qa := &fakeStreamingQA{
chunks: []string{"Partial"},
err: errors.New("secret weknora internal failure"),
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// Markdown fallback with friendly error message
if !reply.called {
t.Fatal("SendMarkdown must be called when error card finalize fails")
}
if reply.lastText != qaErrorReply {
t.Fatalf("markdown text = %q, want %q", reply.lastText, qaErrorReply)
}
// Must not leak QA error
if strings.Contains(reply.lastText, "weknora") || strings.Contains(reply.lastText, "secret") {
t.Fatalf("markdown leaks internal error: %q", reply.lastText)
}
}
func TestHandleOldFakeCardStillA31(t *testing.T) {
// fakeCard does NOT implement StreamingCardSender — must use A3.1 path
card := &fakeCard{returnID: "out-a31"}
qa := &fakeStreamingQA{
result: core.QAResult{Answer: "**a31 answer**"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// A3.1: Ask (not AskStream) + SendFinalCard
if !qa.called {
t.Fatal("Ask must be called (A3.1 path)")
}
if qa.streamCalled {
t.Fatal("AskStream must not be called (A3.1 path)")
}
if !card.called {
t.Fatal("SendFinalCard must be called (A3.1 path)")
}
if card.lastReq.Content != "**a31 answer**" {
t.Fatalf("card content = %q, want a31 answer", card.lastReq.Content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called when card succeeds")
}
}
func TestHandleStreamingGroupNotAtNoStart(t *testing.T) {
card := &fakeStreamingCard{startID: "track-group"}
qa := &fakeStreamingQA{}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
data := groupTextCallback()
data.IsInAtList = false
err := h.Handle(context.Background(), data)
if err != nil {
t.Fatalf("Handle: %v", err)
}
if card.startCalled {
t.Fatal("StartCard must not be called for non-@ group message")
}
if qa.called || qa.streamCalled {
t.Fatal("QA must not be called for non-@ group message")
}
if reply.called {
t.Fatal("SendMarkdown must not be called for non-@ group message")
}
}
func TestHandleStreamingImageDownloadFailureNoStart(t *testing.T) {
card := &fakeStreamingCard{startID: "track-img"}
qa := &fakeStreamingQA{}
reply := &fakeReply{}
downloader := &fakeImageDownloader{err: errors.New("download failed")}
h := newTestHandlerWithDownloader(t, qa, reply, downloader)
h.card = card
data := directPictureCallback()
data.DownloadCode = "broken-code"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if card.startCalled {
t.Fatal("StartCard must not be called on image download failure")
}
if qa.called || qa.streamCalled {
t.Fatal("QA must not be called on download failure")
}
if !reply.called || reply.lastText != imageErrorReply {
t.Fatalf("friendly reply=%q, want %q", reply.lastText, imageErrorReply)
}
}
func TestHandleStreamingQAEmptyAnswerConvergesErrorCard(t *testing.T) {
card := &fakeStreamingCard{startID: "track-empty"}
qa := &fakeStreamingQA{
chunks: []string{},
result: core.QAResult{Answer: ""},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.streamCalled {
t.Fatal("AskStream must be called")
}
// Empty answer: error card with qaErrorReply
last := card.updates[len(card.updates)-1]
if !last.isFinalize || !last.isError {
t.Fatal("empty answer must produce error card")
}
if last.content != qaErrorReply {
t.Fatalf("error card content = %q, want %q", last.content, qaErrorReply)
}
if reply.called {
t.Fatal("SendMarkdown must not be called when error card succeeds")
}
}
func TestHandleStreamingObserverIgnoresWhitespaceOnly(t *testing.T) {
card := &fakeStreamingCard{startID: "track-ws"}
qa := &fakeStreamingQA{
// The observer is called with cumulative content; whitespace-only
// chunks should not trigger updates.
chunks: []string{" ", " \n ", "Real"},
result: core.QAResult{Answer: " \n Real"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
// First non-whitespace update is "Real" (cumulated)
firstUpdate := card.updates[0]
if firstUpdate.content != " \n Real" {
t.Fatalf("first update content = %q, want cumulative whitespace plus Real", firstUpdate.content)
}
if firstUpdate.isFinalize || firstUpdate.isError {
t.Fatal("first update must not be finalize/error")
}
last := card.updates[len(card.updates)-1]
if !last.isFinalize || last.isError {
t.Fatal("last update must be finalize, not error")
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
func TestHandleStreamingStartFailsQAFailsMarkdownFriendly(t *testing.T) {
// Start fails → fallback to Ask → Ask also fails → friendly markdown
card := &fakeStreamingCard{startErr: errors.New("card API unavailable")}
qa := &fakeStreamingQA{
err: errors.New("secret weknora internal failure"),
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !card.startCalled {
t.Fatal("StartCard was not called")
}
if !qa.called {
t.Fatal("Ask (fallback) was not called")
}
if qa.streamCalled {
t.Fatal("AskStream must not be called")
}
if !reply.called {
t.Fatal("SendMarkdown must be called")
}
if !strings.Contains(reply.lastText, "暂时无法完成回答") {
t.Fatalf("friendly markdown = %q", reply.lastText)
}
if strings.Contains(reply.lastText, "weknora") || strings.Contains(reply.lastText, "secret") {
t.Fatalf("markdown leaks internal error: %q", reply.lastText)
}
}
func TestHandleStreamingFinalUpdateAlwaysFiresEvenWithoutIntermediate(t *testing.T) {
// No intermediate chunks (observer never called with non-empty content),
// but final update must still fire with the answer.
card := &fakeStreamingCard{startID: "track-noint"}
qa := &fakeStreamingQA{
chunks: []string{}, // no intermediate chunks
result: core.QAResult{Answer: "direct answer"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), directTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.streamCalled {
t.Fatal("AskStream must be called")
}
// Must have exactly one update: final
if len(card.updates) != 1 {
t.Fatalf("expected 1 update (final only), got %d: %+v", len(card.updates), card.updates)
}
u := card.updates[0]
if !u.isFinalize || u.isError {
t.Fatal("only update must be finalize, not error")
}
if u.content != "direct answer" {
t.Fatalf("content = %q, want direct answer", u.content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
func TestHandleStreamingGroupWithCard(t *testing.T) {
card := &fakeStreamingCard{startID: "track-group-ok"}
qa := &fakeStreamingQA{
chunks: []string{"group", " reply"},
result: core.QAResult{Answer: "group reply"},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
err := h.Handle(context.Background(), groupTextCallback())
if err != nil {
t.Fatalf("Handle: %v", err)
}
if !card.startCalled {
t.Fatal("StartCard was not called")
}
if card.startReq.ConversationType != core.ConversationGroup {
t.Fatalf("StartCard ConversationType = %q, want group", card.startReq.ConversationType)
}
if card.startReq.ExternalChatID != "cid-group-1" {
t.Fatalf("StartCard ExternalChatID = %q, want cid-group-1", card.startReq.ExternalChatID)
}
if !qa.streamCalled {
t.Fatal("AskStream was not called")
}
last := card.updates[len(card.updates)-1]
if !last.isFinalize || last.isError {
t.Fatal("last update must be finalize, not error")
}
if last.content != "group reply" {
t.Fatalf("final content = %q, want group reply", last.content)
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
// --- A3.3: safe progress events + asynchronous card coalescing ---
type fakeEventQA struct {
fakeStreamingQA
events []weknora.StreamEvent
eventCalled bool
}
func (f *fakeEventQA) AskEvents(_ context.Context, req core.QARequest, observer weknora.StreamObserver) (core.QAResult, error) {
f.eventCalled = true
f.lastReq = req
for _, event := range f.events {
if observer != nil {
observer(event)
}
}
return f.result, f.err
}
func TestRenderProgressEventUsesOnlySafeFixedText(t *testing.T) {
tests := []struct {
name string
event weknora.StreamEvent
want string
}{
{"understanding", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "query_understand"}, "正在理解问题…"},
{"understood", weknora.StreamEvent{ResponseType: "tool_result", ToolName: "query_understand"}, "问题理解完成\n\n正在检索知识库…"},
{"searching", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "knowledge_search"}, "正在检索知识库…"},
{"searched", weknora.StreamEvent{ResponseType: "tool_result", ToolName: "knowledge_search"}, "知识库检索完成\n\n正在生成答案…"},
{"references", weknora.StreamEvent{ResponseType: "references", ReferenceCount: 7}, "检索到 7 条相关内容\n\n正在生成答案…"},
{"thinking hidden", weknora.StreamEvent{ResponseType: "thinking"}, ""},
{"unknown tool hidden", weknora.StreamEvent{ResponseType: "tool_call", ToolName: "secret_tool"}, ""},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := renderProgressEvent(tt.event); got != tt.want {
t.Fatalf("renderProgressEvent=%q want %q", got, tt.want)
}
})
}
}
func TestHandleEventStreamingFinalizesLatestAnswerWithoutMarkdown(t *testing.T) {
rawAnswer := "完整答案[[ref id=\"c8\"]]"
card := &fakeStreamingCard{startID: "track-events"}
qa := &fakeEventQA{
fakeStreamingQA: fakeStreamingQA{result: core.QAResult{Answer: rawAnswer}},
events: []weknora.StreamEvent{
{ResponseType: "tool_call", ToolName: "query_understand"},
{ResponseType: "tool_call", ToolName: "knowledge_search"},
{ResponseType: "references", ReferenceCount: 3},
{ResponseType: "answer", FullAnswer: "部分[[ref"},
{ResponseType: "answer", FullAnswer: rawAnswer, Done: true},
},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
h.cardUpdateInterval = time.Hour
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatalf("Handle: %v", err)
}
if !qa.eventCalled || qa.streamCalled {
t.Fatalf("eventCalled=%v streamCalled=%v", qa.eventCalled, qa.streamCalled)
}
if card.startReq.Content != streamingPlaceholder {
t.Fatalf("placeholder=%q", card.startReq.Content)
}
if len(card.updates) != 1 {
t.Fatalf("stale async updates must be dropped before final: %+v", card.updates)
}
last := card.updates[0]
if last.content != "完整答案" || !last.isFinalize || last.isError {
t.Fatalf("final update=%+v", last)
}
if qa.result.Answer != rawAnswer {
t.Fatalf("raw QA answer mutated: %q", qa.result.Answer)
}
if reply.called {
t.Fatal("SendMarkdown must not be called")
}
}
func TestHandleEventStreamingErrorConvergesCard(t *testing.T) {
card := &fakeStreamingCard{startID: "track-event-error"}
qa := &fakeEventQA{
fakeStreamingQA: fakeStreamingQA{err: errors.New("private upstream failure")},
events: []weknora.StreamEvent{{ResponseType: "tool_call", ToolName: "knowledge_search"}, {ResponseType: "error", Done: true}},
}
reply := &fakeReply{}
h := newTestHandlerWithStreaming(t, qa, reply, card)
h.cardUpdateInterval = time.Hour
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatalf("Handle: %v", err)
}
last := card.updates[len(card.updates)-1]
if last.content != qaErrorReply || !last.isFinalize || !last.isError {
t.Fatalf("error final=%+v", last)
}
if strings.Contains(last.content, "private") || reply.called {
t.Fatalf("error leaked or markdown duplicated: content=%q markdown=%v", last.content, reply.called)
}
}
type deadlineFinalCard struct{}
func (deadlineFinalCard) SendFinalCard(context.Context, CardRequest) (string, error) {
return "track-deadline", nil
}
func (deadlineFinalCard) StartCard(context.Context, CardRequest) (string, error) {
return "track-deadline", nil
}
func (deadlineFinalCard) UpdateCard(ctx context.Context, _ string, _ string, isFinalize, _ bool) error {
if !isFinalize {
return nil
}
<-ctx.Done()
return ctx.Err()
}
type contextCheckingReply struct {
called bool
contextErr error
}
func (r *contextCheckingReply) SendMarkdown(ctx context.Context, _, _, _ string) error {
r.called = true
r.contextErr = ctx.Err()
return r.contextErr
}
func TestHandleEventStreamingFinalTimeoutUsesFreshMarkdownContext(t *testing.T) {
qa := &fakeEventQA{
fakeStreamingQA: fakeStreamingQA{result: core.QAResult{Answer: "完整答案"}},
events: []weknora.StreamEvent{{ResponseType: "answer", FullAnswer: "完整答案", Done: true}},
}
reply := &contextCheckingReply{}
h, err := NewHandlerWithOptions(
TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"},
qa,
reply,
HandlerOptions{CardSender: deadlineFinalCard{}},
)
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
h.cardUpdateInterval = time.Hour
h.finalDeliveryTimeout = 5 * time.Millisecond
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatalf("Markdown fallback must receive a fresh context: %v", err)
}
if !reply.called {
t.Fatal("Markdown fallback was not called")
}
if reply.contextErr != nil {
t.Fatalf("Markdown fallback received expired context: %v", reply.contextErr)
}
}
func deliveryQAResult() core.QAResult {
return core.QAResult{
TurnID: "turn-delivery-1", AnswerMessageID: "answer-delivery-1",
DeliveryStatus: core.DeliveryGenerated, Answer: "delivery answer",
}
}
func requireDelivery(t *testing.T, deliveries []core.DeliveryUpdate, status, method, providerID, failureCode string) {
t.Helper()
if len(deliveries) != 1 {
t.Fatalf("delivery updates=%d want=1: %+v", len(deliveries), deliveries)
}
got := deliveries[0]
if got.TenantKey != "tenant-a" || got.Channel != "dingtalk" ||
got.CorrelationID != "turn-delivery-1" || got.AnswerMessageID != "answer-delivery-1" ||
got.Status != status || got.DeliveryMethod != method ||
got.ProviderMessageID != providerID || got.FailureCode != failureCode {
t.Fatalf("unexpected delivery update: %+v", got)
}
}
func TestDeliveryAuditNonStreamingCardSuccess(t *testing.T) {
qa := &fakeQA{result: deliveryQAResult()}
h := newTestHandlerWithCard(t, qa, &fakeReply{}, &fakeCard{returnID: "track-delivery-1"})
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
requireDelivery(t, qa.deliveries, core.DeliverySent, core.DeliveryMethodCard, "track-delivery-1", "")
}
func TestDeliveryAuditNonStreamingMarkdownFallbackAndFailure(t *testing.T) {
t.Run("markdown succeeds", func(t *testing.T) {
qa := &fakeQA{result: deliveryQAResult()}
h := newTestHandlerWithCard(t, qa, &fakeReply{}, &fakeCard{err: errors.New("card failed")})
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
requireDelivery(t, qa.deliveries, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
})
t.Run("both fail", func(t *testing.T) {
qa := &fakeQA{result: deliveryQAResult()}
h := newTestHandlerWithCard(t, qa, &fakeReply{err: errors.New("markdown failed")}, &fakeCard{err: errors.New("card failed")})
if err := h.Handle(context.Background(), directTextCallback()); err == nil {
t.Fatal("expected delivery error")
}
requireDelivery(t, qa.deliveries, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
})
}
func TestDeliveryAuditFailureAfterSuccessfulSendDoesNotTriggerRedelivery(t *testing.T) {
qa := &fakeQA{result: deliveryQAResult(), deliveryErr: errors.New("database unavailable")}
reply := &fakeReply{}
card := &fakeCard{returnID: "track-delivery-1"}
h := newTestHandlerWithCard(t, qa, reply, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatalf("successful channel delivery must remain successful: %v", err)
}
if !card.called || reply.called || len(qa.deliveries) != 1 {
t.Fatalf("delivery was duplicated: card=%v markdown=%v audits=%d", card.called, reply.called, len(qa.deliveries))
}
}
func TestDeliveryAuditSuppressesSentReplayBeforeNonStreamingDelivery(t *testing.T) {
result := deliveryQAResult()
result.Replayed = true
result.DeliveryStatus = core.DeliverySent
qa := &fakeQA{result: result}
reply := &fakeReply{}
card := &fakeCard{returnID: "must-not-send"}
h := newTestHandlerWithCard(t, qa, reply, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if card.called || reply.called || len(qa.deliveries) != 0 {
t.Fatalf("sent replay must have zero delivery side effects: card=%v markdown=%v audits=%d", card.called, reply.called, len(qa.deliveries))
}
}
func TestDeliveryAuditStreamingCardAndMarkdown(t *testing.T) {
t.Run("final card succeeds", func(t *testing.T) {
qa := &fakeStreamingQA{result: deliveryQAResult(), chunks: []string{"delivery answer"}}
card := &fakeStreamingCard{startID: "stream-track-1"}
h := newTestHandlerWithStreaming(t, qa, &fakeReply{}, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
requireDelivery(t, qa.deliveries, core.DeliverySent, core.DeliveryMethodCard, "stream-track-1", "")
})
t.Run("final card fails markdown succeeds", func(t *testing.T) {
qa := &fakeStreamingQA{result: deliveryQAResult(), chunks: []string{"delivery answer"}}
card := &fakeStreamingCard{startID: "stream-track-2", updateErr: errors.New("update failed")}
h := newTestHandlerWithStreaming(t, qa, &fakeReply{}, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
requireDelivery(t, qa.deliveries, core.DeliverySent, core.DeliveryMethodMarkdown, "", "")
})
t.Run("final card and markdown fail", func(t *testing.T) {
qa := &fakeStreamingQA{result: deliveryQAResult(), chunks: []string{"delivery answer"}}
card := &fakeStreamingCard{startID: "stream-track-3", updateErr: errors.New("update failed")}
h := newTestHandlerWithStreaming(t, qa, &fakeReply{err: errors.New("markdown failed")}, card)
if err := h.Handle(context.Background(), directTextCallback()); err == nil {
t.Fatal("expected delivery error")
}
requireDelivery(t, qa.deliveries, core.DeliveryFailed, "", "", core.DeliveryFailureChannelDelivery)
})
}
func TestDeliveryAuditEventStreamingProductionPath(t *testing.T) {
qa := &fakeEventQA{
fakeStreamingQA: fakeStreamingQA{result: deliveryQAResult()},
events: []weknora.StreamEvent{{ResponseType: "answer", FullAnswer: "delivery answer", Done: true}},
}
card := &fakeStreamingCard{startID: "event-track-1"}
h := newTestHandlerWithStreaming(t, qa, &fakeReply{}, card)
h.cardUpdateInterval = time.Hour
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
requireDelivery(t, qa.deliveries, core.DeliverySent, core.DeliveryMethodCard, "event-track-1", "")
}
func TestHandlePassesConversationTitleToQARequest(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
t.Run("group conversation title propagated", func(t *testing.T) {
cb := groupTextCallback()
cb.ConversationTitle = "项目讨论群"
if err := h.Handle(context.Background(), cb); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ConversationTitle != "项目讨论群" {
t.Fatalf("ConversationTitle = %q, want 项目讨论群", qa.lastReq.ConversationTitle)
}
})
t.Run("direct conversation title is empty", func(t *testing.T) {
qa2 := &fakeQA{result: core.QAResult{Answer: "ok"}}
h2 := newTestHandler(t, qa2, &fakeReply{})
cb := directTextCallback()
cb.ConversationTitle = "should not appear"
if err := h2.Handle(context.Background(), cb); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa2.lastReq.ConversationTitle != "" {
t.Fatalf("ConversationTitle = %q, want empty for direct", qa2.lastReq.ConversationTitle)
}
})
}
// TestActorUnionIDSnapshotPropagation verifies the actor_union_id_snapshot
// is populated from the directory profile UnionID when available.
func TestActorUnionIDSnapshotPropagation(t *testing.T) {
t.Run("resolved profile with union ID captures snapshot", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{profile: directory.Profile{
Name: "张三", UnionID: "union-abc-123", DepartmentName: "技术部", Region: "APAC",
}}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ActorUnionIDSnapshot != "union-abc-123" {
t.Fatalf("ActorUnionIDSnapshot = %q, want union-abc-123", qa.lastReq.ActorUnionIDSnapshot)
}
if qa.lastReq.SenderName != "张三" {
t.Fatalf("SenderName = %q, want 张三", qa.lastReq.SenderName)
}
if qa.lastReq.TriggerPersonSnapshot != "钉钉昵称" {
t.Fatalf("TriggerPersonSnapshot = %q, want 钉钉昵称", qa.lastReq.TriggerPersonSnapshot)
}
})
t.Run("blank profile union leaves snapshot empty", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{profile: directory.Profile{
Name: "张三", UnionID: "", DepartmentName: "技术部", Region: "APAC",
}}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ActorUnionIDSnapshot != "" {
t.Fatalf("ActorUnionIDSnapshot = %q, want empty", qa.lastReq.ActorUnionIDSnapshot)
}
})
t.Run("directory failure leaves union snapshot empty", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{err: errors.New("directory unavailable")}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ActorUnionIDSnapshot != "" {
t.Fatalf("ActorUnionIDSnapshot = %q, want empty on directory failure", qa.lastReq.ActorUnionIDSnapshot)
}
})
t.Run("no directory leaves union snapshot empty", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
h := newTestHandler(t, qa, reply)
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.ActorUnionIDSnapshot != "" {
t.Fatalf("ActorUnionIDSnapshot = %q, want empty without directory", qa.lastReq.ActorUnionIDSnapshot)
}
})
}
// TestTriggerPersonSnapshotRegression proves the trigger_person_snapshot
// contract: the callback SenderNick becomes TriggerPersonSnapshot, the
// directory official Name remains SenderName, and a blank callback nick
// falls back to the official name.
func TestTriggerPersonSnapshotRegression(t *testing.T) {
t.Run("callback nick becomes trigger person snapshot", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{profile: directory.Profile{Name: "张三", DepartmentName: "技术部", Region: "APAC"}}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = "钉钉昵称"
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.TriggerPersonSnapshot != "钉钉昵称" {
t.Fatalf("TriggerPersonSnapshot = %q, want 钉钉昵称", qa.lastReq.TriggerPersonSnapshot)
}
if qa.lastReq.SenderName != "张三" {
t.Fatalf("SenderName = %q, want 张三", qa.lastReq.SenderName)
}
})
t.Run("blank callback nick falls back to official name", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: "ok"}}
reply := &fakeReply{}
profiles := &fakeDirectory{profile: directory.Profile{Name: "张三", DepartmentName: "技术部", Region: "APAC"}}
h, err := NewHandlerWithOptions(TenantConfig{TenantKey: "tenant-a", Channel: "dingtalk"}, qa, reply, HandlerOptions{Directory: profiles})
if err != nil {
t.Fatalf("NewHandlerWithOptions: %v", err)
}
data := directTextCallback()
data.SenderNick = ""
if err := h.Handle(context.Background(), data); err != nil {
t.Fatalf("Handle: %v", err)
}
if qa.lastReq.TriggerPersonSnapshot != "张三" {
t.Fatalf("TriggerPersonSnapshot = %q, want 张三 on blank nick", qa.lastReq.TriggerPersonSnapshot)
}
if qa.lastReq.SenderName != "张三" {
t.Fatalf("SenderName = %q, want 张三", qa.lastReq.SenderName)
}
})
}
func TestHandleStreamingRewritesOnlyFinalOutboundImageContent(t *testing.T) {
card := &fakeStreamingCard{startID: "track-image-final"}
resource := "resource://AbCdEfGhIjKlMnOpQrStUv"
answer := "操作说明\n![步骤图](" + resource + ")"
qa := &fakeStreamingQA{chunks: []string{answer}, result: core.QAResult{Answer: answer}}
reply := &fakeReply{}
rewriter := &fakeOutboundRewriter{from: resource, to: "https://img.example/signed.jpg"}
h := newTestHandlerWithStreaming(t, qa, reply, card)
h.outboundRewriter = rewriter
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if len(card.updates) < 2 {
t.Fatalf("updates=%d", len(card.updates))
}
if strings.Contains(card.updates[0].content, resource) {
t.Fatalf("streaming intermediate content leaked internal resource: %q", card.updates[0].content)
}
final := card.updates[len(card.updates)-1]
if !final.isFinalize || strings.Contains(final.content, resource) || !strings.Contains(final.content, "https://img.example/signed.jpg") {
t.Fatalf("final content=%q finalize=%t", final.content, final.isFinalize)
}
if rewriter.calls != 1 {
t.Fatalf("rewrite calls=%d, want 1", rewriter.calls)
}
if rewriter.partialCalls == 0 {
t.Fatal("streaming intermediate content was not sanitized")
}
}
func TestHandleFiltersReferenceMarkersAtDingTalkDisplayBoundary(t *testing.T) {
rawAnswer := "结论[[ref id=\"c2\"]][[ref id=\"c4\"]]。"
wantDisplay := "结论。"
t.Run("final card", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: rawAnswer}}
reply := &fakeReply{}
card := &fakeCard{returnID: "track-reference-filter"}
h := newTestHandlerWithCard(t, qa, reply, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if card.lastReq.Content != wantDisplay {
t.Fatalf("card content=%q, want %q", card.lastReq.Content, wantDisplay)
}
if qa.result.Answer != rawAnswer {
t.Fatalf("raw QA answer mutated: %q", qa.result.Answer)
}
})
t.Run("markdown fallback", func(t *testing.T) {
qa := &fakeQA{result: core.QAResult{Answer: rawAnswer}}
reply := &fakeReply{}
card := &fakeCard{err: errors.New("card unavailable")}
h := newTestHandlerWithCard(t, qa, reply, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if reply.lastText != wantDisplay {
t.Fatalf("markdown content=%q, want %q", reply.lastText, wantDisplay)
}
if qa.result.Answer != rawAnswer {
t.Fatalf("raw QA answer mutated: %q", qa.result.Answer)
}
})
}
func TestHandleStreamingHoldsBackPartialReferenceMarkers(t *testing.T) {
rawAnswer := "答案正文[[ref id=\"c2\"]]继续。"
qa := &fakeStreamingQA{
chunks: []string{"答案正文[[ref", " id=\"c2\"]]继续。"},
result: core.QAResult{Answer: rawAnswer},
}
reply := &fakeReply{}
card := &fakeStreamingCard{startID: "track-stream-reference-filter"}
h := newTestHandlerWithStreaming(t, qa, reply, card)
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
if len(card.updates) < 2 {
t.Fatalf("updates=%d, want at least one partial plus final", len(card.updates))
}
for i, update := range card.updates {
if strings.Contains(update.content, "[[ref") {
t.Fatalf("update[%d] leaked reference marker: %q", i, update.content)
}
}
if card.updates[0].content != "答案正文" {
t.Fatalf("first partial=%q, want dangling marker held back", card.updates[0].content)
}
final := card.updates[len(card.updates)-1]
if !final.isFinalize || final.content != "答案正文继续。" {
t.Fatalf("final content=%q finalize=%t", final.content, final.isFinalize)
}
if qa.result.Answer != rawAnswer {
t.Fatalf("raw QA answer mutated: %q", qa.result.Answer)
}
}
func TestHandleStreamingPublishesTableOnlyOnFinalUpdate(t *testing.T) {
answer := "说明\n\n| 检查项 | 操作要求 |\n| --- | --- |\n| 接地检查 | 上电前确认 |\n\n结论"
qa := &fakeStreamingQA{
chunks: []string{
"说明\n\n",
"| 检查项",
" | 操作要求 |\n",
"| --- | --",
"- |\n",
"| 接地检查 | 上电前确",
"认 |\n\n结论",
},
result: core.QAResult{Answer: answer},
}
reply := &fakeReply{}
card := &fakeStreamingCard{startID: "track-stream-table"}
h := newTestHandlerWithStreaming(t, qa, reply, card)
callCount := int64(0)
h.now = func() time.Time {
callCount++
return time.Unix(0, callCount*int64(time.Second))
}
h.cardUpdateInterval = time.Millisecond
if err := h.Handle(context.Background(), directTextCallback()); err != nil {
t.Fatal(err)
}
var partials []string
for _, update := range card.updates {
if !update.isFinalize {
partials = append(partials, update.content)
}
}
wantPartials := []string{"说明\n\n"}
if !reflect.DeepEqual(partials, wantPartials) {
t.Fatalf("partial updates=%q, want only pre-table stream %q", partials, wantPartials)
}
final := card.updates[len(card.updates)-1]
if !final.isFinalize || final.content != answer {
t.Fatalf("final=%+v, want unchanged complete answer", final)
}
if qa.result.Answer != answer {
t.Fatalf("raw QA answer mutated: %q", qa.result.Answer)
}
}