package com.talentcard.server.business.payment;
|
|
import static org.assertj.core.api.Assertions.assertThat;
|
import static org.mockito.ArgumentMatchers.any;
|
import static org.mockito.ArgumentMatchers.argThat;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.when;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.format.DateTimeFormatter;
|
import java.util.Map;
|
|
import com.talentcard.server.business.order.OrderRefundRequest;
|
import com.talentcard.server.business.payment.huifu.HuifuDelayAccountGateway;
|
import com.talentcard.server.business.payment.huifu.HuifuMiniProgramPaymentCommand;
|
import com.talentcard.server.business.payment.huifu.HuifuMiniProgramPaymentGateway;
|
import com.talentcard.server.business.portal.AppOrderCreateRequest;
|
import com.talentcard.server.business.portal.AppOrderPortalService;
|
import com.talentcard.server.common.BusinessException;
|
import com.talentcard.server.common.ErrorCode;
|
import org.junit.jupiter.api.BeforeEach;
|
import org.junit.jupiter.api.Test;
|
import org.mockito.ArgumentCaptor;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.boot.test.context.SpringBootTest;
|
import org.springframework.jdbc.core.JdbcTemplate;
|
import org.springframework.test.context.ActiveProfiles;
|
import org.springframework.test.context.bean.override.mockito.MockitoBean;
|
|
/**
|
* 延迟入账与资金确认。
|
*
|
* <p>业务规则：先付钱后核销的订单，钱必须留在通道「待确认」，核销确认后才分配给商户；支付即核销的
|
* 到店消费订单不延迟，也不该被这个流程影响。
|
*/
|
@SpringBootTest
|
@ActiveProfiles("test")
|
class PaymentFundConfirmationTests {
|
|
private static final String HUIFU_ID = "6666000226048687";
|
|
@Autowired
|
private JdbcTemplate jdbc;
|
|
@Autowired
|
private AppOrderPortalService orderPortalService;
|
|
@Autowired
|
private HuifuPaymentService paymentService;
|
|
@Autowired
|
private PaymentFundConfirmationService confirmationService;
|
|
@Autowired
|
private PaymentSettlementService settlementService;
|
|
@Autowired
|
private PaymentFundConfirmationRetry confirmationRetry;
|
|
@MockitoBean
|
private HuifuMiniProgramPaymentGateway paymentGateway;
|
|
@MockitoBean
|
private HuifuDelayAccountGateway delayGateway;
|
|
private Long merchantId;
|
private Long storeId;
|
private Long talentId;
|
private Long productId;
|
private String suffix;
|
|
@BeforeEach
|
void prepare() {
|
suffix = String.valueOf(System.nanoTime());
|
jdbc.update("insert into merchant(merchant_name, status, deleted) values (?, 1, 0)", "延迟入账商户 " + suffix);
|
merchantId = jdbc.queryForObject("select max(id) from merchant", Long.class);
|
jdbc.update("insert into talent_user(openid, name, mobile, status, deleted) values (?, ?, ?, 1, 0)",
|
"delay-" + suffix, "延迟入账用户", "13900000009");
|
talentId = jdbc.queryForObject("select max(id) from talent_user", Long.class);
|
jdbc.update("insert into talent_card(talent_id, card_no, status) values (?, ?, 1)", talentId, "DC" + suffix);
|
jdbc.update("insert into merchant_store(merchant_id, store_name, status, deleted) values (?, ?, 1, 0)",
|
merchantId, "延迟入账门店 " + suffix);
|
storeId = jdbc.queryForObject("select max(id) from merchant_store", Long.class);
|
// 下单要求商户的收款能力已确认：进件通过 + 斗拱商户号 + 能力快照（自动结算已关、取现可用）。
|
jdbc.update("""
|
insert into merchant_onboarding_application(merchant_id, store_id, application_no, subject_type, subject_name,
|
contact_name, contact_mobile, idempotency_key, status, provider_huifu_id,
|
auto_settle_status, cash_switch_status, merchant_stat, capability_verified_at)
|
values (?, ?, ?, 'individual', 'Delay owner', 'Delay owner', '13900000009', ?, 'approved', ?, '0', '1', 'NORMAL', current_timestamp)
|
""", merchantId, storeId, "MO-DELAY-" + suffix, "delay-onboarding-" + suffix, HUIFU_ID);
|
Long onboardingId = jdbc.queryForObject("select max(id) from merchant_onboarding_application", Long.class);
|
jdbc.update("""
|
insert into merchant_bank_card(merchant_id, store_id, bank_name, branch_name, city_code, card_tail, card_masked,
|
card_hash, status, idempotency_key, provider_token_no, reviewed_at)
|
values (?, ?, '中国建设银行', '攀枝花东区支行', '510400', '8888', '**** **** **** 8888', ?, 'approved', ?, ?, current_timestamp)
|
""", merchantId, storeId, "hash-delay-" + suffix, "delay-card-" + suffix, "T" + suffix);
|
Long cardId = jdbc.queryForObject("select max(id) from merchant_bank_card", Long.class);
|
jdbc.update("update merchant_onboarding_application set initial_bank_card_id = ? where id = ?", cardId, onboardingId);
|
// 收款就绪要求微信支付业务开通与实名/授权都有通道证据，这里的商户建模成已办完这两步。
|
jdbc.update("insert into merchant_onboarding_progress(application_id, stages_json) values (?, '{\"wechat\":\"confirmed\",\"realname\":\"confirmed\"}')", onboardingId);
|
jdbc.update("""
|
insert into merchant_product(merchant_id, product_no, product_type, product_name, original_price,
|
sale_price, stock, audit_status, status, deleted)
|
values (?, ?, 'GROUP_BUY', '延迟入账商品', 100.00, 100.00, -1, 2, 1, 0)
|
""", merchantId, "DELAY-PRODUCT-" + suffix);
|
productId = jdbc.queryForObject("select max(id) from merchant_product", Long.class);
|
}
|
|
@Test
|
void aDelayedOrderHoldsTheMoneyUntilItIsConfirmed() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "pending");
|
markVerified(orderId(orderNo));
|
|
when(delayGateway.confirm(any())).thenReturn(succeeded("1.00"));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.CONFIRMED);
|
|
Map<String, Object> payment = jdbc.queryForMap(
|
"select funds_confirmation_status, funds_confirmed_amount, funds_confirmed_at, funds_confirm_no"
|
+ " from payment_transaction where payment_no = ?", paymentNo);
|
assertThat(payment).containsEntry("funds_confirmation_status", "confirmed");
|
// 通道回执的已确认金额是「元」字符串，本地存的是分。
|
assertThat(((Number) payment.get("funds_confirmed_amount")).longValue()).isEqualTo(100L);
|
assertThat(payment.get("funds_confirmed_at")).isNotNull();
|
assertThat(String.valueOf(payment.get("funds_confirm_no"))).isNotBlank();
|
}
|
|
@Test
|
void anAlreadyConfirmedOrderIsNeverConfirmedTwice() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
insertPaidPayment(orderNo, 100L, "pending");
|
markVerified(orderId(orderNo));
|
when(delayGateway.confirm(any())).thenReturn(succeeded("1.00"));
|
|
confirmationService.confirmForOrder(orderId(orderNo));
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.CONFIRMED);
|
|
verify(delayGateway).confirm(any());
|
}
|
|
@Test
|
void aConfirmationAlreadyInFlightIsNotStartedAgain() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
insertPaidPayment(orderNo, 100L, "confirming");
|
markVerified(orderId(orderNo));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.PROCESSING);
|
verify(delayGateway, never()).confirm(any());
|
}
|
|
/**
|
* 确认失败时状态有意保留 pending，而订单已经核销、不会再有人走核销入口。
|
* 没有补偿的话这笔钱会永远冻在通道延迟户里。
|
*/
|
@Test
|
void aPendingConfirmationOfAVerifiedOrderIsRetriedWithoutAnotherVerification() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "pending");
|
long orderId = orderId(orderNo);
|
jdbc.update("update benefit_order set order_status = 1, verify_status = 1 where id = ?", orderId);
|
when(delayGateway.confirm(any())).thenReturn(succeeded("1.00"));
|
// 补偿任务扫的是整库、按订单号从小到大取一批，而测试库共享且不清理。先把自己之外的相关行移出
|
// 扫描条件（那些用例已经跑完），本用例这条才一定落在窗口内——否则它会随测试库累积而必然失败
|
// （docs/agents/testing.md 记的「环境相关失败」）。
|
jdbc.update("""
|
update benefit_order set refund_status = 1
|
where id <> ? and deleted = 0 and order_status = 1 and verify_status = 1 and refund_status = 0
|
and exists (select 1 from payment_transaction p
|
where p.order_id = benefit_order.id and p.status = 'SUCCEEDED'
|
and p.funds_confirmation_status in ('pending', 'confirming', 'reverting'))
|
""", orderId);
|
|
assertThat(confirmationRetry.retry(50)).isEqualTo(1);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("confirmed");
|
}
|
|
/** 已经确认过的订单不该被补偿任务反复打扰通道。 */
|
@Test
|
void theRetrySkipsOrdersWhoseFundsAreAlreadyConfirmed() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "confirmed");
|
markVerified(orderId(orderNo));
|
// 补偿任务扫的是整库，会顺带处理其它用例留下的「已核销 + 待确认」订单，所以给它们一个可用的
|
// 回执，并把断言收窄到本单：要证明的是这笔已经确认过的钱不会被再确认一次。
|
when(delayGateway.confirm(any())).thenReturn(processing());
|
|
confirmationRetry.retry(50);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("confirmed");
|
verify(delayGateway, never()).confirm(argThat(command -> paymentNo.equals(command.paymentNo())));
|
}
|
|
@Test
|
void anOrderThatWasNotDelayedNeedsNoConfirmation() {
|
String orderNo = createOrder("STORE_CONSUME", 100L);
|
insertPaidPayment(orderNo, 100L, null);
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.NOT_DELAYED);
|
verify(delayGateway, never()).confirm(any());
|
}
|
|
@Test
|
void anUnsettledPaymentIsLeftForLater() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPayment(orderNo, 100L, "PREPAY_CREATED", "pending");
|
// 确认补偿任务也在跑，会挑走库里其它用例留下的已核销订单；这里只断言本用例这笔不受影响。
|
when(delayGateway.confirm(any())).thenReturn(processing());
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.NOT_SETTLED);
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction where payment_no = ?",
|
String.class, paymentNo)).isEqualTo("pending");
|
}
|
|
@Test
|
void aRejectedConfirmationStaysRetryableInsteadOfLosingTheMoney() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "pending");
|
markVerified(orderId(orderNo));
|
when(delayGateway.confirm(any())).thenReturn(failed("22000002", "商户信息不存在"));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.FAILED);
|
|
assertThat(jdbc.queryForMap("select funds_confirmation_status, funds_confirm_message"
|
+ " from payment_transaction where payment_no = ?", paymentNo))
|
.containsEntry("funds_confirmation_status", "pending")
|
.containsEntry("funds_confirm_message", "商户信息不存在");
|
}
|
|
@Test
|
void aConfirmedOrderCanBeRefundedWhileAnUnconfirmedOneIsNotWithdrawn() {
|
// 这个用例只断言资金状态这一维：确认前订单不可提现，确认后才可提现（提现门槛本身在
|
// AutoWithdrawalAggregationTests 覆盖）。退款路径的改造尚未完成，这里不做断言。
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
insertPaidPayment(orderNo, 100L, "pending");
|
long orderId = orderId(orderNo);
|
jdbc.update("update benefit_order set order_status = 1, verify_status = 1 where id = ?", orderId);
|
|
when(delayGateway.confirm(any())).thenReturn(succeeded("100"));
|
confirmationService.confirmForOrder(orderId);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where order_id = ?", String.class, orderId)).isEqualTo("confirmed");
|
assertThat(new OrderRefundRequest(BigDecimal.ONE, "test", "tester")).isNotNull();
|
}
|
|
/**
|
* 撤销核销要把已确认给商户的钱退回通道延迟户，这是「撤销之后钱又变成不可结算」的唯一保证。
|
*/
|
@Test
|
void aRevertPutsTheMoneyBackInTheDelayAccount() {
|
String paymentNo = confirmedDelayOrder(100L);
|
when(delayGateway.refund(any())).thenReturn(revertSucceeded());
|
|
assertThat(confirmationService.revertForOrder(orderIdOfPayment(paymentNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERTED);
|
|
Map<String, Object> payment = jdbc.queryForMap("""
|
select funds_confirmation_status, funds_revert_no, funds_revert_request_date,
|
funds_reverted_amount, funds_reverted_at, funds_confirm_no
|
from payment_transaction where payment_no = ?
|
""", paymentNo);
|
// 钱回到延迟户：状态退回 pending，商户重新核销时会走一次全新的交易确认。
|
assertThat(payment).containsEntry("funds_confirmation_status", "pending");
|
assertThat(String.valueOf(payment.get("funds_revert_no"))).isNotBlank();
|
assertThat(String.valueOf(payment.get("funds_revert_request_date"))).isNotBlank();
|
assertThat(((Number) payment.get("funds_reverted_amount")).longValue()).isEqualTo(100L);
|
assertThat(payment.get("funds_reverted_at")).isNotNull();
|
// 上一轮确认的回执要留着：它是「这笔钱曾经确认过」的证据。
|
assertThat(String.valueOf(payment.get("funds_confirm_no"))).isNotBlank();
|
}
|
|
/**
|
* 通道明确拒绝（例如钱已被 D1 结算划到商户银行卡）：钱没有动，状态回到可重试的 confirmed，
|
* 回执留作证据。调用方据此拒绝撤销核销。
|
*/
|
@Test
|
void aRejectedRevertKeepsTheMoneyWithTheMerchant() {
|
String paymentNo = confirmedDelayOrder(100L);
|
when(delayGateway.refund(any())).thenReturn(new HuifuDelayAccountGateway.HuifuDelayRevert(
|
HuifuDelayAccountGateway.HuifuDelayRevert.Outcome.FAILED, "22000003", "账户余额不足", ""));
|
|
assertThat(confirmationService.revertForOrder(orderIdOfPayment(paymentNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_REJECTED);
|
|
assertThat(jdbc.queryForMap("select funds_confirmation_status, funds_revert_message"
|
+ " from payment_transaction where payment_no = ?", paymentNo))
|
.containsEntry("funds_confirmation_status", "confirmed")
|
.containsEntry("funds_revert_message", "账户余额不足");
|
}
|
|
/**
|
* 返回码语义未定时绝不能算成功。
|
*
|
* <p>{@code 23000003} 在交易确认那条路上是「已无未确认金额」＝幂等成功（有真实回执复验过），
|
* 但在回退这条路上没有回执证明它的含义。判成成功会让订单翻回「待核销」而钱还在商户基本户，
|
* 因此只能停在 reverting 等人工核对。
|
*/
|
@Test
|
void anUndeterminedRevertCodeNeverCountsAsSuccess() {
|
String paymentNo = confirmedDelayOrder(100L);
|
when(delayGateway.refund(any())).thenReturn(new HuifuDelayAccountGateway.HuifuDelayRevert(
|
HuifuDelayAccountGateway.HuifuDelayRevert.Outcome.NEEDS_REVIEW, "23000003", "已无已确认金额", ""));
|
|
assertThat(confirmationService.revertForOrder(orderIdOfPayment(paymentNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_NEEDS_REVIEW);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("reverting");
|
}
|
|
/**
|
* 请求根本没发出去（配置不完整、SDK 初始化失败）时，钱没有动，可以重试。
|
*
|
* <p>不能报成「已结算到银行卡」：那是另一回事，商户照着这句话去找平台就白跑了。
|
*/
|
@Test
|
void aRevertThatNeverReachedTheProviderIsRetryable() {
|
String paymentNo = confirmedDelayOrder(100L);
|
when(delayGateway.refund(any())).thenThrow(new BusinessException(ErrorCode.CONFLICT, "汇付支付配置不完整"));
|
|
assertThat(confirmationService.revertForOrder(orderIdOfPayment(paymentNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_NOT_SENT);
|
|
Map<String, Object> payment = jdbc.queryForMap("select funds_confirmation_status, funds_revert_no,"
|
+ " funds_revert_code, funds_revert_message from payment_transaction where payment_no = ?", paymentNo);
|
assertThat(payment).containsEntry("funds_confirmation_status", "confirmed")
|
.containsEntry("funds_revert_code", "LOCAL_ERROR");
|
// 请求号是给通道侧定位用的，这次通道没收到，不能留在库里冒充一次回退。
|
assertThat(payment.get("funds_revert_no")).isNull();
|
assertThat(String.valueOf(payment.get("funds_revert_message"))).isNotBlank();
|
}
|
|
/** 钱还在延迟户：没有已确认的资金要回退，也不该白打一次通道。 */
|
@Test
|
void moneyStillInTheDelayAccountNeedsNoRevert() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
insertPaidPayment(orderNo, 100L, "pending");
|
markVerified(orderId(orderNo));
|
|
assertThat(confirmationService.revertForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_NOT_NEEDED);
|
verify(delayGateway, never()).refund(any());
|
}
|
|
/** 支付即核销的到店消费不走延迟入账，钱从来不在延迟户，也就没有回退这回事。 */
|
@Test
|
void aNonDelayedPaymentNeedsNoRevert() {
|
String orderNo = createOrder("STORE_CONSUME", 100L);
|
insertPaidPayment(orderNo, 100L, null);
|
markVerified(orderId(orderNo));
|
|
assertThat(confirmationService.revertForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_NOT_NEEDED);
|
verify(delayGateway, never()).refund(any());
|
}
|
|
/** 已经在回退中的资金不重复发请求：钱的位置未定，撤销核销要等它收敛。 */
|
@Test
|
void aRevertInFlightIsNotStartedAgain() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
insertPaidPayment(orderNo, 100L, "reverting");
|
markVerified(orderId(orderNo));
|
|
assertThat(confirmationService.revertForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_IN_FLIGHT);
|
verify(delayGateway, never()).refund(any());
|
}
|
|
/** 没有原确认的定位键就撤销不了确认：保持原状交人工，不能假装钱已经退回延迟户。 */
|
@Test
|
void aConfirmedPaymentWithoutTheConfirmationReferenceNeedsAHuman() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "confirmed");
|
markVerified(orderId(orderNo));
|
|
assertThat(confirmationService.revertForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.REVERT_UNKNOWN);
|
verify(delayGateway, never()).refund(any());
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("confirmed");
|
}
|
|
/**
|
* 放款前必须复查订单仍是「已核销」：撤销核销会把订单翻回待核销，钱必须留在延迟户。
|
*
|
* <p>没有这道复查，补偿任务（或在途的确认请求）会在撤销之后把钱打给商户，而订单已经回到待核销。
|
*/
|
@Test
|
void aConfirmationIsRefusedOnceTheOrderIsNoLongerVerified() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "pending");
|
jdbc.update("update benefit_order set order_status = 1, verify_status = 0 where id = ?", orderId(orderNo));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.NOT_VERIFIED);
|
verify(delayGateway, never()).confirm(any());
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("pending");
|
}
|
|
// ------------------------------------------------------------------------------------------
|
// helpers
|
// ------------------------------------------------------------------------------------------
|
|
private HuifuDelayAccountGateway.HuifuDelayConfirmation succeeded(String confirmedYuan) {
|
return new HuifuDelayAccountGateway.HuifuDelayConfirmation(
|
HuifuDelayAccountGateway.HuifuDelayConfirmation.Outcome.SUCCEEDED,
|
"00000000", "交易成功", "0.00", confirmedYuan, "HF-" + System.nanoTime());
|
}
|
|
private HuifuDelayAccountGateway.HuifuDelayRevert revertSucceeded() {
|
return new HuifuDelayAccountGateway.HuifuDelayRevert(
|
HuifuDelayAccountGateway.HuifuDelayRevert.Outcome.SUCCEEDED,
|
"00000000", "交易成功", "HF-R-" + System.nanoTime());
|
}
|
|
/** 资金确认与资金回退都要求订单处于「已核销」。 */
|
private void markVerified(long orderId) {
|
jdbc.update("update benefit_order set order_status = 1, verify_status = 1 where id = ?", orderId);
|
}
|
|
/**
|
* 造一笔「延迟入账 + 资金已确认给商户」的订单，返回支付流水号。
|
*
|
* <p>确认走真实服务而不是直接改字段：撤销时用来定位原确认的请求号与请求日期，正是它写下的。
|
*/
|
private String confirmedDelayOrder(long amountInCent) {
|
String orderNo = createOrder("GROUP_BUY", amountInCent);
|
String paymentNo = insertPaidPayment(orderNo, amountInCent, "pending");
|
long orderId = orderId(orderNo);
|
markVerified(orderId);
|
when(delayGateway.confirm(any())).thenReturn(succeeded(BigDecimal.valueOf(amountInCent, 2).toPlainString()));
|
confirmationService.confirmForOrder(orderId);
|
return paymentNo;
|
}
|
|
private long orderIdOfPayment(String paymentNo) {
|
return jdbc.queryForObject("select order_id from payment_transaction where payment_no = ?",
|
Long.class, paymentNo);
|
}
|
|
/**
|
* 通道说「已无未确认金额」表示这笔延迟交易此前已经确认过（重新确认不会重复分账）。
|
* 必须按成功处理：否则补偿任务会一直认为没确认，每隔几分钟无意义地打一次通道。
|
*/
|
@Test
|
void nothingLeftToConfirmCountsAsAlreadyConfirmed() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "pending");
|
markVerified(orderId(orderNo));
|
when(delayGateway.confirm(any())).thenReturn(new HuifuDelayAccountGateway.HuifuDelayConfirmation(
|
HuifuDelayAccountGateway.HuifuDelayConfirmation.Outcome.SUCCEEDED,
|
"23000003", "已无未确认金额", "", "", ""));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.CONFIRMED);
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("confirmed");
|
}
|
|
/**
|
* 认领之后进程就没了（部署、崩溃）会留下 {@code confirming} 的孤儿：补偿任务此前只挑得到它、
|
* 从不重发，这笔钱就永远冻在延迟户。隔天必须能重新确认一次。
|
*/
|
@Test
|
void aConfirmationAbandonedByACrashIsRetriedTheNextDay() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "confirming");
|
long orderId = orderId(orderNo);
|
markVerified(orderId);
|
jdbc.update("update payment_transaction set funds_confirm_request_date = ? where payment_no = ?",
|
LocalDate.now().minusDays(1).format(DateTimeFormatter.BASIC_ISO_DATE), paymentNo);
|
when(delayGateway.confirm(any())).thenReturn(succeeded("1.00"));
|
|
assertThat(confirmationService.confirmForOrder(orderId)).isEqualTo(
|
PaymentFundConfirmationService.CONFIRMED);
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction"
|
+ " where payment_no = ?", String.class, paymentNo)).isEqualTo("confirmed");
|
}
|
|
/** 今天认领的确认不重发：它可能还在通道里处理。 */
|
@Test
|
void aConfirmationClaimedTodayIsNotSentAgain() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "confirming");
|
markVerified(orderId(orderNo));
|
jdbc.update("update payment_transaction set funds_confirm_request_date = ? where payment_no = ?",
|
LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE), paymentNo);
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.PROCESSING);
|
verify(delayGateway, never()).confirm(any());
|
}
|
|
/**
|
* 当天认领出来的「确认中」靠**确认查询**收敛，而不是整整等一天。
|
*
|
* <p>认领规则不允许当天重发确认（避免重复分账），于是同一天的确认中在旧实现里没人再看——而确认查询
|
* 接口（{@code delaytrans.confirmquery}）从写下那天起就是死代码。这里把它接上。
|
*/
|
@Test
|
void aConfirmationClaimedTodayConvergesThroughTheConfirmationQuery() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "confirming");
|
markVerified(orderId(orderNo));
|
jdbc.update("""
|
update payment_transaction
|
set funds_confirm_request_date = ?, funds_confirm_no = ?
|
where payment_no = ?
|
""", LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE), "DC-CLAIMED-" + paymentNo, paymentNo);
|
when(delayGateway.queryConfirm(any(), any())).thenReturn(succeeded("1.00"));
|
|
assertThat(confirmationService.confirmForOrder(orderId(orderNo))).isEqualTo(
|
PaymentFundConfirmationService.CONFIRMED);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction where payment_no = ?",
|
String.class, paymentNo)).isEqualTo("confirmed");
|
verify(delayGateway, never()).confirm(any());
|
}
|
|
/**
|
* 撤销核销的回退停在 {@code reverting} 时也要有人再看：回退没有查询接口，补偿任务原先只扫
|
* 「待确认／确认中」，这类记录会永久卡住撤销核销。幂等的重发就是它的查询对等物。
|
*/
|
@Test
|
void anInFlightRevertConvergesThroughTheRetryTask() {
|
String orderNo = createOrder("GROUP_BUY", 100L);
|
String paymentNo = insertPaidPayment(orderNo, 100L, "reverting");
|
long orderId = orderId(orderNo);
|
markVerified(orderId);
|
jdbc.update("""
|
update payment_transaction
|
set funds_confirm_no = ?, funds_confirm_request_date = ?, funds_revert_no = ?,
|
funds_revert_request_date = ?, funds_confirmed_amount = 100
|
where payment_no = ?
|
""", "DC-ORIGINAL-" + paymentNo, LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE),
|
"DR-INFLIGHT-" + paymentNo, LocalDate.now().format(DateTimeFormatter.BASIC_ISO_DATE), paymentNo);
|
// 补偿任务按订单号从小到大取一批，而测试库共享且不清理：先把别人的相关行移出扫描条件。
|
jdbc.update("""
|
update benefit_order set refund_status = 1
|
where id <> ? and deleted = 0 and order_status = 1 and verify_status = 1 and refund_status = 0
|
and exists (select 1 from payment_transaction p
|
where p.order_id = benefit_order.id and p.status = 'SUCCEEDED'
|
and p.funds_confirmation_status in ('pending', 'confirming', 'reverting'))
|
""", orderId);
|
when(delayGateway.refund(any())).thenReturn(new HuifuDelayAccountGateway.HuifuDelayRevert(
|
HuifuDelayAccountGateway.HuifuDelayRevert.Outcome.SUCCEEDED, "00000000", "交易成功", "HF-REVERT-RETRY"));
|
|
assertThat(confirmationRetry.retry(50)).isEqualTo(1);
|
|
assertThat(jdbc.queryForObject("select funds_confirmation_status from payment_transaction where payment_no = ?",
|
String.class, paymentNo))
|
.as("回退成功了，钱重新回到延迟户（pending）：撤销核销不再被永久卡住")
|
.isEqualTo("pending");
|
}
|
|
/** 通道还在处理：状态保持 pending，供确认补偿任务下一轮再试。 */
|
private HuifuDelayAccountGateway.HuifuDelayConfirmation processing() {
|
return new HuifuDelayAccountGateway.HuifuDelayConfirmation(
|
HuifuDelayAccountGateway.HuifuDelayConfirmation.Outcome.PROCESSING,
|
"00000100", "交易处理中", "1.00", "0.00", "");
|
}
|
|
private HuifuDelayAccountGateway.HuifuDelayConfirmation failed(String code, String message) { return new HuifuDelayAccountGateway.HuifuDelayConfirmation(
|
HuifuDelayAccountGateway.HuifuDelayConfirmation.Outcome.FAILED,
|
code, message, "", "", "");
|
}
|
|
private String createOrder(String orderType, long amountInCent) {
|
Map<String, Object> created = orderPortalService.create(talentId,
|
new AppOrderCreateRequest(merchantId, productId, null), "delay-fund-" + System.nanoTime());
|
String orderNo = String.valueOf(created.get("orderNo"));
|
jdbc.update("update benefit_order set order_type = ?, verify_status = 0 where order_no = ?", orderType, orderNo);
|
return orderNo;
|
}
|
|
private String insertPaidPayment(String orderNo, long amountInCent, String fundsStatus) {
|
return insertPayment(orderNo, amountInCent, "SUCCEEDED", fundsStatus);
|
}
|
|
private String insertPayment(String orderNo, long amountInCent, String status, String fundsStatus) {
|
String paymentNo = "P-DELAY-" + System.nanoTime();
|
Long orderId = orderId(orderNo);
|
jdbc.update("""
|
insert into payment_transaction(payment_no, provider, order_id, order_no, talent_id, merchant_id,
|
provider_huifu_id, amount, status, idempotency_key, attempt_no,
|
paid_at, funds_confirmation_status)
|
values (?, 'HUIFU', ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
|
""", paymentNo, orderId, orderNo, talentId, merchantId, HUIFU_ID, amountInCent, status,
|
"delay-payment-" + paymentNo, LocalDateTime.now(), fundsStatus);
|
return paymentNo;
|
}
|
|
private long orderId(String orderNo) {
|
return jdbc.queryForObject("select id from benefit_order where order_no = ?", Long.class, orderNo);
|
}
|
}
|
