test: add DynamicModelServiceTest

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

@@ -0,0 +1,357 @@
+package com.tinyengine.it.dynamic.service;
+
+import cn.hutool.core.util.ReflectUtil;
+import com.tinyengine.it.common.context.LoginUserContext;
+import com.tinyengine.it.dynamic.dto.DynamicDelete;
+import com.tinyengine.it.dynamic.dto.DynamicInsert;
+import com.tinyengine.it.dynamic.dto.DynamicQuery;
+import com.tinyengine.it.dynamic.dto.DynamicUpdate;
+import com.tinyengine.it.model.dto.ParametersDto;
+import com.tinyengine.it.model.entity.Model;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.jdbc.core.PreparedStatementCreator;
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.support.KeyHolder;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.*;
+
+
+class DynamicModelServiceTest {
+
+	@Mock
+	private JdbcTemplate jdbcTemplate;
+
+	@Mock
+	private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
+
+	@Mock
+	private LoginUserContext loginUserContext;
+
+	@InjectMocks
+	private DynamicModelService dynamicModelService;
+
+	@BeforeEach
+	void setUp() {
+		MockitoAnnotations.openMocks(this);
+		MockitoAnnotations.openMocks(this);
+		ReflectUtil.setFieldValue(dynamicModelService, "jdbcTemplate", jdbcTemplate);
+		ReflectUtil.setFieldValue(dynamicModelService, "loginUserContext", loginUserContext);
+		ReflectUtil.setFieldValue(dynamicModelService, "namedParameterJdbcTemplate", namedParameterJdbcTemplate);
+
+	}
+
+
+	@Test
+	void createDynamicTable() {
+		// Arrange
+		Model model = new Model();
+		model.setNameEn("test_table");
+		ParametersDto parametersDto = new ParametersDto();
+		parametersDto.setProp("name");
+		parametersDto.setType("String");
+		parametersDto.setRequired(true);
+		parametersDto.setDefaultValue("1");
+		parametersDto.setDescription("1");
+		model.setParameters(Collections.singletonList(parametersDto));
+
+		// Mock JdbcTemplate behavior
+		doNothing().when(jdbcTemplate).execute(anyString());
+
+		// Act & Assert
+		assertDoesNotThrow(() -> dynamicModelService.createDynamicTable(model));
+		verify(jdbcTemplate, times(1)).execute(anyString());
+	}
+
+	@Test
+	void dropDynamicTable() {
+		// Arrange
+		Model model = new Model();
+		model.setNameEn("test_table");
+
+		// Mock JdbcTemplate behavior
+		doNothing().when(jdbcTemplate).execute(anyString());
+
+		// Act & Assert
+		assertDoesNotThrow(() -> dynamicModelService.dropDynamicTable(model));
+		verify(jdbcTemplate, times(1)).execute("DROP TABLE IF EXISTS dynamic_test_table;");
+	}
+
+	@Test
+	void initializeDynamicTable() {
+		// Arrange
+		Model model = new Model();
+		model.setNameEn("test_table");
+		ParametersDto param1 = new ParametersDto();
+		param1.setProp("name");
+		param1.setType("String");
+		param1.setDefaultValue("default_name");
+		param1.setRequired(true);
+		model.setParameters(Collections.singletonList(param1));
+
+		Long userId = 1L;
+
+		// Mock JdbcTemplate behavior
+		when(jdbcTemplate.update(anyString(), any(Object[].class))).thenReturn(1);
+
+		// Act & Assert
+		assertDoesNotThrow(() -> dynamicModelService.initializeDynamicTable(model, userId));
+		verify(jdbcTemplate, times(1)).update(anyString(), any(Object[].class));
+	}
+
+	@Test
+	void dynamicQuery() {
+		// Arrange
+		String tableName = "test_table";
+		List<String> fields = Arrays.asList("id", "name");
+		Map<String, Object> conditions = Map.of("id", 1);
+		String orderBy = "id DESC";
+		Integer limit = 10;
+
+		List<Map<String, Object>> mockResult = new ArrayList<>();
+		mockResult.add(Map.of("id", 1, "name", "test_name"));
+
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
+
+		// Act
+		List<Map<String, Object>> result = dynamicModelService.dynamicQuery(tableName, fields, conditions, orderBy, limit);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(1, result.size());
+		assertEquals("test_name", result.get(0).get("name"));
+		verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
+	}
+
+	@Test
+	void dynamicCount() {
+		// Arrange
+		String tableName = "test_table";
+		Map<String, Object> conditions = Map.of("id", 1);
+
+		List<Map<String, Object>> mockResult = new ArrayList<>();
+		mockResult.add(Map.of("count", 5L));
+
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
+
+		// Act
+		List<Map<String, Object>> result = dynamicModelService.dynamicCount(tableName, conditions);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(1, result.size());
+		assertEquals(5L, result.get(0).get("count"));
+		verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
+	}
+
+	@Test
+	void count() {
+		// Arrange
+		String tableName = "test_table";
+		Map<String, Object> conditions = Map.of("id", 1);
+
+		List<Map<String, Object>> mockResult = new ArrayList<>();
+		mockResult.add(Map.of("count", 10L));
+
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockResult);
+
+		// Act
+		Long result = dynamicModelService.count(tableName, conditions);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(10L, result);
+		verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
+	}
+
+	@Test
+	void queryWithPage() {
+		// Arrange
+		DynamicQuery dto = new DynamicQuery();
+		dto.setNameEn("test_table");
+		dto.setFields(Arrays.asList("id", "name"));
+		dto.setParams(Map.of("id", 1));
+		dto.setOrderBy("id DESC");
+		dto.setCurrentPage(1);
+		dto.setPageSize(10);
+
+		List<Map<String, Object>> mockData = new ArrayList<>();
+		mockData.add(Map.of("id", 1, "name", "test_name"));
+
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(mockData);
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(List.of(Map.of("count", 1L)));
+
+		// Act
+		Map<String, Object> result = dynamicModelService.queryWithPage(dto);
+
+		// Assert
+		assertNotNull(result);
+		assertTrue((Boolean) result.get("success"));
+		assertEquals(1L, result.get("total"));
+		assertEquals(1, ((List<?>) result.get("data")).size());
+		verify(namedParameterJdbcTemplate, times(2)).queryForList(anyString(), anyMap());
+	}
+
+
+
+	@Test
+	void createData() {
+		// Arrange
+		DynamicInsert dataDto = new DynamicInsert();
+		dataDto.setNameEn("test_table");
+		dataDto.setParams(Map.of("name", "test"));
+
+		when(loginUserContext.getLoginUserId()).thenReturn("1");
+		when(jdbcTemplate.update(any(PreparedStatementCreator.class), any(KeyHolder.class))).thenAnswer(invocation -> {
+			KeyHolder keyHolder = invocation.getArgument(1);
+			keyHolder.getKeyList().add(Map.of("GENERATED_KEY", 1L));
+			return 1;
+		});
+
+		// Act
+		Map<String, Object> result = dynamicModelService.createData(dataDto);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(1L, result.get("id"));
+		verify(jdbcTemplate, times(1)).update(any(PreparedStatementCreator.class), any(KeyHolder.class));
+	}
+
+	@Test
+	void getDataById() {
+		// Arrange
+		String modelId = "test_table";
+		Long id = 1L;
+
+		List<Map<String, Object>> mockResult = new ArrayList<>();
+		mockResult.add(Map.of("id", 1, "name", "test_name"));
+
+		when(jdbcTemplate.queryForList(anyString(), Optional.ofNullable(any()))).thenReturn(mockResult);
+
+		// Act
+		Map<String, Object> result = dynamicModelService.getDataById(modelId, id);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals("test_name", result.get("name"));
+		verify(jdbcTemplate, times(1)).queryForList(anyString(), Optional.ofNullable(any()));
+	}
+
+	@Test
+	void updateDateById() {
+		// Arrange
+		DynamicUpdate dto = new DynamicUpdate();
+		dto.setNameEn("test_table");
+		dto.setParams(Map.of("id", 1));
+		dto.setData(Map.of("name", "updated_name"));
+
+		when(jdbcTemplate.update(anyString(), any(Object[].class))).thenReturn(1);
+
+		// Act
+		Map<String, Object> result = dynamicModelService.updateDateById(dto);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(1, result.get("rowsAffected"));
+		verify(jdbcTemplate, times(1)).update(anyString(), any(Object[].class));
+	}
+
+	@Test
+	void deleteDataById() {
+		// Arrange
+		DynamicDelete dto = new DynamicDelete();
+		dto.setNameEn("test_table");
+		dto.setId(1);
+
+		when(jdbcTemplate.update(anyString(), Optional.ofNullable(any()))).thenReturn(1);
+
+		// Act
+		Map<String, Object> result = dynamicModelService.deleteDataById(dto);
+
+		// Assert
+		assertNotNull(result);
+		assertEquals(1, result.get("rowsAffected"));
+		verify(jdbcTemplate, times(1)).update(anyString(), Optional.ofNullable(any()));
+	}
+
+
+	@Test
+	void testCreateDynamicTable() {
+		Model model = new Model();
+		model.setNameEn("test_table");
+		ParametersDto parametersDto = new ParametersDto();
+		parametersDto.setProp("name");
+		parametersDto.setType("String");
+		parametersDto.setRequired(true);
+		parametersDto.setDefaultValue("1");
+		parametersDto.setDescription("1");
+		model.setParameters(Collections.singletonList(parametersDto));
+
+		doNothing().when(jdbcTemplate).execute(anyString());
+
+		assertDoesNotThrow(() -> dynamicModelService.createDynamicTable(model));
+		verify(jdbcTemplate, times(1)).execute(anyString());
+	}
+
+	@Test
+	void testDropDynamicTable() {
+		Model model = new Model();
+		model.setNameEn("test_table");
+
+		doNothing().when(jdbcTemplate).execute(anyString());
+
+		assertDoesNotThrow(() -> dynamicModelService.dropDynamicTable(model));
+		verify(jdbcTemplate, times(1)).execute(anyString());
+	}
+
+	@Test
+	void testDynamicQuery() {
+		String tableName = "test_table";
+		List<String> fields = Arrays.asList("id", "name");
+		Map<String, Object> conditions = Map.of("id", 1);
+
+		when(namedParameterJdbcTemplate.queryForList(anyString(), anyMap())).thenReturn(new ArrayList<>());
+
+		List<Map<String, Object>> result = dynamicModelService.dynamicQuery(tableName, fields, conditions, null, null);
+		assertNotNull(result);
+		verify(namedParameterJdbcTemplate, times(1)).queryForList(anyString(), anyMap());
+	}
+
+	@Test
+	void testCreateData() {
+		DynamicInsert dataDto = new DynamicInsert();
+		dataDto.setNameEn("test_table");
+		dataDto.setParams(Map.of("name", "test"));
+
+		when(loginUserContext.getLoginUserId()).thenReturn("1");
+		when(jdbcTemplate.update(any(), any(PreparedStatementCreator.class), any())).thenReturn(1);
+
+		Map<String, Object> result = dynamicModelService.createData(dataDto);
+		assertNotNull(result);
+		verify(jdbcTemplate, times(1)).update(any(PreparedStatementCreator.class), any());
+	}
+
+	@Test
+	void testDeleteDataById() {
+		DynamicDelete dto = new DynamicDelete();
+		dto.setNameEn("test_table");
+		dto.setId(1);
+
+		when(jdbcTemplate.update(anyString(), Optional.ofNullable(any()))).thenReturn(1);
+
+		Map<String, Object> result = dynamicModelService.deleteDataById(dto);
+		assertEquals(1, result.get("rowsAffected"));
+		verify(jdbcTemplate, times(1)).update(anyString(), Optional.ofNullable(any()));
+	}
+
+
+}