zjk
2026-09-29 54dcf0a82e7490fa58b1c056d5c0b9cb739c2931
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
package com.tcm.training.admin.app.settings.service;
 
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import cn.dev33.satoken.stp.SaTokenInfo;
import com.tcm.training.admin.app.auth.service.AppAuthSessionService;
import com.tcm.training.admin.app.auth.vo.AppLoginResponse;
import com.tcm.training.admin.app.auth.service.AppSmsCodeService;
import com.tcm.training.admin.app.auth.service.AppWechatAuthClient;
import com.tcm.training.admin.app.settings.dto.AppSettingsPhoneBindRequest;
import com.tcm.training.admin.app.settings.mapper.AppUserNotificationSettingMapper;
import com.tcm.training.admin.app.share.service.AppShareService;
import com.tcm.training.admin.member.entity.AppUser;
import com.tcm.training.admin.member.mapper.UserMapper;
import com.tcm.training.admin.upload.ObsUploadService;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
/**
 * APP 设置服务手机号绑定测试。
 */
@ExtendWith(MockitoExtension.class)
class AppSettingsServiceTest {
 
    @BeforeAll
    static void initLambdaCache() {
        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
        TableInfoHelper.initTableInfo(assistant, AppUser.class);
    }
 
    @Mock
    private AppAuthSessionService appAuthSessionService;
 
    @Mock
    private UserMapper userMapper;
 
    @Mock
    private AppSmsCodeService appSmsCodeService;
 
    @Mock
    private BCryptPasswordEncoder passwordEncoder;
 
    @Mock
    private AppWechatAuthClient appWechatAuthClient;
 
    @Mock
    private AppShareService appShareService;
 
    @Mock
    private AppUserNotificationSettingMapper appUserNotificationSettingMapper;
 
    @Mock
    private ObsUploadService obsUploadService;
 
    @Captor
    private ArgumentCaptor<AppUser> appUserCaptor;
 
    private AppSettingsService appSettingsService;
 
    /**
     * 每个用例前重新构造被测设置服务。
     */
    @BeforeEach
    void setUp() {
        appSettingsService = new AppSettingsService(
                appAuthSessionService,
                userMapper,
                appSmsCodeService,
                passwordEncoder,
                appWechatAuthClient,
                appShareService,
                appUserNotificationSettingMapper,
                obsUploadService
        );
    }
 
    /**
     * 微信登录后未绑定手机号的用户,可通过验证码首次绑定手机号。
     */
    @Test
    void bindPhoneShouldUpdateCurrentUserWhenPhoneMissing() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser currentUser = buildEnabledUser(null);
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(currentUser);
        when(userMapper.selectOne(any())).thenReturn(null);
        doNothing().when(appSmsCodeService).validatePhoneChangeCode("13800138000", "123456");
        when(appAuthSessionService.getTokenInfo()).thenReturn(buildToken("bind-token"));
 
        AppLoginResponse response = appSettingsService.bindPhone(request);
 
