From ec19c3b4dd6bbbcb34342c141a4b7e6b3d8b9327 Mon Sep 17 00:00:00 2001 From: didi <1643482336@qq.com> Date: Fri, 7 Jan 2022 11:43:31 +0800 Subject: [PATCH] =?UTF-8?q?monitor=E3=80=81openapi=E3=80=81account?= =?UTF-8?q?=E6=A8=A1=E5=9D=97=E4=B8=8B=E7=9A=84=E5=8D=95=E5=85=83=E6=B5=8B?= =?UTF-8?q?=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../service/service/ExpertServiceTest.java | 245 ++++++++++ .../src/test/resources/application.yml | 4 +- .../AbstractEnterpriseStaffServiceTest.java | 99 ++++ .../account/AbstractSingleSignOnTest.java | 244 ++++++++++ .../manager/account/AccountServiceTest.java | 285 ++++++++++- .../manager/account/LoginServiceTest.java | 189 +++++++- .../src/test/resources/application.yml | 4 +- .../bpm/AbstractOrderStorageServiceTest.java | 80 +++ .../src/test/resources/application.yml | 4 +- .../monitor/AbstractMonitorServiceTest.java | 53 ++ .../manager/monitor/MonitorServiceTest.java | 456 +++++++++++++++++- .../src/test/resources/application.yml | 4 +- .../kafka-manager-openapi/pom.xml | 18 + .../manager/openapi/ThirdPartServiceTest.java | 148 ++++++ .../manager/openapi/config/BaseTest.java | 11 + .../openapi/config/CoreSpringBootStartUp.java | 21 + .../openapi/config/DataSourceConfig.java | 51 ++ .../src/test/resources/application.yml | 98 ++++ .../kafka-manager-springboot-distribution.xml | 63 +++ .../src/test/resources/logback-spring.xml | 215 +++++++++ .../src/main/resources/application.yml | 4 +- 21 files changed, 2276 insertions(+), 20 deletions(-) create mode 100644 kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/ExpertServiceTest.java create mode 100644 kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractEnterpriseStaffServiceTest.java create mode 100644 kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractSingleSignOnTest.java create mode 100644 kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/AbstractOrderStorageServiceTest.java create mode 100644 kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/AbstractMonitorServiceTest.java create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/ThirdPartServiceTest.java create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/BaseTest.java create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/CoreSpringBootStartUp.java create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/DataSourceConfig.java create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/resources/application.yml create mode 100755 kafka-manager-extends/kafka-manager-openapi/src/test/resources/distribution/kafka-manager-springboot-distribution.xml create mode 100644 kafka-manager-extends/kafka-manager-openapi/src/test/resources/logback-spring.xml diff --git a/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/ExpertServiceTest.java b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/ExpertServiceTest.java new file mode 100644 index 00000000..30c3e248 --- /dev/null +++ b/kafka-manager-core/src/test/java/com/xiaojukeji/kafka/manager/service/service/ExpertServiceTest.java @@ -0,0 +1,245 @@ +package com.xiaojukeji.kafka.manager.service.service; + +import com.xiaojukeji.kafka.manager.common.entity.ao.config.expert.RegionTopicHotConfig; +import com.xiaojukeji.kafka.manager.common.entity.ao.config.expert.TopicExpiredConfig; +import com.xiaojukeji.kafka.manager.common.entity.ao.config.expert.TopicInsufficientPartitionConfig; +import com.xiaojukeji.kafka.manager.common.entity.ao.expert.TopicInsufficientPartition; +import com.xiaojukeji.kafka.manager.common.entity.ao.expert.TopicRegionHot; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.TopicExpiredDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.TopicMetricsDO; +import com.xiaojukeji.kafka.manager.dao.TopicMetricsDao; +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.Test; + +import javax.validation.constraints.AssertTrue; +import java.util.*; + +/** + * @author wyc + * @date 2021/12/27 + */ +public class ExpertServiceTest extends BaseTest { + private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private final static String REAL_TOPIC_IN_ZK = "topic_a"; + + private final static String REAL_CLUSTER_NAME_IN_ZK = "cluster1"; + + private final static Set REAL_BROKER_ID_SET = new HashSet<>(); + + private 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\":100.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}"; + static { + REAL_BROKER_ID_SET.add(1); + REAL_BROKER_ID_SET.add(2); + } + + @Autowired + @InjectMocks + private ExpertService expertService; + + @Mock + private ConfigService configService; + + @Mock + private RegionService regionService; + + @Mock + private ClusterService clusterService; + + @Mock + private TopicManagerService topicManagerService; + + @Autowired + private TopicMetricsDao topicMetricsDao; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private ClusterDO getClusterDO() { + ClusterDO clusterDO = new ClusterDO(); + clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + + return clusterDO; + } + + private RegionTopicHotConfig getRegionTopicHotConfig() { + RegionTopicHotConfig config = new RegionTopicHotConfig(); + config.setMaxDisPartitionNum(-1);// 为了通过检测 + // ignoreClusterIdList字段不用设置 + config.setMinTopicBytesInUnitB(-1L);// 为了通过检测 + return config; + } + private TopicRegionHot getTopicRegionHot() { + ClusterDO clusterDO = getClusterDO(); + TopicRegionHot hotTopic = new TopicRegionHot(clusterDO, REAL_TOPIC_IN_ZK, null, new HashMap<>()); + return hotTopic; + } + + private Map> getTopicNameRegionBrokerIdMap() { + Map> map = new HashMap<>(); + map.put(REAL_TOPIC_IN_ZK, REAL_BROKER_ID_SET); + return map; + } + + private Map> getMaxAvgBytesInMap() { + Map> map = new HashMap<>(); + map.put(REAL_TOPIC_IN_ZK, new ArrayList<>()); + return map; + } + + private TopicInsufficientPartitionConfig getTopicInsufficientPartitionConfig() { + TopicInsufficientPartitionConfig config = new TopicInsufficientPartitionConfig(); + config.setMinTopicBytesInUnitB(-1L);// 为了通过测试 + config.setMaxBytesInPerPartitionUnitB(10L);// 为了通过测试 + return config; + } + + private TopicExpiredDO getTopicExpiredDO() { + TopicExpiredDO topicExpiredDO = new TopicExpiredDO(); + topicExpiredDO.setTopicName(REAL_TOPIC_IN_ZK); + topicExpiredDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL); + return topicExpiredDO; + } + + private TopicExpiredConfig getTopicExpiredConfig() { + TopicExpiredConfig config = new TopicExpiredConfig(); + config.setIgnoreClusterIdList(new ArrayList<>()); + return config; + } + + private TopicMetricsDO getTopicMetricsDO() { + TopicMetricsDO topicMetricsDO = new TopicMetricsDO(); + topicMetricsDO.setClusterId(REAL_CLUSTER_ID_IN_MYSQL); + topicMetricsDO.setTopicName(REAL_TOPIC_IN_ZK); + topicMetricsDO.setMetrics(metrics); + return topicMetricsDO; + } + + private TopicInsufficientPartition getTopicInsufficientPartition() { + ClusterDO clusterDO = getClusterDO(); + + return new TopicInsufficientPartition( + clusterDO, + REAL_TOPIC_IN_ZK, + null, + null, + null, + null, + new ArrayList<>(REAL_BROKER_ID_SET) + ); + } + + @Test + public void getRegionHotTopicsTest() { + // 返回空集合测试 + getRegionHotTopics2EmptyTest(); + + getRegionHotTopics2SuccessTest(); + } + + private void getRegionHotTopics2EmptyTest() { + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(null); + Assert.assertTrue(expertService.getRegionHotTopics().isEmpty()); + } + + private void getRegionHotTopics2SuccessTest() { + RegionTopicHotConfig config = getRegionTopicHotConfig(); + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(config); + + ClusterDO clusterDO = getClusterDO(); + List clusterDOList = new ArrayList<>(); + clusterDOList.add(clusterDO); + Mockito.when(clusterService.list()).thenReturn(clusterDOList); + + Map> map = getTopicNameRegionBrokerIdMap(); + Mockito.when(regionService.getTopicNameRegionBrokerIdMap(Mockito.anyLong())).thenReturn(map); + + Assert.assertTrue(expertService.getRegionHotTopics().stream().allMatch(hotTopic -> hotTopic.getClusterDO().getId().equals(clusterDO.getId()))); + + } + + + + @Test + public void getPartitionInsufficientTopicsTest() { + // 返回空集合测试 + getPartitionInsufficientTopic2EmptyTest(); + + // 成功测试 + getPartitionInsufficientTopicsSuccessTest(); + } + + private void getPartitionInsufficientTopic2EmptyTest() { + TopicInsufficientPartitionConfig config = getTopicInsufficientPartitionConfig(); + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(config); + Mockito.when(clusterService.list()).thenReturn(new ArrayList<>()); + Assert.assertTrue(expertService.getPartitionInsufficientTopics().isEmpty()); + } + + private void getPartitionInsufficientTopicsSuccessTest() { + // 先向数据库中插入 + List topicMetricsDOList = new ArrayList<>(); + topicMetricsDOList.add(getTopicMetricsDO()); + topicMetricsDao.batchAdd(topicMetricsDOList); + + TopicInsufficientPartitionConfig config = getTopicInsufficientPartitionConfig(); + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(config); + + ClusterDO clusterDO = getClusterDO(); + List clusterDOList = new ArrayList<>(); + clusterDOList.add(clusterDO); + Mockito.when(clusterService.list()).thenReturn(clusterDOList); + + Map> map = getTopicNameRegionBrokerIdMap(); + Mockito.when(regionService.getTopicNameRegionBrokerIdMap(Mockito.anyLong())).thenReturn(map); + + Map> maxAvgBytesInMap = getMaxAvgBytesInMap(); + Mockito.when(topicManagerService.getTopicMaxAvgBytesIn(Mockito.anyLong(), Mockito.anyInt(), Mockito.anyDouble())).thenReturn(maxAvgBytesInMap); + + TopicInsufficientPartition expectResult = getTopicInsufficientPartition(); + Assert.assertTrue(expertService.getPartitionInsufficientTopics().stream().allMatch(topic -> topic.getClusterDO().getId().equals(expectResult.getClusterDO().getId()) && + topic.getTopicName().equals(expectResult.getTopicName()))); + } + + @Test + public void getExpiredTopicsTest() { + // 返回空集合测试 + getExpiredTopics2EmptyTest(); + + // 成功测试 + getExpiredTopics2SuccessTest(); + } + + private void getExpiredTopics2EmptyTest() { + TopicExpiredConfig topicExpiredConfig = getTopicExpiredConfig(); + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(topicExpiredConfig); + + Mockito.when(topicManagerService.getExpiredTopics(Mockito.anyInt())).thenReturn(new ArrayList<>()); + Assert.assertTrue(expertService.getExpiredTopics().isEmpty()); + } + + public void getExpiredTopics2SuccessTest() { + TopicExpiredConfig topicExpiredConfig = getTopicExpiredConfig(); + Mockito.when(configService.getByKey(Mockito.anyString(), Mockito.any())).thenReturn(topicExpiredConfig); + + TopicExpiredDO topicExpiredDO = getTopicExpiredDO(); + List topicExpiredDOList = new ArrayList<>(); + topicExpiredDOList.add(topicExpiredDO); + Mockito.when(topicManagerService.getExpiredTopics(Mockito.anyInt())).thenReturn(topicExpiredDOList); + + Assert.assertTrue(expertService.getExpiredTopics().stream().allMatch(expiredDO -> expiredDO.getClusterId().equals(topicExpiredDO.getClusterId()) && + expiredDO.getTopicName().equals(topicExpiredDO.getTopicName()))); + + } + +} diff --git a/kafka-manager-core/src/test/resources/application.yml b/kafka-manager-core/src/test/resources/application.yml index a331676a..d4d6d8f4 100644 --- a/kafka-manager-core/src/test/resources/application.yml +++ b/kafka-manager-core/src/test/resources/application.yml @@ -13,9 +13,9 @@ spring: active: dev datasource: kafka-manager: - jdbc-url: jdbc:mysql://116.85.6.115:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 username: root - password: Work2019 + password: 2PHCnL6RRM driver-class-name: com.mysql.cj.jdbc.Driver main: allow-bean-definition-overriding: true diff --git a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractEnterpriseStaffServiceTest.java b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractEnterpriseStaffServiceTest.java new file mode 100644 index 00000000..4681d959 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractEnterpriseStaffServiceTest.java @@ -0,0 +1,99 @@ +package com.xiaojukeji.kafka.manager.account; + +import com.xiaojukeji.kafka.manager.account.common.EnterpriseStaff; +import com.xiaojukeji.kafka.manager.account.component.AbstractEnterpriseStaffService; +import com.xiaojukeji.kafka.manager.account.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.entity.pojo.AccountDO; +import com.xiaojukeji.kafka.manager.dao.AccountDao; +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.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @author wyc + * @date 2021/12/30 + */ +public class AbstractEnterpriseStaffServiceTest extends BaseTest { + + @Autowired + @InjectMocks + private AbstractEnterpriseStaffService abstractEnterpriseStaffService; + + @Mock + private AccountDao accountDao; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + + private EnterpriseStaff getEnterpriseStaff() { + EnterpriseStaff staff = new EnterpriseStaff("username", "username", "department"); + return staff; + } + + private AccountDO getAccountDO() { + AccountDO accountDO = new AccountDO(); + accountDO.setUsername("username"); + return accountDO; + } + + @Test + public void getEnterpriseStaffByNameTest() { + // 返回null测试 + getEnterpriseStaffByName2NullTest(); + + // 成功测试 + getEnterpriseStaffByName2SuccessTest(); + } + + private void getEnterpriseStaffByName2NullTest() { + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(null); + Assert.assertNull(abstractEnterpriseStaffService.getEnterpriseStaffByName("username")); + } + + private void getEnterpriseStaffByName2SuccessTest() { + AccountDO accountDO = getAccountDO(); + EnterpriseStaff staff = getEnterpriseStaff(); + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(accountDO); + EnterpriseStaff result = abstractEnterpriseStaffService.getEnterpriseStaffByName("username"); + Assert.assertTrue(result.getUsername().equals(staff.getUsername()) && result.getChineseName().equals(staff.getChineseName())); + } + + + @Test + public void searchEnterpriseStaffByKeyWordTest() { + // 返回空集合测试 + searchEnterpriseStaffByKeyWord2EmptyTest(); + + // 返回非空集合测试 + searchEnterpriseStaffByKeyWord2AllTest(); + } + + private void searchEnterpriseStaffByKeyWord2EmptyTest() { + Mockito.when(accountDao.searchByNamePrefix(Mockito.anyString())).thenReturn(new ArrayList<>()); + Assert.assertTrue(abstractEnterpriseStaffService.searchEnterpriseStaffByKeyWord("username").isEmpty()); + } + + private void searchEnterpriseStaffByKeyWord2AllTest() { + AccountDO accountDO = getAccountDO(); + Mockito.when(accountDao.searchByNamePrefix(Mockito.anyString())).thenReturn(Arrays.asList(accountDO)); + + EnterpriseStaff staff = getEnterpriseStaff(); + List result = abstractEnterpriseStaffService.searchEnterpriseStaffByKeyWord("username"); + Assert.assertTrue(!result.isEmpty() && result.stream().allMatch(enterpriseStaff -> enterpriseStaff.getChineseName().equals(staff.getChineseName()) && + enterpriseStaff.getUsername().equals(staff.getUsername()))); + } + + +} diff --git a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractSingleSignOnTest.java b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractSingleSignOnTest.java new file mode 100644 index 00000000..c65ae280 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AbstractSingleSignOnTest.java @@ -0,0 +1,244 @@ +package com.xiaojukeji.kafka.manager.account; + +import com.xiaojukeji.kafka.manager.account.component.AbstractSingleSignOn; +import com.xiaojukeji.kafka.manager.account.component.ldap.LdapAuthentication; +import com.xiaojukeji.kafka.manager.account.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.bizenum.AccountRoleEnum; +import com.xiaojukeji.kafka.manager.common.constant.LoginConstant; +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.LoginDTO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.AccountDO; +import com.xiaojukeji.kafka.manager.common.utils.EncryptUtil; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.mockito.internal.util.reflection.FieldSetter; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.lang.reflect.Field; + +/** + * @author wyc + * @date 2021/12/30 + */ +public class AbstractSingleSignOnTest extends BaseTest { + @Autowired + @InjectMocks + private AbstractSingleSignOn abstractSingleSignOn; + + @Mock + private AccountService accountService; + + @Mock + private LdapAuthentication ldapAuthentication; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private HttpServletRequest getHttpServletRequest() { + HttpServletRequest request = new MockHttpServletRequest(); + return request; + } + + private HttpServletResponse getHttpServletResponse() { + HttpServletResponse response = new MockHttpServletResponse(); + return response; + } + + private LoginDTO getLoginDTO() { + LoginDTO dto = new LoginDTO(); + dto.setUsername("username"); + dto.setPassword("password"); + return dto; + } + + private AccountDO getAccountDO() { + AccountDO accountDO = new AccountDO(); + accountDO.setUsername("username"); + accountDO.setPassword("password"); + + return accountDO; + } + + @Test + public void loginAndGetLdapTest() throws NoSuchFieldException { + // username为null测试 + loginAndGetLdap2ParamNullTest(); + + // LDAP未激活测试，从最后的return返回 + loginAndGetLdap2LdapDisabledTest(); + + // LDAP激活，返回false测试 + loginAndGetLdap2LdapEnabledReturnFalseTest(); + + // LDAP激活，返回true测试 + loginAndGetLdap2LdapEnabledReturnTrueTest(); + + loginAndGetLdap2FailureTest(); + + // name illegal 测试 + loginAndGetLdap2NameIllegalTest(); + + // password illegal 测试 + loginAndGetLdap2PasswordIllegalTest(); + + + } + + private void resetAbstractSingleSignOn() throws NoSuchFieldException { + // 通过反射将abstractSingleSignOn内属性的值置于初始状态,因为每个private测试中会通过反射改变abstractSingleSignOn成员变量的值 + Field accountLdapEnabled = abstractSingleSignOn.getClass().getDeclaredField("accountLdapEnabled"); + FieldSetter.setField(abstractSingleSignOn, accountLdapEnabled, null); + + Field authUserRegistrationRole = abstractSingleSignOn.getClass().getDeclaredField("authUserRegistrationRole"); + FieldSetter.setField(abstractSingleSignOn, authUserRegistrationRole, null); + + Field authUserRegistration = abstractSingleSignOn.getClass().getDeclaredField("authUserRegistration"); + FieldSetter.setField(abstractSingleSignOn, authUserRegistration, false); + } + + private void loginAndGetLdap2ParamNullTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO loginDTO = getLoginDTO(); + loginDTO.setUsername(null); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, loginDTO).toString(), Result.buildFailure("Missing parameters").toString()); + } + + private void loginAndGetLdap2LdapDisabledTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + + LoginDTO loginDTO = getLoginDTO(); + String pass = EncryptUtil.md5(loginDTO.getPassword()); + + AccountDO accountDO1 = getAccountDO(); + accountDO1.setPassword(pass); + + Result result = Result.buildSuc(accountDO1); + Mockito.when(accountService.getAccountDO(Mockito.any())).thenReturn(result); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, loginDTO).toString(), Result.buildSuc(result.getData().getUsername()).toString()); + } + + private void loginAndGetLdap2LdapEnabledReturnFalseTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO dto = getLoginDTO(); + // 通过反射将abstractSingleSignOn对象中accountLdapEnabled属性设置为true + Field accountLdapEnabled = abstractSingleSignOn.getClass().getDeclaredField("accountLdapEnabled"); + FieldSetter.setField(abstractSingleSignOn, accountLdapEnabled, true); + + Mockito.when(ldapAuthentication.authenticate(Mockito.anyString(), Mockito.anyString())).thenReturn(false); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, dto).toString(), Result.buildFrom(ResultStatus.LDAP_AUTHENTICATION_FAILED).toString()); + } + + private void loginAndGetLdap2LdapEnabledReturnTrueTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO dto = getLoginDTO(); + + Mockito.when(accountService.getAccountDO(Mockito.any())).thenReturn(null); + + // 通过反射将abstractSingleSignOn对象中accountLdapEnabled属性设置为true + Field accountLdapEnabled = abstractSingleSignOn.getClass().getDeclaredField("accountLdapEnabled"); + FieldSetter.setField(abstractSingleSignOn, accountLdapEnabled, true); + + Mockito.when(ldapAuthentication.authenticate(Mockito.anyString(), Mockito.anyString())).thenReturn(true); + + // 通过反射初始化成员变量，防止出现空指针异常 + Field authUserRegistrationRole = abstractSingleSignOn.getClass().getDeclaredField("authUserRegistrationRole"); + FieldSetter.setField(abstractSingleSignOn, authUserRegistrationRole, AccountRoleEnum.NORMAL.getMessage()); + + Field authUserRegistration = abstractSingleSignOn.getClass().getDeclaredField("authUserRegistration"); + FieldSetter.setField(abstractSingleSignOn, authUserRegistration, true); + + + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, dto).toString(), Result.buildSuc(dto.getUsername()).toString()); + } + + private void loginAndGetLdap2FailureTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO dto = getLoginDTO(); + Result result = Result.buildFailure("fail"); + Mockito.when(accountService.getAccountDO(Mockito.any())).thenReturn(result); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, dto).toString(), result.toString()); + } + + private void loginAndGetLdap2NameIllegalTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO dto = getLoginDTO(); + + Result result = Result.buildSuc(); + Mockito.when(accountService.getAccountDO(Mockito.any())).thenReturn(result); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, dto).toString(), Result.buildFailure("username illegal").toString()); + } + + private void loginAndGetLdap2PasswordIllegalTest() throws NoSuchFieldException { + resetAbstractSingleSignOn(); + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + LoginDTO dto = getLoginDTO(); + AccountDO accountDO = getAccountDO(); + Result result = Result.buildSuc(accountDO); + Mockito.when(accountService.getAccountDO(Mockito.any())).thenReturn(result); + Assert.assertEquals(abstractSingleSignOn.loginAndGetLdap(request, response, dto).toString(), Result.buildFailure("password illegal").toString()); + } + + + @Test + public void logoutTest() { + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + abstractSingleSignOn.logout(request, response, true); + Assert.assertEquals(response.getStatus(), 401); + Assert.assertEquals(response.getHeader("location"), ""); + } + + @Test + public void checkLoginAndGetLdapTest() { + // 返回null测试 + checkLoginAndGetLdap2NullTest(); + + // 成功测试 + checkLoginAndGetLdap2SuccessTest(); + } + + private void checkLoginAndGetLdap2NullTest() { + HttpServletRequest request = getHttpServletRequest(); + Assert.assertNull(abstractSingleSignOn.checkLoginAndGetLdap(request)); + } + + private void checkLoginAndGetLdap2SuccessTest() { + HttpServletRequest request = getHttpServletRequest(); + request.getSession().setAttribute(LoginConstant.SESSION_USERNAME_KEY, "username"); + Assert.assertEquals(abstractSingleSignOn.checkLoginAndGetLdap(request), "username"); + } + + @Test + public void setRedirectToLoginPageTest() { + HttpServletResponse response = getHttpServletResponse(); + response.setStatus(401); + response.setHeader("location", ""); + Assert.assertEquals(response.getStatus(), 401); + Assert.assertEquals(response.getHeader("location"), ""); + } +} diff --git a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AccountServiceTest.java b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AccountServiceTest.java index cb1faa37..b943c15d 100644 --- a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AccountServiceTest.java +++ b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/AccountServiceTest.java @@ -1,8 +1,287 @@ package com.xiaojukeji.kafka.manager.account; +import com.xiaojukeji.kafka.manager.account.common.EnterpriseStaff; +import com.xiaojukeji.kafka.manager.account.component.AbstractEnterpriseStaffService; +import com.xiaojukeji.kafka.manager.account.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.bizenum.AccountRoleEnum; +import com.xiaojukeji.kafka.manager.common.constant.Constant; +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.AccountDO; +import com.xiaojukeji.kafka.manager.dao.AccountDao; +import com.xiaojukeji.kafka.manager.service.service.ConfigService; +import com.xiaojukeji.kafka.manager.service.service.OperateRecordService; +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.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + /** - * @author xuguang - * @Date 2021/12/25 + * @author wyc + * @Date 2021/12/29 */ -public class AccountServiceTest { +public class AccountServiceTest extends BaseTest { + @Autowired + @InjectMocks + private AccountService accountService; + + @Mock + private AccountDao accountDao; + + @Mock + private OperateRecordService operateRecordService; + + @Mock + private AbstractEnterpriseStaffService enterpriseStaffService; + + @Mock + private ConfigService configService; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private AccountDO getAccountDO() { + AccountDO accountDO = new AccountDO(); + accountDO.setUsername("test_username"); + accountDO.setPassword("test_password"); + accountDO.setRole(0); + return accountDO; + } + + private EnterpriseStaff getEnterpriseStaff() { + EnterpriseStaff staff = new EnterpriseStaff("username", "ChineseName", "department"); + return staff; + } + + private Account getAccount() { + Account account = new Account(); + return account; + } + + @Test + public void createAccountTest() { + AccountDO accountDO = getAccountDO(); + // 创建成功测试 + createAccount2SuccessTest(accountDO); + + // 主键重复测试 + createAccount2DuplicateKeyExceptionTest(accountDO); + } + + private void createAccount2SuccessTest(AccountDO accountDO) { + Mockito.when(accountDao.addNewAccount(Mockito.any())).thenReturn(1); + Assert.assertEquals(accountService.createAccount(accountDO), ResultStatus.SUCCESS); + } + + private void createAccount2DuplicateKeyExceptionTest(AccountDO accountDO) { + Mockito.when(accountDao.addNewAccount(Mockito.any())).thenThrow(DuplicateKeyException.class); + Assert.assertEquals(accountService.createAccount(accountDO), ResultStatus.RESOURCE_ALREADY_EXISTED); + } + + private void createAccount2MySQLErrorTest(AccountDO accountDO) { + Mockito.when(accountDao.addNewAccount(Mockito.any())).thenReturn(-1); + Assert.assertEquals(accountService.createAccount(accountDO), ResultStatus.MYSQL_ERROR); + } + + + @Test + public void deleteByNameTest() { + // 删除成功测试 + deleteName2SuccessTest(); + + // MySQL_ERROR错误测试 + deleteName2MySQLErrorTest(); + } + + private void deleteName2SuccessTest() { + Mockito.when(accountDao.deleteByName(Mockito.anyString())).thenReturn(1); + Assert.assertEquals(accountService.deleteByName("username", "admin"), ResultStatus.SUCCESS); + } + + private void deleteName2MySQLErrorTest() { + Mockito.when(accountDao.deleteByName(Mockito.anyString())).thenReturn(-1); + Assert.assertEquals(accountService.deleteByName("username", "admin"), ResultStatus.MYSQL_ERROR); + } + + @Test + public void updateAccountTest() { + // 账号不存在测试 + updateAccount2AccountNotExistTest(); + + // 更新成功测试 + updateAccount2SuccessTest(); + + // MySQL_ERROR测试 + updateAccount2MySQLErrorTest(); + } + + private void updateAccount2AccountNotExistTest() { + AccountDO accountDO = getAccountDO(); + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(null); + Assert.assertEquals(accountService.updateAccount(accountDO), ResultStatus.ACCOUNT_NOT_EXIST); + } + + private void updateAccount2SuccessTest() { + AccountDO accountDO = getAccountDO(); + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(accountDO); + Mockito.when(accountDao.updateByName(Mockito.any())).thenReturn(1); + Assert.assertEquals(accountService.updateAccount(accountDO), ResultStatus.SUCCESS); + } + + private void updateAccount2MySQLErrorTest() { + AccountDO accountDO = getAccountDO(); + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(accountDO); + Mockito.when(accountDao.updateByName(Mockito.any())).thenReturn(-1); + Assert.assertEquals(accountService.updateAccount(accountDO), ResultStatus.MYSQL_ERROR); + } + + @Test + public void getAccountDOTest() { + AccountDO accountDO = getAccountDO(); + Result expectedResult = Result.buildSuc(accountDO); + + Mockito.when(accountDao.getByName(Mockito.anyString())).thenReturn(accountDO); + Assert.assertEquals(accountService.getAccountDO(accountDO.getUsername()).toString(), expectedResult.toString()); + } + + @Test + public void listTest() { + AccountDO accountDO = getAccountDO(); + List list = new ArrayList<>(); + list.add(accountDO); + Mockito.when(accountDao.list()).thenReturn(list); + List actualResult = accountService.list(); + Assert.assertTrue(!actualResult.isEmpty() && actualResult.stream().allMatch(account -> account.getUsername().equals(accountDO.getUsername()) && + account.getPassword().equals(accountDO.getPassword()))); + } + + @Test + public void searchAccountByPrefixTest() { + EnterpriseStaff staff = getEnterpriseStaff(); + List expectedResult = new ArrayList<>(); + expectedResult.add(staff); + Mockito.when(enterpriseStaffService.searchEnterpriseStaffByKeyWord(Mockito.anyString())).thenReturn(expectedResult); + List actualResult = accountService.searchAccountByPrefix("prefix"); + + Assert.assertTrue(!actualResult.isEmpty() && actualResult.stream().allMatch(enterpriseStaff -> enterpriseStaff.getUsername().equals(staff.getUsername()))); + } + + // 因为flush只会执行一次，因此需要分开测试 + @Test(description = "普通角色测试") + public void getAccountRoleFromCache2NormalTest() { + Assert.assertEquals(accountService.getAccountRoleFromCache("username"), AccountRoleEnum.NORMAL); + } + + @Test(description = "op角色测试") + public void getAccountRoleFromCache2OpTest() { + AccountDO accountDO = getAccountDO(); + accountDO.setUsername("admin"); + accountDO.setRole(2); + + Mockito.when(accountDao.list()).thenReturn(Arrays.asList(accountDO)); + Assert.assertEquals(accountService.getAccountRoleFromCache("admin"), AccountRoleEnum.OP); + } + + + @Test(description = "自动审批测试") + public void getAccountFromCache2AutoHandleTest() { + Account account = getAccount(); + account.setUsername(Constant.AUTO_HANDLE_USER_NAME); + account.setChineseName(Constant.AUTO_HANDLE_CHINESE_NAME); + account.setAccountRoleEnum(AccountRoleEnum.OP); + Assert.assertEquals(accountService.getAccountFromCache(Constant.AUTO_HANDLE_USER_NAME).toString(), account.toString()); + } + + @Test(description = "staff为null测试") + public void getAccountFromCache2EnterpriseStaffIsNullTest() { + Account account = getAccount(); + account.setUsername("username1"); + account.setChineseName("username1"); + account.setAccountRoleEnum(AccountRoleEnum.NORMAL); + + Mockito.when(enterpriseStaffService.getEnterpriseStaffByName(Mockito.anyString())).thenReturn(null); + Assert.assertEquals(accountService.getAccountFromCache("username1").toString(), account.toString()); + } + + @Test(description = "staff不为null测试") + public void getAccountFromCache2EnterpriseStaffIsNotNullTest() { + Account account = getAccount(); + account.setUsername("username"); + account.setChineseName("ChineseName"); + account.setAccountRoleEnum(AccountRoleEnum.NORMAL); + account.setDepartment("department"); + EnterpriseStaff enterpriseStaff = getEnterpriseStaff(); + + Mockito.when(enterpriseStaffService.getEnterpriseStaffByName(Mockito.any())).thenReturn(enterpriseStaff); + Assert.assertEquals(accountService.getAccountFromCache("username").toString(), account.toString()); + } + + + + @Test(description = "op角色测试") + public void isAdminOrderHandler2OpTest() { + AccountDO accountDO = getAccountDO(); + accountDO.setUsername("admin"); + accountDO.setRole(2); + + Mockito.when(accountDao.list()).thenReturn(Arrays.asList(accountDO)); + Assert.assertTrue(accountService.isAdminOrderHandler("admin")); + } + + @Test(description = "ADMIN_ORDER_HANDLER_CACHE包含用户名测试") + public void isAdminOrderHandler2CacheContainsTest() { + Mockito.when(configService.getArrayByKey(Mockito.anyString(), Mockito.any())).thenReturn(Arrays.asList("username")); + Mockito.when(accountDao.list()).thenReturn(new ArrayList<>()); + Assert.assertTrue(accountService.isAdminOrderHandler("username")); + } + + + @Test(description = "普通角色测试") + public void isAdminOrderHandler2NormalTest() { + Mockito.when(accountDao.list()).thenReturn(new ArrayList<>()); + Assert.assertFalse(accountService.isAdminOrderHandler("username")); + } + + @Test(description = "op角色测试") + public void isOpOrRd2OpTest() { + AccountDO accountDO = getAccountDO(); + accountDO.setUsername("admin"); + accountDO.setRole(2); + + Mockito.when(accountDao.list()).thenReturn(Arrays.asList(accountDO)); + Assert.assertTrue(accountService.isOpOrRd("admin")); + } + + @Test + public void isOpOrRdTest2RdTest() { + AccountDO accountDO = getAccountDO(); + accountDO.setUsername("admin"); + accountDO.setRole(1); + Mockito.when(accountDao.list()).thenReturn(Arrays.asList(accountDO)); + Assert.assertTrue(accountService.isOpOrRd("admin")); + } + + @Test + public void getAdminOrderHandlerFromCacheTest() { + AccountDO accountDO = getAccountDO(); + accountDO.setUsername("username"); + accountDO.setRole(2); + + Mockito.when(accountDao.list()).thenReturn(Arrays.asList(accountDO)); + List actualList = accountService.getAdminOrderHandlerFromCache(); + Assert.assertTrue(!actualList.isEmpty() && actualList.stream().allMatch(account -> account.getUsername().equals(accountDO.getUsername()))); + } + } diff --git a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/LoginServiceTest.java b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/LoginServiceTest.java index 9742ad64..5242de9e 100644 --- a/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/LoginServiceTest.java +++ b/kafka-manager-extends/kafka-manager-account/src/test/java/com/xiaojukeji/kafka/manager/account/LoginServiceTest.java @@ -1,17 +1,198 @@ package com.xiaojukeji.kafka.manager.account; +import com.xiaojukeji.kafka.manager.account.component.AbstractSingleSignOn; +import com.xiaojukeji.kafka.manager.account.component.login.trick.TrickLoginService; import com.xiaojukeji.kafka.manager.account.config.BaseTest; +import com.xiaojukeji.kafka.manager.common.bizenum.AccountRoleEnum; +import com.xiaojukeji.kafka.manager.common.constant.ApiPrefix; +import com.xiaojukeji.kafka.manager.common.constant.LoginConstant; +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 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.mock.web.MockHttpServletRequest; +import org.springframework.mock.web.MockHttpServletResponse; import org.testng.Assert; +import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; +import javax.servlet.http.*; + /** - * @author xuguang - * @Date 2021/12/25 + * @author wyc + * @Date 2021/12/29 */ public class LoginServiceTest extends BaseTest { + @Autowired + @InjectMocks + private LoginService loginService; + + @Mock + private AbstractSingleSignOn singleSignOn; + + @Mock + private AccountService accountService; + + @Mock + private TrickLoginService trickLoginService; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private Account getAccount() { + Account account = new Account(); + account.setUsername("username"); + return account; + } + + private HttpServletRequest getHttpServletRequest() { + HttpServletRequest request = new MockHttpServletRequest(); + return request; + } + + private HttpServletResponse getHttpServletResponse() { + HttpServletResponse response = new MockHttpServletResponse(); + return response; + } + + @Test - public void test() { - Assert.assertEquals("", ""); + public void loginTest() { + // 失败测试 + login2FailureTest(); + + // 成功测试 + HttpServletRequest request = getHttpServletRequest(); + HttpServletResponse response = getHttpServletResponse(); + login2SuccessTest(request, response); } + + private void login2SuccessTest(HttpServletRequest request, HttpServletResponse response) { + Account account = getAccount(); + Result expectResult = Result.buildSuc(account); + Result midResult = Result.buildSuc(); + Mockito.when(singleSignOn.loginAndGetLdap(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(midResult); + Mockito.when(accountService.getAccountFromCache(Mockito.any())).thenReturn(account); + Assert.assertEquals(loginService.login(request, response, null).toString(), expectResult.toString()); + } + + private void login2FailureTest() { + Result result = new Result<>(); + result.setCode(ResultStatus.FAIL.getCode()); + result.setMessage(ResultStatus.FAIL.getMessage()); + Mockito.when(singleSignOn.loginAndGetLdap(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(result); + Result actualResult = loginService.login(null, null, null); + Assert.assertEquals(actualResult.toString(), result.toString()); + } + + + @Test + public void checkLoginTest() { + // classRequestMappingValue为null测试 + checkLogin2ClassValueIsNullTest(); + + // 白名单接口测试 + checkLogin2SSOTest(); + + // trick登陆返回用户名为空 + checkLogin2TrickFalseTest(); + + // 权限检查normal接口测试 + checkLogin2NormalTest(); + + // 权限检查RD接口, 成功测试 + checkLogin2RDSuccessTest(); + + // 权限检查RD接口, 失败测试 + checkLogin2RDFailureTest(); + + // 权限检查OP接口, 成功测试 + checkLogin2OPSuccessTest(); + + // 权限检查OP接口，失败测试 + checkLogin2OPFailureTest(); + } + + private void checkLogin2ClassValueIsNullTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.doNothing().when(singleSignOn).setRedirectToLoginPage(Mockito.any()); + Assert.assertFalse(loginService.checkLogin(request, response, null)); + Assert.assertEquals(response.getStatus(), HttpServletResponse.SC_INTERNAL_SERVER_ERROR); + } + + private void checkLogin2SSOTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Assert.assertTrue(loginService.checkLogin(request, response, ApiPrefix.API_V1_SSO_PREFIX)); + } + + private void checkLogin2TrickFalseTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn(""); + Mockito.doNothing().when(singleSignOn).setRedirectToLoginPage(response); + Assert.assertFalse(loginService.checkLogin(request, response, "string")); + Assert.assertEquals(response.getStatus(), HttpServletResponse.SC_UNAUTHORIZED); + } + + private void checkLogin2NormalTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn("username"); + Assert.assertTrue(loginService.checkLogin(request, response, ApiPrefix.API_V1_NORMAL_PREFIX)); + Assert.assertEquals(request.getSession().getAttribute(LoginConstant.SESSION_USERNAME_KEY), "username"); + } + + private void checkLogin2RDSuccessTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn("username"); + Mockito.when(accountService.getAccountRoleFromCache(Mockito.any())).thenReturn(AccountRoleEnum.OP); + Assert.assertTrue(loginService.checkLogin(request, response, ApiPrefix.API_V1_RD_PREFIX)); + Assert.assertEquals(request.getSession().getAttribute(LoginConstant.SESSION_USERNAME_KEY), "username"); + } + + private void checkLogin2RDFailureTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn("username"); + Mockito.when(accountService.getAccountRoleFromCache(Mockito.any())).thenReturn(AccountRoleEnum.NORMAL); + Assert.assertFalse(loginService.checkLogin(request, response, ApiPrefix.API_V1_RD_PREFIX)); + Assert.assertEquals(response.getStatus(), HttpServletResponse.SC_FORBIDDEN); + } + + private void checkLogin2OPSuccessTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn("username"); + Mockito.when(accountService.getAccountRoleFromCache(Mockito.any())).thenReturn(AccountRoleEnum.OP); + Assert.assertTrue(loginService.checkLogin(request, response, ApiPrefix.API_V1_OP_PREFIX)); + Assert.assertEquals(request.getSession().getAttribute(LoginConstant.SESSION_USERNAME_KEY), "username"); + } + + private void checkLogin2OPFailureTest() { + HttpServletResponse response = getHttpServletResponse(); + HttpServletRequest request = getHttpServletRequest(); + Mockito.when(trickLoginService.isTrickLoginOn(Mockito.any())).thenReturn(true); + Mockito.when(trickLoginService.checkTrickLogin(Mockito.any())).thenReturn("username"); + Mockito.when(accountService.getAccountRoleFromCache(Mockito.any())).thenReturn(AccountRoleEnum.NORMAL); + Assert.assertFalse(loginService.checkLogin(request, response, ApiPrefix.API_V1_OP_PREFIX)); + Assert.assertEquals(response.getStatus(), HttpServletResponse.SC_FORBIDDEN); + } + + + } diff --git a/kafka-manager-extends/kafka-manager-account/src/test/resources/application.yml b/kafka-manager-extends/kafka-manager-account/src/test/resources/application.yml index a4648a46..d4d6d8f4 100644 --- a/kafka-manager-extends/kafka-manager-account/src/test/resources/application.yml +++ b/kafka-manager-extends/kafka-manager-account/src/test/resources/application.yml @@ -13,9 +13,9 @@ spring: active: dev datasource: kafka-manager: - jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 username: root - password: 123456 + password: 2PHCnL6RRM driver-class-name: com.mysql.cj.jdbc.Driver main: allow-bean-definition-overriding: true diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/AbstractOrderStorageServiceTest.java b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/AbstractOrderStorageServiceTest.java new file mode 100644 index 00000000..d64400bf --- /dev/null +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/java/com/xiaojukeji/kafka/manager/bpm/AbstractOrderStorageServiceTest.java @@ -0,0 +1,80 @@ +package com.xiaojukeji.kafka.manager.bpm; + +import com.xiaojukeji.kafka.manager.bpm.component.AbstractOrderStorageService; +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.dao.OrderDao; +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; + +/** + * @author wyc + * @date 2022/1/5 + */ +public class AbstractOrderStorageServiceTest extends BaseTest { + @Autowired + @InjectMocks + private AbstractOrderStorageService abstractOrderStorageService; + + @Mock + private OrderDao orderDao; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private OrderDO getOrderDO() { + OrderDO orderDO = new OrderDO(); + orderDO.setApplicant("applicant"); + return orderDO; + } + + + @Test + public void cancelTest() { + // 返回null测试 + cancel2ReturnNullTest(); + + // 无权限测试 + cancel2WithoutAuthority(); + + // 成功测试 + cancel2SuccessTest(); + + // 数据库错误测试 + cancel2MySQLErrorTest(); + } + + private void cancel2ReturnNullTest() { + Mockito.when(orderDao.getById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(abstractOrderStorageService.cancel(1L, "applicant"), ResultStatus.ORDER_NOT_EXIST); + } + + private void cancel2WithoutAuthority() { + OrderDO orderDO = getOrderDO(); + Assert.assertEquals(abstractOrderStorageService.cancel(1L, "username"), ResultStatus.USER_WITHOUT_AUTHORITY); + } + + private void cancel2SuccessTest() { + OrderDO orderDO = getOrderDO(); + Mockito.when(orderDao.getById(Mockito.anyLong())).thenReturn(orderDO); + Mockito.when(orderDao.updateOrderStatusById(Mockito.anyLong(), Mockito.anyInt())).thenReturn(1); + Assert.assertEquals(abstractOrderStorageService.cancel(1L, "applicant"), ResultStatus.SUCCESS); + } + + private void cancel2MySQLErrorTest() { + OrderDO orderDO = getOrderDO(); + Mockito.when(orderDao.getById(Mockito.anyLong())).thenReturn(orderDO); + Mockito.when(orderDao.updateOrderStatusById(Mockito.anyLong(), Mockito.anyInt())).thenReturn(0); + Assert.assertEquals(abstractOrderStorageService.cancel(1L, "applicant"), ResultStatus.MYSQL_ERROR); + } + +} diff --git a/kafka-manager-extends/kafka-manager-bpm/src/test/resources/application.yml b/kafka-manager-extends/kafka-manager-bpm/src/test/resources/application.yml index a4648a46..d4d6d8f4 100644 --- a/kafka-manager-extends/kafka-manager-bpm/src/test/resources/application.yml +++ b/kafka-manager-extends/kafka-manager-bpm/src/test/resources/application.yml @@ -13,9 +13,9 @@ spring: active: dev datasource: kafka-manager: - jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 username: root - password: 123456 + password: 2PHCnL6RRM driver-class-name: com.mysql.cj.jdbc.Driver main: allow-bean-definition-overriding: true diff --git a/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/AbstractMonitorServiceTest.java b/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/AbstractMonitorServiceTest.java new file mode 100644 index 00000000..343f5d14 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/AbstractMonitorServiceTest.java @@ -0,0 +1,53 @@ +package com.xiaojukeji.kafka.manager.monitor; + +import com.xiaojukeji.kafka.manager.monitor.common.entry.Strategy; +import com.xiaojukeji.kafka.manager.monitor.component.AbstractMonitorService; +import com.xiaojukeji.kafka.manager.monitor.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.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.io.IOException; +import java.net.HttpURLConnection; +import java.util.ArrayList; + +/** + * @author wyc + * @date 2022/1/5 + */ +public class AbstractMonitorServiceTest extends BaseTest { + @Autowired + @InjectMocks + private AbstractMonitorService abstractMonitorService; + + @Mock + private HttpURLConnection conn; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private Strategy getStrategy() { + Strategy strategy = new Strategy(); + strategy.setName("test_strategy"); + strategy.setId(1L); + strategy.setPeriodDaysOfWeek("1"); + strategy.setPeriodHoursOfDay("24"); + strategy.setPriority(0); + strategy.setStrategyFilterList(new ArrayList<>()); + strategy.setStrategyExpressionList(new ArrayList<>()); + strategy.setStrategyActionList(new ArrayList<>()); + return strategy; + } + @Test + public void createStrategyTest() throws IOException { + Strategy strategy = getStrategy(); + Integer i = abstractMonitorService.createStrategy(strategy); + System.out.println(i); + } +} diff --git a/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/MonitorServiceTest.java b/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/MonitorServiceTest.java index 6bf90551..0f1ca266 100644 --- a/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/MonitorServiceTest.java +++ b/kafka-manager-extends/kafka-manager-monitor/src/test/java/com/xiaojukeji/kafka/manager/monitor/MonitorServiceTest.java @@ -1,8 +1,458 @@ package com.xiaojukeji.kafka.manager.monitor; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.pojo.MonitorRuleDO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.gateway.AppDO; +import com.xiaojukeji.kafka.manager.dao.MonitorRuleDao; +import com.xiaojukeji.kafka.manager.dao.gateway.AppDao; +import com.xiaojukeji.kafka.manager.monitor.common.entry.Alert; +import com.xiaojukeji.kafka.manager.monitor.common.entry.Metric; +import com.xiaojukeji.kafka.manager.monitor.common.entry.Silence; +import com.xiaojukeji.kafka.manager.monitor.common.entry.Strategy; +import com.xiaojukeji.kafka.manager.monitor.common.entry.dto.MonitorRuleDTO; +import com.xiaojukeji.kafka.manager.monitor.common.entry.dto.MonitorSilenceDTO; +import com.xiaojukeji.kafka.manager.monitor.common.monitor.MonitorAlertDetail; +import com.xiaojukeji.kafka.manager.monitor.common.monitor.MonitorRuleSummary; +import com.xiaojukeji.kafka.manager.monitor.component.AbstractMonitorService; +import com.xiaojukeji.kafka.manager.monitor.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.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.List; + /** - * @author xuguang - * @Date 2021/12/27 + * @author wyc + * @Date 2022/01/05 */ -public class MonitorServiceTest { +public class MonitorServiceTest extends BaseTest { + @Autowired + @InjectMocks + private MonitorService monitorService; + + @Mock + private AbstractMonitorService abstractMonitorService; + + @Mock + private MonitorRuleDao monitorRuleDao; + + @Mock + private AppDao appDao; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + private MonitorRuleDTO getMonitorRuleDTO() { + MonitorRuleDTO monitorRuleDTO = new MonitorRuleDTO(); + monitorRuleDTO.setAppId("appId"); + monitorRuleDTO.setName("name"); + monitorRuleDTO.setStrategyExpressionList(new ArrayList<>()); + monitorRuleDTO.setStrategyFilterList(new ArrayList<>()); + monitorRuleDTO.setStrategyActionList(new ArrayList<>()); + monitorRuleDTO.setId(1L); + return monitorRuleDTO; + } + + private MonitorRuleDO getMonitorRuleDO() { + MonitorRuleDO monitorRuleDO = new MonitorRuleDO(); + monitorRuleDO.setAppId("appId"); + monitorRuleDO.setName("name"); + monitorRuleDO.setCreateTime(new Date()); + monitorRuleDO.setStrategyId(1L); + monitorRuleDO.setId(1L); + return monitorRuleDO; + } + + private MonitorRuleSummary getMonitorRuleSummary() { + MonitorRuleSummary summary = new MonitorRuleSummary(); + summary.setAppId("appId"); + summary.setAppName("appName"); + return summary; + } + + private AppDO getAppDO() { + AppDO appDO = new AppDO(); + appDO.setAppId("appId"); + appDO.setName("appName"); + return appDO; + } + + private Strategy getStrategy() { + Strategy strategy = new Strategy(); + strategy.setName("name"); + strategy.setStrategyActionList(new ArrayList<>()); + strategy.setStrategyExpressionList(new ArrayList<>()); + strategy.setStrategyFilterList(new ArrayList<>()); + return strategy; + } + + private Alert getAlert() { + Alert alert = new Alert(); + alert.setId(1L); + alert.setStartTime(3700L); + alert.setEndTime(3800L); + return alert; + } + + private MonitorAlertDetail getMonitorAlertDetail() { + MonitorAlertDetail detail = new MonitorAlertDetail(null, null); + return detail; + } + + private Metric getMetric() { + Metric metric = new Metric(); + return metric; + } + + private MonitorSilenceDTO getMonitorSilenceDTO() { + MonitorSilenceDTO dto = new MonitorSilenceDTO(); + dto.setId(1L); + return dto; + } + + private Silence getSilence() { + Silence silence = new Silence(); + silence.setSilenceId(1L); + return silence; + } + + + @Test + public void createMonitorRuleTest() { + // CALL_MONITOR_SYSTEM_ERROR + createMonitorRule2CallMonitorSystemErrorTest(); + + // 成功测试 + createMonitorRule2SuccessTest(); + + // MYSQL_ERROR + createMonitorRule2MySQLErrorTest(); + } + + private void createMonitorRule2CallMonitorSystemErrorTest() { + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(abstractMonitorService.createStrategy(Mockito.any())).thenReturn(null); + Assert.assertEquals(monitorService.createMonitorRule(dto, "admin"), ResultStatus.CALL_MONITOR_SYSTEM_ERROR); + } + + private void createMonitorRule2SuccessTest() { + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(abstractMonitorService.createStrategy(Mockito.any())).thenReturn(1); + Mockito.when(monitorRuleDao.insert(Mockito.any())).thenReturn(1); + Assert.assertEquals(monitorService.createMonitorRule(dto, "admin"), ResultStatus.SUCCESS); + } + + private void createMonitorRule2MySQLErrorTest() { + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(abstractMonitorService.createStrategy(Mockito.any())).thenReturn(1); + Mockito.when(monitorRuleDao.insert(Mockito.any())).thenReturn(-1); + Assert.assertEquals(monitorService.createMonitorRule(dto, "admin"), ResultStatus.MYSQL_ERROR); + } + + + @Test + public void deleteMonitorRuleTest() { + // MONITOR_NOT_EXIST + deleteMonitorRule2MonitorNotExistTest(); + + // CALL_MONITOR_SYSTEM_ERROR + deleteMonitorRule2CallMonitorSystemErrorTest(); + + // 成功测试 + deleteMonitorRule2SuccessTest(); + + // MYSQL_ERROR + deleteMonitorRule2MySQLErrorTest(); + } + + private void deleteMonitorRule2MonitorNotExistTest() { + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.deleteMonitorRule(1L, "admin"), ResultStatus.MONITOR_NOT_EXIST); + } + + private void deleteMonitorRule2CallMonitorSystemErrorTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.deleteStrategyById(Mockito.anyLong())).thenReturn(false); + Assert.assertEquals(monitorService.deleteMonitorRule(1L, "admin"), ResultStatus.CALL_MONITOR_SYSTEM_ERROR); + } + + private void deleteMonitorRule2SuccessTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.deleteStrategyById(Mockito.anyLong())).thenReturn(true); + Mockito.when(monitorRuleDao.deleteById(Mockito.any())).thenReturn(1); + Assert.assertEquals(monitorService.deleteMonitorRule(1L, "admin"), ResultStatus.SUCCESS); + } + + private void deleteMonitorRule2MySQLErrorTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.deleteStrategyById(Mockito.anyLong())).thenReturn(true); + Mockito.when(monitorRuleDao.deleteById(Mockito.any())).thenReturn(-1); + Assert.assertEquals(monitorService.deleteMonitorRule(1L, "admin"), ResultStatus.MYSQL_ERROR); + } + + + @Test + public void modifyMonitorRuleTest() { + // MONITOR_NOT_EXIST + modifyMonitorRule2MonitorNotExistTest(); + + // CALL_MONITOR_SYSTEM_ERROR + modifyMonitorRule2CallMonitorSystemErrorTest(); + + // 成功测试 + modifyMonitorRule2SuccessTest(); + + // MYSQL_ERROR + modifyMonitorRule2MySQLErrorTest(); + } + + private void modifyMonitorRule2MonitorNotExistTest() { + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.modifyMonitorRule(dto, "admin"), ResultStatus.MONITOR_NOT_EXIST); + } + + private void modifyMonitorRule2CallMonitorSystemErrorTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.modifyStrategy(Mockito.any())).thenReturn(false); + Assert.assertEquals(monitorService.modifyMonitorRule(dto, "admin"), ResultStatus.CALL_MONITOR_SYSTEM_ERROR); + } + + private void modifyMonitorRule2SuccessTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.modifyStrategy(Mockito.any())).thenReturn(true); + Mockito.when(monitorRuleDao.updateById(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(1); + Assert.assertEquals(monitorService.modifyMonitorRule(dto, "admin"), ResultStatus.SUCCESS); + } + + private void modifyMonitorRule2MySQLErrorTest() { + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + MonitorRuleDTO dto = getMonitorRuleDTO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.modifyStrategy(Mockito.any())).thenReturn(true); + Mockito.when(monitorRuleDao.updateById(Mockito.anyLong(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString())).thenReturn(-1); + Assert.assertEquals(monitorService.modifyMonitorRule(dto, "admin"), ResultStatus.MYSQL_ERROR); + } + + + @Test + public void getMonitorRulesTest() { + // 返回空集合测试1 + getMonitorRules2EmptyListTest1(); + + // 返回空集合测试2 + getMonitorRules2EmptyListTest2(); + + // 成功测试 + getMonitorRules2SuccessTest(); + + } + + private void getMonitorRules2EmptyListTest1() { + Mockito.when(monitorRuleDao.listAll()).thenReturn(new ArrayList<>()); + Assert.assertTrue(monitorService.getMonitorRules("admin").isEmpty()); + } + + private void getMonitorRules2EmptyListTest2() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + List monitorRuleDOList = new ArrayList<>(Arrays.asList(ruleDO)); + Mockito.when(monitorRuleDao.listAll()).thenReturn(monitorRuleDOList); + Mockito.when(appDao.getByPrincipal(Mockito.anyString())).thenReturn(new ArrayList<>()); + Assert.assertTrue(monitorService.getMonitorRules("admin").isEmpty()); + } + + private void getMonitorRules2SuccessTest() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + List monitorRuleDOList = new ArrayList<>(Arrays.asList(ruleDO)); + Mockito.when(monitorRuleDao.listAll()).thenReturn(monitorRuleDOList); + + AppDO appDO = getAppDO(); + List appDOList = new ArrayList<>(Arrays.asList(appDO)); + Mockito.when(appDao.getByPrincipal(Mockito.anyString())).thenReturn(appDOList); + List result = monitorService.getMonitorRules("admin"); + Assert.assertTrue(!result.isEmpty() && result.stream().allMatch(monitorRuleSummary -> monitorRuleSummary.getAppId().equals(appDO.getAppId()) && + monitorRuleSummary.getAppName().equals(appDO.getName()))); + } + + + @Test + public void getMonitorRuleDetailTest() { + // MONITOR_NOT_EXIST + getMonitorRuleDetail2MonitorNotExist(); + + // CALL_MONITOR_SYSTEM_ERROR + getMonitorRuleDetail2CallMonitorSystemErrorTest(); + + // 成功测试 + getMonitorRuleDetail2Success(); + } + + private void getMonitorRuleDetail2MonitorNotExist() { + Assert.assertEquals(monitorService.getMonitorRuleDetail(null).toString(), Result.buildFrom(ResultStatus.MONITOR_NOT_EXIST).toString()); + } + + private void getMonitorRuleDetail2CallMonitorSystemErrorTest() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + Mockito.when(abstractMonitorService.getStrategyById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.getMonitorRuleDetail(ruleDO).toString(), Result.buildFrom(ResultStatus.CALL_MONITOR_SYSTEM_ERROR).toString()); + } + + private void getMonitorRuleDetail2Success() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + Strategy strategy = getStrategy(); + Mockito.when(abstractMonitorService.getStrategyById(Mockito.anyLong())).thenReturn(strategy); + MonitorRuleDTO result = monitorService.getMonitorRuleDetail(ruleDO).getData(); + Assert.assertTrue(result.getAppId().equals(ruleDO.getAppId()) && + result.getName().equals(ruleDO.getName())); + } + + + @Test + public void getMonitorAlertHistoryTest() { + // MONITOR_NOT_EXIST + getMonitorAlertHistory2MonitorNotExistTest(); + + // CALL_MONITOR_SYSTEM_ERROR + getMonitorAlertHistory2CallMonitorSystemErrorTest(); + + // 成功测试 + getMonitorAlertHistory2SuccessTest(); + } + + private void getMonitorAlertHistory2MonitorNotExistTest() { + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.getMonitorAlertHistory(1L, 1L, 1L).toString(), Result.buildFrom(ResultStatus.MONITOR_NOT_EXIST).toString()); + } + + private void getMonitorAlertHistory2CallMonitorSystemErrorTest() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(ruleDO); + Mockito.when(abstractMonitorService.getAlerts(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(null); + Assert.assertEquals(monitorService.getMonitorAlertHistory(1L, 1L, 1L).toString(), Result.buildFrom(ResultStatus.CALL_MONITOR_SYSTEM_ERROR).toString()); + } + + private void getMonitorAlertHistory2SuccessTest() { + MonitorRuleDO ruleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.anyLong())).thenReturn(ruleDO); + Alert alert = getAlert(); + List alertList = new ArrayList<>(Arrays.asList(alert)); + Mockito.when(abstractMonitorService.getAlerts(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(alertList); + List result = monitorService.getMonitorAlertHistory(1L, 1L, 1L).getData(); + Assert.assertTrue(!result.isEmpty() && result.stream().allMatch(alert1 -> alert1.getId().equals(alert.getId()))); + } + + @Test + public void getMonitorAlertDetailTest() { + // CALL_MONITOR_SYSTEM_ERROR + getMonitorAlertDetail2CallMonitorSystemErrorTest(); + + // MONITOR_NOT_EXIST + getMonitorAlertDetail2MonitorNotExistTest(); + + // 成功测试 + getMonitorAlertDetail2SuccessTest(); + } + + private void getMonitorAlertDetail2CallMonitorSystemErrorTest() { + Mockito.when(abstractMonitorService.getAlertById(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.getMonitorAlertDetail(1L).toString(), Result.buildFrom(ResultStatus.CALL_MONITOR_SYSTEM_ERROR).toString()); + } + + private void getMonitorAlertDetail2MonitorNotExistTest() { + Alert alert = getAlert(); + Mockito.when(abstractMonitorService.getAlertById(Mockito.anyLong())).thenReturn(alert); + Mockito.when(monitorRuleDao.getByStrategyId(Mockito.anyLong())).thenReturn(null); + Assert.assertEquals(monitorService.getMonitorAlertDetail(1L).toString(), Result.buildFrom(ResultStatus.MONITOR_NOT_EXIST).toString()); + } + + private void getMonitorAlertDetail2SuccessTest() { + Alert alert = getAlert(); + Mockito.when(abstractMonitorService.getAlertById(Mockito.anyLong())).thenReturn(alert); + MonitorRuleDO ruleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getByStrategyId(Mockito.any())).thenReturn(ruleDO); + Metric metric = getMetric(); + Mockito.when(abstractMonitorService.getMetrics(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(metric); + MonitorAlertDetail data = monitorService.getMonitorAlertDetail(1L).getData(); + MonitorAlertDetail detail = getMonitorAlertDetail(); + detail.setAlert(alert); + detail.setMetric(metric); + + Assert.assertEquals(data.toString(), detail.toString()); + + } + + @Test + public void createSilenceTest() { + // MONITOR_NOT_EXIST + createSilence2MonitorNotExistTest(); + + // 未实现测试 + createSilence2EmptyTest(); + + // CALL_MONITOR_SYSTEM_ERROR + createSilence2CallMonitorSystemErrorTest(); + } + + private void createSilence2MonitorNotExistTest() { + MonitorSilenceDTO monitorSilenceDTO = getMonitorSilenceDTO(); + Mockito.when(monitorRuleDao.getById(Mockito.any())).thenReturn(null); + Assert.assertEquals(monitorService.createSilence(monitorSilenceDTO, "admin").toString(), Result.buildFrom(ResultStatus.MONITOR_NOT_EXIST).toString()); + } + + private void createSilence2EmptyTest() { + MonitorSilenceDTO monitorSilenceDTO = getMonitorSilenceDTO(); + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.any())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.createSilence(Mockito.any())).thenReturn(true); + Assert.assertNull(monitorService.createSilence(monitorSilenceDTO, "admin").getData()); + } + + private void createSilence2CallMonitorSystemErrorTest() { + MonitorSilenceDTO monitorSilenceDTO = getMonitorSilenceDTO(); + MonitorRuleDO monitorRuleDO = getMonitorRuleDO(); + Mockito.when(monitorRuleDao.getById(Mockito.any())).thenReturn(monitorRuleDO); + Mockito.when(abstractMonitorService.createSilence(Mockito.any())).thenReturn(false); + Assert.assertEquals(monitorService.createSilence(monitorSilenceDTO, "admin").toString(), Result.buildFrom(ResultStatus.CALL_MONITOR_SYSTEM_ERROR).toString()); + } + + + @Test + public void getSilencesTest() { + // CALL_MONITOR_SYSTEM_ERROR + getSilence2CallMonitorSystemErrorTest(); + + // 成功测试 + getSilence2SuccessTest(); + } + + private void getSilence2CallMonitorSystemErrorTest() { + Mockito.when(abstractMonitorService.getSilences(Mockito.any())).thenReturn(null); + Assert.assertEquals(monitorService.getSilences(1L).toString(), Result.buildFrom(ResultStatus.CALL_MONITOR_SYSTEM_ERROR).toString()); + } + + private void getSilence2SuccessTest() { + Silence silence = getSilence(); + List silenceList = new ArrayList<>(Arrays.asList(silence)); + Mockito.when(abstractMonitorService.getSilences(Mockito.any())).thenReturn(silenceList); + List data = monitorService.getSilences(1L).getData(); + Assert.assertTrue(!data.isEmpty() && data.stream().allMatch(silence1 -> silence1.getSilenceId().equals(silence.getSilenceId()))); + } } diff --git a/kafka-manager-extends/kafka-manager-monitor/src/test/resources/application.yml b/kafka-manager-extends/kafka-manager-monitor/src/test/resources/application.yml index a4648a46..d4d6d8f4 100644 --- a/kafka-manager-extends/kafka-manager-monitor/src/test/resources/application.yml +++ b/kafka-manager-extends/kafka-manager-monitor/src/test/resources/application.yml @@ -13,9 +13,9 @@ spring: active: dev datasource: kafka-manager: - jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 username: root - password: 123456 + password: 2PHCnL6RRM driver-class-name: com.mysql.cj.jdbc.Driver main: allow-bean-definition-overriding: true diff --git a/kafka-manager-extends/kafka-manager-openapi/pom.xml b/kafka-manager-extends/kafka-manager-openapi/pom.xml index caaa1242..739fccd1 100644 --- a/kafka-manager-extends/kafka-manager-openapi/pom.xml +++ b/kafka-manager-extends/kafka-manager-openapi/pom.xml @@ -48,5 +48,23 @@ spring-context ${spring-version} + + + + org.springframework.boot + spring-boot-starter-test + test + + + org.springframework.boot + spring-boot-starter-web + + + + org.testng + testng + 6.9.10 + + \ No newline at end of file diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/ThirdPartServiceTest.java b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/ThirdPartServiceTest.java new file mode 100644 index 00000000..af4d87f9 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/ThirdPartServiceTest.java @@ -0,0 +1,148 @@ +package com.xiaojukeji.kafka.manager.openapi; + +import com.xiaojukeji.kafka.manager.common.bizenum.ConsumeHealthEnum; +import com.xiaojukeji.kafka.manager.common.entity.Result; +import com.xiaojukeji.kafka.manager.common.entity.ResultStatus; +import com.xiaojukeji.kafka.manager.common.entity.ao.PartitionOffsetDTO; +import com.xiaojukeji.kafka.manager.common.entity.pojo.ClusterDO; +import com.xiaojukeji.kafka.manager.openapi.common.dto.OffsetResetDTO; +import com.xiaojukeji.kafka.manager.openapi.config.BaseTest; +import com.xiaojukeji.kafka.manager.service.service.ConsumerService; +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.lang.reflect.Array; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * @author wyc + * @date 2022/1/6 + */ +public class ThirdPartServiceTest extends BaseTest { + + private final static Long REAL_CLUSTER_ID_IN_MYSQL = 1L; + + private final static String REAL_TOPIC_IN_ZK = "topic_a"; + + private final static String REAL_PHYSICAL_CLUSTER_NAME = "cluster1"; + + private final static String ZOOKEEPER = "10.190.12.242:2181,10.190.25.160:2181,10.190.25.41:2181/wyc"; + + private final static String BOOTSTRAP_SERVERS = "10.190.12.242:9093,10.190.25.160:9093,10.190.25.41:9093"; + + private final static String SECURITY_PROPERTIES = "{ \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\\\";\" }"; + + private final static String JMX_PROPERTIES = "{\n" + "\t\"maxConn\": 100000\n" + "}"; + private final static Integer STATUS = 1; + + private final static String REAL_APP_ID = "dkm_admin"; + + // 要求消费topic_a这个topic的消费者所属的消费者组是group.demo + private final static String REAL_CONSUMER_GROUP_ID = "group.demo"; + + @Autowired + @InjectMocks + private ThirdPartService thirdPartService; + + @Mock + private ConsumerService consumerService; + + @BeforeMethod + public void init() { + MockitoAnnotations.initMocks(this); + } + + + private ClusterDO getClusterDO() { + ClusterDO clusterDO = new ClusterDO(); + clusterDO.setId(REAL_CLUSTER_ID_IN_MYSQL); + clusterDO.setClusterName(REAL_PHYSICAL_CLUSTER_NAME); + clusterDO.setBootstrapServers(BOOTSTRAP_SERVERS); + clusterDO.setJmxProperties(JMX_PROPERTIES); + clusterDO.setSecurityProperties(SECURITY_PROPERTIES); + clusterDO.setStatus(STATUS); + clusterDO.setZookeeper(ZOOKEEPER); + return clusterDO; + } + + private PartitionOffsetDTO getPartitionOffsetDTO() { + PartitionOffsetDTO dto = new PartitionOffsetDTO(); + dto.setPartitionId(0); + dto.setTimestamp(0L); + dto.setOffset(0L); + return dto; + } + + private OffsetResetDTO getOffsetResetDTO() { + OffsetResetDTO dto = new OffsetResetDTO(); + dto.setAppId(REAL_APP_ID); + dto.setClusterId(REAL_CLUSTER_ID_IN_MYSQL); + dto.setConsumerGroup(REAL_CONSUMER_GROUP_ID); + dto.setTopicName(REAL_TOPIC_IN_ZK); + dto.setTimestamp(0L); + dto.setPartitionOffsetDTOList(new ArrayList<>(Arrays.asList(getPartitionOffsetDTO()))); + dto.setLocation("broker"); + return dto; + } + + @Test(description = "CLUSTER_NOT_EXIST") + public void checkConsumeHealth2ClusterNotExistTest() { + // maxDelayTime = 24h,也就是如果消费组当前的offset介于24小时前这一时间戳对应的offset之后，则认为消费者是健康的 + Assert.assertEquals(thirdPartService.checkConsumeHealth(-1L, REAL_TOPIC_IN_ZK, REAL_CONSUMER_GROUP_ID, 60 * 60 * 24 * 1000L).toString(), Result.buildFrom(ResultStatus.CLUSTER_NOT_EXIST).toString()); + } + + @Test(description = "TOPIC_NOT_EXIST") + public void checkConsumeHealth2TopicNotExistTest() { + Assert.assertEquals(thirdPartService.checkConsumeHealth(1L, "topic_not_exist", REAL_CONSUMER_GROUP_ID, 60 * 60 * 24 * 1000L).toString(), Result.buildFrom(ResultStatus.TOPIC_NOT_EXIST).toString()); + } + + @Test(description = "CONSUMER_GROUP_NOT_EXIST") + public void checkConsumeHealth2ConsumerGroupNotExistTest() { + Assert.assertEquals(thirdPartService.checkConsumeHealth(REAL_CLUSTER_ID_IN_MYSQL, REAL_TOPIC_IN_ZK, "group_not_exist", 60 * 60 * 24 * 1000L).toString(), Result.buildFrom(ResultStatus.CONSUMER_GROUP_NOT_EXIST).toString()); + } + + @Test(description = "HEALTH") + public void checkConsumeHealth2HealthTest() { + // 要求生产者向topic_a发送消息，消费者的group.id=group.demo,生产者生产消息，消费者消费，之后让消费者停止，下面测试才能通过 + Assert.assertEquals(thirdPartService.checkConsumeHealth(REAL_CLUSTER_ID_IN_MYSQL, REAL_TOPIC_IN_ZK, REAL_CONSUMER_GROUP_ID, 60 * 60 * 24 * 1000L).toString(), new Result<>(ConsumeHealthEnum.HEALTH).toString()); + } + + + @Test + public void resetOffsetsTest() { + ClusterDO clusterDO = getClusterDO(); + OffsetResetDTO offsetResetDTO = getOffsetResetDTO(); + Mockito.when(consumerService.checkConsumerGroupExist(Mockito.any(), Mockito.any(), Mockito.anyString(),Mockito.anyString())).thenReturn(true); + List results = thirdPartService.resetOffsets(clusterDO, offsetResetDTO); + System.out.println(results); + } + + @Test + public void resetOffset2NullTest1() { + ClusterDO clusterDO = getClusterDO(); + Assert.assertNull(thirdPartService.resetOffsets(clusterDO, null)); + } + + @Test + public void resetOffsetSuccessTest() { + // 要求有消费组group.demo + Result expectedResult = Result.buildSuc(); + ClusterDO clusterDO = getClusterDO(); + OffsetResetDTO offsetResetDTO = getOffsetResetDTO(); + Mockito.when(consumerService.checkConsumerGroupExist(Mockito.any(), Mockito.any(), Mockito.anyString(),Mockito.anyString())).thenReturn(true); + Mockito.when(consumerService.resetConsumerOffset(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(new ArrayList<>(Arrays.asList(Result.buildSuc()))); + + List results = thirdPartService.resetOffsets(clusterDO, offsetResetDTO); + Assert.assertTrue(!results.isEmpty() && results.stream().allMatch(result -> result.toString().equals(expectedResult.toString()))); + } + + +} diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/BaseTest.java b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/BaseTest.java new file mode 100644 index 00000000..12ca4045 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/BaseTest.java @@ -0,0 +1,11 @@ +package com.xiaojukeji.kafka.manager.openapi.config; + +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests; + +@SpringBootTest(classes = CoreSpringBootStartUp.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT) +@ContextConfiguration(classes = CoreSpringBootStartUp.class) +public class BaseTest extends AbstractTransactionalTestNGSpringContextTests { + +} diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/CoreSpringBootStartUp.java b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/CoreSpringBootStartUp.java new file mode 100644 index 00000000..bb19be09 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/CoreSpringBootStartUp.java @@ -0,0 +1,21 @@ +package com.xiaojukeji.kafka.manager.openapi.config; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.web.servlet.ServletComponentScan; +import org.springframework.scheduling.annotation.EnableAsync; +import org.springframework.scheduling.annotation.EnableScheduling; + +@EnableAsync +@EnableScheduling +@ServletComponentScan +@EnableAutoConfiguration +@SpringBootApplication(scanBasePackages = {"com.xiaojukeji.kafka.manager"}) +public class CoreSpringBootStartUp { + public static void main(String[] args) { + SpringApplication sa = new SpringApplication(CoreSpringBootStartUp.class); + sa.run(args); + } + +} diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/DataSourceConfig.java b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/DataSourceConfig.java new file mode 100644 index 00000000..13788f27 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/java/com/xiaojukeji/kafka/manager/openapi/config/DataSourceConfig.java @@ -0,0 +1,51 @@ +package com.xiaojukeji.kafka.manager.openapi.config; + +import org.apache.ibatis.session.SqlSessionFactory; +import org.mybatis.spring.SqlSessionFactoryBean; +import org.mybatis.spring.SqlSessionTemplate; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.boot.jdbc.DataSourceBuilder; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import org.springframework.core.io.support.PathMatchingResourcePatternResolver; +import org.springframework.jdbc.datasource.DataSourceTransactionManager; + +import javax.sql.DataSource; + +/** + * @author zengqiao + * @date 20/3/17 + */ +@Configuration +public class DataSourceConfig { + @Bean(name = "dataSource") + @ConfigurationProperties(prefix = "spring.datasource.kafka-manager") + @Primary + public DataSource dataSource() { + return DataSourceBuilder.create().build(); + } + + @Bean(name = "sqlSessionFactory") + @Primary + public SqlSessionFactory sqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception { + SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); + bean.setDataSource(dataSource); + bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml")); + bean.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis-config.xml")); + return bean.getObject(); + } + + @Bean(name = "transactionManager") + @Primary + public DataSourceTransactionManager transactionManager(@Qualifier("dataSource") DataSource dataSource) { + return new DataSourceTransactionManager(dataSource); + } + + @Bean(name = "sqlSession") + @Primary + public SqlSessionTemplate sqlSessionTemplate(@Qualifier("sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { + return new SqlSessionTemplate(sqlSessionFactory); + } +} diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/resources/application.yml b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/application.yml new file mode 100644 index 00000000..d4d6d8f4 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/application.yml @@ -0,0 +1,98 @@ +server: + port: 8080 + tomcat: + accept-count: 1000 + max-connections: 10000 + max-threads: 800 + min-spare-threads: 100 + +spring: + application: + name: kafkamanager + profiles: + active: dev + datasource: + kafka-manager: + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + username: root + password: 2PHCnL6RRM + driver-class-name: com.mysql.cj.jdbc.Driver + main: + allow-bean-definition-overriding: true + + servlet: + multipart: + max-file-size: 100MB + max-request-size: 100MB + +logging: + config: classpath:logback-spring.xml + +custom: + idc: cn + jmx: + max-conn: 10 # 2.3版本配置不在这个地方生效 + store-metrics-task: + community: + broker-metrics-enabled: true + topic-metrics-enabled: true + didi: + app-topic-metrics-enabled: false + topic-request-time-metrics-enabled: false + topic-throttled-metrics: false + save-days: 7 + +# 任务相关的开关 +task: + op: + sync-topic-enabled: false # 未落盘的Topic定期同步到DB中 + order-auto-exec: # 工单自动化审批线程的开关 + topic-enabled: false # Topic工单自动化审批开关, false:关闭自动化审批, true:开启 + app-enabled: false # App工单自动化审批开关, false:关闭自动化审批, true:开启 + +account: + ldap: + enabled: false + url: ldap://127.0.0.1:389/ + basedn: dc=tsign,dc=cn + factory: com.sun.jndi.ldap.LdapCtxFactory + filter: sAMAccountName + security: + authentication: simple + principal: cn=admin,dc=tsign,dc=cn + credentials: admin + auth-user-registration: true + auth-user-registration-role: normal + +kcm: + enabled: false + s3: + endpoint: s3.didiyunapi.com + access-key: 1234567890 + secret-key: 0987654321 + bucket: logi-kafka + n9e: + base-url: http://127.0.0.1:8004 + user-token: 12345678 + timeout: 300 + account: root + script-file: kcm_script.sh + +monitor: + enabled: false + n9e: + nid: 2 + user-token: 1234567890 + mon: + base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000 + sink: + base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000 + rdb: + base-url: http://127.0.0.1:8000 # 夜莺v4版本，默认端口统一调整为了8000 + +notify: + kafka: + cluster-id: 95 + topic-name: didi-kafka-notify + order: + detail-url: http://127.0.0.1 diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/resources/distribution/kafka-manager-springboot-distribution.xml b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/distribution/kafka-manager-springboot-distribution.xml new file mode 100755 index 00000000..51c9a632 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/distribution/kafka-manager-springboot-distribution.xml @@ -0,0 +1,63 @@ + + assembly + + tar + zip + + + + src/main/resources/bin + bin + + control.sh + start.bat + + 0755 + + + src/main/resources + config + + *.properties + *.xml + *.yml + env/dev/* + env/qa/* + env/uat/* + env/prod/* + + + + target + lib + + + kafka-manager-web*.jar + + + + *sources.jar + + + + src/main/resources + logs + 0755 + + **/* + + + + + \ No newline at end of file diff --git a/kafka-manager-extends/kafka-manager-openapi/src/test/resources/logback-spring.xml b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/logback-spring.xml new file mode 100644 index 00000000..c1c16136 --- /dev/null +++ b/kafka-manager-extends/kafka-manager-openapi/src/test/resources/logback-spring.xml @@ -0,0 +1,215 @@ + + + logback + + + + + + + + + + + + + + info + + + ${CONSOLE_LOG_PATTERN} + UTF-8 + + + + + + + + + ${log.path}/log_debug.log + + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + + + ${log.path}/log_debug_%d{yyyy-MM-dd}.%i.log + + 100MB + + + 7 + + + + debug + ACCEPT + DENY + + + + + + + ${log.path}/log_info.log + + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + + + ${log.path}/log_info_%d{yyyy-MM-dd}.%i.log + + 100MB + + + 7 + + + + info + ACCEPT + DENY + + + + + + + ${log.path}/log_warn.log + + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + + ${log.path}/log_warn_%d{yyyy-MM-dd}.%i.log + + 100MB + + + 7 + + + + warn + ACCEPT + DENY + + + + + + + + ${log.path}/log_error.log + + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + + ${log.path}/log_error_%d{yyyy-MM-dd}.%i.log + + 100MB + + + 7 + + + + ERROR + ACCEPT + DENY + + + + + + ${log.path}/metrics/collector_metrics.log + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + ${log.path}/metrics/collector_metrics_%d{yyyy-MM-dd}.%i.log + + 100MB + + 3 + + + + + + ${log.path}/metrics/api_metrics.log + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + ${log.path}/metrics/api_metrics_%d{yyyy-MM-dd}.%i.log + + 100MB + + 3 + + + + + + ${log.path}/metrics/scheduled_tasks.log + + %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n + UTF-8 + + + ${log.path}/metrics/scheduled_tasks_%d{yyyy-MM-dd}.%i.log + + 100MB + + 5 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/kafka-manager-web/src/main/resources/application.yml b/kafka-manager-web/src/main/resources/application.yml index a4648a46..d4d6d8f4 100644 --- a/kafka-manager-web/src/main/resources/application.yml +++ b/kafka-manager-web/src/main/resources/application.yml @@ -13,9 +13,9 @@ spring: active: dev datasource: kafka-manager: - jdbc-url: jdbc:mysql://localhost:3306/logi_kafka_manager?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 + jdbc-url: jdbc:mysql://10.190.7.220:3306/user_test?characterEncoding=UTF-8&useSSL=false&serverTimezone=GMT%2B8 username: root - password: 123456 + password: 2PHCnL6RRM driver-class-name: com.mysql.cj.jdbc.Driver main: allow-bean-definition-overriding: true