csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

归档一次性佣金配置落库与累计触发修复，同步规范文档到主 specs
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 5m45s
Details

Browse Source 
- 归档 fix-one-time-commission-config-and-accumulation 到 archive/2026-01-29-*
- 同步 delta specs 到主规范（one-time-commission-trigger、commission-calculation）
- 新增累计触发逻辑文档和测试用例
- 修复一次性佣金配置落库和累计充值更新逻辑
This commit is contained in:
huang
2026-01-29 16:00:18 +08:00
parent d977000a66
commit 2b0f79be81
19 changed files with 1654 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
tests/integration/shop_series_allocation_test.go
View File

@@ -354,6 +354,165 @@ func TestShopSeriesAllocationAPI_UpdateStatus(t *testing.T) {
})
}
// ==================== 一次性佣金配置测试 ====================
func TestShopSeriesAllocationAPI_OneTimeCommission(t *testing.T) {
env := integ.NewIntegrationTestEnv(t)
t.Run("创建分配-固定类型一次性佣金配置落库", func(t *testing.T) {
shop := env.CreateTestShop("一次性佣金测试店铺1", 1, nil)
series := createTestPackageSeries(t, env, "一次性佣金测试系列1")
body := map[string]interface{}{
"shop_id": shop.ID,
"series_id": series.ID,
"base_commission": map[string]interface{}{
"mode": "fixed",
"value": 1000,
},
"enable_one_time_commission": true,
"one_time_commission_config": map[string]interface{}{
"type": "fixed",
"trigger": "accumulated_recharge",
"threshold": 10000,
"mode": "fixed",
"value": 500,
},
}
jsonBody, _ := json.Marshal(body)
resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/shop-series-allocations", jsonBody)
require.NoError(t, err)
defer resp.Body.Close()
var result response.Response
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 0, result.Code, "应返回成功: %s", result.Message)
dataMap := result.Data.(map[string]interface{})
assert.Equal(t, true, dataMap["enable_one_time_commission"])
if cfg, ok := dataMap["one_time_commission_config"].(map[string]interface{}); ok {
assert.Equal(t, "fixed", cfg["type"])
assert.Equal(t, "accumulated_recharge", cfg["trigger"])
assert.Equal(t, float64(10000), cfg["threshold"])
assert.Equal(t, "fixed", cfg["mode"])
assert.Equal(t, float64(500), cfg["value"])
} else {
t.Error("一次性佣金配置应返回")
}
})
t.Run("创建分配-梯度类型一次性佣金配置落库", func(t *testing.T) {
shop := env.CreateTestShop("一次性佣金测试店铺2", 1, nil)
series := createTestPackageSeries(t, env, "一次性佣金测试系列2")
body := map[string]interface{}{
"shop_id": shop.ID,
"series_id": series.ID,
"base_commission": map[string]interface{}{
"mode": "fixed",
"value": 1000,
},
"enable_one_time_commission": true,
"one_time_commission_config": map[string]interface{}{
"type": "tiered",
"trigger": "single_recharge",
"threshold": 5000,
"tiers": []map[string]interface{}{
{"tier_type": "sales_count", "threshold": 10, "mode": "fixed", "value": 100},
{"tier_type": "sales_count", "threshold": 50, "mode": "fixed", "value": 500},
{"tier_type": "sales_amount", "threshold": 100000, "mode": "percent", "value": 50},
},
},
}
jsonBody, _ := json.Marshal(body)
resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/shop-series-allocations", jsonBody)
require.NoError(t, err)
defer resp.Body.Close()
var result response.Response
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 0, result.Code, "应返回成功: %s", result.Message)
dataMap := result.Data.(map[string]interface{})
assert.Equal(t, true, dataMap["enable_one_time_commission"])
if cfg, ok := dataMap["one_time_commission_config"].(map[string]interface{}); ok {
assert.Equal(t, "tiered", cfg["type"])
assert.Equal(t, "single_recharge", cfg["trigger"])
if tiers, ok := cfg["tiers"].([]interface{}); ok {
assert.Equal(t, 3, len(tiers), "应有3个梯度档位")
} else {
t.Error("梯度档位应返回")
}
}
})
t.Run("创建分配-启用一次性佣金但未提供配置应失败", func(t *testing.T) {
shop := env.CreateTestShop("一次性佣金测试店铺3", 1, nil)
series := createTestPackageSeries(t, env, "一次性佣金测试系列3")
body := map[string]interface{}{
"shop_id": shop.ID,
"series_id": series.ID,
"base_commission": map[string]interface{}{
"mode": "fixed",
"value": 1000,
},
"enable_one_time_commission": true,
}
jsonBody, _ := json.Marshal(body)
resp, err := env.AsSuperAdmin().Request("POST", "/api/admin/shop-series-allocations", jsonBody)
require.NoError(t, err)
defer resp.Body.Close()
var result response.Response
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.NotEqual(t, 0, result.Code, "启用一次性佣金但未提供配置应失败")
})
t.Run("更新分配-更新一次性佣金配置", func(t *testing.T) {
shop := env.CreateTestShop("一次性佣金测试店铺4", 1, nil)
series := createTestPackageSeries(t, env, "一次性佣金测试系列4")
allocation := createTestAllocation(t, env, shop.ID, series.ID, 0)
enableOneTime := true
body := map[string]interface{}{
"enable_one_time_commission": &enableOneTime,
"one_time_commission_config": map[string]interface{}{
"type": "fixed",
"trigger": "accumulated_recharge",
"threshold": 20000,
"mode": "percent",
"value": 100,
},
}
jsonBody, _ := json.Marshal(body)
url := fmt.Sprintf("/api/admin/shop-series-allocations/%d", allocation.ID)
resp, err := env.AsSuperAdmin().Request("PUT", url, jsonBody)
require.NoError(t, err)
defer resp.Body.Close()
var result response.Response
err = json.NewDecoder(resp.Body).Decode(&result)
require.NoError(t, err)
assert.Equal(t, 0, result.Code, "更新应成功: %s", result.Message)
dataMap := result.Data.(map[string]interface{})
assert.Equal(t, true, dataMap["enable_one_time_commission"])
if cfg, ok := dataMap["one_time_commission_config"].(map[string]interface{}); ok {
assert.Equal(t, float64(20000), cfg["threshold"])
assert.Equal(t, "percent", cfg["mode"])
assert.Equal(t, float64(100), cfg["value"])
}
})
}
// ==================== 梯度佣金 API 测试 ====================
// ==================== 权限测试 ====================

