BrokerServiceTest && KafkaBillService && LogicalClusterServiceTest && AbstractAllocateQuotaStrategy && AbstractHealthScoreStrategy 单元测试

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

@@ -0,0 +1,300 @@
+package com.xiaojukeji.kafka.manager.service.service;
+
+import com.xiaojukeji.kafka.manager.common.entity.ResultStatus;
+import com.xiaojukeji.kafka.manager.common.entity.ao.BrokerBasicDTO;
+import com.xiaojukeji.kafka.manager.common.entity.ao.BrokerOverviewDTO;
+import com.xiaojukeji.kafka.manager.common.entity.ao.TopicDiskLocation;
+import com.xiaojukeji.kafka.manager.common.entity.metrics.BrokerMetrics;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.BrokerDO;
+import com.xiaojukeji.kafka.manager.common.entity.pojo.BrokerMetricsDO;
+import com.xiaojukeji.kafka.manager.common.zookeeper.znode.brokers.BrokerMetadata;
+import com.xiaojukeji.kafka.manager.service.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.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.*;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/10
+ */
+public class BrokerServiceTest extends BaseTest {
+
+    @Autowired
+    @InjectMocks
+    private BrokerService brokerService;
+
+    @Mock
+    private JmxService jmxService;
+
+    @BeforeMethod
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @DataProvider(name = "provideBrokerDO")
+    public static Object[][] provideBrokerDO() {
+        BrokerDO brokerDO = new BrokerDO();
+        brokerDO.setClusterId(1L);
+        brokerDO.setBrokerId(100);
+        brokerDO.setHost("127.0.0.1");
+        brokerDO.setPort(9093);
+        brokerDO.setTimestamp(1638605696062L);
+        brokerDO.setMaxAvgBytesIn(0d);
+        brokerDO.setStatus(0);
+        brokerDO.setGmtCreate(new Date(1638605696062L));
+        brokerDO.setGmtModify(new Date(1638605696062L));
+        return new Object[][]{{brokerDO}};
+    }
+
+    @DataProvider(name = "provideBrokerMetadata")
+    public static Object[][] provideBrokerMetadata() {
+        BrokerMetadata brokerMetadata = new BrokerMetadata();
+        brokerMetadata.setBrokerId(1);
+        brokerMetadata.setClusterId(1L);
+        brokerMetadata.setHost("127.0.0.1");
+        brokerMetadata.setPort(9092);
+        brokerMetadata.setEndpoints(Arrays.asList("SASL_PLAINTEXT://10.179.162.202:9093"));
+        brokerMetadata.setTimestamp(1638605696062L);
+        brokerMetadata.setJmxPort(9999);
+        brokerMetadata.setRack("CY");
+        brokerMetadata.setVersion("2");
+        return new Object[][] {{brokerMetadata}};
+    }
+
+    public BrokerMetrics getBrokerMetrics() {
+        BrokerMetrics brokerMetrics = new BrokerMetrics(1L, 1);
+        Map<String, Object> metricsMap = new HashMap<>();
+        metricsMap.put("PartitionCountValue", 100);
+        metricsMap.put("LeaderCountValue", 100);
+        brokerMetrics.setMetricsMap(metricsMap);
+        return brokerMetrics;
+    }
+
+    @Test(dataProvider = "provideBrokerDO")
+    public void replaceTest(BrokerDO brokerDO) {
+        int result = brokerService.replace(brokerDO);
+        Assert.assertEquals(result, 2);
+    }
+
+    public void delete2operationFailedTest(BrokerDO brokerDO) {
+        brokerService.replace(brokerDO);
+
+        ResultStatus res = brokerService.delete(100L, brokerDO.getBrokerId());
+        Assert.assertEquals(res.getCode(), ResultStatus.OPERATION_FAILED.getCode());
+    }
+
+    public void delete2SuccessTest(BrokerDO brokerDO) {
+        brokerService.replace(brokerDO);
+
+        ResultStatus res = brokerService.delete(1L, brokerDO.getBrokerId());
+        Assert.assertEquals(res.getCode(), ResultStatus.SUCCESS.getCode());
+    }
+
+    @Test(dataProvider = "provideBrokerDO", description = "测试删除broker")
+    public void deleteTest(BrokerDO brokerDO) {
+        // 删除broker成功
+        delete2SuccessTest(brokerDO);
+        // 删除broker时，出现operation failed
+        delete2operationFailedTest(brokerDO);
+    }
+
+    @Test(dataProvider = "provideBrokerDO")
+    public void listAllTest(BrokerDO brokerDO) {
+        brokerService.replace(brokerDO);
+
+        List<BrokerDO> brokerDOS = brokerService.listAll();
+        Assert.assertFalse(brokerDOS.isEmpty());
+        Assert.assertTrue(brokerDOS.stream().allMatch(broker ->
+                broker.getClusterId().equals(brokerDO.getClusterId())));
+    }
+
+    @Test
+    public void getBrokerVersionTest() {
+        String version = "1.4";
+        Mockito.when(jmxService.getBrokerVersion(Mockito.anyLong(), Mockito.anyInt())).thenReturn(version);
+
+        String brokerVersion = brokerService.getBrokerVersion(1L, 1);
+        Assert.assertNotNull(brokerVersion);
+        Assert.assertEquals(brokerVersion, version);
+    }
+
+    @Test(description = "根据Cluster和brokerId获取broker的具体信息测试")
+    public void getBrokerBasicDTO() {
+        // 测试结果为null
+        getBrokerBasicDTO2nullTest();
+        // 获取的brokerMetrics为空
+        getBrokerBasicDTO2brokerMetricsNullTest();
+        // 获取的brokerMetrics不为空
+        getBrokerBasicDTO2brokerMetricsNotNullTest();
+    }
+
+    private void getBrokerBasicDTO2nullTest() {
+        BrokerBasicDTO result1 = brokerService.getBrokerBasicDTO(null, 1);
+        Assert.assertNull(result1);
+
+        BrokerBasicDTO result2 = brokerService.getBrokerBasicDTO(1L, null);
+        Assert.assertNull(result2);
+
+        BrokerBasicDTO result3 = brokerService.getBrokerBasicDTO(100L, 100);
+        Assert.assertNull(result3);
+    }
+
+    private void getBrokerBasicDTO2brokerMetricsNullTest() {
+        BrokerBasicDTO result1 = brokerService.getBrokerBasicDTO(1L, 1);
+        Assert.assertNotNull(result1);
+        Assert.assertNull(result1.getPartitionCount());
+        Assert.assertNull(result1.getLeaderCount());
+    }
+
+    private void getBrokerBasicDTO2brokerMetricsNotNullTest() {
+        Mockito.when(jmxService.getBrokerMetrics(
+                Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(getBrokerMetrics());
+
+        BrokerBasicDTO result1 = brokerService.getBrokerBasicDTO(1L, 1);
+        Assert.assertNotNull(result1);
+        Assert.assertNotNull(result1.getPartitionCount());
+        Assert.assertNotNull(result1.getLeaderCount());
+    }
+
+    @Test(description = "根据时间区间获取Broker监控数据测试")
+    public void getBrokerMetricsFromDBTest() {
+        long startTime = 1639360565000L;
+        long endTime = 1639407365000L;
+        List<BrokerMetricsDO> brokerMetricsDOList = brokerService.getBrokerMetricsFromDB(
+                1L, 1, new Date(startTime), new Date(endTime));
+        Assert.assertFalse(brokerMetricsDOList.isEmpty());
+        Assert.assertTrue(brokerMetricsDOList.stream().allMatch(brokerMetricsDO ->
+                brokerMetricsDO.getClusterId().equals(1L) &&
+                brokerMetricsDO.getBrokerId().equals(1) &&
+                brokerMetricsDO.getGmtCreate().after(new Date(startTime)) &&
+                brokerMetricsDO.getGmtCreate().before(new Date(endTime))));
+    }
+
+    @Test
+    public void getBrokerTopicLocationTest() {
+        // TODO 待补充， jmxService和topicService测试完成后
+        List<TopicDiskLocation> brokerTopicLocations = brokerService.getBrokerTopicLocation(1L, 1);
+        Assert.assertFalse(brokerTopicLocations.isEmpty());
+        Assert.assertTrue(brokerTopicLocations.stream().allMatch(brokerTopicLocation ->
+                brokerTopicLocation.getClusterId().equals(1L) &&
+                brokerTopicLocation.getBrokerId().equals(1)));
+    }
+
+    @Test(description = "计算Broker的峰值均值流量测试")
+    public void calBrokerMaxAvgBytesInTest() {
+        // 参数异常
+        calBrokerMaxAvgBytesIn2ParamIllegalTest();
+        // 获取的指标为空
+        calBrokerMaxAvgBytesIn2ZeroTest();
+        // 整个流程
+        calBrokerMaxAvgBytesIn2Success();
+    }
+
+    private void calBrokerMaxAvgBytesIn2ParamIllegalTest() {
+        Double result1 = brokerService.calBrokerMaxAvgBytesIn(null, 1, 1, new Date(), new Date());
+        Assert.assertEquals(result1, -1.0);
+        Double result2 = brokerService.calBrokerMaxAvgBytesIn(1L, null, 1, new Date(), new Date());
+        Assert.assertEquals(result2, -1.0);
+        Double result3 = brokerService.calBrokerMaxAvgBytesIn(1L, 1, null, new Date(), new Date());
+        Assert.assertEquals(result3, -1.0);
+        Double result4 = brokerService.calBrokerMaxAvgBytesIn(1L, 1, 1, null, new Date());
+        Assert.assertEquals(result4, -1.0);
+        Double result5 = brokerService.calBrokerMaxAvgBytesIn(1L, 1, 1, new Date(), null);
+        Assert.assertEquals(result5, -1.0);
+    }
+
+    private void calBrokerMaxAvgBytesIn2ZeroTest() {
+        Double result = brokerService.calBrokerMaxAvgBytesIn(1L, 100, 100, new Date(), new Date());
+        Assert.assertEquals(result, 0.0);
+    }
+
+    private void calBrokerMaxAvgBytesIn2Success() {
+        long startTime = 1639360565000L;
+        long endTime = 1639407365000L;
+        Double result = brokerService.calBrokerMaxAvgBytesIn(
+                1L, 1, 2, new Date(startTime), new Date(endTime));
+        Assert.assertTrue(result > 0.0);
+    }
+
+    @Test(description = "获取BrokerMetrics信息测试，单个broker")
+    public void getBrokerMetricsFromJmxTest() {
+        // 参数错误
+        getBrokerMetricsFromJmx2ParamIllegalTest();
+        // 返回为null
+        getBrokerMetricsFromJmx2nullTest();
+        // 获取成功
+        getBrokerMetricsFromJmx2SuccessTest();
+    }
+
+    private void getBrokerMetricsFromJmx2ParamIllegalTest() {
+        BrokerMetrics result1 = brokerService.getBrokerMetricsFromJmx(null, 1, 200);
+        Assert.assertNull(result1);
+
+        BrokerMetrics result3 = brokerService.getBrokerMetricsFromJmx(1L, 1, null);
+        Assert.assertNull(result3);
+    }
+
+    private void getBrokerMetricsFromJmx2nullTest() {
+        BrokerMetrics result1 = brokerService.getBrokerMetricsFromJmx(1L, 1, 200);
+        Assert.assertNull(result1);
+    }
+
+    private void getBrokerMetricsFromJmx2SuccessTest() {
+        Mockito.when(jmxService.getBrokerMetrics(
+                Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(new BrokerMetrics(1L, 1));
+        BrokerMetrics result1 = brokerService.getBrokerMetricsFromJmx(1L, 1, 200);
+        Assert.assertNotNull(result1);
+        Assert.assertEquals(Optional.ofNullable(result1.getClusterId()), Optional.ofNullable(1L));
+        Assert.assertEquals(Optional.ofNullable(result1.getBrokerId()), Optional.ofNullable(1));
+    }
+
+    @Test(description = "获取BrokerMetrics信息测试，多个broker")
+    public void getBrokerMetricsFromJmxWithMoreBrokersTest() {
+        Mockito.when(jmxService.getBrokerMetrics(
+                Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(new BrokerMetrics(1L, 1));
+
+        Set<Integer> set = new HashSet<>();
+        set.add(1);
+        set.add(2);
+        set.add(3);
+        List<BrokerMetrics> result = brokerService.getBrokerMetricsFromJmx(1L, set, 200);
+        Assert.assertNotNull(result);
+        Assert.assertTrue(result.stream().allMatch(brokerMetric ->
+                brokerMetric.getClusterId().equals(1L)));
+    }
+
+    @Test(description = "获取Broker列表信息")
+    public void getBrokerOverviewListTest() {
+        // brokerIdSet为空时
+        getBrokerOverviewList2BrokerIdSetIsNullTest();
+        // brokerIdSet不为空时
+        getBrokerOverviewList2BrokerIdSetNotNullTest();
+    }
+
+    private void getBrokerOverviewList2BrokerIdSetIsNullTest() {
+        List<BrokerOverviewDTO> brokerOverviewList = brokerService.getBrokerOverviewList(1L, null);
+        Assert.assertFalse(brokerOverviewList.isEmpty());
+        Assert.assertTrue(brokerOverviewList.stream().allMatch(brokerOverviewDTO ->
+                brokerOverviewDTO.getPort().equals(9093)));
+    }
+
+    private void getBrokerOverviewList2BrokerIdSetNotNullTest() {
+        Set<Integer> set = new HashSet<>();
+        set.add(1);
+        set.add(2);
+        List<BrokerOverviewDTO> brokerOverviewList = brokerService.getBrokerOverviewList(1L, set);
+        Assert.assertFalse(brokerOverviewList.isEmpty());
+        Assert.assertTrue(brokerOverviewList.stream().allMatch(brokerOverviewDTO ->
+                brokerOverviewDTO.getPort().equals(9093)));
+    }
+
+
+}

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

@@ -0,0 +1,172 @@
+package com.xiaojukeji.kafka.manager.service.service;
+
+import com.xiaojukeji.kafka.manager.common.entity.pojo.KafkaBillDO;
+import com.xiaojukeji.kafka.manager.dao.KafkaBillDao;
+import com.xiaojukeji.kafka.manager.service.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.DataProvider;
+import org.testng.annotations.Test;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/14
+ */
+public class KafkaBillServiceTest extends BaseTest {
+
+    @Autowired
+    @InjectMocks
+    private KafkaBillService kafkaBillService;
+
+    @Mock
+    private KafkaBillDao kafkaBillDao;
+
+    @BeforeMethod
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @DataProvider(name = "provideKafkaBillDO")
+    public static Object[][] provideKafkaBillDO() {
+        KafkaBillDO kafkaBillDO = new KafkaBillDO();
+        kafkaBillDO.setClusterId(1L);
+        kafkaBillDO.setCost(100.0d);
+        kafkaBillDO.setGmtCreate(new Date(1638605696062L));
+        kafkaBillDO.setGmtDay("10");
+        kafkaBillDO.setPrincipal("admin");
+        kafkaBillDO.setQuota(1000.0d);
+        kafkaBillDO.setTopicName("moduleTest");
+        return new Object[][] {{kafkaBillDO}};
+    }
+
+    @Test(dataProvider = "provideKafkaBillDO")
+    public void replaceTest(KafkaBillDO kafkaBillDO) {
+        // 插入成功
+        replace2SuccessTest(kafkaBillDO);
+        // 插入失败
+        replace2ExceptionTest(kafkaBillDO);
+    }
+
+    private void replace2SuccessTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.replace(Mockito.any())).thenReturn(1);
+        int result = kafkaBillService.replace(kafkaBillDO);
+        Assert.assertEquals(result, 1);
+    }
+
+    private void replace2ExceptionTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.replace(Mockito.any())).thenThrow(RuntimeException.class);
+        int result = kafkaBillService.replace(kafkaBillDO);
+        Assert.assertEquals(result, 0);
+    }
+
+    @Test(dataProvider = "provideKafkaBillDO")
+    public void getByTopicNameTest(KafkaBillDO kafkaBillDO) {
+        // 查询成功
+        getByTopicName2SuccessTest(kafkaBillDO);
+        // 查询异常
+        getByTopicName2ExceptionTest();
+
+    }
+
+    private void getByTopicName2SuccessTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.getByTopicName(
+                Mockito.anyLong(), Mockito.anyString(), Mockito.any(), Mockito.any())).thenReturn(Arrays.asList(kafkaBillDO));
+        List<KafkaBillDO> result = kafkaBillService.getByTopicName(1L, "moudleTest", new Date(0L), new Date());
+        Assert.assertFalse(result.isEmpty());
+        Assert.assertTrue(result.stream().allMatch(kafkaBillDO1 ->
+                kafkaBillDO1.getTopicName().equals(kafkaBillDO.getTopicName()) &&
+                        kafkaBillDO1.getClusterId().equals(kafkaBillDO.getClusterId())));
+    }
+
+    private void getByTopicName2ExceptionTest() {
+        Mockito.when(kafkaBillDao.getByTopicName(
+                Mockito.anyLong(), Mockito.anyString(), Mockito.any(), Mockito.any())).thenThrow(RuntimeException.class);
+        List<KafkaBillDO> result = kafkaBillService.getByTopicName(1L, "moudleTest", new Date(0L), new Date());
+        Assert.assertTrue(result.isEmpty());
+    }
+
+    @Test(dataProvider = "provideKafkaBillDO")
+    public void getByPrincipalTest(KafkaBillDO kafkaBillDO) {
+        // 查询成功
+        getByPrincipal2SuccessTest(kafkaBillDO);
+        // 查询失败
+        getByPrincipal2ExceptionTest();
+    }
+
+    private void getByPrincipal2SuccessTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.getByPrincipal(
+                Mockito.anyString(), Mockito.any(), Mockito.any())).thenReturn(Arrays.asList(kafkaBillDO));
+        List<KafkaBillDO> result = kafkaBillService.getByPrincipal("admin", new Date(0L), new Date());
+        Assert.assertFalse(result.isEmpty());
+        Assert.assertTrue(result.stream().allMatch(kafkaBillDO1 ->
+                kafkaBillDO1.getTopicName().equals(kafkaBillDO.getTopicName()) &&
+                        kafkaBillDO1.getClusterId().equals(kafkaBillDO.getClusterId())));
+    }
+
+    private void getByPrincipal2ExceptionTest() {
+        Mockito.when(kafkaBillDao.getByPrincipal(
+                Mockito.anyString(), Mockito.any(), Mockito.any())).thenThrow(RuntimeException.class);
+        List<KafkaBillDO> result = kafkaBillService.getByPrincipal("admin", new Date(0L), new Date());
+        Assert.assertTrue(result.isEmpty());
+    }
+
+    @Test(dataProvider = "provideKafkaBillDO")
+    public void getByTimeBetweenTest(KafkaBillDO kafkaBillDO) {
+        // 查询成功
+        getByTimeBetween2SuccessTest(kafkaBillDO);
+        // 查询失败
+        getByTimeBetween2ExceptionTest();
+    }
+
+    private void getByTimeBetween2SuccessTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.getByTimeBetween(
+                Mockito.any(), Mockito.any())).thenReturn(Arrays.asList(kafkaBillDO));
+        List<KafkaBillDO> result = kafkaBillService.getByTimeBetween(new Date(0L), new Date());
+        Assert.assertFalse(result.isEmpty());
+        Assert.assertTrue(result.stream().allMatch(kafkaBillDO1 ->
+                kafkaBillDO1.getTopicName().equals(kafkaBillDO.getTopicName()) &&
+                        kafkaBillDO1.getClusterId().equals(kafkaBillDO.getClusterId())));
+    }
+
+    private void getByTimeBetween2ExceptionTest() {
+        Mockito.when(kafkaBillDao.getByTimeBetween(
+                Mockito.any(), Mockito.any())).thenThrow(RuntimeException.class);
+        List<KafkaBillDO> result = kafkaBillService.getByTimeBetween(new Date(0L), new Date());
+        Assert.assertTrue(result.isEmpty());
+    }
+
+    @Test(dataProvider = "provideKafkaBillDO")
+    public void getByGmtDayTest(KafkaBillDO kafkaBillDO) {
+        // 查询成功
+        getByGmtDay2SuccessTest(kafkaBillDO);
+        // 查询失败
+        getByGmtDay2ExceptionTest();
+    }
+
+    private void getByGmtDay2SuccessTest(KafkaBillDO kafkaBillDO) {
+        Mockito.when(kafkaBillDao.getByGmtDay(
+                Mockito.anyString())).thenReturn(Arrays.asList(kafkaBillDO));
+        List<KafkaBillDO> result = kafkaBillService.getByGmtDay("10");
+        Assert.assertFalse(result.isEmpty());
+        Assert.assertTrue(result.stream().allMatch(kafkaBillDO1 ->
+                kafkaBillDO1.getTopicName().equals(kafkaBillDO.getTopicName()) &&
+                        kafkaBillDO1.getClusterId().equals(kafkaBillDO.getClusterId())));
+    }
+
+    private void getByGmtDay2ExceptionTest() {
+        Mockito.when(kafkaBillDao.getByGmtDay(
+                Mockito.anyString())).thenThrow(RuntimeException.class);
+        List<KafkaBillDO> result = kafkaBillService.getByGmtDay("10");
+        Assert.assertTrue(result.isEmpty());
+    }
+
+}

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