        verify(userMapper).updateById(appUserCaptor.capture());
        verify(appAuthSessionService).login(1L);
        assertEquals("13800138000", appUserCaptor.getValue().getPhone());
        assertEquals("13800138000", response.getUser().getPhone());
        assertEquals("bind-token", response.getToken());
    }
 
    /**
     * 已绑定手机号的用户不允许走首次绑定接口。
     */
    @Test
    void bindPhoneShouldRejectWhenCurrentUserAlreadyHasPhone() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(buildEnabledUser("13900139000"));
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> appSettingsService.bindPhone(request));
 
        assertEquals("当前账号已绑定手机号", exception.getMessage());
        verify(appSmsCodeService, never()).validatePhoneChangeCode(any(), any());
        verify(userMapper, never()).updateById(any());
    }
 
    /**
     * 微信临时账号绑定已注册但未绑定微信的手机号时,应合并到手机号账号。
     */
    @Test
    void bindPhoneShouldMergeWechatUserIntoExistingPhoneUser() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser currentUser = buildEnabledUser(null);
        currentUser.setWechatOpenid("wx-openid");
        currentUser.setNickname(null);
        currentUser.setWechatNickname("微信昵称");
        AppUser occupiedUser = buildEnabledUser("13800138000");
        occupiedUser.setId(2L);
        occupiedUser.setNickname(null);
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(currentUser);
        when(userMapper.selectOne(any())).thenReturn(occupiedUser);
        doNothing().when(appSmsCodeService).validatePhoneChangeCode("13800138000", "123456");
        when(appAuthSessionService.getTokenInfo()).thenReturn(buildToken("merged-token"));
 
        AppLoginResponse response = appSettingsService.bindPhone(request);
 
        verify(userMapper, times(2)).updateById(appUserCaptor.capture());
        AppUser mergedUser = appUserCaptor.getAllValues().get(0);
        AppUser deletedTemporaryUser = appUserCaptor.getAllValues().get(1);
        verify(appAuthSessionService).login(2L);
        assertEquals("wx-openid", mergedUser.getWechatOpenid());
        assertEquals("微信昵称", mergedUser.getNickname());
        assertEquals(Integer.valueOf(1), deletedTemporaryUser.getDeleted());
        assertEquals(Long.valueOf(2L), response.getUser().getId());
        assertEquals("merged-token", response.getToken());
    }
 
    /**
     * 微信临时账号绑定已绑定微信的手机号时,应直接覆盖目标账号微信票据。
     */
    @Test
    void bindPhoneShouldOverwriteWechatBindingWhenPhoneUserAlreadyBoundWechat() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser currentUser = buildEnabledUser(null);
        currentUser.setWechatOpenid("wx-openid");
        currentUser.setWechatNickname("新微信昵称");
        AppUser occupiedUser = buildEnabledUser("13800138000");
        occupiedUser.setId(2L);
        occupiedUser.setWechatOpenid("other-wx-openid");
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(currentUser);
        when(userMapper.selectOne(any())).thenReturn(occupiedUser);
        doNothing().when(appSmsCodeService).validatePhoneChangeCode("13800138000", "123456");
        when(appAuthSessionService.getTokenInfo()).thenReturn(buildToken("wechat-overwrite-token"));
 
        AppLoginResponse response = appSettingsService.bindPhone(request);
 
        verify(userMapper, times(2)).updateById(appUserCaptor.capture());
        AppUser mergedUser = appUserCaptor.getAllValues().get(0);
        AppUser deletedTemporaryUser = appUserCaptor.getAllValues().get(1);
        verify(appAuthSessionService).login(2L);
        assertEquals("wx-openid", mergedUser.getWechatOpenid());
        assertEquals("新微信昵称", mergedUser.getWechatNickname());
        assertEquals(Integer.valueOf(1), deletedTemporaryUser.getDeleted());
        assertEquals(Long.valueOf(2L), response.getUser().getId());
    }
 
    /**
     * 苹果临时账号绑定已注册但未绑定苹果的手机号时,应合并到手机号账号。
     */
    @Test
    void bindPhoneShouldMergeAppleUserIntoExistingPhoneUser() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser currentUser = buildEnabledUser(null);
        currentUser.setAppleIdentitySubject("apple-subject");
        currentUser.setAppleUserIdentifier("apple-user");
        AppUser occupiedUser = buildEnabledUser("13800138000");
        occupiedUser.setId(2L);
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(currentUser);
        when(userMapper.selectOne(any())).thenReturn(occupiedUser);
        doNothing().when(appSmsCodeService).validatePhoneChangeCode("13800138000", "123456");
        when(appAuthSessionService.getTokenInfo()).thenReturn(buildToken("apple-merged-token"));
 
        AppLoginResponse response = appSettingsService.bindPhone(request);
 
        verify(userMapper, times(2)).updateById(appUserCaptor.capture());
        AppUser mergedUser = appUserCaptor.getAllValues().get(0);
        verify(appAuthSessionService).login(2L);
        assertEquals("apple-subject", mergedUser.getAppleIdentitySubject());
        assertEquals("apple-user", mergedUser.getAppleUserIdentifier());
        assertEquals(Long.valueOf(2L), response.getUser().getId());
    }
 
    /**
     * 苹果临时账号绑定已绑定苹果的手机号时,应直接覆盖目标账号苹果票据。
     */
    @Test
    void bindPhoneShouldOverwriteAppleBindingWhenPhoneUserAlreadyBoundApple() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser currentUser = buildEnabledUser(null);
        currentUser.setAppleIdentitySubject("apple-subject");
        currentUser.setAppleUserIdentifier("apple-user");
        AppUser occupiedUser = buildEnabledUser("13800138000");
        occupiedUser.setId(2L);
        occupiedUser.setAppleIdentitySubject("other-apple-subject");
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(currentUser);
        when(userMapper.selectOne(any())).thenReturn(occupiedUser);
        doNothing().when(appSmsCodeService).validatePhoneChangeCode("13800138000", "123456");
        when(appAuthSessionService.getTokenInfo()).thenReturn(buildToken("apple-overwrite-token"));
 
        AppLoginResponse response = appSettingsService.bindPhone(request);
 
        verify(userMapper, times(2)).updateById(appUserCaptor.capture());
        AppUser mergedUser = appUserCaptor.getAllValues().get(0);
        AppUser deletedTemporaryUser = appUserCaptor.getAllValues().get(1);
        verify(appAuthSessionService).login(2L);
        assertEquals("apple-subject", mergedUser.getAppleIdentitySubject());
        assertEquals("apple-user", mergedUser.getAppleUserIdentifier());
        assertEquals(Integer.valueOf(1), deletedTemporaryUser.getDeleted());
        assertEquals(Long.valueOf(2L), response.getUser().getId());
    }
 
    /**
     * 非第三方临时账号绑定已注册手机号时仍按占用处理。
     */
    @Test
    void bindPhoneShouldRejectOccupiedPhoneWithoutThirdPartyBinding() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("123456");
        AppUser occupiedUser = buildEnabledUser("13800138000");
        occupiedUser.setId(2L);
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(buildEnabledUser(null));
        when(userMapper.selectOne(any())).thenReturn(occupiedUser);
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> appSettingsService.bindPhone(request));
 
        assertEquals("该手机号已注册", exception.getMessage());
        verify(appSmsCodeService, never()).validatePhoneChangeCode(any(), any());
        verify(userMapper, never()).updateById(any());
    }
 
    /**
     * 验证码错误时不应更新用户手机号。
     */
    @Test
    void bindPhoneShouldNotUpdateWhenSmsCodeInvalid() {
        AppSettingsPhoneBindRequest request = new AppSettingsPhoneBindRequest();
        request.setNewPhone("13800138000");
        request.setCode("000000");
 
        when(appAuthSessionService.requireLoginUserId()).thenReturn(1L);
        when(userMapper.selectById(1L)).thenReturn(buildEnabledUser(null));
        when(userMapper.selectOne(any())).thenReturn(null);
        org.mockito.Mockito.doThrow(new IllegalArgumentException("验证码错误"))
                .when(appSmsCodeService).validatePhoneChangeCode("13800138000", "000000");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> appSettingsService.bindPhone(request));
 
        assertEquals("验证码错误", exception.getMessage());
        verify(userMapper, never()).updateById(any());
    }
 
    /**
     * 构造测试登录态。
     */
    private SaTokenInfo buildToken(String tokenValue) {
        SaTokenInfo tokenInfo = new SaTokenInfo();
        tokenInfo.setTokenValue(tokenValue);
        tokenInfo.setTokenTimeout(7200L);
        return tokenInfo;
    }
 
    /**
     * 构造启用状态 APP 用户。
     */
    private AppUser buildEnabledUser(String phone) {
        AppUser user = new AppUser();
        user.setId(1L);
        user.setNickname("微信用户");
        user.setAvatar("avatar.png");
        user.setPhone(phone);
        user.setType(0);
        user.setStatus(1);
        user.setDeleted(0);
        return user;
    }
}