hejianhao
2026-08-28 16a57a8fc6868cea9171a1119698572407a2fc03
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
package com.tcm.training.admin.system.service;
 
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.tcm.training.admin.member.entity.AppUser;
import com.tcm.training.admin.member.mapper.UserMapper;
import com.tcm.training.admin.system.dto.UserFeedbackSubmitRequest;
import com.tcm.training.admin.system.entity.UserFeedback;
import com.tcm.training.admin.system.mapper.UserFeedbackMapper;
import com.tcm.training.admin.system.mapper.UserFeedbackQueryMapper;
import com.tcm.training.admin.system.vo.UserFeedbackListItemVO;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
 
import java.time.LocalDateTime;
import java.util.Collections;
 
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
@ExtendWith(MockitoExtension.class)
class UserFeedbackAppServiceTest {
 
    @Mock
    private UserFeedbackMapper userFeedbackMapper;
 
    @Mock
    private UserFeedbackQueryMapper userFeedbackQueryMapper;
 
    @Mock
    private UserMapper userMapper;
 
    @InjectMocks
    private UserFeedbackAppService userFeedbackAppService;
 
    @Captor
    private ArgumentCaptor<UserFeedback> userFeedbackCaptor;
 
    @Test
    void submitShouldPersistTrimmedFeedback() {
        AppUser user = new AppUser();
        user.setId(1L);
        when(userMapper.selectById(1L)).thenReturn(user);
        doAnswer(invocation -> {
            UserFeedback item = invocation.getArgument(0);
            item.setId(10L);
            return 1;
        }).when(userFeedbackMapper).insert(any(UserFeedback.class));
 
        UserFeedbackSubmitRequest request = new UserFeedbackSubmitRequest();
        request.setContent("  收不到验证码  ");
        request.setContact(" 13800138000 ");
 
        userFeedbackAppService.submit(1L, request);
 
        verify(userFeedbackMapper).insert(userFeedbackCaptor.capture());
        assertEquals(1L, userFeedbackCaptor.getValue().getAppUserId());
        assertEquals("收不到验证码", userFeedbackCaptor.getValue().getContent());
        assertEquals("13800138000", userFeedbackCaptor.getValue().getContact());
    }
 
    @Test
    void submitShouldAllowBlankContact() {
        AppUser user = new AppUser();
        user.setId(2L);
        when(userMapper.selectById(2L)).thenReturn(user);
 
        UserFeedbackSubmitRequest request = new UserFeedbackSubmitRequest();
        request.setContent("课程卡顿");
        request.setContact("   ");
 
        userFeedbackAppService.submit(2L, request);
 
        verify(userFeedbackMapper).insert(userFeedbackCaptor.capture());
        assertNull(userFeedbackCaptor.getValue().getContact());
    }
 
    @Test
    void submitShouldRejectInvalidContact() {
        AppUser user = new AppUser();
        user.setId(3L);
        when(userMapper.selectById(3L)).thenReturn(user);
 
        UserFeedbackSubmitRequest request = new UserFeedbackSubmitRequest();
        request.setContent("问题");
        request.setContact("abc");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> userFeedbackAppService.submit(3L, request));
 
        assertEquals("请输入正确的手机号或邮箱", exception.getMessage());
    }
 
    @Test
    void submitShouldRejectMissingUser() {
        when(userMapper.selectById(100L)).thenReturn(null);
 
        UserFeedbackSubmitRequest request = new UserFeedbackSubmitRequest();
        request.setContent("问题");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> userFeedbackAppService.submit(100L, request));
 
        assertEquals("用户不存在", exception.getMessage());
    }
 
    @Test
    void pageShouldTrimContentKeyword() {
        UserFeedbackListItemVO item = new UserFeedbackListItemVO();
        item.setId(1L);
        item.setNickname("王志强");
        item.setContact("14725836904");
        item.setContent("反馈内容");
        item.setCreatedAt(LocalDateTime.of(2026, 3, 26, 10, 0, 0));
        IPage<UserFeedbackListItemVO> result = new Page<UserFeedbackListItemVO>(1, 10);
        result.setRecords(Collections.singletonList(item));
        result.setTotal(1);
        when(userFeedbackQueryMapper.selectUserFeedbackPage(any(Page.class), eq("验证码"))).thenReturn(result);
 
        assertEquals(1, userFeedbackAppService.page(1, 10, "  验证码 ").getList().size());
    }
}