From 8dcf15d0f914f042a24b12fb56dc614a2bd5deef Mon Sep 17 00:00:00 2001 From: xuguang Date: Tue, 4 Jan 2022 17:29:28 +0800 Subject: [PATCH] =?UTF-8?q?kafka-manager-bpm=E5=8C=85=E5=8D=95=E5=85=83?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=E7=9A=84=E7=BC=96=E5=86=99=20&=20bugfix?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../manager/bpm/impl/OrderServiceImpl.java | 4 +- .../manager/bpm/order/impl/ApplyAppOrder.java | 3 + .../bpm/order/impl/DeleteTopicOrder.java | 5 + .../kafka/manager/bpm/OrderServiceTest.java | 258 ++++++++++++- .../manager/bpm/order/ApplyAppOrderTest.java | 136 +++++++ .../bpm/order/ApplyAuthorityOrderTest.java | 343 ++++++++++++++++++ .../bpm/order/ApplyClusterOrderTest.java | 107 ++++++ .../bpm/order/ApplyPartitionOrderTest.java | 215 +++++++++++ .../bpm/order/ApplyQuotaOrderTest.java | 316 ++++++++++++++++ .../bpm/order/ApplyTopicOrderTest.java | 338 +++++++++++++++++ .../manager/bpm/order/DeleteAppOrderTest.java | 209 +++++++++++ .../bpm/order/DeleteAuthorityOrderTest.java | 186 ++++++++++ .../bpm/order/DeleteClusterOrderTest.java | 132 +++++++ .../bpm/order/DeleteTopicOrderTest.java | 269 ++++++++++++++ .../bpm/order/ModifyClusterOrderTest.java | 109 ++++++ .../order/ModifyGatewayConfigOrderTest.java | 158 ++++++++ .../order/ThirdPartDeleteTopicOrderTest.java | 322 ++++++++++++++++ 17 files changed, 3107 insertions(+), 3 deletions(-) create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAppOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAuthorityOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyClusterOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyPartitionOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyQuotaOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyTopicOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAppOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAuthorityOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteClusterOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteTopicOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyClusterOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyGatewayConfigOrderTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ThirdPartDeleteTopicOrderTest.java diff --git a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/impl/OrderServiceImpl.java b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/impl/OrderServiceImpl.java index 71c05163..dda42507 100644 --- a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/impl/OrderServiceImpl.java +++ b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/impl/OrderServiceImpl.java @@ -215,7 +215,7 @@ public class OrderServiceImpl implements OrderService { } catch (Exception e) { LOGGER.error("get wait deal order failed.", e); } - return null; + return Collections.emptyList(); } @Override @@ -225,7 +225,7 @@ public class OrderServiceImpl implements OrderService { } catch (Exception e) { LOGGER.error("get passed order failed, startTime:{}.", startTime, e); } - return null; + return Collections.emptyList(); } private TopicDO getTopicDOFromCacheOrDB(Long physicalClusterId, diff --git a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/ApplyAppOrder.java b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/ApplyAppOrder.java index 1528ada8..f0ceeade 100644 --- a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/ApplyAppOrder.java +++ b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/ApplyAppOrder.java @@ -39,6 +39,9 @@ public class ApplyAppOrder extends AbstractAppOrder { } OrderDetailApplyAppDTO orderDetailDTO = new OrderDetailApplyAppDTO(); + if (ValidateUtils.isNull(orderExtensionDTO)) { + return orderDetailDTO; + } orderDetailDTO.setName(orderExtensionDTO.getName()); orderDetailDTO.setPrincipals(orderExtensionDTO.getPrincipals()); AppDO appDO = appService.getByName(orderExtensionDTO.getName()); diff --git a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/DeleteTopicOrder.java b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/DeleteTopicOrder.java index 58627c39..5056e51c 100644 --- a/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/DeleteTopicOrder.java +++ b/kafka-manager-extends/kafka-manager-bpm/src/main/java/com/xiaojukeji/kafka/manager/bpm/order/impl/DeleteTopicOrder.java @@ -62,6 +62,9 @@ public class DeleteTopicOrder extends AbstractTopicOrder { OrderExtensionDeleteTopicDTO.class); orderDetailDTO.setTopicName(orderExtensionDTO.getTopicName()); ClusterNameDTO clusterNameDTO = clusterService.getClusterName(orderExtensionDTO.getClusterId()); + if(ValidateUtils.isNull(clusterNameDTO)) { + return orderDetailDTO; + } orderDetailDTO.setLogicalClusterId(clusterNameDTO.getLogicalClusterId()); orderDetailDTO.setLogicalClusterName(clusterNameDTO.getLogicalClusterName()); orderDetailDTO.setPhysicalClusterId(clusterNameDTO.getPhysicalClusterId()); @@ -129,6 +132,8 @@ public class DeleteTopicOrder extends AbstractTopicOrder { if (!PhysicalClusterMetadataManager.isTopicExistStrictly(physicalClusterId, extensionDTO.getTopicName())) { return ResultStatus.TOPIC_NOT_EXIST; } + + // 最近topic是否还有生产或者消费操作 if (connectionService.isExistConnection( physicalClusterId, extensionDTO.getTopicName(), diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/OrderServiceTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/OrderServiceTest.java index 5435ec2a..c4f32c3f 100644 --- a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/OrderServiceTest.java +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/OrderServiceTest.java @@ -1,8 +1,264 @@ package com.xiaojukeji.kafka.manager.bpm; +import com.xiaojukeji.kafka.manager.account.AccountService; +import com.xiaojukeji.kafka.manager.bpm.common.OrderResult; +import com.xiaojukeji.kafka.manager.bpm.common.OrderStatusEnum; +import com.xiaojukeji.kafka.manager.bpm.common.OrderTypeEnum; +import com.xiaojukeji.kafka.manager.bpm.common.entry.apply.OrderDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBatchDTO; +import com.xiaojukeji.kafka.manager.bpm.component.AbstractOrderStorageService; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Arrays; +import java.util.Date; +import java.util.List; + /** * @author xuguang * @Date 2021/12/27 */ -public class OrderServiceTest { +public class OrderServiceTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest2\",\"appId\":\"dkm_admin\",\"peakBytesIn\":104857600000}"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + private static final Integer ORDER_REFUSED_STATUS = 2; + + @Autowired + @InjectMocks + private OrderService orderService; + + @Mock + private AbstractOrderStorageService orderStorageService; + + @Mock + private AccountService accountService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDTO getOrderDTO() { + OrderDTO orderDTO = new OrderDTO(); + orderDTO.setApplicant(ADMIN); + orderDTO.setType(APPLY_TOPIC_TYPE); + orderDTO.setExtensions(EXTENSIONS); + orderDTO.setDescription("测试用测试用"); + return orderDTO; + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setDetail(""); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setOpinion(""); + return orderHandleBaseDTO; + } + + @Test(description = "测试创建工单") + public void createOrder() { + // paramIllegal + createOrder2ParamIllegal(); + // checkExtensionFieldsAndGenerateTitle false + createOrder2Success(); + // mysql error + createOrder2MysqlError(); + } + + private void createOrder2ParamIllegal() { + Result order1 = orderService.createOrder(null); + Assert.assertEquals(order1.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + + OrderDTO orderDTO = getOrderDTO(); + orderDTO.setType(INVALID_ORDER_TYPE); + Result order2 = orderService.createOrder(orderDTO); + Assert.assertEquals(order2.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void createOrder2Success() { + Mockito.when(orderStorageService.save(Mockito.any())).thenReturn(true); + + OrderDTO orderDTO = getOrderDTO(); + Result order2 = orderService.createOrder(orderDTO); + Assert.assertEquals(order2.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void createOrder2MysqlError() { + Mockito.when(orderStorageService.save(Mockito.any())).thenReturn(false); + + OrderDTO orderDTO = getOrderDTO(); + Result order2 = orderService.createOrder(orderDTO); + Assert.assertEquals(order2.getCode(), ResultStatus.MYSQL_ERROR.getCode()); + } + + @Test(description = "测试工单详情") + public void getOrderDetailDataTest() { + // order not exist + getOrderDetailData2OrderNotExistTest(); + // param illegal + getOrderDetailData2ParamIllegalTest(); + // success + getOrderDetailData2SuccessTest(); + } + + private void getOrderDetailData2OrderNotExistTest() { + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(null); + + Result orderDetailData = orderService.getOrderDetailData(ORDER_ID); + Assert.assertEquals(orderDetailData.getCode(), ResultStatus.ORDER_NOT_EXIST.getCode()); + } + + private void getOrderDetailData2ParamIllegalTest() { + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(new OrderDO()); + + Result orderDetailData = orderService.getOrderDetailData(ORDER_ID); + Assert.assertEquals(orderDetailData.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void getOrderDetailData2SuccessTest() { + OrderDO orderDO = getOrderDO(); + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(orderDO); + + Result orderDetailData = orderService.getOrderDetailData(ORDER_ID); + Assert.assertEquals(orderDetailData.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "测试处理工单") + public void handleOrderTest() { + // paramIllegal + handleOrder2ParamIllegalTest(); + // orderNotExist + handleOrder2OrderNotExistTest(); + // orderAlreadyHandled, + // SpringTool.getUserName() 需要构建上下文对象 + handleOrder2OrderAlreadyHandledTest(); + } + + private void handleOrder2ParamIllegalTest() { + ResultStatus result1 = orderService.handleOrder(null); + Assert.assertEquals(result1.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + + OrderDO orderDO = getOrderDO(); + orderDO.setType(INVALID_ORDER_TYPE); + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(orderDO); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus result2 = orderService.handleOrder(orderHandleBaseDTO); + Assert.assertEquals(result2.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void handleOrder2OrderNotExistTest() { + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(null); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus result2 = orderService.handleOrder(orderHandleBaseDTO); + Assert.assertEquals(result2.getCode(), ResultStatus.ORDER_NOT_EXIST.getCode()); + } + + private void handleOrder2OrderAlreadyHandledTest() { + OrderDO orderDO = getOrderDO(); + Mockito.when(orderStorageService.getById(Mockito.anyLong())).thenReturn(orderDO); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus result2 = orderService.handleOrder(orderHandleBaseDTO); + Assert.assertEquals(result2.getCode(), ResultStatus.ORDER_ALREADY_HANDLED.getCode()); + } + + @Test(description = "测试获取全部的工单审核列表") + public void getApprovalListTest() { + Mockito.when(accountService.isAdminOrderHandler(Mockito.any())).thenReturn(false); + OrderDO orderDO = getOrderDO(); + Mockito.when(orderStorageService.getByApproverAndStatus(Mockito.anyString(), Mockito.any())) + .thenReturn(Arrays.asList(orderDO)); + + } + + @Test + public void handleOrderBatchTest() { + // 要通过所有审批 + handleOrderBatchWithPassedTest(); + // 要拒绝所有审批 + handleOrderBatchWithRefusedTest(); + } + + private void handleOrderBatchWithPassedTest() { + /* + 构造数据，尽量走handleOrderBatch的每个流程 + */ + OrderDO orderDO1 = getOrderDO(); + Mockito.when(orderStorageService.getById(ORDER_ID)).thenReturn(orderDO1); + Mockito.when(orderStorageService.getById(INVALID_ORDER_ID)).thenReturn(null); + + OrderDO orderDO2 = getOrderDO(); + orderDO2.setId(2L); + orderDO2.setType(OrderTypeEnum.APPLY_APP.getCode()); + Mockito.when(orderStorageService.getById(2L)).thenReturn(orderDO2); + + OrderHandleBatchDTO orderHandleBatchDTO = new OrderHandleBatchDTO(); + orderHandleBatchDTO.setStatus(OrderStatusEnum.PASSED.getCode()); + orderHandleBatchDTO.setOrderIdList(Arrays.asList(ORDER_ID, INVALID_ORDER_ID, 2L)); + List orderResults = orderService.handleOrderBatch(orderHandleBatchDTO, ADMIN); + Assert.assertFalse(orderResults.isEmpty()); + } + + private void handleOrderBatchWithRefusedTest() { + /* + 构造数据，尽量走handleOrderBatch的每个流程 + */ + OrderDO orderDO1 = getOrderDO(); + Mockito.when(orderStorageService.getById(ORDER_ID)).thenReturn(orderDO1); + Mockito.when(orderStorageService.getById(INVALID_ORDER_ID)).thenReturn(null); + + OrderDO orderDO2 = getOrderDO(); + orderDO2.setId(2L); + orderDO2.setType(OrderTypeEnum.APPLY_APP.getCode()); + Mockito.when(orderStorageService.getById(2L)).thenReturn(orderDO2); + + OrderHandleBatchDTO orderHandleBatchDTO = new OrderHandleBatchDTO(); + orderHandleBatchDTO.setStatus(OrderStatusEnum.REFUSED.getCode()); + orderHandleBatchDTO.setOrderIdList(Arrays.asList(ORDER_ID, INVALID_ORDER_ID, 2L)); + List orderResults = orderService.handleOrderBatch(orderHandleBatchDTO, ADMIN); + Assert.assertFalse(orderResults.isEmpty()); + } + } diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAppOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAppOrderTest.java new file mode 100644 index 00000000..74419c1b --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAppOrderTest.java @@ -0,0 +1,136 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.AbstractOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailApplyAppDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.utils.ConfigUtils; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/29 + */ +public class ApplyAppOrderTest extends BaseTest { + + private static final String EXTENSIONS = "{\"name\":\"dkm_admin\",\"idc\":\"country\",\"principals\":\"admin\"}"; + + private static final Long ORDER_ID = 1L; + + private static final String ADMIN = "admin"; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + private static final String APP_ID = "dkm_admin"; + + @Autowired + @Qualifier("applyAppOrder") + @InjectMocks + private AbstractOrder applyAppOrder; + + @Mock + private AppService appService; + + @Mock + private ConfigUtils configUtils; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // resourceAlreadyExist + checkExtensionFieldsAndGenerateTitle2ResourceAlreadyExistTest(); + // idc not exist + checkExtensionFieldsAndGenerateTitle2IdcNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = applyAppOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ResourceAlreadyExistTest() { + Mockito.when(appService.getByName(Mockito.any())).thenReturn(new AppDO()); + + Result result = applyAppOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.RESOURCE_ALREADY_EXISTED.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2IdcNotExistTest() { + Mockito.when(appService.getByName(Mockito.any())).thenReturn(null); + Mockito.when(configUtils.getIdc()).thenReturn(""); + + Result result = applyAppOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.IDC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(appService.getByName(Mockito.any())).thenReturn(null); + Mockito.when(configUtils.getIdc()).thenReturn("country"); + + Result result = applyAppOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "") + public void handleOrderDetailTest() { + Mockito.when(appService.addApp(Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAppOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "") + public void getOrderExtensionDetailDataTest() { + AppDO appDO = new AppDO(); + appDO.setAppId(APP_ID); + appDO.setPassword("password"); + Mockito.when(appService.getByName(Mockito.any())).thenReturn(appDO); + OrderDetailApplyAppDTO data = (OrderDetailApplyAppDTO) applyAppOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertEquals(data.getAppId(), APP_ID); + } +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAuthorityOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAuthorityOrderTest.java new file mode 100644 index 00000000..5e1d5559 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyAuthorityOrderTest.java @@ -0,0 +1,343 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.account.AccountService; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailApplyAuthorityDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.ao.account.Account; +import com.xiaojukeji.kafka.manager.common.entity.pojo.LogicalClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.TopicDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.TopicManagerService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AuthorityService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Date; +import java.util.List; + +/** + * @author xuguang + * @Date 2021/12/29 + */ +public class ApplyAuthorityOrderTest extends BaseTest { + + private final static String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest\",\"appId\":\"dkm_admin\",\"access\":\"3\"}"; + + private final static String TOPIC_NOT_EXIST_EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"xxxx\",\"appId\":\"dkm_admin\",\"access\":\"3\"}"; + + private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private static final Long ORDER_ID = 1L; + + private static final String ADMIN = "admin"; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final String APP_ID = "dkm_admin"; + + private static final String INVALIDE_USER = "xxxx"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + @Autowired + @Qualifier("applyAuthorityOrder") + @InjectMocks + private AbstractOrder applyAuthorityOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private AppService appService; + + @Mock + private TopicManagerService topicManagerService; + + @Mock + private AccountService accountService; + + @Mock + private AuthorityService authorityService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setId(4L); + appDO.setAppId(APP_ID); + appDO.setName("moduleTestApp"); + appDO.setPassword("moduleTestApp"); + appDO.setType(1); + appDO.setApplicant(ADMIN); + appDO.setPrincipals(ADMIN); + appDO.setDescription("moduleTestApp"); + appDO.setCreateTime(new Date()); + appDO.setModifyTime(new Date()); + return appDO; + } + + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest(); + // topic not exist + checkExtensionFieldsAndGenerateTitle2TopicNotExistTest(); + // app not exist + checkExtensionFieldsAndGenerateTitle2AppNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = applyAuthorityOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + Result result = applyAuthorityOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = applyAuthorityOrder.checkExtensionFieldsAndGenerateTitle(TOPIC_NOT_EXIST_EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2AppNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + Result result = applyAuthorityOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + + Result result = applyAuthorityOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void checkAuthorityTest() { + // JsonParseError + checkAuthority2JsonParseErrorTest(); + // cluster not exist + checkAuthority2ClusterNotExistTest(); + // topic not exist + checkAuthority2TopicNotExistTest(); + // user without authority + checkAuthority2UserWithoutAuthorityTest(); + // success + checkAuthority2SuccessTest(); + } + + private void checkAuthority2JsonParseErrorTest() { + OrderDO orderDO = getOrderDO(); + orderDO.setExtensions("{"); + ResultStatus resultStatus = applyAuthorityOrder.checkAuthority(orderDO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.JSON_PARSER_ERROR.getCode()); + } + + private void checkAuthority2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.checkAuthority(orderDO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkAuthority2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.checkAuthority(orderDO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_BIZ_DATA_NOT_EXIST.getCode()); + } + + private void checkAuthority2UserWithoutAuthorityTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + AppDO appDO = new AppDO(); + appDO.setPrincipals(""); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.checkAuthority(orderDO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.USER_WITHOUT_AUTHORITY.getCode()); + } + + private void checkAuthority2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + AppDO appDO = new AppDO(); + appDO.setPrincipals(ADMIN); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.checkAuthority(orderDO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getApproverListTest() { + // emptyList + getApproverList2EmptyListTest(); + // not empty list + getApproverList2NotEmptyListTest(); + } + + private void getApproverList2EmptyListTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(null); + List approverList = applyAuthorityOrder.getApproverList(EXTENSIONS); + Assert.assertTrue(approverList.isEmpty()); + + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + List approverList2 = applyAuthorityOrder.getApproverList(EXTENSIONS); + Assert.assertTrue(approverList2.isEmpty()); + } + + private void getApproverList2NotEmptyListTest() { + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + AppDO appDO = getAppDO(); + appDO.setPrincipals(ADMIN + "," + INVALIDE_USER); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + Mockito.when(accountService.getAccountFromCache(ADMIN)).thenReturn(new Account()); + Mockito.when(accountService.getAccountFromCache(INVALIDE_USER)).thenReturn(null); + + List approverList = applyAuthorityOrder.getApproverList(EXTENSIONS); + Assert.assertFalse(approverList.isEmpty()); + } + + @Test + public void handleOrderDetailTest() { + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // operationFailed + handleOrderDetail2OperationFailedTest(); + // success + handleOrderDetail2SuccessTest(); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationFailedTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(authorityService.addAuthorityAndQuota(Mockito.any(), Mockito.any())).thenReturn(-1); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FAILED.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(authorityService.addAuthorityAndQuota(Mockito.any(), Mockito.any())).thenReturn(1); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = applyAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + // app is null + getOrderExtensionDetailData2AppIsNullTest(); + // app is not null + getOrderExtensionDetailData2AppNotNullTest(); + } + + private void getOrderExtensionDetailData2AppIsNullTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + LogicalClusterDO logicalClusterDO = new LogicalClusterDO(); + logicalClusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + logicalClusterDO.setName(""); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster(Mockito.anyLong())).thenReturn(logicalClusterDO); + OrderDetailApplyAuthorityDTO data = (OrderDetailApplyAuthorityDTO) applyAuthorityOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNull(data.getAppName()); + } + + private void getOrderExtensionDetailData2AppNotNullTest() { + AppDO appDO = getAppDO(); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + LogicalClusterDO logicalClusterDO = new LogicalClusterDO(); + logicalClusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + logicalClusterDO.setName(""); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster(Mockito.anyLong())).thenReturn(logicalClusterDO); + OrderDetailApplyAuthorityDTO data = (OrderDetailApplyAuthorityDTO) applyAuthorityOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNotNull(data.getAppName()); + Assert.assertEquals(data.getAppName(), appDO.getName()); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyClusterOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyClusterOrderTest.java new file mode 100644 index 00000000..54130c13 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyClusterOrderTest.java @@ -0,0 +1,107 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailApplyClusterDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.utils.ConfigUtils; +import org.junit.Assert; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +/** + * @author xuguang + * @Date 2021/12/30 + */ +public class ApplyClusterOrderTest extends BaseTest { + + private final static String APP_ID = "dkm_admin"; + + private final static String IDC = "国内"; + + private final static String EXTENSIONS = "{\"idc\":\"国内\",\"bytesIn\":2000,\"mode\":200,\"appId\":\"dkm_admin\"}"; + + private final static String INVALID_IDC = "xxx"; + + private final static String ADMIN = "admin"; + + @Autowired + @Qualifier("applyClusterOrder") + @InjectMocks + private AbstractOrder applyClusterOrder; + + @Mock + private AppService appService; + + @Mock + private ConfigUtils configUtils; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // app not exist + checkExtensionFieldsAndGenerateTitle2AppNotExistTest(); + // idc not exist + checkExtensionFieldsAndGenerateTitle2IdcNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = applyClusterOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2AppNotExistTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + Result result = applyClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2IdcNotExistTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(configUtils.getIdc()).thenReturn(INVALID_IDC); + + Result result = applyClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.IDC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(configUtils.getIdc()).thenReturn(IDC); + + Result result = applyClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + OrderDetailApplyClusterDTO data = (OrderDetailApplyClusterDTO) applyClusterOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertEquals(data.getAppId(), APP_ID); + Assert.assertEquals(data.getIdc(), IDC); + } + + @Test + public void handleOrderDetail() { + ResultStatus resultStatus = applyClusterOrder.handleOrderDetail(new OrderDO(), new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyPartitionOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyPartitionOrderTest.java new file mode 100644 index 00000000..cbc01da0 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyPartitionOrderTest.java @@ -0,0 +1,215 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.AbstractOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.PartitionOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.LogicalClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.AdminService; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/30 + */ +public class ApplyPartitionOrderTest extends BaseTest { + + private final static String EXTENSIONS = "{\"clusterId\":1,\"topicName\":\"moduleTest\",\"needIncrPartitionNum\":20}"; + + private final static String INVALIDE_TOPIC_EXTENSIONS = "{\"clusterId\":1,\"topicName\":\"xxxx\",\"needIncrPartitionNum\":20}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"regionId\":1}"; + + private static final String INVALIDE_APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":0,\"regionId\":1}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + @Autowired + @Qualifier("applyPartitionOrder") + @InjectMocks + private AbstractOrder applyPartitionOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private AdminService adminService; + + @Mock + private ClusterService clusterService; + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setDetail(APPROVE_ORDER_APPLY_DETAIL); + return orderHandleBaseDTO; + } + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest(); + // topic not exist + checkExtensionFieldsAndGenerateTitle2TopicNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result stringResult = applyPartitionOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(stringResult.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(null); + + Result stringResult = applyPartitionOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(stringResult.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + Result stringResult = applyPartitionOrder.checkExtensionFieldsAndGenerateTitle(INVALIDE_TOPIC_EXTENSIONS); + Assert.assertEquals(stringResult.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + Result stringResult = applyPartitionOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(stringResult.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetailTest() { + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // topic not exist + handleOrderDetail2TopicNotExistTest(); + // operation failed + handleOrderDetail2OperationFailedTest(); + // success + handleOrderDetail2SuccessTest(); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyPartitionOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + OrderDO orderDO = getOrderDO(); + orderDO.setExtensions(INVALIDE_TOPIC_EXTENSIONS); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyPartitionOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationFailedTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + orderHandleBaseDTO.setDetail(INVALIDE_APPROVE_ORDER_APPLY_DETAIL); + ResultStatus resultStatus = applyPartitionOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FAILED.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(adminService.expandPartitions( + Mockito.any(), Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyPartitionOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + LogicalClusterDO logicalCluster = new LogicalClusterDO(); + logicalCluster.setId(REAL_CLUSTER_ID_IN_MYSQL); + logicalCluster.setName(""); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster( + Mockito.anyLong(), Mockito.any())).thenReturn(logicalCluster); + + ClusterDO clusterDO = new ClusterDO(); + clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + clusterDO.setClusterName(""); + Mockito.when(clusterService.getById(Mockito.any())).thenReturn(clusterDO); + PartitionOrderDetailData data2 = (PartitionOrderDetailData) applyPartitionOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data2); + Assert.assertNotNull(data2.getPhysicalClusterId()); + Assert.assertNotNull(data2.getLogicalClusterId()); + } +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyQuotaOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyQuotaOrderTest.java new file mode 100644 index 00000000..1bd3df20 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyQuotaOrderTest.java @@ -0,0 +1,316 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.OrderService; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.QuotaOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.LogicalClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.AdminService; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.RegionService; +import com.xiaojukeji.kafka.manager.service.service.TopicManagerService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.QuotaService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Arrays; +import java.util.Collections; +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/30 + */ +public class ApplyQuotaOrderTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"appId\":\"dkm_admin\",\"clusterId\":7,\"partitionNum\":2,\"produceQuota\":104857600,\"consumeQuota\":104857600,\"regionId\":1,\"topicName\":\"moduleTest\",\"brokerIdList\":[3]}"; + + private static final String TOPIC_NOT_EXIST_EXTENSIONS = "{\"appId\":\"dkm_admin\",\"clusterId\":7,\"partitionNum\":2,\"produceQuota\":104857600,\"consumeQuota\":104857600,\"regionId\":1,\"retentionTime\":12,\"topicName\":\"xxx\",\"brokerIdList\":[3]}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"regionId\":1}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + + @Autowired + @Qualifier("applyQuotaOrder") + @InjectMocks + private AbstractOrder applyQuotaOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private AdminService adminService; + + @Mock + private ClusterService clusterService; + + @Mock + private AppService appService; + + @Mock + private OrderService orderService; + + @Mock + private QuotaService quotaService; + + @Mock + private TopicManagerService topicManagerService; + + @Mock + private RegionService regionService; + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setDetail(APPROVE_ORDER_APPLY_DETAIL); + return orderHandleBaseDTO; + } + + private LogicalClusterDO getLogicalClusterDO() { + LogicalClusterDO logicalClusterDO = new LogicalClusterDO(); + logicalClusterDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL); + logicalClusterDO.setIdentification("moduleTestLogicalCluster"); + logicalClusterDO.setName("moduleTestLogicalCluster"); + logicalClusterDO.setMode(0); + logicalClusterDO.setRegionList("2,3"); + logicalClusterDO.setAppId(""); + logicalClusterDO.setGmtCreate(new Date()); + logicalClusterDO.setGmtModify(new Date()); + return logicalClusterDO; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setId(4L); + appDO.setAppId("moduleTestAppId"); + appDO.setName("moduleTestApp"); + appDO.setPassword("moduleTestApp"); + appDO.setType(1); + appDO.setApplicant("admin"); + appDO.setPrincipals("admin"); + appDO.setDescription("moduleTestApp"); + appDO.setCreateTime(new Date(1638786493173L)); + appDO.setModifyTime(new Date(1638786493173L)); + return appDO; + } + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test(description = "测试检查扩展字段并生成工单的Title") + public void checkExtensionFieldsAndGenerateTitle() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegal(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExist(); + // topic not exist + checkExtensionFieldsAndGenerateTitle2TopicNotExist(); + // app not exist + checkExtensionFieldsAndGenerateTitle2AppNotExist(); + // success + checkExtensionFieldsAndGenerateTitle2Success(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal() { + Result result = applyQuotaOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + Result result = applyQuotaOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = applyQuotaOrder.checkExtensionFieldsAndGenerateTitle(TOPIC_NOT_EXIST_EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2AppNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + Result result = applyQuotaOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2Success() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + + Result result = applyQuotaOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetail() { + // app not exist + handleOrderDetail2AppNotExist(); + // cluster not exist + handleOrderDetail2ClusterNotExist(); + // topic not exist + handleOrderDetail2TopicNotExist(); + // operation fobidden + handleOrderDetail2OperationFobiddenTest(); + // success + handleOrderDetail2SuccessTest(); + // + handleOrderDetail2OperationFailedTest(); + } + + private void handleOrderDetail2AppNotExist() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2ClusterNotExist() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2TopicNotExist() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + OrderDO orderDO = getOrderDO(); + orderDO.setExtensions(TOPIC_NOT_EXIST_EXTENSIONS); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationFobiddenTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(adminService.expandPartitions( + Mockito.any(), Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.OPERATION_FORBIDDEN); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(adminService.expandPartitions( + Mockito.any(), Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + Mockito.when(quotaService.addTopicQuota(Mockito.any())).thenReturn(1); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void handleOrderDetail2OperationFailedTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(adminService.expandPartitions( + Mockito.any(), Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + Mockito.when(quotaService.addTopicQuota(Mockito.any())).thenReturn(0); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyQuotaOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + @Test + public void getOrderExtensionDetailData() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + AppDO appDO = getAppDO(); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + Mockito.when(topicManagerService.getTopicStatistic( + Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + Mockito.when(regionService.getRegionListByTopicName(Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + ClusterDO clusterDO = new ClusterDO(); + clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + clusterDO.setClusterName(""); + Mockito.when(clusterService.getById(Mockito.any())).thenReturn(clusterDO); + LogicalClusterDO logicalClusterDO = new LogicalClusterDO(); + logicalClusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + logicalClusterDO.setName(""); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster( + Mockito.anyLong(), Mockito.any())).thenReturn(logicalClusterDO); + + QuotaOrderDetailData data = (QuotaOrderDetailData) applyQuotaOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertEquals(data.getLogicalClusterId(), REAL_CLUSTER_ID_IN_MYSQL); + } +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyTopicOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyTopicOrderTest.java new file mode 100644 index 00000000..4dcbc99a --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ApplyTopicOrderTest.java @@ -0,0 +1,338 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.OrderService; +import com.xiaojukeji.kafka.manager.bpm.common.OrderStatusEnum; +import com.xiaojukeji.kafka.manager.bpm.common.entry.BaseOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.AbstractOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailApplyTopicDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.LogicalClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.AdminService; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/27 + */ +public class ApplyTopicOrderTest extends BaseTest { + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest2\",\"appId\":\"dkm_admin\",\"peakBytesIn\":104857600000}"; + + private static final String TOPIC_EXIST_EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest\",\"appId\":\"dkm_admin\",\"peakBytesIn\":104857600000}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"replicaNum\":1,\"retentionTime\":12}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + + @Autowired + @Qualifier("applyTopicOrder") + @InjectMocks + private AbstractTopicOrder applyTopicOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private AdminService adminService; + + @Mock + private ClusterService clusterService; + + @Mock + private AppService appService; + + @Mock + private OrderService orderService; + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setDetail(APPROVE_ORDER_APPLY_DETAIL); + return orderHandleBaseDTO; + } + + private LogicalClusterDO getLogicalClusterDO() { + LogicalClusterDO logicalClusterDO = new LogicalClusterDO(); + logicalClusterDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL); + logicalClusterDO.setIdentification("moduleTestLogicalCluster"); + logicalClusterDO.setName("moduleTestLogicalCluster"); + logicalClusterDO.setMode(0); + logicalClusterDO.setRegionList("2,3"); + logicalClusterDO.setAppId(""); + logicalClusterDO.setGmtCreate(new Date()); + logicalClusterDO.setGmtModify(new Date()); + return logicalClusterDO; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setId(4L); + appDO.setAppId("moduleTestAppId"); + appDO.setName("moduleTestApp"); + appDO.setPassword("moduleTestApp"); + appDO.setType(1); + appDO.setApplicant("admin"); + appDO.setPrincipals("admin"); + appDO.setDescription("moduleTestApp"); + appDO.setCreateTime(new Date(1638786493173L)); + appDO.setModifyTime(new Date(1638786493173L)); + return appDO; + } + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test(description = "测试获取工单详情") + public void getOrderDetailTest() { + // null + getOrderDetail2NullTest(); + // success + getOrderDetail2SuccessTest(); + } + + private void getOrderDetail2NullTest() { + BaseOrderDetailData orderDetail = applyTopicOrder.getOrderDetail(null); + Assert.assertNull(orderDetail); + } + + private void getOrderDetail2SuccessTest() { + BaseOrderDetailData orderDetail = applyTopicOrder.getOrderDetail(getOrderDO()); + Assert.assertNotNull(orderDetail); + } + + + @Test + public void getOrderExtensionDetailDataTest() { + // app is null + getOrderExtensionDetailData2AppIsNullTest(); + // app is not null + getOrderExtensionDetailData2AppIsNotNullTest(); + } + + private void getOrderExtensionDetailData2AppIsNullTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + LogicalClusterDO logicalClusterDO = getLogicalClusterDO(); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster( + Mockito.anyLong(), Mockito.any())).thenReturn(logicalClusterDO); + + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + OrderDetailApplyTopicDTO data = (OrderDetailApplyTopicDTO) applyTopicOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNull(data.getAppName()); + } + + private void getOrderExtensionDetailData2AppIsNotNullTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + LogicalClusterDO logicalClusterDO = getLogicalClusterDO(); + Mockito.when(logicalClusterMetadataManager.getLogicalCluster( + Mockito.anyLong(), Mockito.any())).thenReturn(logicalClusterDO); + AppDO appDO = getAppDO(); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDetailApplyTopicDTO data = (OrderDetailApplyTopicDTO) applyTopicOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNotNull(data.getAppId()); + Assert.assertEquals(data.getAppName(), appDO.getName()); + } + + @Test(description = "测试检查扩展字段并生成工单的Title") + public void checkExtensionFieldsAndGenerateTitle() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegal(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExist(); + // topic already exist + checkExtensionFieldsAndGenerateTitle2TopicAlreadyExist(); + // success + checkExtensionFieldsAndGenerateTitle2Success(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal() { + Result result = applyTopicOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + Result result = applyTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicAlreadyExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = applyTopicOrder.checkExtensionFieldsAndGenerateTitle(TOPIC_EXIST_EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_ALREADY_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2Success() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = applyTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "测试处理具体的订单信息") + public void handleOrderDetailTest() { + // paramIllegal + handleOrderDetail2ParamIllegalTest(); + // app not exist + handleOrderDetail2AppNotExistTest(); + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // success + handleOrderDetail2SuccessTest(); + } + + private void handleOrderDetail2ParamIllegalTest() { + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + orderHandleBaseDTO.setDetail("{}"); + ResultStatus resultStatus = applyTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void handleOrderDetail2AppNotExistTest() { + OrderDO orderDO = getOrderDO(); + orderDO.setExtensions("{}"); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + + OrderDO orderDO = getOrderDO(); + orderDO.setExtensions("{\"appId\":\"dkm_admin\"}"); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + + orderDO.setExtensions("{\"appId\":\"dkm_admin\", \"clusterId\":\"-1\"}"); + ResultStatus resultStatus2 = applyTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus2.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + Mockito.when(clusterService.getById(Mockito.anyLong())).thenReturn(new ClusterDO()); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + + Mockito.when(adminService.createTopic( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()) + ).thenReturn(ResultStatus.SUCCESS); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "测试处理工单") + public void handleOrderTest() { + // not wait deal + handleOrder2OrderAlreadyHandledTest(); + // check authority and no authority + handleOrder2WithoutAuthorityTest(); + // refuse + handleOrder2RefuseTest(); + } + + private void handleOrder2OrderAlreadyHandledTest() { + OrderDO orderDO = getOrderDO(); + orderDO.setStatus(OrderStatusEnum.PASSED.getCode()); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyTopicOrder.handleOrder(orderDO, orderHandleBaseDTO, ADMIN, true); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.ORDER_ALREADY_HANDLED.getCode()); + } + + private void handleOrder2WithoutAuthorityTest() { + OrderDO orderDO = getOrderDO(); + orderDO.setStatus(OrderStatusEnum.WAIT_DEAL.getCode()); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = applyTopicOrder.handleOrder( + orderDO, orderHandleBaseDTO, + INVALID_USER_NAME, true + ); + Assert.assertNotEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void handleOrder2RefuseTest() { + Mockito.when(orderService.updateOrderById(Mockito.any())).thenReturn(1); + + OrderDO orderDO = getOrderDO(); + orderDO.setStatus(OrderStatusEnum.WAIT_DEAL.getCode()); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + orderHandleBaseDTO.setStatus(OrderStatusEnum.REFUSED.getCode()); + ResultStatus resultStatus = applyTopicOrder.handleOrder( + orderDO, orderHandleBaseDTO, + ADMIN, true + ); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAppOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAppOrderTest.java new file mode 100644 index 00000000..32b4dcad --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAppOrderTest.java @@ -0,0 +1,209 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailDeleteAppDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AuthorityDO; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AuthorityService; +import com.xiaojukeji.kafka.manager.service.service.gateway.TopicConnectionService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Arrays; +import java.util.Collections; +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/29 + */ +public class DeleteAppOrderTest extends BaseTest { + + private static final String EXTENSIONS = "{\"appId\":\"dkm_admin\"}"; + + private static final Long ORDER_ID = 1L; + + private static final String ADMIN = "admin"; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + private static final String APP_ID = "dkm_admin"; + + @Autowired + @Qualifier("deleteAppOrder") + @InjectMocks + private AbstractOrder deleteAppOrder; + + @Mock + private AppService appService; + + @Mock + private AuthorityService authorityService; + + @Mock + private TopicConnectionService connectionService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setId(4L); + appDO.setAppId("moduleTestAppId"); + appDO.setName("moduleTestApp"); + appDO.setPassword("moduleTestApp"); + appDO.setType(1); + appDO.setApplicant("admin"); + appDO.setPrincipals("admin"); + appDO.setDescription("moduleTestApp"); + appDO.setCreateTime(new Date(1638786493173L)); + appDO.setModifyTime(new Date(1638786493173L)); + return appDO; + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // app not exist + checkExtensionFieldsAndGenerateTitle2AppNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = deleteAppOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2AppNotExistTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + Result result = deleteAppOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + + Result result = deleteAppOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetailTest() { + // appNotExist + handleOrderDetail2AppNotExistTest(); + // app offline forbidden + handleOrderDetail2AppOfflineForbiddenTest(); + // success + handleOrderDetail2SuccesssTest(); + // failed + handleOrderDetail2FailedTest(); + } + + private void handleOrderDetail2AppNotExistTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAppOrder.handleOrderDetail( + orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2AppOfflineForbiddenTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(authorityService.getAuthority(Mockito.any())).thenReturn(Arrays.asList(new AuthorityDO())); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAppOrder.handleOrderDetail( + orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.APP_OFFLINE_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2SuccesssTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(authorityService.getAuthority(Mockito.any())).thenReturn(Collections.emptyList()); + Mockito.when(appService.deleteApp(Mockito.any(), Mockito.any())).thenReturn(1); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAppOrder.handleOrderDetail( + orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void handleOrderDetail2FailedTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(new AppDO()); + Mockito.when(authorityService.getAuthority(Mockito.any())).thenReturn(Collections.emptyList()); + Mockito.when(appService.deleteApp(Mockito.any(), Mockito.any())).thenReturn(-1); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAppOrder.handleOrderDetail( + orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FAILED.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + // app is null + getOrderExtensionDetailData2AppDOIsNullTest(); + // success + getOrderExtensionDetailData2SuccessTest(); + } + + private void getOrderExtensionDetailData2AppDOIsNullTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + OrderDetailDeleteAppDTO data = (OrderDetailDeleteAppDTO) deleteAppOrder.getOrderExtensionDetailData(EXTENSIONS); + + Assert.assertNotNull(data); + Assert.assertNull(data.getName()); + } + + private void getOrderExtensionDetailData2SuccessTest() { + AppDO appDO = getAppDO(); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + Mockito.when(connectionService.getByAppId( + Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + + OrderDetailDeleteAppDTO data = (OrderDetailDeleteAppDTO) deleteAppOrder.getOrderExtensionDetailData(EXTENSIONS); + + Assert.assertNotNull(data); + Assert.assertNotNull(data.getName()); + Assert.assertTrue(data.getConnectionList().isEmpty()); + } +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAuthorityOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAuthorityOrderTest.java new file mode 100644 index 00000000..dc918ed9 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteAuthorityOrderTest.java @@ -0,0 +1,186 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailDeleteAuthorityDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.common.entity.vo.normal.cluster.ClusterNameDTO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AuthorityService; +import com.xiaojukeji.kafka.manager.service.service.gateway.TopicConnectionService; +import org.junit.Assert; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/29 + */ +public class DeleteAuthorityOrderTest extends BaseTest { + + private final static String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest\",\"appId\":\"dkm_admin\",\"access\":\"3\"}"; + + private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private static final Long ORDER_ID = 1L; + + private static final String ADMIN = "admin"; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final String APP_ID = "dkm_admin"; + + private static final String INVALIDE_USER = "xxxx"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + @Autowired + @Qualifier("deleteAuthorityOrder") + @InjectMocks + private AbstractOrder deleteAuthorityOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private TopicConnectionService connectionService; + + @Mock + private AuthorityService authorityService; + + @Mock + private AppService appService; + + @Mock + private ClusterService clusterService; + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setId(4L); + appDO.setAppId(APP_ID); + appDO.setName("moduleTestApp"); + appDO.setPassword("moduleTestApp"); + appDO.setType(1); + appDO.setApplicant(ADMIN); + appDO.setPrincipals(ADMIN); + appDO.setDescription("moduleTestApp"); + appDO.setCreateTime(new Date()); + appDO.setModifyTime(new Date()); + return appDO; + } + + private ClusterNameDTO getClusterNameDTO() { + ClusterNameDTO clusterNameDTO = new ClusterNameDTO(); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setPhysicalClusterName(""); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterName(""); + return clusterNameDTO; + } + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void handleOrderDetailTest() { + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // OperationForbidden + handleOrderDetail2OperationForbiddenTest(); + // success + handleOrderDetail2SuccessTest(); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())).thenReturn(null); + OrderDO orderDO = getOrderDO(); + + ResultStatus resultStatus = deleteAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationForbiddenTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())) + .thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())) + .thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(authorityService.deleteSpecifiedAccess( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())) + .thenReturn(ResultStatus.SUCCESS); + + OrderDO orderDO = getOrderDO(); + ResultStatus resultStatus = deleteAuthorityOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + // app is null + getOrderExtensionDetailData2AppIsNullTest(); + // app is not null + getOrderExtensionDetailData2AppNotNullTest(); + } + + private void getOrderExtensionDetailData2AppIsNullTest() { + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + ClusterNameDTO clusterNameDTO = getClusterNameDTO(); + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + OrderDetailDeleteAuthorityDTO data = (OrderDetailDeleteAuthorityDTO) deleteAuthorityOrder.getOrderExtensionDetailData(EXTENSIONS); + org.testng.Assert.assertNotNull(data); + org.testng.Assert.assertNull(data.getAppName()); + } + + private void getOrderExtensionDetailData2AppNotNullTest() { + AppDO appDO = getAppDO(); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + ClusterNameDTO clusterNameDTO = getClusterNameDTO(); + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + OrderDetailDeleteAuthorityDTO data = (OrderDetailDeleteAuthorityDTO) deleteAuthorityOrder.getOrderExtensionDetailData(EXTENSIONS); + org.testng.Assert.assertNotNull(data); + org.testng.Assert.assertEquals(data.getAppName(), appDO.getName()); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteClusterOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteClusterOrderTest.java new file mode 100644 index 00000000..2475488c --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteClusterOrderTest.java @@ -0,0 +1,132 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailDeleteClusterDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.vo.normal.cluster.ClusterNameDTO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; + +/** + * @author xuguang + * @Date 2021/12/30 + */ +public class DeleteClusterOrderTest extends BaseTest { + + private final static String APP_ID = "dkm_admin"; + + private final static String IDC = "国内"; + + private final static String EXTENSIONS = "{\"clusterId\":\"7\"}"; + + private final static String INVALID_IDC = "xxx"; + + private final static String ADMIN = "admin"; + + private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + @Autowired + @Qualifier("deleteClusterOrder") + @InjectMocks + private AbstractOrder deleteClusterOrder; + + @Mock + private AppService appService; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private ClusterService clusterService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = deleteClusterOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())).thenReturn(null); + Result result = deleteClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = deleteClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetailTest() { + // operation forbidden + handleOrderDetail2OperationForbiddenTest(); + // success + handleOrderDetail2SuccessTest(); + } + + private void handleOrderDetail2OperationForbiddenTest() { + Set topics = new HashSet<>(); + topics.add(""); + Mockito.when(logicalClusterMetadataManager.getTopicNameSet(Mockito.any())).thenReturn(topics); + OrderDO orderDO = new OrderDO(); + orderDO.setExtensions(EXTENSIONS); + ResultStatus resultStatus = deleteClusterOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2SuccessTest() { + Mockito.when(logicalClusterMetadataManager.getTopicNameSet(Mockito.any())).thenReturn(Collections.emptySet()); + OrderDO orderDO = new OrderDO(); + orderDO.setExtensions(EXTENSIONS); + ResultStatus resultStatus = deleteClusterOrder.handleOrderDetail(orderDO, new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + ClusterNameDTO clusterNameDTO = new ClusterNameDTO(); + clusterNameDTO.setPhysicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterName(""); + clusterNameDTO.setPhysicalClusterName(""); + + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + Mockito.when(logicalClusterMetadataManager.getTopicNameSet(Mockito.any())).thenReturn(Collections.emptySet()); + + OrderDetailDeleteClusterDTO data = (OrderDetailDeleteClusterDTO) deleteClusterOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertEquals(data.getLogicalClusterId(), REAL_CLUSTER_ID_IN_MYSQL); + Assert.assertEquals(data.getPhysicalClusterId(), REAL_CLUSTER_ID_IN_MYSQL); + } +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteTopicOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteTopicOrderTest.java new file mode 100644 index 00000000..7e091816 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/DeleteTopicOrderTest.java @@ -0,0 +1,269 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.AbstractOrderDetailData; +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailDeleteTopicDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.TopicDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.common.entity.vo.normal.cluster.ClusterNameDTO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.AdminService; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.TopicManagerService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.TopicConnectionService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Collections; +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/28 + */ +public class DeleteTopicOrderTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest\",\"appId\":\"dkm_admin\",\"peakBytesIn\":104857600000}"; + + private static final String TOPIC_NOT_EXIST_EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"xxx\",\"appId\":\"dkm_admin\",\"peakBytesIn\":104857600000}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"replicaNum\":1,\"retentionTime\":12}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private static final Long INVALID_CLUSTER_ID = -1L; + + private static final String APP_ID = "dkm_admin"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + @Autowired + @Qualifier("deleteTopicOrder") + @InjectMocks + private AbstractTopicOrder deleteTopicOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private TopicConnectionService connectionService; + + @Mock + private AdminService adminService; + + @Mock + private ClusterService clusterService; + + @Mock + private TopicManagerService topicManagerService; + + @Mock + private AppService appService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setDetail(APPROVE_ORDER_APPLY_DETAIL); + return orderHandleBaseDTO; + } + + private ClusterNameDTO getClusterNameDTO() { + ClusterNameDTO clusterNameDTO = new ClusterNameDTO(); + clusterNameDTO.setPhysicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setPhysicalClusterName("physicalClusterName"); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterName("logicalClusterName"); + return clusterNameDTO; + } + + @Test(description = "测试检查扩展字段并生成工单的Title") + public void checkExtensionFieldsAndGenerateTitle() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegal(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExist(); + // topic already exist + checkExtensionFieldsAndGenerateTitle2TopicNotExist(); + // success + checkExtensionFieldsAndGenerateTitle2Success(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal() { + Result result = deleteTopicOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong())).thenReturn(null); + Result result = deleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = deleteTopicOrder.checkExtensionFieldsAndGenerateTitle(TOPIC_NOT_EXIST_EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2Success() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = deleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "测试处理删除topic工单") + public void handleOrderDetail() { + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // topic not exist + handleOrderDetail2TopicNotExistTest(); + // operation forbidden, 因为最近topic还有生产和消费操作 + handleOrderDetail2OperationForbiddenTest(); + // delete success + handleOrderDetail2DeleteSuccessTest(); + // delete not success + handleOrderDetail2DeleteNotSuccessTest(); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = deleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(INVALID_CLUSTER_ID); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = deleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationForbiddenTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = deleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2DeleteSuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(adminService.deleteTopic(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = deleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void handleOrderDetail2DeleteNotSuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(adminService.deleteTopic(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.FAIL); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = deleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.FAIL.getCode()); + } + + @Test(description = "") + public void getOrderExtensionDetailDataTest() { + // topicDO不存在 + getOrderExtensionDetailData2TopicNotExistTest(); + // 获取成功 + getOrderExtensionDetailData2SuccessTest(); + } + + private void getOrderExtensionDetailData2TopicNotExistTest() { + ClusterNameDTO clusterNameDTO = getClusterNameDTO(); + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + Mockito.when(connectionService.getByTopicName( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(null); + + OrderDetailDeleteTopicDTO data = (OrderDetailDeleteTopicDTO)deleteTopicOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNull(data.getAppId()); + } + + private void getOrderExtensionDetailData2SuccessTest() { + ClusterNameDTO clusterNameDTO = getClusterNameDTO(); + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + Mockito.when(connectionService.getByTopicName( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + AppDO appDO = new AppDO(); + appDO.setAppId(APP_ID); + appDO.setName(""); + appDO.setPrincipals(""); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDetailDeleteTopicDTO data = (OrderDetailDeleteTopicDTO)deleteTopicOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNotNull(data.getAppId()); + Assert.assertNotNull(data.getAppName()); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyClusterOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyClusterOrderTest.java new file mode 100644 index 00000000..24a627ad --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyClusterOrderTest.java @@ -0,0 +1,109 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailModifyClusterDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.vo.normal.cluster.ClusterNameDTO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import org.junit.Assert; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +/** + * @author xuguang + * @Date 2021/12/30 + */ +public class ModifyClusterOrderTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"clusterId\":7}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + @Autowired + @Qualifier("modifyClusterOrder") + @InjectMocks + private AbstractOrder modifyClusterOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private ClusterService clusterService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegalTest(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest(); + // success + checkExtensionFieldsAndGenerateTitle2ZSuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegalTest() { + Result result = modifyClusterOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(null); + + Result result = modifyClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ZSuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + + Result result = modifyClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetailTest() { + ResultStatus resultStatus = modifyClusterOrder.handleOrderDetail(new OrderDO(), new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + ClusterNameDTO clusterNameDTO = new ClusterNameDTO(); + clusterNameDTO.setPhysicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setPhysicalClusterName(""); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterName(""); + Mockito.when(clusterService.getClusterName(Mockito.any())).thenReturn(clusterNameDTO); + OrderDetailModifyClusterDTO data = (OrderDetailModifyClusterDTO) modifyClusterOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertEquals(data.getPhysicalClusterId(), REAL_CLUSTER_ID_IN_MYSQL); + Assert.assertEquals(data.getLogicalClusterId(), REAL_CLUSTER_ID_IN_MYSQL); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyGatewayConfigOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyGatewayConfigOrderTest.java new file mode 100644 index 00000000..d748fca8 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ModifyGatewayConfigOrderTest.java @@ -0,0 +1,158 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailGatewayConfigModifyData; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.GatewayConfigDO; +import com.xiaojukeji.kafka.manager.service.service.gateway.GatewayConfigService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +/** + * @author xuguang + * @Date 2021/12/31 + */ +public class ModifyGatewayConfigOrderTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String GATEWAY_TYPE = "SD_CLUSTER_ID"; + + private static final String EXTENSIONS = "{\"id\":1,\"type\":\"SD_CLUSTER_ID\",\"name\":\"gateway\",\"value\":\"gateway\",\"description\":\"gateway\"}"; + + private static final String INVALIDE_TYPE_EXTENSIONS = "{\"id\":1,\"type\":\"xxxx\",\"name\":\"gateway\",\"value\":\"gateway\",\"description\":\"gateway\"}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"replicaNum\":1,\"retentionTime\":12}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private static final Long INVALID_CLUSTER_ID = -1L; + + private static final String APP_ID = "dkm_admin"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + + @Autowired + @Qualifier("modifyGatewayConfigOrder") + @InjectMocks + private AbstractOrder modifyGatewayConfigOrder; + + @Mock + private GatewayConfigService gatewayConfigService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + @Test + public void checkExtensionFieldsAndGenerateTitleTest() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegal1Test(); + checkExtensionFieldsAndGenerateTitle2ParamIllegal2Test(); + checkExtensionFieldsAndGenerateTitle2ParamIllegal3Test(); + checkExtensionFieldsAndGenerateTitle2ParamIllegal4Test(); + // success + checkExtensionFieldsAndGenerateTitle2SuccessTest(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal1Test() { + Result result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle("{"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal2Test() { + Result result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle("{}"); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal3Test() { + Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(null); + Result result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal4Test() { + Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(new GatewayConfigDO()); + Result result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle(INVALIDE_TYPE_EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2SuccessTest() { + Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(new GatewayConfigDO()); + Result result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void handleOrderDetailTest() { + ResultStatus resultStatus = modifyGatewayConfigOrder.handleOrderDetail(new OrderDO(), new OrderHandleBaseDTO(), ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test + public void getOrderExtensionDetailDataTest() { + // result is null + getOrderExtensionDetailData2nullTest(); + // old config is null + getOrderExtensionDetailData2OldConfigNullTest(); + // old config is not null + getOrderExtensionDetailData2OldConfigNotNullTest(); + } + + private void getOrderExtensionDetailData2nullTest() { + OrderDetailGatewayConfigModifyData data = (OrderDetailGatewayConfigModifyData) + modifyGatewayConfigOrder.getOrderExtensionDetailData("{"); + Assert.assertNull(data); + } + + private void getOrderExtensionDetailData2OldConfigNullTest() { + Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(null); + + OrderDetailGatewayConfigModifyData data = (OrderDetailGatewayConfigModifyData) + modifyGatewayConfigOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertEquals(data.getNewGatewayConfig().getType(), GATEWAY_TYPE); + } + + private void getOrderExtensionDetailData2OldConfigNotNullTest() { + GatewayConfigDO gatewayConfigDO = new GatewayConfigDO(); + String invalid_value = "xxx"; + gatewayConfigDO.setType(invalid_value); + gatewayConfigDO.setId(1L); + gatewayConfigDO.setValue(invalid_value); + gatewayConfigDO.setName(invalid_value); + gatewayConfigDO.setVersion(1L); + Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(gatewayConfigDO); + + OrderDetailGatewayConfigModifyData data = (OrderDetailGatewayConfigModifyData) + modifyGatewayConfigOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertEquals(data.getNewGatewayConfig().getType(), invalid_value); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ThirdPartDeleteTopicOrderTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ThirdPartDeleteTopicOrderTest.java new file mode 100644 index 00000000..c7206780 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/order/ThirdPartDeleteTopicOrderTest.java @@ -0,0 +1,322 @@ +package com.xiaojukeji.kafka.manager.bpm.order; + +import com.xiaojukeji.kafka.manager.bpm.common.entry.detail.OrderDetailDeleteTopicDTO; +import com.xiaojukeji.kafka.manager.bpm.common.handle.OrderHandleBaseDTO; +import com.xiaojukeji.kafka.manager.bpm.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.OrderDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.TopicDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.common.entity.vo.normal.cluster.ClusterNameDTO; +import com.xiaojukeji.kafka.manager.service.cache.LogicalClusterMetadataManager; +import com.xiaojukeji.kafka.manager.service.service.AdminService; +import com.xiaojukeji.kafka.manager.service.service.ClusterService; +import com.xiaojukeji.kafka.manager.service.service.TopicManagerService; +import com.xiaojukeji.kafka.manager.service.service.gateway.AppService; +import com.xiaojukeji.kafka.manager.service.service.gateway.TopicConnectionService; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.Collections; +import java.util.Date; + +/** + * @author xuguang + * @Date 2021/12/31 + */ +public class ThirdPartDeleteTopicOrderTest extends BaseTest { + + private static final String ADMIN = "admin"; + + private static final String INVALID_USER_NAME = "xxxxx"; + + private static final Integer INVALID_ORDER_TYPE = -1; + + private static final Integer APPLY_TOPIC_TYPE = 0; + + private static final Long ORDER_ID = 1L; + + private static final Long INVALID_ORDER_ID = -1L; + + private static final String EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"moduleTest\",\"appId\":\"dkm_admin\",\"password\":\"123456\"}"; + + private static final String TOPIC_NOT_EXIST_EXTENSIONS = "{\"clusterId\":7,\"topicName\":\"xxxx\",\"appId\":\"dkm_admin\",\"password\":\"123456\"}"; + + private static final String APPROVE_ORDER_APPLY_DETAIL = "{\"brokerIdList\":[3],\"partitionNum\":1,\"replicaNum\":1,\"retentionTime\":12}"; + + private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private static final Long INVALID_CLUSTER_ID = -1L; + + private static final String APP_ID = "dkm_admin"; + + /** + * 工单状态, 0:待审批, 1:通过, 2:拒绝, 3:取消 + */ + private static final Integer ORDER_PASSED_STATUS = 1; + + + @Autowired + @Qualifier("thirdPartDeleteTopicOrder") + @InjectMocks + private AbstractOrder thirdPartDeleteTopicOrder; + + @Mock + private LogicalClusterMetadataManager logicalClusterMetadataManager; + + @Mock + private TopicConnectionService connectionService; + + @Mock + private AdminService adminService; + + @Mock + private ClusterService clusterService; + + @Mock + private TopicManagerService topicManagerService; + + @Mock + private AppService appService; + + @BeforeMethod + public void setup() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setId(ORDER_ID); + orderDO.setType(APPLY_TOPIC_TYPE); + orderDO.setTitle("apply topic"); + orderDO.setApplicant(ADMIN); + orderDO.setDescription("测试的OrderDO"); + orderDO.setApprover(ADMIN); + orderDO.setGmtHandle(new Date()); + orderDO.setGmtCreate(new Date()); + orderDO.setExtensions(EXTENSIONS); + orderDO.setStatus(ORDER_PASSED_STATUS); + return orderDO; + } + + private OrderHandleBaseDTO getOrderHandleBaseDTO() { + OrderHandleBaseDTO orderHandleBaseDTO = new OrderHandleBaseDTO(); + orderHandleBaseDTO.setId(ORDER_ID); + orderHandleBaseDTO.setStatus(ORDER_PASSED_STATUS); + orderHandleBaseDTO.setDetail(APPROVE_ORDER_APPLY_DETAIL); + return orderHandleBaseDTO; + } + + private ClusterNameDTO getClusterNameDTO() { + ClusterNameDTO clusterNameDTO = new ClusterNameDTO(); + clusterNameDTO.setPhysicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setPhysicalClusterName("physicalClusterName"); + clusterNameDTO.setLogicalClusterId(REAL_CLUSTER_ID_IN_MYSQL); + clusterNameDTO.setLogicalClusterName("logicalClusterName"); + return clusterNameDTO; + } + + @Test(description = "测试检查扩展字段并生成工单的Title") + public void checkExtensionFieldsAndGenerateTitle() { + // paramIllegal + checkExtensionFieldsAndGenerateTitle2ParamIllegal(); + // cluster not exist + checkExtensionFieldsAndGenerateTitle2ClusterNotExist(); + // topic not exist + checkExtensionFieldsAndGenerateTitle2TopicNotExist(); + // app not exist + checkExtensionFieldsAndGenerateTitle2AppNotExist(); + // user without authority + checkExtensionFieldsAndGenerateTitle2WithoutAuthority(); + // success + checkExtensionFieldsAndGenerateTitle2Success(); + } + + private void checkExtensionFieldsAndGenerateTitle2ParamIllegal() { + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle("{}"); + org.testng.Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2ClusterNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(null); + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + org.testng.Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2TopicNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle(TOPIC_NOT_EXIST_EXTENSIONS); + org.testng.Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2AppNotExist() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + org.testng.Assert.assertEquals(result.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2WithoutAuthority() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + AppDO appDO = new AppDO(); + appDO.setPassword("xxx"); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + org.testng.Assert.assertEquals(result.getCode(), ResultStatus.USER_WITHOUT_AUTHORITY.getCode()); + } + + private void checkExtensionFieldsAndGenerateTitle2Success() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId( + Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + AppDO appDO = new AppDO(); + appDO.setPassword("123456"); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + Result result = thirdPartDeleteTopicOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS); + Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode()); + } + + @Test(description = "测试处理删除topic工单") + public void handleOrderDetail() { + // cluster not exist + handleOrderDetail2ClusterNotExistTest(); + // topic not exist + handleOrderDetail2TopicNotExistTest(); + // operation forbidden, 因为最近topic还有生产和消费操作 + handleOrderDetail2OperationForbiddenTest(); + // app not exist + handleOrderDetail2AppNotExistTest(); + // user without authority + handleOrderDetail2UserWithoutAuthorityTest(); + // delete success + handleOrderDetail2DeleteSuccessTest(); + // delete not success + handleOrderDetail2DeleteNotSuccessTest(); + } + + private void handleOrderDetail2ClusterNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.CLUSTER_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2TopicNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(INVALID_CLUSTER_ID); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2OperationForbiddenTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode()); + } + + private void handleOrderDetail2AppNotExistTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.APP_NOT_EXIST.getCode()); + } + + private void handleOrderDetail2UserWithoutAuthorityTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + AppDO appDO = new AppDO(); + appDO.setPassword("xxx"); + appDO.setPrincipals(ADMIN); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.USER_WITHOUT_AUTHORITY.getCode()); + } + + private void handleOrderDetail2DeleteSuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(adminService.deleteTopic(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.SUCCESS); + AppDO appDO = new AppDO(); + appDO.setPassword("123456"); + appDO.setPrincipals(ADMIN); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode()); + } + + private void handleOrderDetail2DeleteNotSuccessTest() { + Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong(), Mockito.any())).thenReturn(REAL_CLUSTER_ID_IN_MYSQL); + Mockito.when(connectionService.isExistConnection(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false); + Mockito.when(adminService.deleteTopic(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(ResultStatus.FAIL); + AppDO appDO = new AppDO(); + appDO.setPassword("123456"); + appDO.setPrincipals(ADMIN); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDO orderDO = getOrderDO(); + OrderHandleBaseDTO orderHandleBaseDTO = getOrderHandleBaseDTO(); + ResultStatus resultStatus = thirdPartDeleteTopicOrder.handleOrderDetail(orderDO, orderHandleBaseDTO, ADMIN); + Assert.assertEquals(resultStatus.getCode(), ResultStatus.FAIL.getCode()); + } + + @Test(description = "") + public void getOrderExtensionDetailDataTest() { + // 获取成功 + getOrderExtensionDetailData2SuccessTest(); + } + + private void getOrderExtensionDetailData2SuccessTest() { + ClusterDO clusterDO = new ClusterDO(); + clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + clusterDO.setClusterName(""); + Mockito.when(clusterService.getById(Mockito.any())).thenReturn(clusterDO); + Mockito.when(connectionService.getByTopicName( + Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(Collections.emptyList()); + TopicDO topicDO = new TopicDO(); + topicDO.setAppId(APP_ID); + Mockito.when(topicManagerService.getByTopicName(Mockito.any(), Mockito.any())).thenReturn(topicDO); + AppDO appDO = new AppDO(); + appDO.setAppId(APP_ID); + appDO.setName(""); + appDO.setPrincipals(""); + Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(appDO); + + OrderDetailDeleteTopicDTO data = (OrderDetailDeleteTopicDTO)thirdPartDeleteTopicOrder.getOrderExtensionDetailData(EXTENSIONS); + Assert.assertNotNull(data); + Assert.assertNotNull(data.getAppId()); + Assert.assertNotNull(data.getAppName()); + } +}