Merge branch 'dev_v2.5.0_addtest' of github.com:didi/LogiKM into dev_v2.5.0_addtest

 Conflicts:

	kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/ExpertServiceTest.java

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/entity/Result.java

@@ -82,15 +82,15 @@ public class Result<T> implements Serializable {
         return JSON.toJSONString(this);
     }
 
-    public static Result buildSuc() {
-        Result result = new Result();
+    public static <T> Result<T> buildSuc() {
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.SUCCESS.getCode());
         result.setMessage(ResultStatus.SUCCESS.getMessage());
         return result;
     }
 
     public static <T> Result<T> buildSuc(T data) {
-        Result<T> result = new Result<T>();
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.SUCCESS.getCode());
         result.setMessage(ResultStatus.SUCCESS.getMessage());
         result.setData(data);
@@ -98,7 +98,7 @@ public class Result<T> implements Serializable {
     }
 
     public static <T> Result<T> buildGatewayFailure(String message) {
-        Result<T> result = new Result<T>();
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.GATEWAY_INVALID_REQUEST.getCode());
         result.setMessage(message);
         result.setData(null);
@@ -106,22 +106,22 @@ public class Result<T> implements Serializable {
     }
 
     public static <T> Result<T> buildFailure(String message) {
-        Result<T> result = new Result<T>();
+        Result<T> result = new Result<>();
         result.setCode(ResultStatus.FAIL.getCode());
         result.setMessage(message);
         result.setData(null);
         return result;
     }
 
