209 lines
8.6 KiB
Go
209 lines
8.6 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"encoding/base64"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.ipao.vip/rogee/creator-hub/internal/creator"
|
|
hub "git.ipao.vip/rogee/creator-hub/internal/environment"
|
|
"github.com/gofiber/fiber/v3"
|
|
)
|
|
|
|
func TestCreatorHelperBranches(t *testing.T) {
|
|
if got := flattenActionEvidence(map[string]string{}, "evidence", "text"); got != 1 {
|
|
t.Fatalf("flatten string count = %d", got)
|
|
}
|
|
values := map[string]string{}
|
|
if got := flattenActionEvidence(values, "evidence", map[string]any{"nested": "value", "empty": "", "number": 1}); got != 1 || values["evidence.nested"] != "value" {
|
|
t.Fatalf("flatten map = %d, %#v", got, values)
|
|
}
|
|
if got := flattenActionEvidence(values, "evidence", []any{"ignored"}); got != 0 {
|
|
t.Fatalf("flatten unsupported count = %d", got)
|
|
}
|
|
if _, err := verifyCreatorPlatformIdentity(context.Background(), "unsupported", hub.Gateway{}, hub.EnvironmentContext{}, "key"); !errors.Is(err, creator.ErrUnavailable) {
|
|
t.Fatalf("unsupported identity platform = %v", err)
|
|
}
|
|
if _, _, err := newCreatorCollector(context.Background(), creator.PlatformDouyin, hub.Gateway{}, hub.EnvironmentContext{}, "", "target", "", creator.SourceCompetitor, "id"); !errors.Is(err, creator.ErrInvalid) {
|
|
t.Fatalf("missing collector key = %v", err)
|
|
}
|
|
if _, err := decodeBase64("not-base64"); err == nil {
|
|
t.Fatal("invalid base64 must fail")
|
|
}
|
|
encoded := base64.StdEncoding.EncodeToString([]byte("media"))
|
|
if data, err := decodeBase64(encoded); err != nil || string(data) != "media" {
|
|
t.Fatalf("decode media = %q, %v", data, err)
|
|
}
|
|
if err := validateDouyinCompetitor(creator.CompetitorInput{Platform: creator.PlatformDouyin}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := validateDouyinCompetitor(creator.CompetitorInput{Platform: "unsupported"}); !errors.Is(err, creator.ErrInvalid) {
|
|
t.Fatalf("unsupported competitor platform = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreatorAccountMetricSnapshotFailurePropagates(t *testing.T) {
|
|
// 浏览器不可用（网关零值）时快照拉取失败必须向上返回错误，绝不静默吞掉；
|
|
// 调度器对 syncCreatorOwned 的失败会记 warning 日志（runCreatorScheduleOnce）。
|
|
SetGatewayChannelStore(newMemoryChannelStore())
|
|
if err := recordCreatorAccountMetricSnapshot(context.Background(), nil, creatorGatewayBrowser{}, "account-1"); err == nil {
|
|
t.Fatal("account metric snapshot failure must propagate error")
|
|
}
|
|
}
|
|
|
|
func TestCreatorPageQueryValidation(t *testing.T) {
|
|
app := fiber.New()
|
|
app.Get("/", func(c fiber.Ctx) error {
|
|
page, pageSize, enabled, err := creatorPageQuery(c)
|
|
if err != nil {
|
|
return creatorError(c, err)
|
|
}
|
|
return c.JSON(map[string]any{"page": page, "page_size": pageSize, "enabled": enabled})
|
|
})
|
|
for _, query := range []string{"", "?page=2&page_size=10&enabled=false"} {
|
|
response, err := app.Test(httptest.NewRequest(http.MethodGet, "/"+query, nil))
|
|
if err != nil || response.StatusCode != http.StatusOK {
|
|
t.Fatalf("valid query %s: %d %v", query, response.StatusCode, err)
|
|
}
|
|
}
|
|
for _, query := range []string{"?page=bad"} {
|
|
response, err := app.Test(httptest.NewRequest(http.MethodGet, "/"+query, nil))
|
|
if err != nil || response.StatusCode != http.StatusBadRequest {
|
|
t.Fatalf("invalid query %s: %d %v", query, response.StatusCode, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreatorControlPlaneGuards(t *testing.T) {
|
|
ctx := context.Background()
|
|
if _, _, err := newCreatorCollector(ctx, "unsupported", hub.Gateway{}, hub.EnvironmentContext{}, "viewer", "target", "", creator.SourceOwned, "id"); !errors.Is(err, creator.ErrUnavailable) {
|
|
t.Fatalf("unsupported collector platform = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCreatorSchedulerAndPreviewGuards(t *testing.T) {
|
|
ctx := context.Background()
|
|
checks := []struct {
|
|
name string
|
|
call func() error
|
|
}{
|
|
{"verify account", func() error { _, err := verifyCreatorAccount(ctx, nil, nil, nil, "account"); return err }},
|
|
{"login QR", func() error { _, err := creatorLoginQRCode(ctx, nil, nil, nil, "account"); return err }},
|
|
{"preview competitor", func() error {
|
|
_, err := previewDouyinCompetitor(ctx, nil, nil, nil, "account", creator.CompetitorInput{})
|
|
return err
|
|
}},
|
|
{"sync competitor", func() error { _, err := syncCreatorCompetitor(ctx, nil, nil, "competitor"); return err }},
|
|
{"sync due competitor", func() error {
|
|
_, err := syncCreatorCompetitorDue(ctx, nil, nil, "competitor")
|
|
return err
|
|
}},
|
|
{"sync owned", func() error { return syncCreatorOwned(ctx, nil, nil, nil, "account", time.Now()) }},
|
|
{"select collection account", func() error {
|
|
_, err := creatorCollectionAccount(ctx, nil, nil, nil, creator.PlatformDouyin)
|
|
return err
|
|
}},
|
|
}
|
|
for _, check := range checks {
|
|
if err := check.call(); err == nil {
|
|
t.Fatalf("%s unexpectedly succeeded", check.name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreatorGatewayBrowserHistoryAndMedia(t *testing.T) {
|
|
cleanup := startFakeChannelGateway(t, 1, "creator-helper-key-0001", map[string]string{
|
|
"POST /v1/browsers/browser/douyin/messages": "200 " + `{"status":"succeeded","account_uid":"account","history_source":"douyin","messages":[]}`,
|
|
"POST /v1/browsers/browser/douyin/media": "200 " + `{"status":200,"content_type":"video/mp4","body_base64":"` + base64.StdEncoding.EncodeToString([]byte("video")) + `"}`,
|
|
})
|
|
defer cleanup()
|
|
browser := creatorGatewayBrowser{gateway: hub.Gateway{ID: 1, Name: "gw-test"}, environment: hub.EnvironmentContext{Env: hub.Env{Alias: "browser"}, RuntimeID: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", RuntimeNetworkID: "native-dddddddddddddddddddddddddddddddd", BindingVersion: 1}}
|
|
history, err := browser.MessageHistory(context.Background(), "account", "peer", "", 10)
|
|
if err != nil || history.Status != "succeeded" || history.HistorySource != "douyin" {
|
|
t.Fatalf("history = %+v, %v", history, err)
|
|
}
|
|
if _, err := browser.MessageHistory(context.Background(), "", "peer", "", 10); err == nil {
|
|
t.Fatal("empty history identity must fail")
|
|
}
|
|
path := filepath.Join(t.TempDir(), "media.mp4")
|
|
if err := browser.Media(context.Background(), "https://video.example/media", path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if data, err := os.ReadFile(path); err != nil || string(data) != "video" {
|
|
t.Fatalf("media output = %q, %v", data, err)
|
|
}
|
|
}
|
|
|
|
func TestCreatorGatewayBrowserIdentity(t *testing.T) {
|
|
cleanup := startFakeChannelGateway(t, 2, "creator-helper-key-0002", map[string]string{
|
|
"POST /v1/browsers/browser/douyin/identity": `{"uid":"verified-uid"}`,
|
|
})
|
|
defer cleanup()
|
|
browser := creatorGatewayBrowser{
|
|
gateway: hub.Gateway{ID: 2, Name: "gw-test"},
|
|
environment: hub.EnvironmentContext{Env: hub.Env{Alias: "browser"}, RuntimeID: "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", RuntimeNetworkID: "native-dddddddddddddddddddddddddddddddd", BindingVersion: 1},
|
|
}
|
|
uid, err := browser.Identity(context.Background(), "expected-key")
|
|
if err != nil || uid != "verified-uid" {
|
|
t.Fatalf("identity = %q, %v", uid, err)
|
|
}
|
|
}
|
|
|
|
// startFakeChannelGateway 启动平台侧会话服务器并接入假网关，返回收尾函数。
|
|
// routes 值为 "<status> <body>"（缺省 status=200）；onTask 可选用于断言收到的请求帧。
|
|
func startFakeChannelGateway(t *testing.T, gatewayID int64, accessKey string, routes map[string]string, onTask ...func(task taskFrame)) (cleanup func()) {
|
|
t.Helper()
|
|
store := newMemoryChannelStore(hub.Gateway{ID: gatewayID, Name: "gw-test", AccessKey: accessKey})
|
|
SetGatewayChannelStore(store)
|
|
server := (&gatewayChannelTestServer{store: store, URL: startChannelServer(t, store)})
|
|
var fake *fakeChannelGateway
|
|
fake = connectFakeGateway(t, server.URL, accessKey, func(task taskFrame) *TaskResult {
|
|
for _, hook := range onTask {
|
|
hook(task)
|
|
}
|
|
route, ok := routes[task.Method+" "+task.Path]
|
|
if !ok {
|
|
return &TaskResult{Status: 404, Error: "no route for " + task.Method + " " + task.Path}
|
|
}
|
|
if route == "disconnect" {
|
|
// 模拟网关在任务处理中断开出站连接：会话失败，任务由平台终态化。
|
|
_ = fake.conn.Close()
|
|
return nil
|
|
}
|
|
status, body := 200, route
|
|
if space := strings.Index(route, " "); space > 0 && isAllDigits(route[:space]) {
|
|
status = int(routeInt(route[:space]))
|
|
body = route[space+1:]
|
|
}
|
|
return &TaskResult{Status: status, Body: []byte(body)}
|
|
})
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) && sessionByGateway(gatewayID) == nil {
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
return func() {
|
|
}
|
|
}
|
|
|
|
func isAllDigits(raw string) bool {
|
|
for _, c := range raw {
|
|
if c < '0' || c > '9' {
|
|
return false
|
|
}
|
|
}
|
|
return len(raw) > 0
|
|
}
|
|
|
|
func routeInt(raw string) int64 {
|
|
value, _ := strconv.ParseInt(raw, 10, 32)
|
|
return value
|
|
}
|