1410 lines
46 KiB
Go
1410 lines
46 KiB
Go
package services
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"quyun/v2/app/commands/testx"
|
|
"quyun/v2/app/errorx"
|
|
super_dto "quyun/v2/app/http/super/v1/dto"
|
|
v1_dto "quyun/v2/app/http/v1/dto"
|
|
"quyun/v2/app/requests"
|
|
"quyun/v2/database"
|
|
"quyun/v2/database/fields"
|
|
"quyun/v2/database/models"
|
|
"quyun/v2/pkg/consts"
|
|
|
|
"github.com/samber/lo"
|
|
. "github.com/smartystreets/goconvey/convey"
|
|
"github.com/stretchr/testify/suite"
|
|
"go.ipao.vip/atom/contracts"
|
|
"go.ipao.vip/gen/types"
|
|
"go.uber.org/dig"
|
|
)
|
|
|
|
type SuperTestSuiteInjectParams struct {
|
|
dig.In
|
|
|
|
DB *sql.DB
|
|
Initials []contracts.Initial `group:"initials"`
|
|
}
|
|
|
|
type SuperTestSuite struct {
|
|
suite.Suite
|
|
SuperTestSuiteInjectParams
|
|
}
|
|
|
|
func Test_Super(t *testing.T) {
|
|
providers := testx.Default().With(Provide)
|
|
|
|
testx.Serve(providers, t, func(p SuperTestSuiteInjectParams) {
|
|
suite.Run(t, &SuperTestSuite{SuperTestSuiteInjectParams: p})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_ListUsers() {
|
|
Convey("ListUsers", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser)
|
|
|
|
u1 := &models.User{Username: "user1", Nickname: "Alice"}
|
|
u2 := &models.User{Username: "user2", Nickname: "Bob"}
|
|
models.UserQuery.WithContext(ctx).Create(u1, u2)
|
|
|
|
Convey("should list users", func() {
|
|
filter := &super_dto.UserListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListUsers(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 2)
|
|
|
|
items := res.Items.([]super_dto.UserItem)
|
|
So(items[0].Username, ShouldEqual, "user2") // Desc order
|
|
})
|
|
|
|
Convey("should filter users", func() {
|
|
filter := &super_dto.UserListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Username: lo.ToPtr("Alice"),
|
|
}
|
|
res, err := Super.ListUsers(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
items := res.Items.([]super_dto.UserItem)
|
|
So(items[0].Username, ShouldEqual, "user1")
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_LoginAndCheckToken() {
|
|
Convey("Login and CheckToken", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser)
|
|
|
|
admin := &models.User{
|
|
Username: "super_admin",
|
|
Password: "pass123",
|
|
Roles: types.Array[consts.Role]{consts.RoleSuperAdmin},
|
|
Status: consts.UserStatusVerified,
|
|
}
|
|
normal := &models.User{
|
|
Username: "normal_user",
|
|
Password: "pass123",
|
|
Status: consts.UserStatusVerified,
|
|
}
|
|
models.UserQuery.WithContext(ctx).Create(admin, normal)
|
|
|
|
Convey("should login as super admin", func() {
|
|
res, err := Super.Login(ctx, &super_dto.LoginForm{
|
|
Username: admin.Username,
|
|
Password: admin.Password,
|
|
})
|
|
So(err, ShouldBeNil)
|
|
So(res, ShouldNotBeNil)
|
|
So(res.Token, ShouldNotBeBlank)
|
|
So(res.User.ID, ShouldEqual, admin.ID)
|
|
})
|
|
|
|
Convey("should reject non-super admin", func() {
|
|
_, err := Super.Login(ctx, &super_dto.LoginForm{
|
|
Username: normal.Username,
|
|
Password: normal.Password,
|
|
})
|
|
So(err, ShouldNotBeNil)
|
|
})
|
|
|
|
Convey("should refresh token", func() {
|
|
loginRes, err := Super.Login(ctx, &super_dto.LoginForm{
|
|
Username: admin.Username,
|
|
Password: admin.Password,
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
token := "Bearer " + loginRes.Token
|
|
checkRes, err := Super.CheckToken(ctx, token)
|
|
So(err, ShouldBeNil)
|
|
So(checkRes, ShouldNotBeNil)
|
|
So(checkRes.Token, ShouldNotBeBlank)
|
|
So(checkRes.User.ID, ShouldEqual, admin.ID)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_CreateTenant() {
|
|
Convey("CreateTenant", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser, models.TableNameTenant)
|
|
|
|
u := &models.User{Username: "admin1"}
|
|
models.UserQuery.WithContext(ctx).Create(u)
|
|
|
|
Convey("should create tenant", func() {
|
|
startAt := time.Now()
|
|
form := &super_dto.TenantCreateForm{
|
|
Name: "Super Tenant",
|
|
Code: "st1",
|
|
AdminUserID: u.ID,
|
|
Duration: 7,
|
|
}
|
|
err := Super.CreateTenant(ctx, form)
|
|
So(err, ShouldBeNil)
|
|
|
|
t, _ := models.TenantQuery.WithContext(ctx).Where(models.TenantQuery.Code.Eq("st1")).First()
|
|
So(t, ShouldNotBeNil)
|
|
So(t.Name, ShouldEqual, "Super Tenant")
|
|
So(t.UserID, ShouldEqual, u.ID)
|
|
So(t.Status, ShouldEqual, consts.TenantStatusVerified)
|
|
So(t.ExpiredAt.After(startAt), ShouldBeTrue)
|
|
|
|
tu, _ := models.TenantUserQuery.WithContext(ctx).
|
|
Where(models.TenantUserQuery.TenantID.Eq(t.ID), models.TenantUserQuery.UserID.Eq(u.ID)).
|
|
First()
|
|
So(tu, ShouldNotBeNil)
|
|
So(tu.Status, ShouldEqual, consts.UserStatusVerified)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_ListTenantsSortAggregates() {
|
|
Convey("ListTenants sort by aggregates", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser, models.TableNameTenant, models.TableNameTenantUser, models.TableNameOrder)
|
|
|
|
owner1 := &models.User{Username: "tenant_sort_owner_1"}
|
|
owner2 := &models.User{Username: "tenant_sort_owner_2"}
|
|
owner3 := &models.User{Username: "tenant_sort_owner_3"}
|
|
member := &models.User{Username: "tenant_sort_member"}
|
|
models.UserQuery.WithContext(ctx).Create(owner1, owner2, owner3, member)
|
|
|
|
tenant1 := &models.Tenant{UserID: owner1.ID, Code: "t-sort-1", Name: "Tenant Sort 1", Status: consts.TenantStatusVerified}
|
|
tenant2 := &models.Tenant{UserID: owner2.ID, Code: "t-sort-2", Name: "Tenant Sort 2", Status: consts.TenantStatusVerified}
|
|
tenant3 := &models.Tenant{UserID: owner3.ID, Code: "t-sort-3", Name: "Tenant Sort 3", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant1, tenant2, tenant3)
|
|
|
|
models.TenantUserQuery.WithContext(ctx).Create(
|
|
&models.TenantUser{TenantID: tenant1.ID, UserID: owner1.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
&models.TenantUser{TenantID: tenant2.ID, UserID: owner2.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
&models.TenantUser{TenantID: tenant2.ID, UserID: member.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
&models.TenantUser{TenantID: tenant3.ID, UserID: owner3.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
&models.TenantUser{TenantID: tenant3.ID, UserID: owner1.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
&models.TenantUser{TenantID: tenant3.ID, UserID: member.ID, Role: types.Array[consts.TenantUserRole]{consts.TenantUserRoleMember}},
|
|
)
|
|
|
|
models.OrderQuery.WithContext(ctx).Create(
|
|
&models.Order{
|
|
TenantID: tenant1.ID,
|
|
UserID: owner1.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 300,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 300,
|
|
IdempotencyKey: "tenant-sort-income-1",
|
|
},
|
|
&models.Order{
|
|
TenantID: tenant2.ID,
|
|
UserID: owner2.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 100,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 100,
|
|
IdempotencyKey: "tenant-sort-income-2",
|
|
},
|
|
&models.Order{
|
|
TenantID: tenant3.ID,
|
|
UserID: owner3.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 200,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 200,
|
|
IdempotencyKey: "tenant-sort-income-3",
|
|
},
|
|
)
|
|
|
|
Convey("should sort by user_count asc", func() {
|
|
filter := &super_dto.TenantListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Asc: lo.ToPtr("user_count"),
|
|
}
|
|
res, err := Super.ListTenants(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.TenantItem)
|
|
So(items[0].ID, ShouldEqual, tenant1.ID)
|
|
So(items[1].ID, ShouldEqual, tenant2.ID)
|
|
So(items[2].ID, ShouldEqual, tenant3.ID)
|
|
})
|
|
|
|
Convey("should sort by user_count desc", func() {
|
|
filter := &super_dto.TenantListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Desc: lo.ToPtr("user_count"),
|
|
}
|
|
res, err := Super.ListTenants(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.TenantItem)
|
|
So(items[0].ID, ShouldEqual, tenant3.ID)
|
|
So(items[2].ID, ShouldEqual, tenant1.ID)
|
|
})
|
|
|
|
Convey("should sort by income_amount_paid_sum asc", func() {
|
|
filter := &super_dto.TenantListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Asc: lo.ToPtr("income_amount_paid_sum"),
|
|
}
|
|
res, err := Super.ListTenants(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.TenantItem)
|
|
So(items[0].ID, ShouldEqual, tenant2.ID)
|
|
So(items[1].ID, ShouldEqual, tenant3.ID)
|
|
So(items[2].ID, ShouldEqual, tenant1.ID)
|
|
})
|
|
|
|
Convey("should sort by income_amount_paid_sum desc", func() {
|
|
filter := &super_dto.TenantListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Desc: lo.ToPtr("income_amount_paid_sum"),
|
|
}
|
|
res, err := Super.ListTenants(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.TenantItem)
|
|
So(items[0].ID, ShouldEqual, tenant1.ID)
|
|
So(items[2].ID, ShouldEqual, tenant2.ID)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_WithdrawalApproval() {
|
|
Convey("Withdrawal Approval", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameOrder, models.TableNameUser, models.TableNameTenantLedger)
|
|
|
|
u := &models.User{Username: "user_w", Balance: 1000} // Initial 10.00
|
|
admin := &models.User{Username: "admin_w"}
|
|
models.UserQuery.WithContext(ctx).Create(u, admin)
|
|
|
|
// Create Withdrawal Order (Pending)
|
|
o1 := &models.Order{
|
|
UserID: u.ID,
|
|
Type: consts.OrderTypeWithdrawal,
|
|
Status: consts.OrderStatusCreated,
|
|
AmountPaid: 500,
|
|
}
|
|
models.OrderQuery.WithContext(ctx).Create(o1)
|
|
|
|
Convey("should list withdrawals", func() {
|
|
filter := &super_dto.SuperOrderListFilter{Pagination: requests.Pagination{Page: 1, Limit: 10}}
|
|
res, err := Super.ListWithdrawals(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
})
|
|
|
|
Convey("should approve withdrawal", func() {
|
|
err := Super.ApproveWithdrawal(ctx, admin.ID, o1.ID)
|
|
So(err, ShouldBeNil)
|
|
|
|
oReload, _ := models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o1.ID)).First()
|
|
So(oReload.Status, ShouldEqual, consts.OrderStatusPaid)
|
|
})
|
|
|
|
Convey("should reject withdrawal and refund", func() {
|
|
// Another order
|
|
o2 := &models.Order{
|
|
UserID: u.ID,
|
|
Type: consts.OrderTypeWithdrawal,
|
|
Status: consts.OrderStatusCreated,
|
|
AmountPaid: 200,
|
|
}
|
|
models.OrderQuery.WithContext(ctx).Create(o2)
|
|
|
|
// Assuming user balance was deducted when o2 was created (logic in creator service)
|
|
// But here we set balance manually to 1000. Let's assume it was 1200 before.
|
|
// Current balance 1000. Refund 200 -> Expect 1200.
|
|
|
|
err := Super.RejectWithdrawal(ctx, admin.ID, o2.ID, "Invalid account")
|
|
So(err, ShouldBeNil)
|
|
|
|
oReload, _ := models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o2.ID)).First()
|
|
So(oReload.Status, ShouldEqual, consts.OrderStatusFailed)
|
|
|
|
uReload, _ := models.UserQuery.WithContext(ctx).Where(models.UserQuery.ID.Eq(u.ID)).First()
|
|
So(uReload.Balance, ShouldEqual, 1200)
|
|
|
|
// Check Ledger
|
|
l, _ := models.TenantLedgerQuery.WithContext(ctx).Where(models.TenantLedgerQuery.OrderID.Eq(o2.ID)).First()
|
|
So(l, ShouldNotBeNil)
|
|
So(l.Type, ShouldEqual, consts.TenantLedgerTypeAdjustment)
|
|
So(l.OperatorUserID, ShouldEqual, admin.ID)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_CommentGovernance() {
|
|
Convey("Comment Governance", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameComment, models.TableNameContent, models.TableNameTenant, models.TableNameUser)
|
|
|
|
owner := &models.User{Username: "owner_comment"}
|
|
commenter := &models.User{Username: "commenter"}
|
|
admin := &models.User{Username: "admin_comment"}
|
|
models.UserQuery.WithContext(ctx).Create(owner, commenter, admin)
|
|
|
|
tenant := &models.Tenant{UserID: owner.ID, Code: "t-comment", Name: "Comment Tenant", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
content := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Comment Content",
|
|
Description: "Desc",
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(content)
|
|
|
|
Convey("should list comments", func() {
|
|
comment := &models.Comment{
|
|
TenantID: tenant.ID,
|
|
UserID: commenter.ID,
|
|
ContentID: content.ID,
|
|
Content: "Nice work",
|
|
}
|
|
models.CommentQuery.WithContext(ctx).Create(comment)
|
|
|
|
filter := &super_dto.SuperCommentListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListComments(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
items := res.Items.([]super_dto.SuperCommentItem)
|
|
So(items[0].ContentTitle, ShouldEqual, "Comment Content")
|
|
So(items[0].Username, ShouldEqual, commenter.Username)
|
|
})
|
|
|
|
Convey("should delete comment", func() {
|
|
comment := &models.Comment{
|
|
TenantID: tenant.ID,
|
|
UserID: commenter.ID,
|
|
ContentID: content.ID,
|
|
Content: "Spam content",
|
|
}
|
|
models.CommentQuery.WithContext(ctx).Create(comment)
|
|
|
|
err := Super.DeleteComment(ctx, admin.ID, comment.ID, &super_dto.SuperCommentDeleteForm{Reason: "spam"})
|
|
So(err, ShouldBeNil)
|
|
|
|
deleted, err := models.CommentQuery.WithContext(ctx).Unscoped().Where(models.CommentQuery.ID.Eq(comment.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(deleted.DeletedAt.Valid, ShouldBeTrue)
|
|
|
|
filter := &super_dto.SuperCommentListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListComments(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 0)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_ContentReportGovernance() {
|
|
Convey("Content Report Governance", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameContentReport, models.TableNameContent, models.TableNameTenant, models.TableNameUser)
|
|
|
|
owner := &models.User{Username: "owner_report"}
|
|
reporter := &models.User{Username: "reporter"}
|
|
admin := &models.User{Username: "admin_report"}
|
|
models.UserQuery.WithContext(ctx).Create(owner, reporter, admin)
|
|
|
|
tenant := &models.Tenant{UserID: owner.ID, Code: "t-report", Name: "Report Tenant", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
content := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Report Content",
|
|
Description: "Report Desc",
|
|
Status: consts.ContentStatusPublished,
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(content)
|
|
|
|
Convey("should list reports", func() {
|
|
report := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: content.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "spam",
|
|
Detail: "内容涉嫌违规",
|
|
Status: "pending",
|
|
}
|
|
models.ContentReportQuery.WithContext(ctx).Create(report)
|
|
|
|
filter := &super_dto.SuperContentReportListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListContentReports(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
items := res.Items.([]super_dto.SuperContentReportItem)
|
|
So(items[0].ContentTitle, ShouldEqual, "Report Content")
|
|
So(items[0].ReporterName, ShouldEqual, reporter.Username)
|
|
So(items[0].Status, ShouldEqual, "pending")
|
|
})
|
|
|
|
Convey("should process report and block content", func() {
|
|
report := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: content.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "abuse",
|
|
Detail: "严重违规",
|
|
Status: "pending",
|
|
}
|
|
models.ContentReportQuery.WithContext(ctx).Create(report)
|
|
|
|
err := Super.ProcessContentReport(ctx, admin.ID, report.ID, &super_dto.SuperContentReportProcessForm{
|
|
Action: "approve",
|
|
ContentAction: "block",
|
|
Reason: "违规属实",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded, err := models.ContentReportQuery.WithContext(ctx).Where(models.ContentReportQuery.ID.Eq(report.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.Status, ShouldEqual, "approved")
|
|
So(reloaded.HandledBy, ShouldEqual, admin.ID)
|
|
So(reloaded.HandledAction, ShouldEqual, "block")
|
|
So(reloaded.HandledReason, ShouldEqual, "违规属实")
|
|
So(reloaded.HandledAt.IsZero(), ShouldBeFalse)
|
|
|
|
contentReload, err := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(contentReload.Status, ShouldEqual, consts.ContentStatusBlocked)
|
|
})
|
|
|
|
Convey("should reject report without content action", func() {
|
|
report := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: content.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "other",
|
|
Detail: "误报",
|
|
Status: "pending",
|
|
}
|
|
models.ContentReportQuery.WithContext(ctx).Create(report)
|
|
|
|
err := Super.ProcessContentReport(ctx, admin.ID, report.ID, &super_dto.SuperContentReportProcessForm{
|
|
Action: "reject",
|
|
Reason: "证据不足",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded, err := models.ContentReportQuery.WithContext(ctx).Where(models.ContentReportQuery.ID.Eq(report.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.Status, ShouldEqual, "rejected")
|
|
So(reloaded.HandledBy, ShouldEqual, admin.ID)
|
|
So(reloaded.HandledAction, ShouldEqual, "ignore")
|
|
So(reloaded.HandledReason, ShouldEqual, "证据不足")
|
|
|
|
contentReload, err := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(contentReload.Status, ShouldEqual, consts.ContentStatusPublished)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_BatchProcessContentReports() {
|
|
Convey("BatchProcessContentReports", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameContentReport, models.TableNameContent, models.TableNameTenant, models.TableNameUser)
|
|
|
|
owner := &models.User{Username: "batch_report_owner"}
|
|
reporter := &models.User{Username: "batch_reporter"}
|
|
admin := &models.User{Username: "batch_report_admin"}
|
|
models.UserQuery.WithContext(ctx).Create(owner, reporter, admin)
|
|
|
|
tenant := &models.Tenant{UserID: owner.ID, Code: "t-report-batch", Name: "Report Batch Tenant", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
contentA := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Batch Report A",
|
|
Status: consts.ContentStatusPublished,
|
|
}
|
|
contentB := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Batch Report B",
|
|
Status: consts.ContentStatusPublished,
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(contentA, contentB)
|
|
|
|
Convey("should batch approve reports and unpublish contents", func() {
|
|
reportA := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: contentA.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "spam",
|
|
Detail: "批量举报A",
|
|
Status: "pending",
|
|
}
|
|
reportB := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: contentB.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "abuse",
|
|
Detail: "批量举报B",
|
|
Status: "pending",
|
|
}
|
|
models.ContentReportQuery.WithContext(ctx).Create(reportA, reportB)
|
|
|
|
err := Super.BatchProcessContentReports(ctx, admin.ID, &super_dto.SuperContentReportBatchProcessForm{
|
|
ReportIDs: []int64{reportA.ID, reportB.ID},
|
|
Action: "approve",
|
|
ContentAction: "unpublish",
|
|
Reason: "集中处理",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloadedA, err := models.ContentReportQuery.WithContext(ctx).Where(models.ContentReportQuery.ID.Eq(reportA.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloadedA.Status, ShouldEqual, "approved")
|
|
So(reloadedA.HandledBy, ShouldEqual, admin.ID)
|
|
So(reloadedA.HandledAction, ShouldEqual, "unpublish")
|
|
So(reloadedA.HandledReason, ShouldEqual, "集中处理")
|
|
So(reloadedA.HandledAt.IsZero(), ShouldBeFalse)
|
|
|
|
reloadedB, err := models.ContentReportQuery.WithContext(ctx).Where(models.ContentReportQuery.ID.Eq(reportB.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloadedB.Status, ShouldEqual, "approved")
|
|
So(reloadedB.HandledAction, ShouldEqual, "unpublish")
|
|
|
|
contentReloadA, err := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(contentA.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(contentReloadA.Status, ShouldEqual, consts.ContentStatusUnpublished)
|
|
|
|
contentReloadB, err := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(contentB.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(contentReloadB.Status, ShouldEqual, consts.ContentStatusUnpublished)
|
|
})
|
|
|
|
Convey("should reject when report already handled", func() {
|
|
report := &models.ContentReport{
|
|
TenantID: tenant.ID,
|
|
ContentID: contentA.ID,
|
|
ReporterID: reporter.ID,
|
|
Reason: "other",
|
|
Detail: "已处理",
|
|
Status: "approved",
|
|
}
|
|
models.ContentReportQuery.WithContext(ctx).Create(report)
|
|
|
|
err := Super.BatchProcessContentReports(ctx, admin.ID, &super_dto.SuperContentReportBatchProcessForm{
|
|
ReportIDs: []int64{report.ID},
|
|
Action: "reject",
|
|
Reason: "重复提交",
|
|
})
|
|
So(err, ShouldNotBeNil)
|
|
|
|
var appErr *errorx.AppError
|
|
So(errors.As(err, &appErr), ShouldBeTrue)
|
|
So(appErr.Code, ShouldEqual, errorx.ErrStatusConflict.Code)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_FinanceAnomalies() {
|
|
Convey("Finance Anomalies", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameOrder, models.TableNameTenant, models.TableNameUser)
|
|
|
|
user := &models.User{Username: "finance_user", Balance: -100}
|
|
models.UserQuery.WithContext(ctx).Create(user)
|
|
|
|
tenant := &models.Tenant{UserID: user.ID, Code: "t-fin", Name: "Finance Tenant", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
order := &models.Order{
|
|
TenantID: tenant.ID,
|
|
UserID: user.ID,
|
|
Type: consts.OrderTypeRecharge,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 100,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 100,
|
|
IdempotencyKey: "anomaly-paid",
|
|
}
|
|
models.OrderQuery.WithContext(ctx).Create(order)
|
|
|
|
Convey("should list balance anomalies", func() {
|
|
filter := &super_dto.SuperBalanceAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListBalanceAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
items := res.Items.([]super_dto.SuperBalanceAnomalyItem)
|
|
So(items[0].UserID, ShouldEqual, user.ID)
|
|
So(items[0].Issue, ShouldEqual, "negative_balance")
|
|
})
|
|
|
|
Convey("should list order anomalies", func() {
|
|
filter := &super_dto.SuperOrderAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.ListOrderAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 1)
|
|
items := res.Items.([]super_dto.SuperOrderAnomalyItem)
|
|
So(items[0].OrderID, ShouldEqual, order.ID)
|
|
So(items[0].Issue, ShouldEqual, "missing_paid_at")
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_FinanceAnomalySorting() {
|
|
Convey("Finance Anomaly Sorting", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameOrder, models.TableNameTenant, models.TableNameUser)
|
|
|
|
now := time.Now().Truncate(time.Second)
|
|
userOld := &models.User{Username: "balance_old", Balance: -100, CreatedAt: now.Add(-2 * time.Hour)}
|
|
userNew := &models.User{Username: "balance_new", Balance: -200, CreatedAt: now.Add(-1 * time.Hour)}
|
|
models.UserQuery.WithContext(ctx).Create(userOld, userNew)
|
|
|
|
orderOwner := &models.User{Username: "order_anomaly_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(orderOwner)
|
|
|
|
tenant := &models.Tenant{UserID: orderOwner.ID, Code: "t-anomaly-sort", Name: "Anomaly Sort Tenant", Status: consts.TenantStatusVerified}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
order1 := &models.Order{
|
|
TenantID: tenant.ID,
|
|
UserID: orderOwner.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 100,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 100,
|
|
IdempotencyKey: "anomaly-sort-1",
|
|
}
|
|
order2 := &models.Order{
|
|
TenantID: tenant.ID,
|
|
UserID: orderOwner.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountOriginal: 200,
|
|
AmountDiscount: 0,
|
|
AmountPaid: 200,
|
|
IdempotencyKey: "anomaly-sort-2",
|
|
}
|
|
models.OrderQuery.WithContext(ctx).Create(order1, order2)
|
|
|
|
Convey("should sort balance anomalies by created_at asc", func() {
|
|
filter := &super_dto.SuperBalanceAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Asc: lo.ToPtr("created_at"),
|
|
}
|
|
res, err := Super.ListBalanceAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.SuperBalanceAnomalyItem)
|
|
So(items[0].UserID, ShouldEqual, userOld.ID)
|
|
So(items[1].UserID, ShouldEqual, userNew.ID)
|
|
})
|
|
|
|
Convey("should sort balance anomalies by user_id desc", func() {
|
|
filter := &super_dto.SuperBalanceAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Desc: lo.ToPtr("user_id"),
|
|
}
|
|
res, err := Super.ListBalanceAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.SuperBalanceAnomalyItem)
|
|
So(items[0].UserID, ShouldEqual, userNew.ID)
|
|
})
|
|
|
|
Convey("should sort order anomalies by order_id asc", func() {
|
|
filter := &super_dto.SuperOrderAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Asc: lo.ToPtr("order_id"),
|
|
}
|
|
res, err := Super.ListOrderAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.SuperOrderAnomalyItem)
|
|
So(items[0].OrderID, ShouldEqual, order1.ID)
|
|
So(items[1].OrderID, ShouldEqual, order2.ID)
|
|
})
|
|
|
|
Convey("should sort order anomalies by order_id desc", func() {
|
|
filter := &super_dto.SuperOrderAnomalyFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
Desc: lo.ToPtr("order_id"),
|
|
}
|
|
res, err := Super.ListOrderAnomalies(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
items := res.Items.([]super_dto.SuperOrderAnomalyItem)
|
|
So(items[0].OrderID, ShouldEqual, order2.ID)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_TenantHealth() {
|
|
Convey("TenantHealth", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(
|
|
ctx,
|
|
s.DB,
|
|
models.TableNameUser,
|
|
models.TableNameTenant,
|
|
models.TableNameTenantUser,
|
|
models.TableNameContent,
|
|
models.TableNameOrder,
|
|
)
|
|
|
|
owner1 := &models.User{Username: "health_owner_1"}
|
|
owner2 := &models.User{Username: "health_owner_2"}
|
|
models.UserQuery.WithContext(ctx).Create(owner1, owner2)
|
|
|
|
tenant1 := &models.Tenant{
|
|
UserID: owner1.ID,
|
|
Name: "Health Tenant 1",
|
|
Code: "health1",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
tenant2 := &models.Tenant{
|
|
UserID: owner2.ID,
|
|
Name: "Health Tenant 2",
|
|
Code: "health2",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant1, tenant2)
|
|
|
|
models.TenantUserQuery.WithContext(ctx).Create(
|
|
&models.TenantUser{TenantID: tenant1.ID, UserID: owner1.ID},
|
|
&models.TenantUser{TenantID: tenant2.ID, UserID: owner2.ID},
|
|
)
|
|
|
|
models.ContentQuery.WithContext(ctx).Create(
|
|
&models.Content{
|
|
TenantID: tenant1.ID,
|
|
UserID: owner1.ID,
|
|
Title: "Content H1",
|
|
Status: consts.ContentStatusPublished,
|
|
},
|
|
&models.Content{
|
|
TenantID: tenant2.ID,
|
|
UserID: owner2.ID,
|
|
Title: "Content H2",
|
|
Status: consts.ContentStatusPublished,
|
|
},
|
|
)
|
|
|
|
now := time.Now().Truncate(time.Second)
|
|
models.OrderQuery.WithContext(ctx).Create(
|
|
&models.Order{
|
|
TenantID: tenant1.ID,
|
|
UserID: owner1.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountPaid: 1000,
|
|
PaidAt: now,
|
|
},
|
|
&models.Order{
|
|
TenantID: tenant2.ID,
|
|
UserID: owner2.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountPaid: 1000,
|
|
PaidAt: now,
|
|
},
|
|
&models.Order{
|
|
TenantID: tenant2.ID,
|
|
UserID: owner2.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusRefunded,
|
|
AmountPaid: 1000,
|
|
UpdatedAt: now,
|
|
},
|
|
)
|
|
|
|
filter := &super_dto.TenantListFilter{
|
|
Pagination: requests.Pagination{Page: 1, Limit: 10},
|
|
}
|
|
res, err := Super.TenantHealth(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.Total, ShouldEqual, 2)
|
|
|
|
items := res.Items.([]super_dto.TenantHealthItem)
|
|
itemMap := make(map[int64]super_dto.TenantHealthItem, len(items))
|
|
for _, item := range items {
|
|
itemMap[item.TenantID] = item
|
|
}
|
|
|
|
So(itemMap[tenant1.ID].PaidOrders, ShouldEqual, 1)
|
|
So(itemMap[tenant1.ID].RefundOrders, ShouldEqual, 0)
|
|
So(itemMap[tenant1.ID].HealthLevel, ShouldEqual, "healthy")
|
|
|
|
So(itemMap[tenant2.ID].PaidOrders, ShouldEqual, 1)
|
|
So(itemMap[tenant2.ID].RefundOrders, ShouldEqual, 1)
|
|
So(itemMap[tenant2.ID].HealthLevel, ShouldEqual, "risk")
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_HealthOverview() {
|
|
Convey("HealthOverview", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(
|
|
ctx,
|
|
s.DB,
|
|
models.TableNameUser,
|
|
models.TableNameTenant,
|
|
models.TableNameTenantUser,
|
|
models.TableNameContent,
|
|
models.TableNameOrder,
|
|
models.TableNameMediaAsset,
|
|
)
|
|
|
|
owner := &models.User{Username: "health_overview_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Health Overview",
|
|
Code: "health_overview",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
models.TenantUserQuery.WithContext(ctx).Create(&models.TenantUser{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
})
|
|
|
|
models.ContentQuery.WithContext(ctx).Create(&models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Health Content",
|
|
Status: consts.ContentStatusPublished,
|
|
})
|
|
|
|
now := time.Now()
|
|
models.OrderQuery.WithContext(ctx).Create(
|
|
&models.Order{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountPaid: 1000,
|
|
PaidAt: now,
|
|
CreatedAt: now,
|
|
},
|
|
&models.Order{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusFailed,
|
|
AmountPaid: 1000,
|
|
UpdatedAt: now,
|
|
CreatedAt: now,
|
|
},
|
|
)
|
|
|
|
models.MediaAssetQuery.WithContext(ctx).Create(
|
|
&models.MediaAsset{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
ObjectKey: "failed.mp4",
|
|
Type: consts.MediaAssetTypeVideo,
|
|
Status: consts.MediaAssetStatusFailed,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
},
|
|
&models.MediaAsset{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
ObjectKey: "ready.mp4",
|
|
Type: consts.MediaAssetTypeVideo,
|
|
Status: consts.MediaAssetStatusReady,
|
|
CreatedAt: now,
|
|
UpdatedAt: now,
|
|
},
|
|
&models.MediaAsset{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
ObjectKey: "processing.mp4",
|
|
Type: consts.MediaAssetTypeVideo,
|
|
Status: consts.MediaAssetStatusProcessing,
|
|
CreatedAt: now.Add(-48 * time.Hour),
|
|
UpdatedAt: now.Add(-48 * time.Hour),
|
|
},
|
|
)
|
|
|
|
startAt := now.AddDate(0, 0, -7).Format(time.RFC3339)
|
|
endAt := now.Add(time.Second).Format(time.RFC3339)
|
|
filter := &super_dto.SuperHealthOverviewFilter{
|
|
TenantID: &tenant.ID,
|
|
StartAt: &startAt,
|
|
EndAt: &endAt,
|
|
UploadStuckHours: lo.ToPtr(int64(24)),
|
|
}
|
|
|
|
res, err := Super.HealthOverview(ctx, filter)
|
|
So(err, ShouldBeNil)
|
|
So(res.TenantTotal, ShouldEqual, 1)
|
|
So(res.OrderTotal, ShouldEqual, 2)
|
|
So(res.OrderFailed, ShouldEqual, 1)
|
|
So(res.UploadTotal, ShouldEqual, 3)
|
|
So(res.UploadFailed, ShouldEqual, 1)
|
|
So(res.UploadProcessingStuck, ShouldEqual, 1)
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_ContentReview() {
|
|
Convey("ContentReview", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser, models.TableNameTenant, models.TableNameContent)
|
|
|
|
admin := &models.User{Username: "review_admin"}
|
|
owner := &models.User{Username: "review_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(admin, owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Review Tenant",
|
|
Code: "review",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
content := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Review Content",
|
|
Status: consts.ContentStatusReviewing,
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(content)
|
|
|
|
err := Super.ReviewContent(ctx, admin.ID, content.ID, &super_dto.SuperContentReviewForm{
|
|
Action: "approve",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded, _ := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content.ID)).First()
|
|
So(reloaded.Status, ShouldEqual, consts.ContentStatusPublished)
|
|
So(reloaded.PublishedAt.IsZero(), ShouldBeFalse)
|
|
|
|
content2 := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Review Content 2",
|
|
Status: consts.ContentStatusReviewing,
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(content2)
|
|
|
|
err = Super.ReviewContent(ctx, admin.ID, content2.ID, &super_dto.SuperContentReviewForm{
|
|
Action: "reject",
|
|
Reason: "Policy violation",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded2, _ := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content2.ID)).First()
|
|
So(reloaded2.Status, ShouldEqual, consts.ContentStatusBlocked)
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_BatchUpdateContentStatus() {
|
|
Convey("BatchUpdateContentStatus", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser, models.TableNameTenant, models.TableNameContent)
|
|
|
|
admin := &models.User{Username: "batch_admin"}
|
|
owner := &models.User{Username: "batch_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(admin, owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Batch Tenant",
|
|
Code: "batch",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
content1 := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Batch Content 1",
|
|
Status: consts.ContentStatusPublished,
|
|
}
|
|
content2 := &models.Content{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Title: "Batch Content 2",
|
|
Status: consts.ContentStatusUnpublished,
|
|
}
|
|
models.ContentQuery.WithContext(ctx).Create(content1, content2)
|
|
|
|
err := Super.BatchUpdateContentStatus(ctx, admin.ID, &super_dto.SuperContentBatchStatusForm{
|
|
ContentIDs: []int64{content1.ID, content2.ID},
|
|
Status: consts.ContentStatusBlocked,
|
|
Reason: "违规处理",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded1, _ := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content1.ID)).First()
|
|
reloaded2, _ := models.ContentQuery.WithContext(ctx).Where(models.ContentQuery.ID.Eq(content2.ID)).First()
|
|
So(reloaded1.Status, ShouldEqual, consts.ContentStatusBlocked)
|
|
So(reloaded2.Status, ShouldEqual, consts.ContentStatusBlocked)
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_OrderGovernance() {
|
|
Convey("OrderGovernance", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameOrder, models.TableNameAuditLog)
|
|
|
|
newOrder := func() *models.Order {
|
|
o := &models.Order{
|
|
TenantID: 1,
|
|
UserID: 2,
|
|
Type: consts.OrderTypeContentPurchase,
|
|
Status: consts.OrderStatusPaid,
|
|
AmountPaid: 100,
|
|
}
|
|
So(models.OrderQuery.WithContext(ctx).Create(o), ShouldBeNil)
|
|
return o
|
|
}
|
|
|
|
operatorID := int64(9001)
|
|
|
|
Convey("should require reason when flagging", func() {
|
|
o := newOrder()
|
|
err := Super.FlagOrder(ctx, operatorID, o.ID, &super_dto.SuperOrderFlagForm{
|
|
IsFlagged: true,
|
|
})
|
|
So(err, ShouldNotBeNil)
|
|
|
|
var appErr *errorx.AppError
|
|
So(errors.As(err, &appErr), ShouldBeTrue)
|
|
So(appErr.Code, ShouldEqual, errorx.ErrBadRequest.Code)
|
|
})
|
|
|
|
Convey("should flag and unflag order", func() {
|
|
o := newOrder()
|
|
reason := "支付回调异常"
|
|
|
|
So(Super.FlagOrder(ctx, operatorID, o.ID, &super_dto.SuperOrderFlagForm{
|
|
IsFlagged: true,
|
|
Reason: reason,
|
|
}), ShouldBeNil)
|
|
|
|
reloaded, err := models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.IsFlagged, ShouldBeTrue)
|
|
So(reloaded.FlagReason, ShouldEqual, reason)
|
|
So(reloaded.FlaggedBy, ShouldEqual, operatorID)
|
|
So(reloaded.FlaggedAt.IsZero(), ShouldBeFalse)
|
|
|
|
So(Super.FlagOrder(ctx, operatorID, o.ID, &super_dto.SuperOrderFlagForm{
|
|
IsFlagged: false,
|
|
}), ShouldBeNil)
|
|
|
|
reloaded, err = models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.IsFlagged, ShouldBeFalse)
|
|
So(reloaded.FlagReason, ShouldEqual, "")
|
|
So(reloaded.FlaggedBy, ShouldEqual, int64(0))
|
|
So(reloaded.FlaggedAt.IsZero(), ShouldBeTrue)
|
|
})
|
|
|
|
Convey("should reconcile and unreconcile order", func() {
|
|
o := newOrder()
|
|
note := "对账完成"
|
|
|
|
So(Super.ReconcileOrder(ctx, operatorID, o.ID, &super_dto.SuperOrderReconcileForm{
|
|
IsReconciled: true,
|
|
Note: note,
|
|
}), ShouldBeNil)
|
|
|
|
reloaded, err := models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.IsReconciled, ShouldBeTrue)
|
|
So(reloaded.ReconcileNote, ShouldEqual, note)
|
|
So(reloaded.ReconciledBy, ShouldEqual, operatorID)
|
|
So(reloaded.ReconciledAt.IsZero(), ShouldBeFalse)
|
|
|
|
So(Super.ReconcileOrder(ctx, operatorID, o.ID, &super_dto.SuperOrderReconcileForm{
|
|
IsReconciled: false,
|
|
}), ShouldBeNil)
|
|
|
|
reloaded, err = models.OrderQuery.WithContext(ctx).Where(models.OrderQuery.ID.Eq(o.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(reloaded.IsReconciled, ShouldBeFalse)
|
|
So(reloaded.ReconcileNote, ShouldEqual, "")
|
|
So(reloaded.ReconciledBy, ShouldEqual, int64(0))
|
|
So(reloaded.ReconciledAt.IsZero(), ShouldBeTrue)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_PayoutAccountReview() {
|
|
Convey("PayoutAccountReview", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNamePayoutAccount, models.TableNameUser, models.TableNameTenant)
|
|
|
|
admin := &models.User{Username: "payout_admin"}
|
|
owner := &models.User{Username: "payout_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(admin, owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Payout Tenant",
|
|
Code: "payout",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
account := &models.PayoutAccount{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Type: consts.PayoutAccountTypeBank,
|
|
Name: "Bank",
|
|
Account: "123",
|
|
Realname: "Owner",
|
|
Status: consts.PayoutAccountStatusPending,
|
|
}
|
|
models.PayoutAccountQuery.WithContext(ctx).Create(account)
|
|
|
|
Convey("should approve payout account", func() {
|
|
err := Super.ReviewPayoutAccount(ctx, admin.ID, account.ID, &super_dto.SuperPayoutAccountReviewForm{
|
|
Action: "approve",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
reloaded, _ := models.PayoutAccountQuery.WithContext(ctx).Where(models.PayoutAccountQuery.ID.Eq(account.ID)).First()
|
|
So(reloaded.Status, ShouldEqual, consts.PayoutAccountStatusApproved)
|
|
So(reloaded.ReviewedBy, ShouldEqual, admin.ID)
|
|
So(reloaded.ReviewedAt.IsZero(), ShouldBeFalse)
|
|
})
|
|
|
|
Convey("should require reason when rejecting", func() {
|
|
account2 := &models.PayoutAccount{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Type: consts.PayoutAccountTypeAlipay,
|
|
Name: "Alipay",
|
|
Account: "user@example.com",
|
|
Realname: "Owner",
|
|
Status: consts.PayoutAccountStatusPending,
|
|
}
|
|
models.PayoutAccountQuery.WithContext(ctx).Create(account2)
|
|
|
|
err := Super.ReviewPayoutAccount(ctx, admin.ID, account2.ID, &super_dto.SuperPayoutAccountReviewForm{
|
|
Action: "reject",
|
|
})
|
|
So(err, ShouldNotBeNil)
|
|
|
|
var appErr *errorx.AppError
|
|
So(errors.As(err, &appErr), ShouldBeTrue)
|
|
So(appErr.Code, ShouldEqual, errorx.ErrBadRequest.Code)
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_UpdateUserProfile() {
|
|
Convey("UpdateUserProfile", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameUser)
|
|
|
|
meta := types.JSON([]byte(`{"real_name":"Old Name","id_card":"ENC:1111"}`))
|
|
u := &models.User{
|
|
Username: "profile_user",
|
|
Nickname: "Old",
|
|
Avatar: "http://old-avatar",
|
|
Gender: consts.GenderSecret,
|
|
Bio: "old bio",
|
|
Metas: meta,
|
|
}
|
|
models.UserQuery.WithContext(ctx).Create(u)
|
|
|
|
Convey("should update profile fields and real-name meta", func() {
|
|
form := &super_dto.SuperUserProfileUpdateForm{
|
|
Nickname: lo.ToPtr("New Nick"),
|
|
Avatar: lo.ToPtr("http://new-avatar"),
|
|
Gender: lo.ToPtr(consts.GenderMale),
|
|
Bio: lo.ToPtr("new bio"),
|
|
IsRealNameVerified: lo.ToPtr(true),
|
|
RealName: lo.ToPtr("New Name"),
|
|
IDCard: lo.ToPtr("123456789012345678"),
|
|
}
|
|
err := Super.UpdateUserProfile(ctx, 1001, u.ID, form)
|
|
So(err, ShouldBeNil)
|
|
|
|
updated, err := models.UserQuery.WithContext(ctx).Where(models.UserQuery.ID.Eq(u.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(updated.Nickname, ShouldEqual, "New Nick")
|
|
So(updated.Avatar, ShouldEqual, "http://new-avatar")
|
|
So(updated.Gender, ShouldEqual, consts.GenderMale)
|
|
So(updated.Bio, ShouldEqual, "new bio")
|
|
So(updated.IsRealNameVerified, ShouldBeTrue)
|
|
So(updated.VerifiedAt.IsZero(), ShouldBeFalse)
|
|
|
|
metaMap := make(map[string]interface{})
|
|
So(json.Unmarshal(updated.Metas, &metaMap), ShouldBeNil)
|
|
So(metaMap["real_name"], ShouldEqual, "New Name")
|
|
So(metaMap["id_card"], ShouldEqual, "ENC:123456789012345678")
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_UpdateCreatorSettings() {
|
|
Convey("UpdateCreatorSettings", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameTenant, models.TableNameUser)
|
|
|
|
owner := &models.User{Username: "settings_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Old Tenant",
|
|
Code: "creator-settings",
|
|
Status: consts.TenantStatusVerified,
|
|
Config: types.NewJSONType(fields.TenantConfig{}),
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
form := &v1_dto.Settings{
|
|
Name: "New Tenant",
|
|
Bio: "new bio",
|
|
Avatar: "http://avatar",
|
|
Cover: "http://cover",
|
|
Description: "new description",
|
|
}
|
|
err := Super.UpdateCreatorSettings(ctx, 2001, tenant.ID, form)
|
|
So(err, ShouldBeNil)
|
|
|
|
updated, err := models.TenantQuery.WithContext(ctx).Where(models.TenantQuery.ID.Eq(tenant.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(updated.Name, ShouldEqual, "New Tenant")
|
|
cfg := updated.Config.Data()
|
|
So(cfg.Bio, ShouldEqual, "new bio")
|
|
So(cfg.Avatar, ShouldEqual, "http://avatar")
|
|
So(cfg.Cover, ShouldEqual, "http://cover")
|
|
So(cfg.Description, ShouldEqual, "new description")
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_PayoutAccountCreateUpdate() {
|
|
Convey("PayoutAccountCreateUpdate", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNamePayoutAccount, models.TableNameUser, models.TableNameTenant)
|
|
|
|
admin := &models.User{Username: "payout_admin_2"}
|
|
owner := &models.User{Username: "payout_owner_2"}
|
|
models.UserQuery.WithContext(ctx).Create(admin, owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Payout Tenant 2",
|
|
Code: "payout-2",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
Convey("should create payout account", func() {
|
|
err := Super.CreatePayoutAccount(ctx, admin.ID, tenant.ID, &super_dto.SuperPayoutAccountCreateForm{
|
|
UserID: owner.ID,
|
|
Type: "bank",
|
|
Name: "Bank",
|
|
Account: "123",
|
|
Realname: "Owner",
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
account, err := models.PayoutAccountQuery.WithContext(ctx).
|
|
Where(models.PayoutAccountQuery.TenantID.Eq(tenant.ID), models.PayoutAccountQuery.UserID.Eq(owner.ID)).
|
|
First()
|
|
So(err, ShouldBeNil)
|
|
So(account.Status, ShouldEqual, consts.PayoutAccountStatusPending)
|
|
})
|
|
|
|
Convey("should reset status when updating approved account", func() {
|
|
account := &models.PayoutAccount{
|
|
TenantID: tenant.ID,
|
|
UserID: owner.ID,
|
|
Type: consts.PayoutAccountTypeBank,
|
|
Name: "Bank",
|
|
Account: "111",
|
|
Realname: "Owner",
|
|
Status: consts.PayoutAccountStatusApproved,
|
|
ReviewedBy: admin.ID,
|
|
ReviewReason: "ok",
|
|
ReviewedAt: time.Now(),
|
|
}
|
|
models.PayoutAccountQuery.WithContext(ctx).Create(account)
|
|
|
|
err := Super.UpdatePayoutAccount(ctx, admin.ID, account.ID, &super_dto.SuperPayoutAccountUpdateForm{
|
|
Account: lo.ToPtr("222"),
|
|
})
|
|
So(err, ShouldBeNil)
|
|
|
|
updated, err := models.PayoutAccountQuery.WithContext(ctx).Where(models.PayoutAccountQuery.ID.Eq(account.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(updated.Account, ShouldEqual, "222")
|
|
So(updated.Status, ShouldEqual, consts.PayoutAccountStatusPending)
|
|
So(updated.ReviewedBy, ShouldEqual, int64(0))
|
|
So(updated.ReviewReason, ShouldEqual, "")
|
|
})
|
|
})
|
|
}
|
|
|
|
func (s *SuperTestSuite) Test_UpdateNotificationTemplate() {
|
|
Convey("UpdateNotificationTemplate", s.T(), func() {
|
|
ctx := s.T().Context()
|
|
database.Truncate(ctx, s.DB, models.TableNameNotificationTemplate, models.TableNameTenant, models.TableNameUser)
|
|
|
|
owner := &models.User{Username: "tmpl_owner"}
|
|
models.UserQuery.WithContext(ctx).Create(owner)
|
|
|
|
tenant := &models.Tenant{
|
|
UserID: owner.ID,
|
|
Name: "Template Tenant",
|
|
Code: "tmpl",
|
|
Status: consts.TenantStatusVerified,
|
|
}
|
|
models.TenantQuery.WithContext(ctx).Create(tenant)
|
|
|
|
tmpl := &models.NotificationTemplate{
|
|
TenantID: tenant.ID,
|
|
Name: "Old Template",
|
|
Type: consts.NotificationTypeSystem,
|
|
Title: "Old Title",
|
|
Content: "Old Content",
|
|
IsActive: true,
|
|
}
|
|
models.NotificationTemplateQuery.WithContext(ctx).Create(tmpl)
|
|
|
|
item, err := Super.UpdateNotificationTemplate(ctx, 3001, tmpl.ID, &super_dto.SuperNotificationTemplateUpdateForm{
|
|
Name: lo.ToPtr("New Template"),
|
|
Title: lo.ToPtr("New Title"),
|
|
Content: lo.ToPtr("New Content"),
|
|
IsActive: lo.ToPtr(false),
|
|
})
|
|
So(err, ShouldBeNil)
|
|
So(item.Name, ShouldEqual, "New Template")
|
|
So(item.IsActive, ShouldBeFalse)
|
|
|
|
updated, err := models.NotificationTemplateQuery.WithContext(ctx).Where(models.NotificationTemplateQuery.ID.Eq(tmpl.ID)).First()
|
|
So(err, ShouldBeNil)
|
|
So(updated.Title, ShouldEqual, "New Title")
|
|
So(updated.Content, ShouldEqual, "New Content")
|
|
So(updated.IsActive, ShouldBeFalse)
|
|
})
|
|
}
|