-    public static Result buildFrom(ResultStatus resultStatus) {
-        Result result = new Result();
+    public static <T> Result<T> buildFrom(ResultStatus resultStatus) {
+        Result<T> result = new Result<>();
         result.setCode(resultStatus.getCode());
         result.setMessage(resultStatus.getMessage());
         return result;
     }
 
-    public static Result buildFrom(ResultStatus resultStatus, Object data) {
-        Result result = new Result();
+    public static <T> Result<T> buildFrom(ResultStatus resultStatus, T data) {
+        Result<T> result = new Result<>();
         result.setCode(resultStatus.getCode());
         result.setMessage(resultStatus.getMessage());
         result.setData(data);

kafka-manager-common/src/main/java/com/xiaojukeji/kafka/manager/common/utils/SpringTool.java

@@ -13,6 +13,7 @@ import org.springframework.context.ApplicationEvent;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.core.annotation.Order;
 import org.springframework.stereotype.Service;
+import org.springframework.web.context.request.RequestAttributes;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 
@@ -81,16 +82,19 @@ public class SpringTool implements ApplicationContextAware, DisposableBean {
     }
 
     public static String getUserName(){
-        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
-
         String username = null;
-        if (TrickLoginConstant.TRICK_LOGIN_SWITCH_ON.equals(request.getHeader(TrickLoginConstant.TRICK_LOGIN_SWITCH))) {
-            // trick登录方式的获取用户
-            username = request.getHeader(TrickLoginConstant.TRICK_LOGIN_USER);
-        } else {
-            // 走页面登录方式登录的获取用户
-            HttpSession session = request.getSession();
-            username = (String) session.getAttribute(LoginConstant.SESSION_USERNAME_KEY);
+        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
+        if (!ValidateUtils.isNull(requestAttributes)) {
+            HttpServletRequest request = ((ServletRequestAttributes) requestAttributes).getRequest();
+
+            if (TrickLoginConstant.TRICK_LOGIN_SWITCH_ON.equals(request.getHeader(TrickLoginConstant.TRICK_LOGIN_SWITCH))) {
+                // trick登录方式的获取用户
+                username = request.getHeader(TrickLoginConstant.TRICK_LOGIN_USER);
+            } else {
+                // 走页面登录方式登录的获取用户
+                HttpSession session = request.getSession();
+                username = (String) session.getAttribute(LoginConstant.SESSION_USERNAME_KEY);
+            }
         }
 
         if (ValidateUtils.isNull(username)) {

kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/AdminServiceTest.java

@@ -0,0 +1,375 @@
+package com.xiaojukeji.kafka.manager.service.service;
+
+import com.xiaojukeji.kafka.manager.common.bizenum.TaskStatusEnum;
+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.TopicDO;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Properties;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/24
+ */
+public class AdminServiceTest extends BaseTest {
+
+    /**
+     * 集群共包括三个broker:1,2,3, 该topic 1分区 1副本因子，在broker1上
+     */
+    private final static String REAL_TOPIC1_IN_ZK = "moduleTest";
+
+    /**
+     * 集群共包括三个broker:1,2,3, 该topic 2分区 3副本因子，在broker1,2,3上
+     */
+    private final static String REAL_TOPIC2_IN_ZK = "xgTest";
+
+    private final static String INVALID_TOPIC = "xxxxx";
+
+    private final static String ZK_DEFAULT_TOPIC = "_consumer_offsets";
+
+    private final static String CREATE_TOPIC_TEST = "createTopicTest";
+
+    private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L;
+
+    private final static Integer REAL_BROKER_ID_IN_ZK = 1;
+
+    private final static Long INVALID_CLUSTER_ID = -1L;
+
+    private final static Integer INVALID_PARTITION_ID = -1;
+
+    private final static Integer REAL_PARTITION_ID = 0;
+
+    private final static Integer INVALID_BROKER_ID = -1;
+
+    private final static String APP_ID = "dkm_admin";
+
+    private final static Long INVALID_REGION_ID = -1L;
+
+    private final static Long REAL_REGION_ID_IN_MYSQL = 1L;
+
+    private final static String ADMIN = "admin";
+
+
+    @Autowired
+    private AdminService adminService;
+
+    @Autowired
+    private TopicManagerService topicManagerService;
+
+    private TopicDO getTopicDO() {
+        TopicDO topicDO = new TopicDO();
+        topicDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL);
+        topicDO.setTopicName(CREATE_TOPIC_TEST);
+        topicDO.setAppId(APP_ID);
+        topicDO.setDescription(CREATE_TOPIC_TEST);
+        topicDO.setPeakBytesIn(100000L);
+        return topicDO;
+    }
+
+    public ClusterDO getClusterDO() {
+        ClusterDO clusterDO = new ClusterDO();
+        clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL);
+        clusterDO.setClusterName("LogiKM_moduleTest");
+        clusterDO.setZookeeper("10.190.46.198:2181,10.190.14.237:2181,10.190.50.65:2181/xg");
+        clusterDO.setBootstrapServers("10.190.46.198:9093,10.190.14.237:9093,10.190.50.65:9093");
+        clusterDO.setSecurityProperties("{ \t\"security.protocol\": \"SASL_PLAINTEXT\", \t\"sasl.mechanism\": \"PLAIN\", \t\"sasl.jaas.config\": \"org.apache.kafka.common.security.plain.PlainLoginModule required username=\\\"dkm_admin\\\" password=\\\"km_kMl4N8as1Kp0CCY\\\";\" }");
+        clusterDO.setStatus(1);
+        clusterDO.setGmtCreate(new Date());
+        clusterDO.setGmtModify(new Date());
+        return clusterDO;
+    }
+
+    @Test(description = "测试创建topic")
+    public void createTopicTest() {
+        // broker not exist
+        createTopic2BrokerNotExistTest();
+        // success to create topic
+        createTopic2SuccessTest();
+        // failure to create topic, topic already exists
+        createTopic2FailureTest();
+    }
+
+    private void createTopic2BrokerNotExistTest() {
+        TopicDO topicDO = getTopicDO();
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = adminService.createTopic(
+                clusterDO,
+                topicDO,
+                1,
+                1,
+                1L,
+                Arrays.asList(INVALID_BROKER_ID),
+                new Properties(),
+                ADMIN,
+                ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.BROKER_NOT_EXIST.getCode());
+    }
+
+    private void createTopic2FailureTest() {
+        TopicDO topicDO = getTopicDO();
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = adminService.createTopic(
+                clusterDO,
+                topicDO,
+                1,
+                1,
+                INVALID_REGION_ID,
+                Arrays.asList(REAL_BROKER_ID_IN_ZK),
+                new Properties(),
+                ADMIN,
+                ADMIN);
+        Assert.assertNotEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    private void createTopic2SuccessTest() {
+        TopicDO topicDO = getTopicDO();
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = adminService.createTopic(
+                clusterDO,
+                topicDO,
+                1,
+                1,
+                INVALID_REGION_ID,
+                Arrays.asList(REAL_BROKER_ID_IN_ZK),
+                new Properties(),
+                ADMIN,
+                ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试删除topic")
+    public void deleteTopicTest() {
+        // topic does not exist
+        deleteTopic2FailureTest();
+        // success to delete
+        deleteTopic2SuccessTest();
+    }
+
+    private void deleteTopic2FailureTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.deleteTopic(
+                clusterDO,
+                INVALID_TOPIC,
+                ADMIN
+        );
+        Assert.assertNotEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    private void deleteTopic2SuccessTest() {
+        TopicDO topicDO = getTopicDO();
+        topicManagerService.addTopic(topicDO);
+
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.deleteTopic(
+                clusterDO,
+                CREATE_TOPIC_TEST,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试优先副本选举状态")
+    public void preferredReplicaElectionStatusTest() {
+        // running
+        preferredReplicaElectionStatus2RunningTest();
+        // not running
+        preferredReplicaElectionStatus2NotRunningTest();
+    }
+
+    private void preferredReplicaElectionStatus2RunningTest() {
+        // zk上需要创建/admin/preferred_replica_election节点
+        ClusterDO clusterDO = getClusterDO();
+        TaskStatusEnum taskStatusEnum = adminService.preferredReplicaElectionStatus(clusterDO);
+        Assert.assertEquals(taskStatusEnum.getCode(), TaskStatusEnum.RUNNING.getCode());
+    }
+
+    private void preferredReplicaElectionStatus2NotRunningTest() {
+        ClusterDO clusterDO = getClusterDO();
+        // zk上无/admin/preferred_replica_election节点
+        TaskStatusEnum taskStatusEnum = adminService.preferredReplicaElectionStatus(clusterDO);
+        Assert.assertEquals(taskStatusEnum.getCode(), TaskStatusEnum.SUCCEED.getCode());
+    }
+
+    @Test(description = "测试集群纬度优先副本选举")
+    public void preferredReplicaElectionOfCluster2Test() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(clusterDO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "Broker纬度优先副本选举")
+    public void preferredReplicaElectionOfBrokerTest() {
+        // 参数异常
+        preferredReplicaElectionOfBroker2ParamIllegalTest();
+        // success
+        preferredReplicaElectionOfBroker2SuccessTest();
+    }
+
+    private void preferredReplicaElectionOfBroker2ParamIllegalTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                INVALID_BROKER_ID,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void preferredReplicaElectionOfBroker2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                REAL_BROKER_ID_IN_ZK,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "Topic纬度优先副本选举")
+    public void preferredReplicaElectionOfTopicTest() {
+        // topic not exist
+        preferredReplicaElectionOfTopic2TopicNotExistTest();
+        // success
+        preferredReplicaElectionOfTopic2SuccessTest();
+    }
+
+    private void preferredReplicaElectionOfTopic2TopicNotExistTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                INVALID_TOPIC,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode());
+    }
+
+    private void preferredReplicaElectionOfTopic2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                REAL_TOPIC1_IN_ZK,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "Topic纬度优先副本选举")
+    public void preferredReplicaElectionOfPartitionTest() {
+        // topic not exist
+        preferredReplicaElectionOfPartition2TopicNotExistTest();
+        // partition Not Exist
+        preferredReplicaElectionOfPartition2PartitionNotExistTest();
+        // success
+        preferredReplicaElectionOfPartition2SuccessTest();
+    }
+
+    private void preferredReplicaElectionOfPartition2TopicNotExistTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                INVALID_TOPIC,
+                INVALID_PARTITION_ID,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.TOPIC_NOT_EXIST.getCode());
+    }
+
+    private void preferredReplicaElectionOfPartition2PartitionNotExistTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                REAL_TOPIC2_IN_ZK,
+                INVALID_PARTITION_ID,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.PARTITION_NOT_EXIST.getCode());
+    }
+
+    private void preferredReplicaElectionOfPartition2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.preferredReplicaElection(
+                clusterDO,
+                REAL_TOPIC2_IN_ZK,
+                REAL_PARTITION_ID,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试获取Topic配置")
+    public void getTopicConfigTest() {
+        // result is null
+        getTopicConfig2NullTest();
+        // result not null
+        getTopicConfig2NotNullTest();
+    }
+
+    private void getTopicConfig2NullTest() {
+        ClusterDO clusterDO = getClusterDO();
+        clusterDO.setId(INVALID_CLUSTER_ID);
+        Properties topicConfig = adminService.getTopicConfig(clusterDO, REAL_TOPIC1_IN_ZK);
+        Assert.assertNull(topicConfig);
+    }
+
+    private void getTopicConfig2NotNullTest() {
+        ClusterDO clusterDO = getClusterDO();
+        Properties topicConfig = adminService.getTopicConfig(clusterDO, REAL_TOPIC1_IN_ZK);
+        Assert.assertNotNull(topicConfig);
+    }
+
+    @Test(description = "测试修改Topic配置")
+    public void modifyTopicConfigTest() {
+        ClusterDO clusterDO = getClusterDO();
+        Properties properties = new Properties();
+        properties.put("retention.ms", "21600000");
+        ResultStatus resultStatus = adminService.modifyTopicConfig(
+                clusterDO,
+                REAL_TOPIC1_IN_ZK,
+                properties,
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试扩分区")
+    public void expandPartitionsTest() {
+        // broker not exist
+        expandPartitions2BrokerNotExistTest();
+        // success
+        expandPartitions2SuccessTest();
+    }
+
+    private void expandPartitions2BrokerNotExistTest() {
+        // 存在两个下线broker, region中包含一个
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.expandPartitions(
+                clusterDO,
+                REAL_TOPIC1_IN_ZK,
+                2,
+                REAL_REGION_ID_IN_MYSQL,
+                Arrays.asList(INVALID_BROKER_ID),
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.BROKER_NOT_EXIST.getCode());
+    }
+
+    private void expandPartitions2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus resultStatus = adminService.expandPartitions(
+                clusterDO,
+                REAL_TOPIC1_IN_ZK,
+                2,
+                INVALID_REGION_ID,
+                Arrays.asList(REAL_BROKER_ID_IN_ZK),
+                ADMIN
+        );
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.BROKER_NOT_EXIST.getCode());
+    }
+
+}

kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/gateway/AppServiceTest.java

@@ -27,13 +27,13 @@ public class AppServiceTest extends BaseTest {
     public static Object[][] provideAppDO() {
         AppDO appDO = new AppDO();
         appDO.setId(4L);
-        appDO.setAppId("testAppId");
-        appDO.setName("testApp");
-        appDO.setPassword("testApp");
+        appDO.setAppId("moduleTestAppId");
+        appDO.setName("moduleTestApp");
+        appDO.setPassword("moduleTestApp");
         appDO.setType(1);
         appDO.setApplicant("admin");
         appDO.setPrincipals("admin");
-        appDO.setDescription("testApp");
+        appDO.setDescription("moduleTestApp");
         appDO.setCreateTime(new Date(1638786493173L));
         appDO.setModifyTime(new Date(1638786493173L));
         return new Object[][] {{appDO}};
@@ -59,7 +59,6 @@ public class AppServiceTest extends BaseTest {
         addApp2MysqlErrorTest();
     }
 
-    @Rollback(false)
     private void addApp2SuccessTest(AppDO appDO) {
         ResultStatus addAppResult = appService.addApp(appDO, "admin");
         Assert.assertEquals(addAppResult.getCode(), ResultStatus.SUCCESS.getCode());
@@ -70,7 +69,6 @@ public class AppServiceTest extends BaseTest {
         Assert.assertEquals(addAppResult.getCode(), ResultStatus.RESOURCE_ALREADY_EXISTED.getCode());
     }
 
-    @Rollback()
     private void addApp2MysqlErrorTest() {
         ResultStatus addAppResult = appService.addApp(new AppDO(), "admin");
         Assert.assertEquals(addAppResult.getCode(), ResultStatus.MYSQL_ERROR.getCode());
@@ -78,20 +76,24 @@ public class AppServiceTest extends BaseTest {
 
     @Test(dataProvider = "provideAppDO")
     public void deleteAppTest(AppDO appDO) {
+        appService.addApp(appDO, "admin");
+
         // 测试删除app成功
         deleteApp2SuccessTest(appDO);
         // 测试删除app失败
-        deleteApp2FailureTest();
+        deleteApp2FailureTest(appDO);
     }
 
-    @Rollback()
     private void deleteApp2SuccessTest(AppDO appDO) {
+        appService.addApp(appDO, "admin");
+
         int result = appService.deleteApp(appDO, "admin");
         Assert.assertEquals(result, 1);
     }
 
-    @Rollback()
-    private void deleteApp2FailureTest() {
+    private void deleteApp2FailureTest(AppDO appDO) {
+        appService.addApp(appDO, "admin");
+
         int result = appService.deleteApp(new AppDO(), "admin");
         Assert.assertEquals(result, 0);
     }
@@ -116,7 +118,6 @@ public class AppServiceTest extends BaseTest {
         Assert.assertEquals(result.getCode(), ResultStatus.USER_WITHOUT_AUTHORITY.getCode());
     }
 
-    @Rollback()
     private void updateByAppId2SucessTest(AppDTO appDTO) {
         ResultStatus result1 = appService.updateByAppId(appDTO, "admin", false);
         Assert.assertEquals(result1.getCode(), ResultStatus.SUCCESS.getCode());

kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/gateway/TopicConnectionServiceTest.java

@@ -0,0 +1,85 @@
+package com.xiaojukeji.kafka.manager.service.service.gateway;
+
+import com.xiaojukeji.kafka.manager.common.entity.ao.topic.TopicConnection;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.TopicConnectionDO;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.Assert;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/7
+ */
+public class TopicConnectionServiceTest extends BaseTest {
+
+    @Autowired
+    private TopicConnectionService topicConnectionService;
+
+    private static final String TOPIC_NAME = "moduleTest";
+
+    private static final Long CLUSTER_ID = 1L;
+
+    private static final String APP_ID = "dkm_admin";
+
+    @DataProvider(name = "provideTopicConnection")
+    public static Object[][] provideTopicConnection() {
+        TopicConnectionDO topicConnectionDO = new TopicConnectionDO();
+        topicConnectionDO.setId(13L);
+        topicConnectionDO.setAppId(APP_ID);
+        topicConnectionDO.setClusterId(CLUSTER_ID);
+        topicConnectionDO.setTopicName(TOPIC_NAME);
+        topicConnectionDO.setType("fetch");
+        topicConnectionDO.setIp("172.23.142.253");
+        topicConnectionDO.setClientVersion("2.4");
+        topicConnectionDO.setCreateTime(new Date(1638786493173L));
+        return new Object[][] {{topicConnectionDO}};
+    }
+
+    // 测试批量插入为空的情况
+    @Test
+    private void batchAdd2EmptyTest() {
+        topicConnectionService.batchAdd(new ArrayList<>());
+    }
+
+    // 测试批量插入成功的情况，通过调整list的数量和TopicConnectionServiceImpl中splitInterval的数量，使每个流程都测试一遍
+    @Test(dataProvider = "provideTopicConnection")
+    private void batchAdd2SuccessTest(TopicConnectionDO topicConnectionDO) {
+        List<TopicConnectionDO> list = new ArrayList<>();
+        list.add(topicConnectionDO);
+        list.add(topicConnectionDO);
+        list.add(topicConnectionDO);
+        topicConnectionService.batchAdd(list);
+    }
+
+    @Test(dataProvider = "provideTopicConnection")
+    public void getByTopicName2Test(TopicConnectionDO topicConnectionDO) {
+        List<TopicConnection> result = topicConnectionService.getByTopicName(CLUSTER_ID, TOPIC_NAME, new Date(0L), new Date());
+        Assert.assertEquals(result.size(), 1);
+        Assert.assertEquals(result.get(0).toString(), topicConnectionDO.toString());
+    }
+
+    // 测试获取数据时为空
+    @Test
+    public void getByTopicName2EmptyTest() {
+        List<TopicConnection> result = topicConnectionService.getByTopicName(100L, "xgTestxxx", new Date(0L), new Date());
+        Assert.assertTrue(result.isEmpty());
+    }
+
+    // 测试获取数据,clusterId不为null，TODO
+    @Test(dataProvider = "provideTopicConnection")
+    public void getByTopicName2SuccessTest(TopicConnectionDO topicConnectionDO) {
+        List<TopicConnectionDO> list = new ArrayList<>();
+        list.add(topicConnectionDO);
+        topicConnectionService.batchAdd(list);
+        
+        List<TopicConnection> result = topicConnectionService.getByTopicName(CLUSTER_ID, TOPIC_NAME, new Date(0L), new Date());
+        Assert.assertTrue(result.stream().anyMatch(topicConnection -> topicConnection.getTopicName().equals(TOPIC_NAME)
+                                                            && topicConnection.getClusterId().equals(CLUSTER_ID)));
+    }
+}

kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/utils/TopicCommandsTest.java

@@ -0,0 +1,234 @@
+package com.xiaojukeji.kafka.manager.service.utils;
+
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.Properties;
+
+/**
+ * @author xuguang
+ * @Date 2022/1/6
+ */
+public class TopicCommandsTest extends BaseTest {
+
+    private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L;
+
+    private final static String TEST_CREATE_TOPIC = "createTopicTest";
+
+    private final static String REAL_TOPIC_IN_ZK = "moduleTest";
+
+    private final static String INVALID_TOPIC = ".,&";
+
+    private final static Integer PARTITION_NUM = 1;
+
+    private final static Integer REPLICA_NUM = 1;
+
+    private final static Integer BROKER_ID = 1;
+
+    public ClusterDO getClusterDO() {
+        ClusterDO clusterDO = new ClusterDO();
+        clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL);
+        clusterDO.setClusterName("LogiKM_moduleTest");
+        clusterDO.setZookeeper("10.190.46.198:2181,10.190.14.237:2181,10.190.50.65:2181/xg");
+        clusterDO.setBootstrapServers("10.190.46.198:9093,10.190.14.237:9093,10.190.50.65:9093");
+        clusterDO.setSecurityProperties("{ \t\"security.protocol\": \"SASL_PLAINTEXT\", \t\"sasl.mechanism\": \"PLAIN\", \t\"sasl.jaas.config\": \"org.apache.kafka.common.security.plain.PlainLoginModule required username=\\\"dkm_admin\\\" password=\\\"km_kMl4N8as1Kp0CCY\\\";\" }");
+        clusterDO.setStatus(1);
+        clusterDO.setGmtCreate(new Date());
+        clusterDO.setGmtModify(new Date());
+        return clusterDO;
+    }
+
+
+    @Test(description = "测试创建topic")
+    public void createTopicTest() {
+        // NullPointerException
+        createTopic2NullPointerExceptionTest();
+        // InvalidPartitions
+        createTopic2InvalidPartitionsTest();
+        // InvalidReplicationFactor
+        createTopic2InvalidReplicationFactorTest();
+        // topic exists
+        createTopic2TopicExistsTest();
+        // invalid topic
+        createTopic2InvalidTopicTest();
+        // success
+        createTopic2SuccessTest();
+    }
+
+    private void createTopic2NullPointerExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        clusterDO.setZookeeper(null);
+        clusterDO.setBootstrapServers(null);
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                TEST_CREATE_TOPIC,
+                PARTITION_NUM,
+                REPLICA_NUM,
+                Arrays.asList(BROKER_ID),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_PARAM_NULL_POINTER.getCode());
+    }
+
+    private void createTopic2InvalidPartitionsTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                TEST_CREATE_TOPIC,
+                -1,
+                REPLICA_NUM,
+                Arrays.asList(BROKER_ID),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_PARTITION_NUM_ILLEGAL.getCode());
+    }
+
+    private void createTopic2InvalidReplicationFactorTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                TEST_CREATE_TOPIC,
+                PARTITION_NUM,
+                REPLICA_NUM,
+                Collections.emptyList(),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.BROKER_NUM_NOT_ENOUGH.getCode());
+    }
+
+    private void createTopic2TopicExistsTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                REAL_TOPIC_IN_ZK,
+                PARTITION_NUM,
+                REPLICA_NUM,
+                Arrays.asList(BROKER_ID),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_TOPIC_EXISTED.getCode());
+    }
+
+    private void createTopic2InvalidTopicTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                INVALID_TOPIC,
+                PARTITION_NUM,
+                REPLICA_NUM,
+                Arrays.asList(BROKER_ID),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_TOPIC_NAME_ILLEGAL.getCode());
+    }
+
+    private void createTopic2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.createTopic(
+                clusterDO,
+                TEST_CREATE_TOPIC,
+                PARTITION_NUM,
+                REPLICA_NUM,
+                Arrays.asList(BROKER_ID),
+                new Properties()
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试修改topic配置")
+    public void modifyTopicConfigTest() {
+        // AdminOperationException
+        modifyTopicConfig2AdminOperationExceptionTest();
+        // InvalidConfigurationException
+        modifyTopicConfig2InvalidConfigurationExceptionTest();
+        // success
+        modifyTopicConfig2SuccessTest();
+    }
+
+    private void modifyTopicConfig2AdminOperationExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.modifyTopicConfig(clusterDO, INVALID_TOPIC, new Properties());
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_UNKNOWN_TOPIC_PARTITION.getCode());
+    }
+
+    private void modifyTopicConfig2InvalidConfigurationExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        Properties properties = new Properties();
+        properties.setProperty("xxx", "xxx");
+        ResultStatus result = TopicCommands.modifyTopicConfig(clusterDO, REAL_TOPIC_IN_ZK, properties);
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_TOPIC_CONFIG_ILLEGAL.getCode());
+    }
+
+    private void modifyTopicConfig2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        Properties properties = new Properties();
+        ResultStatus result = TopicCommands.modifyTopicConfig(clusterDO, REAL_TOPIC_IN_ZK, properties);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试扩分区")
+    public void expandTopicTest() {
+        // failed
+        expandTopic2FailureTest();
+        // success
+        expandTopic2SuccessTest();
+    }
+
+    private void expandTopic2FailureTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.expandTopic(
+                clusterDO,
+                INVALID_TOPIC,
+                PARTITION_NUM + 1,
+                Arrays.asList(BROKER_ID, 2)
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_UNKNOWN_ERROR.getCode());
+    }
+
+    private void expandTopic2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.expandTopic(
+                clusterDO,
+                TEST_CREATE_TOPIC,
+                PARTITION_NUM + 1,
+                Arrays.asList(BROKER_ID, 2)
+        );
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(description = "测试删除Topic")
+    public void deleteTopicTest() {
+        // UnknownTopicOrPartitionException
+        deleteTopic2UnknownTopicOrPartitionExceptionTest();
+        // NullPointerException
+        deleteTopic2NullPointerExceptionTest();
+        // success
+        deleteTopic2SuccessTest();
+    }
+
+    private void deleteTopic2UnknownTopicOrPartitionExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.deleteTopic(clusterDO, INVALID_TOPIC);
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_UNKNOWN_TOPIC_PARTITION.getCode());
+    }
+
+    private void deleteTopic2NullPointerExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        clusterDO.setBootstrapServers(null);
+        clusterDO.setZookeeper(null);
+        ResultStatus result = TopicCommands.deleteTopic(clusterDO, INVALID_TOPIC);
+        Assert.assertEquals(result.getCode(), ResultStatus.TOPIC_OPERATION_UNKNOWN_ERROR.getCode());
+    }
+
+    private void deleteTopic2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        ResultStatus result = TopicCommands.deleteTopic(clusterDO, TEST_CREATE_TOPIC);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+}

kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/utils/TopicReassignUtilsTest.java

@@ -0,0 +1,78 @@
+package com.xiaojukeji.kafka.manager.service.utils;
+
+import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import org.junit.Assert;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Date;
+
+/**
+ * @author xuguang
+ * @Date 2022/1/6
+ */
+public class TopicReassignUtilsTest extends BaseTest {
+
+    private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L;
+
+    private final static String TEST_CREATE_TOPIC = "createTopicTest";
+
+    private final static String REAL_TOPIC_IN_ZK = "moduleTest";
+
+    private final static String INVALID_TOPIC = ".,&";
+
+    private final static Integer PARTITION_NUM = 1;
+
+    private final static Integer REPLICA_NUM = 1;
+
+    private final static Integer BROKER_ID = 1;
+
+    private final static Integer PARTITION_ID = 1;
+
+    public ClusterDO getClusterDO() {
+        ClusterDO clusterDO = new ClusterDO();
+        clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL);
+        clusterDO.setClusterName("LogiKM_moduleTest");
+        clusterDO.setZookeeper("10.190.46.198:2181,10.190.14.237:2181,10.190.50.65:2181/xg");
+        clusterDO.setBootstrapServers("10.190.46.198:9093,10.190.14.237:9093,10.190.50.65:9093");
+        clusterDO.setSecurityProperties("{ \t\"security.protocol\": \"SASL_PLAINTEXT\", \t\"sasl.mechanism\": \"PLAIN\", \t\"sasl.jaas.config\": \"org.apache.kafka.common.security.plain.PlainLoginModule required username=\\\"dkm_admin\\\" password=\\\"km_kMl4N8as1Kp0CCY\\\";\" }");
+        clusterDO.setStatus(1);
+        clusterDO.setGmtCreate(new Date());
+        clusterDO.setGmtModify(new Date());
+        return clusterDO;
+    }
+
+    @Test
+    public void generateReassignmentJsonTest() {
+        // null
+        generateReassignmentJson2NullPointerExceptionTest();
+        // not null
+        generateReassignmentJson2SuccessTest();
+    }
+
+    private void generateReassignmentJson2NullPointerExceptionTest() {
+        ClusterDO clusterDO = getClusterDO();
+        clusterDO.setZookeeper(null);
+        String result = TopicReassignUtils.generateReassignmentJson(
+                clusterDO,
+                REAL_TOPIC_IN_ZK,
+                Arrays.asList(PARTITION_ID),
+                Arrays.asList(BROKER_ID)
+        );
+
+        Assert.assertNull(result);
+    }
+
+    private void generateReassignmentJson2SuccessTest() {
+        ClusterDO clusterDO = getClusterDO();
+        String result = TopicReassignUtils.generateReassignmentJson(
+                clusterDO,
+                REAL_TOPIC_IN_ZK,
+                Arrays.asList(PARTITION_ID),
+                Arrays.asList(BROKER_ID)
+        );
+
+        Assert.assertNotNull(result);
+    }
+}

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