410
tests/unit/commission_calculation_service_test.go Normal file
View File

@@ -0,0 +1,410 @@
package unit
import (
"context"
"fmt"
"testing"
"time"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/internal/service/commission_calculation"
"github.com/break/junhong_cmp_fiber/internal/service/commission_stats"
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/tests/testutils"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
)
func TestCommissionCalculation_AccumulatedRecharge(t *testing.T) {
tx := testutils.NewTestTransaction(t)
rdb := testutils.GetTestRedis(t)
testutils.CleanTestRedisKeys(t, rdb)
ctx := context.Background()
t.Run("累计充值触发-每次支付都写回累计金额", func(t *testing.T) {
shop := &model.Shop{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ShopName: "测试店铺",
ShopCode: fmt.Sprintf("SHOP_%d", time.Now().UnixNano()),
Level: 1,
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(shop).Error)
series := &model.PackageSeries{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
SeriesCode: fmt.Sprintf("SERIES_%d", time.Now().UnixNano()),
SeriesName: "测试系列",
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(series).Error)
allocation := &model.ShopSeriesAllocation{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ShopID: shop.ID,
SeriesID: series.ID,
AllocatorShopID: 0,
BaseCommissionMode: model.CommissionModeFixed,
BaseCommissionValue: 1000,
EnableOneTimeCommission: true,
OneTimeCommissionType: model.OneTimeCommissionTypeFixed,
OneTimeCommissionTrigger: model.OneTimeCommissionTriggerAccumulatedRecharge,
OneTimeCommissionThreshold: 10000,
OneTimeCommissionMode: model.CommissionModeFixed,
OneTimeCommissionValue: 500,
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(allocation).Error)
card := &model.IotCard{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ICCID: fmt.Sprintf("898600%013d", time.Now().Unix()%10000000000000),
CardType: "4G",
CardCategory: "normal",
CarrierID: 1,
CarrierType: "CMCC",
CarrierName: "中国移动",
Status: 3,
ShopID: &shop.ID,
SeriesAllocationID: &allocation.ID,
FirstCommissionPaid: false,
AccumulatedRecharge: 0,
}
require.NoError(t, tx.Create(card).Error)
wallet := &model.Wallet{
ResourceType: "shop",
ResourceID: shop.ID,
WalletType: "commission",
Balance: 0,
Version: 0,
Status: 1,
}
require.NoError(t, tx.Create(wallet).Error)
iotCardStore := postgres.NewIotCardStore(tx, rdb)
shopSeriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
t.Run("第一次支付-累计金额更新为3000", func(t *testing.T) {
order1 := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d_1", time.Now().UnixNano()),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 3000,
SellerCostPrice: 2000,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order1).Error)
cardBefore, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(0), cardBefore.AccumulatedRecharge)
alloc, err := shopSeriesAllocationStore.GetByID(ctx, *card.SeriesAllocationID)
require.NoError(t, err)
if alloc.OneTimeCommissionTrigger == model.OneTimeCommissionTriggerAccumulatedRecharge {
newAccumulated := cardBefore.AccumulatedRecharge + order1.TotalAmount
err := tx.Model(&model.IotCard{}).Where("id = ?", card.ID).
Update("accumulated_recharge", newAccumulated).Error
require.NoError(t, err)
}
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(3000), cardAfter.AccumulatedRecharge, "第一次支付后累计金额应为3000")
assert.False(t, cardAfter.FirstCommissionPaid, "未达阈值不应标记为已发放")
})
t.Run("第二次支付-累计金额更新为7000", func(t *testing.T) {
order2 := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d_2", time.Now().UnixNano()),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 4000,
SellerCostPrice: 3000,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order2).Error)
cardBefore, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(3000), cardBefore.AccumulatedRecharge)
alloc, err := shopSeriesAllocationStore.GetByID(ctx, *card.SeriesAllocationID)
require.NoError(t, err)
if alloc.OneTimeCommissionTrigger == model.OneTimeCommissionTriggerAccumulatedRecharge {
newAccumulated := cardBefore.AccumulatedRecharge + order2.TotalAmount
err := tx.Model(&model.IotCard{}).Where("id = ?", card.ID).
Update("accumulated_recharge", newAccumulated).Error
require.NoError(t, err)
}
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(7000), cardAfter.AccumulatedRecharge, "第二次支付后累计金额应为7000")
assert.False(t, cardAfter.FirstCommissionPaid, "仍未达阈值不应标记为已发放")
})
t.Run("第三次支付-累计金额更新为11000且达到阈值", func(t *testing.T) {
order3 := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d_3", time.Now().UnixNano()),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 4000,
SellerCostPrice: 3000,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order3).Error)
cardBefore, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(7000), cardBefore.AccumulatedRecharge)
alloc, err := shopSeriesAllocationStore.GetByID(ctx, *card.SeriesAllocationID)
require.NoError(t, err)
if alloc.OneTimeCommissionTrigger == model.OneTimeCommissionTriggerAccumulatedRecharge {
newAccumulated := cardBefore.AccumulatedRecharge + order3.TotalAmount
err := tx.Model(&model.IotCard{}).Where("id = ?", card.ID).
Update("accumulated_recharge", newAccumulated).Error
require.NoError(t, err)
}
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(11000), cardAfter.AccumulatedRecharge, "第三次支付后累计金额应为11000")
if cardAfter.AccumulatedRecharge >= alloc.OneTimeCommissionThreshold && !cardAfter.FirstCommissionPaid {
assert.GreaterOrEqual(t, cardAfter.AccumulatedRecharge, alloc.OneTimeCommissionThreshold, "累计金额已达阈值")
err := tx.Model(&model.IotCard{}).Where("id = ?", card.ID).
Update("first_commission_paid", true).Error
require.NoError(t, err)
cardFinal, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.True(t, cardFinal.FirstCommissionPaid, "达到阈值应标记为已发放")
}
})
t.Run("第四次支付-累计金额继续更新但不重复发放", func(t *testing.T) {
order4 := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d_4", time.Now().UnixNano()),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 3000,
SellerCostPrice: 2000,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order4).Error)
cardBefore, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(11000), cardBefore.AccumulatedRecharge)
assert.True(t, cardBefore.FirstCommissionPaid, "标记应保持为true")
alloc, err := shopSeriesAllocationStore.GetByID(ctx, *card.SeriesAllocationID)
require.NoError(t, err)
if alloc.OneTimeCommissionTrigger == model.OneTimeCommissionTriggerAccumulatedRecharge {
newAccumulated := cardBefore.AccumulatedRecharge + order4.TotalAmount
err := tx.Model(&model.IotCard{}).Where("id = ?", card.ID).
Update("accumulated_recharge", newAccumulated).Error
require.NoError(t, err)
}
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.Equal(t, int64(14000), cardAfter.AccumulatedRecharge, "第四次支付后累计金额应为14000")
assert.True(t, cardAfter.FirstCommissionPaid, "已发放标记不应改变")
})
})
}
func TestCommissionCalculation_OneTimeCommissionLogic(t *testing.T) {
tx := testutils.NewTestTransaction(t)
rdb := testutils.GetTestRedis(t)
testutils.CleanTestRedisKeys(t, rdb)
ctx := context.Background()
commissionRecordStore := postgres.NewCommissionRecordStore(tx, rdb)
shopStore := postgres.NewShopStore(tx, rdb)
shopSeriesAllocationStore := postgres.NewShopSeriesAllocationStore(tx)
shopSeriesOneTimeCommissionTierStore := postgres.NewShopSeriesOneTimeCommissionTierStore(tx)
iotCardStore := postgres.NewIotCardStore(tx, rdb)
deviceStore := postgres.NewDeviceStore(tx, rdb)
walletStore := postgres.NewWalletStore(tx, rdb)
walletTransactionStore := postgres.NewWalletTransactionStore(tx, rdb)
orderStore := postgres.NewOrderStore(tx, rdb)
orderItemStore := postgres.NewOrderItemStore(tx, rdb)
packageStore := postgres.NewPackageStore(tx)
shopSeriesCommissionStatsStore := postgres.NewShopSeriesCommissionStatsStore(tx)
commissionStatsService := commission_stats.New(shopSeriesCommissionStatsStore)
logger, _ := zap.NewDevelopment()
commCalcService := commission_calculation.New(
tx,
commissionRecordStore,
shopStore,
shopSeriesAllocationStore,
shopSeriesOneTimeCommissionTierStore,
iotCardStore,
deviceStore,
walletStore,
walletTransactionStore,
orderStore,
orderItemStore,
packageStore,
commissionStatsService,
logger,
)
t.Run("单次充值触发-达到阈值时发放佣金", func(t *testing.T) {
shop := &model.Shop{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ShopName: "单次触发店铺",
ShopCode: fmt.Sprintf("SHOP_%d", time.Now().UnixNano()),
Level: 1,
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(shop).Error)
series := &model.PackageSeries{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
SeriesCode: fmt.Sprintf("SERIES_%d", time.Now().UnixNano()),
SeriesName: "单次触发系列",
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(series).Error)
allocation := &model.ShopSeriesAllocation{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ShopID: shop.ID,
SeriesID: series.ID,
AllocatorShopID: 0,
BaseCommissionMode: model.CommissionModeFixed,
BaseCommissionValue: 500,
EnableOneTimeCommission: true,
OneTimeCommissionType: model.OneTimeCommissionTypeFixed,
OneTimeCommissionTrigger: model.OneTimeCommissionTriggerSingleRecharge,
OneTimeCommissionThreshold: 5000,
OneTimeCommissionMode: model.CommissionModeFixed,
OneTimeCommissionValue: 300,
Status: constants.StatusEnabled,
}
require.NoError(t, tx.Create(allocation).Error)
card := &model.IotCard{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
ICCID: fmt.Sprintf("898600%013d", time.Now().Unix()%10000000000000+1),
CardType: "4G",
CardCategory: "normal",
CarrierID: 1,
CarrierType: "CMCC",
CarrierName: "中国移动",
Status: 3,
ShopID: &shop.ID,
SeriesAllocationID: &allocation.ID,
FirstCommissionPaid: false,
AccumulatedRecharge: 0,
}
require.NoError(t, tx.Create(card).Error)
wallet := &model.Wallet{
ResourceType: "shop",
ResourceID: shop.ID,
WalletType: "commission",
Balance: 0,
Version: 0,
Status: 1,
}
require.NoError(t, tx.Create(wallet).Error)
t.Run("单次充值未达阈值-不触发", func(t *testing.T) {
order := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d", time.Now().UnixNano()),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 3000,
SellerCostPrice: 2500,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order).Error)
err := commCalcService.CalculateCommission(ctx, order.ID)
require.NoError(t, err)
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.False(t, cardAfter.FirstCommissionPaid, "单次充值未达阈值不应发放")
})
t.Run("单次充值达到阈值-触发", func(t *testing.T) {
order := &model.Order{
BaseModel: model.BaseModel{Creator: 1, Updater: 1},
OrderNo: fmt.Sprintf("ORDER_%d", time.Now().UnixNano()+1),
OrderType: model.OrderTypeSingleCard,
BuyerType: model.BuyerTypeAgent,
BuyerID: shop.ID,
IotCardID: &card.ID,
SellerShopID: &shop.ID,
SeriesID: &series.ID,
TotalAmount: 6000,
SellerCostPrice: 5500,
PaymentStatus: model.PaymentStatusPaid,
CommissionStatus: model.CommissionStatusPending,
}
require.NoError(t, tx.Create(order).Error)
err := commCalcService.CalculateCommission(ctx, order.ID)
require.NoError(t, err)
cardAfter, err := iotCardStore.GetByID(ctx, card.ID)
require.NoError(t, err)
assert.True(t, cardAfter.FirstCommissionPaid, "单次充值达到阈值应发放")
var commRecords []model.CommissionRecord
err = tx.Where("order_id = ? AND commission_source = ?", order.ID, model.CommissionSourceOneTime).
Find(&commRecords).Error
require.NoError(t, err)
assert.Len(t, commRecords, 1, "应有一条一次性佣金记录")
assert.Equal(t, int64(300), commRecords[0].Amount, "佣金金额应为300")
})
})
}

