fix(pay): 优化转账结果通知与渠道错误处理

YunaiV
1 parent 5d67f1fe
Showing 3 changed files with 346 additions and 5 deletions
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/enums/ErrorCodeConstants.java
yudao-module-pay/src/main/java/cn/iocoder/yudao/module/pay/service/transfer/PayTransferServiceImpl.java
yudao-module-pay/src/test/java/cn/iocoder/yudao/module/pay/service/transfer/PayTransferServiceTest.java
@@ -71,6 +71,7 @@ public interface ErrorCodeConstants {
     ErrorCode PAY_TRANSFER_CREATE_FAIL_STATUS_NOT_CLOSED = new ErrorCode(1_007_009_004, "转账发起失败，原因：已经存在相同的转账单，且状态不是已关闭");
     ErrorCode PAY_TRANSFER_NOTIFY_FAIL_STATUS_IS_NOT_WAITING = new ErrorCode(1_007_009_006, "通知转账结果失败，原因：转账单不处于待转账");
     ErrorCode PAY_TRANSFER_NOTIFY_FAIL_STATUS_NOT_WAITING_OR_PROCESSING = new ErrorCode(1_007_009_007, "通知转账结果失败，原因：转账单不处于待转账或转账中");
+    ErrorCode PAY_TRANSFER_SUBMIT_CHANNEL_ERROR = new ErrorCode(1_007_009_008, "发起转账报错，错误码：{}，错误提示：{}");
     // ========== 示例订单 1-007-900-000 ==========
     ErrorCode DEMO_ORDER_NOT_FOUND = new ErrorCode(1_007_900_000, "示例订单不存在");
@@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
 import cn.hutool.extra.spring.SpringUtil;
+import cn.iocoder.yudao.framework.common.exception.ServiceException;
 import cn.iocoder.yudao.framework.common.pojo.PageResult;
 import cn.iocoder.yudao.framework.common.util.json.JsonUtils;
 import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
@@ -35,8 +36,6 @@ import java.util.List;
 import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
 import static cn.iocoder.yudao.module.pay.enums.ErrorCodeConstants.*;
-// TODO @jason：等彻底实现完，单测写写；
-
 /**
  * 转账 Service 实现类
  *
@@ -96,19 +95,61 @@ public class PayTransferServiceImpl implements PayTransferService {
                     .setOutTransferNo(transfer.getNo())
                     .setNotifyUrl(genChannelTransferNotifyUrl(channel));
             unifiedTransferResp = client.unifiedTransfer(transferUnifiedReq);
-            // 4. 通知转账结果
-            getSelf().notifyTransfer(channel, unifiedTransferResp);
         } catch (Throwable e) {
             // 注意这里仅打印异常，不进行抛出。
             // 原因是：虽然调用支付渠道进行转账发生异常（网络请求超时），实际转账成功。这个结果，后续转账轮询可以拿到。
             //       或者，使用相同 no 再次发起转账请求
             log.error("[createTransfer][转账编号({}) requestDTO({}) 发生异常]", transfer.getId(), reqDTO, e);
         }
+
+        // 4. 通知转账结果
+        if (unifiedTransferResp != null) {
+            PayTransferDO latestTransfer = null;
+            try {
+                getSelf().notifyTransfer(channel, unifiedTransferResp);
+            } catch (ServiceException ex) {
+                // 由于转账回调、转账轮询可能同时更新转账单，导致存在并发更新问题，此时以最新的转账状态为准
+                latestTransfer = validateTransferNotifyConcurrent(transfer.getId(), ex);
+                log.warn("[createTransfer][transfer({}) channel({}) 转账结果({}) 通知时发生并发更新，最新状态为({})]",
+                        transfer.getId(), channel.getId(), unifiedTransferResp, latestTransfer.getStatus(), ex);
+            }
+            // 如有渠道错误码，则抛出业务异常，提示用户
+            // 特殊：如果已被并发更新为成功，则以最新状态为准，避免旧的关闭结果误报
+            if (StrUtil.isNotEmpty(unifiedTransferResp.getChannelErrorCode())
+                    && (latestTransfer == null || PayTransferStatusEnum.isClosed(latestTransfer.getStatus()))) {
+                throw exception(PAY_TRANSFER_SUBMIT_CHANNEL_ERROR, unifiedTransferResp.getChannelErrorCode(),
+                        unifiedTransferResp.getChannelErrorMsg());
+            }
+        }
         return new PayTransferCreateRespDTO().setId(transfer.getId())
                 .setChannelPackageInfo(unifiedTransferResp != null ? unifiedTransferResp.getChannelPackageInfo() : null);
     }
     /**
+     * 校验转账结果通知时的并发更新
+     *
+     * 只有状态竞争导致的通知失败，并且转账单已被并发更新为成功或关闭时，才返回最新的转账单；
+     * 否则，直接抛出原异常，避免掩盖真实的通知失败
+     *
+     * @param id 转账单编号
+     * @param ex 通知转账结果时的业务异常
+     * @return 最新的转账单
+     */
+    private PayTransferDO validateTransferNotifyConcurrent(Long id, ServiceException ex) {
+        // 1. 校验是否为状态竞争
+        if (ObjectUtil.notEqual(ex.getCode(), PAY_TRANSFER_NOTIFY_FAIL_STATUS_IS_NOT_WAITING.getCode())
+                && ObjectUtil.notEqual(ex.getCode(), PAY_TRANSFER_NOTIFY_FAIL_STATUS_NOT_WAITING_OR_PROCESSING.getCode())) {
+            throw ex;
+        }
+        // 2. 校验最新状态为成功或关闭
+        PayTransferDO latestTransfer = transferMapper.selectById(id);
+        if (latestTransfer == null || !PayTransferStatusEnum.isSuccessOrClosed(latestTransfer.getStatus())) {
+            throw ex;
+        }
+        return latestTransfer;
+    }
+
+    /**
      * 根据支付渠道的编码，生成支付渠道的回调地址
      *
      * @param channel 支付渠道
 package cn.iocoder.yudao.module.pay.service.transfer;
+import cn.hutool.extra.spring.SpringUtil;
 import cn.iocoder.yudao.framework.test.core.ut.BaseDbAndRedisUnitTest;
+import cn.iocoder.yudao.module.pay.api.transfer.dto.PayTransferCreateReqDTO;
+import cn.iocoder.yudao.module.pay.api.transfer.dto.PayTransferCreateRespDTO;
+import cn.iocoder.yudao.module.pay.dal.dataobject.app.PayAppDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.channel.PayChannelDO;
 import cn.iocoder.yudao.module.pay.dal.dataobject.transfer.PayTransferDO;
 import cn.iocoder.yudao.module.pay.dal.mysql.transfer.PayTransferMapper;
 import cn.iocoder.yudao.module.pay.dal.redis.no.PayNoRedisDAO;
+import cn.iocoder.yudao.module.pay.enums.PayChannelEnum;
+import cn.iocoder.yudao.module.pay.enums.notify.PayNotifyTypeEnum;
 import cn.iocoder.yudao.module.pay.enums.transfer.PayTransferStatusEnum;
 import cn.iocoder.yudao.module.pay.framework.pay.config.PayProperties;
+import cn.iocoder.yudao.module.pay.framework.pay.core.client.PayClient;
 import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.transfer.PayTransferRespDTO;
+import cn.iocoder.yudao.module.pay.framework.pay.core.client.dto.transfer.PayTransferUnifiedReqDTO;
 import cn.iocoder.yudao.module.pay.service.app.PayAppService;
 import cn.iocoder.yudao.module.pay.service.channel.PayChannelService;
 import cn.iocoder.yudao.module.pay.service.notify.PayNotifyService;
 import jakarta.annotation.Resource;
 import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
 import org.springframework.context.annotation.Import;
 import org.springframework.test.context.bean.override.mockito.MockitoBean;
+import java.time.LocalDateTime;
+
+import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertServiceException;
 import static cn.iocoder.yudao.framework.test.core.util.RandomUtils.randomPojo;
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static cn.iocoder.yudao.module.pay.enums.ErrorCodeConstants.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.*;
 /**
  * {@link PayTransferServiceImpl} 的单元测试类
@@ -88,4 +105,286 @@ public class PayTransferServiceTest extends BaseDbAndRedisUnitTest {
         assertEquals("package-info-110", dbTransfer.getChannelPackageInfo());
     }
+    @Test // 调用 unifiedTransfer 接口，发生异常（例如说：网络超时）
+    public void testCreateTransfer_unifiedTransferException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenThrow(new RuntimeException("模拟网络超时"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：未知结果不抛出异常，保留 WAITING 等待轮询
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertNotNull(dbTransfer);
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(respDTO.getChannelPackageInfo());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口，返回 null
+    public void testCreateTransfer_nullResponse() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenReturn(null);
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(respDTO.getChannelPackageInfo());
+    }
+
+    @Test // 调用 unifiedTransfer 接口，返回存在渠道错误
+    public void testCreateTransfer_channelError() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                    unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用，并断言异常
+        assertServiceException(() -> transferService.createTransfer(reqDTO),
+                PAY_TRANSFER_SUBMIT_CHANNEL_ERROR, "PAYEE_NOT_EXIST", "收款账号不存在");
+        // 断言：关闭状态已落库
+        PayTransferDO dbTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, reqDTO.getMerchantTransferId());
+        assertNotNull(dbTransfer);
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), dbTransfer.getStatus());
+        assertEquals("PAYEE_NOT_EXIST", dbTransfer.getChannelErrorCode());
+        assertEquals("收款账号不存在", dbTransfer.getChannelErrorMsg());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.TRANSFER.getType()), eq(dbTransfer.getId()));
+    }
+
+    @Test // 调用 unifiedTransfer 接口，返回关闭，但不存在渠道错误
+    public void testCreateTransfer_closedWithoutChannelError() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf(null, null, unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), dbTransfer.getStatus());
+    }
+
+    @Test // 调用 unifiedTransfer 接口，返回成功
+    public void testCreateTransfer_success() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.successOf("CHANNEL_T001", LocalDateTime.now(),
+                    unifiedReqDTO.getOutTransferNo(), "success");
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.SUCCESS.getStatus(), dbTransfer.getStatus());
+        assertEquals("CHANNEL_T001", dbTransfer.getChannelTransferNo());
+        verify(notifyService).createPayNotifyTask(eq(PayNotifyTypeEnum.TRANSFER.getType()), eq(dbTransfer.getId()));
+    }
+
+    @Test // 调用 unifiedTransfer 接口，返回转账中
+    public void testCreateTransfer_processing() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            PayTransferRespDTO resp = PayTransferRespDTO.processingOf("CHANNEL_T001",
+                    unifiedReqDTO.getOutTransferNo(), "processing");
+            resp.setChannelPackageInfo("package-info-001");
+            return resp;
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        assertEquals("package-info-001", respDTO.getChannelPackageInfo());
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.PROCESSING.getStatus(), dbTransfer.getStatus());
+        assertEquals("package-info-001", dbTransfer.getChannelPackageInfo());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回成功，但通知转账结果时找不到转账单
+    public void testCreateTransfer_notifyTransferNotFound() {
+        // mock 方法（client）：返回不存在的转账单号，使 notifyTransfer 抛出异常
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenReturn(PayTransferRespDTO.successOf("CHANNEL_T001",
+                LocalDateTime.now(), "NOT_EXISTS", "success"));
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用，并断言异常：非并发更新的通知异常，不能被吞掉
+        assertServiceException(() -> transferService.createTransfer(reqDTO), PAY_TRANSFER_NOT_FOUND);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, reqDTO.getMerchantTransferId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回存在渠道错误，但创建转账通知任务时发生异常
+    public void testCreateTransfer_channelErrorAndNotifyTaskException() {
+        // mock 方法（client）
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                    unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        // mock 方法（notify）
+        RuntimeException notifyTaskException = new RuntimeException("模拟创建通知任务异常");
+        doThrow(notifyTaskException).when(notifyService).createPayNotifyTask(any(), any());
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用，并断言异常：抛出真实的通知异常，而不是渠道错误
+        RuntimeException ex = assertThrows(RuntimeException.class, () -> transferService.createTransfer(reqDTO));
+        assertSame(notifyTaskException, ex);
+        // 断言：关闭状态随通知事务回滚
+        PayTransferDO dbTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, reqDTO.getMerchantTransferId());
+        assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getChannelErrorCode());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回存在渠道错误，但转账单已被并发更新为成功
+    public void testCreateTransfer_channelErrorWhenConcurrentSuccess() {
+        // mock 方法（client）：返回前，转账回调已经将转账单更新为成功
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            updateTransferStatus(unifiedReqDTO.getOutTransferNo(), PayTransferStatusEnum.SUCCESS.getStatus());
+            return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                    unifiedReqDTO.getOutTransferNo(), "closed");
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：以最新的成功状态为准，不误报渠道错误
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.SUCCESS.getStatus(), dbTransfer.getStatus());
+        assertNull(dbTransfer.getChannelErrorCode());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回成功，但转账单已被并发更新为关闭
+    public void testCreateTransfer_successWhenConcurrentClosed() {
+        // mock 方法（client）：返回前，转账轮询已经将转账单更新为关闭
+        PayClient<?> client = mockPayClient();
+        when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+            PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+            updateTransferStatus(unifiedReqDTO.getOutTransferNo(), PayTransferStatusEnum.CLOSED.getStatus());
+            return PayTransferRespDTO.successOf("CHANNEL_T001", LocalDateTime.now(),
+                    unifiedReqDTO.getOutTransferNo(), "success");
+        });
+        // 准备参数
+        PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+        // 调用：以最新的关闭状态为准
+        PayTransferCreateRespDTO respDTO = transferService.createTransfer(reqDTO);
+        // 断言
+        PayTransferDO dbTransfer = transferMapper.selectById(respDTO.getId());
+        assertEquals(PayTransferStatusEnum.CLOSED.getStatus(), dbTransfer.getStatus());
+        verify(notifyService, never()).createPayNotifyTask(any(), any());
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回存在渠道错误，通知时发生状态竞争，且转账单已被并发更新为关闭
+    public void testCreateTransfer_channelErrorWhenConcurrentClosed() {
+        PayTransferServiceImpl transferServiceImpl = mock(PayTransferServiceImpl.class);
+        try (MockedStatic<SpringUtil> springUtilMockedStatic = mockStatic(SpringUtil.class)) {
+            springUtilMockedStatic.when(() -> SpringUtil.getBean(eq(PayTransferServiceImpl.class)))
+                    .thenReturn(transferServiceImpl);
+            doThrow(exception(PAY_TRANSFER_NOTIFY_FAIL_STATUS_NOT_WAITING_OR_PROCESSING))
+                    .when(transferServiceImpl).notifyTransfer(any(PayChannelDO.class), any());
+            // mock 方法（client）：返回前，转账轮询已经将转账单更新为关闭
+            PayClient<?> client = mockPayClient();
+            when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+                PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+                updateTransferStatus(unifiedReqDTO.getOutTransferNo(), PayTransferStatusEnum.CLOSED.getStatus());
+                return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                        unifiedReqDTO.getOutTransferNo(), "closed");
+            });
+            // 准备参数
+            PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+            // 调用，并断言异常：已确认关闭，提示渠道错误
+            assertServiceException(() -> transferService.createTransfer(reqDTO),
+                    PAY_TRANSFER_SUBMIT_CHANNEL_ERROR, "PAYEE_NOT_EXIST", "收款账号不存在");
+        }
+    }
+
+    @Test // 调用 unifiedTransfer 接口返回存在渠道错误，通知时发生状态竞争，但转账单仍是待转账
+    public void testCreateTransfer_channelErrorWhenConcurrentWaiting() {
+        PayTransferServiceImpl transferServiceImpl = mock(PayTransferServiceImpl.class);
+        try (MockedStatic<SpringUtil> springUtilMockedStatic = mockStatic(SpringUtil.class)) {
+            springUtilMockedStatic.when(() -> SpringUtil.getBean(eq(PayTransferServiceImpl.class)))
+                    .thenReturn(transferServiceImpl);
+            doThrow(exception(PAY_TRANSFER_NOTIFY_FAIL_STATUS_NOT_WAITING_OR_PROCESSING))
+                    .when(transferServiceImpl).notifyTransfer(any(PayChannelDO.class), any());
+            // mock 方法（client）
+            PayClient<?> client = mockPayClient();
+            when(client.unifiedTransfer(any())).thenAnswer(invocation -> {
+                PayTransferUnifiedReqDTO unifiedReqDTO = invocation.getArgument(0);
+                return PayTransferRespDTO.closedOf("PAYEE_NOT_EXIST", "收款账号不存在",
+                        unifiedReqDTO.getOutTransferNo(), "closed");
+            });
+            // 准备参数
+            PayTransferCreateReqDTO reqDTO = buildTransferCreateReqDTO();
+
+            // 调用，并断言异常：无法确认最新状态，抛出原通知异常
+            assertServiceException(() -> transferService.createTransfer(reqDTO),
+                    PAY_TRANSFER_NOTIFY_FAIL_STATUS_NOT_WAITING_OR_PROCESSING);
+            // 断言
+            PayTransferDO dbTransfer = transferMapper.selectByAppIdAndMerchantOrderId(1L, reqDTO.getMerchantTransferId());
+            assertEquals(PayTransferStatusEnum.WAITING.getStatus(), dbTransfer.getStatus());
+        }
+    }
+
+    private PayClient<?> mockPayClient() {
+        // mock 方法（app）
+        PayAppDO app = randomPojo(PayAppDO.class, o -> o.setId(1L).setTransferNotifyUrl("http://127.0.0.1/transfer"));
+        when(appService.validPayApp(eq("demo"))).thenReturn(app);
+        // mock 方法（channel）
+        PayChannelDO channel = randomPojo(PayChannelDO.class, o -> o.setId(10L).setAppId(1L)
+                .setCode(PayChannelEnum.ALIPAY_PC.getCode()));
+        when(channelService.validPayChannel(eq(1L), eq(PayChannelEnum.ALIPAY_PC.getCode()))).thenReturn(channel);
+        when(payProperties.getTransferNotifyUrl()).thenReturn("http://127.0.0.1");
+        // mock 方法（client）
+        PayClient<?> client = mock(PayClient.class);
+        when(channelService.getPayClient(eq(10L))).thenReturn(client);
+        return client;
+    }
+
+    private void updateTransferStatus(String no, Integer status) {
+        PayTransferDO transfer = transferMapper.selectByAppIdAndNo(1L, no);
+        transferMapper.updateById(new PayTransferDO().setId(transfer.getId()).setStatus(status));
+    }
+
+    private static PayTransferCreateReqDTO buildTransferCreateReqDTO() {
+        return new PayTransferCreateReqDTO().setAppKey("demo").setChannelCode(PayChannelEnum.ALIPAY_PC.getCode())
+                .setUserIp("127.0.0.1").setUserId(1L).setUserType(1)
+                .setMerchantTransferId("1001").setSubject("佣金提现").setPrice(100)
+                .setUserAccount("test@example.com").setUserName("芋艿");
+    }
+
 }