@@ -93,14 +93,27 @@ public class LogicalClusterServiceTest extends BaseTest {
         return appDO;
     }
 
-    @Test(description = "创建逻辑集群时参数错误")
+    @Test(description = "测试创建逻辑集群")
-    public void createLogicalCluster2paramIllegalTest() {
+    public void createLogicalCluster() {
+        // 创建逻辑集群时参数错误
+        createLogicalCluster2paramIllegalTest();
+        // 创建逻辑集群时,region已使用
+        createLogicalCluster2existRegionAlreadyInUseTest();
+        // 创建逻辑集群时,物理集群不存在
+        createLogicalCluster2PhysicalClusterNotExistTest();
+        // 创建逻辑集群时,不存在region已使用
+        createLogicalCluster2NotexistRegionAlreadyInUseTest();
+        // 创建逻辑集群成功
+        createLogicalCluster2SuccessTest();
+    }
+
+    private void createLogicalCluster2paramIllegalTest() {
         ResultStatus result = logicalClusterService.createLogicalCluster(null);
         Assert.assertEquals(result.getCode(), ResultStatus.PARAM_ILLEGAL.getCode());
     }
 
-    @Test(dataProvider = "provideLogicalClusterDO", description = "创建逻辑集群时,region已使用")
+    private void createLogicalCluster2existRegionAlreadyInUseTest() {
-    public void createLogicalCluster2existRegionAlreadyInUseTest(LogicalClusterDO logicalClusterDO) {
+        LogicalClusterDO logicalClusterDO = getLogicalClusterDO();
         // 物理集群Id为null
         logicalClusterDO.setClusterId(null);
         ResultStatus result1 = logicalClusterService.createLogicalCluster(logicalClusterDO);
@@ -118,8 +131,8 @@ public class LogicalClusterServiceTest extends BaseTest {
         Assert.assertEquals(result3.getCode(), ResultStatus.RESOURCE_ALREADY_USED.getCode());
     }
 
-    @Test(dataProvider = "provideLogicalClusterDO", description = "创建逻辑集群时,物理集群不存在")
+    private void createLogicalCluster2PhysicalClusterNotExistTest() {
-    public void createLogicalCluster2PhysicalClusterNotExistTest(LogicalClusterDO logicalClusterDO) {
+        LogicalClusterDO logicalClusterDO = getLogicalClusterDO();
         Mockito.when(logicalClusterDao.insert(Mockito.any())).thenReturn(1);
         // 不存在该物理集群情况
         logicalClusterDO.setClusterId(100L);
@@ -128,8 +141,8 @@ public class LogicalClusterServiceTest extends BaseTest {
         Assert.assertEquals(result1.getCode(), ResultStatus.SUCCESS.getCode());
     }
 
-    @Test(dataProvider = "provideLogicalClusterDO", description = "创建逻辑集群时,不存在region已使用")
+    private void createLogicalCluster2NotexistRegionAlreadyInUseTest() {
-    public void createLogicalCluster2NotexistRegionAlreadyInUseTest(LogicalClusterDO logicalClusterDO) {
+        LogicalClusterDO logicalClusterDO = getLogicalClusterDO();
         Mockito.when(logicalClusterDao.insert(Mockito.any())).thenReturn(1);
         // region没有存在使用
         ResultStatus result2 = logicalClusterService.createLogicalCluster(logicalClusterDO);
@@ -137,16 +150,17 @@ public class LogicalClusterServiceTest extends BaseTest {
         Assert.assertEquals(result2.getCode(), ResultStatus.SUCCESS.getCode());
     }
 
-    @Test(dataProvider = "provideLogicalClusterDO", description = "创建逻辑集群时,不存在region已使用")
+    @Test(description = "创建逻辑集群时,不存在region已使用(键重复)")
-    public void createLogicalCluster2DuplicateKeyTest(LogicalClusterDO logicalClusterDO) {
+    private void createLogicalCluster2DuplicateKeyTest() {
+        LogicalClusterDO logicalClusterDO = getLogicalClusterDO();
         Mockito.when(logicalClusterDao.insert(Mockito.any())).thenThrow(DuplicateKeyException.class);
         logicalClusterDO.setRegionList("100");
         ResultStatus result3 = logicalClusterService.createLogicalCluster(logicalClusterDO);
         Assert.assertEquals(result3.getCode(), ResultStatus.RESOURCE_ALREADY_EXISTED.getCode());
     }
 
-    @Test(dataProvider = "provideLogicalClusterDO", description = "创建逻辑集群成功")
+    private void createLogicalCluster2SuccessTest() {
-    public void createLogicalCluster2SuccessTest(LogicalClusterDO logicalClusterDO) {
+        LogicalClusterDO logicalClusterDO = getLogicalClusterDO();
         Mockito.when(logicalClusterDao.insert(Mockito.any())).thenReturn(1);
 
         ResultStatus result3 = logicalClusterService.createLogicalCluster(logicalClusterDO);

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

@@ -0,0 +1,35 @@
+package com.xiaojukeji.kafka.manager.service.strategy;
+
+import com.xiaojukeji.kafka.manager.common.entity.ao.gateway.TopicQuota;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import org.junit.Assert;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.testng.annotations.Test;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/15
+ */
+public class AbstractAllocateQuotaStrategyTest extends BaseTest {
+
+    @Autowired
+    private AbstractAllocateQuotaStrategy abstractAllocateQuotaStrategy;
+
+    private TopicQuota getTopicQuota() {
+        TopicQuota topicQuota = new TopicQuota();
+        topicQuota.setTopicName("xxx");
+        topicQuota.setConsumeQuota(1000L);
+        topicQuota.setProduceQuota(1000L);
+        topicQuota.setAppId("xxxAppId");
+        topicQuota.setClusterId(1L);
+        return topicQuota;
+    }
+
+    @Test
+    public void getNewTopicQuotaTest() {
+        TopicQuota topicQuota = getTopicQuota();
+        TopicQuota newTopicQuota = abstractAllocateQuotaStrategy.getNewTopicQuota(topicQuota, 3, 1000L);
+        Assert.assertNotNull(newTopicQuota);
+        Assert.assertEquals(newTopicQuota.toString(), topicQuota.toString());
+    }
+}

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

@@ -0,0 +1,231 @@
+package com.xiaojukeji.kafka.manager.service.strategy;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.xiaojukeji.kafka.manager.common.constant.Constant;
+import com.xiaojukeji.kafka.manager.common.entity.metrics.BrokerMetrics;
+import com.xiaojukeji.kafka.manager.service.config.BaseTest;
+import com.xiaojukeji.kafka.manager.service.service.JmxService;
+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.HashMap;
+import java.util.Map;
+
+/**
+ * @author xuguang
+ * @Date 2021/12/15
+ */
+public class AbstractHealthScoreStrategyTest extends BaseTest {
+
+    private BrokerMetrics getBrokerMetrics() {
+        BrokerMetrics brokerMetrics = new BrokerMetrics(1L, 1);
+        String metrics = "{\"TotalFetchRequestsPerSecFiveMinuteRate\":4.132236103122026,\"BytesRejectedPerSecFiveMinuteRate\":0.0,\"TotalFetchRequestsPerSecFifteenMinuteRate\":1.5799208507558833,\"ProduceTotalTimeMs98thPercentile\":0.0,\"MessagesInPerSecMeanRate\":0.0,\"ProduceTotalTimeMs75thPercentile\":0.0,\"ProduceTotalTimeMs99thPercentile\":0.0,\"TotalProduceRequestsPerSecOneMinuteRate\":0.0,\"FailedProduceRequestsPerSecFifteenMinuteRate\":0.0,\"BytesInPerSecMeanRate\":0.0,\"TotalProduceRequestsPerSecFiveMinuteRate\":0.0,\"FetchConsumerTotalTimeMs999thPercentile\":0.0,\"FetchConsumerTotalTimeMs98thPercentile\":0.0,\"FetchConsumerTotalTimeMsMean\":0.0,\"FetchConsumerTotalTimeMs99thPercentile\":0.0,\"FailedFetchRequestsPerSecFifteenMinuteRate\":0.0,\"MessagesInPerSecFiveMinuteRate\":0.0,\"RequestHandlerAvgIdlePercentOneMinuteRate\":0.999221766772746,\"ProduceTotalTimeMsMean\":0.0,\"BytesInPerSecFiveMinuteRate\":0.0,\"FailedProduceRequestsPerSecMeanRate\":0.0,\"FailedFetchRequestsPerSecMeanRate\":0.0,\"FailedProduceRequestsPerSecFiveMinuteRate\":0.0,\"BytesOutPerSecFifteenMinuteRate\":0.0,\"BytesInPerSecOneMinuteRate\":0.0,\"BytesOutPerSecFiveMinuteRate\":0.0,\"HealthScore\":90,\"FailedFetchRequestsPerSecOneMinuteRate\":0.0,\"MessagesInPerSecOneMinuteRate\":0.0,\"BytesRejectedPerSecFifteenMinuteRate\":0.0,\"FailedFetchRequestsPerSecFiveMinuteRate\":0.0,\"RequestHandlerAvgIdlePercentFiveMinuteRate\":0.999803118809842,\"BytesOutPerSecOneMinuteRate\":0.0,\"ResponseQueueSizeValue\":0,\"MessagesInPerSecFifteenMinuteRate\":0.0,\"TotalProduceRequestsPerSecMeanRate\":0.0,\"BytesRejectedPerSecMeanRate\":0.0,\"TotalFetchRequestsPerSecMeanRate\":1.2674449706628523,\"NetworkProcessorAvgIdlePercentValue\":1.0,\"TotalFetchRequestsPerSecOneMinuteRate\":10.457259856316893,\"BytesInPerSecFifteenMinuteRate\":0.0,\"BytesOutPerSecMeanRate\":0.0,\"TotalProduceRequestsPerSecFifteenMinuteRate\":0.0,\"FetchConsumerTotalTimeMs50thPercentile\":0.0,\"RequestHandlerAvgIdlePercentFifteenMinuteRate\":0.9999287809186348,\"FetchConsumerTotalTimeMs95thPercentile\":0.0,\"FailedProduceRequestsPerSecOneMinuteRate\":0.0,\"CreateTime\":1638792321071,\"FetchConsumerTotalTimeMs75thPercentile\":0.0,\"ProduceTotalTimeMs999thPercentile\":0.0,\"RequestQueueSizeValue\":0,\"ProduceTotalTimeMs50thPercentile\":0.0,\"BytesRejectedPerSecOneMinuteRate\":0.0,\"RequestHandlerAvgIdlePercentMeanRate\":0.9999649184090593,\"ProduceTotalTimeMs95thPercentile\":0.0}";
+        JSONObject jsonObject = JSON.parseObject(metrics);
+        Map<String, Object> metricsMap = new HashMap<>();
+        for (Map.Entry<String, Object> stringObjectEntry : jsonObject.entrySet()) {
+            metricsMap.put(stringObjectEntry.getKey(), stringObjectEntry.getValue());
+        }
+        brokerMetrics.setMetricsMap(metricsMap);
+        return brokerMetrics;
+    }
+
+    @Autowired
+    @InjectMocks
+    private AbstractHealthScoreStrategy didiHealthScoreStrategy;
+
+    @Mock
+    private JmxService jmxService;
+
+    @BeforeMethod
+    public void setup() {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test(description = "测试计算broker健康分")
+    public void calBrokerHealthScoreWithBrokerMetricsTest() {
+        // brokerMetrics为空时
+        calBrokerHealthScoreWithBrokerMetrics2InvideCodeTest();
+        // HEALTH_SCORE_VERY_BAD
+        calBrokerHealthScoreWithBrokerMetrics2HealthScoreVeryBadTest();
+        // requestQueueSizeValue is Null or responseQueueSizeValue is Null
+        calBrokerHealthScoreWithBrokerMetrics2requestQueueSizeValueNullTest();
+        // HEALTH_SCORE_BAD
+        calBrokerHealthScoreWithBrokerMetrics2HealthScoreBadTest();
+        // requestHandlerAvgIdlePercentOneMinuteRate is null
+        calBrokerHealthScoreWithBrokerMetrics2InvideCode3Test();
+        // HEALTH_SCORE_NORMAL
+        calBrokerHealthScoreWithBrokerMetrics2HealthScoreNormalTest();
+        // HEALTH_SCORE_Healthy
+        calBrokerHealthScoreWithBrokerMetrics2HealthScoreHealthyTest();
+        // exception
+        calBrokerHealthScoreWithBrokerMetrics2ExceptionTest();
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2InvideCodeTest() {
+        Integer result1 = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, null);
+        Assert.assertEquals(result1, Constant.INVALID_CODE);
+
+        Integer result2 = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, new BrokerMetrics(1L, 1));
+        Assert.assertEquals(result2, Constant.INVALID_CODE);
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2HealthScoreVeryBadTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.02);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.02);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Integer.valueOf(30));
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2requestQueueSizeValueNullTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", null);
+        metricsMap.put("ResponseQueueSizeValue", null);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Constant.INVALID_CODE);
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2HealthScoreBadTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 500);
+        metricsMap.put("ResponseQueueSizeValue", 500);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Integer.valueOf(60));
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2InvideCode3Test() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 300);
+        metricsMap.put("ResponseQueueSizeValue", 300);
+        metricsMap.put("RequestHandlerAvgIdlePercentOneMinuteRate", null);
+        metricsMap.put("NetworkProcessorAvgIdlePercentValue", null);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Constant.INVALID_CODE);
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2HealthScoreNormalTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 300);
+        metricsMap.put("ResponseQueueSizeValue", 300);
+        metricsMap.put("RequestHandlerAvgIdlePercentOneMinuteRate", 0.0);
+        metricsMap.put("NetworkProcessorAvgIdlePercentValue", 0.0);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Integer.valueOf(90));
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2HealthScoreHealthyTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 300);
+        metricsMap.put("ResponseQueueSizeValue", 300);
+        metricsMap.put("RequestHandlerAvgIdlePercentOneMinuteRate", 100.0);
+        metricsMap.put("NetworkProcessorAvgIdlePercentValue", 100.0);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Integer.valueOf(100));
+    }
+
+    private void calBrokerHealthScoreWithBrokerMetrics2ExceptionTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 300);
+        metricsMap.put("ResponseQueueSizeValue", 300);
+        // Integer转Double出现异常
+        metricsMap.put("RequestHandlerAvgIdlePercentOneMinuteRate", 100);
+        metricsMap.put("NetworkProcessorAvgIdlePercentValue", 100);
+
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1, brokerMetrics);
+        Assert.assertEquals(result, Constant.INVALID_CODE);
+    }
+
+    @Test(description = "测试计算broker健康分")
+    public void calBrokerHealthScoreTest() {
+        // BrokerMetadata is Null
+        calBrokerHealthScore2BrokerMetadataIsNullTest();
+        // INVALID_CODE
+        calBrokerHealthScore2InvideCodeTest();
+        // success
+        calBrokerHealthScore2SuccessTest();
+    }
+
+    private void calBrokerHealthScore2BrokerMetadataIsNullTest() {
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 100);
+        Assert.assertEquals(result, Integer.valueOf(100));
+    }
+
+    private void calBrokerHealthScore2InvideCodeTest() {
+        Mockito.when(jmxService.getBrokerMetrics(Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(null);
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1);
+        Assert.assertEquals(result, Constant.INVALID_CODE);
+    }
+
+    private void calBrokerHealthScore2SuccessTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 500);
+        metricsMap.put("ResponseQueueSizeValue", 500);
+
+        Mockito.when(jmxService.getBrokerMetrics(Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(brokerMetrics);
+        Integer result = didiHealthScoreStrategy.calBrokerHealthScore(1L, 1);
+        Assert.assertEquals(result, Integer.valueOf(60));
+    }
+
+    @Test(description = "测试计算健康分")
+    public void calTopicHealthScore() {
+        // TopicMetadata为空
+        calTopicHealthScore2InvadeCodeTest();
+        // 测试计算topic健康分成功
+        calTopicHealthScore2SuccessTest();
+    }
+
+    private void calTopicHealthScore2InvadeCodeTest() {
+        Integer result = didiHealthScoreStrategy.calTopicHealthScore(1L, "xxx");
+        Assert.assertEquals(result, Constant.INVALID_CODE);
+    }
+
+    private void calTopicHealthScore2SuccessTest() {
+        BrokerMetrics brokerMetrics = getBrokerMetrics();
+        Map<String, Object> metricsMap = brokerMetrics.getMetricsMap();
+        metricsMap.put("FailedFetchRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("FailedProduceRequestsPerSecOneMinuteRate", 0.0);
+        metricsMap.put("RequestQueueSizeValue", 500);
+        metricsMap.put("ResponseQueueSizeValue", 500);
+
+        Mockito.when(jmxService.getBrokerMetrics(Mockito.anyLong(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(brokerMetrics);
+
+        Integer result = didiHealthScoreStrategy.calTopicHealthScore(1L, "xgTest");
+        Assert.assertNotEquals(result, Constant.INVALID_CODE);
+    }
+
+}