Skip to content

Commit 7dfdd6b

Browse files
msslulumsslulu
committed
feat: add DynamicModelServiceTest
1 parent 2b97f64 commit 7dfdd6b

File tree

1 file changed

+357
-0
lines changed

1 file changed

+357
-0
lines changed

‎base/src/test/java/com/tinyengine/it/dynamic/service/DynamicModelServiceTest.java‎

Lines changed: 357 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,357 @@
1+
package com.tinyengine.it.dynamic.service;
2+
3+
import cn.hutool.core.util.ReflectUtil;
4+
import com.tinyengine.it.common.context.LoginUserContext;
5+
import com.tinyengine.it.dynamic.dto.DynamicDelete;
6+
import com.tinyengine.it.dynamic.dto.DynamicInsert;
7+
import com.tinyengine.it.dynamic.dto.DynamicQuery;
8+
import com.tinyengine.it.dynamic.dto.DynamicUpdate;
9+
import com.tinyengine.it.model.dto.ParametersDto;
10+
import com.tinyengine.it.model.entity.Model;
11+
import org.junit.jupiter.api.BeforeEach;
12+
import org.junit.jupiter.api.Test;
13+
import org.mockito.InjectMocks;
14+
import org.mockito.Mock;
15+
import org.mockito.MockitoAnnotations;
16+
import org.springframework.jdbc.core.JdbcTemplate;
17+
import org.springframework.jdbc.core.PreparedStatementCreator;
18+
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
19+
import org.springframework.jdbc.support.KeyHolder;
20+
21+
import java.util.*;
22+
23+
import static org.junit.jupiter.api.Assertions.*;
24+
import static org.mockito.ArgumentMatchers.any;
25+
import static org.mockito.ArgumentMatchers.anyString;
26+
import static org.mockito.Mockito.*;
27+
28+
29+
class DynamicModelServiceTest {
30+
31+
@Mock
32+
private JdbcTemplate jdbcTemplate;
33+
34+
@Mock
35+
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
36+
37+
@Mock
38+
private LoginUserContext loginUserContext;
39+
40+
@InjectMocks
41+
private DynamicModelService dynamicModelService;
42+
43+
@BeforeEach
44+
void setUp() {
45+
MockitoAnnotations.openMocks(this);
46+
MockitoAnnotations.openMocks(this);
47+
ReflectUtil.setFieldValue(dynamicModelService, "jdbcTemplate", jdbcTemplate);
48+
ReflectUtil.setFieldValue(dynamicModelService, "loginUserContext", loginUserContext);
49+
ReflectUtil.setFieldValue(dynamicModelService, "namedParameterJdbcTemplate", namedParameterJdbcTemplate);
50+
51+
}
52+
53+
54+
@Test
55+
void createDynamicTable() {
56+
// Arrange
57+
Model model = new Model();
58+
model.setNameEn("test_table");
59+
ParametersDto parametersDto = new ParametersDto();
60+
parametersDto.setProp("name");
61+
parametersDto.setType("String");
62+
parametersDto.setRequired(true);
63+
parametersDto.setDefaultValue("1");
64+
parametersDto.setDescription("1");
65+
model.setParameters(Collections.singletonList(parametersDto));
66+
67+
// Mock JdbcTemplate behavior
68+
doNothing().when(jdbcTemplate).execute(anyString());
69+
70+
// Act & Assert
71+
assertDoesNotThrow(() -> dynamicModelService.createDynamicTable(model));
72+
verify(jdbcTemplate, times(1)).execute(anyString());
73+
}
74+
75+
@Test
76+
void dropDynamicTable() {
77+
// Arrange
78+
Model model = new Model();
79+
model.setNameEn("test_table");
80+
81+
// Mock JdbcTemplate behavior
82+
doNothing().when(jdbcTemplate).execute(anyString());
83+
84+
// Act & Assert
85+
assertDoesNotThrow(() -> dynamicModelService.dropDynamicTable(model));
86+
verify(jdbcTemplate, times(1)).execute("DROP TABLE IF EXISTS dynamic_test_table;");
87+
}
88+
89+
@Test
90+
void initializeDynamicTable() {
91+
// Arrange
92+
Model model = new Model();
93+
model.setNameEn("test_table");
94+
ParametersDto param1 = new ParametersDto();
95+
param1.setProp("name");
96+
param1.setType("String");
97+
param1.setDefaultValue("default_name");
98+
param1.setRequired(true);
99+
model.setParameters(Collections.singletonList(param1));
100+
101+
Long userId = 1L;
102+
103+
// Mock JdbcTemplate behavior
104+
when(jdbcTemplate.update(anyString(), any(Object[].class))).thenReturn(1);
105+
106+
// Act & Assert
107+
assertDoesNotThrow(() -> dynamicModelService.initializeDynamicTable(model, userId));
108+
verify(jdbcTemplate, times(1)).update(anyString(), any(Object[].class));
109+
}
110+
111+
@Test
112+
void dynamicQuery() {
113+
// Arrange
114+
String tableName = "test_table";
115+
List<String> fields = Arrays.asList("id", "name");
116+
Map<String, Object> conditions = Map.of("id", 1);
117+
String orderBy = "id DESC";
118+
Integer limit = 10;
119+
120+
List<Map<String, Object>> mockResult = new ArrayList<>();
121+
mockResult.add(Map.of("id", 1, "name", "test_name"));
122+
123+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
124+
125+
// Act
126+
List<Map<String, Object>> result = dynamicModelService.dynamicQuery(tableName, fields, conditions, orderBy, limit);
127+
128+
// Assert
129+
assertNotNull(result);
130+
assertEquals(1, result.size());
131+
assertEquals("test_name", result.get(0).get("name"));
132+
verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
133+
}
134+
135+
@Test
136+
void dynamicCount() {
137+
// Arrange
138+
String tableName = "test_table";
139+
Map<String, Object> conditions = Map.of("id", 1);
140+
141+
List<Map<String, Object>> mockResult = new ArrayList<>();
142+
mockResult.add(Map.of("count", 5L));
143+
144+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
145+
146+
// Act
147+
List<Map<String, Object>> result = dynamicModelService.dynamicCount(tableName, conditions);
148+
149+
// Assert
150+
assertNotNull(result);
151+
assertEquals(1, result.size());
152+
assertEquals(5L, result.get(0).get("count"));
153+
verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
154+
}
155+
156+
@Test
157+
void count() {
158+
// Arrange
159+
String tableName = "test_table";
160+
Map<String, Object> conditions = Map.of("id", 1);
161+
162+
List<Map<String, Object>> mockResult = new ArrayList<>();
163+
mockResult.add(Map.of("count", 10L));
164+
165+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
166+
167+
// Act
168+
Long result = dynamicModelService.count(tableName, conditions);
169+
170+
// Assert
171+
assertNotNull(result);
172+
assertEquals(10L, result);
173+
verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
174+
}
175+
176+
@Test
177+
void queryWithPage() {
178+
// Arrange
179+
DynamicQuery dto = new DynamicQuery();
180+
dto.setNameEn("test_table");
181+
dto.setFields(Arrays.asList("id", "name"));
182+
dto.setParams(Map.of("id", 1));
183+
dto.setOrderBy("id DESC");
184+
dto.setCurrentPage(1);
185+
dto.setPageSize(10);
186+
187+
List<Map<String, Object>> mockData = new ArrayList<>();
188+
mockData.add(Map.of("id", 1, "name", "test_name"));
189+
190+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockData);
191+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(List.of(Map.of("count", 1L)));
192+
193+
// Act
194+
Map<String, Object> result = dynamicModelService.queryWithPage(dto);
195+
196+
// Assert
197+
assertNotNull(result);
198+
assertTrue((Boolean) result.get("success"));
199+
assertEquals(1L, result.get("total"));
200+
assertEquals(1, ((List<?>) result.get("data")).size());
201+
verify(namedParameterJdbcTemplate, times(2)).queryForList(anyString(), anyMap());
202+
}
203+
204+
205+
206+
@Test
207+
void createData() {
208+
// Arrange
209+
DynamicInsert dataDto = new DynamicInsert();
210+
dataDto.setNameEn("test_table");
211+
dataDto.setParams(Map.of("name", "test"));
212+
213+
when(loginUserContext.getLoginUserId()).thenReturn("1");
214+
when(jdbcTemplate.update(any(PreparedStatementCreator.class), any(KeyHolder.class))).thenAnswer(invocation -> {
215+
KeyHolder keyHolder = invocation.getArgument(1);
216+
keyHolder.getKeyList().add(Map.of("GENERATED_KEY", 1L));
217+
return 1;
218+
});
219+
220+
// Act
221+
Map<String, Object> result = dynamicModelService.createData(dataDto);
222+
223+
// Assert
224+
assertNotNull(result);
225+
assertEquals(1L, result.get("id"));
226+
verify(jdbcTemplate, times(1)).update(any(PreparedStatementCreator.class), any(KeyHolder.class));
227+
}
228+
229+
@Test
230+
void getDataById() {
231+
// Arrange
232+
String modelId = "test_table";
233+
Long id = 1L;
234+
235+
List<Map<String, Object>> mockResult = new ArrayList<>();
236+
mockResult.add(Map.of("id", 1, "name", "test_name"));
237+
238+
when(jdbcTemplate.queryForList(anyString(), Optional.ofNullable(any()))).thenReturn(mockResult);
239+
240+
// Act
241+
Map<String, Object> result = dynamicModelService.getDataById(modelId, id);
242+
243+
// Assert
244+
assertNotNull(result);
245+
assertEquals("test_name", result.get("name"));
246+
verify(jdbcTemplate, times(1)).queryForList(anyString(), Optional.ofNullable(any()));
247+
}
248+
249+
@Test
250+
void updateDateById() {
251+
// Arrange
252+
DynamicUpdate dto = new DynamicUpdate();
253+
dto.setNameEn("test_table");
254+
dto.setParams(Map.of("id", 1));
255+
dto.setData(Map.of("name", "updated_name"));
256+
257+
when(jdbcTemplate.update(anyString(), any(Object[].class))).thenReturn(1);
258+
259+
// Act
260+
Map<String, Object> result = dynamicModelService.updateDateById(dto);
261+
262+
// Assert
263+
assertNotNull(result);
264+
assertEquals(1, result.get("rowsAffected"));
265+
verify(jdbcTemplate, times(1)).update(anyString(), any(Object[].class));
266+
}
267+
268+
@Test
269+
void deleteDataById() {
270+
// Arrange
271+
DynamicDelete dto = new DynamicDelete();
272+
dto.setNameEn("test_table");
273+
dto.setId(1);
274+
275+
when(jdbcTemplate.update(anyString(), Optional.ofNullable(any()))).thenReturn(1);
276+
277+
// Act
278+
Map<String, Object> result = dynamicModelService.deleteDataById(dto);
279+
280+
// Assert
281+
assertNotNull(result);
282+
assertEquals(1, result.get("rowsAffected"));
283+
verify(jdbcTemplate, times(1)).update(anyString(), Optional.ofNullable(any()));
284+
}
285+
286+
287+
@Test
288+
void testCreateDynamicTable() {
289+
Model model = new Model();
290+
model.setNameEn("test_table");
291+
ParametersDto parametersDto = new ParametersDto();
292+
parametersDto.setProp("name");
293+
parametersDto.setType("String");
294+
parametersDto.setRequired(true);
295+
parametersDto.setDefaultValue("1");
296+
parametersDto.setDescription("1");
297+
model.setParameters(Collections.singletonList(parametersDto));
298+
299+
doNothing().when(jdbcTemplate).execute(anyString());
300+
301+
assertDoesNotThrow(() -> dynamicModelService.createDynamicTable(model));
302+
verify(jdbcTemplate, times(1)).execute(anyString());
303+
}
304+
305+
@Test
306+
void testDropDynamicTable() {
307+
Model model = new Model();
308+
model.setNameEn("test_table");
309+
310+
doNothing().when(jdbcTemplate).execute(anyString());
311+
312+
assertDoesNotThrow(() -> dynamicModelService.dropDynamicTable(model));
313+
verify(jdbcTemplate, times(1)).execute(anyString());
314+
}
315+
316+
@Test
317+
void testDynamicQuery() {
318+
String tableName = "test_table";
319+
List<String> fields = Arrays.asList("id", "name");
320+
Map<String, Object> conditions = Map.of("id", 1);
321+
322+
when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(new ArrayList<>());
323+
324+
List<Map<String, Object>> result = dynamicModelService.dynamicQuery(tableName, fields, conditions, null, null);
325+
assertNotNull(result);
326+
verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
327+
}
328+
329+
@Test
330+
void testCreateData() {
331+
DynamicInsert dataDto = new DynamicInsert();
332+
dataDto.setNameEn("test_table");
333+
dataDto.setParams(Map.of("name", "test"));
334+
335+
when(loginUserContext.getLoginUserId()).thenReturn("1");
336+
when(jdbcTemplate.update(any(), any(PreparedStatementCreator.class), any())).thenReturn(1);
337+
338+
Map<String, Object> result = dynamicModelService.createData(dataDto);
339+
assertNotNull(result);
340+
verify(jdbcTemplate, times(1)).update(any(PreparedStatementCreator.class), any());
341+
}
342+
343+
@Test
344+
void testDeleteDataById() {
345+
DynamicDelete dto = new DynamicDelete();
346+
dto.setNameEn("test_table");
347+
dto.setId(1);
348+
349+
when(jdbcTemplate.update(anyString(), Optional.ofNullable(any()))).thenReturn(1);
350+
351+
Map<String, Object> result = dynamicModelService.deleteDataById(dto);
352+
assertEquals(1, result.get("rowsAffected"));
353+
verify(jdbcTemplate, times(1)).update(anyString(), Optional.ofNullable(any()));
354+
}
355+
356+
357+
}

0 commit comments

Comments
 (0)