zgty/zt-base
9
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1. 新增物料相关接口

Browse Source 
2. 修复部分服务因为包名设置错误导致无法采集日志的错误
This commit is contained in:
chenbowen
2025-11-06 13:41:56 +08:00
parent 8acfaffb62
commit 1282ef43cc
36 changed files with 1896 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

201
zt-module-base/zt-module-base-server/src/test/java/com/zt/plat/module/base/api/businessdictionarytype/BusinessDictionaryTypeApiImplTest.java Normal file
View File

@@ -0,0 +1,201 @@
package com.zt.plat.module.base.api.businessdictionarytype;
import com.zt.plat.framework.common.pojo.CommonResult;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.module.base.api.businessdictionarytype.dto.BusinessDictionaryDataDTO;
import com.zt.plat.module.base.api.businessdictionarytype.dto.BusinessDictionaryTypePageReqDTO;
import com.zt.plat.module.base.api.businessdictionarytype.dto.BusinessDictionaryTypeRespDTO;
import com.zt.plat.module.base.api.businessdictionarytype.dto.BusinessDictionaryTypeSaveReqDTO;
import com.zt.plat.module.base.controller.admin.businessdictionarytype.vo.BusinessDictionaryTypePageReqVO;
import com.zt.plat.module.base.controller.admin.businessdictionarytype.vo.BusinessDictionaryTypeRespVO;
import com.zt.plat.module.base.controller.admin.businessdictionarytype.vo.BusinessDictionaryTypeSaveReqVO;
import com.zt.plat.module.base.dal.dataobject.businessdictionarytype.BusinessDictionaryDataDO;
import com.zt.plat.module.base.dal.dataobject.businessdictionarytype.BusinessDictionaryTypeDO;
import com.zt.plat.module.base.service.businessdictionarytype.BusinessDictionaryTypeService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class BusinessDictionaryTypeApiImplTest {
@InjectMocks
private BusinessDictionaryTypeApiImpl api;
@Mock
private BusinessDictionaryTypeService businessDictionaryTypeService;
private BusinessDictionaryTypeSaveReqDTO buildSaveReqDTO() {
BusinessDictionaryDataDTO dataDTO = new BusinessDictionaryDataDTO();
dataDTO.setId(10L);
dataDTO.setLabel("启用");
dataDTO.setValue("ENABLE");
dataDTO.setRemark("默认状态");
BusinessDictionaryTypeSaveReqDTO dto = new BusinessDictionaryTypeSaveReqDTO();
dto.setId(1L);
dto.setName("状态字典");
dto.setType("base_material_status");
dto.setStatus(0L);
dto.setRemark("备注");
dto.setBusinessDictionaryDatas(List.of(dataDTO));
return dto;
}
private BusinessDictionaryTypeRespVO buildRespVO() {
BusinessDictionaryTypeRespVO respVO = new BusinessDictionaryTypeRespVO();
respVO.setId(1L);
respVO.setName("状态字典");
respVO.setType("base_material_status");
respVO.setStatus(0L);
respVO.setRemark("备注");
respVO.setCreateTime(LocalDateTime.now());
return respVO;
}
@Test
void createBusinessDictionaryType_shouldForwardToServiceAndReturnConvertedDto() {
BusinessDictionaryTypeSaveReqDTO reqDTO = buildSaveReqDTO();
BusinessDictionaryTypeRespVO serviceResp = buildRespVO();
when(businessDictionaryTypeService.createBusinessDictionaryType(any(BusinessDictionaryTypeSaveReqVO.class)))
.thenReturn(serviceResp);
CommonResult<BusinessDictionaryTypeRespDTO> result = api.createBusinessDictionaryType(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).usingRecursiveComparison()
.ignoringFields("createTime")
.isEqualTo(BeanAssertHelper.toRespDTO(serviceResp));
ArgumentCaptor<BusinessDictionaryTypeSaveReqVO> captor = ArgumentCaptor.forClass(BusinessDictionaryTypeSaveReqVO.class);
verify(businessDictionaryTypeService).createBusinessDictionaryType(captor.capture());
BusinessDictionaryTypeSaveReqVO passed = captor.getValue();
assertThat(passed.getName()).isEqualTo(reqDTO.getName());
assertThat(passed.getBusinessDictionaryDatas()).hasSize(1);
BusinessDictionaryDataDO dataDO = passed.getBusinessDictionaryDatas().get(0);
assertThat(dataDO.getLabel()).isEqualTo("启用");
assertThat(dataDO.getValue()).isEqualTo("ENABLE");
}
@Test
void updateBusinessDictionaryType_shouldInvokeServiceWithConvertedPayload() {
BusinessDictionaryTypeSaveReqDTO reqDTO = buildSaveReqDTO();
CommonResult<Boolean> result = api.updateBusinessDictionaryType(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
ArgumentCaptor<BusinessDictionaryTypeSaveReqVO> captor = ArgumentCaptor.forClass(BusinessDictionaryTypeSaveReqVO.class);
verify(businessDictionaryTypeService).updateBusinessDictionaryType(captor.capture());
assertThat(captor.getValue().getName()).isEqualTo(reqDTO.getName());
}
@Test
void deleteBusinessDictionaryType_shouldInvokeService() {
CommonResult<Boolean> result = api.deleteBusinessDictionaryType(123L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(businessDictionaryTypeService).deleteBusinessDictionaryType(123L);
}
@Test
void deleteBusinessDictionaryTypeList_shouldInvokeService() {
List<Long> ids = List.of(1L, 2L);
CommonResult<Boolean> result = api.deleteBusinessDictionaryTypeList(ids);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(businessDictionaryTypeService).deleteBusinessDictionaryTypeListByIds(ids);
}
@Test
void getBusinessDictionaryType_shouldConvertDoToDto() {
BusinessDictionaryTypeDO typeDO = new BusinessDictionaryTypeDO();
typeDO.setId(55L);
typeDO.setName("状态字典");
when(businessDictionaryTypeService.getBusinessDictionaryType(55L)).thenReturn(typeDO);
CommonResult<BusinessDictionaryTypeRespDTO> result = api.getBusinessDictionaryType(55L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getId()).isEqualTo(55L);
assertThat(result.getData().getName()).isEqualTo("状态字典");
}
@Test
void getBusinessDictionaryTypePage_shouldConvertPageResult() {
BusinessDictionaryTypeDO typeDO = new BusinessDictionaryTypeDO();
typeDO.setId(11L);
typeDO.setName("状态");
PageResult<BusinessDictionaryTypeDO> page = new PageResult<>(List.of(typeDO), 1L);
when(businessDictionaryTypeService.getBusinessDictionaryTypePage(any(BusinessDictionaryTypePageReqVO.class)))
.thenReturn(page);
BusinessDictionaryTypePageReqDTO reqDTO = new BusinessDictionaryTypePageReqDTO();
reqDTO.setName("状态");
CommonResult<PageResult<BusinessDictionaryTypeRespDTO>> result = api.getBusinessDictionaryTypePage(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getList()).hasSize(1);
assertThat(result.getData().getList().get(0).getName()).isEqualTo("状态");
assertThat(result.getData().getTotal()).isEqualTo(1L);
}
@Test
void getBusinessDictionaryDataListByDictionaryTypeId_shouldConvertList() {
BusinessDictionaryDataDO dataDO = new BusinessDictionaryDataDO();
dataDO.setId(9L);
dataDO.setLabel("启用");
when(businessDictionaryTypeService.getBusinessDictionaryDataListByDictionaryTypeId(8L))
.thenReturn(List.of(dataDO));
CommonResult<List<BusinessDictionaryDataDTO>> result = api.getBusinessDictionaryDataListByDictionaryTypeId(8L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).hasSize(1);
assertThat(result.getData().get(0).getLabel()).isEqualTo("启用");
}
@Test
void getBusinessDictionaryDataListByType_shouldConvertList() {
BusinessDictionaryDataDO dataDO = new BusinessDictionaryDataDO();
dataDO.setId(9L);
dataDO.setValue("ENABLE");
when(businessDictionaryTypeService.getBusinessDictionaryDataListByType("base_material_status"))
.thenReturn(List.of(dataDO));
CommonResult<List<BusinessDictionaryDataDTO>> result = api.getBusinessDictionaryDataListByType("base_material_status");
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).hasSize(1);
assertThat(result.getData().get(0).getValue()).isEqualTo("ENABLE");
}
private static final class BeanAssertHelper {
private BeanAssertHelper() {
}
static BusinessDictionaryTypeRespDTO toRespDTO(BusinessDictionaryTypeRespVO respVO) {
BusinessDictionaryTypeRespDTO dto = new BusinessDictionaryTypeRespDTO();
dto.setId(respVO.getId());
dto.setName(respVO.getName());
dto.setType(respVO.getType());
dto.setStatus(respVO.getStatus());
dto.setRemark(respVO.getRemark());
dto.setCreateTime(respVO.getCreateTime());
return dto;
}
}
}

146
zt-module-base/zt-module-base-server/src/test/java/com/zt/plat/module/base/api/departmentmaterial/DepartmentMaterialApiImplTest.java Normal file
View File

@@ -0,0 +1,146 @@
package com.zt.plat.module.base.api.departmentmaterial;
import com.zt.plat.framework.common.pojo.CommonResult;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.module.base.api.departmentmaterial.dto.DepartmentMaterialPageReqDTO;
import com.zt.plat.module.base.api.departmentmaterial.dto.DepartmentMaterialRespDTO;
import com.zt.plat.module.base.api.departmentmaterial.dto.DepartmentMaterialSaveReqDTO;
import com.zt.plat.module.base.controller.admin.departmentmaterial.vo.DepartmentMaterialPageReqVO;
import com.zt.plat.module.base.controller.admin.departmentmaterial.vo.DepartmentMaterialRespVO;
import com.zt.plat.module.base.controller.admin.departmentmaterial.vo.DepartmentMaterialSaveReqVO;
import com.zt.plat.module.base.service.departmentmaterial.DepartmentMaterialService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class DepartmentMaterialApiImplTest {
@InjectMocks
private DepartmentMaterialApiImpl api;
@Mock
private DepartmentMaterialService departmentMaterialService;
private DepartmentMaterialSaveReqDTO buildSaveReq() {
DepartmentMaterialSaveReqDTO dto = new DepartmentMaterialSaveReqDTO();
dto.setId(100L);
dto.setDeptId(200L);
dto.setInfomationId(300L);
dto.setClassesId(400L);
dto.setDictionaryDataValue("TYPE");
dto.setStatus("ENABLE");
dto.setRemark("备注");
return dto;
}
private DepartmentMaterialRespVO buildRespVO() {
DepartmentMaterialRespVO respVO = new DepartmentMaterialRespVO();
respVO.setId(100L);
respVO.setDeptId(200L);
respVO.setInfomationId(300L);
respVO.setClassesId(400L);
respVO.setDictionaryDataValue("TYPE");
respVO.setRemark("备注");
respVO.setStatus("ENABLE");
respVO.setMaterialName("原材料");
respVO.setCreateTime(LocalDateTime.now());
return respVO;
}
@Test
void createDepartmentMaterial_shouldForwardToServiceAndReturnConvertedDto() {
DepartmentMaterialSaveReqDTO reqDTO = buildSaveReq();
DepartmentMaterialRespVO serviceResp = buildRespVO();
when(departmentMaterialService.createDepartmentMaterial(any(DepartmentMaterialSaveReqVO.class)))
.thenReturn(serviceResp);
CommonResult<DepartmentMaterialRespDTO> result = api.createDepartmentMaterial(reqDTO);
assertThat(result.isSuccess()).isTrue();
DepartmentMaterialRespDTO data = result.getData();
assertThat(data.getId()).isEqualTo(serviceResp.getId());
assertThat(data.getMaterialName()).isEqualTo("原材料");
ArgumentCaptor<DepartmentMaterialSaveReqVO> captor = ArgumentCaptor.forClass(DepartmentMaterialSaveReqVO.class);
verify(departmentMaterialService).createDepartmentMaterial(captor.capture());
DepartmentMaterialSaveReqVO passed = captor.getValue();
assertThat(passed.getDeptId()).isEqualTo(reqDTO.getDeptId());
assertThat(passed.getInfomationId()).isEqualTo(reqDTO.getInfomationId());
assertThat(passed.getDictionaryDataValue()).isEqualTo(reqDTO.getDictionaryDataValue());
}
@Test
void updateDepartmentMaterial_shouldInvokeService() {
DepartmentMaterialSaveReqDTO reqDTO = buildSaveReq();
CommonResult<Boolean> result = api.updateDepartmentMaterial(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
ArgumentCaptor<DepartmentMaterialSaveReqVO> captor = ArgumentCaptor.forClass(DepartmentMaterialSaveReqVO.class);
verify(departmentMaterialService).updateDepartmentMaterial(captor.capture());
assertThat(captor.getValue().getDeptId()).isEqualTo(reqDTO.getDeptId());
}
@Test
void deleteDepartmentMaterial_shouldInvokeService() {
CommonResult<Boolean> result = api.deleteDepartmentMaterial(99L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(departmentMaterialService).deleteDepartmentMaterial(99L);
}
@Test
void deleteDepartmentMaterialList_shouldInvokeService() {
List<Long> ids = List.of(1L, 2L, 3L);
CommonResult<Boolean> result = api.deleteDepartmentMaterialList(ids);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(departmentMaterialService).deleteDepartmentMaterialListByIds(ids);
}
@Test
void getDepartmentMaterial_shouldConvertVoToDto() {
DepartmentMaterialRespVO respVO = buildRespVO();
when(departmentMaterialService.getDepartmentMaterial(11L)).thenReturn(respVO);
CommonResult<DepartmentMaterialRespDTO> result = api.getDepartmentMaterial(11L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getId()).isEqualTo(respVO.getId());
assertThat(result.getData().getMaterialName()).isEqualTo(respVO.getMaterialName());
}
@Test
void getDepartmentMaterialPage_shouldConvertPageResult() {
DepartmentMaterialRespVO respVO = buildRespVO();
PageResult<DepartmentMaterialRespVO> page = new PageResult<>(List.of(respVO), 1L);
when(departmentMaterialService.getDepartmentMaterialPage(any(DepartmentMaterialPageReqVO.class)))
.thenReturn(page);
DepartmentMaterialPageReqDTO reqDTO = new DepartmentMaterialPageReqDTO();
reqDTO.setDeptId(200L);
CommonResult<PageResult<DepartmentMaterialRespDTO>> result = api.getDepartmentMaterialPage(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getList()).hasSize(1);
assertThat(result.getData().getList().get(0).getMaterialName()).isEqualTo("原材料");
assertThat(result.getData().getTotal()).isEqualTo(1L);
}
}

180
zt-module-base/zt-module-base-server/src/test/java/com/zt/plat/module/base/api/materialclasses/MaterialClassesApiImplTest.java Normal file
View File

@@ -0,0 +1,180 @@
package com.zt.plat.module.base.api.materialclasses;
import com.zt.plat.framework.common.pojo.CommonResult;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.module.base.api.materialclasses.dto.MaterialClassesPageReqDTO;
import com.zt.plat.module.base.api.materialclasses.dto.MaterialClassesRespDTO;
import com.zt.plat.module.base.api.materialclasses.dto.MaterialClassesSaveReqDTO;
import com.zt.plat.module.base.api.materialclasses.dto.MaterialClassesTreeRespDTO;
import com.zt.plat.module.base.controller.admin.materialclasses.vo.MaterialClassesPageReqVO;
import com.zt.plat.module.base.controller.admin.materialclasses.vo.MaterialClassesRespVO;
import com.zt.plat.module.base.controller.admin.materialclasses.vo.MaterialClassesSaveReqVO;
import com.zt.plat.module.base.dal.dataobject.materialclasses.MaterialClassesDO;
import com.zt.plat.module.base.service.materialclasses.MaterialClassesService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class MaterialClassesApiImplTest {
@InjectMocks
private MaterialClassesApiImpl api;
@Mock
private MaterialClassesService materialClassesService;
private MaterialClassesSaveReqDTO buildSaveReq() {
MaterialClassesSaveReqDTO dto = new MaterialClassesSaveReqDTO();
dto.setId(1L);
dto.setParentId(0L);
dto.setCode("CLS001");
dto.setName("原材料");
dto.setLevel(1L);
dto.setRemark("顶级分类");
return dto;
}
private MaterialClassesRespVO buildRespVO() {
MaterialClassesRespVO respVO = new MaterialClassesRespVO();
respVO.setId(1L);
respVO.setParentId(0L);
respVO.setCode("CLS001");
respVO.setName("原材料");
respVO.setLevel(1L);
respVO.setRemark("顶级分类");
respVO.setCreateTime(LocalDateTime.now());
return respVO;
}
@Test
void createMaterialClasses_shouldForwardToServiceAndReturnConvertedDto() {
MaterialClassesSaveReqDTO reqDTO = buildSaveReq();
MaterialClassesRespVO serviceResp = buildRespVO();
when(materialClassesService.createMaterialClasses(any(MaterialClassesSaveReqVO.class)))
.thenReturn(serviceResp);
CommonResult<MaterialClassesRespDTO> result = api.createMaterialClasses(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getName()).isEqualTo("原材料");
ArgumentCaptor<MaterialClassesSaveReqVO> captor = ArgumentCaptor.forClass(MaterialClassesSaveReqVO.class);
verify(materialClassesService).createMaterialClasses(captor.capture());
MaterialClassesSaveReqVO passed = captor.getValue();
assertThat(passed.getCode()).isEqualTo(reqDTO.getCode());
assertThat(passed.getName()).isEqualTo(reqDTO.getName());
}
@Test
void updateMaterialClasses_shouldInvokeService() {
MaterialClassesSaveReqDTO reqDTO = buildSaveReq();
CommonResult<Boolean> result = api.updateMaterialClasses(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
ArgumentCaptor<MaterialClassesSaveReqVO> captor = ArgumentCaptor.forClass(MaterialClassesSaveReqVO.class);
verify(materialClassesService).updateMaterialClasses(captor.capture());
assertThat(captor.getValue().getCode()).isEqualTo(reqDTO.getCode());
}
@Test
void deleteMaterialClasses_shouldInvokeService() {
CommonResult<Boolean> result = api.deleteMaterialClasses(5L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(materialClassesService).deleteMaterialClasses(5L);
}
@Test
void deleteMaterialClassesList_shouldInvokeService() {
List<Long> ids = List.of(3L, 4L);
CommonResult<Boolean> result = api.deleteMaterialClassesList(ids);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData()).isTrue();
verify(materialClassesService).deleteMaterialClassesListByIds(ids);
}
@Test
void getMaterialClasses_shouldConvertDoToDto() {
MaterialClassesDO classesDO = new MaterialClassesDO();
classesDO.setId(7L);
classesDO.setName("辅料");
when(materialClassesService.getMaterialClasses(7L)).thenReturn(classesDO);
CommonResult<MaterialClassesRespDTO> result = api.getMaterialClasses(7L);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getId()).isEqualTo(7L);
assertThat(result.getData().getName()).isEqualTo("辅料");
}
@Test
void getMaterialClassesPage_shouldConvertPageResult() {
MaterialClassesDO classesDO = new MaterialClassesDO();
classesDO.setId(8L);
classesDO.setName("辅料");
PageResult<MaterialClassesDO> page = new PageResult<>(List.of(classesDO), 1L);
when(materialClassesService.getMaterialClassesPage(any(MaterialClassesPageReqVO.class)))
.thenReturn(page);
MaterialClassesPageReqDTO reqDTO = new MaterialClassesPageReqDTO();
reqDTO.setName("辅料");
CommonResult<PageResult<MaterialClassesRespDTO>> result = api.getMaterialClassesPage(reqDTO);
assertThat(result.isSuccess()).isTrue();
assertThat(result.getData().getList()).hasSize(1);
assertThat(result.getData().getList().get(0).getName()).isEqualTo("辅料");
assertThat(result.getData().getTotal()).isEqualTo(1L);
}
@Test
void getMaterialClassesTree_shouldAssembleHierarchy() {
MaterialClassesDO root = new MaterialClassesDO();
root.setId(1L);
root.setParentId(0L);
root.setName("根节点");
MaterialClassesDO child = new MaterialClassesDO();
child.setId(2L);
child.setParentId(1L);
child.setName("子节点");
MaterialClassesDO orphan = new MaterialClassesDO();
orphan.setId(3L);
orphan.setParentId(99L);
orphan.setName("孤儿节点");
when(materialClassesService.getMaterialClassesList()).thenReturn(List.of(child, root, orphan));
CommonResult<List<MaterialClassesTreeRespDTO>> result = api.getMaterialClassesTree();
assertThat(result.isSuccess()).isTrue();
List<MaterialClassesTreeRespDTO> tree = result.getData();
assertThat(tree).hasSize(2);
MaterialClassesTreeRespDTO rootNode = tree.get(0);
assertThat(rootNode.getId()).isEqualTo(1L);
assertThat(rootNode.getChildren()).hasSize(1);
assertThat(rootNode.getChildren().get(0).getId()).isEqualTo(2L);
MaterialClassesTreeRespDTO orphanNode = tree.get(1);
assertThat(orphanNode.getId()).isEqualTo(3L);
assertThat(orphanNode.getChildren()).isEmpty();
}
}