diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/BrokerServiceTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/BrokerServiceTest.java new file mode 100644 index 00000000..0ea97a1b --- /dev/null +++ b/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 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 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 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 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 set = new HashSet<>(); + set.add(1); + set.add(2); + set.add(3); + List 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 brokerOverviewList = brokerService.getBrokerOverviewList(1L, null); + Assert.assertFalse(brokerOverviewList.isEmpty()); + Assert.assertTrue(brokerOverviewList.stream().allMatch(brokerOverviewDTO -> + brokerOverviewDTO.getPort().equals(9093))); + } + + private void getBrokerOverviewList2BrokerIdSetNotNullTest() { + Set set = new HashSet<>(); + set.add(1); + set.add(2); + List brokerOverviewList = brokerService.getBrokerOverviewList(1L, set); + Assert.assertFalse(brokerOverviewList.isEmpty()); + Assert.assertTrue(brokerOverviewList.stream().allMatch(brokerOverviewDTO -> + brokerOverviewDTO.getPort().equals(9093))); + } + + +} diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/KafkaBillServiceTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/KafkaBillServiceTest.java new file mode 100644 index 00000000..8cf514a9 --- /dev/null +++ b/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 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 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 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 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 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 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 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 result = kafkaBillService.getByGmtDay("10"); + Assert.assertTrue(result.isEmpty()); + } + +} diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/LogicalClusterServiceTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/LogicalClusterServiceTest.java index 4c4c2a92..92d62c27 100644 --- a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/LogicalClusterServiceTest.java +++ b/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 = "创建逻辑集群时参数错误") - public void createLogicalCluster2paramIllegalTest() { + @Test(description = "测试创建逻辑集群") + 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已使用") - public void createLogicalCluster2existRegionAlreadyInUseTest(LogicalClusterDO logicalClusterDO) { + private void createLogicalCluster2existRegionAlreadyInUseTest() { + 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 = "创建逻辑集群时,物理集群不存在") - public void createLogicalCluster2PhysicalClusterNotExistTest(LogicalClusterDO logicalClusterDO) { + private void createLogicalCluster2PhysicalClusterNotExistTest() { + 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已使用") - public void createLogicalCluster2NotexistRegionAlreadyInUseTest(LogicalClusterDO logicalClusterDO) { + private void createLogicalCluster2NotexistRegionAlreadyInUseTest() { + 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已使用") - public void createLogicalCluster2DuplicateKeyTest(LogicalClusterDO logicalClusterDO) { + @Test(description = "创建逻辑集群时,不存在region已使用(键重复)") + 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 = "创建逻辑集群成功") - public void createLogicalCluster2SuccessTest(LogicalClusterDO logicalClusterDO) { + private void createLogicalCluster2SuccessTest() { + LogicalClusterDO logicalClusterDO = getLogicalClusterDO(); Mockito.when(logicalClusterDao.insert(Mockito.any())).thenReturn(1); ResultStatus result3 = logicalClusterService.createLogicalCluster(logicalClusterDO); diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/strategy/AbstractAllocateQuotaStrategyTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/strategy/AbstractAllocateQuotaStrategyTest.java new file mode 100644 index 00000000..80b5e1b4 --- /dev/null +++ b/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()); + } +} diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/strategy/AbstractHealthScoreStrategyTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/strategy/AbstractHealthScoreStrategyTest.java new file mode 100644 index 00000000..5cc67486 --- /dev/null +++ b/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 metricsMap = new HashMap<>(); + for (Map.Entry 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 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 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 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 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 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 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 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 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 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); + } + +}