diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java new file mode 100644 index 000000000..fb57206bb --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/annotation/SpringValueProcessorTest.java @@ -0,0 +1,153 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.annotation; + +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Objects; +import java.util.Optional; + +import com.tencent.cloud.polaris.config.PolarisConfigBootstrapAutoConfiguration; +import com.tencent.cloud.polaris.config.enums.RefreshType; +import com.tencent.cloud.polaris.config.spring.property.SpringValue; +import com.tencent.cloud.polaris.config.spring.property.SpringValueRegistry; +import com.tencent.polaris.api.utils.CollectionUtils; +import org.junit.Assert; +import org.junit.Test; + +import org.springframework.beans.factory.BeanFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.boot.autoconfigure.AutoConfigurations; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.test.context.runner.ApplicationContextRunner; +import org.springframework.cloud.autoconfigure.RefreshAutoConfiguration; +import org.springframework.context.annotation.Configuration; +import org.springframework.stereotype.Component; + +/** + * Test for {@link SpringValueProcessor}. + * + * @author lingxiao.wlx + */ +public class SpringValueProcessorTest { + + @Test + public void springValueFiledProcessorTest() { + ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(PolarisConfigBootstrapAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(RefreshAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(ValueTest.class)) + .withConfiguration(AutoConfigurations.of(PolarisConfigAutoConfiguration.class)) + .withPropertyValues("spring.application.name=" + "conditionalOnConfigReflectEnabledTest") + .withPropertyValues("spring.cloud.polaris.address=grpc://127.0.0.1:10081") + .withPropertyValues("spring.cloud.polaris.config.refresh-type=" + RefreshType.REFLECT) + .withPropertyValues("spring.cloud.polaris.config.enabled=true") + .withPropertyValues("timeout=10000"); + contextRunner.run(context -> { + SpringValueRegistry springValueRegistry = context.getBean(SpringValueRegistry.class); + PolarisConfigAutoConfiguration polarisConfigAutoConfiguration = context.getBean(PolarisConfigAutoConfiguration.class); + BeanFactory beanFactory = polarisConfigAutoConfiguration.beanFactory; + Collection timeout = springValueRegistry.get(beanFactory, "timeout"); + Assert.assertFalse(CollectionUtils.isEmpty(timeout)); + Optional springValueOptional = timeout.stream().findAny(); + Assert.assertTrue(springValueOptional.isPresent()); + + SpringValue springValue = springValueOptional.get(); + Assert.assertEquals("${timeout:1000}", springValue.getPlaceholder()); + Assert.assertTrue(springValue.isField()); + Assert.assertTrue(Objects.nonNull(springValue.getField())); + Assert.assertEquals("timeout", springValue.getField().getName()); + Assert.assertEquals(int.class, springValue.getTargetType()); + + ValueTest bean = context.getBean(ValueTest.class); + Assert.assertEquals(10000, bean.timeout); + }); + } + + @Test + public void springValueMethodProcessorTest() { + ApplicationContextRunner contextRunner = new ApplicationContextRunner() + .withConfiguration(AutoConfigurations.of(PolarisConfigBootstrapAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(RefreshAutoConfiguration.class)) + .withConfiguration(AutoConfigurations.of(ValueTest.class)) + .withConfiguration(AutoConfigurations.of(PolarisConfigAutoConfiguration.class)) + .withPropertyValues("spring.application.name=" + "conditionalOnConfigReflectEnabledTest") + .withPropertyValues("spring.cloud.polaris.address=grpc://127.0.0.1:10081") + .withPropertyValues("spring.cloud.polaris.config.refresh-type=" + RefreshType.REFLECT) + .withPropertyValues("spring.cloud.polaris.config.enabled=true") + .withPropertyValues("name=test"); + contextRunner.run(context -> { + SpringValueRegistry springValueRegistry = context.getBean(SpringValueRegistry.class); + PolarisConfigAutoConfiguration polarisConfigAutoConfiguration = context.getBean(PolarisConfigAutoConfiguration.class); + BeanFactory beanFactory = polarisConfigAutoConfiguration.beanFactory; + Collection name = springValueRegistry.get(beanFactory, "name"); + Assert.assertFalse(CollectionUtils.isEmpty(name)); + Optional springValueOptional = name.stream().findAny(); + Assert.assertTrue(springValueOptional.isPresent()); + + SpringValue springValue = springValueOptional.get(); + Method method = springValue.getMethodParameter().getMethod(); + Assert.assertTrue(Objects.nonNull(method)); + Assert.assertEquals("setName", method.getName()); + Assert.assertEquals("${name:1000}", springValue.getPlaceholder()); + Assert.assertFalse(springValue.isField()); + Assert.assertEquals(String.class, springValue.getTargetType()); + + Assert.assertEquals("test", ValueTest.name); + }); + } + + @Configuration + @EnableAutoConfiguration + static class PolarisConfigAutoConfiguration { + + @Autowired + private BeanFactory beanFactory; + + public BeanFactory getBeanFactory() { + return beanFactory; + } + + public void setBeanFactory(BeanFactory beanFactory) { + this.beanFactory = beanFactory; + } + } + + @Component + private static class ValueTest { + @Value("${timeout:1000}") + private int timeout; + + private static String name; + + public int getTimeout() { + return timeout; + } + + public void setTimeout(int timeout) { + this.timeout = timeout; + } + + @Value("${name:1000}") + public void setName(String name) { + ValueTest.name = name; + } + } +} diff --git a/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java new file mode 100644 index 000000000..a605dda88 --- /dev/null +++ b/spring-cloud-starter-tencent-polaris-config/src/test/java/com/tencent/cloud/polaris/config/spring/property/PlaceholderHelperTest.java @@ -0,0 +1,88 @@ +/* + * Tencent is pleased to support the open source community by making Spring Cloud Tencent available. + * + * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved. + * + * Licensed under the BSD 3-Clause License (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + * + * Unless required by applicable law or agreed to in writing, software distributed + * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR + * CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + */ + +package com.tencent.cloud.polaris.config.spring.property; + +import java.util.Set; + +import com.tencent.polaris.api.utils.CollectionUtils; +import org.junit.Assert; +import org.junit.Test; + +/** + * Test for {@link PlaceholderHelper}. + * + * @author lingxiao.wlx + */ +public class PlaceholderHelperTest { + + private static final PlaceholderHelper PLACEHOLDER_HELPER = new PlaceholderHelper(); + + @Test + public void extractNormalPlaceholderKeysTest() { + final String placeholderCase = "${some.key}"; + final String placeholderCase1 = "${some.key:${some.other.key:100}}"; + final String placeholderCase2 = "${${some.key}}"; + final String placeholderCase3 = "${${some.key:other.key}}"; + final String placeholderCase4 = "${${some.key}:${another.key}}"; + final String placeholderCase5 = "#{new java.text.SimpleDateFormat('${some.key}').parse('${another.key}')}"; + + Set placeholderKeys = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase); + Assert.assertEquals(1, placeholderKeys.size()); + Assert.assertTrue(placeholderKeys.contains("some.key")); + + Set placeholderKeys1 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase1); + Assert.assertEquals(2, placeholderKeys1.size()); + Assert.assertTrue(placeholderKeys1.contains("some.key")); + Assert.assertTrue(placeholderKeys1.contains("some.other.key")); + + Set placeholderKeys2 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase2); + Assert.assertEquals(1, placeholderKeys2.size()); + Assert.assertTrue(placeholderKeys2.contains("some.key")); + + Set placeholderKeys3 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase3); + Assert.assertEquals(1, placeholderKeys3.size()); + Assert.assertTrue(placeholderKeys3.contains("some.key")); + + Set placeholderKeys4 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase4); + Assert.assertEquals(2, placeholderKeys4.size()); + Assert.assertTrue(placeholderKeys4.contains("some.key")); + Assert.assertTrue(placeholderKeys4.contains("another.key")); + + Set placeholderKeys5 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase5); + Assert.assertEquals(2, placeholderKeys5.size()); + Assert.assertTrue(placeholderKeys5.contains("some.key")); + Assert.assertTrue(placeholderKeys5.contains("another.key")); + } + + @Test + public void extractIllegalPlaceholderKeysTest() { + final String placeholderCase = "${some.key"; + final String placeholderCase1 = "{some.key}"; + final String placeholderCase2 = "some.key"; + + Set placeholderKeys = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys)); + + Set placeholderKeys1 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase1); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys1)); + + Set placeholderKeys2 = PLACEHOLDER_HELPER.extractPlaceholderKeys(placeholderCase2); + Assert.assertTrue(CollectionUtils.isEmpty(placeholderKeys2)); + } +}