wangjia
397 lines
15 KiB
Go
397 lines
15 KiB
Go
package handler_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
|
|
"github.com/wangjia/pay/config"
|
|
"github.com/wangjia/pay/internal/accounts"
|
|
"github.com/wangjia/pay/internal/gateway"
|
|
"github.com/wangjia/pay/internal/model"
|
|
"github.com/wangjia/pay/internal/provider"
|
|
"github.com/wangjia/pay/internal/provider/fake"
|
|
"github.com/wangjia/pay/internal/router"
|
|
"github.com/wangjia/pay/internal/store"
|
|
)
|
|
|
|
type nopEnqueuer struct{}
|
|
|
|
func (nopEnqueuer) Enqueue(string, string, string, string, map[string]any) error { return nil }
|
|
|
|
type oneResolver struct{}
|
|
|
|
func (oneResolver) Resolve(sku, currency string) (int64, string, string, error) {
|
|
return 29990000, "Pro 年付", "pro_year", nil
|
|
}
|
|
|
|
func buildEngine(t *testing.T) *gin.Engine {
|
|
t.Helper()
|
|
r, _ := buildEngineWithStore(t)
|
|
return r
|
|
}
|
|
|
|
func buildEngineWithStore(t *testing.T) (*gin.Engine, *store.OrderStore) {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
db := model.OpenTestDB(t)
|
|
orders := store.NewOrderStore(db)
|
|
refunds := store.NewRefundStore(db)
|
|
subs := store.NewSubscriptionStore(db)
|
|
chargebacks := store.NewChargebackStore(db)
|
|
preg := provider.NewRegistry()
|
|
preg.Register(fake.New())
|
|
areg := accounts.New([]config.AccountConfig{
|
|
{AccountID: "fake-a1", Channel: "fake", Region: "global", Enabled: true, Weight: 1},
|
|
})
|
|
picker := accounts.NewRouter(areg, nil, nil)
|
|
g := gateway.New(orders, refunds, preg, picker, oneResolver{}, nopEnqueuer{}, "global", subs, chargebacks)
|
|
r := gin.New()
|
|
router.SetupV2(r, g)
|
|
return r, orders
|
|
}
|
|
|
|
func do(t *testing.T, r *gin.Engine, method, path string, body any) (*httptest.ResponseRecorder, map[string]any) {
|
|
t.Helper()
|
|
var buf bytes.Buffer
|
|
if body != nil {
|
|
_ = json.NewEncoder(&buf).Encode(body)
|
|
}
|
|
req := httptest.NewRequest(method, path, &buf)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
var out map[string]any
|
|
_ = json.Unmarshal(w.Body.Bytes(), &out)
|
|
return w, out
|
|
}
|
|
|
|
func TestV2OrderLifecycle(t *testing.T) {
|
|
r := buildEngine(t)
|
|
|
|
// 下单(独立收款,无 biz_system → 无需签名)
|
|
w, out := do(t, r, http.MethodPost, "/api/v2/orders", map[string]any{"sku": "pro_year", "method": "fake"})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("create code=%d body=%v", w.Code, out)
|
|
}
|
|
data := out["data"].(map[string]any)
|
|
orderNo := data["order_no"].(string)
|
|
sess := data["session"].(map[string]any)
|
|
if sess["render_type"] != "crypto_address" {
|
|
t.Fatalf("session = %v", sess)
|
|
}
|
|
|
|
// 查单:pending
|
|
_, out2 := do(t, r, http.MethodGet, "/api/v2/orders/"+orderNo, nil)
|
|
if out2["data"].(map[string]any)["status"] != "pending" {
|
|
t.Fatalf("status = %v", out2["data"])
|
|
}
|
|
|
|
// 取 provider_ref:直接构造 fake 回调体(provider_ref 由 payload 无法拿,需查尝试)
|
|
// 这里用 callback 端点 + fake JSON:先取尝试 ref。测试通过再次下单太绕,
|
|
// 改为:回调体里 provider_ref 用 order_no 反查——fake ref 前缀 FAKE-<orderNo>。
|
|
// 直接命中:构造 verify 输入需真实 ref,故经 /api/v2/callback 前先查库拿 ref。
|
|
// 简化:暴露一个内部查询——本测试用 status 已足够验证下单/查单闭环;
|
|
// 回调闭环在 gateway settle_test 已覆盖。此处验证 callback 路由存在且 404 语义:
|
|
wc, _ := do(t, r, http.MethodPost, "/api/v2/callback/fake", map[string]any{
|
|
"provider_ref": "GHOST", "status": "succeeded", "amount_minor": 1, "currency": "USDT",
|
|
})
|
|
if wc.Code != http.StatusOK { // not_found 也回 200(渠道无需重投未知单)
|
|
t.Fatalf("callback code=%d", wc.Code)
|
|
}
|
|
|
|
// 取消
|
|
wCancel, outCancel := do(t, r, http.MethodPost, "/api/v2/orders/"+orderNo+"/cancel", nil)
|
|
if wCancel.Code != http.StatusOK || outCancel["data"].(map[string]any)["canceled"] != true {
|
|
t.Fatalf("cancel = %d %v", wCancel.Code, outCancel)
|
|
}
|
|
}
|
|
|
|
// TestV2CallbackAmountMismatchIs200Terminal 覆盖 P2-7 审查发现:金额/币种不符是终态,
|
|
// 渠道无需(也不该)重投,回调必须回 200 停投,而不是 400 触发无限重投。
|
|
func TestV2CallbackAmountMismatchIs200Terminal(t *testing.T) {
|
|
r, orders := buildEngineWithStore(t)
|
|
|
|
w, out := do(t, r, http.MethodPost, "/api/v2/orders", map[string]any{"sku": "pro_year", "method": "fake"})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("create code=%d body=%v", w.Code, out)
|
|
}
|
|
orderNo := out["data"].(map[string]any)["order_no"].(string)
|
|
|
|
atts, err := orders.ListAttemptsByStatus(model.AttemptPending, 10)
|
|
if err != nil || len(atts) == 0 {
|
|
t.Fatalf("无 pending 尝试: %v", err)
|
|
}
|
|
var ref string
|
|
for _, a := range atts {
|
|
if a.OutTradeNo == orderNo {
|
|
ref = a.ProviderRef
|
|
}
|
|
}
|
|
if ref == "" {
|
|
t.Fatalf("未找到订单 %s 的尝试", orderNo)
|
|
}
|
|
|
|
// 币种正确但少付(amount_minor=1 << 应收 29990000)→ amount_mismatch,终态,必须 200。
|
|
wc, outc := do(t, r, http.MethodPost, "/api/v2/callback/fake", map[string]any{
|
|
"provider_ref": ref, "status": "succeeded", "amount_minor": 1, "currency": "USDT",
|
|
})
|
|
if wc.Code != http.StatusOK {
|
|
t.Fatalf("amount_mismatch callback code=%d body=%v (终态应 200 停投,不应 400 触发无限重投)", wc.Code, outc)
|
|
}
|
|
if outc["result"] != string(gateway.SettleAmountMismatch) {
|
|
t.Fatalf("result = %v, want amount_mismatch", outc["result"])
|
|
}
|
|
|
|
// 订单应仍是 pending(未被误标为已支付)。
|
|
_, outStatus := do(t, r, http.MethodGet, "/api/v2/orders/"+orderNo, nil)
|
|
if outStatus["data"].(map[string]any)["status"] != "pending" {
|
|
t.Fatalf("order status = %v, want pending", outStatus["data"])
|
|
}
|
|
}
|
|
|
|
// TestV2CallbackMalformedBodyIs400Transient 验签/解析失败是瞬时态,渠道应重投,故回 400。
|
|
func TestV2CallbackMalformedBodyIs400Transient(t *testing.T) {
|
|
r := buildEngine(t)
|
|
|
|
req := httptest.NewRequest(http.MethodPost, "/api/v2/callback/fake", bytes.NewBufferString("not-json"))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
if w.Code != http.StatusBadRequest {
|
|
t.Fatalf("malformed body callback code=%d, want 400", w.Code)
|
|
}
|
|
}
|
|
|
|
// TestV2RetryCurrencyMismatch409 覆盖 review 发现:重试到结算币种不同的渠道应返回 409,
|
|
// 不再落入默认 500,以避免客户端误以为是瞬时失败而无限重试。
|
|
func TestV2RetryCurrencyMismatch409(t *testing.T) {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
db := model.OpenTestDB(t)
|
|
orders := store.NewOrderStore(db)
|
|
refunds := store.NewRefundStore(db)
|
|
subs := store.NewSubscriptionStore(db)
|
|
chargebacks := store.NewChargebackStore(db)
|
|
preg := provider.NewRegistry()
|
|
preg.Register(fake.New()) // method="fake", settles in "USDT"
|
|
|
|
// 构造一个只支持 EUR 的 provider
|
|
eurProvider := &eurFakeProvider{}
|
|
preg.Register(eurProvider) // method="fake_eur", settles in "EUR"
|
|
|
|
areg := accounts.New([]config.AccountConfig{
|
|
{AccountID: "fake-a1", Channel: "fake", Region: "global", Enabled: true, Weight: 1},
|
|
{AccountID: "fake-a2", Channel: "fake_eur", Region: "global", Enabled: true, Weight: 1},
|
|
})
|
|
picker := accounts.NewRouter(areg, nil, nil)
|
|
g := gateway.New(orders, refunds, preg, picker, oneResolver{}, nopEnqueuer{}, "global", subs, chargebacks)
|
|
r := gin.New()
|
|
router.SetupV2(r, g)
|
|
|
|
// 下单(USDT 渠道)
|
|
w, out := do(t, r, http.MethodPost, "/api/v2/orders", map[string]any{"sku": "pro_year", "method": "fake"})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("create code=%d body=%v", w.Code, out)
|
|
}
|
|
orderNo := out["data"].(map[string]any)["order_no"].(string)
|
|
|
|
// 重试到 EUR 渠道 → 币种不符 → 409 currency_mismatch
|
|
wRetry, outRetry := do(t, r, http.MethodPost, "/api/v2/orders/"+orderNo+"/retry", map[string]any{"method": "fake_eur"})
|
|
if wRetry.Code != http.StatusConflict {
|
|
t.Fatalf("retry code=%d, want 409; body=%v", wRetry.Code, outRetry)
|
|
}
|
|
if outRetry["code"] != "currency_mismatch" {
|
|
t.Fatalf("retry code=%v, want currency_mismatch", outRetry["code"])
|
|
}
|
|
}
|
|
|
|
// eurFakeProvider 是一个测试用的 provider,仅支持 EUR。
|
|
type eurFakeProvider struct{}
|
|
|
|
func (p *eurFakeProvider) Method() string { return "fake_eur" }
|
|
|
|
func (p *eurFakeProvider) Capabilities() provider.Capabilities {
|
|
return provider.Capabilities{
|
|
RenderTypes: []provider.RenderType{provider.RenderCryptoAddress},
|
|
SupportsRefund: false,
|
|
SettleCurrencies: []string{"EUR"},
|
|
Regions: []string{"global"},
|
|
}
|
|
}
|
|
|
|
func (p *eurFakeProvider) Create(_ context.Context, req provider.CreateRequest) (*provider.Session, error) {
|
|
exp := time.Now().Add(15 * time.Minute)
|
|
ref := "EURK-" + req.OutTradeNo
|
|
return &provider.Session{
|
|
ProviderRef: ref,
|
|
RenderType: provider.RenderCryptoAddress,
|
|
Payload: map[string]any{
|
|
"address": "EFake" + req.Account.AccountID + req.OutTradeNo,
|
|
"amount_minor": req.AmountMinor,
|
|
"currency": req.Currency,
|
|
},
|
|
ExpiresAt: &exp,
|
|
}, nil
|
|
}
|
|
|
|
func (p *eurFakeProvider) VerifyCallback(_ context.Context, in provider.CallbackInput) (*provider.PaidEvent, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
func (p *eurFakeProvider) Query(_ context.Context, req provider.QueryRequest) (*provider.PaidEvent, error) {
|
|
return nil, errors.New("not implemented")
|
|
}
|
|
|
|
// subFakeProvider 实现 provider.SubscriptionProvider,供 handler 层 CancelSubscription/
|
|
// GetSubscription 端到端测试用(独立于 internal/gateway 包的 fakeSubProvider,同构但不能跨
|
|
// 测试包复用未导出类型)。VerifyCallback 原样透传测试构造的 provider.PaidEvent JSON。
|
|
type subFakeProvider struct {
|
|
sessionRef string
|
|
}
|
|
|
|
func (p *subFakeProvider) Method() string { return "subfake" }
|
|
|
|
func (p *subFakeProvider) Capabilities() provider.Capabilities {
|
|
return provider.Capabilities{
|
|
RenderTypes: []provider.RenderType{provider.RenderRedirect},
|
|
SupportsRecurring: true,
|
|
RecurringKind: provider.RecurringKindGatewayScheduled,
|
|
SettleCurrencies: []string{"USD"},
|
|
Regions: []string{"global"},
|
|
}
|
|
}
|
|
|
|
func (p *subFakeProvider) Create(_ context.Context, _ provider.CreateRequest) (*provider.Session, error) {
|
|
return nil, errors.New("subFakeProvider: one-time Create not used")
|
|
}
|
|
|
|
func (p *subFakeProvider) CreateSubscriptionCheckout(_ context.Context, req provider.CreateRequest) (*provider.Session, error) {
|
|
return &provider.Session{
|
|
ProviderRef: p.sessionRef, RenderType: provider.RenderRedirect,
|
|
Payload: map[string]any{"url": "https://checkout.example/" + p.sessionRef},
|
|
}, nil
|
|
}
|
|
|
|
func (p *subFakeProvider) CancelSubscription(_ context.Context, _ string) error { return nil }
|
|
|
|
func (p *subFakeProvider) VerifyCallback(_ context.Context, in provider.CallbackInput) (*provider.PaidEvent, error) {
|
|
var ev provider.PaidEvent
|
|
if err := json.Unmarshal(in.Raw, &ev); err != nil {
|
|
return nil, err
|
|
}
|
|
return &ev, nil
|
|
}
|
|
|
|
func (p *subFakeProvider) Query(_ context.Context, req provider.QueryRequest) (*provider.PaidEvent, error) {
|
|
return &provider.PaidEvent{ProviderRef: req.ProviderRef, Status: provider.PaidPending}, nil
|
|
}
|
|
|
|
type subResolver struct{}
|
|
|
|
func (subResolver) Resolve(sku, currency string) (int64, string, string, error) {
|
|
return 2999, "Pro 月付", "pro_monthly", nil
|
|
}
|
|
|
|
// buildSubEngine 装配一套支持订阅的路由(subfake 渠道),供取消/查询端点测试用。
|
|
func buildSubEngine(t *testing.T) (*gin.Engine, *subFakeProvider) {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
db := model.OpenTestDB(t)
|
|
orders := store.NewOrderStore(db)
|
|
refunds := store.NewRefundStore(db)
|
|
subs := store.NewSubscriptionStore(db)
|
|
chargebacks := store.NewChargebackStore(db)
|
|
preg := provider.NewRegistry()
|
|
fp := &subFakeProvider{sessionRef: "cs_sub_1"}
|
|
preg.Register(fp)
|
|
areg := accounts.New([]config.AccountConfig{
|
|
{AccountID: "subfake-a1", Channel: "subfake", Region: "global", Enabled: true, Weight: 1},
|
|
})
|
|
picker := accounts.NewRouter(areg, nil, nil)
|
|
g := gateway.New(orders, refunds, preg, picker, subResolver{}, nopEnqueuer{}, "global", subs, chargebacks)
|
|
r := gin.New()
|
|
router.SetupV2(r, g)
|
|
return r, fp
|
|
}
|
|
|
|
// TestV2SubscriptionNotFound404 —— 未知 sub_id 的取消/查询都应 404,而不是 500。
|
|
func TestV2SubscriptionNotFound404(t *testing.T) {
|
|
r, _ := buildSubEngine(t)
|
|
|
|
wGet, _ := do(t, r, http.MethodGet, "/api/v2/subscriptions/SUB-GHOST", nil)
|
|
if wGet.Code != http.StatusNotFound {
|
|
t.Fatalf("get unknown sub code=%d, want 404", wGet.Code)
|
|
}
|
|
wCancel, _ := do(t, r, http.MethodPost, "/api/v2/subscriptions/SUB-GHOST/cancel", nil)
|
|
if wCancel.Code != http.StatusNotFound {
|
|
t.Fatalf("cancel unknown sub code=%d, want 404", wCancel.Code)
|
|
}
|
|
}
|
|
|
|
// TestV2SubscriptionCancelLifecycle 端到端:建订阅 → 首期支付回调激活 → 查询 active →
|
|
// 取消 → 查询 canceled;取消端点重复调用幂等(仍 200,canceled=true)。
|
|
func TestV2SubscriptionCancelLifecycle(t *testing.T) {
|
|
r, fp := buildSubEngine(t)
|
|
|
|
w, out := do(t, r, http.MethodPost, "/api/v2/subscriptions", map[string]any{
|
|
"sku": "pro_monthly", "method": "subfake", "biz_system": "", "biz_ref": "u-1",
|
|
})
|
|
if w.Code != http.StatusOK {
|
|
t.Fatalf("create subscription code=%d body=%v", w.Code, out)
|
|
}
|
|
data := out["data"].(map[string]any)
|
|
subID := data["sub_id"].(string)
|
|
|
|
// 激活前:GetSubscription 404(Subscription 行在首期支付回调时才诞生)。
|
|
wPre, _ := do(t, r, http.MethodGet, "/api/v2/subscriptions/"+subID, nil)
|
|
if wPre.Code != http.StatusNotFound {
|
|
t.Fatalf("get before activation code=%d, want 404", wPre.Code)
|
|
}
|
|
|
|
// 首期支付回调激活。
|
|
raw, err := json.Marshal(provider.PaidEvent{
|
|
Kind: provider.EventPayment, ProviderRef: fp.sessionRef, Status: provider.PaidSucceeded,
|
|
PaidAmountMinor: 2999, PaidCurrency: "USD", SubscriptionRef: "sub_h1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("marshal event: %v", err)
|
|
}
|
|
wc, _ := do(t, r, http.MethodPost, "/api/v2/callback/subfake", json.RawMessage(raw))
|
|
if wc.Code != http.StatusOK {
|
|
t.Fatalf("activate callback code=%d", wc.Code)
|
|
}
|
|
|
|
wActive, outActive := do(t, r, http.MethodGet, "/api/v2/subscriptions/"+subID, nil)
|
|
if wActive.Code != http.StatusOK {
|
|
t.Fatalf("get after activation code=%d body=%v", wActive.Code, outActive)
|
|
}
|
|
if outActive["data"].(map[string]any)["status"] != "active" {
|
|
t.Fatalf("status = %v, want active", outActive["data"])
|
|
}
|
|
|
|
// 取消。
|
|
wCancel, outCancel := do(t, r, http.MethodPost, "/api/v2/subscriptions/"+subID+"/cancel", nil)
|
|
if wCancel.Code != http.StatusOK || outCancel["data"].(map[string]any)["canceled"] != true {
|
|
t.Fatalf("cancel = %d %v", wCancel.Code, outCancel)
|
|
}
|
|
wAfter, outAfter := do(t, r, http.MethodGet, "/api/v2/subscriptions/"+subID, nil)
|
|
if wAfter.Code != http.StatusOK || outAfter["data"].(map[string]any)["status"] != "canceled" {
|
|
t.Fatalf("status after cancel = %d %v", wAfter.Code, outAfter)
|
|
}
|
|
|
|
// 重复取消:幂等 200,不报错。
|
|
wCancel2, outCancel2 := do(t, r, http.MethodPost, "/api/v2/subscriptions/"+subID+"/cancel", nil)
|
|
if wCancel2.Code != http.StatusOK || outCancel2["data"].(map[string]any)["canceled"] != true {
|
|
t.Fatalf("repeat cancel = %d %v", wCancel2.Code, outCancel2)
|
|
}
|
|
}
|