wangjia
190 lines
6.7 KiB
Go
190 lines
6.7 KiB
Go
package gateway_test
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"testing"
|
|
|
|
"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/store"
|
|
)
|
|
|
|
// fakeSubProvider 实现 provider.SubscriptionProvider:创建订阅 Checkout 返回固定 session。
|
|
// VerifyCallback 不经它——测试直接构造 PaidEvent 走 Settle/HandleCallback 的 default 分支
|
|
// 时也走它(HandleCallback 仍需先过 VerifyCallback 才能拿到 ev),这里让它原样透传注入的
|
|
// JSON 回调体(与 fake.Provider.VerifyCallback 同构,便于测试直接摆事件)。
|
|
type fakeSubProvider struct {
|
|
sessionRef string
|
|
}
|
|
|
|
func (p *fakeSubProvider) Method() string { return "substripe" }
|
|
|
|
func (p *fakeSubProvider) Capabilities() provider.Capabilities {
|
|
return provider.Capabilities{
|
|
RenderTypes: []provider.RenderType{provider.RenderRedirect},
|
|
SupportsRecurring: true,
|
|
RecurringKind: provider.RecurringKindGatewayScheduled,
|
|
SettleCurrencies: []string{"USD"},
|
|
Regions: []string{"global"},
|
|
}
|
|
}
|
|
|
|
func (p *fakeSubProvider) Create(_ context.Context, _ provider.CreateRequest) (*provider.Session, error) {
|
|
return nil, errors.New("fakeSubProvider: one-time Create not used")
|
|
}
|
|
|
|
func (p *fakeSubProvider) 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, "amount_minor": req.AmountMinor},
|
|
}, nil
|
|
}
|
|
|
|
func (p *fakeSubProvider) CancelSubscription(_ context.Context, _ string) error { return nil }
|
|
|
|
// VerifyCallback 直接把测试构造的 provider.PaidEvent JSON 反序列化透传回放,省去自建协议。
|
|
func (p *fakeSubProvider) 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 *fakeSubProvider) Query(_ context.Context, req provider.QueryRequest) (*provider.PaidEvent, error) {
|
|
return &provider.PaidEvent{ProviderRef: req.ProviderRef, Status: provider.PaidPending}, nil
|
|
}
|
|
|
|
func newSubGateway(t *testing.T) (*gateway.Gateway, *fakeSubProvider, *spyEnqueuer, *store.OrderStore, *store.SubscriptionStore) {
|
|
t.Helper()
|
|
db := model.OpenTestDB(t)
|
|
orders := store.NewOrderStore(db)
|
|
refunds := store.NewRefundStore(db)
|
|
subs := store.NewSubscriptionStore(db)
|
|
preg := provider.NewRegistry()
|
|
fp := &fakeSubProvider{sessionRef: "cs_test_sess1"}
|
|
preg.Register(fp)
|
|
areg := accounts.New([]config.AccountConfig{
|
|
{AccountID: "sub-a1", Channel: "substripe", Region: "global", Enabled: true, Weight: 1},
|
|
})
|
|
picker := accounts.NewRouter(areg, nil, nil)
|
|
spy := &spyEnqueuer{}
|
|
g := gateway.New(orders, refunds, preg, picker, stubSubResolver{}, spy, "global", subs)
|
|
return g, fp, spy, orders, subs
|
|
}
|
|
|
|
type stubSubResolver struct{}
|
|
|
|
func (stubSubResolver) Resolve(sku, currency string) (int64, string, string, error) {
|
|
if sku != "pro_monthly" {
|
|
return 0, "", "", gateway.ErrProductNotFound
|
|
}
|
|
if currency != "USD" {
|
|
return 0, "", "", gateway.ErrProductNotFound
|
|
}
|
|
return 2999, "Pro 月付", "pro_monthly", nil
|
|
}
|
|
|
|
func TestCreateSubscriptionPipeline(t *testing.T) {
|
|
g, fp, _, orders, _ := newSubGateway(t)
|
|
res, err := g.CreateSubscription(context.Background(), gateway.CreateSubscriptionInput{
|
|
SKU: "pro_monthly", Method: "substripe", BizSystem: "pangolin", BizRef: "u-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateSubscription: %v", err)
|
|
}
|
|
if res.SubID == "" || res.OrderNo == "" {
|
|
t.Fatalf("result = %+v", res)
|
|
}
|
|
if res.Session.RenderType != string(provider.RenderRedirect) {
|
|
t.Fatalf("session = %+v", res.Session)
|
|
}
|
|
o, err := orders.GetOrder(res.OrderNo)
|
|
if err != nil || o.Status != model.OrderPendingV2 || o.AmountMinor != 2999 || o.Currency != "USD" {
|
|
t.Fatalf("order = %+v, %v", o, err)
|
|
}
|
|
atts, _ := orders.ListAttemptsByStatus(model.AttemptPending, 10)
|
|
if len(atts) != 1 || atts[0].ProviderRef != fp.sessionRef {
|
|
t.Fatalf("attempt = %+v", atts)
|
|
}
|
|
}
|
|
|
|
func TestSubscriptionActivationOnFirstPayment(t *testing.T) {
|
|
g, fp, spy, orders, subs := newSubGateway(t)
|
|
ctx := context.Background()
|
|
res, err := g.CreateSubscription(ctx, gateway.CreateSubscriptionInput{
|
|
SKU: "pro_monthly", Method: "substripe", BizSystem: "pangolin", BizRef: "u-1",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("CreateSubscription: %v", err)
|
|
}
|
|
|
|
raw, err := json.Marshal(provider.PaidEvent{
|
|
Kind: provider.EventPayment, ProviderRef: fp.sessionRef, Status: provider.PaidSucceeded,
|
|
PaidAmountMinor: 2999, PaidCurrency: "USD", SubscriptionRef: "sub_new",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("marshal event: %v", err)
|
|
}
|
|
|
|
// 首次:order 翻 paid + 订阅诞生 active + webhook 收到 2 条(payment.succeeded + subscription.created)。
|
|
result, err := g.HandleCallback(ctx, "substripe", provider.CallbackInput{Raw: raw})
|
|
if err != nil || result != gateway.SettleProcessed {
|
|
t.Fatalf("HandleCallback = %v, %v", result, err)
|
|
}
|
|
o, err := orders.GetOrder(res.OrderNo)
|
|
if err != nil || o.Status != model.OrderPaidV2 {
|
|
t.Fatalf("order after settle = %+v, %v", o, err)
|
|
}
|
|
sub, err := subs.GetByProviderRef("substripe", "sub_new")
|
|
if err != nil {
|
|
t.Fatalf("subscription not created: %v", err)
|
|
}
|
|
if sub.Status != model.SubActive || sub.SubID != res.SubID {
|
|
t.Fatalf("subscription = %+v, want active/%s", sub, res.SubID)
|
|
}
|
|
if len(spy.calls) != 2 {
|
|
t.Fatalf("webhook calls = %d, want 2: %+v", len(spy.calls), spy.calls)
|
|
}
|
|
sawPaymentSucceeded, sawSubCreated := false, false
|
|
for _, c := range spy.calls {
|
|
switch c["event_type"] {
|
|
case gateway.EvtPaymentSucceeded:
|
|
sawPaymentSucceeded = true
|
|
case gateway.EvtSubscriptionCreated:
|
|
sawSubCreated = true
|
|
if c["sub_id"] != res.SubID {
|
|
t.Fatalf("subscription.created sub_id = %v, want %s", c["sub_id"], res.SubID)
|
|
}
|
|
}
|
|
}
|
|
if !sawPaymentSucceeded || !sawSubCreated {
|
|
t.Fatalf("missing expected events: %+v", spy.calls)
|
|
}
|
|
|
|
// 重投同一 event → 幂等:订单/订阅不重复变动,webhook 不再新增。
|
|
result2, err := g.HandleCallback(ctx, "substripe", provider.CallbackInput{Raw: raw})
|
|
if err != nil {
|
|
t.Fatalf("HandleCallback replay: %v", err)
|
|
}
|
|
if result2 != gateway.SettleDuplicate {
|
|
t.Fatalf("replay result = %v, want duplicate", result2)
|
|
}
|
|
if len(spy.calls) != 2 {
|
|
t.Fatalf("webhook calls after replay = %d, want still 2: %+v", len(spy.calls), spy.calls)
|
|
}
|
|
subAfter, err := subs.GetByProviderRef("substripe", "sub_new")
|
|
if err != nil {
|
|
t.Fatalf("subscription after replay: %v", err)
|
|
}
|
|
if subAfter.ID != sub.ID {
|
|
t.Fatalf("subscription duplicated on replay: %+v vs %+v", subAfter, sub)
|
|
}
|
|
}
|