408 lines
17 KiB
Go
408 lines
17 KiB
Go
package withdrawal
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"hfb_sys/backend/internal/database"
|
|
"hfb_sys/backend/internal/model"
|
|
"hfb_sys/backend/internal/modules/wallet"
|
|
"hfb_sys/backend/pkg/crypto"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/logger"
|
|
)
|
|
|
|
type withdrawalFixture struct {
|
|
db *gorm.DB
|
|
repo *Repository
|
|
userID uint64
|
|
adminID uint64
|
|
accountID uint64
|
|
}
|
|
|
|
func newWithdrawalFixture(t *testing.T) withdrawalFixture {
|
|
t.Helper()
|
|
db := database.NewTestDB()
|
|
if err := database.AutoMigrateIfMissing(db,
|
|
&model.User{},
|
|
&model.AdminUser{},
|
|
&model.UserPaymentAccount{},
|
|
&model.WithdrawalRequest{},
|
|
&model.WalletAccount{},
|
|
&model.WalletLedger{},
|
|
&model.RentalListing{},
|
|
&model.RentalOrder{},
|
|
&model.GameAccount{},
|
|
&model.AdminPickup{},
|
|
&model.AdminPickupFinancialAdjustment{},
|
|
&model.DistributionSite{},
|
|
); err != nil {
|
|
t.Fatalf("migrate fixture: %v", err)
|
|
}
|
|
|
|
user := model.User{Phone: "13800000001", Nickname: "test-user", Status: "active"}
|
|
admin := model.AdminUser{Username: "reviewer", PasswordHash: "test", Nickname: "reviewer", Status: "active"}
|
|
if err := db.Create(&user).Error; err != nil {
|
|
t.Fatalf("create user: %v", err)
|
|
}
|
|
if err := db.Create(&admin).Error; err != nil {
|
|
t.Fatalf("create admin: %v", err)
|
|
}
|
|
account := model.UserPaymentAccount{
|
|
UserID: user.ID, AccountType: "bank", AccountName: "Test User",
|
|
AccountNo: "6222021234567890", BankName: "Test Bank", Status: "active",
|
|
}
|
|
if err := db.Create(&account).Error; err != nil {
|
|
t.Fatalf("create payment account: %v", err)
|
|
}
|
|
if err := db.Create(&model.WalletAccount{
|
|
UserID: user.ID, AvailableBalanceCent: 100_000, Status: "active",
|
|
}).Error; err != nil {
|
|
t.Fatalf("create wallet: %v", err)
|
|
}
|
|
|
|
return withdrawalFixture{
|
|
db: db, repo: NewRepository(db, wallet.NewRepository(db), &crypto.MockEncryptor{}),
|
|
userID: user.ID, adminID: admin.ID, accountID: account.ID,
|
|
}
|
|
}
|
|
|
|
type withdrawalQueryCounter struct {
|
|
logger.Interface
|
|
count int
|
|
}
|
|
|
|
func (c *withdrawalQueryCounter) Trace(_ context.Context, _ time.Time, fc func() (string, int64), _ error) {
|
|
c.count++
|
|
fc()
|
|
}
|
|
|
|
func TestAdminListUsesBatchQueries(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
for i := 0; i < 5; i++ {
|
|
item := model.WithdrawalRequest{
|
|
WithdrawNo: "WD-BATCH-" + string(rune('A'+i)),
|
|
UserID: f.userID,
|
|
AmountCent: int64(1000 + i),
|
|
ActualAmountCent: int64(1000 + i),
|
|
AccountType: "bank",
|
|
AccountName: "Test User",
|
|
AccountNo: "****0000",
|
|
Status: "pending",
|
|
}
|
|
if err := f.db.Create(&item).Error; err != nil {
|
|
t.Fatalf("create withdrawal: %v", err)
|
|
}
|
|
}
|
|
|
|
counter := &withdrawalQueryCounter{Interface: logger.Default.LogMode(logger.Silent)}
|
|
repo := NewRepository(f.db.Session(&gorm.Session{Logger: counter}), f.repo.walletRepo, f.repo.encryptor)
|
|
result, err := repo.AdminList(context.Background(), AdminListQuery{Page: 1, Size: 20})
|
|
if err != nil {
|
|
t.Fatalf("AdminList failed: %v", err)
|
|
}
|
|
if len(result.Items) != 5 {
|
|
t.Fatalf("AdminList items = %d, want 5", len(result.Items))
|
|
}
|
|
if counter.count > 4 {
|
|
t.Fatalf("AdminList queries = %d, want batch queries (<=4)", counter.count)
|
|
}
|
|
}
|
|
|
|
func TestAdminReviewContextSummarizesIncomeAndHistory(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
renter := model.User{Phone: "13800000002", Nickname: "renter", Status: "active"}
|
|
if err := f.db.Create(&renter).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
account := model.GameAccount{OwnerID: f.userID, ServerRegion: "cn", LoginPlatform: "pc", Title: "审核订单"}
|
|
if err := f.db.Create(&account).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
listing := model.RentalListing{ListingNo: "202610280362", AccountID: account.ID, OwnerID: f.userID, Status: "active"}
|
|
if err := f.db.Create(&listing).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
orders := []model.RentalOrder{
|
|
{OrderNo: "RO-WALLET", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", RentAmountCent: 1000, OwnerRentAmountCent: 700},
|
|
{OrderNo: "RO-PLATFORM", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "arbitrated", SettlementMode: "platform_managed", RentAmountCent: 200, OwnerRentAmountCent: 100, OfflineSettlementStatus: "settled", OfflineSettlementAmountCent: 100},
|
|
{OrderNo: "RO-OPEN", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "renting", SettlementStatus: "unsettled", SettlementMode: "owner_wallet"},
|
|
}
|
|
for i := range orders {
|
|
if err := f.db.Create(&orders[i]).Error; err != nil {
|
|
t.Fatalf("create order: %v", err)
|
|
}
|
|
}
|
|
|
|
orderID := orders[0].ID
|
|
ledgers := []model.WalletLedger{
|
|
{LedgerNo: "WL-OWNER-INCOME", UserID: f.userID, OrderID: &orderID, Direction: "in", AmountCent: 700, BalanceType: "available", BizType: "owner_income", BizNo: "RO-WALLET"},
|
|
{LedgerNo: "WL-DEPOSIT-COMP", UserID: f.userID, OrderID: &orderID, Direction: "in", AmountCent: 50, BalanceType: "available", BizType: "deposit_compensation", BizNo: "RO-WALLET"},
|
|
}
|
|
if err := f.db.Create(&ledgers).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
now := time.Now()
|
|
pickups := []model.AdminPickup{
|
|
{PickupNo: "PK-WALLET", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 200, CompletedAt: &now},
|
|
{PickupNo: "PK-PLATFORM", ListingID: listing.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "platform_managed", SettleAmountCent: 100, OfflineSettlementStatus: "settled", CompletedAt: &now},
|
|
}
|
|
if err := f.db.Create(&pickups).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
adjustments := []model.AdminPickupFinancialAdjustment{
|
|
{PickupID: pickups[0].ID, SettleDeltaCent: 50, SettlementMode: "owner_wallet", Status: "settled", Reason: "补款", CreatedBy: f.adminID},
|
|
{PickupID: pickups[1].ID, SettleDeltaCent: 20, SettlementMode: "platform_managed", Status: "settled", Reason: "补款", CreatedBy: f.adminID},
|
|
}
|
|
if err := f.db.Create(&adjustments).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
withdrawals := []model.WithdrawalRequest{
|
|
{WithdrawNo: "WD-CURRENT", UserID: f.userID, AmountCent: 300, ActualAmountCent: 300, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "pending", CreatedAt: now},
|
|
{WithdrawNo: "WD-PAID", UserID: f.userID, AmountCent: 300, ActualAmountCent: 300, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "completed", CreatedAt: now.Add(-time.Hour)},
|
|
{WithdrawNo: "WD-REJECTED", UserID: f.userID, AmountCent: 100, ActualAmountCent: 100, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "rejected", CreatedAt: now.Add(-2 * time.Hour)},
|
|
}
|
|
if err := f.db.Create(&withdrawals).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
contextDTO, err := f.repo.AdminReviewContext(context.Background(), withdrawals[0].ID, WithdrawalReviewContextQuery{PageSize: 10})
|
|
if err != nil {
|
|
t.Fatalf("AdminReviewContext failed: %v", err)
|
|
}
|
|
summary := contextDTO.Summary
|
|
if summary.OwnerOrderCount != 3 || summary.FinalizedOrderCount != 2 {
|
|
t.Fatalf("order summary = %+v", summary)
|
|
}
|
|
if summary.OwnerPickupCount != 2 || summary.PickupIncomeCent != 370 {
|
|
t.Fatalf("pickup summary = %+v", summary)
|
|
}
|
|
if summary.WalletPickupIncomeCent != 250 || summary.PlatformManagedPickupIncomeCent != 120 {
|
|
t.Fatalf("pickup income summary = %+v", summary)
|
|
}
|
|
if summary.WalletActualIncomeCent != 1000 || summary.PlatformManagedIncomeCent != 220 {
|
|
t.Fatalf("income summary = %+v", summary)
|
|
}
|
|
if summary.WithdrawalCount != 3 || summary.WithdrawnAmountCent != 300 || summary.PendingWithdrawalAmountCent != 300 || summary.RejectedWithdrawalCount != 1 {
|
|
t.Fatalf("withdrawal summary = %+v", summary)
|
|
}
|
|
if summary.ReconcileDifferenceAmountCent != 400 {
|
|
t.Fatalf("reconcile difference = %d, want 400", summary.ReconcileDifferenceAmountCent)
|
|
}
|
|
if len(contextDTO.Orders) != 3 || contextDTO.Orders[0].ListingNo != listing.ListingNo {
|
|
t.Fatalf("review orders = %+v", contextDTO.Orders)
|
|
}
|
|
if len(contextDTO.Pickups) != 2 || contextDTO.Pickups[0].ListingNo != listing.ListingNo {
|
|
t.Fatalf("review pickups = %+v", contextDTO.Pickups)
|
|
}
|
|
if len(contextDTO.Withdrawals) != 3 || contextDTO.Withdrawals[0].WithdrawNo != "WD-CURRENT" {
|
|
t.Fatalf("review withdrawals = %+v", contextDTO.Withdrawals)
|
|
}
|
|
}
|
|
|
|
func TestAdminReviewContextScopesIncomeByWithdrawalSite(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
siteA := model.DistributionSite{SiteCode: "audit-a", SiteName: "审核站A", Domain: "a.example.com", Status: "active"}
|
|
siteB := model.DistributionSite{SiteCode: "audit-b", SiteName: "审核站B", Domain: "b.example.com", Status: "active"}
|
|
if err := f.db.Create(&siteA).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.db.Create(&siteB).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
renter := model.User{Phone: "13800000003", Nickname: "renter-site", Status: "active"}
|
|
if err := f.db.Create(&renter).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
account := model.GameAccount{OwnerID: f.userID, ServerRegion: "cn", LoginPlatform: "pc", Title: "分站审核"}
|
|
if err := f.db.Create(&account).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
listingA := model.RentalListing{ListingNo: "SITE-A-LISTING", AccountID: account.ID, OwnerID: f.userID, Status: "active", DistributionSiteID: &siteA.ID}
|
|
listingB := model.RentalListing{ListingNo: "SITE-B-LISTING", AccountID: account.ID, OwnerID: f.userID, Status: "active", DistributionSiteID: &siteB.ID}
|
|
if err := f.db.Create(&listingA).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.db.Create(&listingB).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
orderA := model.RentalOrder{OrderNo: "RO-SITE-A", ListingID: listingA.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", DistributionSiteID: &siteA.ID}
|
|
orderB := model.RentalOrder{OrderNo: "RO-SITE-B", ListingID: listingB.ID, AccountID: account.ID, OwnerID: f.userID, RenterID: renter.ID, Status: "completed", SettlementStatus: "settled", SettlementMode: "owner_wallet", DistributionSiteID: &siteB.ID}
|
|
if err := f.db.Create(&orderA).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.db.Create(&orderB).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.db.Create(&[]model.WalletLedger{
|
|
{LedgerNo: "WL-SITE-A", UserID: f.userID, DistributionSiteID: siteA.ID, OrderID: &orderA.ID, Direction: "in", AmountCent: 100, BalanceType: "available", BizType: "owner_income", BizNo: orderA.OrderNo},
|
|
{LedgerNo: "WL-SITE-B", UserID: f.userID, DistributionSiteID: siteB.ID, OrderID: &orderB.ID, Direction: "in", AmountCent: 999, BalanceType: "available", BizType: "owner_income", BizNo: orderB.OrderNo},
|
|
}).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := f.db.Create(&[]model.AdminPickup{
|
|
{PickupNo: "PK-SITE-A", ListingID: listingA.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 100},
|
|
{PickupNo: "PK-SITE-B", ListingID: listingB.ID, AccountID: account.ID, OwnerID: f.userID, AdminID: f.adminID, Status: "completed", SettlementMode: "owner_wallet", SettleAmountCent: 999},
|
|
}).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
current := model.WithdrawalRequest{WithdrawNo: "WD-SITE-A", UserID: f.userID, DistributionSiteID: siteA.ID, AmountCent: 100, ActualAmountCent: 100, AccountType: "bank", AccountName: "Test User", AccountNo: "****0000", Status: "pending"}
|
|
if err := f.db.Create(¤t).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
contextDTO, err := f.repo.AdminReviewContext(context.Background(), current.ID, WithdrawalReviewContextQuery{PageSize: 10})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if contextDTO.Summary.OwnerOrderCount != 1 || contextDTO.Summary.OwnerPickupCount != 1 {
|
|
t.Fatalf("site-scoped business count = %+v", contextDTO.Summary)
|
|
}
|
|
if contextDTO.Summary.WalletActualIncomeCent != 200 || contextDTO.Summary.WithdrawalCount != 1 {
|
|
t.Fatalf("site-scoped income/withdrawal = %+v", contextDTO.Summary)
|
|
}
|
|
}
|
|
|
|
func (f withdrawalFixture) create(t *testing.T, amountCent int64) *WithdrawalDTO {
|
|
t.Helper()
|
|
dto, err := f.repo.Create(context.Background(), f.userID, CreateWithdrawalRequest{
|
|
PaymentAccountID: f.accountID,
|
|
AmountCent: amountCent,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Create: %v", err)
|
|
}
|
|
return dto
|
|
}
|
|
|
|
func (f withdrawalFixture) assertBalance(t *testing.T, available, frozen int64) {
|
|
t.Helper()
|
|
var account model.WalletAccount
|
|
if err := f.db.Where("user_id = ?", f.userID).First(&account).Error; err != nil {
|
|
t.Fatalf("load wallet: %v", err)
|
|
}
|
|
if account.AvailableBalanceCent != available || account.FrozenBalanceCent != frozen {
|
|
t.Fatalf("balance = available:%d frozen:%d, want available:%d frozen:%d",
|
|
account.AvailableBalanceCent, account.FrozenBalanceCent, available, frozen)
|
|
}
|
|
}
|
|
|
|
func TestWithdrawalCreateAndCancelPreservesBalance(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
dto := f.create(t, 20_000)
|
|
if dto.Status != "pending" || dto.FeeCent != 0 || dto.ActualAmountCent != 20_000 {
|
|
t.Fatalf("created withdrawal = %+v", dto)
|
|
}
|
|
f.assertBalance(t, 80_000, 20_000)
|
|
|
|
if err := f.repo.Cancel(context.Background(), f.userID, dto.ID); err != nil {
|
|
t.Fatalf("Cancel: %v", err)
|
|
}
|
|
f.assertBalance(t, 100_000, 0)
|
|
if err := f.repo.Cancel(context.Background(), f.userID, dto.ID); !errors.Is(err, ErrWithdrawalLocked) {
|
|
t.Fatalf("second Cancel error = %v, want ErrWithdrawalLocked", err)
|
|
}
|
|
f.assertBalance(t, 100_000, 0)
|
|
}
|
|
|
|
func TestWithdrawalRejectedReturnsFrozenBalanceOnce(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
dto := f.create(t, 30_000)
|
|
approved := false
|
|
result, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{
|
|
Approved: &approved,
|
|
Remark: "account mismatch",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Review rejected: %v", err)
|
|
}
|
|
if result.Status != "rejected" || result.ReviewedByName != "reviewer" {
|
|
t.Fatalf("review result = %+v", result)
|
|
}
|
|
f.assertBalance(t, 100_000, 0)
|
|
if _, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{Approved: &approved}); !errors.Is(err, ErrWithdrawalLocked) {
|
|
t.Fatalf("second Review error = %v, want ErrWithdrawalLocked", err)
|
|
}
|
|
}
|
|
|
|
func TestWithdrawalApprovedAndPaidConsumesFrozenBalanceOnce(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
dto := f.create(t, 40_000)
|
|
approved := true
|
|
if _, err := f.repo.Review(context.Background(), f.adminID, dto.ID, ReviewWithdrawalRequest{Approved: &approved}); err != nil {
|
|
t.Fatalf("Review approved: %v", err)
|
|
}
|
|
f.assertBalance(t, 60_000, 40_000)
|
|
|
|
result, err := f.repo.ConfirmPayment(context.Background(), f.adminID, dto.ID, ConfirmPaymentRequest{
|
|
PaymentProofURL: "proof/test.png",
|
|
Remark: "paid",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("ConfirmPayment: %v", err)
|
|
}
|
|
if result.Status != "completed" || result.PaidByName != "reviewer" {
|
|
t.Fatalf("payment result = %+v", result)
|
|
}
|
|
f.assertBalance(t, 60_000, 0)
|
|
if _, err := f.repo.ConfirmPayment(context.Background(), f.adminID, dto.ID, ConfirmPaymentRequest{}); !errors.Is(err, ErrWithdrawalLocked) {
|
|
t.Fatalf("second ConfirmPayment error = %v, want ErrWithdrawalLocked", err)
|
|
}
|
|
f.assertBalance(t, 60_000, 0)
|
|
}
|
|
|
|
func TestWithdrawalCreateRollsBackWhenBalanceIsInsufficient(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
_, err := f.repo.Create(context.Background(), f.userID, CreateWithdrawalRequest{
|
|
PaymentAccountID: f.accountID,
|
|
AmountCent: 100_001,
|
|
})
|
|
if !errors.Is(err, wallet.ErrInsufficientBalance) {
|
|
t.Fatalf("Create error = %v, want ErrInsufficientBalance", err)
|
|
}
|
|
var count int64
|
|
if err := f.db.Model(&model.WithdrawalRequest{}).Count(&count).Error; err != nil {
|
|
t.Fatalf("count withdrawals: %v", err)
|
|
}
|
|
if count != 0 {
|
|
t.Fatalf("withdrawal count = %d, want 0", count)
|
|
}
|
|
f.assertBalance(t, 100_000, 0)
|
|
}
|
|
|
|
func TestWithdrawalDetailIncludesDistributionSiteInfo(t *testing.T) {
|
|
f := newWithdrawalFixture(t)
|
|
if err := f.db.AutoMigrate(&model.DistributionSite{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
site := model.DistributionSite{SiteCode: "sub_site", SiteName: "分销子站", Domain: "sub.example.com", Status: "active"}
|
|
if err := f.db.Create(&site).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wReq := model.WithdrawalRequest{
|
|
WithdrawNo: "WD2026TESTSITE",
|
|
UserID: f.userID,
|
|
DistributionSiteID: site.ID,
|
|
AmountCent: 5000,
|
|
ActualAmountCent: 5000,
|
|
Status: "pending",
|
|
}
|
|
if err := f.db.Create(&wReq).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
detail, err := f.repo.AdminFindByID(context.Background(), wReq.ID)
|
|
if err != nil {
|
|
t.Fatalf("AdminFindByID failed: %v", err)
|
|
}
|
|
if detail.DistributionSiteID != site.ID || detail.DistributionSiteName != "分销子站" || detail.DistributionSiteCode != "sub_site" {
|
|
t.Fatalf("unexpected detail site info: %+v", detail)
|
|
}
|
|
}
|