Files
dobotai-platform/internal/channels/dingtalk/feedback_test.go
2026-07-27 11:54:34 +08:00

374 lines
16 KiB
Go

package dingtalk
import (
"context"
"encoding/json"
"errors"
"strings"
"testing"
sdkcard "github.com/open-dingtalk/dingtalk-stream-sdk-go/card"
"github.com/open-dingtalk/dingtalk-stream-sdk-go/payload"
"github.com/open-dingtalk/dingtalk-stream-sdk-go/utils"
feedbackdomain "gitea.zheromiku.top/Weknora/dobotai-platform/internal/feedback"
)
type fakeFeedbackService struct {
calls int
command feedbackdomain.Command
result feedbackdomain.Result
err error
}
func (f *fakeFeedbackService) Apply(_ context.Context, command feedbackdomain.Command) (feedbackdomain.Result, error) {
f.calls++
f.command = command
return f.result, f.err
}
func cardRequest(action string) *sdkcard.CardRequest {
return &sdkcard.CardRequest{
OutTrackId: "track-1",
UserId: "user-1",
CorpId: "must-not-be-stored",
Content: "must-not-be-stored",
Extension: "must-not-be-stored",
CardActionData: sdkcard.PrivateCardActionData{CardPrivateData: sdkcard.CardPrivateData{
ActionIdList: []string{action},
Params: map[string]any{
"tenant_key": "attacker", "turn_id": "attacker", "user_id": "attacker", "token": "attacker",
},
}},
}
}
func TestCardFeedbackMapsNativeLike(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Created: true, Value: feedbackdomain.ValueUp}}
handler, err := NewCardFeedbackHandler(service)
if err != nil {
t.Fatal(err)
}
request := cardRequest(ActionNativeFeedback)
request.CardActionData.CardPrivateData.Params = map[string]any{
"variableKey": "node_ocmrjfmlsra_likeOrDislike",
"variableValue": "like",
}
response, err := handler.HandleSDK(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if service.calls != 1 || service.command.Value != feedbackdomain.ValueUp || service.command.ReasonCode != feedbackdomain.ReasonEmpty {
t.Fatalf("calls=%d command=%+v", service.calls, service.command)
}
if response == nil || response.UserPrivateData == nil || response.UserPrivateData.CardParamMap["feedbackSelected"] != feedbackdomain.ValueUp {
t.Fatalf("response=%+v", response)
}
}
func TestCardFeedbackMapsNativeDislike(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Created: true, Value: feedbackdomain.ValueDown}}
handler, err := NewCardFeedbackHandler(service)
if err != nil {
t.Fatal(err)
}
request := cardRequest(ActionNativeFeedback)
request.CardActionData.CardPrivateData.Params = map[string]any{
"variableKey": "node_ocmrjfmlsra_likeOrDislike",
"variableValue": "dislike",
}
response, err := handler.HandleSDK(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if service.calls != 1 || service.command.Value != feedbackdomain.ValueDown || service.command.ReasonCode != feedbackdomain.ReasonEmpty {
t.Fatalf("calls=%d command=%+v", service.calls, service.command)
}
if response == nil || response.UserPrivateData == nil ||
response.UserPrivateData.CardParamMap["showFeedbackReasons"] != "false" ||
response.UserPrivateData.CardParamMap["feedbackMessage"] != "感谢反馈,我们会继续改进" {
t.Fatalf("response=%+v", response)
}
}
func TestCardFeedbackMapsNativeReasons(t *testing.T) {
tests := []struct {
tag string
reason string
}{
{"1", feedbackdomain.ReasonContentMismatch},
{"2", feedbackdomain.ReasonContentIncomplete},
{"3", feedbackdomain.ReasonIllogical},
{"4", feedbackdomain.ReasonFactualError},
{"5", feedbackdomain.ReasonSensitiveContent},
{"6", feedbackdomain.ReasonAnswerNotWanted},
}
for _, tc := range tests {
t.Run(tc.tag, func(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Changed: true, Value: feedbackdomain.ValueDown, ReasonCode: tc.reason}}
handler, err := NewCardFeedbackHandler(service)
if err != nil {
t.Fatal(err)
}
request := cardRequest(ActionNativeFeedback)
request.CardActionData.CardPrivateData.Params = map[string]any{
"variableKey": "node_ocmrjfmlsra_dislikeTags",
"variableValue": []any{tc.tag},
}
response, err := handler.HandleSDK(context.Background(), request)
if err != nil {
t.Fatal(err)
}
if service.calls != 1 || service.command.Value != feedbackdomain.ValueDown || service.command.ReasonCode != tc.reason {
t.Fatalf("calls=%d command=%+v", service.calls, service.command)
}
if response == nil || response.UserPrivateData == nil || response.UserPrivateData.CardParamMap["feedbackReasonSelected"] != tc.reason {
t.Fatalf("response=%+v", response)
}
})
}
}
func TestCardFeedbackRejectsMalformedNativeEvents(t *testing.T) {
tests := []struct {
name string
actions []string
params map[string]any
}{
{name: "empty node ID", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node__likeOrDislike", "variableValue": "like"}},
{name: "unknown suffix", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_other", "variableValue": "like"}},
{name: "unknown vote", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_likeOrDislike", "variableValue": "LIKE"}},
{name: "wrong vote type", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_likeOrDislike", "variableValue": []any{"like"}}},
{name: "empty tags", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_dislikeTags", "variableValue": []any{}}},
{name: "multiple tags", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_dislikeTags", "variableValue": []any{"1", "2"}}},
{name: "numeric tag", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_dislikeTags", "variableValue": []any{1}}},
{name: "unknown tag", actions: []string{ActionNativeFeedback}, params: map[string]any{"variableKey": "node_x_dislikeTags", "variableValue": []any{"7"}}},
{name: "ambiguous actions", actions: []string{ActionNativeFeedback, ActionFeedbackUp}, params: map[string]any{"variableKey": "node_x_likeOrDislike", "variableValue": "like"}},
{name: "nil params", actions: []string{ActionNativeFeedback}},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
service := &fakeFeedbackService{}
handler, _ := NewCardFeedbackHandler(service)
request := cardRequest("unknown")
request.CardActionData.CardPrivateData.ActionIdList = tc.actions
request.CardActionData.CardPrivateData.Params = tc.params
response, err := handler.HandleSDK(context.Background(), request)
if err != nil || response == nil || service.calls != 0 {
t.Fatalf("response=%+v error=%v calls=%d", response, err, service.calls)
}
if response.CardUpdateOptions != nil || response.UserPrivateData != nil {
t.Fatalf("safe ACK must not update card: %+v", response)
}
})
}
}
func TestCardFeedbackMapsCustomExactReasons(t *testing.T) {
tests := []struct {
action string
reason string
}{
{ActionReasonContentMismatch, feedbackdomain.ReasonContentMismatch},
{ActionReasonContentIncomplete, feedbackdomain.ReasonContentIncomplete},
{ActionReasonIllogical, feedbackdomain.ReasonIllogical},
{ActionReasonFactualError, feedbackdomain.ReasonFactualError},
{ActionReasonSensitiveContent, feedbackdomain.ReasonSensitiveContent},
{ActionReasonAnswerNotWanted, feedbackdomain.ReasonAnswerNotWanted},
}
for _, tc := range tests {
t.Run(tc.action, func(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Changed: true, Value: feedbackdomain.ValueDown, ReasonCode: tc.reason}}
handler, _ := NewCardFeedbackHandler(service)
response, err := handler.HandleSDK(context.Background(), cardRequest(tc.action))
if err != nil {
t.Fatal(err)
}
if service.calls != 1 || service.command.Value != feedbackdomain.ValueDown || service.command.ReasonCode != tc.reason {
t.Fatalf("calls=%d command=%+v", service.calls, service.command)
}
if response == nil || response.UserPrivateData == nil || response.UserPrivateData.CardParamMap["feedbackReasonSelected"] != tc.reason {
t.Fatalf("response=%+v", response)
}
})
}
}
func TestCardFeedbackMapsWhitelistedActions(t *testing.T) {
tests := []struct {
action string
value string
reason string
showReasons string
message string
}{
{ActionFeedbackUp, feedbackdomain.ValueUp, "", "false", "感谢反馈"},
{ActionFeedbackDown, feedbackdomain.ValueDown, "", "false", "感谢反馈,我们会继续改进"},
{ActionReasonIncorrect, feedbackdomain.ValueDown, feedbackdomain.ReasonIncorrect, "false", "感谢反馈,我们会继续改进"},
{ActionReasonNotResolved, feedbackdomain.ValueDown, feedbackdomain.ReasonNotResolved, "false", "感谢反馈,我们会继续改进"},
{ActionReasonIrrelevant, feedbackdomain.ValueDown, feedbackdomain.ReasonIrrelevant, "false", "感谢反馈,我们会继续改进"},
{ActionReasonUnclear, feedbackdomain.ValueDown, feedbackdomain.ReasonUnclear, "false", "感谢反馈,我们会继续改进"},
{ActionReasonOutdated, feedbackdomain.ValueDown, feedbackdomain.ReasonOutdated, "false", "感谢反馈,我们会继续改进"},
{ActionReasonOther, feedbackdomain.ValueDown, feedbackdomain.ReasonOther, "false", "感谢反馈,我们会继续改进"},
}
for _, tc := range tests {
t.Run(tc.action, func(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Created: true, Value: tc.value, ReasonCode: tc.reason}}
handler, err := NewCardFeedbackHandler(service)
if err != nil {
t.Fatal(err)
}
response, err := handler.HandleSDK(context.Background(), cardRequest(tc.action))
if err != nil {
t.Fatal(err)
}
if service.calls != 1 {
t.Fatalf("calls=%d", service.calls)
}
if service.command.ExternalActorID != "user-1" || service.command.OutTrackID != "track-1" || service.command.Value != tc.value || service.command.ReasonCode != tc.reason || service.command.Source != feedbackdomain.SourceDingTalkCard {
t.Fatalf("command=%+v", service.command)
}
if response == nil || response.CardUpdateOptions == nil || !response.CardUpdateOptions.UpdatePrivateDataByKey || response.CardUpdateOptions.UpdateCardDataByKey || response.CardData != nil || response.UserPrivateData == nil {
t.Fatalf("response=%+v", response)
}
params := response.UserPrivateData.CardParamMap
if params["feedbackSelected"] != tc.value || params["feedbackReasonSelected"] != tc.reason || params["showFeedbackReasons"] != tc.showReasons || params["feedbackMessage"] != tc.message {
t.Fatalf("params=%+v", params)
}
})
}
}
func TestCardFeedbackUnknownOrAmbiguousActionIsSafeAck(t *testing.T) {
for _, actions := range [][]string{{"unknown"}, {ActionFeedbackUp, ActionFeedbackDown}, nil} {
service := &fakeFeedbackService{}
handler, _ := NewCardFeedbackHandler(service)
request := cardRequest("unknown")
request.CardActionData.CardPrivateData.ActionIdList = actions
response, err := handler.HandleSDK(context.Background(), request)
if err != nil || response == nil || service.calls != 0 {
t.Fatalf("actions=%v response=%+v error=%v calls=%d", actions, response, err, service.calls)
}
if response.CardUpdateOptions != nil || response.UserPrivateData != nil {
t.Fatalf("safe ACK must not update card: %+v", response)
}
}
}
func TestCardFeedbackValidationAndServiceError(t *testing.T) {
if _, err := NewCardFeedbackHandler(nil); err == nil {
t.Fatal("nil service must fail")
}
serviceErr := errors.New("store failed")
service := &fakeFeedbackService{err: serviceErr}
handler, _ := NewCardFeedbackHandler(service)
if _, err := handler.HandleSDK(context.Background(), nil); err == nil {
t.Fatal("nil request must fail")
}
response, err := handler.HandleSDK(context.Background(), cardRequest(ActionFeedbackUp))
if !errors.Is(err, serviceErr) || response != nil || service.calls != 1 {
t.Fatalf("response=%+v error=%v calls=%d", response, err, service.calls)
}
}
func TestStreamClientRegistersOptionalCardFeedbackRouter(t *testing.T) {
config := StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "tenant"}
chatHandler := mustTestHandler(t)
feedbackHandler, _ := NewCardFeedbackHandler(&fakeFeedbackService{})
client, err := NewStreamClient(config, chatHandler, feedbackHandler)
if err != nil {
t.Fatal(err)
}
if _, err := client.inner.GetHandler(utils.SubscriptionTypeKCallback, payload.CardInstanceCallbackTopic); err != nil {
t.Fatalf("card callback router not registered: %v", err)
}
withoutFeedback, err := NewStreamClient(config, chatHandler)
if err != nil {
t.Fatal(err)
}
if _, err := withoutFeedback.inner.GetHandler(utils.SubscriptionTypeKCallback, payload.CardInstanceCallbackTopic); err == nil {
t.Fatal("card callback router must remain optional for old callers")
}
if _, err := NewStreamClient(config, chatHandler, nil); err == nil {
t.Fatal("explicit nil feedback handler must fail")
}
if _, err := NewStreamClient(config, chatHandler, feedbackHandler, feedbackHandler); err == nil {
t.Fatal("multiple feedback handlers must fail")
}
}
func TestStreamCardRouterHandlesNativeSDKDataFrameEnvelope(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Changed: true, Value: feedbackdomain.ValueDown, ReasonCode: feedbackdomain.ReasonContentMismatch}}
feedbackHandler, _ := NewCardFeedbackHandler(service)
client, err := NewStreamClient(
StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "tenant"},
mustTestHandler(t), feedbackHandler,
)
if err != nil {
t.Fatal(err)
}
router, err := client.inner.GetHandler(utils.SubscriptionTypeKCallback, payload.CardInstanceCallbackTopic)
if err != nil {
t.Fatal(err)
}
actionData, _ := json.Marshal(map[string]any{"cardPrivateData": map[string]any{
"actionIds": []string{ActionNativeFeedback},
"params": map[string]any{
"variableKey": "node_ocmrjfmlsra_dislikeTags",
"variableValue": []string{"1"},
},
}})
outer, _ := json.Marshal(map[string]any{
"outTrackId": "track-native-frame", "userId": "user-native-frame", "content": string(actionData),
"corpId": "must-not-be-used", "extension": "must-not-be-used",
})
frameResponse, err := router(context.Background(), &payload.DataFrame{Data: string(outer)})
if err != nil {
t.Fatal(err)
}
if frameResponse == nil || frameResponse.Code != payload.DataFrameResponseStatusCodeKOK {
t.Fatalf("frame response=%+v", frameResponse)
}
if service.calls != 1 || service.command.ExternalActorID != "user-native-frame" || service.command.OutTrackID != "track-native-frame" || service.command.Value != feedbackdomain.ValueDown || service.command.ReasonCode != feedbackdomain.ReasonContentMismatch {
t.Fatalf("service calls=%d command=%+v", service.calls, service.command)
}
}
func TestStreamCardRouterHandlesRealSDKDataFrameEnvelope(t *testing.T) {
service := &fakeFeedbackService{result: feedbackdomain.Result{Created: true, Value: feedbackdomain.ValueDown, ReasonCode: feedbackdomain.ReasonNotResolved}}
feedbackHandler, _ := NewCardFeedbackHandler(service)
client, err := NewStreamClient(
StreamConfig{ClientID: "id", ClientSecret: "secret", TenantKey: "tenant"},
mustTestHandler(t), feedbackHandler,
)
if err != nil {
t.Fatal(err)
}
router, err := client.inner.GetHandler(utils.SubscriptionTypeKCallback, payload.CardInstanceCallbackTopic)
if err != nil {
t.Fatal(err)
}
actionData, _ := json.Marshal(map[string]any{"cardPrivateData": map[string]any{
"actionIds": []string{ActionReasonNotResolved},
"params": map[string]any{"tenant_key": "attacker", "token": "attacker"},
}})
outer, _ := json.Marshal(map[string]any{
"outTrackId": "track-frame", "userId": "user-frame", "content": string(actionData),
"corpId": "must-not-be-used", "extension": "must-not-be-used",
})
frameResponse, err := router(context.Background(), &payload.DataFrame{Data: string(outer)})
if err != nil {
t.Fatal(err)
}
if frameResponse == nil || frameResponse.Code != payload.DataFrameResponseStatusCodeKOK {
t.Fatalf("frame response=%+v", frameResponse)
}
if service.calls != 1 || service.command.ExternalActorID != "user-frame" || service.command.OutTrackID != "track-frame" || service.command.Value != feedbackdomain.ValueDown || service.command.ReasonCode != feedbackdomain.ReasonNotResolved {
t.Fatalf("service calls=%d command=%+v", service.calls, service.command)
}
if strings.Contains(frameResponse.Data, "attacker") || !strings.Contains(frameResponse.Data, "feedbackReasonSelected") {
t.Fatalf("unsafe or incomplete frame response: %s", frameResponse.Data)
}
}