mirror of
https://github.com/silenceper/wechat.git
synced 2026-11-16 05:12:03 +08:00
* feat: add aispeech dialog APIs * test: fix aispeech lint failures * test: satisfy aispeech interfacer lint
423 lines
12 KiB
Go
423 lines
12 KiB
Go
package dialog
|
|
|
|
import (
|
|
stdcontext "context"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/silenceper/wechat/v2/aispeech/config"
|
|
aispeechContext "github.com/silenceper/wechat/v2/aispeech/context"
|
|
"github.com/silenceper/wechat/v2/aispeech/encryptor"
|
|
"github.com/silenceper/wechat/v2/cache"
|
|
)
|
|
|
|
const (
|
|
testAccessToken = "access-token"
|
|
testAccount = "admin"
|
|
testAESKey = "q1Os1ZMe0nG28KUEx9lg3HjK7V5QyXvi212fzsgDqgz"
|
|
testAppID = "appid"
|
|
testImportRequest = "import-rid"
|
|
testImportTaskID = "task-import"
|
|
testPublishTaskID = "task-publish"
|
|
testQuery = "hello"
|
|
testQueryAnswer = "hello answer"
|
|
testQueryRequestID = "query-rid"
|
|
testToken = "token"
|
|
testTokenRequestID = "token-rid"
|
|
)
|
|
|
|
type emptyAccessTokenHandle struct{}
|
|
|
|
func (emptyAccessTokenHandle) GetAccessToken() (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func (emptyAccessTokenHandle) GetAccessTokenContext(ctx stdcontext.Context) (string, error) {
|
|
return "", nil
|
|
}
|
|
|
|
func TestAccessTokenCache(t *testing.T) {
|
|
var tokenRequests int
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
tokenRequests++
|
|
body := readBody(t, r)
|
|
assertSign(t, r, testToken, body)
|
|
if r.Header.Get("X-APPID") != testAppID {
|
|
t.Fatalf("bad X-APPID: %s", r.Header.Get("X-APPID"))
|
|
}
|
|
_, _ = w.Write([]byte(accessTokenResponse("rid")))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
ak := NewAccessToken(&config.Config{
|
|
AppID: testAppID,
|
|
Token: testToken,
|
|
Account: testAccount,
|
|
BaseURL: srv.URL,
|
|
Cache: cache.NewMemory(),
|
|
})
|
|
|
|
token, err := ak.GetAccessToken()
|
|
if err != nil {
|
|
t.Fatalf("GetAccessToken error: %v", err)
|
|
}
|
|
if token != testAccessToken {
|
|
t.Fatalf("bad token: %s", token)
|
|
}
|
|
token, err = ak.GetAccessToken()
|
|
if err != nil {
|
|
t.Fatalf("GetAccessToken second error: %v", err)
|
|
}
|
|
if token != testAccessToken {
|
|
t.Fatalf("bad token second: %s", token)
|
|
}
|
|
if tokenRequests != 1 {
|
|
t.Fatalf("token requests = %d, want 1", tokenRequests)
|
|
}
|
|
}
|
|
|
|
func TestAccessTokenCacheByAccount(t *testing.T) {
|
|
var tokenRequests int
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
tokenRequests++
|
|
body := readBody(t, r)
|
|
assertSign(t, r, testToken, body)
|
|
|
|
var req AccessTokenRequest
|
|
if err := json.Unmarshal(body, &req); err != nil {
|
|
t.Fatalf("bad token body: %v", err)
|
|
}
|
|
_, _ = w.Write([]byte(accountAccessTokenResponse(req.Account)))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
memory := cache.NewMemory()
|
|
cfgA := testDialogConfig(srv.URL)
|
|
cfgA.Account = "admin-a"
|
|
cfgA.Cache = memory
|
|
cfgB := testDialogConfig(srv.URL)
|
|
cfgB.Account = "admin-b"
|
|
cfgB.Cache = memory
|
|
|
|
tokenA, err := NewAccessToken(cfgA).GetAccessToken()
|
|
if err != nil {
|
|
t.Fatalf("GetAccessToken A error: %v", err)
|
|
}
|
|
tokenB, err := NewAccessToken(cfgB).GetAccessToken()
|
|
if err != nil {
|
|
t.Fatalf("GetAccessToken B error: %v", err)
|
|
}
|
|
if tokenA != "admin-a-token" || tokenB != "admin-b-token" {
|
|
t.Fatalf("bad tokens: %s %s", tokenA, tokenB)
|
|
}
|
|
if tokenRequests != 2 {
|
|
t.Fatalf("token requests = %d, want 2", tokenRequests)
|
|
}
|
|
}
|
|
|
|
func TestAccessTokenEmptyToken(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, _ = w.Write([]byte(`{"code":0,"msg":"success","request_id":"rid","data":{"access_token":""}}`))
|
|
}))
|
|
defer srv.Close()
|
|
|
|
ak := NewAccessToken(&config.Config{
|
|
AppID: testAppID,
|
|
Token: testToken,
|
|
BaseURL: srv.URL,
|
|
Cache: cache.NewMemory(),
|
|
})
|
|
|
|
if _, err := ak.GetAccessToken(); err == nil {
|
|
t.Fatal("GetAccessToken should return error")
|
|
}
|
|
}
|
|
|
|
func TestDialogAPIs(t *testing.T) {
|
|
srv := newDialogAPITestServer(t)
|
|
defer srv.Close()
|
|
|
|
d := newTestDialog(srv.URL)
|
|
assertDialogImportJSON(t, d)
|
|
assertDialogPublish(t, d)
|
|
assertDialogProgress(t, d)
|
|
assertDialogFetchAsync(t, d)
|
|
assertDialogQuery(t, d)
|
|
}
|
|
|
|
func TestDialogEmptyAccessToken(t *testing.T) {
|
|
d := NewDialog(&aispeechContext.Context{
|
|
Config: &config.Config{
|
|
AESKey: testAESKey,
|
|
},
|
|
AccessTokenContextHandle: emptyAccessTokenHandle{},
|
|
})
|
|
|
|
if _, err := d.ImportJSON(&ImportJSONRequest{}); err == nil {
|
|
t.Fatal("ImportJSON should return error")
|
|
}
|
|
if _, err := d.Publish(); err == nil {
|
|
t.Fatal("Publish should return error")
|
|
}
|
|
if _, err := d.Query(&QueryRequest{}); err == nil {
|
|
t.Fatal("Query should return error")
|
|
}
|
|
}
|
|
|
|
func TestDialogAPIError(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case tokenPath:
|
|
_, _ = w.Write([]byte(accessTokenResponse(testTokenRequestID)))
|
|
case importJSONPath:
|
|
_, _ = w.Write([]byte(`{"code":210202,"msg":"forbidden","request_id":"import-rid","data":{"reason":"forbidden"}}`))
|
|
default:
|
|
t.Fatalf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
d := newTestDialog(srv.URL)
|
|
|
|
_, err := d.ImportJSON(&ImportJSONRequest{})
|
|
if err == nil {
|
|
t.Fatal("ImportJSON should return error")
|
|
}
|
|
apiErr, ok := err.(*APIError)
|
|
if !ok {
|
|
t.Fatalf("ImportJSON error should be *APIError but %T", err)
|
|
}
|
|
if apiErr.Code != 210202 || apiErr.Msg != "forbidden" || apiErr.RequestID != testImportRequest {
|
|
t.Fatalf("bad api error: %+v", apiErr)
|
|
}
|
|
if string(apiErr.Data) != `{"reason":"forbidden"}` {
|
|
t.Fatalf("bad api error data: %s", apiErr.Data)
|
|
}
|
|
}
|
|
|
|
func TestQueryPlainJSONError(t *testing.T) {
|
|
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
switch r.URL.Path {
|
|
case tokenPath:
|
|
_, _ = w.Write([]byte(accessTokenResponse(testTokenRequestID)))
|
|
case queryPath:
|
|
_, _ = w.Write([]byte(`{"code":110002,"msg":"bad param","request_id":"query-rid"}`))
|
|
default:
|
|
t.Fatalf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
}))
|
|
defer srv.Close()
|
|
|
|
d := newTestDialog(srv.URL)
|
|
|
|
_, err := d.Query(&QueryRequest{Query: testQuery})
|
|
if err == nil {
|
|
t.Fatal("Query should return error")
|
|
}
|
|
apiErr, ok := err.(*APIError)
|
|
if !ok {
|
|
t.Fatalf("Query error should be *APIError but %T", err)
|
|
}
|
|
if apiErr.Code != 110002 || apiErr.RequestID != testQueryRequestID {
|
|
t.Fatalf("bad api error: %+v", apiErr)
|
|
}
|
|
}
|
|
|
|
func newDialogAPITestServer(t *testing.T) *httptest.Server {
|
|
t.Helper()
|
|
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
body := readBody(t, r)
|
|
assertSign(t, r, testToken, body)
|
|
switch r.URL.Path {
|
|
case tokenPath:
|
|
handleDialogToken(t, w, r)
|
|
case importJSONPath:
|
|
handleDialogImport(t, w, r, body)
|
|
case publishPath:
|
|
handleDialogPublish(t, w, r, body)
|
|
case effectiveProgressPath:
|
|
assertToken(t, r)
|
|
_, _ = w.Write([]byte(`{"code":0,"msg":"success","request_id":"progress-rid","data":{"end_time":"","progress":100,"status":1}}`))
|
|
case fetchAsyncPath:
|
|
assertToken(t, r)
|
|
_, _ = w.Write([]byte(`{"code":0,"msg":"success","request_id":"fetch-rid","data":{"state":2,"msg":"","progress":100,"start":1,"end":2,"url":"","success_skill_info":[{"id":1,"name":"AAA","intents":[{"id":2,"name":"BBB"}]}]}}`))
|
|
case queryPath:
|
|
handleDialogQuery(t, w, r, body)
|
|
default:
|
|
t.Fatalf("unexpected path: %s", r.URL.Path)
|
|
}
|
|
}))
|
|
}
|
|
|
|
func handleDialogToken(t *testing.T, w io.Writer, r *http.Request) {
|
|
t.Helper()
|
|
if r.Header.Get("X-APPID") != testAppID {
|
|
t.Fatalf("bad X-APPID: %s", r.Header.Get("X-APPID"))
|
|
}
|
|
_, _ = w.Write([]byte(accessTokenResponse(testTokenRequestID)))
|
|
}
|
|
|
|
func handleDialogImport(t *testing.T, w io.Writer, r *http.Request, body []byte) {
|
|
t.Helper()
|
|
assertToken(t, r)
|
|
var req ImportJSONRequest
|
|
if err := json.Unmarshal(body, &req); err != nil {
|
|
t.Fatalf("bad import body: %v", err)
|
|
}
|
|
if len(req.Data) != 1 || req.Data[0].Skill != "pre-sale" {
|
|
t.Fatalf("bad import request: %+v", req)
|
|
}
|
|
_, _ = w.Write([]byte(`{"code":0,"msg":"success","request_id":"import-rid","data":{"task_id":"task-import"}}`))
|
|
}
|
|
|
|
func handleDialogPublish(t *testing.T, w io.Writer, r *http.Request, body []byte) {
|
|
t.Helper()
|
|
assertToken(t, r)
|
|
if len(body) != 0 {
|
|
t.Fatalf("publish body should be empty: %s", body)
|
|
}
|
|
_, _ = w.Write([]byte(`{"code":0,"msg":"success","request_id":"publish-rid","data":{"task_id":"task-publish"}}`))
|
|
}
|
|
|
|
func handleDialogQuery(t *testing.T, w io.Writer, r *http.Request, body []byte) {
|
|
t.Helper()
|
|
assertToken(t, r)
|
|
if !strings.HasPrefix(r.Header.Get("Content-Type"), "text/plain") {
|
|
t.Fatalf("bad content type: %s", r.Header.Get("Content-Type"))
|
|
}
|
|
plain, err := encryptor.Decrypt(testAESKey, string(body))
|
|
if err != nil {
|
|
t.Fatalf("decrypt query body error: %v", err)
|
|
}
|
|
var req QueryRequest
|
|
if err = json.Unmarshal(plain, &req); err != nil {
|
|
t.Fatalf("bad query body: %v", err)
|
|
}
|
|
if req.Query != testQuery {
|
|
t.Fatalf("bad query: %+v", req)
|
|
}
|
|
_, _ = w.Write([]byte(encryptQueryResponse(t)))
|
|
}
|
|
|
|
func assertDialogImportJSON(t *testing.T, d *Dialog) {
|
|
t.Helper()
|
|
res, err := d.ImportJSON(&ImportJSONRequest{
|
|
Mode: 0,
|
|
Data: []BotIntent{{
|
|
Skill: "pre-sale",
|
|
Intent: "business-hours",
|
|
Disable: false,
|
|
Questions: []string{"when are you open"},
|
|
Answers: []string{"9:00-18:00"},
|
|
}},
|
|
})
|
|
if err != nil || res.TaskID != testImportTaskID || res.RequestID != testImportRequest {
|
|
t.Fatalf("ImportJSON = %+v, %v", res, err)
|
|
}
|
|
}
|
|
|
|
func assertDialogPublish(t *testing.T, d *Dialog) {
|
|
t.Helper()
|
|
res, err := d.Publish()
|
|
if err != nil || res.TaskID != testPublishTaskID {
|
|
t.Fatalf("Publish = %+v, %v", res, err)
|
|
}
|
|
}
|
|
|
|
func assertDialogProgress(t *testing.T, d *Dialog) {
|
|
t.Helper()
|
|
res, err := d.GetEffectiveProgress(&EffectiveProgressRequest{Env: "online"})
|
|
if err != nil || res.Progress != 100 {
|
|
t.Fatalf("GetEffectiveProgress = %+v, %v", res, err)
|
|
}
|
|
}
|
|
|
|
func assertDialogFetchAsync(t *testing.T, d *Dialog) {
|
|
t.Helper()
|
|
res, err := d.FetchAsync(&FetchAsyncRequest{TaskID: testImportTaskID})
|
|
if err != nil || res.State != 2 || len(res.SuccessSkillInfo) != 1 {
|
|
t.Fatalf("FetchAsync = %+v, %v", res, err)
|
|
}
|
|
}
|
|
|
|
func assertDialogQuery(t *testing.T, d *Dialog) {
|
|
t.Helper()
|
|
res, err := d.Query(&QueryRequest{Query: testQuery, Env: "online"})
|
|
if err != nil || res.Answer != testQueryAnswer || res.RequestID != testQueryRequestID {
|
|
t.Fatalf("Query = %+v, %v", res, err)
|
|
}
|
|
}
|
|
|
|
func newTestDialog(baseURL string) *Dialog {
|
|
cfg := testDialogConfig(baseURL)
|
|
return NewDialog(&aispeechContext.Context{
|
|
Config: cfg,
|
|
AccessTokenContextHandle: NewAccessToken(cfg),
|
|
})
|
|
}
|
|
|
|
func testDialogConfig(baseURL string) *config.Config {
|
|
return &config.Config{
|
|
AppID: testAppID,
|
|
Token: testToken,
|
|
AESKey: testAESKey,
|
|
Account: testAccount,
|
|
BaseURL: baseURL,
|
|
Cache: cache.NewMemory(),
|
|
}
|
|
}
|
|
|
|
func accountAccessTokenResponse(account string) string {
|
|
return `{"code":0,"msg":"success","request_id":"rid","data":{"access_token":"` + account + `-token"}}`
|
|
}
|
|
|
|
func accessTokenResponse(requestID string) string {
|
|
return `{"code":0,"msg":"success","request_id":"` + requestID + `","data":{"access_token":"` + testAccessToken + `"}}`
|
|
}
|
|
|
|
func encryptQueryResponse(t *testing.T) string {
|
|
t.Helper()
|
|
cipherText, err := encryptor.Encrypt(testAESKey, []byte(queryResponse()))
|
|
if err != nil {
|
|
t.Fatalf("encrypt response error: %v", err)
|
|
}
|
|
return cipherText
|
|
}
|
|
|
|
func queryResponse() string {
|
|
return `{"code":0,"msg":"success","request_id":"query-rid","data":{"answer":"hello answer","answer_type":"text","skill_name":"skill","intent_name":"intent","msg_id":"msg","status":"FAQ","slots":[{"name":"n","value":"v","norm":"v"}]}}`
|
|
}
|
|
|
|
func readBody(t *testing.T, r *http.Request) []byte {
|
|
t.Helper()
|
|
body, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
t.Fatalf("read body error: %v", err)
|
|
}
|
|
return body
|
|
}
|
|
|
|
func assertToken(t *testing.T, r *http.Request) {
|
|
t.Helper()
|
|
if r.Header.Get("X-OPENAI-TOKEN") != testAccessToken {
|
|
t.Fatalf("bad X-OPENAI-TOKEN: %s", r.Header.Get("X-OPENAI-TOKEN"))
|
|
}
|
|
}
|
|
|
|
func assertSign(t *testing.T, r *http.Request, token string, body []byte) {
|
|
t.Helper()
|
|
timestamp, err := strconv.ParseInt(r.Header.Get("timestamp"), 10, 64)
|
|
if err != nil {
|
|
t.Fatalf("bad timestamp: %v", err)
|
|
}
|
|
want := encryptor.Sign(token, timestamp, r.Header.Get("nonce"), body)
|
|
if got := r.Header.Get("sign"); got != want {
|
|
t.Fatalf("bad sign: got %s want %s body %s", got, want, body)
|
|
}
|
|
}
|