598 lines
31 KiB
Go
598 lines
31 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"database/sql"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
account "git.ipao.vip/rogee/creator-hub/internal/account"
|
|
"git.ipao.vip/rogee/creator-hub/internal/creator"
|
|
hub "git.ipao.vip/rogee/creator-hub/internal/environment"
|
|
"github.com/gofiber/fiber/v3"
|
|
)
|
|
|
|
func TestCreatorReadRoutesAgainstPostgres(t *testing.T) {
|
|
databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
|
|
if databaseURL == "" {
|
|
t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator route coverage")
|
|
}
|
|
ctx := context.Background()
|
|
databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
|
|
phaseAStore, err := account.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = phaseAStore.Close() })
|
|
hubStore, err := hub.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = hubStore.Close() })
|
|
creatorStore, err := creator.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = creatorStore.Close() })
|
|
app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
|
|
for _, path := range []string{
|
|
"/api/creator/settings", "/api/creator/accounts", "/api/creator/competitors", "/api/creator/relations",
|
|
"/api/creator/accounts/route-account/strategies", "/api/creator/rules", "/api/creator/rule-results", "/api/creator/leads",
|
|
"/api/creator/works", "/api/creator/works?page=1&page_size=10", "/api/creator/comments", "/api/creator/comments?page=1&page_size=10",
|
|
"/api/creator/listener-boundaries", "/api/creator/events", "/api/creator/events?page=1&page_size=10",
|
|
"/api/creator/listeners", "/api/creator/operations", "/api/creator/conversations",
|
|
} {
|
|
response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreatorRouteValidationCoverage(t *testing.T) {
|
|
databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
|
|
if databaseURL == "" {
|
|
t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator route coverage")
|
|
}
|
|
ctx := context.Background()
|
|
databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
|
|
phaseAStore, err := account.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = phaseAStore.Close() })
|
|
hubStore, err := hub.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = hubStore.Close() })
|
|
creatorStore, err := creator.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = creatorStore.Close() })
|
|
credentials := &testCredentialBridge{values: make(map[string]string)}
|
|
if err := phaseAStore.CreateAccount(ctx, account.Account{
|
|
ID: "route-account", Name: "Route Account", Platform: creator.PlatformDouyin,
|
|
PlatformAccountKey: "route-platform", Tags: []string{}, Cookies: "",
|
|
CredentialReference: account.CredentialReference{ID: "route-account-credential", Provider: "os_keyring"},
|
|
CredentialKey: "creatorhub/route-account/cookies",
|
|
}, credentials); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
|
|
for _, path := range []string{
|
|
"/api/creator/accounts/route-account/profile", "/api/creator/accounts/route-account/strategies",
|
|
} {
|
|
response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
for _, path := range []string{
|
|
"/api/creator/works/missing/metrics", "/api/creator/rule-results?comment_id=missing",
|
|
"/api/creator/events/missing/strategy-trace", "/api/creator/conversations/missing/messages",
|
|
} {
|
|
response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
|
|
if response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
for _, path := range []string{
|
|
"/api/creator/competitors/missing", "/api/creator/works/missing",
|
|
"/api/creator/comments/missing", "/api/creator/rules/missing",
|
|
"/api/creator/operations/missing", "/api/creator/operations/missing/verification",
|
|
} {
|
|
response := do(app, http.MethodGet, path, "", "operator", "unit-test-password")
|
|
if response.Code != http.StatusNotFound {
|
|
t.Fatalf("GET %s returned %d: %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
response := do(app, http.MethodGet, "/api/creator/works/missing/material", "", "operator", "unit-test-password")
|
|
if response.Code != http.StatusBadRequest {
|
|
t.Fatalf("GET material for missing work returned %d: %s", response.Code, response.Body.String())
|
|
}
|
|
for _, route := range []struct {
|
|
method string
|
|
path string
|
|
}{
|
|
{http.MethodPut, "/api/creator/settings"},
|
|
{http.MethodPut, "/api/creator/accounts/missing/profile"},
|
|
{http.MethodPost, "/api/creator/accounts/missing/login-result"},
|
|
{http.MethodPost, "/api/creator/accounts/missing/big-account"},
|
|
{http.MethodPost, "/api/creator/relations"},
|
|
{http.MethodPost, "/api/creator/accounts/missing/strategies"},
|
|
{http.MethodPost, "/api/creator/strategies/missing/enable"},
|
|
{http.MethodPost, "/api/creator/strategies/missing/disable"},
|
|
{http.MethodDelete, "/api/creator/strategies/missing"},
|
|
{http.MethodPut, "/api/creator/strategies/missing"},
|
|
{http.MethodPost, "/api/creator/competitors/preview"},
|
|
{http.MethodPost, "/api/creator/competitors"},
|
|
{http.MethodPost, "/api/creator/competitors/missing/pause"},
|
|
{http.MethodPost, "/api/creator/competitors/missing/resume"},
|
|
{http.MethodPost, "/api/creator/competitors/missing/sync"},
|
|
{http.MethodPost, "/api/creator/xiaohongshu/search"},
|
|
{http.MethodPost, "/api/creator/xiaohongshu/detail"},
|
|
{http.MethodPost, "/api/creator/works/missing/metrics"},
|
|
{http.MethodPost, "/api/creator/works/missing/material/select"},
|
|
{http.MethodPost, "/api/creator/works/missing/material/process"},
|
|
{http.MethodPost, "/api/creator/works/missing/material/rewrite/confirm"},
|
|
{http.MethodPost, "/api/creator/works/missing/material/rewrite/generate"},
|
|
{http.MethodPut, "/api/creator/works/missing/material/rewrite"},
|
|
{http.MethodPost, "/api/creator/rules"},
|
|
{http.MethodPut, "/api/creator/rules/missing"},
|
|
{http.MethodPost, "/api/creator/rules/missing/enable"},
|
|
{http.MethodPost, "/api/creator/rules/missing/disable"},
|
|
{http.MethodPost, "/api/creator/comments/analyze"},
|
|
{http.MethodPost, "/api/creator/comments/missing/analyze"},
|
|
{http.MethodPost, "/api/creator/events/missing/display"},
|
|
{http.MethodPost, "/api/creator/operations"},
|
|
{http.MethodPost, "/api/creator/operations/missing/execute"},
|
|
{http.MethodPost, "/api/creator/conversations/missing/sync"},
|
|
{http.MethodPost, "/api/creator/messages/send"},
|
|
} {
|
|
response := do(app, route.method, route.path, "{", "operator", "unit-test-password")
|
|
if response.Code != http.StatusBadRequest && response.Code != http.StatusNotFound && response.Code != http.StatusNoContent && response.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("%s %s returned %d for invalid JSON: %s", route.method, route.path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
for _, path := range []string{
|
|
"/api/creator/works", "/api/creator/comments", "/api/creator/events", "/api/creator/events/process", "/api/creator/messages",
|
|
} {
|
|
response := do(app, http.MethodPost, path, `{}`, "operator", "unit-test-password")
|
|
if response.Code != http.StatusConflict {
|
|
t.Fatalf("POST %s accepted public platform input: %d", path, response.Code)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreatorFixtureRoutesPostgres(t *testing.T) {
|
|
databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
|
|
if databaseURL == "" {
|
|
t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run creator fixture coverage")
|
|
}
|
|
ctx := context.Background()
|
|
databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
|
|
phaseAStore, err := account.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = phaseAStore.Close() })
|
|
hubStore, err := hub.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = hubStore.Close() })
|
|
creatorStore, err := creator.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = creatorStore.Close() })
|
|
credentials := &testCredentialBridge{values: make(map[string]string)}
|
|
if err := phaseAStore.CreateAccount(ctx, account.Account{
|
|
ID: "fixture-account", Name: "Fixture Account", Platform: creator.PlatformDouyin,
|
|
PlatformAccountKey: "fixture-platform", Tags: []string{}, Cookies: "",
|
|
CredentialReference: account.CredentialReference{ID: "fixture-credential", Provider: "os_keyring"},
|
|
CredentialKey: "creatorhub/fixture-account/cookies",
|
|
}, credentials); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := phaseAStore.CreateAccount(ctx, account.Account{
|
|
ID: "fixture-small", Name: "Fixture Small", Platform: creator.PlatformDouyin,
|
|
PlatformAccountKey: "fixture-small-platform", Tags: []string{}, Cookies: "",
|
|
CredentialReference: account.CredentialReference{ID: "fixture-small-credential", Provider: "os_keyring"},
|
|
CredentialKey: "creatorhub/fixture-small/cookies",
|
|
}, credentials); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := creatorStore.EnsureAccountProfile(ctx, "fixture-small"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
app := newHandlerWithCreator(t.TempDir(), "operator", "unit-test-password", phaseAStore, hubStore, nil, creatorStore)
|
|
idFrom := func(response *httptest.ResponseRecorder) string {
|
|
var value struct {
|
|
ID string `json:"id"`
|
|
}
|
|
if err := json.Unmarshal(response.Body.Bytes(), &value); err != nil || value.ID == "" {
|
|
t.Fatalf("response has no ID: %s (%v)", response.Body.String(), err)
|
|
}
|
|
return value.ID
|
|
}
|
|
workBody := `{"platform":"douyin","work_key":"fixture-work","source_type":"owned","source_id":"fixture-account","author_name":"author","title":"title","body":"body","published_at":"2024-01-01T00:00:00Z","published_at_status":"verified"}`
|
|
workResponse := do(app, http.MethodPost, "/api/creator/test/works", workBody, "operator", "unit-test-password")
|
|
if workResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture work: %d %s", workResponse.Code, workResponse.Body.String())
|
|
}
|
|
workID := idFrom(workResponse)
|
|
if response := do(app, http.MethodPost, "/api/creator/test/works", workBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("deduplicate fixture work: %d %s", response.Code, response.Body.String())
|
|
}
|
|
for _, path := range []string{"/api/creator/works/" + workID, "/api/creator/works/" + workID + "/metrics", "/api/creator/works/" + workID + "/material"} {
|
|
if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
metricBody := `{"likes":2,"comments_count":1,"shares":1}`
|
|
if response := do(app, http.MethodPost, "/api/creator/works/"+workID+"/metrics", metricBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("record fixture metric: %d %s", response.Code, response.Body.String())
|
|
}
|
|
materialResponse := do(app, http.MethodPost, "/api/creator/works/"+workID+"/material/select", `{}`, "operator", "unit-test-password")
|
|
if materialResponse.Code != http.StatusCreated && materialResponse.Code != http.StatusOK {
|
|
t.Fatalf("select fixture material: %d %s", materialResponse.Code, materialResponse.Body.String())
|
|
}
|
|
if _, claimed, err := creatorStore.ClaimMaterialStep(ctx, workID, "download", "fixture-material-token"); err != nil || !claimed {
|
|
t.Fatalf("claim fixture material download: claimed=%v err=%v", claimed, err)
|
|
}
|
|
if _, err := setMaterialFailure(ctx, creatorStore, workID, "download", "fixture-material-token", errors.New("fixture download failed")); err != nil {
|
|
t.Fatalf("record fixture material failure: %v", err)
|
|
}
|
|
commentBody := `{"platform":"douyin","comment_key":"fixture-comment","work_id":"` + workID + `","author_uid":"peer","author_name":"Peer","content":"hello","comment_type":"top_level","published_at":"2024-01-01T00:00:00Z"}`
|
|
commentResponse := do(app, http.MethodPost, "/api/creator/test/comments", commentBody, "operator", "unit-test-password")
|
|
if commentResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture comment: %d %s", commentResponse.Code, commentResponse.Body.String())
|
|
}
|
|
commentID := idFrom(commentResponse)
|
|
if response := do(app, http.MethodPost, "/api/creator/test/comments", commentBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("deduplicate fixture comment: %d %s", response.Code, response.Body.String())
|
|
}
|
|
if response := do(app, http.MethodGet, "/api/creator/comments/"+commentID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET fixture comment: %d %s", response.Code, response.Body.String())
|
|
}
|
|
profileBody := `{"real_name_status":"unknown","business_status":"normal","cooldown_seconds":60}`
|
|
if response := do(app, http.MethodPut, "/api/creator/accounts/fixture-account/profile", profileBody, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("update fixture profile: %d %s", response.Code, response.Body.String())
|
|
}
|
|
if response := do(app, http.MethodPost, "/api/creator/accounts/fixture-account/big-account", `{"enabled":true}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("enable fixture big account: %d %s", response.Code, response.Body.String())
|
|
}
|
|
for _, accountID := range []string{"fixture-account", "fixture-small"} {
|
|
if _, err := creatorStore.UpdateAccountProfile(ctx, accountID, creator.AccountProfileUpdate{RealNameStatus: "unknown", BusinessStatus: "normal", BigAccount: accountID == "fixture-account", CooldownSeconds: 60}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if _, err := creatorStore.RecordVerifiedLoginResult(ctx, "fixture-account", "fixture-platform"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := creatorStore.RecordVerifiedLoginResult(ctx, "fixture-small", "fixture-small-platform"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := creatorStore.SetRelation(ctx, "fixture-account", "fixture-small", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
strategyBody := `{"execution_account_id":"fixture-small","position":1,"enabled":true,"event_types":["comment"],"action":"reply_comment","target_type":"comment","candidate_texts":["已收到"]}`
|
|
strategyResponse := do(app, http.MethodPost, "/api/creator/accounts/fixture-account/strategies", strategyBody, "operator", "unit-test-password")
|
|
if strategyResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture strategy: %d %s", strategyResponse.Code, strategyResponse.Body.String())
|
|
}
|
|
strategyID := idFrom(strategyResponse)
|
|
for _, route := range []struct {
|
|
method string
|
|
path string
|
|
body string
|
|
}{
|
|
{http.MethodPut, "/api/creator/strategies/" + strategyID, strategyBody},
|
|
{http.MethodPost, "/api/creator/strategies/" + strategyID + "/enable", `{}`},
|
|
{http.MethodPost, "/api/creator/strategies/" + strategyID + "/disable", `{}`},
|
|
} {
|
|
if response := do(app, route.method, route.path, route.body, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("%s %s: %d %s", route.method, route.path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
if response := do(app, http.MethodDelete, "/api/creator/strategies/"+strategyID, "", "operator", "unit-test-password"); response.Code != http.StatusNoContent {
|
|
t.Fatalf("delete fixture strategy: %d %s", response.Code, response.Body.String())
|
|
}
|
|
ruleBody := `{"name":"fixture-rule","enabled":true,"source_type":"owned","topic":"title","include_keywords":["hello"],"ai_requirement":"lead"}`
|
|
ruleResponse := do(app, http.MethodPost, "/api/creator/rules", ruleBody, "operator", "unit-test-password")
|
|
if ruleResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture rule: %d %s", ruleResponse.Code, ruleResponse.Body.String())
|
|
}
|
|
ruleID := idFrom(ruleResponse)
|
|
if response := do(app, http.MethodGet, "/api/creator/rules/"+ruleID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET fixture rule: %d %s", response.Code, response.Body.String())
|
|
}
|
|
if response := do(app, http.MethodPost, "/api/creator/comments/"+commentID+"/analyze", `{"rule_id":"`+ruleID+`"}`, "operator", "unit-test-password"); response.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("analyze fixture comment without AI: %d %s", response.Code, response.Body.String())
|
|
}
|
|
competitor, err := creatorStore.CreateCompetitor(ctx, creator.CompetitorInput{Platform: creator.PlatformDouyin, PlatformAccountKey: "competitor-key", Nickname: "Competitor", HomepageURL: "https://www.douyin.com/user/competitor-key"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
competitorID := competitor.ID
|
|
if response := do(app, http.MethodGet, "/api/creator/competitors/"+competitorID, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET fixture competitor: %d %s", response.Code, response.Body.String())
|
|
}
|
|
for _, action := range []string{"pause", "resume", "sync"} {
|
|
if response := do(app, http.MethodPost, "/api/creator/competitors/"+competitorID+"/"+action, `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK && response.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("competitor %s: %d %s", action, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
if _, err := syncCreatorCompetitorWithClaim(ctx, creatorStore, phaseAStore, hubStore, competitorID, "fixture-account", true); err == nil {
|
|
t.Fatal("competitor sync without browser unexpectedly succeeded")
|
|
}
|
|
if _, err := previewDouyinCompetitor(ctx, creatorStore, phaseAStore, hubStore, "fixture-account", creator.CompetitorInput{Platform: creator.PlatformDouyin, PlatformAccountKey: "preview-key", Nickname: "Preview", HomepageURL: "https://www.douyin.com/user/preview-key"}); err == nil {
|
|
t.Fatal("competitor preview without browser unexpectedly succeeded")
|
|
}
|
|
eventBody := `{"platform":"douyin","receiving_account_id":"fixture-account","event_key":"fixture-event","event_type":"comment","interactor_uid":"peer","work_id":"` + workID + `","comment_id":"` + commentID + `"}`
|
|
eventResponse := do(app, http.MethodPost, "/api/creator/test/events", eventBody, "operator", "unit-test-password")
|
|
if eventResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture event: %d %s", eventResponse.Code, eventResponse.Body.String())
|
|
}
|
|
var eventEnvelope struct {
|
|
Event struct {
|
|
ID string `json:"id"`
|
|
} `json:"event"`
|
|
}
|
|
if err := json.Unmarshal(eventResponse.Body.Bytes(), &eventEnvelope); err != nil || eventEnvelope.Event.ID == "" {
|
|
t.Fatalf("event has no ID: %s (%v)", eventResponse.Body.String(), err)
|
|
}
|
|
eventID := eventEnvelope.Event.ID
|
|
if response := do(app, http.MethodPost, "/api/creator/events/"+eventID+"/display", `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("display fixture event: %d %s", response.Code, response.Body.String())
|
|
}
|
|
operationBody := `{"idempotency_key":"fixture-operation","source":"manual","action":"reply_comment","platform":"douyin","account_id":"fixture-account","target_uid":"peer","target_comment_id":"` + commentID + `","target_work_id":"` + workID + `","text":"reply"}`
|
|
operationResponse := do(app, http.MethodPost, "/api/creator/operations", operationBody, "operator", "unit-test-password")
|
|
if operationResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture operation: %d %s", operationResponse.Code, operationResponse.Body.String())
|
|
}
|
|
operationID := idFrom(operationResponse)
|
|
for _, path := range []string{"/api/creator/operations/" + operationID, "/api/creator/operations/" + operationID + "/verification"} {
|
|
if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
if response := do(app, http.MethodPost, "/api/creator/operations/"+operationID+"/execute", `{}`, "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("execute fixture operation without executor: %d %s", response.Code, response.Body.String())
|
|
}
|
|
if response := do(app, http.MethodPost, "/api/creator/test/events/process", eventBody, "operator", "unit-test-password"); response.Code != http.StatusOK && response.Code != http.StatusServiceUnavailable {
|
|
t.Fatalf("process fixture event without executor: %d %s", response.Code, response.Body.String())
|
|
}
|
|
messageBody := `{"platform":"douyin","account_id":"fixture-account","peer_uid":"peer","peer_name":"Peer","platform_message_key":"fixture-message","direction":"inbound","message_type":"text","text":"hello"}`
|
|
messageResponse := do(app, http.MethodPost, "/api/creator/test/messages", messageBody, "operator", "unit-test-password")
|
|
if messageResponse.Code != http.StatusCreated {
|
|
t.Fatalf("create fixture message: %d %s", messageResponse.Code, messageResponse.Body.String())
|
|
}
|
|
var message struct {
|
|
ConversationID string `json:"conversation_id"`
|
|
}
|
|
if err := json.Unmarshal(messageResponse.Body.Bytes(), &message); err != nil || message.ConversationID == "" {
|
|
t.Fatalf("message has no conversation: %s (%v)", messageResponse.Body.String(), err)
|
|
}
|
|
for _, path := range []string{"/api/creator/conversations/" + message.ConversationID + "/messages", "/api/creator/conversations/" + message.ConversationID + "/messages?page=1&page_size=10"} {
|
|
if response := do(app, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("GET %s: %d %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
if err := runCreatorScheduleOnce(ctx, creatorStore, phaseAStore, hubStore); err != nil && !errors.Is(err, creator.ErrUnavailable) {
|
|
t.Fatalf("creator schedule fixture: %v", err)
|
|
}
|
|
if err := runCreatorMetricScheduleOnce(ctx, creatorStore, phaseAStore, hubStore, time.Now().UTC()); err != nil && !errors.Is(err, creator.ErrUnavailable) {
|
|
t.Fatalf("creator metric schedule fixture: %v", err)
|
|
}
|
|
storedWork, err := creatorStore.GetWork(ctx, workID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
settings, err := creatorStore.GetSettings(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := refreshCreatorMetricWork(ctx, creatorStore, phaseAStore, hubStore, storedWork, "fixture-account", settings, time.Now().UTC()); err == nil {
|
|
t.Fatal("metric refresh without browser unexpectedly succeeded")
|
|
}
|
|
if _, err := verifyCreatorAccount(ctx, creatorStore, phaseAStore, hubStore, "fixture-account"); err == nil {
|
|
t.Fatal("account verification without browser unexpectedly succeeded")
|
|
}
|
|
}
|
|
|
|
func TestPhaseAAccountRequestRejectsUnknownFields(t *testing.T) {
|
|
for name, body := range map[string]string{
|
|
"client id": `{"id":"account-a","name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value"}`,
|
|
"authorization kind": `{"name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value","authorization_kind":"owned"}`,
|
|
"credential reference": `{"name":"账号 A","platform":"douyin","platform_account_key":"a","tags":[],"cookies":"sid=value","credential_reference":{}}`,
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
app := fiber.New()
|
|
app.Post("/", func(c fiber.Ctx) error {
|
|
var input accountRequest
|
|
if err := decodePhaseA(c, &input); err != nil {
|
|
return phaseAError(c, err)
|
|
}
|
|
return c.SendStatus(http.StatusNoContent)
|
|
})
|
|
response, err := app.Test(httptest.NewRequest(http.MethodPost, "/", strings.NewReader(body)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer response.Body.Close()
|
|
if response.StatusCode != http.StatusBadRequest {
|
|
t.Fatalf("expected sensitive or unknown field to be rejected, got %d", response.StatusCode)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPhaseAAccountHTTPWorkflowRedactsSecrets(t *testing.T) {
|
|
databaseURL := os.Getenv("CREATORHUB_POSTGRES_TEST_URL")
|
|
if databaseURL == "" {
|
|
t.Skip("set CREATORHUB_POSTGRES_TEST_URL to run PostgreSQL integration coverage")
|
|
}
|
|
ctx := context.Background()
|
|
databaseURL = isolatedControlPlaneDatabaseURL(t, databaseURL)
|
|
store, err := account.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = store.Close() })
|
|
hubStore, err := hub.Open(ctx, databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = hubStore.Close() })
|
|
|
|
webDirectory := t.TempDir()
|
|
if err := os.WriteFile(filepath.Join(webDirectory, "index.html"), []byte("index"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
protectedApp := newHandlerWithStores(webDirectory, "operator", "unit-test-password", store, hubStore)
|
|
for _, route := range []struct{ method, path string }{
|
|
{http.MethodGet, "/api/phase-a/accounts"}, {http.MethodPost, "/api/phase-a/accounts"},
|
|
{http.MethodPost, "/api/phase-a/accounts/account-http/pause"}, {http.MethodGet, "/api/phase-a/tasks"},
|
|
{http.MethodPost, "/api/phase-a/mock/execute"}, {http.MethodGet, "/api/phase-a/audit"},
|
|
{http.MethodGet, "/api/browsers"}, {http.MethodPost, "/api/browsers/account-http/start"},
|
|
{http.MethodDelete, "/api/browsers/account-http"}, {http.MethodPut, "/api/browser-versions/1"},
|
|
{http.MethodPost, "/api/network-exits/exit-http/check"}, {http.MethodPost, "/api/network-exits/exit-http/disable"},
|
|
} {
|
|
if response := do(protectedApp, route.method, route.path, ""); response.Code != http.StatusUnauthorized {
|
|
t.Fatalf("unauthenticated %s %s returned %d", route.method, route.path, response.Code)
|
|
}
|
|
}
|
|
for _, path := range []string{"/api/phase-a/accounts", "/api/browsers", "/api/phase-a/audit"} {
|
|
if response := do(protectedApp, http.MethodGet, path, "", "operator", "unit-test-password"); response.Code != http.StatusOK {
|
|
t.Fatalf("authenticated GET %s returned %d: %s", path, response.Code, response.Body.String())
|
|
}
|
|
}
|
|
app := fiber.New()
|
|
app.Use(authenticate("operator", "unit-test-password"))
|
|
credentials := &testCredentialBridge{values: map[string]string{}}
|
|
registerPhaseA(app, store, nil, credentials)
|
|
cookieHeader := "sessionid=phase-http-secret; token=value"
|
|
accountBody := `{"name":"Phase HTTP","platform":"douyin","platform_account_key":"phase-http","tags":["测试"],"cookies":"` + cookieHeader + `"}`
|
|
request := func(method, path, body string, wantStatus int) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
response := do(app, method, path, body, "operator", "unit-test-password")
|
|
if response.Code != wantStatus {
|
|
t.Fatalf("%s %s returned %d, want %d: %s", method, path, response.Code, wantStatus, response.Body.String())
|
|
}
|
|
if strings.Contains(response.Body.String(), cookieHeader) {
|
|
t.Fatalf("%s %s leaked cookies: %s", method, path, response.Body.String())
|
|
}
|
|
return response
|
|
}
|
|
|
|
created := request(http.MethodPost, "/api/phase-a/accounts", accountBody, http.StatusCreated)
|
|
var account account.Account
|
|
if err := json.Unmarshal(created.Body.Bytes(), &account); err != nil || account.ID == "" || account.Name != "Phase HTTP" || account.RuntimeStatus != "paused" {
|
|
t.Fatalf("unexpected account response: %#v err=%v", account, err)
|
|
}
|
|
if credentials.values["creatorhub/"+account.ID+"/cookies"] != cookieHeader {
|
|
t.Fatalf("cookies were not stored through the credential bridge: %#v", credentials.values)
|
|
}
|
|
request(http.MethodPost, "/api/phase-a/accounts", accountBody, http.StatusConflict)
|
|
request(http.MethodPost, "/api/phase-a/accounts", `{"name":"Bad","platform":"douyin","platform_account_key":"bad","tags":[],"cookies":"sessionid"}`, http.StatusBadRequest)
|
|
request(http.MethodPost, "/api/phase-a/accounts", strings.TrimSuffix(accountBody, "}")+`,"password":"secret"}`, http.StatusBadRequest)
|
|
request(http.MethodGet, "/api/phase-a/accounts", "", http.StatusOK)
|
|
request(http.MethodGet, "/api/phase-a/accounts/"+account.ID, "", http.StatusOK)
|
|
|
|
db, err := sql.Open("pgx", databaseURL)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = db.Close() })
|
|
assertControlPlaneDatabaseCount(t, db, `SELECT count(*) FROM credential_reference
|
|
WHERE id = '`+account.ID+`-cookies' AND provider = 'os_keyring'`, 1)
|
|
assertControlPlaneDatabaseCount(t, db, `SELECT count(*) FROM information_schema.columns
|
|
WHERE table_schema = current_schema() AND table_name = 'social_account' AND column_name = 'cookies'`, 0)
|
|
|
|
if _, err := db.ExecContext(ctx, `
|
|
INSERT INTO gateway (name, endpoint, token) VALUES ('phase-http', 'http://127.0.0.1:8081', 'phase-http-gateway-token');
|
|
INSERT INTO browser_version (version, browser_path) VALUES ('1', '/opt/creatorhub/browsers/1');
|
|
INSERT INTO browser_env (alias, name, gateway_name, browser_version, fingerprint)
|
|
VALUES ('account-http', 'Phase HTTP', 'phase-http', '1', '{"seed":1}');
|
|
INSERT INTO network_exit (id, protocol, host, port, health_status)
|
|
VALUES ('exit-http', 'socks5', '127.0.0.1', 1080, 'healthy')`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := db.ExecContext(ctx, `INSERT INTO environment_binding (id, account_id, browser_env_alias, network_exit_id)
|
|
VALUES ('binding-http', $1, 'account-http', 'exit-http')`, account.ID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
request(http.MethodPost, "/api/phase-a/accounts/"+account.ID+"/resume", "", http.StatusNoContent)
|
|
request(http.MethodPost, "/api/phase-a/accounts/"+account.ID+"/pause", "", http.StatusNoContent)
|
|
request(http.MethodPost, "/api/phase-a/accounts/"+account.ID+"/resume", "", http.StatusNoContent)
|
|
request(http.MethodPost, "/api/phase-a/accounts/"+account.ID+"/revoke", "", http.StatusNoContent)
|
|
blocked := request(http.MethodPost, "/api/phase-a/accounts/"+account.ID+"/resume", "", http.StatusConflict)
|
|
if !strings.Contains(blocked.Body.String(), `"reason_code":"account_revoked"`) {
|
|
t.Fatalf("revoked resume did not return a stable conflict reason: %s", blocked.Body.String())
|
|
}
|
|
}
|
|
|
|
func TestPhaseAErrorRedactsInternalDetails(t *testing.T) {
|
|
app := fiber.New()
|
|
app.Get("/", func(c fiber.Ctx) error {
|
|
return phaseAError(c, errors.New("database exposed a secret value"))
|
|
})
|
|
response, err := app.Test(httptest.NewRequest(http.MethodGet, "/", nil))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer response.Body.Close()
|
|
body, _ := io.ReadAll(response.Body)
|
|
if response.StatusCode != http.StatusInternalServerError || strings.Contains(string(body), "secret") || !strings.Contains(string(body), "phase A operation failed") {
|
|
t.Fatalf("internal error was not redacted: status=%d body=%s", response.StatusCode, body)
|
|
}
|
|
}
|
|
|
|
func newHandlerWithStores(_ string, _ string, _ string, accountStore *account.Store, environmentStore *hub.Store) *fiber.App {
|
|
appInstance := fiber.New()
|
|
if environmentStore != nil {
|
|
RegisterEnvironments(appInstance, environmentStore)
|
|
}
|
|
if accountStore != nil {
|
|
RegisterAccounts(appInstance, accountStore, environmentStore, nil)
|
|
}
|
|
return appInstance
|
|
}
|
|
|
|
func newHandlerWithCreator(_ string, _ string, _ string, accountStore *account.Store, environmentStore *hub.Store, _ account.CredentialBridge, creatorStore *creator.Store) *fiber.App {
|
|
appInstance := newHandlerWithStores("", "", "", accountStore, environmentStore)
|
|
if creatorStore != nil {
|
|
RegisterCreator(appInstance, creatorStore, accountStore, environmentStore)
|
|
}
|
|
return appInstance
|
|
}
|
|
|
|
func authenticate(username, password string) fiber.Handler {
|
|
wantUser, wantPassword := sha256.Sum256([]byte(username)), sha256.Sum256([]byte(password))
|
|
return func(c fiber.Ctx) error {
|
|
encoded, ok := strings.CutPrefix(c.Get(fiber.HeaderAuthorization), "Basic ")
|
|
decoded, err := base64.StdEncoding.DecodeString(encoded)
|
|
user, suppliedPassword, found := strings.Cut(string(decoded), ":")
|
|
gotUser, gotPassword := sha256.Sum256([]byte(user)), sha256.Sum256([]byte(suppliedPassword))
|
|
if !ok || err != nil || !found || subtle.ConstantTimeCompare(gotUser[:], wantUser[:]) != 1 || subtle.ConstantTimeCompare(gotPassword[:], wantPassword[:]) != 1 {
|
|
return c.Status(fiber.StatusUnauthorized).JSON(map[string]string{"error": "authentication required"})
|
|
}
|
|
return c.Next()
|
|
}
|
|
}
|