update

liujie

2026-08-04 e9e42b621afdf6ac94f5327ee843b32b10a401b4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
package com.tourguide.modules.finance.service;
 
import com.tourguide.common.exception.BusinessException;
import com.tourguide.common.huifu.biz.DouGongBasicDataBiz;
import com.tourguide.modules.finance.dto.GuideElectronicLedgerRequest;
import com.tourguide.modules.finance.dto.GuideElectronicLedgerResponse;
import com.tourguide.modules.finance.dto.GuideElectronicLedgerStatusResponse;
import com.tourguide.modules.finance.entity.GuideWithdrawalAccount;
import com.tourguide.modules.finance.mapper.GuideWithdrawalAccountMapper;
import com.tourguide.modules.user.entity.GuideUser;
import com.tourguide.modules.user.service.GuideUserService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
 
import java.util.HashMap;
import java.util.Map;
 
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
class GuideElectronicLedgerServiceTest {
    private GuideWithdrawalAccountMapper accountMapper;
    private GuideUserService guideUserService;
    private DouGongBasicDataBiz douGongBasicDataBiz;
    private GuideElectronicLedgerService service;
 
    @BeforeEach
    void setUp() {
        accountMapper = mock(GuideWithdrawalAccountMapper.class);
        guideUserService = mock(GuideUserService.class);
        douGongBasicDataBiz = mock(DouGongBasicDataBiz.class);
        service = new GuideElectronicLedgerService(accountMapper, guideUserService, douGongBasicDataBiz);
    }
 
    @Test
    void createShouldPersistSuccessfulDouGongOnboarding() throws Exception {
        GuideUser guide = new GuideUser();
        guide.setId(8L);
        guide.setMobile("13800138000");
        when(guideUserService.findEnabledById(8L)).thenReturn(guide);
        when(accountMapper.selectOne(any())).thenReturn(null);
        doAnswer(invocation -> {
            GuideWithdrawalAccount account = invocation.getArgument(0);
            account.setId(10);
            return 1;
        }).when(accountMapper).insert(any(GuideWithdrawalAccount.class));
        when(douGongBasicDataBiz.userBasicDataIndv(any())).thenReturn(success("huifu_id", "HF100"));
        when(douGongBasicDataBiz.userBusinessOpen(any())).thenReturn(success("token_no", "TOKEN100"));
 
        GuideElectronicLedgerResponse response = service.create(8L, request());
 
        assertThat(response.getHuifuId()).isEqualTo("HF100");
        assertThat(response.getApplicationStatus()).isEqualTo("submitted");
        verify(accountMapper).insert(any(GuideWithdrawalAccount.class));
        verify(accountMapper, org.mockito.Mockito.atLeastOnce()).updateById(any(GuideWithdrawalAccount.class));
    }
 
    @Test
    void statusShouldRequireOnboardingWhenAccountDoesNotExist() {
        GuideUser guide = new GuideUser();
        guide.setId(8L);
        when(guideUserService.findEnabledById(8L)).thenReturn(guide);
        when(accountMapper.selectOne(any())).thenReturn(null);
 
        GuideElectronicLedgerStatusResponse response = service.status(8L);
 
        assertThat(response.isExists()).isFalse();
        assertThat(response.isRequiresOnboarding()).isTrue();
    }
 
    @Test
    void createShouldPersistFailureReasonWhenDouGongRejectsRequest() throws Exception {
        GuideUser guide = new GuideUser();
        guide.setId(8L);
        when(guideUserService.findEnabledById(8L)).thenReturn(guide);
        when(accountMapper.selectOne(any())).thenReturn(null);
        doAnswer(invocation -> {
            GuideWithdrawalAccount account = invocation.getArgument(0);
            account.setId(10);
            return 1;
        }).when(accountMapper).insert(any(GuideWithdrawalAccount.class));
        Map<String, Object> rejected = new HashMap<String, Object>();
        rejected.put("resp_code", "10000001");
        rejected.put("resp_desc", "银行卡信息不正确");
        when(douGongBasicDataBiz.userBasicDataIndv(any())).thenReturn(rejected);
 
        assertThatThrownBy(() -> service.create(8L, request()))
                .isInstanceOf(BusinessException.class)
                .hasMessage("银行卡信息不正确");
        verify(accountMapper, org.mockito.Mockito.atLeastOnce()).updateById(any(GuideWithdrawalAccount.class));
    }
 
    private GuideElectronicLedgerRequest request() {
        GuideElectronicLedgerRequest request = new GuideElectronicLedgerRequest();
        request.setCertificateName("张三");
        request.setCertificateCode("510000199001010000");
        request.setCertificateExpireTime("2020-01-01，长期");
        request.setBankName("中国银行");
        request.setBankCardCode("6217000000000000000");
        request.setOpenAccountName("张三");
        request.setPhone("13800138000");
        request.setIdCardFrontPicture("front-media-id");
        request.setIdCardReversePicture("back-media-id");
        request.setBankCardProvinceCode("320000");
        request.setBankCardCityCode("320100");
        return request;
    }
 
    private Map<String, Object> success(String key, String value) {
        Map<String, Object> result = new HashMap<String, Object>();
        result.put("resp_code", "00000000");
        result.put(key, value);
        return result;
    }
}