259 lines
8.3 KiB
Go
259 lines
8.3 KiB
Go
package paymentguideser
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"91porn-server/models/v/paymentguidemod"
|
|
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
func TestPaymentGuideListResponseUsesLegacyVideoLimitDefault(t *testing.T) {
|
|
list := []paymentguidemod.PaymentGuide{
|
|
{Scene: paymentguidemod.SceneVIPContentUpdate},
|
|
{Scene: paymentguidemod.SceneVIPContentUpdate, VideoLimit: 12},
|
|
{Scene: paymentguidemod.SceneVIPCenter},
|
|
}
|
|
normalizeVideoLimits(list)
|
|
|
|
if list[0].VideoLimit != paymentguidemod.DefaultVIPContentVideoLimit {
|
|
t.Fatalf("legacy videoLimit = %d, want %d", list[0].VideoLimit, paymentguidemod.DefaultVIPContentVideoLimit)
|
|
}
|
|
if list[1].VideoLimit != 12 {
|
|
t.Fatalf("configured videoLimit = %d, want 12", list[1].VideoLimit)
|
|
}
|
|
if list[2].VideoLimit != 0 {
|
|
t.Fatalf("unrelated scene videoLimit = %d, want 0", list[2].VideoLimit)
|
|
}
|
|
}
|
|
|
|
func TestSceneOptionsUseConfiguredFreeTrialCountAndHideLegacyScene(t *testing.T) {
|
|
options := sceneOptions(5)
|
|
if len(options) != paymentguidemod.MaxBatchSceneCount {
|
|
t.Fatalf("len(options) = %d, want %d", len(options), paymentguidemod.MaxBatchSceneCount)
|
|
}
|
|
if options[0].Value != paymentguidemod.SceneHomeNewUserFreeTrial ||
|
|
options[0].Label != "首页新用户免费5次试看" ||
|
|
options[0].TotalWatchCount == nil || *options[0].TotalWatchCount != 5 {
|
|
t.Fatalf("unexpected free-trial option: %+v", options[0])
|
|
}
|
|
for _, option := range options {
|
|
if option.Value == paymentguidemod.SceneHomeNewUser {
|
|
t.Fatalf("legacy HOME_NEW_USER must not be returned: %+v", options)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWebConfigurationRejectsLegacyHomeNewUserScene(t *testing.T) {
|
|
listReq := ListReq{Scene: paymentguidemod.SceneHomeNewUser, PageNumber: 1, PageSize: 20}
|
|
if _, err := listReq.List(); err == nil || !strings.Contains(err.Error(), "unsupported scene") {
|
|
t.Fatalf("List() error = %v, want unsupported scene", err)
|
|
}
|
|
|
|
config := validBatchConfig()
|
|
config.Scene = paymentguidemod.SceneHomeNewUser
|
|
if err := Add(&config); err == nil || !strings.Contains(err.Error(), "unsupported scene") {
|
|
t.Fatalf("Add() error = %v, want unsupported scene", err)
|
|
}
|
|
}
|
|
|
|
func validBatchConfig() paymentguidemod.PaymentGuide {
|
|
return paymentguidemod.PaymentGuide{
|
|
Segments: []string{paymentguidemod.SegmentNormal},
|
|
Style: "BOTTOM_SHEET",
|
|
Title: "会员内容更新",
|
|
VideoIDs: []string{"video-a"},
|
|
Action: paymentguidemod.Action{Type: "NONE"},
|
|
Enable: true,
|
|
Sort: 100,
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsNormalizesScenesAndDefaultsVideoLimit(t *testing.T) {
|
|
req := BatchAddReq{
|
|
Scenes: []string{" home_new_user_free_trial ", "vip_content_update"},
|
|
Config: validBatchConfig(),
|
|
}
|
|
configs, err := req.Configs()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(configs) != 2 {
|
|
t.Fatalf("len(configs) = %d, want 2", len(configs))
|
|
}
|
|
if configs[0].Scene != paymentguidemod.SceneHomeNewUserFreeTrial || configs[1].Scene != paymentguidemod.SceneVIPContentUpdate {
|
|
t.Fatalf("unexpected scenes: %#v", []string{configs[0].Scene, configs[1].Scene})
|
|
}
|
|
for i := range configs {
|
|
if configs[i].VideoLimit != paymentguidemod.DefaultVIPContentVideoLimit {
|
|
t.Fatalf("configs[%d].VideoLimit = %d, want %d", i, configs[i].VideoLimit, paymentguidemod.DefaultVIPContentVideoLimit)
|
|
}
|
|
}
|
|
|
|
configs[0].Segments[0] = paymentguidemod.SegmentMaxVIP
|
|
configs[0].VideoIDs[0] = "changed"
|
|
if configs[1].Segments[0] != paymentguidemod.SegmentNormal || configs[1].VideoIDs[0] != "video-a" {
|
|
t.Fatal("batch configs must not share slice storage")
|
|
}
|
|
if req.Config.Segments[0] != paymentguidemod.SegmentNormal || req.Config.VideoIDs[0] != "video-a" {
|
|
t.Fatal("building configs must not mutate the request template")
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsPreservesExplicitVideoLimit(t *testing.T) {
|
|
config := validBatchConfig()
|
|
config.VideoLimit = 12
|
|
configs, err := (BatchAddReq{
|
|
Scenes: []string{paymentguidemod.SceneVIPContentUpdate},
|
|
Config: config,
|
|
}).Configs()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if configs[0].VideoLimit != 12 {
|
|
t.Fatalf("VideoLimit = %d, want 12", configs[0].VideoLimit)
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsSupportsEveryScene(t *testing.T) {
|
|
configs, err := (BatchAddReq{
|
|
Scenes: []string{
|
|
paymentguidemod.SceneHomeNewUserFreeTrial,
|
|
paymentguidemod.SceneHomeOldUser,
|
|
paymentguidemod.SceneVideoPreviewEnd,
|
|
paymentguidemod.SceneDiscountCountdown,
|
|
paymentguidemod.SceneVideoBack,
|
|
paymentguidemod.SceneVIPCenter,
|
|
paymentguidemod.SceneVIPContentUpdate,
|
|
},
|
|
Config: validBatchConfig(),
|
|
}).Configs()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(configs) != paymentguidemod.MaxBatchSceneCount {
|
|
t.Fatalf("len(configs) = %d, want %d", len(configs), paymentguidemod.MaxBatchSceneCount)
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsDiscardsTemplateIdentityAndTimestamps(t *testing.T) {
|
|
config := validBatchConfig()
|
|
config.ID = primitive.NewObjectID()
|
|
config.Scene = paymentguidemod.SceneVIPCenter
|
|
config.CreatedAt = time.Now().Add(-2 * time.Hour)
|
|
config.UpdatedAt = time.Now().Add(-time.Hour)
|
|
configs, err := (BatchAddReq{
|
|
Scenes: []string{paymentguidemod.SceneHomeNewUserFreeTrial},
|
|
Config: config,
|
|
}).Configs()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !configs[0].ID.IsZero() {
|
|
t.Fatalf("ID = %s, want zero before insertion", configs[0].ID.Hex())
|
|
}
|
|
if configs[0].Scene != paymentguidemod.SceneHomeNewUserFreeTrial {
|
|
t.Fatalf("Scene = %s, want %s", configs[0].Scene, paymentguidemod.SceneHomeNewUserFreeTrial)
|
|
}
|
|
if !configs[0].CreatedAt.IsZero() || !configs[0].UpdatedAt.IsZero() {
|
|
t.Fatalf("timestamps must be zero before insertion: %+v", configs[0])
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsRejectsInvalidScenes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
scenes []string
|
|
match string
|
|
}{
|
|
{name: "empty", scenes: nil, match: "scenes are required"},
|
|
{name: "unsupported", scenes: []string{"UNKNOWN"}, match: "unsupported scene"},
|
|
{name: "duplicate after normalization", scenes: []string{"VIP_CENTER", " vip_center "}, match: "duplicate scene"},
|
|
{name: "too many inputs", scenes: []string{"a", "b", "c", "d", "e", "f", "g", "h"}, match: "more than 7"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
_, err := (BatchAddReq{Scenes: tt.scenes, Config: validBatchConfig()}).Configs()
|
|
if err == nil || !strings.Contains(err.Error(), tt.match) {
|
|
t.Fatalf("Configs() error = %v, want match %q", err, tt.match)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBatchAddReqConfigsValidatesTemplateForEveryScene(t *testing.T) {
|
|
config := validBatchConfig()
|
|
config.Title = ""
|
|
_, err := (BatchAddReq{
|
|
Scenes: []string{paymentguidemod.SceneVIPCenter},
|
|
Config: config,
|
|
}).Configs()
|
|
if err == nil || !strings.Contains(err.Error(), "title is required") {
|
|
t.Fatalf("Configs() error = %v, want title validation error", err)
|
|
}
|
|
}
|
|
|
|
func TestAddReqSupportsExistingSingleSceneJSON(t *testing.T) {
|
|
body := []byte(`{
|
|
"scene":"VIP_CONTENT_UPDATE",
|
|
"style":"BOTTOM_SHEET",
|
|
"title":"会员内容更新",
|
|
"action":{"type":"NONE","value":""}
|
|
}`)
|
|
var req AddReq
|
|
if err := json.Unmarshal(body, &req); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if req.IsBatch() {
|
|
t.Fatal("existing flat add request must remain single-scene")
|
|
}
|
|
if req.Scene != paymentguidemod.SceneVIPContentUpdate || req.Title != "会员内容更新" {
|
|
t.Fatalf("unexpected single add request: %+v", req.PaymentGuide)
|
|
}
|
|
}
|
|
|
|
func TestAddReqSupportsBatchJSONShape(t *testing.T) {
|
|
body := []byte(`{
|
|
"scenes":["HOME_NEW_USER_FREE_TRIAL","VIP_CONTENT_UPDATE"],
|
|
"config":{
|
|
"style":"BOTTOM_SHEET",
|
|
"title":"会员内容更新",
|
|
"videoLimit":20,
|
|
"action":{"type":"NONE","value":""},
|
|
"enable":true,
|
|
"sort":100
|
|
}
|
|
}`)
|
|
var req AddReq
|
|
if err := json.Unmarshal(body, &req); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !req.IsBatch() || req.Config == nil {
|
|
t.Fatalf("unexpected batch add request: %+v", req)
|
|
}
|
|
configs, err := (BatchAddReq{Scenes: req.Scenes, Config: *req.Config}).Configs()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(configs) != 2 || configs[1].VideoLimit != 20 {
|
|
t.Fatalf("unexpected configs: %+v", configs)
|
|
}
|
|
}
|
|
|
|
func TestAddReqTreatsPresentEmptyScenesAsBatch(t *testing.T) {
|
|
var req AddReq
|
|
if err := json.Unmarshal([]byte(`{"scenes":[]}`), &req); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !req.IsBatch() {
|
|
t.Fatal("a present scenes field must use batch validation")
|
|
}
|
|
_, err := (BatchAddReq{Scenes: req.Scenes, Config: paymentguidemod.PaymentGuide{}}).Configs()
|
|
if err == nil || !strings.Contains(err.Error(), "scenes are required") {
|
|
t.Fatalf("Configs() error = %v, want scenes validation error", err)
|
|
}
|
|
}
|