401 lines
16 KiB
Go
401 lines
16 KiB
Go
package wallet_test
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"hyapp/pkg/xerr"
|
|
"hyapp/services/wallet-service/internal/domain/ledger"
|
|
walletservice "hyapp/services/wallet-service/internal/service/wallet"
|
|
)
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptMifaPayReturnsPaidSnapshot(t *testing.T) {
|
|
mifaPay := &fakeMifaPayClient{
|
|
queryResp: walletservice.MifaPayQueryOrderResponse{
|
|
OrderID: "receipt-mifa-1",
|
|
ProviderOrderID: "mb_receipt_mifa_1",
|
|
Status: "1",
|
|
Amount: "125000",
|
|
Currency: "PHP",
|
|
PayType: "GCASH",
|
|
RawJSON: `{"status":"1"}`,
|
|
},
|
|
}
|
|
svc := walletservice.New(nil)
|
|
svc.SetMifaPayClient(mifaPay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderMifaPay,
|
|
ExternalOrderNo: "receipt-mifa-1",
|
|
OrderDateMS: 1767225600000,
|
|
ProviderCurrencyCode: "php",
|
|
ProviderPayType: "gcash",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt mifapay failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.ProviderOrderID != "mb_receipt_mifa_1" || receipt.ProviderAmountMinor != 125000 || receipt.CurrencyCode != "PHP" || receipt.RawJSON == "" {
|
|
t.Fatalf("mifapay receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if mifaPay.queryReq.OrderID != "receipt-mifa-1" || mifaPay.queryReq.OrderCreatedAtMS != 1767225600000 {
|
|
t.Fatalf("mifapay query request mismatch: %+v", mifaPay.queryReq)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptMifaPayWithoutDateUsesRecentLookup(t *testing.T) {
|
|
mifaPay := &fakeMifaPayClient{
|
|
querySeq: []fakeMifaPayQueryResult{
|
|
{err: xerr.New(xerr.NotFound, "mifapay order not found")},
|
|
{resp: walletservice.MifaPayQueryOrderResponse{
|
|
OrderID: "receipt-mifa-no-date",
|
|
ProviderOrderID: "mb_receipt_mifa_no_date",
|
|
Status: "1",
|
|
Amount: "125000",
|
|
Currency: "PHP",
|
|
PayType: "GCASH",
|
|
RawJSON: `{"status":"1"}`,
|
|
}},
|
|
},
|
|
}
|
|
svc := walletservice.New(nil)
|
|
svc.SetMifaPayClient(mifaPay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderMifaPay,
|
|
ExternalOrderNo: "receipt-mifa-no-date",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt mifapay without date failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.ProviderOrderID != "mb_receipt_mifa_no_date" {
|
|
t.Fatalf("mifapay no-date receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if len(mifaPay.queryReqs) != 2 {
|
|
t.Fatalf("mifapay no-date lookup should continue after not found, got %+v", mifaPay.queryReqs)
|
|
}
|
|
firstDate := time.UnixMilli(mifaPay.queryReqs[0].OrderCreatedAtMS).UTC()
|
|
secondDate := time.UnixMilli(mifaPay.queryReqs[1].OrderCreatedAtMS).UTC()
|
|
if firstDate.Hour() != 0 || secondDate.Hour() != 0 || !sameUTCDate(secondDate, firstDate.AddDate(0, 0, -1)) {
|
|
t.Fatalf("mifapay no-date lookup should walk backwards by UTC date: %+v", mifaPay.queryReqs)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptMifaPayWithoutDateReturnsUnpaidSnapshot(t *testing.T) {
|
|
mifaPay := &fakeMifaPayClient{
|
|
querySeq: []fakeMifaPayQueryResult{
|
|
{err: xerr.New(xerr.NotFound, "mifapay order not found")},
|
|
{resp: walletservice.MifaPayQueryOrderResponse{
|
|
OrderID: "receipt-mifa-unpaid",
|
|
Status: "0",
|
|
Amount: "125000",
|
|
Currency: "PHP",
|
|
RawJSON: `{"status":"0"}`,
|
|
}},
|
|
},
|
|
}
|
|
svc := walletservice.New(nil)
|
|
svc.SetMifaPayClient(mifaPay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderMifaPay,
|
|
ExternalOrderNo: "receipt-mifa-unpaid",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt mifapay unpaid failed: %v", err)
|
|
}
|
|
if receipt.Verified || receipt.FailureReason != "mifapay order status 0" {
|
|
t.Fatalf("mifapay unpaid should return failed snapshot, got %+v", receipt)
|
|
}
|
|
if len(mifaPay.queryReqs) != 2 {
|
|
t.Fatalf("mifapay unpaid should stop once an order is found, got %+v", mifaPay.queryReqs)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptV5PayRejectsCurrencyMismatchWithoutWriting(t *testing.T) {
|
|
v5Pay := &fakeV5PayClient{
|
|
queryResp: walletservice.V5PayQueryOrderResponse{
|
|
OrderID: "receipt-v5-1",
|
|
ProviderOrderID: "tx_receipt_v5_1",
|
|
Status: "2",
|
|
Amount: "48.00",
|
|
Currency: "TRY",
|
|
ProductType: "BANK_TRANSFER",
|
|
RawJSON: `{"status":"2"}`,
|
|
},
|
|
}
|
|
svc := walletservice.New(nil)
|
|
svc.SetV5PayClient(v5Pay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderV5Pay,
|
|
ExternalOrderNo: "receipt-v5-1",
|
|
ProviderCountryCode: "TR",
|
|
ProviderCurrencyCode: "PHP",
|
|
ProviderPayType: "BANK_TRANSFER",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt v5pay failed: %v", err)
|
|
}
|
|
if receipt.Verified || receipt.FailureReason != "v5pay currency mismatch" || receipt.ProviderAmountMinor != 4800 {
|
|
t.Fatalf("v5pay mismatch should return a failed snapshot, got %+v", receipt)
|
|
}
|
|
if v5Pay.queryReq.CountryCode != "TR" || v5Pay.queryReq.CurrencyCode != "PHP" {
|
|
t.Fatalf("v5pay query request should use caller supplied country/currency: %+v", v5Pay.queryReq)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptV5PayWithoutCountryCurrencyUsesEnabledCandidates(t *testing.T) {
|
|
repository := &fakeReceiptRepository{channels: []ledger.ThirdPartyPaymentChannel{{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderV5Pay,
|
|
Status: ledger.ThirdPartyPaymentStatusActive,
|
|
Methods: []ledger.ThirdPartyPaymentMethod{
|
|
{ProviderCode: ledger.PaymentProviderV5Pay, CountryCode: "TR", CurrencyCode: "TRY", Status: ledger.ThirdPartyPaymentStatusActive},
|
|
{ProviderCode: ledger.PaymentProviderV5Pay, CountryCode: "PH", CurrencyCode: "PHP", Status: ledger.ThirdPartyPaymentStatusActive},
|
|
},
|
|
}}}
|
|
v5Pay := &fakeV5PayClient{
|
|
querySeq: []fakeV5PayQueryResult{
|
|
{err: xerr.New(xerr.NotFound, "v5pay order not found")},
|
|
{resp: walletservice.V5PayQueryOrderResponse{
|
|
OrderID: "receipt-v5-no-hints",
|
|
ProviderOrderID: "tx_receipt_v5_no_hints",
|
|
Status: "2",
|
|
Amount: "48.00",
|
|
Currency: "PHP",
|
|
ProductType: "GCASH",
|
|
RawJSON: `{"status":"2"}`,
|
|
}},
|
|
},
|
|
}
|
|
svc := walletservice.New(repository)
|
|
svc.SetV5PayClient(v5Pay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderV5Pay,
|
|
ExternalOrderNo: "receipt-v5-no-hints",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt v5pay no hints failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.ProviderOrderID != "tx_receipt_v5_no_hints" {
|
|
t.Fatalf("v5pay no-hints receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if !repository.querySeen || repository.query.ProviderCode != ledger.PaymentProviderV5Pay || repository.query.IncludeDisabledMethods {
|
|
t.Fatalf("v5pay no-hints lookup should enumerate active V5Pay methods: %+v", repository.query)
|
|
}
|
|
if len(v5Pay.queryReqs) != 2 || v5Pay.queryReqs[0].CountryCode != "TR" || v5Pay.queryReqs[0].CurrencyCode != "TRY" || v5Pay.queryReqs[1].CountryCode != "PH" || v5Pay.queryReqs[1].CurrencyCode != "PHP" {
|
|
t.Fatalf("v5pay no-hints lookup should use enabled country/currency candidates: %+v", v5Pay.queryReqs)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptV5PayWithoutCountryCurrencyNotFound(t *testing.T) {
|
|
repository := &fakeReceiptRepository{channels: []ledger.ThirdPartyPaymentChannel{{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderV5Pay,
|
|
Status: ledger.ThirdPartyPaymentStatusActive,
|
|
Methods: []ledger.ThirdPartyPaymentMethod{
|
|
{ProviderCode: ledger.PaymentProviderV5Pay, CountryCode: "TR", CurrencyCode: "TRY", Status: ledger.ThirdPartyPaymentStatusActive},
|
|
{ProviderCode: ledger.PaymentProviderV5Pay, CountryCode: "PH", CurrencyCode: "PHP", Status: ledger.ThirdPartyPaymentStatusActive},
|
|
},
|
|
}}}
|
|
v5Pay := &fakeV5PayClient{querySeq: []fakeV5PayQueryResult{
|
|
{err: xerr.New(xerr.NotFound, "v5pay order not found")},
|
|
{err: xerr.New(xerr.NotFound, "v5pay order not found")},
|
|
}}
|
|
svc := walletservice.New(repository)
|
|
svc.SetV5PayClient(v5Pay)
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderV5Pay,
|
|
ExternalOrderNo: "receipt-v5-missing",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt v5pay not found failed: %v", err)
|
|
}
|
|
if receipt.Verified || receipt.FailureReason != "v5pay order not found for enabled country/currency candidates" {
|
|
t.Fatalf("v5pay missing order should return failed snapshot, got %+v", receipt)
|
|
}
|
|
if len(v5Pay.queryReqs) != 2 {
|
|
t.Fatalf("v5pay missing order should exhaust enabled candidates, got %+v", v5Pay.queryReqs)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptUSDTBEP20UsesReadOnlyClient(t *testing.T) {
|
|
bsc := &fakeTronUSDTClient{rawJSON: `{"receipt":true}`}
|
|
svc := walletservice.New(nil)
|
|
svc.SetBSCUSDTClient(bsc)
|
|
svc.SetExternalRechargeConfig(walletservice.ExternalRechargeConfig{
|
|
USDTBEP20Enabled: true,
|
|
USDTBEP20Address: "0xPlatformBEP20ReceiveAddress",
|
|
})
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderUSDTBEP20,
|
|
ExternalOrderNo: "0xreceiptbep20",
|
|
USDMinorAmount: 150,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt usdt_bep20 failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.Status != "confirmed" || receipt.Chain != "bep20" || receipt.ProviderAmountMinor != 150 || receipt.ReceiveAddress != "0xPlatformBEP20ReceiveAddress" {
|
|
t.Fatalf("bep20 receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if bsc.lastTxHash != "0xreceiptbep20" || bsc.lastToAddress != "0xPlatformBEP20ReceiveAddress" || bsc.lastAmountMinor != 150 {
|
|
t.Fatalf("bep20 client request mismatch: %+v", bsc)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptUSDTBEP20DisabledFailsClosed(t *testing.T) {
|
|
svc := walletservice.New(nil)
|
|
_, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderUSDTBEP20,
|
|
ExternalOrderNo: "0xreceiptbep20",
|
|
USDMinorAmount: 150,
|
|
})
|
|
if !xerr.IsCode(err, xerr.Unavailable) || !strings.Contains(err.Error(), "not configured") {
|
|
t.Fatalf("disabled bep20 verification should fail closed, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptUSDTTRC20HashUsesTronGrid(t *testing.T) {
|
|
tron := &fakeTronUSDTClient{rawJSON: `{"chain":true}`}
|
|
binance := &fakeBinanceClient{err: xerr.New(xerr.Internal, "binance should not be called")}
|
|
svc := walletservice.New(nil)
|
|
svc.SetTronUSDTClient(tron)
|
|
svc.SetBinanceClient(binance)
|
|
svc.SetExternalRechargeConfig(walletservice.ExternalRechargeConfig{
|
|
USDTTRC20Enabled: true,
|
|
USDTTRC20Address: "TPlatformReceiveAddress",
|
|
})
|
|
txHash := "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "lalu",
|
|
ProviderCode: ledger.PaymentProviderUSDTTRC20,
|
|
ExternalOrderNo: txHash,
|
|
USDMinorAmount: 50000,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt usdt_trc20 hash failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.Status != "confirmed" || receipt.RawJSON != `{"chain":true}` {
|
|
t.Fatalf("trc20 hash receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if tron.lastTxHash != txHash || tron.lastToAddress != "TPlatformReceiveAddress" || tron.lastAmountMinor != 50000 {
|
|
t.Fatalf("trc20 hash should use TronGrid client: %+v", tron)
|
|
}
|
|
if binance.calls != 0 {
|
|
t.Fatalf("chain tx hash must not call Binance, calls=%d", binance.calls)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptUSDTTRC20OffchainUsesBinance(t *testing.T) {
|
|
tron := &fakeTronUSDTClient{err: xerr.New(xerr.Internal, "tron should not be called")}
|
|
binance := &fakeBinanceClient{record: walletservice.BinanceDepositRecord{
|
|
TxID: "Off-chain transfer 388611987194",
|
|
Coin: ledger.PaidCurrencyUSDT,
|
|
Network: "TRX",
|
|
Status: 1,
|
|
Address: "TNwqCkF8cnM4XiwjnbbKTfdZvFDqVoa1TN",
|
|
Amount: "500.00000000",
|
|
AmountMinor: 50000,
|
|
RawJSON: `{"txId":"Off-chain transfer 388611987194","status":1}`,
|
|
}}
|
|
svc := walletservice.New(nil)
|
|
svc.SetTronUSDTClient(tron)
|
|
svc.SetBinanceClient(binance)
|
|
svc.SetExternalRechargeConfig(walletservice.ExternalRechargeConfig{
|
|
USDTTRC20Enabled: true,
|
|
USDTTRC20Address: "TGlobalFallbackReceiveAddress",
|
|
USDTTRC20Addresses: map[string]string{
|
|
"aslan": "TNwqCkF8cnM4XiwjnbbKTfdZvFDqVoa1TN",
|
|
},
|
|
})
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "aslan",
|
|
ProviderCode: ledger.PaymentProviderUSDTTRC20,
|
|
ExternalOrderNo: "388611987194",
|
|
USDMinorAmount: 50000,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("VerifyCoinSellerRechargeReceipt binance offchain failed: %v", err)
|
|
}
|
|
if !receipt.Verified || receipt.Status != "confirmed" || receipt.ProviderOrderID != "Off-chain transfer 388611987194" || receipt.ProviderAmountMinor != 50000 || receipt.ReceiveAddress != "TNwqCkF8cnM4XiwjnbbKTfdZvFDqVoa1TN" {
|
|
t.Fatalf("binance offchain receipt snapshot mismatch: %+v", receipt)
|
|
}
|
|
if binance.calls != 1 || binance.req.AppCode != "aslan" || binance.req.ExternalID != "388611987194" || binance.req.Network != "TRX" || binance.req.ToAddress != "TNwqCkF8cnM4XiwjnbbKTfdZvFDqVoa1TN" || binance.req.AmountMinor != 50000 {
|
|
t.Fatalf("binance offchain request mismatch: calls=%d req=%+v", binance.calls, binance.req)
|
|
}
|
|
if tron.lastTxHash != "" {
|
|
t.Fatalf("off-chain Binance id must not call TronGrid: %+v", tron)
|
|
}
|
|
}
|
|
|
|
func TestVerifyCoinSellerRechargeReceiptUSDTTRC20OffchainMissingBinanceAccount(t *testing.T) {
|
|
binance := &fakeBinanceClient{err: xerr.New(xerr.Unavailable, "binance account is not configured")}
|
|
svc := walletservice.New(nil)
|
|
svc.SetBinanceClient(binance)
|
|
svc.SetExternalRechargeConfig(walletservice.ExternalRechargeConfig{
|
|
USDTTRC20Enabled: true,
|
|
USDTTRC20Address: "TNwqCkF8cnM4XiwjnbbKTfdZvFDqVoa1TN",
|
|
})
|
|
receipt, err := svc.VerifyCoinSellerRechargeReceipt(context.Background(), ledger.VerifyCoinSellerRechargeReceiptCommand{
|
|
AppCode: "yumi",
|
|
ProviderCode: ledger.PaymentProviderUSDTTRC20,
|
|
ExternalOrderNo: "388611987194",
|
|
USDMinorAmount: 50000,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("missing binance account should return failed snapshot, got error %v", err)
|
|
}
|
|
if receipt.Verified || !strings.Contains(receipt.FailureReason, "binance account is not configured") {
|
|
t.Fatalf("missing binance account should be explicit in snapshot, got %+v", receipt)
|
|
}
|
|
}
|
|
|
|
type fakeReceiptRepository struct {
|
|
walletservice.Repository
|
|
channels []ledger.ThirdPartyPaymentChannel
|
|
query ledger.ListThirdPartyPaymentChannelsQuery
|
|
queryErr error
|
|
querySeen bool
|
|
}
|
|
|
|
func (r *fakeReceiptRepository) ListThirdPartyPaymentChannels(_ context.Context, query ledger.ListThirdPartyPaymentChannelsQuery) ([]ledger.ThirdPartyPaymentChannel, error) {
|
|
r.query = query
|
|
r.querySeen = true
|
|
if r.queryErr != nil {
|
|
return nil, r.queryErr
|
|
}
|
|
return r.channels, nil
|
|
}
|
|
|
|
func (r *fakeReceiptRepository) GetExternalRechargeOrder(context.Context, string, string) (ledger.ExternalRechargeOrder, error) {
|
|
return ledger.ExternalRechargeOrder{}, xerr.New(xerr.NotFound, "external recharge order not found")
|
|
}
|
|
|
|
func sameUTCDate(left time.Time, right time.Time) bool {
|
|
left = left.UTC()
|
|
right = right.UTC()
|
|
return left.Year() == right.Year() && left.YearDay() == right.YearDay()
|
|
}
|
|
|
|
type fakeBinanceClient struct {
|
|
req walletservice.BinanceDepositLookupRequest
|
|
record walletservice.BinanceDepositRecord
|
|
err error
|
|
calls int
|
|
}
|
|
|
|
func (f *fakeBinanceClient) FindUSDTDeposit(_ context.Context, req walletservice.BinanceDepositLookupRequest) (walletservice.BinanceDepositRecord, error) {
|
|
f.calls++
|
|
f.req = req
|
|
if f.err != nil {
|
|
return walletservice.BinanceDepositRecord{}, f.err
|
|
}
|
|
return f.record, nil
|
|
}
|