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