kafka-manager-extends/kafka-manager-kcm/src/test/java/com/xiaojukeji/kafka/manager/kcm/ClusterHostTaskServiceTest.java

@@ -0,0 +1,80 @@
+package com.xiaojukeji.kafka.manager.kcm;
+
+import com.xiaojukeji.kafka.manager.common.entity.Result;
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.ao.CreationTaskData;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.dto.ClusterHostTaskDTO;
+import com.xiaojukeji.kafka.manager.kcm.config.BaseTest;
+import com.xiaojukeji.kafka.manager.kcm.tasks.ClusterHostTaskService;
+import org.junit.Assert;
+import org.mockito.InjectMocks;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+
+/**
+ * @author xuguang
+ * @Date 2022/1/5
+ */
+public class ClusterHostTaskServiceTest extends BaseTest {
+
+    @Autowired
+    @InjectMocks
+    private ClusterHostTaskService clusterHostTaskService;
+
+    private ClusterHostTaskDTO getClusterHostTaskDTO() {
+        ClusterHostTaskDTO clusterHostTaskDTO = new ClusterHostTaskDTO();
+        clusterHostTaskDTO.setClusterId(-1L);
+        clusterHostTaskDTO.setHostList(Arrays.asList("127.0.0.1"));
+        clusterHostTaskDTO.setTaskType("");
+        clusterHostTaskDTO.setKafkaFileBaseUrl("");
+        clusterHostTaskDTO.setKafkaPackageMd5("");
+        clusterHostTaskDTO.setKafkaPackageName("");
+        clusterHostTaskDTO.setServerPropertiesMd5("");
+        clusterHostTaskDTO.setServerPropertiesName("");
+        return clusterHostTaskDTO;
+    }
+
+    @Test
+    public void getOperationHostsTest() {
+        // cluster task host list illegal
+        getOperationHosts2HostListIllegalTest();
+        // success
+        getOperationHosts2SuccessTest();
+    }
+
+    private void getOperationHosts2HostListIllegalTest() {
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        clusterHostTaskDTO.setHostList(Arrays.asList(""));
+        Result<CreationTaskData> result = clusterHostTaskService.getOperationHosts(clusterHostTaskDTO);
+        Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_TASK_HOST_LIST_ILLEGAL.getCode());
+    }
+
+    private void getOperationHosts2SuccessTest() {
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        Result<CreationTaskData> result = clusterHostTaskService.getOperationHosts(clusterHostTaskDTO);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test
+    public void getCreateTaskParamDTOTest() {
+        // not success
+        getCreateTaskParamDTO2NotSuccessTest();
+        // success
+        getCreateTaskParamDTO2SuccessTest();
+    }
+
+    private void getCreateTaskParamDTO2NotSuccessTest() {
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        clusterHostTaskDTO.setHostList(Arrays.asList(""));
+        Result<CreationTaskData> dto = clusterHostTaskService.getCreateTaskParamDTO(clusterHostTaskDTO);
+        Assert.assertEquals(dto.getCode(), ResultStatus.CLUSTER_TASK_HOST_LIST_ILLEGAL.getCode());
+    }
+
+    private void getCreateTaskParamDTO2SuccessTest() {
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        Result<CreationTaskData> dto = clusterHostTaskService.getCreateTaskParamDTO(clusterHostTaskDTO);
+        Assert.assertEquals(dto.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+}

kafka-manager-extends/kafka-manager-kcm/src/test/java/com/xiaojukeji/kafka/manager/kcm/ClusterRoleTaskServiceTest.java

@@ -0,0 +1,74 @@
+package com.xiaojukeji.kafka.manager.kcm;
+
+import com.xiaojukeji.kafka.manager.common.bizenum.KafkaBrokerRoleEnum;
+import com.xiaojukeji.kafka.manager.common.entity.Result;
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.ao.CreationTaskData;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.dto.ClusterRoleTaskDTO;
+import com.xiaojukeji.kafka.manager.kcm.config.BaseTest;
+import com.xiaojukeji.kafka.manager.kcm.tasks.ClusterRoleTaskService;
+import org.junit.Assert;
+import org.mockito.InjectMocks;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+/**
+ * @author xuguang
+ * @Date 2022/1/5
+ */
+public class ClusterRoleTaskServiceTest extends BaseTest {
+
+    @Autowired
+    @InjectMocks
+    private ClusterRoleTaskService clusterRoleTaskService;
+
+    private ClusterRoleTaskDTO getClusterRoleTaskDTO() {
+        ClusterRoleTaskDTO clusterRoleTaskDTO = new ClusterRoleTaskDTO();
+        clusterRoleTaskDTO.setClusterId(-1L);
+        clusterRoleTaskDTO.setTaskType("");
+        return clusterRoleTaskDTO;
+    }
+
+    @Test
+    public void getOperationHostsTest() {
+        // controller not alive
+        getOperationHosts2ControllerNotAliveTest();
+        // success
+        getOperationHosts2SuccessTest();
+    }
+
+    private void getOperationHosts2ControllerNotAliveTest() {
+        ClusterRoleTaskDTO dto = getClusterRoleTaskDTO();
+        List<String> upgradeSequenceList = new ArrayList<>();
+        upgradeSequenceList.add(KafkaBrokerRoleEnum.CONTROLLER.getRole());
+        dto.setUpgradeSequenceList(upgradeSequenceList);
+        dto.setKafkaRoleBrokerHostMap(new HashMap<>(0));
+
+        Result<CreationTaskData> result = clusterRoleTaskService.getOperationHosts(dto);
+        Assert.assertEquals(result.getCode(), ResultStatus.CONTROLLER_NOT_ALIVE.getCode());
+    }
+
+    private void getOperationHosts2SuccessTest() {
+        ClusterRoleTaskDTO dto = getClusterRoleTaskDTO();
+        List<String> upgradeSequenceList = new ArrayList<>();
+        upgradeSequenceList.add(KafkaBrokerRoleEnum.CONTROLLER.getRole());
+        upgradeSequenceList.add(KafkaBrokerRoleEnum.NORMAL.getRole());
+        upgradeSequenceList.add(KafkaBrokerRoleEnum.COORDINATOR.getRole());
+        dto.setUpgradeSequenceList(upgradeSequenceList);
+        Map<String, List<String>> map = new HashMap<>();
+        List<String> controllerList = new ArrayList<>();
+        controllerList.add("127.0.0.1");
+        controllerList.add("localhost");
+        List<String> coordinatorList = new ArrayList<>();
+        coordinatorList.add("127.0.0.1");
+        coordinatorList.add("localhost");
+        map.put(KafkaBrokerRoleEnum.CONTROLLER.getRole(), controllerList);
+        map.put(KafkaBrokerRoleEnum.COORDINATOR.getRole(), coordinatorList);
+        dto.setKafkaRoleBrokerHostMap(map);
+
+        Result<CreationTaskData> result = clusterRoleTaskService.getOperationHosts(dto);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+}

kafka-manager-extends/kafka-manager-kcm/src/test/java/com/xiaojukeji/kafka/manager/kcm/ClusterTaskServiceTest.java

@@ -1,8 +1,354 @@
 package com.xiaojukeji.kafka.manager.kcm;
 
+import com.xiaojukeji.kafka.manager.common.entity.Result;
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterTaskDO;
+import com.xiaojukeji.kafka.manager.dao.ClusterTaskDao;
+import com.xiaojukeji.kafka.manager.kcm.common.bizenum.ClusterTaskActionEnum;
+import com.xiaojukeji.kafka.manager.kcm.common.bizenum.ClusterTaskStateEnum;
+import com.xiaojukeji.kafka.manager.kcm.common.bizenum.ClusterTaskTypeEnum;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.ao.ClusterTaskLog;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.ao.ClusterTaskStatus;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.dto.AbstractClusterTaskDTO;
+import com.xiaojukeji.kafka.manager.kcm.common.entry.dto.ClusterHostTaskDTO;
+import com.xiaojukeji.kafka.manager.kcm.component.agent.AbstractAgent;
+import com.xiaojukeji.kafka.manager.kcm.config.BaseTest;
+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;
+
 /**
  * @author xuguang
  * @Date 2021/12/27
  */
-public class ClusterTaskServiceTest {
+public class ClusterTaskServiceTest extends BaseTest {
+
+    private static final Long REAL_CLUSTER_ID_IN_MYSQL = 1L;
+
+    private static final String ADMIN = "admin";
+
+    private static final String BASEURL = "127.0.0.1";
+
+    private static final String MD5 = "md5";
+
+    private static final Long REAL_TASK_ID_IN_MYSQL = 1L;
+
+    private static final Long INVALID_TASK_ID = -1L;
+
+
+    @Autowired
+    @InjectMocks
+    private ClusterTaskService clusterTaskService;
+
+    @Mock
+    private AbstractAgent abstractAgent;
+
+    @Mock
+    private ClusterTaskDao clusterTaskDao;
+
+    private ClusterHostTaskDTO getClusterHostTaskDTO() {
+        ClusterHostTaskDTO clusterHostTaskDTO = new ClusterHostTaskDTO();
+        clusterHostTaskDTO.setClusterId(-1L);
+        clusterHostTaskDTO.setHostList(Arrays.asList(BASEURL));
+        clusterHostTaskDTO.setTaskType(ClusterTaskTypeEnum.HOST_UPGRADE.getName());
+        clusterHostTaskDTO.setKafkaFileBaseUrl(BASEURL);
+        clusterHostTaskDTO.setKafkaPackageMd5(MD5);
+        clusterHostTaskDTO.setKafkaPackageName("name");
+        clusterHostTaskDTO.setServerPropertiesMd5(MD5);
+        clusterHostTaskDTO.setServerPropertiesName("name");
+        return clusterHostTaskDTO;
+    }
+
+    private ClusterTaskDO getClusterTaskDO() {
+        ClusterTaskDO clusterTaskDO = new ClusterTaskDO();
+        clusterTaskDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL);
+        clusterTaskDO.setId(REAL_TASK_ID_IN_MYSQL);
+        clusterTaskDO.setAgentTaskId(-1L);
+        clusterTaskDO.setAgentRollbackTaskId(-1L);
+        clusterTaskDO.setTaskStatus(0);
+        return clusterTaskDO;
+    }
+
+    @BeforeMethod
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test(description = "测试创建任务")
+    public void createTaskTest() {
+        // paramIllegal
+        createTask2ParamIllegalTest();
+        // not success
+        createTask2NotSuccessTest();
+        // CallClusterTaskAgentFailed
+        createTask2CallClusterTaskAgentFailedTest();
+        // success
+        createTask2SuccessTest();
+        // mysqlError
+        createTask2MysqlErrorTest();
+    }
+
+    private void createTask2ParamIllegalTest() {
+        AbstractClusterTaskDTO dto = getClusterHostTaskDTO();
+        dto.setTaskType(null);
+        Result result1 = clusterTaskService.createTask(dto, ADMIN);
+        Assert.assertEquals(result1.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+
+        dto.setTaskType("");
+        Result result2 = clusterTaskService.createTask(dto, ADMIN);
+        Assert.assertEquals(result2.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void createTask2NotSuccessTest() {
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        clusterHostTaskDTO.setHostList(Arrays.asList("host"));
+        Result result = clusterTaskService.createTask(clusterHostTaskDTO, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.CLUSTER_TASK_HOST_LIST_ILLEGAL.getCode());
+    }
+
+    private void createTask2CallClusterTaskAgentFailedTest() {
+        Mockito.when(abstractAgent.createTask(Mockito.any())).thenReturn(null);
+
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        Result result = clusterTaskService.createTask(clusterHostTaskDTO, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.CALL_CLUSTER_TASK_AGENT_FAILED.getCode());
+    }
+
+    private void createTask2SuccessTest() {
+        Mockito.when(abstractAgent.createTask(Mockito.any())).thenReturn(Result.buildSuc(1L));
+        Mockito.when(clusterTaskDao.insert(Mockito.any())).thenReturn(1);
+
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        Result result = clusterTaskService.createTask(clusterHostTaskDTO, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    private void createTask2MysqlErrorTest() {
+        Mockito.when(abstractAgent.createTask(Mockito.any())).thenReturn(Result.buildSuc(1L));
+        Mockito.when(clusterTaskDao.insert(Mockito.any())).thenThrow(RuntimeException.class);
+
+        ClusterHostTaskDTO clusterHostTaskDTO = getClusterHostTaskDTO();
+        Result result = clusterTaskService.createTask(clusterHostTaskDTO, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.MYSQL_ERROR.getCode());
+    }
+
+    @Test
+    public void executeTaskTest() {
+        // task not exist
+        executeTask2TaskNotExistTest();
+        // CallClusterTaskAgentFailed
+        executeTask2CallClusterTaskAgentFailedTest();
+        // 暂停状态, 可以执行开始
+        executeTask2StartTest();
+        // 运行状态, 可以执行暂停
+        executeTask2PauseTest();
+        // 忽略
+        executeTask2IgnoreTest();
+        // 取消
+        executeTask2CancelTest();
+        // operation failed
+        executeTask2OperationFailedTest();
+        // 回滚 operation forbidden
+        executeTask2RollbackForbiddenTest();
+    }
+
+    private void executeTask2TaskNotExistTest() {
+        ResultStatus resultStatus = clusterTaskService.executeTask(INVALID_TASK_ID, ClusterTaskActionEnum.START.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.RESOURCE_NOT_EXIST.getCode());
+    }
+
+    private void executeTask2CallClusterTaskAgentFailedTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(null);
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        ResultStatus resultStatus = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.START.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.CALL_CLUSTER_TASK_AGENT_FAILED.getCode());
+    }
+
+    private void executeTask2StartTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.BLOCKED));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // success
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(true);
+        ResultStatus resultStatus = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.START.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+
+        // operation failed
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(false);
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.START.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void executeTask2PauseTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // success
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(true);
+        ResultStatus resultStatus = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.PAUSE.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+
+        // operation failed
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(false);
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.PAUSE.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void executeTask2IgnoreTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // success
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(true);
+        ResultStatus resultStatus = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.IGNORE.getAction(), "");
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+
+        // operation failed
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(false);
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.IGNORE.getAction(), "");
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void executeTask2CancelTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // success
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(true);
+        ResultStatus resultStatus = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.CANCEL.getAction(), "");
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+
+        // operation failed
+        Mockito.when(abstractAgent.actionTask(Mockito.anyLong(), Mockito.any())).thenReturn(false);
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.CANCEL.getAction(), "");
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void executeTask2OperationFailedTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // operation failed
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.START.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void executeTask2RollbackForbiddenTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+
+        // operation failed
+        ResultStatus resultStatus2 = clusterTaskService.executeTask(REAL_TASK_ID_IN_MYSQL, ClusterTaskActionEnum.ROLLBACK.getAction(), ADMIN);
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FORBIDDEN.getCode());
+    }
+
+    @Test
+    public void getTaskLogTest() {
+        // task not exist
+        getTaskLog2TaskNotExistTest();
+        // call cluster task agent failed
+        getTaskLog2CallClusterTaskAgentFailedTest();
+        // success
+        getTaskLog2SuccessTest();
+    }
+
+    private void getTaskLog2TaskNotExistTest() {
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(null);
+
+        Result<String> result = clusterTaskService.getTaskLog(REAL_TASK_ID_IN_MYSQL, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.TASK_NOT_EXIST.getCode());
+    }
+
+    private void getTaskLog2CallClusterTaskAgentFailedTest() {
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+        Mockito.when(abstractAgent.getTaskLog(Mockito.anyLong(), Mockito.any())).thenReturn(null);
+
+        Result<String> result = clusterTaskService.getTaskLog(REAL_TASK_ID_IN_MYSQL, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.CALL_CLUSTER_TASK_AGENT_FAILED.getCode());
+    }
+
+    private void getTaskLog2SuccessTest() {
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+        Mockito.when(abstractAgent.getTaskLog(Mockito.anyLong(), Mockito.any()))
+                .thenReturn(Result.buildSuc(new ClusterTaskLog("")));
+
+        Result<String> result = clusterTaskService.getTaskLog(REAL_TASK_ID_IN_MYSQL, ADMIN);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test
+    public void getTaskStateTest() {
+        // null
+        getTaskState2NullTest();
+        //
+        getTaskState2NotNullTest();
+    }
+
+    private void getTaskState2NullTest() {
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(null);
+
+        ClusterTaskStateEnum taskState = clusterTaskService.getTaskState(REAL_TASK_ID_IN_MYSQL);
+        Assert.assertNull(taskState);
+    }
+
+    private void getTaskState2NotNullTest() {
+
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+
+        ClusterTaskStateEnum taskState = clusterTaskService.getTaskState(REAL_TASK_ID_IN_MYSQL);
+        Assert.assertNotNull(taskState);
+    }
+
+    @Test
+    public void getTaskStatusTest() {
+        // task not exist
+        getTaskStatus2TaskNotExistTest();
+        // get failed
+        getTaskStatus2FailedTest();
+        // success
+        getTaskStatus2SuccessTest();
+    }
+
+    private void getTaskStatus2TaskNotExistTest() {
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(null);
+
+        Result<ClusterTaskStatus> result = clusterTaskService.getTaskStatus(REAL_TASK_ID_IN_MYSQL);
+        Assert.assertEquals(result.getCode(), ResultStatus.TASK_NOT_EXIST.getCode());
+    }
+
+    private void getTaskStatus2FailedTest() {
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong())).thenReturn(Result.buildFailure(""));
+
+        Result<ClusterTaskStatus> result = clusterTaskService.getTaskStatus(REAL_TASK_ID_IN_MYSQL);
+        Assert.assertEquals(result.getCode(), ResultStatus.FAIL.getCode());
+    }
+
+    private void getTaskStatus2SuccessTest() {
+        ClusterTaskDO clusterTaskDO = getClusterTaskDO();
+        Mockito.when(clusterTaskDao.getById(Mockito.anyLong())).thenReturn(clusterTaskDO);
+        Mockito.when(abstractAgent.getTaskExecuteState(Mockito.anyLong()))
+                .thenReturn(Result.buildSuc(ClusterTaskStateEnum.RUNNING));
+
+        Result<ClusterTaskStatus> result = clusterTaskService.getTaskStatus(REAL_TASK_ID_IN_MYSQL);
+        Assert.assertEquals(result.getCode(), ResultStatus.SUCCESS.getCode());
+    }
 }

