kafka-manager-bpm包单元测试的编写 & bugfix

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,

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());

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(),

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<OrderResult> 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<OrderResult> orderResults = orderService.handleOrderBatch(orderHandleBatchDTO, ADMIN);
+        Assert.assertFalse(orderResults.isEmpty());
+    }
+
 }

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<String> result = applyAppOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ResourceAlreadyExistTest() {
+        Mockito.when(appService.getByName(Mockito.any())).thenReturn(new AppDO());
+
+        Result<String> 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<String> 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<String> 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);
+    }
+}

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<String> 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<String> 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<String> 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<String> 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<String> 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<Account> 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<Account> 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<Account> 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());
+    }
+
+}

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<String> result = applyClusterOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2AppNotExistTest() {
+        Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null);
+
+        Result<String> 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<String> 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<String> 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());
+    }
+
+}

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<String> 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<String> 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<String> 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<String> 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());
+    }
+}

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<String> 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<String> 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<String> 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<String> 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<String> 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);
+    }
+}

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<String> 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<String> 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<String> 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<String> 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());
+    }
+
+}

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<String> result = deleteAppOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2AppNotExistTest() {
+        Mockito.when(appService.getByAppId(Mockito.any())).thenReturn(null);
+
+        Result<String> 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<String> 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());
+    }
+}

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());
+    }
+
+}

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<String> result = deleteClusterOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() {
+        Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.any())).thenReturn(null);
+        Result<String> 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<String> result = deleteClusterOrder.checkExtensionFieldsAndGenerateTitle(EXTENSIONS);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test
+    public void handleOrderDetailTest() {
+        // operation forbidden
+        handleOrderDetail2OperationForbiddenTest();
+        // success
+        handleOrderDetail2SuccessTest();
+    }
+
+    private void handleOrderDetail2OperationForbiddenTest() {
+        Set<String> 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);
+    }
+}

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<String> result = deleteTopicOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ClusterNotExist() {
+        Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(
+                Mockito.anyLong())).thenReturn(null);
+        Result<String> 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<String> 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<String> 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());
+    }
+
+}

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<String> result = modifyClusterOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ClusterNotExistTest() {
+        Mockito.when(logicalClusterMetadataManager.getPhysicalClusterId(Mockito.anyLong())).thenReturn(null);
+
+        Result<String> 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<String> 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);
+    }
+
+}

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<String> result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle("{");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ParamIllegal2Test() {
+        Result<String> result = modifyGatewayConfigOrder.checkExtensionFieldsAndGenerateTitle("{}");
+        Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void checkExtensionFieldsAndGenerateTitle2ParamIllegal3Test() {
+        Mockito.when(gatewayConfigService.getById(Mockito.anyLong())).thenReturn(null);
+        Result<String> 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<String> 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<String> 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);
+    }
+
+}

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<String> 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<String> 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<String> 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<String> 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<String> 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<String> 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());
+    }
+}