diff --git a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/DataTest.java b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/DataTest.java index 7cb06efb93..1487179d4e 100644 --- a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/DataTest.java +++ b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/DataTest.java @@ -102,6 +102,13 @@ public static ServiceId newServiceId() { return serviceId; } + public static ServiceId newTestServiceId() { + ServiceId serviceId = new ServiceId(); + Map params = new HashMap<>(); + serviceId.setParameters(params); + return serviceId; + } + public static ServiceInstance genServiceInstance(int i) { Map map = new HashMap<>(); map.put(POLARIS_CMDBCAMPUS, "cmdbCampus"); @@ -170,6 +177,14 @@ private static PluginConfig createDiscoveryConfig() { return new PluginConfig("polaris", PolarisSelector.class, extMap); } + private static PluginConfig createDiscoveryConfig1() { + Map extMap = new HashMap<>(); + extMap.put(PolarisConstant.POLARIS_RUNMODE_KEY, RunMode.ModeNoAgent.ordinal()); + extMap.put(PolarisConstant.POLARIS_ADDRESSES_KEY, "http://10.235.25.499:8080"); + extMap.put(PolarisConstant.POLARIS_ENABLE_TRANS_META, "true"); + return new PluginConfig("polaris", PolarisSelector.class, extMap); + } + private static PluginConfig createWorkerPoolConfig() { return WorkerPoolManager.newThreadWorkerPoolConfig("selector_pool1", 4, Boolean.FALSE); diff --git a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/PolarisSelectorTest.java b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/PolarisSelectorTest.java index c85b9a7d0f..67ae1eff96 100644 --- a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/PolarisSelectorTest.java +++ b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/PolarisSelectorTest.java @@ -26,22 +26,27 @@ import com.tencent.polaris.api.rpc.InstancesResponse; import com.tencent.polaris.client.api.SDKContext; import com.tencent.polaris.factory.api.APIFactory; +import com.tencent.polaris.factory.config.ConfigurationImpl; +import com.tencent.polaris.plugins.loadbalancer.random.WeightedRandomBalance; +import com.tencent.polaris.plugins.loadbalancer.ringhash.ConsistentHashLoadBalance; import com.tencent.trpc.core.common.ConfigManager; import com.tencent.trpc.core.common.config.PluginConfig; import com.tencent.trpc.core.rpc.Request; import com.tencent.trpc.core.selector.ServiceId; import com.tencent.trpc.core.selector.ServiceInstance; +import com.tencent.trpc.polaris.common.PolarisConstant; import com.tencent.trpc.polaris.common.PolarisTrans; import com.tencent.trpc.selector.polaris.PolarisSelector; +import com.tencent.trpc.selector.polaris.common.PolarisCommon; import com.tencent.trpc.selector.polaris.common.pojo.PolarisServiceInstances; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; + +import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.concurrent.CompletionStage; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; + +import org.apache.commons.lang3.ObjectUtils; import org.junit.After; import org.junit.Assert; import org.junit.Before; @@ -152,9 +157,9 @@ public void testFallback() { clusterNaming.init(); ServiceId serviceId = DataTest.newServiceId(); serviceId.setServiceName("fallback"); - + Request request = DataTest.request; CompletionStage future = clusterNaming - .asyncSelectOne(serviceId, DataTest.request); + .asyncSelectOne(serviceId, request); AtomicReference errorRef = new AtomicReference<>(); CompletionStage stage = future.whenComplete((res, err) -> { if (err != null) { @@ -307,6 +312,12 @@ public void toPolarisInstance() { Assert.assertEquals("set.sz.1", polarisServiceInstance.getMetadata().get("set")); } + @Test + public void testEmptyToPolarisInstance() { + List serviceInstances = null; + Assert.assertNull(PolarisTrans.toPolarisInstance(serviceInstances)); + } + @Test public void testDestroy() { PolarisSelector clusterNaming = new PolarisSelector(); @@ -327,4 +338,113 @@ public void testGetConsumerAPI() { Assert.assertNotNull(polarisSelector.getPolarisAPI()); polarisSelector.destroy(); } + + @Test + public void testExceptionInit() { + PolarisSelector polarisSelector = new PolarisSelector(); + try { + polarisSelector.setPluginConfig(selectorConfig); + polarisSelector.init(); + Assert.assertNull(polarisSelector.getPolarisAPI()); + polarisSelector.destroy(); + } catch (Exception e) { + return; + } + } + + @Test + public void testExceptionWarmup() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + clusterNaming.init(); + ServiceId serviceId = DataTest.newTestServiceId(); + try { + clusterNaming.warmup(serviceId); + } catch (Exception e) { + return; + } + } + + @Test + public void testAsyncSelectOne() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + clusterNaming.init(); + ServiceId serviceId = DataTest.newServiceId(); + serviceId.setServiceName("service-metadata-select-one"); + clusterNaming.warmup(serviceId); + Request request = DataTest.mockServiceMetadataRequest(); + CompletionStage future = clusterNaming.asyncSelectOne(serviceId, request); + AtomicReference errorRef = new AtomicReference<>(); + CompletionStage stage = future.whenComplete((res, err) -> { + if (err != null) { + errorRef.set(err); + err.printStackTrace(); + } + }); + CompletableFuture.allOf(stage.toCompletableFuture()).join(); + Assert.assertNull(errorRef.get()); + } + + @Test + public void testGetCriteria() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + clusterNaming.init(); + ServiceId serviceId = DataTest.newServiceId(); + serviceId.setServiceName("service-metadata-select-one"); + clusterNaming.warmup(serviceId); + Request request = DataTest.mockServiceMetadataRequest(); + request.getMeta().setHashVal("123333"); + CompletionStage future = clusterNaming.asyncSelectOne(serviceId, request); + AtomicReference errorRef = new AtomicReference<>(); + CompletionStage stage = future.whenComplete((res, err) -> { + if (err != null) { + errorRef.set(err); + err.printStackTrace(); + } + }); + CompletableFuture.allOf(stage.toCompletableFuture()).join(); + Assert.assertNull(errorRef.get()); + } + + @Test + public void testExceptionAsyncSelectOne() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + ServiceId serviceId = DataTest.newServiceId(); + serviceId.setServiceName("fallback"); + Request request = DataTest.request; + try { + CompletionStage future = clusterNaming + .asyncSelectOne(serviceId, request); + } catch (Exception e) { + return; + } + } + + @Test + public void testExceptionReport() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + clusterNaming.init(); + try { + clusterNaming.report(null, 1, -1L); + } catch (Exception e) { + return; + } + } + + @Test + public void testExceptionAsyncSelectAll() { + PolarisSelector clusterNaming = new PolarisSelector(); + clusterNaming.setPluginConfig(selectorConfig); + clusterNaming.init(); + try { + ServiceId serviceId = Mockito.mock(ServiceId.class); + clusterNaming.asyncSelectAll(serviceId,DataTest.request); + } catch (Exception e) { + return; + } + } } diff --git a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/common/PolarisTransTest.java b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/common/PolarisTransTest.java index 69448746f2..18f5ec6fd4 100644 --- a/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/common/PolarisTransTest.java +++ b/trpc-selector/trpc-selector-open-polaris/src/test/java/com/tencent/trpc/selector/open/polaris/common/PolarisTransTest.java @@ -11,18 +11,39 @@ package com.tencent.trpc.selector.open.polaris.common; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import com.tencent.polaris.api.pojo.ServiceInstances; +import com.tencent.polaris.factory.config.consumer.CircuitBreakerConfigImpl; +import com.tencent.trpc.core.common.config.PluginConfig; +import com.tencent.trpc.core.selector.SelectorManager; +import com.tencent.trpc.core.selector.spi.Selector; +import com.tencent.trpc.selector.open.polaris.DataTest; +import com.tencent.trpc.selector.polaris.PolarisSelector; +import org.junit.Assert; +import org.junit.Test; +import org.mockito.Mockito; + import com.google.common.collect.Maps; +import com.tencent.polaris.api.plugin.route.RouteResult; +import com.tencent.polaris.api.plugin.route.RouteResult.NextRouterInfo; +import com.tencent.polaris.api.plugin.route.RouteResult.State; +import com.tencent.polaris.api.pojo.Instance; +import com.tencent.polaris.api.rpc.InstancesResponse; import com.tencent.polaris.factory.config.ConfigurationImpl; import com.tencent.polaris.factory.config.consumer.ConsumerConfigImpl; import com.tencent.polaris.factory.config.consumer.LocalCacheConfigImpl; import com.tencent.polaris.factory.config.global.APIConfigImpl; import com.tencent.polaris.factory.config.global.ServerConnectorConfigImpl; +import com.tencent.trpc.core.selector.ServiceInstance; import com.tencent.trpc.polaris.common.PolarisConstant; import com.tencent.trpc.polaris.common.PolarisTrans; -import java.util.HashMap; -import java.util.Map; -import org.junit.Assert; -import org.junit.Test; +import com.tencent.trpc.selector.polaris.common.PolarisCommon; public class PolarisTransTest { @@ -143,4 +164,137 @@ public void testUpdateConsumerConfig() { Assert.assertEquals(3, cacheConfig.getPersistMaxWriteRetry()); Assert.assertEquals("test_type", cacheConfig.getType()); } + + @Test + public void testGetPolarisInstanceId() { + Instance instance = Mockito.mock(Instance.class); + when(instance.getHost()).thenReturn("127.0.0.1"); + when(instance.getPort()).thenReturn(111); + when(instance.isHealthy()).thenReturn(true); + when(instance.getRevision()).thenReturn("1.0.0"); + Map metadata = new HashMap<>(); + metadata.put("set", "set.sz.1"); + metadata.put(PolarisConstant.POLARIS_ID, "sz0001"); + when(instance.getMetadata()).thenReturn(metadata); + + InstancesResponse instancesResponse = Mockito.mock(InstancesResponse.class); + when(instancesResponse.getTotalWeight()).thenReturn(1000); + when(instancesResponse.getNamespace()).thenReturn("dev"); + when(instancesResponse.getService()).thenReturn("trpc.test.test.1"); + when(instancesResponse.getInstances()).thenReturn(new Instance[]{instance}); + + ServiceInstance serviceInstance = PolarisTrans + .toServiceInstance(instancesResponse, instance); + String instanceId = PolarisTrans.getPolarisInstanceId(serviceInstance); + Assert.assertEquals("sz0001",instanceId); + } + + @Test + public void testParseRouterResult() { + Instance instance1 = Mockito.mock(Instance.class); + when(instance1.getId()).thenReturn("10001"); + when(instance1.getHost()).thenReturn("10.0.0.1"); + when(instance1.getPort()).thenReturn(2); + Map metadata = new HashMap<>(); + metadata.put("set", "set.sz.1"); + metadata.put(PolarisConstant.POLARIS_ID, "sz0001"); + when(instance1.getMetadata()).thenReturn(metadata); + + Instance instance2 = Mockito.mock(Instance.class); + when(instance2.getId()).thenReturn("10002"); + when(instance2.getHost()).thenReturn("10.0.0.1"); + when(instance2.getPort()).thenReturn(1); + List instances = new ArrayList<>(); + instances.add(instance1); + instances.add(instance2); + InstancesResponse instancesResponse = Mockito.mock(InstancesResponse.class); + when(instancesResponse.getTotalWeight()).thenReturn(1000); + when(instancesResponse.getNamespace()).thenReturn("dev"); + when(instancesResponse.getService()).thenReturn("trpc.test.test.1"); + when(instancesResponse.getInstances()).thenReturn(instances.toArray(new Instance[0])); + + RouteResult routeResult = Mockito.mock(RouteResult.class); + when(routeResult.getInstances()).thenReturn(instances); + when(routeResult.getNextRouterInfo()).thenReturn(new NextRouterInfo(State.Next)); + + List serviceInstances = PolarisTrans.parseRouterResult(routeResult,instancesResponse); + + ServiceInstances convertServiceIns = PolarisCommon.toServiceInstances(serviceInstances); + + Assert.assertEquals(2,serviceInstances.size()); + Assert.assertEquals("sz0001",serviceInstances.get(0).getParameter(PolarisConstant.POLARIS_ID)); + Assert.assertEquals(2,convertServiceIns.getInstances().size()); + } + + @Test + public void testGenCircuitBreakerConfiguration() { + ConfigurationImpl configuration = new ConfigurationImpl(); + configuration.setDefault(); + Map extMap = new HashMap<>(); + extMap.put(PolarisConstant.POLARIS_ID, "sz0001"); + CircuitBreakerConfigImpl circuitBreakerConfig = + PolarisCommon.genCircuitBreakerConfiguration(configuration,extMap); + Assert.assertEquals(1,circuitBreakerConfig.getChain().size()); + } + + @Test + public void testEmptyGenCircuitBreakerConfiguration() { + ConfigurationImpl configuration = new ConfigurationImpl(); + configuration.setDefault(); + Map extMap = null; + CircuitBreakerConfigImpl circuitBreakerConfig = + PolarisCommon.genCircuitBreakerConfiguration(configuration,extMap); + Assert.assertEquals(1,circuitBreakerConfig.getChain().size()); + } + + @Test + public void testEmptyGenPolarisConfiguration() { + Assert.assertNotNull(PolarisCommon.genPolarisConfiguration(null)); + } + + @Test + public void testGetSetName() { + Instance instance = Mockito.mock(Instance.class); + when(instance.getHost()).thenReturn("127.0.0.1"); + when(instance.getPort()).thenReturn(111); + when(instance.isHealthy()).thenReturn(true); + when(instance.getRevision()).thenReturn("1.0.0"); + Map metadata = new HashMap<>(); + metadata.put(PolarisConstant.INTERNAL_SET_NAME_KEY, "set.sz.1"); + metadata.put(PolarisConstant.INTERNAL_ENABLE_SET_KEY, "Y"); + when(instance.getMetadata()).thenReturn(metadata); + Assert.assertEquals("set.sz.1",PolarisTrans.getSetName(instance)); + } + + @Test + public void testGetContainerName() { + Instance instance = Mockito.mock(Instance.class); + when(instance.getHost()).thenReturn("127.0.0.1"); + when(instance.getPort()).thenReturn(111); + when(instance.isHealthy()).thenReturn(true); + when(instance.getRevision()).thenReturn("1.0.0"); + Map metadata = new HashMap<>(); + metadata.put(PolarisConstant.CONTAINER_NAME, "xxx1"); + when(instance.getMetadata()).thenReturn(metadata); + Assert.assertEquals("xxx1",PolarisTrans.getContainerName(instance)); + } + + @Test + public void testPickMetaData() { + Assert.assertNotNull(PolarisTrans.pickMetaData(new HashMap<>(),false,"sz11")); + } + + @Test + public void testEmptyTransfer2ServiceInstance() { + Assert.assertEquals(0,PolarisTrans.transfer2ServiceInstance(null,null).size()); + } + + @Test + public void testExceptionParseRouterResult() { + try { + PolarisTrans.parseRouterResult(null,null); + } catch (Exception e) { + return; + } + } }