kafka-manager-extends/kafka-manager-kcm/src/test/java/com/xiaojukeji/kafka/manager/kcm/KafkaFileServiceTest.java

@@ -0,0 +1,224 @@
+package com.xiaojukeji.kafka.manager.kcm;
+
+import com.xiaojukeji.kafka.manager.common.bizenum.KafkaFileEnum;
+import com.xiaojukeji.kafka.manager.common.entity.Result;
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.common.entity.dto.normal.KafkaFileDTO;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.KafkaFileDO;
+import com.xiaojukeji.kafka.manager.dao.KafkaFileDao;
+import com.xiaojukeji.kafka.manager.kcm.component.storage.AbstractStorageService;
+import com.xiaojukeji.kafka.manager.kcm.config.BaseTest;
+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.dao.DuplicateKeyException;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.web.multipart.MultipartFile;
+import org.testng.Assert;
+import org.testng.annotations.BeforeMethod;
+import org.testng.annotations.Test;
+
+/**
+ * @author xuguang
+ * @Date 2022/1/4
+ */
+public class KafkaFileServiceTest extends BaseTest {
+
+    private static final Long KAFKA_FILE_ID = 1L;
+
+    private static final String ADMIN = "admin";
+
+    private KafkaFileDTO getKafkaFileDTO() {
+        KafkaFileDTO kafkaFileDTO = new KafkaFileDTO();
+        kafkaFileDTO.setId(KAFKA_FILE_ID);
+        kafkaFileDTO.setClusterId(-1L);
+        kafkaFileDTO.setFileMd5("");
+        kafkaFileDTO.setFileName(".tgz");
+        kafkaFileDTO.setFileType(KafkaFileEnum.PACKAGE.getCode());
+        kafkaFileDTO.setUploadFile(new MockMultipartFile("name", new byte[]{1}));
+        return kafkaFileDTO;
+    }
+
+    private KafkaFileDO getKafkaFileDO() {
+        KafkaFileDO kafkaFileDO = new KafkaFileDO();
+        kafkaFileDO.setFileType(KafkaFileEnum.PACKAGE.getCode());
+        kafkaFileDO.setFileName(".tgz");
+        return kafkaFileDO;
+    }
+
+    @Autowired
+    @InjectMocks
+    private KafkaFileService kafkaFileService;
+
+    @Mock
+    private KafkaFileDao kafkaFileDao;
+
+    @Mock
+    private AbstractStorageService storageService;
+
+    @BeforeMethod
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void uploadKafkaFile() {
+        // paramIllegal
+        uploadKafkaFile2ParamIllegalTest();
+        // mysqlError
+        uploadKafkaFile2MysqlErrorTest();
+        // storage upload file failed
+        uploadKafkaFile2StorageUploadFileFailedTest();
+        // success
+        uploadKafkaFile2SuccessTest();
+        // DuplicateKey
+        uploadKafkaFile2DuplicateKeyTest();
+    }
+
+    private void uploadKafkaFile2ParamIllegalTest() {
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        kafkaFileDTO.setUploadFile(null);
+        ResultStatus resultStatus = kafkaFileService.uploadKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void uploadKafkaFile2MysqlErrorTest() {
+        Mockito.when(kafkaFileDao.insert(Mockito.any())).thenReturn(-1);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus = kafkaFileService.uploadKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.MYSQL_ERROR.getCode());
+    }
+
+    private void uploadKafkaFile2StorageUploadFileFailedTest() {
+        Mockito.when(kafkaFileDao.insert(Mockito.any())).thenReturn(1);
+        Mockito.when(kafkaFileDao.deleteById(Mockito.any())).thenReturn(1);
+        Mockito.when(storageService.upload(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(false);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus = kafkaFileService.uploadKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.STORAGE_UPLOAD_FILE_FAILED.getCode());
+    }
+
+    private void uploadKafkaFile2SuccessTest() {
+        Mockito.when(kafkaFileDao.insert(Mockito.any())).thenReturn(1);
+        Mockito.when(kafkaFileDao.deleteById(Mockito.any())).thenReturn(1);
+        Mockito.when(storageService.upload(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus = kafkaFileService.uploadKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    private void uploadKafkaFile2DuplicateKeyTest() {
+        Mockito.when(kafkaFileDao.insert(Mockito.any())).thenThrow(DuplicateKeyException.class);
+        Mockito.when(kafkaFileDao.deleteById(Mockito.any())).thenReturn(1);
+        Mockito.when(storageService.upload(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus = kafkaFileService.uploadKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.RESOURCE_ALREADY_EXISTED.getCode());
+    }
+
+
+    @Test
+    public void modifyKafkaFileTest() {
+        // paramIllegal
+        modifyKafkaFile2ParamIllegalTest();
+        // resource not exist
+        modifyKafkaFile2ResourceNotExistTest();
+        // operation failed
+        modifyKafkaFile2OperationFailedTest();
+        // mysqlError
+        modifyKafkaFile2MysqlErrorTest();
+        // success
+        modifyKafkaFile2SuccessTest();
+    }
+
+    private void modifyKafkaFile2ParamIllegalTest() {
+        ResultStatus resultStatus = kafkaFileService.modifyKafkaFile(null, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
+    }
+
+    private void modifyKafkaFile2ResourceNotExistTest() {
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(null);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus = kafkaFileService.modifyKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.RESOURCE_NOT_EXIST.getCode());
+    }
+
+    private void modifyKafkaFile2OperationFailedTest() {
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(new KafkaFileDO());
+        Mockito.when(kafkaFileDao.updateById(Mockito.any())).thenReturn(-1);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        kafkaFileDTO.setFileType(-1);
+        ResultStatus resultStatus1 = kafkaFileService.modifyKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus1.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+
+        kafkaFileDTO.setFileType(KafkaFileEnum.PACKAGE.getCode());
+        kafkaFileDTO.setFileName("xxx");
+        ResultStatus resultStatus2 = kafkaFileService.modifyKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus2.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    private void modifyKafkaFile2MysqlErrorTest() {
+        KafkaFileDO kafkaFileDO = getKafkaFileDO();
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(kafkaFileDO);
+        Mockito.when(kafkaFileDao.updateById(Mockito.any())).thenReturn(-1);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus1 = kafkaFileService.modifyKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus1.getCode(), ResultStatus.MYSQL_ERROR.getCode());
+
+    }
+
+    private void modifyKafkaFile2SuccessTest() {
+        KafkaFileDO kafkaFileDO = getKafkaFileDO();
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(kafkaFileDO);
+        Mockito.when(kafkaFileDao.updateById(Mockito.any())).thenReturn(1);
+        Mockito.when(storageService.upload(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(true);
+
+        KafkaFileDTO kafkaFileDTO = getKafkaFileDTO();
+        ResultStatus resultStatus1 = kafkaFileService.modifyKafkaFile(kafkaFileDTO, ADMIN);
+        Assert.assertEquals(resultStatus1.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test
+    public void downloadKafkaFileTest() {
+        // resource not exist
+        downloadKafkaFile2ResourceNotExist();
+        // STORAGE_FILE_TYPE_NOT_SUPPORT
+        downloadKafkaFile2FileNotSupportExist();
+        // success
+        downloadKafkaFile2SuccessExist();
+    }
+
+    private void downloadKafkaFile2ResourceNotExist() {
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(null);
+        Result<MultipartFile> resultStatus = kafkaFileService.downloadKafkaFile(KAFKA_FILE_ID);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.RESOURCE_NOT_EXIST.getCode());
+    }
+
+    private void downloadKafkaFile2FileNotSupportExist() {
+        KafkaFileDO kafkaFileDO = getKafkaFileDO();
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(kafkaFileDO);
+        Result<MultipartFile> resultStatus = kafkaFileService.downloadKafkaFile(KAFKA_FILE_ID);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.STORAGE_FILE_TYPE_NOT_SUPPORT.getCode());
+    }
+
+    private void downloadKafkaFile2SuccessExist() {
+        Mockito.when(storageService.download(Mockito.any(), Mockito.any())).thenReturn(Result.buildFrom(ResultStatus.SUCCESS));
+        KafkaFileDO kafkaFileDO = getKafkaFileDO();
+        kafkaFileDO.setFileType(KafkaFileEnum.SERVER_CONFIG.getCode());
+        Mockito.when(kafkaFileDao.getById(Mockito.anyLong())).thenReturn(kafkaFileDO);
+
+        Result<MultipartFile> resultStatus = kafkaFileService.downloadKafkaFile(KAFKA_FILE_ID);
+        Assert.assertEquals(resultStatus.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+
+}