Files
affiliate_dash/backend/internal/service/rock_redeem_pending_test.go
T
zhaoxing a9473990be refactor: 移除 Rock 发货处理中状态,新增异常派生筛选标记
- 新增迁移 028:历史 redeeming 回退为 bound,重建 pending 部分索引
- pending 语义改为 bound + redeem_requested_at 标记,不再写状态与状态日志
- 新增 anomaly 虚拟筛选项:基于状态日志派生异常标记,不改状态、不落库
- 状态列追加「⚠️ 异常」标签,统计新增 anomaly_stock
- 清理前后端 redeeming 相关分支与文案
2026-11-14 15:40:19 +08:00

414 lines
14 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package service
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"affiliate_dash/internal/model"
)
func setRockTestBearerToken(t *testing.T, svc *RockService, bearer string) {
t.Helper()
if _, err := svc.GetConfig(context.Background()); err != nil {
t.Fatalf("初始化配置失败: %v", err)
}
if err := svc.db.Model(&model.RockConfig{}).
Where("id = 1").
Update("bearer_token", bearer).Error; err != nil {
t.Fatalf("写入 Bearer Token 失败: %v", err)
}
}
// 上游返回 pending(HTTP 200 + status=pending + token.status=bound)时:
// Token 主状态必须保持 bound,只写发货确认标记,绝不写 redeemed 终态或履约流水。
func TestRedeemTokenForOrder_PendingKeepsBoundWithMarkers(t *testing.T) {
db := newRockTestDB(t)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch {
case strings.HasSuffix(r.URL.Path, "/refresh"):
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"token": map[string]interface{}{
"id": 179384,
"status": "bound",
"bound_account": "舱z",
"bound_account_id": "3829515948",
"region": "安卓-微信",
"redeemed_at": nil,
},
"binding": map[string]interface{}{
"bound": true,
"role": "舱z",
"roleId": "3829515948",
"region": "安卓-微信",
},
"deliveryList": []interface{}{},
"message": "已刷新绑定信息",
})
case strings.HasPrefix(r.URL.Path, "/api/redeem/"):
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"token": map[string]interface{}{
"id": 179384,
"status": "bound",
"redeem_skin": nil,
"redeemed_at": nil,
"redeem_code": "CODE-PENDING",
"bound_account": "舱z",
},
"status": "pending",
"pending": true,
"message": "官方处理中,请稍后刷新查看结果",
})
default:
w.WriteHeader(http.StatusNotFound)
}
}))
defer server.Close()
svc := NewRockService(db, NewRockClient(server.URL))
setRockTestBearerToken(t, svc, "bearer-test")
now := time.Now()
token := model.RockToken{
UpstreamTokenID: "179384",
Token: "jwt-179384",
RedeemCode: "CODE-PENDING",
Color: model.RockColorBlack,
Status: model.RockStatusBound,
AssignedOrderNo: "FO-PENDING-1",
ExpectedUID: "3829515948",
ActualRoleName: "舱z",
ActualRoleID: "3829515948",
ActualChannel: "安卓-微信",
BoundAt: &now,
}
if err := db.Create(&token).Error; err != nil {
t.Fatalf("创建 Token 失败: %v", err)
}
recorder := svc.NewDeliveryRecorder(token.AssignedOrderNo, nil, "127.0.0.1", "go-test")
result, err := svc.RedeemTokenForOrder(context.Background(), token.AssignedOrderNo, model.RockSKUBlackTshirt, token.ExpectedUID, recorder)
if err != nil {
t.Fatalf("pending 不应返回错误: %v", err)
}
if result == nil || !result.Pending {
t.Fatalf("pending 响应应标记 Pending=true,实际: %+v", result)
}
var saved model.RockToken
if err := db.First(&saved, token.ID).Error; err != nil {
t.Fatalf("读取 Token 失败: %v", err)
}
if saved.Status != model.RockStatusBound {
t.Fatalf("pending 后状态应保持 bound,实际为 %s", saved.Status)
}
if saved.RedeemedAt != nil {
t.Fatalf("pending 不能写 redeemed_at,实际为 %v", saved.RedeemedAt)
}
if saved.UpstreamFulfillID != 0 {
t.Fatalf("pending 不能写履约流水,实际为 %d", saved.UpstreamFulfillID)
}
if saved.RedeemRequestedAt == nil || saved.RedeemNextRetryAt == nil {
t.Fatalf("pending 应记录提交时间与下次轮询时间: %+v", saved)
}
if strings.TrimSpace(saved.RedeemLastMessage) == "" {
t.Fatalf("pending 应保留上游处理中说明")
}
// 报文日志应完整记录兑换请求与响应(明文)。
var logs []model.RockDeliveryLog
if err := db.Where("token_id = ?", token.ID).Order("id ASC").Find(&logs).Error; err != nil {
t.Fatalf("读取发货日志失败: %v", err)
}
var hasRequest, hasPendingResponse bool
for _, entry := range logs {
if entry.Step == "redeem_request" && entry.Direction == "outbound" {
hasRequest = true
if entry.Status != "pending" {
t.Fatalf("兑换请求日志状态应为 pending,实际 %s", entry.Status)
}
if !strings.Contains(entry.RequestBody, "黑色ROCK长袖T恤") {
t.Fatalf("请求报文应包含皮肤名,实际 %q", entry.RequestBody)
}
if !strings.Contains(entry.ResponseBody, "官方处理中") {
t.Fatalf("响应报文应保留上游原文,实际 %q", entry.ResponseBody)
}
hasPendingResponse = true
}
}
if !hasRequest || !hasPendingResponse {
t.Fatalf("缺少兑换报文日志: %+v", logs)
}
}
// 上游 HTTP 200 但既非 success 也非 pending(例如空响应 / 状态异常)时必须报错且不改状态。
func TestRedeemTokenForOrder_UnexpectedPayloadDoesNotMarkRedeemed(t *testing.T) {
db := newRockTestDB(t)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasPrefix(r.URL.Path, "/api/redeem/") {
// 模拟上游业务失败但返回 200:只有 message,没有 status。
_, _ = w.Write([]byte(`{"token":{"status":"bound"},"message":"当前已禁止提交"}`))
return
}
w.WriteHeader(http.StatusNotFound)
}))
defer server.Close()
svc := NewRockService(db, NewRockClient(server.URL))
setRockTestBearerToken(t, svc, "bearer-test")
now := time.Now()
token := model.RockToken{
UpstreamTokenID: "179385",
Token: "jwt-179385",
RedeemCode: "CODE-BLOCKED",
Color: model.RockColorBlack,
Status: model.RockStatusBound,
AssignedOrderNo: "FO-BLOCKED-1",
ExpectedUID: "3829515949",
ActualRoleName: "舱y",
ActualRoleID: "3829515949",
BoundAt: &now,
}
if err := db.Create(&token).Error; err != nil {
t.Fatalf("创建 Token 失败: %v", err)
}
if _, err := svc.RedeemTokenForOrder(context.Background(), token.AssignedOrderNo, model.RockSKUBlackTshirt, token.ExpectedUID, nil); err == nil {
t.Fatalf("非 success/pending 响应必须报错,避免误判为已发货")
}
var saved model.RockToken
if err := db.First(&saved, token.ID).Error; err != nil {
t.Fatalf("读取 Token 失败: %v", err)
}
if saved.Status != model.RockStatusBound {
t.Fatalf("失败后状态应保持 bound,实际为 %s", saved.Status)
}
if saved.RedeemedAt != nil {
t.Fatalf("失败后不能写 redeemed_at")
}
}
// 发货确认中(已提交兑换未确认)的 Token 再次提交必须直接返回处理中,不能重复调用上游兑换。
func TestRedeemTokenForOrder_PendingDoesNotResubmit(t *testing.T) {
db := newRockTestDB(t)
var redeemCalls int
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasPrefix(r.URL.Path, "/api/redeem/") {
redeemCalls++
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"status": "success",
"message": "领取成功",
"token": map[string]interface{}{"status": "redeemed"},
})
return
}
w.WriteHeader(http.StatusNotFound)
}))
defer server.Close()
svc := NewRockService(db, NewRockClient(server.URL))
setRockTestBearerToken(t, svc, "bearer-test")
now := time.Now()
next := now.Add(30 * time.Second)
token := model.RockToken{
UpstreamTokenID: "179386",
Token: "jwt-179386",
RedeemCode: "CODE-REDEEMING",
Color: model.RockColorBlack,
Status: model.RockStatusBound,
AssignedOrderNo: "FO-REDEEMING-1",
ExpectedUID: "3829515950",
ActualRoleName: "舱x",
ActualRoleID: "3829515950",
BoundAt: &now,
RedeemRequestedAt: &now,
RedeemNextRetryAt: &next,
RedeemLastMessage: "官方处理中,请稍后刷新查看结果",
}
if err := db.Create(&token).Error; err != nil {
t.Fatalf("创建 Token 失败: %v", err)
}
result, err := svc.RedeemTokenForOrder(context.Background(), token.AssignedOrderNo, model.RockSKUBlackTshirt, token.ExpectedUID, nil)
if err != nil {
t.Fatalf("重复提交应返回处理中而不是错误: %v", err)
}
if result == nil || !result.Pending {
t.Fatalf("重复提交应返回 Pending=true: %+v", result)
}
if redeemCalls != 0 {
t.Fatalf("发货确认中不应再次调用上游兑换,实际调用 %d 次", redeemCalls)
}
}
// 后台确认任务拿到 redeemed 后应写终态、记录履约流水并触发订单同步回调。
func TestProcessRedeemingTokens_ConfirmsAndSyncsOrder(t *testing.T) {
db := newRockTestDB(t)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasSuffix(r.URL.Path, "/refresh") {
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"token": map[string]interface{}{
"status": "redeemed",
"bound_account": "舱z",
"bound_account_id": "3829515948",
"region": "安卓-微信",
"redeemed_at": "2026-11-14 11:04:52",
},
"deliveryList": []interface{}{
map[string]interface{}{"fulfillId": 4519960, "time": "2026-11-14 11:04:52"},
},
"message": "已刷新绑定信息",
})
return
}
w.WriteHeader(http.StatusNotFound)
}))
defer server.Close()
svc := NewRockService(db, NewRockClient(server.URL))
setRockTestBearerToken(t, svc, "bearer-test")
var hookCalled int
var hookTokenID uint
var hookFulfillID int64
svc.SetRedeemConfirmHook(func(ctx context.Context, order *model.FulfillmentOrder, token *model.RockToken) error {
hookCalled++
hookTokenID = token.ID
hookFulfillID = token.UpstreamFulfillID
return nil
})
now := time.Now().Add(-2 * time.Minute)
next := now
token := model.RockToken{
UpstreamTokenID: "179384",
Token: "jwt-179384",
RedeemCode: "CODE-CONFIRM",
Color: model.RockColorBlack,
Status: model.RockStatusBound,
AssignedOrderNo: "FO-CONFIRM-1",
ExpectedUID: "3829515948",
ActualRoleName: "舱z",
ActualRoleID: "3829515948",
BoundAt: &now,
RedeemRequestedAt: &now,
RedeemNextRetryAt: &next,
}
if err := db.Create(&token).Error; err != nil {
t.Fatalf("创建 Token 失败: %v", err)
}
order := model.FulfillmentOrder{
MerchantID: 1,
OrderNo: "FO-CONFIRM-1",
OrderStatus: model.OrderStatusDelivering,
}
if err := db.Create(&order).Error; err != nil {
t.Fatalf("创建订单失败: %v", err)
}
summary, err := svc.ProcessRedeemingTokens(context.Background())
if err != nil {
t.Fatalf("确认任务失败: %v", err)
}
if summary.Confirmed != 1 {
t.Fatalf("应确认 1 条,实际 %+v", summary)
}
var saved model.RockToken
if err := db.First(&saved, token.ID).Error; err != nil {
t.Fatalf("读取 Token 失败: %v", err)
}
if saved.Status != model.RockStatusRedeemed {
t.Fatalf("确认后状态应为 redeemed,实际 %s", saved.Status)
}
if saved.UpstreamFulfillID != 4519960 {
t.Fatalf("应记录履约流水 4519960,实际 %d", saved.UpstreamFulfillID)
}
if saved.RedeemedAt == nil {
t.Fatalf("确认后应写 redeemed_at")
}
if hookCalled != 1 || hookTokenID != token.ID || hookFulfillID != 4519960 {
t.Fatalf("订单同步回调不正确: called=%d token=%d fulfill=%d", hookCalled, hookTokenID, hookFulfillID)
}
}
// 上游仍为 bound 时应保持发货确认标记,并按指数退避延后下一次查询。
func TestProcessRedeemingTokens_StaysPendingAndBacksOff(t *testing.T) {
db := newRockTestDB(t)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
if strings.HasSuffix(r.URL.Path, "/refresh") {
_ = json.NewEncoder(w).Encode(map[string]interface{}{
"token": map[string]interface{}{
"status": "bound",
"bound_account": "舱z",
"bound_account_id": "3829515948",
"redeemed_at": nil,
},
"binding": map[string]interface{}{"bound": true, "roleId": "3829515948"},
"deliveryList": []interface{}{},
"message": "已刷新绑定信息",
})
return
}
w.WriteHeader(http.StatusNotFound)
}))
defer server.Close()
svc := NewRockService(db, NewRockClient(server.URL))
setRockTestBearerToken(t, svc, "bearer-test")
requested := time.Now().Add(-3 * time.Minute)
next := time.Now().Add(-time.Second)
token := model.RockToken{
UpstreamTokenID: "179387",
Token: "jwt-179387",
RedeemCode: "CODE-STILL-PENDING",
Color: model.RockColorBlack,
Status: model.RockStatusBound,
AssignedOrderNo: "FO-STILL-PENDING",
ExpectedUID: "3829515948",
RedeemRequestedAt: &requested,
RedeemNextRetryAt: &next,
}
if err := db.Create(&token).Error; err != nil {
t.Fatalf("创建 Token 失败: %v", err)
}
summary, err := svc.ProcessRedeemingTokens(context.Background())
if err != nil {
t.Fatalf("确认任务失败: %v", err)
}
if summary.Confirmed != 0 || summary.Pending != 1 {
t.Fatalf("应保持处理中,实际 %+v", summary)
}
var saved model.RockToken
if err := db.First(&saved, token.ID).Error; err != nil {
t.Fatalf("读取 Token 失败: %v", err)
}
if saved.Status != model.RockStatusBound {
t.Fatalf("状态应保持 bound(发货确认中只写标记),实际 %s", saved.Status)
}
if saved.RedeemAttempts != 1 {
t.Fatalf("轮询次数应为 1,实际 %d", saved.RedeemAttempts)
}
if saved.RedeemNextRetryAt == nil || !saved.RedeemNextRetryAt.After(time.Now()) {
t.Fatalf("应设置下一次退避时间: %+v", saved.RedeemNextRetryAt)
}
if saved.RedeemLastMessage == "" {
t.Fatalf("应保留上游处理中说明")
}
}