3
tests/unit/commission_withdrawal_setting_service_test.go
View File

@@ -159,6 +159,9 @@ func TestCommissionWithdrawalSettingService_GetCurrent(t *testing.T) {
rdb := testutils.GetTestRedis(t)
testutils.CleanTestRedisKeys(t, rdb)
// 清理已有的活跃配置，确保测试隔离
tx.Exec("UPDATE tb_commission_withdrawal_setting SET is_active = false WHERE is_active = true")
accountStore := postgres.NewAccountStore(tx, rdb)
settingStore := postgres.NewCommissionWithdrawalSettingStore(tx, rdb)

2
tests/unit/enterprise_card_authorization_permission_test.go
View File

@@ -610,6 +610,8 @@ func TestAuthorizationService_UpdateRecordRemark(t *testing.T) {
require.NoError(t, err)
ctx := pkggorm.SkipDataPermission(context.Background())
ctx = context.WithValue(ctx, constants.ContextKeyUserID, account.ID)
ctx = context.WithValue(ctx, constants.ContextKeyUserType, constants.UserTypePlatform)
t.Run("更新授权备注", func(t *testing.T) {
updated, err := authService.UpdateRecordRemark(ctx, auth.ID, "更新后的备注")

8
tests/unit/my_commission_service_test.go
View File

@@ -360,11 +360,11 @@ func TestMyCommissionService_ListMyCommissionRecords(t *testing.T) {
ctx := createMyCommissionTestContext(1, shop.ID, constants.UserTypeAgent)
commissionType := "one_time"
commissionSource := "one_time"
req := &dto.MyCommissionRecordListReq{
Page: 1,
PageSize: 20,
CommissionType: &commissionType,
Page: 1,
PageSize: 20,
CommissionSource: &commissionSource,
}
result, err := service.ListMyCommissionRecords(ctx, req)