374 lines
16 KiB
Go
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)
|
|
}
|
|
}
|