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