“mitao”
2026-05-14 0c76f764b00b724c60f42fa647dd02decb9c0ca2
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
package com.tcm.training.admin.system.service;
 
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.tcm.training.admin.system.dto.CommonQuestionSaveRequest;
import com.tcm.training.admin.system.entity.CommonQuestion;
import com.tcm.training.admin.system.mapper.CommonQuestionMapper;
import com.tcm.training.admin.system.vo.CommonQuestionDetailVO;
import org.apache.ibatis.builder.MapperBuilderAssistant;
import org.junit.jupiter.api.BeforeAll;
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 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.doAnswer;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
 
@ExtendWith(MockitoExtension.class)
class CommonQuestionAppServiceTest {
 
    @BeforeAll
    static void initLambdaCache() {
        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
        TableInfoHelper.initTableInfo(assistant, CommonQuestion.class);
    }
 
    @Mock
    private CommonQuestionMapper commonQuestionMapper;
 
    @InjectMocks
    private CommonQuestionAppService commonQuestionAppService;
 
    @Captor
    private ArgumentCaptor<CommonQuestion> commonQuestionCaptor;
 
    @Test
    void createShouldPersistQuestion() {
        doAnswer(invocation -> {
            CommonQuestion item = invocation.getArgument(0);
            item.setId(1L);
            return 1;
        }).when(commonQuestionMapper).insert(any(CommonQuestion.class));
 
        CommonQuestion persisted = new CommonQuestion();
        persisted.setId(1L);
        persisted.setTitle("常见问题");
        persisted.setContentHtml("<p>内容</p>");
        persisted.setCreatedAt(LocalDateTime.of(2026, 3, 26, 21, 10, 0));
        when(commonQuestionMapper.selectOne(any())).thenReturn(persisted);
 
        CommonQuestionSaveRequest request = new CommonQuestionSaveRequest();
        request.setTitle("  常见问题  ");
        request.setContentHtml("<p>内容</p>");
 
        CommonQuestionDetailVO result = commonQuestionAppService.create(request);
 
        verify(commonQuestionMapper).insert(commonQuestionCaptor.capture());
        assertEquals("常见问题", commonQuestionCaptor.getValue().getTitle());
        assertEquals("<p>内容</p>", commonQuestionCaptor.getValue().getContentHtml());
        assertEquals("常见问题", result.getTitle());
    }
 
    @Test
    void updateShouldPersistQuestion() {
        CommonQuestion persisted = new CommonQuestion();
        persisted.setId(2L);
        persisted.setTitle("旧问题");
        persisted.setContentHtml("<p>旧内容</p>");
        when(commonQuestionMapper.selectOne(any())).thenReturn(persisted);
 
        CommonQuestionSaveRequest request = new CommonQuestionSaveRequest();
        request.setTitle("新问题");
        request.setContentHtml("<p>新内容</p>");
 
        commonQuestionAppService.update(2L, request);
 
        verify(commonQuestionMapper).updateById(commonQuestionCaptor.capture());
        assertEquals("新问题", commonQuestionCaptor.getValue().getTitle());
        assertEquals("<p>新内容</p>", commonQuestionCaptor.getValue().getContentHtml());
    }
 
    @Test
    void createShouldRejectBlankTitle() {
        CommonQuestionSaveRequest request = new CommonQuestionSaveRequest();
        request.setTitle("   ");
        request.setContentHtml("<p>内容</p>");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> commonQuestionAppService.create(request));
 
        assertEquals("请输入问题", exception.getMessage());
    }
 
    @Test
    void createShouldRejectTooLongTitle() {
        CommonQuestionSaveRequest request = new CommonQuestionSaveRequest();
        request.setTitle("这是一个超过十五个字的问题标题啊");
        request.setContentHtml("<p>内容</p>");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> commonQuestionAppService.create(request));
 
        assertEquals("请输入15个字以内", exception.getMessage());
    }
 
    @Test
    void createShouldRejectBlankContent() {
        CommonQuestionSaveRequest request = new CommonQuestionSaveRequest();
        request.setTitle("问题");
        request.setContentHtml("<p><br/></p>");
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> commonQuestionAppService.create(request));
 
        assertEquals("请输入内容", exception.getMessage());
    }
 
    @Test
    void deleteShouldRejectMissingQuestion() {
        when(commonQuestionMapper.selectOne(any())).thenReturn(null);
 
        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
                () -> commonQuestionAppService.delete(100L));
 
        assertEquals("常见问题不存在", exception.getMessage());
    }
}