From 672f3d40be83d9e380fd7be4b674d5e8d5fa36de Mon Sep 17 00:00:00 2001 From: HuabingZhao Date: Tue, 25 Jul 2017 15:18:33 +0800 Subject: Divide the MSB source codes into two repos Change-Id: Ie76d545b214a8ce5191f215350a623e1529983d9 Issue-id: MSB-5 Signed-off-by: HuabingZhao --- .../org/onap/msb/apiroute/SyncDataManagerTest.java | 56 ++ .../apiroute/health/ApiRouteHealthCheckTest.java | 69 +++ .../apiroute/health/ConsulLinkHealthCheckTest.java | 103 ++++ .../apiroute/health/OpenRestyHealthCheckTest.java | 77 +++ .../msb/apiroute/health/RedisHealthCheckTest.java | 77 +++ .../wrapper/ApiRouteServiceWrapperTest.java | 252 ++++++++ .../wrapper/CustomRouteServiceWrapperTest.java | 208 +++++++ .../wrapper/InitRouteServiceWrapperTest.java | 241 ++++++++ .../wrapper/IuiRouteServiceWrapperTest.java | 212 +++++++ .../apiroute/wrapper/MicroServiceWrapperTest.java | 294 +++++++++ .../apiroute/wrapper/consulextend/ConsulTest.java | 149 +++++ .../consulextend/cache/ServiceHealthCacheTest.java | 24 + .../cache/ServicesCatalogCacheTest.java | 15 + ...ServiceDataEmptyAndAutoStopWatchFilterTest.java | 53 ++ .../expose/CheckTagAndAutoStopWatchFilterTest.java | 70 +++ .../consulextend/expose/ConsulIndexFilterTest.java | 42 ++ .../expose/ServiceModifyIndexFilterTest.java | 114 ++++ .../expose/WatchCatalogServicesTaskTest.java | 138 +++++ .../expose/WatchServiceHealthTaskTest.java | 156 +++++ .../expose/WriteBufferHandlerTest.java | 46 ++ .../model/health/ServiceHealthTest.java | 54 ++ .../consulextend/model/health/ServiceTest.java | 32 + .../wrapper/consulextend/util/HttpTest.java | 80 +++ .../apiroute/wrapper/queue/QueueManagerTest.java | 178 ++++++ .../wrapper/service/ApiRouteServiceTest.java | 251 ++++++++ .../wrapper/service/CustomRouteServiceTest.java | 241 ++++++++ .../wrapper/service/IuiRouteServiceTest.java | 221 +++++++ .../service/MicroServiceFullServiceTest.java | 413 +++++++++++++ .../MicroServiceChangeListenerTest.java | 666 +++++++++++++++++++++ .../msb/apiroute/wrapper/util/CommonUtilTest.java | 61 ++ .../msb/apiroute/wrapper/util/ConfigUtilTest.java | 214 +++++++ .../apiroute/wrapper/util/HttpClientUtilTest.java | 29 + .../apiroute/wrapper/util/JacksonJsonUtilTest.java | 94 +++ .../msb/apiroute/wrapper/util/JedisUtilTest.java | 20 + .../wrapper/util/MicroServiceUtilTest.java | 45 ++ .../apiroute/wrapper/util/RegExpTestUtilTest.java | 96 +++ .../msb/apiroute/wrapper/util/RouteUtilTest.java | 373 ++++++++++++ .../apiroute/wrapper/util/ServiceFilterTest.java | 210 +++++++ 38 files changed, 5674 insertions(+) create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/SyncDataManagerTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ApiRouteHealthCheckTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ConsulLinkHealthCheckTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/OpenRestyHealthCheckTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/RedisHealthCheckTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/ApiRouteServiceWrapperTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/CustomRouteServiceWrapperTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/InitRouteServiceWrapperTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/IuiRouteServiceWrapperTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/MicroServiceWrapperTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/ConsulTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServiceHealthCacheTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServicesCatalogCacheTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckServiceDataEmptyAndAutoStopWatchFilterTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckTagAndAutoStopWatchFilterTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ConsulIndexFilterTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ServiceModifyIndexFilterTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchCatalogServicesTaskTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchServiceHealthTaskTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WriteBufferHandlerTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceHealthTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/util/HttpTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/queue/QueueManagerTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/ApiRouteServiceTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/CustomRouteServiceTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/IuiRouteServiceTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/MicroServiceFullServiceTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/serviceListener/MicroServiceChangeListenerTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/CommonUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ConfigUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JedisUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RouteUtilTest.java create mode 100644 apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ServiceFilterTest.java (limited to 'apiroute/apiroute-service/src/test/java/org/onap') diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/SyncDataManagerTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/SyncDataManagerTest.java new file mode 100644 index 0000000..668d445 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/SyncDataManagerTest.java @@ -0,0 +1,56 @@ +package org.onap.msb.apiroute; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.onap.msb.apiroute.SyncDataManager; +import org.onap.msb.apiroute.wrapper.consulextend.async.ConsulResponseCallback; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import com.fasterxml.jackson.core.type.TypeReference; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ Http.class }) +@PowerMockIgnore({ "javax.net.ssl.*" }) +public class SyncDataManagerTest { + + @SuppressWarnings("unchecked") + @Before + public void setUpBeforeTest() { + Http http = PowerMockito.mock(Http.class); + + PowerMockito + .doNothing() + .when(http) + .asyncGet(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + PowerMockito + .doNothing() + .when(http) + .asyncGetDelayHandle(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + // + PowerMockito.spy(Http.class); + PowerMockito.when(Http.getInstance()).thenReturn(http); + + } + + @Test + public void testSyncDataManager() + { + SyncDataManager.initSyncTask("127.0.0.1",8500); + SyncDataManager.startWatchService("huangleibo"); + SyncDataManager.resetIndex("huangleibo"); + SyncDataManager.stopWatchService("huangleibo"); + SyncDataManager.stopWatchServiceList(); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ApiRouteHealthCheckTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ApiRouteHealthCheckTest.java new file mode 100644 index 0000000..1048ce0 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ApiRouteHealthCheckTest.java @@ -0,0 +1,69 @@ +package org.onap.msb.apiroute.health; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.onap.msb.apiroute.health.ApiRouteHealthCheck; +import org.onap.msb.apiroute.wrapper.util.HttpClientUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.codahale.metrics.health.HealthCheck.Result; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ HttpClientUtil.class }) +public class ApiRouteHealthCheckTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(ApiRouteHealthCheckTest.class); + + @Test + public void testchecksuccess() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(200); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + ApiRouteHealthCheck check = new ApiRouteHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testchecksuccess health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testchecksuccess health"); + } + } + + @Test + public void testcheckfailed() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(400); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + ApiRouteHealthCheck check = new ApiRouteHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testcheckfailed health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testcheckfailed health"); + } + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ConsulLinkHealthCheckTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ConsulLinkHealthCheckTest.java new file mode 100644 index 0000000..50ac829 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/ConsulLinkHealthCheckTest.java @@ -0,0 +1,103 @@ +package org.onap.msb.apiroute.health; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.onap.msb.apiroute.health.ConsulLinkHealthCheck; +import org.onap.msb.apiroute.wrapper.util.HttpClientUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.codahale.metrics.health.HealthCheck.Result; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ HttpClientUtil.class,ConsulLinkHealthCheck.class }) +public class ConsulLinkHealthCheckTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(ConsulLinkHealthCheckTest.class); + + @Test + public void testchecksuccess() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(200); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("CONSUL_IP")).thenReturn("192.168.0.1"); + + ConsulLinkHealthCheck check = new ConsulLinkHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testchecksuccess health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testchecksuccess health"); + } + } + + @Test + public void testcheckfailed() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(400); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("CONSUL_IP")).thenReturn("192.168.0.1"); + + ConsulLinkHealthCheck check = new ConsulLinkHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testcheckfailed health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug("testcheckfailed health"); + } + } + + + @Test + public void testcheckNoENV() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(400); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("CONSUL_IP")).thenReturn(""); + + ConsulLinkHealthCheck check = new ConsulLinkHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testcheckNoENV health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug("testcheckNoENV health"); + } + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/OpenRestyHealthCheckTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/OpenRestyHealthCheckTest.java new file mode 100644 index 0000000..810f645 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/OpenRestyHealthCheckTest.java @@ -0,0 +1,77 @@ +package org.onap.msb.apiroute.health; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.onap.msb.apiroute.health.OpenRestyHealthCheck; +import org.onap.msb.apiroute.wrapper.util.HttpClientUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.codahale.metrics.health.HealthCheck.Result; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ HttpClientUtil.class,OpenRestyHealthCheck.class }) +public class OpenRestyHealthCheckTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(OpenRestyHealthCheckTest.class); + + @Test + public void testchecksuccess() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(200); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("HTTP_OVERWRITE_PORT")).thenReturn("10080"); + + OpenRestyHealthCheck check = new OpenRestyHealthCheck(); + + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testchecksuccess health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testchecksuccess health"); + } + } + + @Test + public void testcheckfailed() + { + PowerMockito.mockStatic(HttpClientUtil.class); + try { + + PowerMockito.when(HttpClientUtil.httpGetStatus(Mockito.anyString())).thenReturn(400); + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("HTTP_OVERWRITE_PORT")).thenReturn(""); + + OpenRestyHealthCheck check = new OpenRestyHealthCheck(); + + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testchecksuccess health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testchecksuccess health"); + } + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/RedisHealthCheckTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/RedisHealthCheckTest.java new file mode 100644 index 0000000..a667df2 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/health/RedisHealthCheckTest.java @@ -0,0 +1,77 @@ +package org.onap.msb.apiroute.health; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.health.RedisHealthCheck; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.codahale.metrics.health.HealthCheck.Result; +import com.fiftyonred.mock_jedis.MockJedisPool; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class RedisHealthCheckTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(RedisHealthCheckTest.class); + + @Before + public void setUpBeforeTest() throws Exception { + + } + + @SuppressWarnings("static-access") + @Test + public void testchecksuccess() + { + + try { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + RedisHealthCheck check = new RedisHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testchecksuccess health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug(" testchecksuccess health"); + } + + } catch (Exception e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + + @Test + public void testcheckfailed() + { + RedisHealthCheck check = new RedisHealthCheck(); + Result rst = check.execute(); + + if (!rst.isHealthy()) { + LOGGER.warn("testcheckfailed health check failed:"+rst.getMessage()); + } + else + { + LOGGER.debug("testcheckfailed health"); + } + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/ApiRouteServiceWrapperTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/ApiRouteServiceWrapperTest.java new file mode 100644 index 0000000..bb90a2c --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/ApiRouteServiceWrapperTest.java @@ -0,0 +1,252 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.ApiRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException; +import org.onap.msb.apiroute.wrapper.ApiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.JacksonJsonUtil; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; + + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RouteUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class ApiRouteServiceWrapperTest { + private static ApiRouteServiceWrapper apiRouteServiceWrapper; + private static Comparator apiRouteComparator = null; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + apiRouteServiceWrapper=ApiRouteServiceWrapper.getInstance(); + apiRouteComparator = new Comparator() { + @Override + public int compare(ApiRouteInfo o1, ApiRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + if (!o1.getVersion().equals(o2.getVersion())) + return (o1.getVersion()).compareTo(o2.getVersion()); + return 0; + } + }; + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn(null); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn("ip|domain"); + ConfigUtil.getInstance().initRouteWay(); + } + + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + + + @Test + public void test_getApiRouteInstance_not_exist(){ + try { + apiRouteServiceWrapper.getApiRouteInstance("testForJunit", "v1","","","ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_getApiRouteInstance(){ + + ApiRouteInfo apirouteInfo = buildApiRouteInfo(); + try { + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo, "ip"); + ApiRouteInfo dbApirouteInfo=apiRouteServiceWrapper.getApiRouteInstance("testapi", "v1", "", "", "ip"); + Assert.assertEquals(apirouteInfo,dbApirouteInfo ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + + @Test + public void test_getAllApiRouteInstances(){ + ApiRouteInfo apirouteInfo = buildApiRouteInfo(); + ApiRouteInfo apirouteInfo2 = buildApiRouteInfo2(); + List expected = new ArrayList<>(); + expected.add(apirouteInfo); + expected.add(apirouteInfo2); + Collections.sort(expected, apiRouteComparator); + + try { + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo, "ip"); + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo2, "ip"); + + + PowerMockito.mockStatic(RouteUtil.class); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE, "ip")).thenReturn("msb:routing:api:*"); + List apiRouterList=apiRouteServiceWrapper.getAllApiRouteInstances("ip"); + Collections.sort(apiRouterList, apiRouteComparator); + + Assert.assertEquals(expected,apiRouterList); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_updateApiRouteStatus(){ + ApiRouteInfo apirouteInfo = buildApiRouteInfo(); + try { + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo, "ip"); + ApiRouteInfo dbApirouteInfo=apiRouteServiceWrapper.getApiRouteInstance("testapi", "v1", "", "", "ip"); + Assert.assertEquals("1",dbApirouteInfo.getStatus() ); + apiRouteServiceWrapper.updateApiRouteStatus("testapi","v1","","","0", "ip"); + dbApirouteInfo=apiRouteServiceWrapper.getApiRouteInstance("testapi", "v1", "", "", "ip"); + Assert.assertEquals("0",dbApirouteInfo.getStatus() ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + + @Test + public void test_deleteApiRoute(){ + ApiRouteInfo apirouteInfo2 = buildApiRouteInfo2(); + try { + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo2, "ip"); + ApiRouteInfo dbApirouteInfo=apiRouteServiceWrapper.getApiRouteInstance("testapi2", "null","","","ip"); + Assert.assertNotNull(dbApirouteInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + try { + apiRouteServiceWrapper.deleteApiRoute("testapi2", "null","","","ip"); + apiRouteServiceWrapper.getApiRouteInstance("testapi2", "","","","ip"); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + } + + @Test + public void test_getAllApiDocs(){ + String[] paths=apiRouteServiceWrapper.getAllApiDocs(); + String[] expecteds_paths={"api-doc1.json","api-doc2.json"}; + Arrays.sort(expecteds_paths); + Arrays.sort(paths); + Assert.assertArrayEquals(expecteds_paths, paths); + } + + @Test + public void test_getAllrouteByJson(){ + ApiRouteInfo apirouteInfo = buildApiRouteInfo(); + try { + apiRouteServiceWrapper.saveApiRouteInstance4Rest(apirouteInfo, "ip"); + + ApiRouteInfo[] apirouteList={apirouteInfo}; + String expected_routeJson=JacksonJsonUtil.beanToJson(apirouteList); + + PowerMockito.mockStatic(RouteUtil.class); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE, "ip")).thenReturn("msb:routing:api:*"); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE, "ip")).thenReturn("msb:routing:iui:*"); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE, "ip")).thenReturn("msb:routing:custom:*"); + + String allrouteJson= apiRouteServiceWrapper.getAllrouteByJson("ip"); + Assert.assertEquals(expected_routeJson, allrouteJson); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + + } + + + + private ApiRouteInfo buildApiRouteInfo(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + apirouteInfo.setServers(servers); + return apirouteInfo; + } + + private ApiRouteInfo buildApiRouteInfo2(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi2"); + apirouteInfo.setVersion(""); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi2/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("1"); + apirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.89","8080")}; + apirouteInfo.setServers(servers); + return apirouteInfo; + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/CustomRouteServiceWrapperTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/CustomRouteServiceWrapperTest.java new file mode 100644 index 0000000..3c77dbf --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/CustomRouteServiceWrapperTest.java @@ -0,0 +1,208 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.CustomRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException; +import org.onap.msb.apiroute.wrapper.CustomRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RouteUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class CustomRouteServiceWrapperTest { + + private static CustomRouteServiceWrapper customRouteServiceWrapper; + private static Comparator customRouteComparator = null; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + customRouteServiceWrapper=CustomRouteServiceWrapper.getInstance(); + customRouteComparator = new Comparator() { + @Override + public int compare(CustomRouteInfo o1, CustomRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + return 0; + } + }; + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn(null); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn("ip|domain"); + ConfigUtil.getInstance().initRouteWay(); + } + + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + @Test + public void test_getCustomRouteInstance_not_exist(){ + try { + customRouteServiceWrapper.getCustomRouteInstance("/testForJunit","","","ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + + } + + } + + @Test + public void test_getCustomRouteInstance(){ + + CustomRouteInfo customrouteInfo = buildCustomRouteInfo(); + try { + customRouteServiceWrapper.saveCustomRouteInstance4Rest(customrouteInfo, "ip"); + CustomRouteInfo dbCustomRouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/testcustom", "", "", "ip"); + Assert.assertEquals(customrouteInfo,dbCustomRouteInfo ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_getAllCustomRouteInstances(){ + CustomRouteInfo customrouteInfo = buildCustomRouteInfo(); + CustomRouteInfo customrouteInfo2 = buildCustomRouteInfo2(); + List expected = new ArrayList<>(); + expected.add(customrouteInfo); + expected.add(customrouteInfo2); + Collections.sort(expected, customRouteComparator); + + try { + customRouteServiceWrapper.saveCustomRouteInstance4Rest(customrouteInfo, "ip"); + customRouteServiceWrapper.saveCustomRouteInstance4Rest(customrouteInfo2, "ip"); + + PowerMockito.mockStatic(RouteUtil.class); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE, "ip")).thenReturn("msb:routing:custom:*"); + List customRouterList=customRouteServiceWrapper.getAllCustomRouteInstances("ip"); + Collections.sort(customRouterList, customRouteComparator); + + Assert.assertEquals(expected,customRouterList); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_updateCustomRouteStatus(){ + CustomRouteInfo customrouteInfo = buildCustomRouteInfo(); + try { + customRouteServiceWrapper.saveCustomRouteInstance4Rest(customrouteInfo, "ip"); + CustomRouteInfo dbCustomrouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/testcustom", "", "", "ip"); + Assert.assertEquals("1",dbCustomrouteInfo.getStatus() ); + customRouteServiceWrapper.updateCustomRouteStatus("/testcustom","","","0", "ip"); + dbCustomrouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/testcustom", "", "", "ip"); + Assert.assertEquals("0",dbCustomrouteInfo.getStatus() ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + + @Test + public void test_deleteCustomRoute(){ + CustomRouteInfo customrouteInfo2 = buildCustomRouteInfo2(); + try { + customRouteServiceWrapper.saveCustomRouteInstance4Rest(customrouteInfo2, "ip"); + CustomRouteInfo dbCustomrouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/testcustom2","","","ip"); + Assert.assertNotNull(dbCustomrouteInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + try { + customRouteServiceWrapper.deleteCustomRoute("/testcustom2","","","ip"); + customRouteServiceWrapper.getCustomRouteInstance("/testcustom2","","","ip"); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + } + + + private CustomRouteInfo buildCustomRouteInfo(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("/testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + return customrouteInfo; + } + + private CustomRouteInfo buildCustomRouteInfo2(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("/testcustom2"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("1"); + customrouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.89","8080")}; + customrouteInfo.setServers(servers); + return customrouteInfo; + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/InitRouteServiceWrapperTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/InitRouteServiceWrapperTest.java new file mode 100644 index 0000000..7c183dd --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/InitRouteServiceWrapperTest.java @@ -0,0 +1,241 @@ +package org.onap.msb.apiroute.wrapper; + +import io.dropwizard.jetty.HttpConnectorFactory; +import io.dropwizard.server.SimpleServerFactory; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.msb.apiroute.ApiRouteAppConfig; +import org.onap.msb.apiroute.api.ApiRouteInfo; +import org.onap.msb.apiroute.api.CustomRouteInfo; +import org.onap.msb.apiroute.api.DiscoverInfo; +import org.onap.msb.apiroute.api.IuiRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.wrapper.ApiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.CustomRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.InitRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.IuiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.async.ConsulResponseCallback; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fiftyonred.mock_jedis.MockJedisPool; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ JedisUtil.class, RedisAccessWrapper.class, ConfigUtil.class, + Http.class, InitRouteServiceWrapper.class }) +@PowerMockIgnore({ "javax.management.*", "javax.net.ssl.*" }) +public class InitRouteServiceWrapperTest { + private static InitRouteServiceWrapper initRouteServiceWrapper; + private static Consul consul; + + @SuppressWarnings("unchecked") + @BeforeClass + public static void setUpBeforeClass() throws Exception { + initRouteServiceWrapper = InitRouteServiceWrapper.getInstance(); + + Http http = PowerMockito.mock(Http.class); + + PowerMockito + .doNothing() + .when(http) + .asyncGet(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + PowerMockito + .doNothing() + .when(http) + .asyncGetDelayHandle(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + PowerMockito.spy(Http.class); + PowerMockito.when(Http.getInstance()).thenReturn(http); + + consul = Consul.builder().withHostAndPort("127.0.0.1", 8500).build(); + } + + @Before + public void initReidsMock() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool( + new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil = PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn( + mockJedisPool.getResource()); + + PowerMockito.replace( + PowerMockito.method(RedisAccessWrapper.class, "filterKeys")) + .with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, + Object[] args) throws Throwable { + return mockJedisPool.getResource().keys( + (String) args[0]); + } + }); + } + + @Test + public void test_startCheckRedisConnect() { + try { + boolean ifRedisConnect = initRouteServiceWrapper + .startCheckRedisConnect(); + Assert.assertEquals(true, ifRedisConnect); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + + } + } + + @Test + public void test_runConsulClientApp() { + + DiscoverInfo discoverInfo = new DiscoverInfo(); + discoverInfo.setEnabled(true); + discoverInfo.setIp("127.0.0.1"); + discoverInfo.setPort(10081); + + ApiRouteAppConfig configuration = new ApiRouteAppConfig(); + configuration.setDiscoverInfo(discoverInfo); + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("SDCLIENT_IP")).thenReturn("127.0.0.1"); + ConfigUtil.getInstance().initDiscoverInfo(configuration); + + try { + initRouteServiceWrapper.runConsulClientApp(); + + ApiRouteInfo discoverApiService = new ApiRouteInfo(); + discoverApiService.setServiceName("msdiscover"); + discoverApiService.setUrl("/api/microservices/v1"); + discoverApiService.setVersion("v1"); + discoverApiService.setMetricsUrl("/admin/metrics"); + discoverApiService.setApiJson("/api/microservices/v1/swagger.json"); + discoverApiService.setHost("msb"); + + RouteServer[] servers = new RouteServer[1]; + servers[0] = new RouteServer(discoverInfo.getIp(), + String.valueOf(discoverInfo.getPort())); + discoverApiService.setServers(servers); + + ApiRouteInfo db_discoverApiService = ApiRouteServiceWrapper + .getInstance().getApiRouteInstance("msdiscover", "v1", + "msb", "", "ip"); + Assert.assertEquals(discoverApiService, db_discoverApiService); + + IuiRouteInfo discoverIUIService = new IuiRouteInfo(); + discoverIUIService.setServiceName("msdiscover"); + discoverIUIService.setUrl("/iui/microservices"); + discoverIUIService.setHost("msb"); + discoverIUIService.setServers(servers); + + Assert.assertEquals( + discoverIUIService, + IuiRouteServiceWrapper.getInstance().getIuiRouteInstance( + "msdiscover", "msb", "", "ip")); + + } catch (Exception e) { + assert false : "throw exception means error occured!" + + e.getMessage(); + } + } + + @Test + public void test_initRouteInfoFromJson() { + try { + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("dwApp_server_connector_port")) + .thenReturn("8068"); + initRouteServiceWrapper.initRouteInfoFromJson(); + + ApiRouteInfo apiroute = new ApiRouteInfo(); + apiroute.setServiceName("microservices"); + apiroute.setUrl("/api/microservices/v1"); + apiroute.setVersion("v1"); + apiroute.setMetricsUrl("/admin/metrics"); + apiroute.setApiJson("/api/microservices/v1/swagger.json"); + apiroute.setHost("msb"); + apiroute.setControl("1"); + apiroute.setStatus("1"); + + RouteServer[] servers = new RouteServer[1]; + servers[0] = new RouteServer("127.0.0.1", "8068"); + apiroute.setServers(servers); + + ApiRouteInfo db_apiService = ApiRouteServiceWrapper + .getInstance() + .getApiRouteInstance("microservices", "v1", "msb", "", "ip"); + Assert.assertEquals(apiroute, db_apiService); + + IuiRouteInfo iuiRoute = new IuiRouteInfo(); + iuiRoute.setServiceName("microservices"); + iuiRoute.setUrl("/iui/microservices"); + iuiRoute.setHost("msb"); + iuiRoute.setControl("1"); + iuiRoute.setStatus("1"); + iuiRoute.setServers(servers); + + Assert.assertEquals(iuiRoute, IuiRouteServiceWrapper.getInstance() + .getIuiRouteInstance("microservices", "msb", "", "ip")); + + CustomRouteInfo customRoute = new CustomRouteInfo(); + customRoute.setServiceName("/custom"); + customRoute.setUrl("/custom"); + customRoute.setHost("msb"); + customRoute.setControl("1"); + customRoute.setStatus("1"); + RouteServer[] servers2 = new RouteServer[1]; + servers2[0] = new RouteServer("127.0.0.1", "8066"); + customRoute.setServers(servers2); + + Assert.assertEquals(customRoute, + CustomRouteServiceWrapper.getInstance() + .getCustomRouteInstance("/custom", "msb", "", "ip")); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + } + + @Test + public void test_initMetricsConfig() { + ApiRouteAppConfig configuration = new ApiRouteAppConfig(); + SimpleServerFactory simpleServerFactory = new SimpleServerFactory(); + HttpConnectorFactory httpConnectorFactory = new HttpConnectorFactory(); + httpConnectorFactory.setPort(8888); + simpleServerFactory.setConnector(httpConnectorFactory); + simpleServerFactory.setAdminContextPath("/admin"); + + configuration.setServerFactory(simpleServerFactory); + + initRouteServiceWrapper.initMetricsConfig(configuration); + + Assert.assertEquals("http://127.0.0.1:8888/admin/metrics", ConfigUtil + .getInstance().getMetricsUrl()); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/IuiRouteServiceWrapperTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/IuiRouteServiceWrapperTest.java new file mode 100644 index 0000000..7451e9b --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/IuiRouteServiceWrapperTest.java @@ -0,0 +1,212 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Ignore; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.IuiRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException; +import org.onap.msb.apiroute.wrapper.IuiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; + + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RouteUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class IuiRouteServiceWrapperTest { + private static IuiRouteServiceWrapper iuiRouteServiceWrapper; + private static Comparator iuiRouteComparator = null; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + iuiRouteServiceWrapper=IuiRouteServiceWrapper.getInstance(); + iuiRouteComparator = new Comparator() { + @Override + public int compare(IuiRouteInfo o1, IuiRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + return 0; + } + }; + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn(null); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn("ip|domain"); + ConfigUtil.getInstance().initRouteWay(); + } + + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + + @Test + public void test_getIuiRouteInstance_not_exist(){ + try { + iuiRouteServiceWrapper.getIuiRouteInstance("testForJunit","","","ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + + } + + } + + @Test + public void test_getIuiRouteInstance(){ + + IuiRouteInfo iuirouteInfo = buildIuiRouteInfo(); + try { + iuiRouteServiceWrapper.saveIuiRouteInstance4Rest(iuirouteInfo, "ip"); + IuiRouteInfo dbIuiRouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("testiui", "", "", "ip"); + Assert.assertEquals(iuirouteInfo,dbIuiRouteInfo ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_getAllIuiRouteInstances(){ + IuiRouteInfo iuirouteInfo = buildIuiRouteInfo(); + IuiRouteInfo iuirouteInfo2 = buildIuiRouteInfo2(); + List expected = new ArrayList<>(); + expected.add(iuirouteInfo); + expected.add(iuirouteInfo2); + Collections.sort(expected, iuiRouteComparator); + + try { + iuiRouteServiceWrapper.saveIuiRouteInstance4Rest(iuirouteInfo, "ip"); + iuiRouteServiceWrapper.saveIuiRouteInstance4Rest(iuirouteInfo2, "ip"); + + + + PowerMockito.mockStatic(RouteUtil.class); + PowerMockito.when(RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE, "ip")).thenReturn("msb:routing:iui:*"); + List iuiRouterList=iuiRouteServiceWrapper.getAllIuiRouteInstances("ip"); + Collections.sort(iuiRouterList, iuiRouteComparator); + + Assert.assertEquals(expected,iuiRouterList); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_updateIuiRouteStatus(){ + IuiRouteInfo iuirouteInfo = buildIuiRouteInfo(); + try { + iuiRouteServiceWrapper.saveIuiRouteInstance4Rest(iuirouteInfo, "ip"); + IuiRouteInfo dbIuirouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("testiui", "", "", "ip"); + Assert.assertEquals("1",dbIuirouteInfo.getStatus() ); + iuiRouteServiceWrapper.updateIuiRouteStatus("testiui","","","0", "ip"); + dbIuirouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("testiui", "", "", "ip"); + Assert.assertEquals("0",dbIuirouteInfo.getStatus() ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + + @Test + public void test_deleteIuiRoute(){ + IuiRouteInfo iuirouteInfo2 = buildIuiRouteInfo2(); + try { + iuiRouteServiceWrapper.saveIuiRouteInstance4Rest(iuirouteInfo2, "ip"); + IuiRouteInfo dbIuirouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("testiui2","","","ip"); + Assert.assertNotNull(dbIuirouteInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + try { + iuiRouteServiceWrapper.deleteIuiRoute("testiui2","","","ip"); + iuiRouteServiceWrapper.getIuiRouteInstance("testiui2","","","ip"); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + } + + + private IuiRouteInfo buildIuiRouteInfo(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + iuirouteInfo.setServers(servers); + return iuirouteInfo; + } + + private IuiRouteInfo buildIuiRouteInfo2(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui2"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("1"); + iuirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.89","8080")}; + iuirouteInfo.setServers(servers); + return iuirouteInfo; + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/MicroServiceWrapperTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/MicroServiceWrapperTest.java new file mode 100644 index 0000000..d830397 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/MicroServiceWrapperTest.java @@ -0,0 +1,294 @@ +package org.onap.msb.apiroute.wrapper; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.MicroServiceFullInfo; +import org.onap.msb.apiroute.api.Node; +import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException; +import org.onap.msb.apiroute.api.exception.UnprocessableEntityException; +import org.onap.msb.apiroute.wrapper.MicroServiceWrapper; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; + + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class MicroServiceWrapperTest { + private static MicroServiceWrapper microServiceWrapper; + private static Comparator microServiceComparator = null; + + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + microServiceWrapper=MicroServiceWrapper.getInstance(); + microServiceComparator = new Comparator() { + @Override + public int compare(MicroServiceFullInfo o1, MicroServiceFullInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + return 0; + } + }; + } + + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + @Test + public void test_getMicroServiceFullInfo_not_exist(){ + try { + microServiceWrapper.getMicroServiceInstance("testForJunit","v1"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + + } + + } + + @Test + public void test_getMicroServiceFullInfo(){ + + MicroServiceFullInfo microServiceFullInfo = buildMicroServiceFullInfo(); + try { + microServiceWrapper.saveMicroServiceInstance(microServiceFullInfo, false, "", ""); + MicroServiceFullInfo dbMicroServiceFullInfo=microServiceWrapper.getMicroServiceInstance("testService", "v1"); + Assert.assertEquals(microServiceFullInfo,dbMicroServiceFullInfo ); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + + } + + @Test + public void test_getAllMicroServiceInstances(){ + MicroServiceFullInfo microService = buildMicroServiceFullInfo(); + MicroServiceFullInfo microService2 = buildMicroServiceFullInfo2(); + List expected = new ArrayList<>(); + expected.add(microService); + expected.add(microService2); + Collections.sort(expected, microServiceComparator); + + try { + microServiceWrapper.saveMicroServiceInstance(microService, false, "", ""); + microServiceWrapper.saveMicroServiceInstance(microService2, false, "", ""); + + List microServiceList=microServiceWrapper.getAllMicroServiceInstances(); + Collections.sort(microServiceList, microServiceComparator); + + Assert.assertEquals(expected,microServiceList); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + @Test + public void test_updateMicroServiceStatus(){ + MicroServiceFullInfo microService = buildMicroServiceFullInfo(); + + try { + microServiceWrapper.saveMicroServiceInstance(microService, false, "", ""); + MicroServiceFullInfo dbMicroServiceFullInfo=microServiceWrapper.getMicroServiceInstance("testService", "v1"); + Assert.assertEquals("1",dbMicroServiceFullInfo.getStatus() ); + microServiceWrapper.updateMicroServiceStatus("testService","v1","0"); + dbMicroServiceFullInfo=microServiceWrapper.getMicroServiceInstance("testService", "v1"); + Assert.assertEquals("0",dbMicroServiceFullInfo.getStatus() ); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + + @Test + public void test_deleteMicroService(){ + MicroServiceFullInfo microService = buildMicroServiceFullInfo2(); + try { + microServiceWrapper.saveMicroServiceInstance(microService, false, "", ""); + MicroServiceFullInfo dbMicroServiceFullInfo=microServiceWrapper.getMicroServiceInstance("testService2", "v1"); + Assert.assertNotNull(dbMicroServiceFullInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + try { + microServiceWrapper.deleteMicroService("testService2","v1"); + microServiceWrapper.getMicroServiceInstance("testService2", "v1"); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + } + + @Test + public void test_deleteMicroServiceInstance(){ + + + //添加多版本服务 + MicroServiceFullInfo microService4v2 = buildMicroServiceFullInfo4version2(); + try { + microServiceWrapper.saveMicroServiceInstance(microService4v2, false, "", ""); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + //删除不存在实例 + try { + microServiceWrapper.deleteMicroServiceInstance("testService","v2","127.0.0.1","8989"); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + //删除其中一个实例 + microServiceWrapper.deleteMicroServiceInstance("testService","v2","10.74.148.87","8080"); + MicroServiceFullInfo microService =microServiceWrapper.getMicroServiceInstance("testService", "v2"); + + Set nodeSet=new HashSet(); + nodeSet.add(new Node("10.74.148.86","8080")); + Assert.assertEquals(nodeSet, microService.getNodes()); + + //删除服务 + microServiceWrapper.deleteMicroServiceInstance("testService","v2","10.74.148.86","8080"); + } + catch(Exception e){ + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + microServiceWrapper.getMicroServiceInstance("testService","v2"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + + } + } + + @Test + public void test_getAllVersion(){ + try { + microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo(), false, "", ""); + microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo4version2(), false, "", ""); + Set versionSet=new HashSet(); + versionSet.add("v1"); + versionSet.add("v2"); + Assert.assertEquals(versionSet,microServiceWrapper.getAllVersion("testService")); + + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + try { + microServiceWrapper.deleteMicroService4AllVersion("testService"); + Assert.assertEquals(0,microServiceWrapper.getAllVersion("testService").size()); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + + } + + } + + @Test + public void test_getAllMicroServiceKey(){ + microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo(), false, "", ""); + microServiceWrapper.saveMicroServiceInstance(buildMicroServiceFullInfo2(), false, "", ""); + Set builder = new HashSet(); + builder.add("testService"); + builder.add("testService2"); + Assert.assertEquals(builder,microServiceWrapper.getAllMicroServiceKey()); + + + } + + private MicroServiceFullInfo buildMicroServiceFullInfo(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("HTTP"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + + return microServiceFullInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4version2(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v2"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("HTTP"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.87","8080")); + nodeSet.add(new Node("10.74.148.86","8080")); + microServiceFullInfo.setNodes(nodeSet); + + return microServiceFullInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo2(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService2"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/api/testService/v1"); + microServiceFullInfo.setVisualRange("1"); + microServiceFullInfo.setProtocol("REST"); + microServiceFullInfo.setEnable_ssl(true); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.89","8080")); + microServiceFullInfo.setNodes(nodeSet); + + return microServiceFullInfo; + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/ConsulTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/ConsulTest.java new file mode 100644 index 0000000..abf5e09 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/ConsulTest.java @@ -0,0 +1,149 @@ +package org.onap.msb.apiroute.wrapper.consulextend; + +import java.util.List; + +import org.apache.http.HttpEntity; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.msb.apiroute.wrapper.consulextend.CatalogClient; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.HealthClient; +import org.onap.msb.apiroute.wrapper.consulextend.async.ConsulResponseCallback; +import org.onap.msb.apiroute.wrapper.consulextend.async.OriginalConsulResponse; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.option.CatalogOptions; +import com.orbitz.consul.option.QueryOptions; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ Http.class }) +@PowerMockIgnore({ "javax.net.ssl.*" }) +public class ConsulTest { + private static Consul consul10081; + private static Consul consul8500; + + private static final Logger LOGGER = LoggerFactory + .getLogger(ConsulTest.class); + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @BeforeClass + public static void setUpBeforeClass() throws Exception { + + Http http = PowerMockito.mock(Http.class); + + PowerMockito + .doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) + throws Throwable { + Object[] args = invocation.getArguments(); + ((ConsulResponseCallback) args[2]).onComplete(null); + return null; + } + }) + .when(http) + .asyncGet(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + // + PowerMockito.spy(Http.class); + PowerMockito.when(Http.getInstance()).thenReturn(http); + + // + consul10081 = Consul.builder().withHostAndPort("10.74.148.111", 10081) + .build(); + consul8500 = Consul.builder().withHostAndPort("10.74.148.111", 8500) + .build(); + } + + @Test + public void testcatalogClient() { + + ConsulResponseCallback callback = new ConsulResponseCallback() { + + @Override + public void onComplete( + ConsulResponse consulResponse) { + LOGGER.info("service list complete!"); + } + + @Override + public void onFailure(Throwable throwable) { + LOGGER.info("service list failure!"); + } + + @Override + public void onDelayComplete( + OriginalConsulResponse originalConsulResponse) { + // TODO Auto-generated method stub + LOGGER.info("service list complete!"); + } + + }; + + // 10081 + CatalogClient catalogclient10081 = consul10081.catalogClient(); + catalogclient10081.getServices(CatalogOptions.BLANK, QueryOptions.BLANK, callback); + + // 8500 + CatalogClient catalogclient8500 = consul8500.catalogClient(); + catalogclient8500.getServices(CatalogOptions.BLANK, QueryOptions.BLANK, callback); + } + + @Test + public void testhealthClient() { + + ConsulResponseCallback> callback = new ConsulResponseCallback>() { + + @Override + public void onComplete( + ConsulResponse> consulResponse) { + LOGGER.info("health service complete!"); + + } + + @Override + public void onFailure(Throwable throwable) { + LOGGER.info("health service failure!"); + } + + @Override + public void onDelayComplete( + OriginalConsulResponse> originalConsulResponse) { + // TODO Auto-generated method stub + LOGGER.info("health service complete!"); + } + + }; + + // 10081 + HealthClient healthClient10081 = consul10081.healthClient(); + healthClient10081.getAllServiceInstances("apigateway-default", CatalogOptions.BLANK, + QueryOptions.BLANK, callback); + + healthClient10081.getHealthyServiceInstances("apigateway-default", + CatalogOptions.BLANK, QueryOptions.BLANK, callback); + + // 8500 + HealthClient healthClient8500 = consul8500.healthClient(); + healthClient8500.getAllServiceInstances("apigateway-default", CatalogOptions.BLANK, + QueryOptions.BLANK, callback); + healthClient8500.getHealthyServiceInstances("apigateway-default", CatalogOptions.BLANK, + QueryOptions.BLANK, callback); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServiceHealthCacheTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServiceHealthCacheTest.java new file mode 100644 index 0000000..03cc209 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServiceHealthCacheTest.java @@ -0,0 +1,24 @@ +package org.onap.msb.apiroute.wrapper.consulextend.cache; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.cache.ServiceHealthCache; + +import com.orbitz.consul.option.CatalogOptions; + +public class ServiceHealthCacheTest { + + @Test + public void testnewCache() { + Consul consul = Consul.newClient(); + ServiceHealthCache cache1 = ServiceHealthCache.newCache( + consul.healthClient(), "huangleibo"); + Assert.assertNotNull(cache1); + + ServiceHealthCache cache2 = ServiceHealthCache.newCache( + consul.healthClient(), "huangleibo", false, + CatalogOptions.BLANK, 10); + Assert.assertNotNull(cache2); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServicesCatalogCacheTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServicesCatalogCacheTest.java new file mode 100644 index 0000000..7518ad7 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/cache/ServicesCatalogCacheTest.java @@ -0,0 +1,15 @@ +package org.onap.msb.apiroute.wrapper.consulextend.cache; + +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.cache.ServicesCatalogCache; + +public class ServicesCatalogCacheTest { + + @Test + public void testnewCache() + { + Consul consul = Consul.newClient(); + ServicesCatalogCache cache = ServicesCatalogCache.newCache(consul.catalogClient()); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckServiceDataEmptyAndAutoStopWatchFilterTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckServiceDataEmptyAndAutoStopWatchFilterTest.java new file mode 100644 index 0000000..9b9dd17 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckServiceDataEmptyAndAutoStopWatchFilterTest.java @@ -0,0 +1,53 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + + + + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.expose.CheckServiceDataEmptyAndAutoStopWatchFilter; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; + +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.model.health.ImmutableNode; + +public class CheckServiceDataEmptyAndAutoStopWatchFilterTest { + @Test + public void testfilter() + { + + + CheckServiceDataEmptyAndAutoStopWatchFilter filter = new CheckServiceDataEmptyAndAutoStopWatchFilter("huangleibo"); + + + List list = new ArrayList(); + + //id:huangleibo1,name:huangleibo,modifyIndex:1,createindex:1 + Service service0 = ImmutableService.builder().id("huangleibo1").port(0).address("") + .service("huangleibo").addTags("").createIndex(1).modifyIndex(1).build(); + ServiceHealth serviceHealth0 = ImmutableServiceHealth.builder() + .service(service0) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + + list.add(serviceHealth0); + ConsulResponse> object = new ConsulResponse>(list,1,true, BigInteger.valueOf(1)); + + //have service,return true + Assert.assertTrue(filter.filter(object)); + + //empty [],return false + list.clear(); + Assert.assertFalse(filter.filter(object)); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckTagAndAutoStopWatchFilterTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckTagAndAutoStopWatchFilterTest.java new file mode 100644 index 0000000..bd9fe3a --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/CheckTagAndAutoStopWatchFilterTest.java @@ -0,0 +1,70 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.expose.CheckTagAndAutoStopWatchFilter; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; + +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.model.health.ImmutableNode; + +public class CheckTagAndAutoStopWatchFilterTest { + + @Test + public void testfilter() { + + CheckTagAndAutoStopWatchFilter filter = new CheckTagAndAutoStopWatchFilter("huangleibo"); + + + List list = new ArrayList(); + + //visual range:0,tags meet conditions + List tags = new ArrayList(); + tags.add("\"base\":{\"protocol\":\"REST\",\"is_manual\":\"true\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tags.add("\"ns\":{\"namespace\":\"nsName\"}"); + tags.add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + + Service service0 = ImmutableService.builder().id("huangleibo1").port(0) + .address("").service("huangleibo").tags(tags).createIndex(1) + .modifyIndex(1).build(); + ServiceHealth serviceHealth0 = ImmutableServiceHealth.builder() + .service(service0) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + + list.add(serviceHealth0); + ConsulResponse> object = new ConsulResponse>(list,1,true,BigInteger.valueOf(1)); + + //visual range:0,tags meet conditions,return true + Assert.assertTrue(filter.filter(object)); + + //visual range:1,tags don't meet conditions + List tags1 = new ArrayList(); + tags1.add("\"base\":{\"protocol\":\"REST\",\"is_manual\":\"true\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tags1.add("\"ns\":{\"namespace\":\"nsName\"}"); + tags1.add("\"labels\":{\"visualRange\":\"1\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + + Service service1 = ImmutableService.builder().id("huangleibo1").port(0) + .address("").service("huangleibo").tags(tags1).createIndex(1) + .modifyIndex(1).build(); + ServiceHealth serviceHealth1 = ImmutableServiceHealth.builder() + .service(service1) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + list.clear(); + list.add(serviceHealth1); + + //visual range:1,tags don't meet conditions,return false + Assert.assertFalse(filter.filter(object)); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ConsulIndexFilterTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ConsulIndexFilterTest.java new file mode 100644 index 0000000..51dfa49 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ConsulIndexFilterTest.java @@ -0,0 +1,42 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; + +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.expose.ConsulIndexFilter; + +import com.orbitz.consul.model.ConsulResponse; + +public class ConsulIndexFilterTest { + @BeforeClass + public static void setUpBeforeClass() throws Exception { + + } + + @Test + public void testfilter() + { + ConsulIndexFilter filter = new ConsulIndexFilter(); + + int response = 1; + long lastContact= 1; + boolean knownLeader = true; + + ConsulResponse object = new ConsulResponse(response,lastContact,knownLeader,BigInteger.valueOf(1)); + + //index 1;the first time,return true + Assert.assertTrue(filter.filter(object)); + + + //index 1;same index,return false + Assert.assertFalse(filter.filter(object)); + + ConsulResponse object1 = new ConsulResponse(response,lastContact,knownLeader,BigInteger.valueOf(2)); + + //index 2;different index,return true + Assert.assertTrue(filter.filter(object1)); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ServiceModifyIndexFilterTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ServiceModifyIndexFilterTest.java new file mode 100644 index 0000000..bc01589 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/ServiceModifyIndexFilterTest.java @@ -0,0 +1,114 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.expose.ServiceModifyIndexFilter; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; + +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.model.health.ImmutableNode; + +public class ServiceModifyIndexFilterTest { + + @Test + public void testfilter() + { + ServiceModifyIndexFilter filter = new ServiceModifyIndexFilter(); + + + List list0 = new ArrayList(); + + //id:huangleibo1,name:huangleibo,modifyIndex:1,createIndex:1 + Service service0 = ImmutableService.builder().id("huangleibo1").port(0).address("") + .service("huangleibo").addTags("").createIndex(1).modifyIndex(1).build(); + ServiceHealth serviceHealth0 = ImmutableServiceHealth.builder() + .service(service0) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + list0.add(serviceHealth0); + + ConsulResponse> object0 = new ConsulResponse>(list0,1,true,BigInteger.valueOf(1)); + + //list-size:1,id:huangleibo1,name:huangleibo,modifyIndex:1;the first time:return true + Assert.assertTrue(filter.filter(object0)); + + //list-size:1,id:huangleibo1,name:huangleibo,modifyIndex:1;same index:return false + Assert.assertFalse(filter.filter(object0)); + + ///////////////////////////////////////////////////////////////////////////////// + + List list1 = new ArrayList(); + + //id:huangleibo2,name:huangleibo,modifyIndex:1,createIndex:1 + Service service1 = ImmutableService.builder().id("huangleibo2").port(0).address("") + .service("huangleibo").addTags("").createIndex(1).modifyIndex(1).build(); + ServiceHealth serviceHealth1 = ImmutableServiceHealth.builder() + .service(service1) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + + list1.add(serviceHealth0); + list1.add(serviceHealth1); + + ConsulResponse> object1 = new ConsulResponse>(list1,1,true,BigInteger.valueOf(1)); + + //list-size:2, + //id:huangleibo1,name:huangleibo,modifyIndex:1,createIndex:1 + //id:huangleibo2,name:huangleibo,modifyIndex:1,createIndex:1 + //size different,return true + Assert.assertTrue(filter.filter(object1)); + + ////////////////////////////////////////////////////////////////////////// + List list2 = new ArrayList(); + + //id:huangleibo3,name:huangleibo,modifyIndex:1,createIndex:1 + ImmutableService service2 = ImmutableService.builder().id("huangleibo3").port(0).address("") + .service("huangleibo").addTags("").createIndex(1).modifyIndex(1).build(); + ServiceHealth serviceHealth2 = ImmutableServiceHealth.builder() + .service(service2) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + list2.add(serviceHealth0); + list2.add(serviceHealth2); + + ConsulResponse> object2 = new ConsulResponse>(list2,1,true,BigInteger.valueOf(1)); + + //list-size:2, + //id:huangleibo1,name:huangleibo,modifyIndex:1,createIndex:1 + //id:huangleibo3,name:huangleibo,modifyIndex:1,createIndex:1 + //instance id different,return true + Assert.assertTrue(filter.filter(object2)); + + + ////////////////////////////////////////////////////////////////////////// + List list3 = new ArrayList(); + + //edit modifyindex 1 to 2 + Service service3 = service2.withModifyIndex(2); + ServiceHealth serviceHealth3 = ImmutableServiceHealth.builder() + .service(service3) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + list3.add(serviceHealth0); + list3.add(serviceHealth3); + + ConsulResponse> object3 = new ConsulResponse>(list3,1,true,BigInteger.valueOf(1)); + + //list-size:2, + //id:huangleibo1,name:huangleibo,modifyIndex:1,createIndex:1 + //id:huangleibo3,name:huangleibo,modifyIndex:2,createIndex:1 + //modifyIndex different,return true + Assert.assertTrue(filter.filter(object3)); + + //the same content,return false + Assert.assertFalse(filter.filter(object3)); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchCatalogServicesTaskTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchCatalogServicesTaskTest.java new file mode 100644 index 0000000..14455ee --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchCatalogServicesTaskTest.java @@ -0,0 +1,138 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.http.HttpEntity; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.async.ConsulResponseCallback; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchCatalogServicesTask; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchTask; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchTask.Filter; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.option.CatalogOptions; +import com.orbitz.consul.option.QueryOptions; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ Http.class }) +@PowerMockIgnore({ "javax.net.ssl.*" }) +public class WatchCatalogServicesTaskTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(WatchCatalogServicesTaskTest.class); + + private Consul consul; + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Before + public void init() { + + Map> catalogservices = new HashMap>(); + String servicename = "huangleibo"; + List tags = new ArrayList(); + tags.add("1111"); + tags.add("2222"); + catalogservices.put(servicename, tags); + + long lastContact = 1; + boolean knownLeader = true; + BigInteger index = BigInteger.valueOf(1); + final ConsulResponse>> response = new ConsulResponse>>( + catalogservices, lastContact, knownLeader, index); + + // + Http http = PowerMockito.mock(Http.class); + + PowerMockito + .doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) + throws Throwable { + Object[] args = invocation.getArguments(); + ((ConsulResponseCallback) args[2]).onComplete(response); + return null; + } + }) + .when(http) + .asyncGet(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + // + PowerMockito.spy(Http.class); + PowerMockito.when(Http.getInstance()).thenReturn(http); + + consul = Consul.newClient(); + + WatchCatalogServicesTask task0 = new WatchCatalogServicesTask( + consul.catalogClient(), CatalogOptions.BLANK, + QueryOptions.BLANK, 10); + + WatchCatalogServicesTask task1 = new WatchCatalogServicesTask( + consul.catalogClient(), 10); + + WatchCatalogServicesTask task2 = new WatchCatalogServicesTask( + consul.catalogClient()); + + } + + public class StopHandler implements WatchTask.Handler + { + + private WatchCatalogServicesTask task; + + StopHandler(WatchCatalogServicesTask task) + { + this.task = task; + } + + @Override + public void handle(ConsulResponse object) { + // TODO Auto-generated method stub +// Map> map = (Map>)object.getResponse(); + LOGGER.debug("handler is here"); + task.stopWatch(); + } + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test + public void teststartWatch() { + WatchCatalogServicesTask task0 = new WatchCatalogServicesTask( + consul.catalogClient(), CatalogOptions.BLANK, + QueryOptions.BLANK, 10); + + task0.addFilter(new Filter() { + @Override + public boolean filter(ConsulResponse object) { + // TODO Auto-generated method stub +// Map> map = (Map>)object.getResponse(); + LOGGER.debug("filter is here"); + return true; + } + + }); + + task0.addHandler(new StopHandler(task0)); + + task0.startWatch(); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchServiceHealthTaskTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchServiceHealthTaskTest.java new file mode 100644 index 0000000..0e5f95b --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WatchServiceHealthTaskTest.java @@ -0,0 +1,156 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.msb.apiroute.wrapper.consulextend.Consul; +import org.onap.msb.apiroute.wrapper.consulextend.async.ConsulResponseCallback; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchServiceHealthTask; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchTask; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WatchTask.Filter; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.model.health.ImmutableNode; +import com.orbitz.consul.option.CatalogOptions; +import com.orbitz.consul.option.QueryOptions; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ Http.class }) +@PowerMockIgnore({ "javax.net.ssl.*" }) +public class WatchServiceHealthTaskTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(WatchServiceHealthTaskTest.class); + + private Consul consul; + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Before + public void init() { + + List list = new ArrayList(); + + Service service = ImmutableService.builder().id("").port(0).address("") + .service("huangleibo").addTags("").createIndex(1).modifyIndex(1).build(); + ServiceHealth serviceHealth = ImmutableServiceHealth.builder() + .service(service) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + list.add(serviceHealth); + + long lastContact = 1; + boolean knownLeader = true; + BigInteger index = BigInteger.valueOf(1); + final ConsulResponse> response = new ConsulResponse>( + list, lastContact, knownLeader, index); + + // + Http http = PowerMockito.mock(Http.class); + + PowerMockito + .doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) + throws Throwable { + Object[] args = invocation.getArguments(); + ((ConsulResponseCallback) args[2]).onComplete(response); + return null; + } + }) + .when(http) + .asyncGet(Mockito.anyString(), + Mockito.any(TypeReference.class), + Mockito.any(ConsulResponseCallback.class)); + + // + PowerMockito.spy(Http.class); + PowerMockito.when(Http.getInstance()).thenReturn(http); + + } + + @Test + public void testgetServiceName() { + consul = Consul.newClient(); + + WatchServiceHealthTask task0 = new WatchServiceHealthTask( + consul.healthClient(), "huangleibo_task0", true, + CatalogOptions.BLANK, 10, QueryOptions.BLANK); + + LOGGER.info("service name:" + task0.getServiceName()); + + WatchServiceHealthTask task1 = new WatchServiceHealthTask( + consul.healthClient(), "huangleibo_task1", true, 10); + + LOGGER.debug("service name:" + task1.getServiceName()); + + WatchServiceHealthTask task2 = new WatchServiceHealthTask( + consul.healthClient(), "huangleibo_task2", 10); + + LOGGER.debug("service name:" + task2.getServiceName()); + + } + + public class StopHandler implements WatchTask.Handler> + { + + private WatchServiceHealthTask task; + + StopHandler(WatchServiceHealthTask task) + { + this.task = task; + } + + @Override + public void handle(ConsulResponse> object) { + // TODO Auto-generated method stub + List list = (List)object.getResponse(); + LOGGER.debug("handler:"+list.get(0).getService().getService()); + task.stopWatch(); + } + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Test + public void teststartWatch() { + Consul consul = Consul.newClient(); + String serviceName = "huangleibo"; + + WatchServiceHealthTask task0 = new WatchServiceHealthTask( + consul.healthClient(), serviceName, true, CatalogOptions.BLANK, + 10, QueryOptions.BLANK); + + task0.addFilter(new Filter() { + + @Override + public boolean filter(ConsulResponse object) { + // TODO Auto-generated method stub + List list = (List)object.getResponse(); + LOGGER.debug("filter:"+list.get(0).getService().getService()); + return true; + } + + }); + + task0.addHandler(new StopHandler(task0)); + + task0.startWatch(); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WriteBufferHandlerTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WriteBufferHandlerTest.java new file mode 100644 index 0000000..a86baf1 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/expose/WriteBufferHandlerTest.java @@ -0,0 +1,46 @@ +package org.onap.msb.apiroute.wrapper.consulextend.expose; + +import java.math.BigInteger; +import java.util.ArrayList; +import java.util.List; + +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.expose.WriteBufferHandler; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.queue.ServiceData; + +import com.orbitz.consul.model.ConsulResponse; +import com.orbitz.consul.model.health.ImmutableNode; + +public class WriteBufferHandlerTest { + @Test + public void testhandle() { + List list = new ArrayList(); + + // modifyIndex 1 + Service service0 = ImmutableService.builder().id("huangleibo1").port(0) + .address("").service("huangleibo").addTags("").createIndex(1) + .modifyIndex(1).build(); + ServiceHealth serviceHealth0 = ImmutableServiceHealth.builder() + .service(service0) + .node(ImmutableNode.builder().node("").address("").build()) + .build(); + + list.add(serviceHealth0); + + long lastContact = 1; + boolean knownLeader = true; + BigInteger index = BigInteger.valueOf(1); + ConsulResponse> object = new ConsulResponse>( + list, lastContact, knownLeader, index); + + WriteBufferHandler> handler = new WriteBufferHandler>( + ServiceData.DataType.service); + + handler.handle(object); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceHealthTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceHealthTest.java new file mode 100644 index 0000000..008a28d --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceHealthTest.java @@ -0,0 +1,54 @@ +package org.onap.msb.apiroute.wrapper.consulextend.model.health; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; + +import com.orbitz.consul.model.health.HealthCheck; +import com.orbitz.consul.model.health.ImmutableHealthCheck; +import com.orbitz.consul.model.health.ImmutableNode; +import com.orbitz.consul.model.health.Node; + +public class ServiceHealthTest { + + @Test + public void TestImmutableServiceHealth() { + Service service = ImmutableService.builder().id("").port(0).address("") + .service("huangleibo").addTags("").createIndex(1) + .modifyIndex(1).build(); + Node node = ImmutableNode.builder().node("").address("").build(); + + HealthCheck healthCheck0 = ImmutableHealthCheck.builder().checkId("") + .name("").node("").notes("").output("").serviceId("") + .serviceName("").status("").build(); + HealthCheck healthCheck1 = ImmutableHealthCheck.builder().checkId("") + .name("").node("").notes("").output("").serviceId("") + .serviceName("").status("").build(); + HealthCheck healthCheck2 = ImmutableHealthCheck.builder().checkId("") + .name("").node("").notes("").output("").serviceId("") + .serviceName("").status("").build(); + + ImmutableServiceHealth serviceHealth0 = ImmutableServiceHealth + .builder().service(service).node(node).addChecks(healthCheck0) + .addChecks(healthCheck1, healthCheck2).build(); + + Assert.assertNotNull(serviceHealth0.getNode()); + Assert.assertNotNull(serviceHealth0.getChecks()); + /* ############################################################### */ + + ImmutableServiceHealth serviceHealth1 = serviceHealth0.withNode(node) + .withNode(ImmutableNode.builder().node("").address("").build()) + .withService(service).withService(ImmutableService.builder().id("").port(0).address("") + .service("huangleibo1111").addTags("").createIndex(1) + .modifyIndex(1).build()).withChecks(healthCheck0); + + Assert.assertFalse(serviceHealth1.equals(serviceHealth0)); + System.out.println(serviceHealth1.hashCode()); + + /* ############################################################### */ + + ImmutableServiceHealth serviceHealth2 = ImmutableServiceHealth.builder().from(serviceHealth1).build(); + Assert.assertTrue(serviceHealth1.equals(serviceHealth2)); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceTest.java new file mode 100644 index 0000000..81629c5 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/model/health/ServiceTest.java @@ -0,0 +1,32 @@ +package org.onap.msb.apiroute.wrapper.consulextend.model.health; + +import org.junit.Assert; +import org.junit.Test; + +public class ServiceTest { + + @Test + public void testImmutableService() { + ImmutableService service0 = ImmutableService.builder() + .id("huangleibo_id").port(0).address("").service("huangleibo") + .addTags("111", "222").createIndex(1).modifyIndex(1).build(); + Assert.assertEquals("huangleibo_id", service0.getId()); + Assert.assertEquals(1, service0.getCreateIndex()); + Assert.assertEquals(1, service0.getModifyIndex()); + + ImmutableService service1 = service0.withId("huangleibo_id") + .withId("new_id").withService("huangleibo") + .withService("new_service").withTags("new_tags") + .withAddress("").withAddress("new_address").withPort(0) + .withPort(1).withCreateIndex(1).withCreateIndex(2) + .withModifyIndex(1).withModifyIndex(2); + + Assert.assertFalse(service0.equals(service1)); + + System.out.println(service1.hashCode()); + + ImmutableService service2 = ImmutableService.builder().from(service1) + .build(); + Assert.assertEquals("new_id", service2.getId()); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/util/HttpTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/util/HttpTest.java new file mode 100644 index 0000000..af2197e --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/consulextend/util/HttpTest.java @@ -0,0 +1,80 @@ +package org.onap.msb.apiroute.wrapper.consulextend.util; + +import java.io.InputStream; +import java.math.BigInteger; +import java.util.List; +import java.util.Map; + +import org.apache.http.HttpEntity; +import org.apache.http.ProtocolVersion; +import org.apache.http.StatusLine; +import org.apache.http.entity.BasicHttpEntity; +import org.apache.http.message.BasicHttpResponse; +import org.apache.http.message.BasicStatusLine; +import org.junit.Before; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.consulextend.util.Http; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.orbitz.consul.option.ConsistencyMode; +import com.orbitz.consul.option.ImmutableCatalogOptions; +import com.orbitz.consul.option.ImmutableQueryOptions; +import com.orbitz.consul.option.QueryOptions; + +public class HttpTest { + private static final Logger LOGGER = LoggerFactory + .getLogger(HttpTest.class); + + @Before + public void init() { + + } + + @Test + public void testoptionsFrom() { + ImmutableCatalogOptions catalogs = ImmutableCatalogOptions.builder() + .build(); + catalogs = catalogs.withDatacenter("datacenter").withTag("tag"); + + BigInteger index = new BigInteger("1"); + ImmutableQueryOptions querys = QueryOptions.blockSeconds(10, index) + .build(); + querys = querys.withConsistencyMode(ConsistencyMode.STALE) + .withDatacenter("datacenter").withNear("near") + .withToken("taoken"); + String url = Http.optionsFrom(catalogs, querys); + LOGGER.info(url); + } + + @Test + public void testconsulResponse() { + + TypeReference>> TYPE_SERVICES_MAP = new TypeReference>>() {}; + + ProtocolVersion version = new ProtocolVersion("HTTP",1,1); + StatusLine status= new BasicStatusLine(version,200,"ok"); + BasicHttpResponse response = new BasicHttpResponse(status); + + response.setHeader("X-Consul-Index", "1"); + response.setHeader("X-Consul-Lastcontact", "1"); + response.setHeader("X-Consul-Knownleader", "true"); + + BasicHttpEntity entity = new BasicHttpEntity(); + InputStream content = HttpTest.class.getResourceAsStream("serviceslist.json"); + entity.setContent(content); + response.setEntity(entity); + + Http.consulResponse(TYPE_SERVICES_MAP, response); + + TypeReference TYPE_SERVICES_MAP_STRING = new TypeReference() {}; + InputStream content1 = HttpTest.class.getResourceAsStream("serviceslist.json"); + entity.setContent(content1); + + Http.consulResponse(TYPE_SERVICES_MAP_STRING, response); + + TypeReference TYPE_SERVICES_MAP_ENTITY = new TypeReference() {}; + Http.consulResponse(TYPE_SERVICES_MAP_ENTITY, response); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/queue/QueueManagerTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/queue/QueueManagerTest.java new file mode 100644 index 0000000..a76575f --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/queue/QueueManagerTest.java @@ -0,0 +1,178 @@ +package org.onap.msb.apiroute.wrapper.queue; + +import java.io.InputStream; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.http.HttpEntity; +import org.apache.http.entity.BasicHttpEntity; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.SyncDataManager; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.util.HttpTest; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.queue.QueueManager; +import org.onap.msb.apiroute.wrapper.queue.ServiceConsumer; +import org.onap.msb.apiroute.wrapper.queue.ServiceData; +import org.onap.msb.apiroute.wrapper.queue.ServiceListConsumer; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; +import com.orbitz.consul.model.health.ImmutableNode; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RouteUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class QueueManagerTest { + private static QueueManager queueManager; + + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + queueManager=QueueManager.getInstance(); + putInServiceListQueue(); + putInServiceQueue4Update(); + + } + + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + + + public void test_ServiceConsumer(){ + + //start ServiceListConsumer +// new Thread(new ServiceListConsumer(this),"ServiceListConsumerThread").start(); + + //start Service Consumer + int serviceQueneNum=RouteUtil.SERVICE_DATA_QUEUE_NUM; + for(int i=0;i data=new ServiceData(); + data.setDataType(ServiceData.DataType.service_list); + + BasicHttpEntity entity = new BasicHttpEntity(); + InputStream content = HttpTest.class.getResourceAsStream("serviceslist.json"); + entity.setContent(content); + data.setData(entity); + + try { + queueManager.putIn(data); + } catch (Exception e) { + Assert.assertTrue(e instanceof InterruptedException); + } + } + + private static void putInServiceQueue4Update(){ + ServiceData> data=new ServiceData>(); + data.setDataType(ServiceData.DataType.service); + data.setOperate(ServiceData.Operate.delete); + + List tagList = new ArrayList(); + tagList.add("\"base\":{\"protocol\":\"REST\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + + Service service = + ImmutableService.builder().id("id").port(8686).address("10.74.165.246").service("msbtest") + .addAllTags(tagList).createIndex(0).modifyIndex(0).build(); + ServiceHealth serviceHealth = + ImmutableServiceHealth.builder().service(service) + .node(ImmutableNode.builder().node("server").address("192.168.1.98").build()).build(); + List serviceHealthList = new ArrayList(); + serviceHealthList.add(serviceHealth); + + data.setData(serviceHealthList); + + try { + queueManager.putIn(data); + } catch (Exception e) { + Assert.assertTrue(e instanceof InterruptedException); + } + } + + private static void putInServiceQueue4Delete(){ + ServiceData> data=new ServiceData>(); + data.setDataType(ServiceData.DataType.service); + data.setOperate(ServiceData.Operate.update); + + List tagList = new ArrayList(); + tagList.add("\"base\":{\"protocol\":\"REST\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + + Service service = + ImmutableService.builder().id("id").port(8686).address("10.74.165.246").service("msbtest") + .addAllTags(tagList).createIndex(0).modifyIndex(0).build(); + ServiceHealth serviceHealth = + ImmutableServiceHealth.builder().service(service) + .node(ImmutableNode.builder().node("server").address("192.168.1.98").build()).build(); + List serviceHealthList = new ArrayList(); + serviceHealthList.add(serviceHealth); + + data.setData(serviceHealthList); + + try { + queueManager.putIn(data); + } catch (Exception e) { + Assert.assertTrue(e instanceof InterruptedException); + } + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/ApiRouteServiceTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/ApiRouteServiceTest.java new file mode 100644 index 0000000..a5aa87a --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/ApiRouteServiceTest.java @@ -0,0 +1,251 @@ +package org.onap.msb.apiroute.wrapper.service; + +import com.fiftyonred.mock_jedis.MockJedisPool; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.ApiRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.service.ApiRouteService; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import static org.junit.Assert.*; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class ApiRouteServiceTest { + private static ApiRouteService apiRouteService = null; + private static Comparator apiRouteComparator = null; + @BeforeClass + public static void setUp() throws Exception{ + apiRouteService = ApiRouteService.getInstance(); + apiRouteComparator = new Comparator() { + @Override + public int compare(ApiRouteInfo o1, ApiRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + if (!o1.getVersion().equals(o2.getVersion())) + return (o1.getVersion()).compareTo(o2.getVersion()); + return 0; + } + }; + } + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + @Test + public void testGetApiRouteInstance_key_not_exist(){ + try { + assertNull(apiRouteService.getApiRouteInstance("msb:routing:api:notexistservice:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetApiRouteInstance_key_exist(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + apirouteInfo.setServers(servers); + try { + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + assertEquals(apirouteInfo, apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testSaveApiRouteService2Redis(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + apirouteInfo.setServers(servers); + try { + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + assertEquals(apirouteInfo, apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testSaveApiRouteService2Redis2(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("test26msb"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/microservices/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.151.26","443")}; + apirouteInfo.setServers(servers); + try { + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:test26msb:v1"); + assertEquals(apirouteInfo, apiRouteService.getApiRouteInstance("msb:routing:api:test26msb:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testDeleteApiRouteService2Redis(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + apirouteInfo.setServers(servers); + try { + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + assertNotNull(apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1")); + apiRouteService.deleteApiRouteService2Redis("msb:routing:api:testapi:v1"); + assertNull(apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testUpdateApiRouteStatus2Redis(){ + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + apirouteInfo.setServers(servers); + try { + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + assertEquals("1", apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1").getStatus()); + apiRouteService.updateApiRouteStatus2Redis("msb:routing:api:testapi:v1","0"); + assertEquals("0", apiRouteService.getApiRouteInstance("msb:routing:api:testapi:v1").getStatus()); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetMultiApiRouteInstances() throws Exception { + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(false); + apirouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + ApiRouteInfo apirouteInfo2 = new ApiRouteInfo(); + apirouteInfo2.setServiceName("testapi"); + apirouteInfo2.setVersion("v2"); + apirouteInfo2.setStatus("0"); + apirouteInfo2.setUrl("/api/testapi/v2"); + apirouteInfo2.setUseOwnUpstream("0"); + apirouteInfo2.setVisualRange("0");; + apirouteInfo.setEnable_ssl(true); + apirouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + apiRouteService.saveApiRouteService2Redis(apirouteInfo2,"msb:routing:api:testapi:v2"); + + List expected = new ArrayList<>(); + expected.add(apirouteInfo); + expected.add(apirouteInfo2); + Collections.sort(expected, apiRouteComparator); + + List result = apiRouteService.getMultiApiRouteInstances("msb:routing:api:*"); + + Collections.sort(result, apiRouteComparator); + assertEquals(expected, result); + } + + @Test + public void testDeleteMultiApiRouteInstances() throws Exception { + ApiRouteInfo apirouteInfo = new ApiRouteInfo(); + apirouteInfo.setServiceName("testapi"); + apirouteInfo.setVersion("v1"); + apirouteInfo.setStatus("1"); + apirouteInfo.setUrl("/api/testapi/v1"); + apirouteInfo.setUseOwnUpstream("0"); + apirouteInfo.setVisualRange("0"); + apirouteInfo.setEnable_ssl(false); + apirouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + ApiRouteInfo apirouteInfo2 = new ApiRouteInfo(); + apirouteInfo2.setServiceName("testapi"); + apirouteInfo2.setVersion("v2"); + apirouteInfo2.setStatus("0"); + apirouteInfo2.setUrl("/api/testapi/v2"); + apirouteInfo2.setUseOwnUpstream("0"); + apirouteInfo2.setVisualRange("0");; + apirouteInfo.setEnable_ssl(true); + apirouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + apiRouteService.saveApiRouteService2Redis(apirouteInfo,"msb:routing:api:testapi:v1"); + apiRouteService.saveApiRouteService2Redis(apirouteInfo2,"msb:routing:api:testapi:v2"); + + assertEquals(2,apiRouteService.getMultiApiRouteInstances("msb:routing:api:testapi:*").size()); + assertEquals(2,apiRouteService.deleteMultiApiRouteService2Redis("msb:routing:api:testapi:*")); + assertEquals(0,apiRouteService.getMultiApiRouteInstances("msb:routing:api:testapi:*").size()); + } + + @Test(expected = Exception.class) + public void testUpdateApiRouteStatus2Redis_keyNotExist() throws Exception { + apiRouteService.updateApiRouteStatus2Redis("msb:routing:api:notexistservice:v1","0"); + } + + @Test(expected = Exception.class) + public void testSaveApiRouteService2Redis_null() throws Exception { + apiRouteService.saveApiRouteService2Redis(null,"msb:routing:api:null:v1"); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/CustomRouteServiceTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/CustomRouteServiceTest.java new file mode 100644 index 0000000..d34958b --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/CustomRouteServiceTest.java @@ -0,0 +1,241 @@ +package org.onap.msb.apiroute.wrapper.service; + +import com.fiftyonred.mock_jedis.MockJedisPool; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.CustomRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.service.CustomRouteService; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import static org.junit.Assert.*; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class CustomRouteServiceTest { + private static CustomRouteService customRouteService = null; + private static Comparator customRouteComparator = null; + @BeforeClass + public static void setUp() throws Exception{ + customRouteService = CustomRouteService.getInstance(); + customRouteComparator = new Comparator() { + @Override + public int compare(CustomRouteInfo o1, CustomRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + return 0; + } + }; + } + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + @Test + public void testGetCustomRouteInstance_key_not_exist(){ + try { + assertNull(customRouteService.getCustomRouteInstance("msb:routing:custom:notexistservice:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetCustomRouteInstance_key_exist(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + try { + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + assertEquals(customrouteInfo, customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testSaveCustomRouteService2Redis(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom/v1"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + try { + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + assertEquals(customrouteInfo, customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testSaveCustomRouteService2Redis_urlIsSlash(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + try { + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + customrouteInfo.setUrl(""); + assertEquals(customrouteInfo, customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testDeleteCustomRouteService2Redis(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom/v1"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + try { + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + assertNotNull(customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom")); + customRouteService.deleteCustomRouteService2Redis("msb:routing:custom:testcustom"); + assertNull(customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testUpdateCustomRouteStatus2Redis(){ + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom/v1"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + customrouteInfo.setServers(servers); + try { + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + assertEquals("1", customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom").getStatus()); + customRouteService.updateCustomRouteStatus2Redis("msb:routing:custom:testcustom", "0"); + assertEquals("0", customRouteService.getCustomRouteInstance("msb:routing:custom:testcustom").getStatus()); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetMultiCustomRouteInstances() throws Exception { + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(false); + customrouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + CustomRouteInfo customrouteInfo2 = new CustomRouteInfo(); + customrouteInfo2.setServiceName("testcustom2"); + customrouteInfo2.setStatus("0"); + customrouteInfo2.setUrl("/custom/testcustom2"); + customrouteInfo2.setUseOwnUpstream("0"); + customrouteInfo2.setVisualRange("0");; + customrouteInfo.setEnable_ssl(true); + customrouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + customRouteService.saveCustomRouteService2Redis(customrouteInfo2, "msb:routing:custom:testcustom2"); + + List expected = new ArrayList<>(); + expected.add(customrouteInfo); + expected.add(customrouteInfo2); + Collections.sort(expected, customRouteComparator); + + List result = customRouteService.getMultiCustomRouteInstances("msb:routing:custom:*"); + + Collections.sort(result, customRouteComparator); + assertEquals(expected, result); + } + + @Test + public void testDeleteMultiCustomRouteInstances() throws Exception { + CustomRouteInfo customrouteInfo = new CustomRouteInfo(); + customrouteInfo.setServiceName("testcustom"); + customrouteInfo.setStatus("1"); + customrouteInfo.setUrl("/custom/testcustom"); + customrouteInfo.setUseOwnUpstream("0"); + customrouteInfo.setVisualRange("0"); + customrouteInfo.setEnable_ssl(false); + customrouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + CustomRouteInfo customrouteInfo2 = new CustomRouteInfo(); + customrouteInfo2.setServiceName("testcustom2"); + customrouteInfo2.setStatus("0"); + customrouteInfo2.setUrl("/custom/testcustom2"); + customrouteInfo2.setUseOwnUpstream("0"); + customrouteInfo2.setVisualRange("0");; + customrouteInfo.setEnable_ssl(true); + customrouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + customRouteService.saveCustomRouteService2Redis(customrouteInfo, "msb:routing:custom:testcustom"); + customRouteService.saveCustomRouteService2Redis(customrouteInfo2, "msb:routing:custom:testcustom2"); + + assertEquals(2,customRouteService.getMultiCustomRouteInstances("msb:routing:custom:*").size()); + assertEquals(2,customRouteService.deleteMultiCustomRouteService2Redis("msb:routing:custom:*")); + assertEquals(0, customRouteService.getMultiCustomRouteInstances("msb:routing:custom:*").size()); + } + + @Test(expected = Exception.class) + public void testUpdateCustomRouteStatus2Redis_keyNotExist() throws Exception { + customRouteService.updateCustomRouteStatus2Redis("msb:routing:custom:notexistservice", "0"); + } + + @Test(expected = Exception.class) + public void testSaveCustomRouteService2Redis_null() throws Exception { + customRouteService.saveCustomRouteService2Redis(null, "msb:routing:custom:null"); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/IuiRouteServiceTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/IuiRouteServiceTest.java new file mode 100644 index 0000000..0ddbb32 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/IuiRouteServiceTest.java @@ -0,0 +1,221 @@ +package org.onap.msb.apiroute.wrapper.service; + +import com.fiftyonred.mock_jedis.MockJedisPool; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.IuiRouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.service.IuiRouteService; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; + +import static org.junit.Assert.*; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class IuiRouteServiceTest { + private static IuiRouteService iuiRouteService = null; + private static Comparator iuiRouteComparator = null; + @BeforeClass + public static void setUp() throws Exception{ + iuiRouteService = IuiRouteService.getInstance(); + iuiRouteComparator = new Comparator() { + @Override + public int compare(IuiRouteInfo o1, IuiRouteInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + return 0; + } + }; + } + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + @Test + public void testGetIuiRouteInstance_key_not_exist(){ + try { + assertNull(iuiRouteService.getIuiRouteInstance("msb:routing:iui:notexistservice:v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetIuiRouteInstance_key_exist(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + iuirouteInfo.setServers(servers); + try { + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + assertEquals(iuirouteInfo, iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testSaveIuiRouteService2Redis(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui/v1"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + iuirouteInfo.setServers(servers); + try { + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + assertEquals(iuirouteInfo, iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testDeleteIuiRouteService2Redis(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui/v1"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(false); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + iuirouteInfo.setServers(servers); + try { + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + assertNotNull(iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui")); + iuiRouteService.deleteIuiRouteService2Redis("msb:routing:iui:testiui"); + assertNull(iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testUpdateIuiRouteStatus2Redis(){ + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui/v1"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(true); + RouteServer[] servers = new RouteServer[]{new RouteServer("10.74.148.88","8080")}; + iuirouteInfo.setServers(servers); + try { + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + assertEquals("1", iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui").getStatus()); + iuiRouteService.updateIuiRouteStatus2Redis("msb:routing:iui:testiui","0"); + assertEquals("0", iuiRouteService.getIuiRouteInstance("msb:routing:iui:testiui").getStatus()); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetMultiIuiRouteInstances() throws Exception { + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(false); + iuirouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + IuiRouteInfo iuirouteInfo2 = new IuiRouteInfo(); + iuirouteInfo2.setServiceName("testiui2"); + iuirouteInfo2.setStatus("0"); + iuirouteInfo2.setUrl("/iui/testiui2"); + iuirouteInfo2.setUseOwnUpstream("0"); + iuirouteInfo2.setVisualRange("0");; + iuirouteInfo.setEnable_ssl(true); + iuirouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo2,"msb:routing:iui:testiui2"); + + List expected = new ArrayList<>(); + expected.add(iuirouteInfo); + expected.add(iuirouteInfo2); + Collections.sort(expected, iuiRouteComparator); + + List result = iuiRouteService.getMultiIuiRouteInstances("msb:routing:iui:*"); + + Collections.sort(result, iuiRouteComparator); + assertEquals(expected, result); + } + + @Test + public void testDeleteMultiIuiRouteInstances() throws Exception { + IuiRouteInfo iuirouteInfo = new IuiRouteInfo(); + iuirouteInfo.setServiceName("testiui"); + iuirouteInfo.setStatus("1"); + iuirouteInfo.setUrl("/iui/testiui"); + iuirouteInfo.setUseOwnUpstream("0"); + iuirouteInfo.setVisualRange("0"); + iuirouteInfo.setEnable_ssl(false); + iuirouteInfo.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + IuiRouteInfo iuirouteInfo2 = new IuiRouteInfo(); + iuirouteInfo2.setServiceName("testiui2"); + iuirouteInfo2.setStatus("0"); + iuirouteInfo2.setUrl("/iui/testiui2"); + iuirouteInfo2.setUseOwnUpstream("0"); + iuirouteInfo2.setVisualRange("0");; + iuirouteInfo.setEnable_ssl(true); + iuirouteInfo2.setServers(new RouteServer[]{new RouteServer("10.74.148.88","8088")}); + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo,"msb:routing:iui:testiui"); + iuiRouteService.saveIuiRouteService2Redis(iuirouteInfo2,"msb:routing:iui:testiui2"); + + assertEquals(2,iuiRouteService.getMultiIuiRouteInstances("msb:routing:iui:*").size()); + assertEquals(2,iuiRouteService.deleteMultiIuiRouteService2Redis("msb:routing:iui:*")); + assertEquals(0,iuiRouteService.getMultiIuiRouteInstances("msb:routing:iui:*").size()); + } + + @Test(expected = Exception.class) + public void testUpdateIuiRouteStatus2Redis_keyNotExist() throws Exception { + iuiRouteService.updateIuiRouteStatus2Redis("msb:routing:iui:notexistservice","0"); + } + + @Test(expected = Exception.class) + public void testSaveIuiRouteService2Redis_null() throws Exception { + iuiRouteService.saveIuiRouteService2Redis(null,"msb:routing:iui:null"); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/MicroServiceFullServiceTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/MicroServiceFullServiceTest.java new file mode 100644 index 0000000..7ca2ff7 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/service/MicroServiceFullServiceTest.java @@ -0,0 +1,413 @@ +package org.onap.msb.apiroute.wrapper.service; + +import com.fiftyonred.mock_jedis.MockJedisPool; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.MicroServiceFullInfo; +import org.onap.msb.apiroute.api.Node; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.service.MicroServiceFullService; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.MicroServiceUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.*; + +import static org.junit.Assert.*; +import static org.powermock.api.mockito.PowerMockito.when; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,RedisAccessWrapper.class}) +@PowerMockIgnore( {"javax.management.*"}) +public class MicroServiceFullServiceTest { + private static MicroServiceFullService microServiceFullService = null; + private static Comparator serviceComparator = null; + @BeforeClass + public static void setUp() throws Exception{ + microServiceFullService = MicroServiceFullService.getInstance(); + serviceComparator = new Comparator() { + @Override + public int compare(MicroServiceFullInfo o1, MicroServiceFullInfo o2) { + if (!o1.getServiceName().equals(o2.getServiceName())) + return (o1.getServiceName()).compareTo(o2.getServiceName()); + if (!o1.getVersion().equals(o2.getVersion())) + return (o1.getVersion()).compareTo(o2.getVersion()); + return 0; + } + }; + } + @Before + public void setUpBeforeTest() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + @Test + public void testExistsMicroServiceInstance_notExist(){ + try { + assertFalse(microServiceFullService.existsMicroServiceInstance("notExist", "v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + @Test + public void testExistsMicroServiceInstance_Exist(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + try { + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1")); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + + @Test + public void testSaveMicroServiceInfo2Redis(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + MicroServiceFullInfo actual = microServiceFullService.getMicroServiceInstance("testService", "v1"); + assertEquals(microServiceFullInfo, actual); + } catch (Exception e) { + e.printStackTrace(); + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testDeleteMicroService(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + assertTrue(microServiceFullService.existsMicroServiceInstance("testService", "v1")); + microServiceFullService.deleteMicroService("testService","v1"); + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + + @Test + public void testUpdateMicroServiceStatus(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + assertEquals("1", microServiceFullService.getMicroServiceInstance("testService","v1").getStatus()); + microServiceFullService.updateMicroServiceStatus("testService", "v1", "0"); + assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "v1").getStatus()); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void testGetAllMicroServiceKey(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + + MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo(); + microServiceFullInfo2.setServiceName("testService2"); + microServiceFullInfo2.setVersion(""); + microServiceFullInfo2.setStatus("1"); + microServiceFullInfo2.setUrl("/testService2"); + microServiceFullInfo2.setVisualRange("0"); + microServiceFullInfo2.setProtocol("http"); + microServiceFullInfo2.setEnable_ssl(false); + Set nodeSet2 = new HashSet<>(); + nodeSet2.add(new Node("10.74.148.88","8081")); + microServiceFullInfo2.setNodes(nodeSet2); + + MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo(); + microServiceFullInfo3.setServiceName("testService"); + microServiceFullInfo3.setVersion("v2"); + microServiceFullInfo3.setStatus("1"); + microServiceFullInfo3.setUrl("/testService/v2"); + microServiceFullInfo3.setVisualRange("0"); + microServiceFullInfo3.setProtocol("http"); + microServiceFullInfo3.setEnable_ssl(false); + Set nodeSet3 = new HashSet<>(); + nodeSet3.add(new Node("10.74.148.89","8080")); + microServiceFullInfo3.setNodes(nodeSet3); + + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3); + + Set result = microServiceFullService.getAllMicroServiceKey(); + final Set expected =new HashSet(); + expected.add("testService"); + expected.add("testService2"); + + assertEquals(expected, result); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + + } + + @Test + public void testGetAllVersionsOfTheService(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + + MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo(); + microServiceFullInfo2.setServiceName("testService2"); + microServiceFullInfo2.setVersion(""); + microServiceFullInfo2.setStatus("1"); + microServiceFullInfo2.setUrl("/testService2"); + microServiceFullInfo2.setVisualRange("0"); + microServiceFullInfo2.setProtocol("http"); + microServiceFullInfo2.setEnable_ssl(false); + Set nodeSet2 = new HashSet<>(); + nodeSet2.add(new Node("10.74.148.88","8081")); + microServiceFullInfo2.setNodes(nodeSet2); + + MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo(); + microServiceFullInfo3.setServiceName("testService"); + microServiceFullInfo3.setVersion("v2"); + microServiceFullInfo3.setStatus("1"); + microServiceFullInfo3.setUrl("/testService/v2"); + microServiceFullInfo3.setVisualRange("0"); + microServiceFullInfo3.setProtocol("http"); + microServiceFullInfo3.setEnable_ssl(false); + Set nodeSet3 = new HashSet<>(); + nodeSet3.add(new Node("10.74.148.89","8080")); + microServiceFullInfo3.setNodes(nodeSet3); + + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2); + + + List result = microServiceFullService.getAllVersionsOfTheService("testService"); + + List expected = new ArrayList<>(); + expected.add(microServiceFullInfo); + expected.add(microServiceFullInfo3); + + Collections.sort(expected,serviceComparator); + Collections.sort(result,serviceComparator); + assertEquals(expected, result); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + + } + + @Test + public void testGetAllMicroServicesInstances(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + + MicroServiceFullInfo microServiceFullInfo2 = new MicroServiceFullInfo(); + microServiceFullInfo2.setServiceName("testService2"); + microServiceFullInfo2.setVersion(""); + microServiceFullInfo2.setStatus("1"); + microServiceFullInfo2.setUrl("/testService/v1"); + microServiceFullInfo2.setVisualRange("0"); + microServiceFullInfo2.setProtocol("http"); + microServiceFullInfo2.setEnable_ssl(true); + Set nodeSet2 = new HashSet<>(); + nodeSet2.add(new Node("10.74.148.89","8080")); + microServiceFullInfo2.setNodes(nodeSet2); + + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo2); + + List expected = new ArrayList(); + expected.add(microServiceFullInfo); + expected.add(microServiceFullInfo2); + List result = microServiceFullService.getAllMicroServiceInstances(); + Collections.sort(expected, serviceComparator); + Collections.sort(result,serviceComparator ); + assertEquals(expected, result); + } catch (Exception e) { + e.printStackTrace(); + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + + @Test + public void testDeleteMultiMicroService(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion("v1"); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + + + MicroServiceFullInfo microServiceFullInfo3 = new MicroServiceFullInfo(); + microServiceFullInfo3.setServiceName("testService"); + microServiceFullInfo3.setVersion("v2"); + microServiceFullInfo3.setStatus("1"); + microServiceFullInfo3.setUrl("/testService/v2"); + microServiceFullInfo3.setVisualRange("0"); + microServiceFullInfo3.setProtocol("http"); + microServiceFullInfo3.setEnable_ssl(false); + Set nodeSet3 = new HashSet<>(); + nodeSet3.add(new Node("10.74.148.89","8080")); + microServiceFullInfo3.setNodes(nodeSet3); + + try { + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo3); + //two versions of testservice exist + assertEquals(2,microServiceFullService.getAllVersionsOfTheService("testService").size()); + //delete all versions of testservice + long size = microServiceFullService.deleteMultiMicroService(MicroServiceUtil.getPrefixedKey("testService","*")); + //after delete,no version exist + assertEquals(0,microServiceFullService.getAllVersionsOfTheService("testService").size()); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test + public void tesGetMicroServiceInstance_notExist(){ + try { + assertNull(microServiceFullService.getMicroServiceInstance("notExist","v1")); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + + } + @Test + public void tesExistsGetUpdateDeleteMicroServiceStatus_versionNull(){ + MicroServiceFullInfo microServiceFullInfo = new MicroServiceFullInfo(); + microServiceFullInfo.setServiceName("testService"); + microServiceFullInfo.setVersion(""); + microServiceFullInfo.setStatus("1"); + microServiceFullInfo.setUrl("/testService/v1"); + microServiceFullInfo.setVisualRange("0"); + microServiceFullInfo.setProtocol("http"); + microServiceFullInfo.setEnable_ssl(false); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88","8080")); + microServiceFullInfo.setNodes(nodeSet); + try { + //test null + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null")); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + assertEquals("1", microServiceFullService.getMicroServiceInstance("testService","null").getStatus()); + microServiceFullService.updateMicroServiceStatus("testService", "null", "0"); + assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", "null").getStatus()); + microServiceFullService.deleteMicroService("testService","null"); + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", "null")); + + + //test String "null" + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null)); + microServiceFullService.saveMicroServiceInfo2Redis(microServiceFullInfo); + assertEquals("1", microServiceFullService.getMicroServiceInstance("testService",null).getStatus()); + microServiceFullService.updateMicroServiceStatus("testService", null, "0"); + assertEquals("0", microServiceFullService.getMicroServiceInstance("testService", null).getStatus()); + microServiceFullService.deleteMicroService("testService",null); + assertFalse(microServiceFullService.existsMicroServiceInstance("testService", null)); + } catch (Exception e) { + assert false:"throw exception means error occured!"+e.getMessage(); + } + } + + @Test(expected = Exception.class) + public void tesSaveMicroService_null() throws Exception { + microServiceFullService.saveMicroServiceInfo2Redis(null); + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/serviceListener/MicroServiceChangeListenerTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/serviceListener/MicroServiceChangeListenerTest.java new file mode 100644 index 0000000..f537e0e --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/serviceListener/MicroServiceChangeListenerTest.java @@ -0,0 +1,666 @@ +package org.onap.msb.apiroute.wrapper.serviceListener; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.ApiRouteAppConfig; +import org.onap.msb.apiroute.api.ApiRouteInfo; +import org.onap.msb.apiroute.api.CustomRouteInfo; +import org.onap.msb.apiroute.api.DiscoverInfo; +import org.onap.msb.apiroute.api.IuiRouteInfo; +import org.onap.msb.apiroute.api.MicroServiceFullInfo; +import org.onap.msb.apiroute.api.Node; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.api.exception.ExtendedNotFoundException; +import org.onap.msb.apiroute.wrapper.ApiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.CustomRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.InitRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.IuiRouteServiceWrapper; +import org.onap.msb.apiroute.wrapper.dao.RedisAccessWrapper; +import org.onap.msb.apiroute.wrapper.serviceListener.RouteNotify; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.HttpClientUtil; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; +import org.onap.msb.apiroute.wrapper.util.RouteUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PowerMockIgnore; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.JedisPool; +import redis.clients.jedis.JedisPoolConfig; + +import com.fiftyonred.mock_jedis.MockJedisPool; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({JedisUtil.class,ConfigUtil.class,HttpClientUtil.class, RedisAccessWrapper.class,}) +@PowerMockIgnore({"javax.management.*"}) +public class MicroServiceChangeListenerTest { + private static RouteNotify routeInstance; + private static ApiRouteServiceWrapper apiRouteServiceWrapper; + private static IuiRouteServiceWrapper iuiRouteServiceWrapper; + private static CustomRouteServiceWrapper customRouteServiceWrapper; + + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + InitRouteServiceWrapper.getInstance().registerServiceChangeListener(); + routeInstance=RouteNotify.getInstance(); + apiRouteServiceWrapper=ApiRouteServiceWrapper.getInstance(); + iuiRouteServiceWrapper=IuiRouteServiceWrapper.getInstance(); + customRouteServiceWrapper=CustomRouteServiceWrapper.getInstance(); + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn("ip|domain"); + ConfigUtil.getInstance().initRouteWay(); + } + + @Before + public void initReidsMock() throws Exception { + final JedisPool mockJedisPool = new MockJedisPool(new JedisPoolConfig(), "localhost"); + PowerMockito.mockStatic(JedisUtil.class); + JedisUtil jedisUtil=PowerMockito.mock(JedisUtil.class); + PowerMockito.when(jedisUtil.borrowJedisInstance()).thenReturn(mockJedisPool.getResource()); + + PowerMockito.replace(PowerMockito.method(RedisAccessWrapper.class, "filterKeys")).with(new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { + return mockJedisPool.getResource().keys((String) args[0]); + } + }); + } + + @Test + public void test_noticeRouteListener4Update_api(){ + try { + routeInstance.noticeRouteListener4Update("apiTest-ns", "v1", buildMicroServiceFullInfo4API()); + ApiRouteInfo apiRouteInfo=apiRouteServiceWrapper.getApiRouteInstance("apiTest-ns", "v1", "host", "20081", "ip"); + + Assert.assertNotNull(apiRouteInfo); + Assert.assertEquals("1", apiRouteInfo.getStatus()); + + routeInstance.noticeUpdateStatusListener(buildMicroServiceFullInfo4API(),"0"); + apiRouteInfo=apiRouteServiceWrapper.getApiRouteInstance("apiTest-ns", "v1", "host", "20081", "ip"); + Assert.assertEquals("0", apiRouteInfo.getStatus()); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + } + + @Test + public void test_noticeRouteListener4Update_iui(){ + try { + routeInstance.noticeRouteListener4Update("iuiTest-ns", "v1", buildMicroServiceFullInfo4IUI()); + IuiRouteInfo iuiRouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest-ns", "host", "20081", "ip"); + + Assert.assertNotNull(iuiRouteInfo); + Assert.assertEquals("1", iuiRouteInfo.getStatus()); + + routeInstance.noticeUpdateStatusListener(buildMicroServiceFullInfo4IUI(),"0"); + iuiRouteInfo=iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest-ns", "host", "20081", "ip"); + Assert.assertEquals("0", iuiRouteInfo.getStatus()); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + } + + @Test + public void test_noticeRouteListener4Update_http(){ + try { + routeInstance.noticeRouteListener4Update("httpTest-ns", "v1", buildMicroServiceFullInfo4HTTP()); + CustomRouteInfo customRouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/httpTest-ns", "host", "20081", "ip"); + Assert.assertNotNull(customRouteInfo); + Assert.assertEquals("1", customRouteInfo.getStatus()); + + routeInstance.noticeUpdateStatusListener(buildMicroServiceFullInfo4HTTP(),"0"); + customRouteInfo=customRouteServiceWrapper.getCustomRouteInstance("/httpTest-ns", "host", "20081", "ip"); + Assert.assertEquals("0", customRouteInfo.getStatus()); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + } + + @Test + public void test_noticeRouteListener4Add_del_api(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4API(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "20081", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/", "apitest-ns", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "20081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "apitest-ns", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + + } + + @Test + public void test_noticeRouteListener4Add_del_api_path(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4API_path(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "", "10081", "ip")); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "", "10082", "ip")); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "host", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest4Path", "v1", "host", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_noticeRouteListener4Add_del_api_mutiPort(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4API_path(); + microServiceInfo.setPath(""); + microServiceInfo.setHost(""); + + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "10081", "ip")); + Assert.assertNotNull(apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "10082", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/", "apitest", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + apiRouteServiceWrapper.getApiRouteInstance("apiTest", "v1", "apitest", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_noticeRouteListener4Add_del_iui(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4IUI(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "20081", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/", "iuitest-ns", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "20081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "iuitest-ns", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_noticeRouteListener4Add_del_iui_path(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4IUI_path(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "", "10081", "ip")); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "", "10082", "ip")); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "host", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest4Path", "host", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + + @Test + public void test_noticeRouteListener4Add_del_iui_mutiPort(){ + try { + MicroServiceFullInfo microServiceInfo =buildMicroServiceFullInfo4IUI_path(); + microServiceInfo.setPath(""); + microServiceInfo.setHost(""); + + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "10081", "ip")); + Assert.assertNotNull(iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "10082", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/", "iuitest", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + iuiRouteServiceWrapper.getIuiRouteInstance("iuiTest", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/", "iuitest", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_noticeRouteListener4Add_del_http(){ + try { + MicroServiceFullInfo microServiceInfo=buildMicroServiceFullInfo4HTTP(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "20081", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "httptest-ns", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "20081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest", "httptest-ns", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + @Test + public void test_noticeRouteListener4Add_del_http_path(){ + try { + MicroServiceFullInfo microServiceInfo=buildMicroServiceFullInfo4HTTP_path(); + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "", "10081", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "", "10082", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "host", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest4Path", "host", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + + @Test + public void test_noticeRouteListener4Add_del_http_mutiPort(){ + try { + MicroServiceFullInfo microServiceInfo=buildMicroServiceFullInfo4HTTP_path(); + microServiceInfo.setPath(""); + microServiceInfo.setHost(""); + + routeInstance.noticeRouteListener4Add(microServiceInfo); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "10081", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "10082", "ip")); + Assert.assertNotNull(customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "httptest", "", "domain")); + + routeInstance.noticeRouteListener4Delete(microServiceInfo); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "10081", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest/v1", "", "10082", "ip"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + try { + customRouteServiceWrapper.getCustomRouteInstance("/httpTest", "httptest", "", "domain"); + Assert.fail("should not process to here."); + } + catch(Exception e){ + Assert.assertTrue(e instanceof ExtendedNotFoundException); + } + + } + + + @Test + public void test_noticeRouteListener4Add_portal(){ + try { + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("SDCLIENT_IP")).thenReturn("127.0.0.1"); + ApiRouteAppConfig configuration=new ApiRouteAppConfig(); + + DiscoverInfo discoverInfo=new DiscoverInfo(); + discoverInfo.setEnabled(true); + discoverInfo.setIp("127.0.0.2"); + discoverInfo.setPort(10081); + configuration.setDiscoverInfo(discoverInfo); + ConfigUtil.getInstance().initDiscoverInfo(configuration); + + + PowerMockito.mockStatic(HttpClientUtil.class); + String publishUrl="http://127.0.0.1:10081/api/microservices/v1/services/portalTest/version/v1/allpublishaddress?namespace=&visualRange=0"; + String resultJson ="[{\"domain\":\"opapi.openpalette.zte.com.cn\",\"port\":\"443\",\"publish_url\":\"/api\",\"visualRange\":\"0\",\"publish_protocol\":\"https\"},{\"ip\":\"10.74.165.246\",\"port\":\"443\",\"publish_url\":\"/opapi\",\"visualRange\":\"0\",\"publish_protocol\":\"https\"},{\"ip\":\"10.74.165.246\",\"port\":\"80\",\"publish_url\":\"/opapi\",\"visualRange\":\"0\",\"publish_protocol\":\"http\"}]"; + PowerMockito.when(HttpClientUtil.httpGet(publishUrl)).thenReturn(resultJson); + + MicroServiceFullInfo microServiceInfo=buildMicroServiceFullInfo4PORTAL(); + + routeInstance.noticeRouteListener4Add(microServiceInfo); + + CustomRouteInfo routeInfo_ip=customRouteServiceWrapper.getCustomRouteInstance("/portalTest/v1", "", "10088", "ip"); + RouteServer[] servers_ip = new RouteServer[]{new RouteServer("10.74.148.99","8080")}; + Assert.assertArrayEquals(servers_ip, routeInfo_ip.getServers()); + + CustomRouteInfo routeInfo_domain=customRouteServiceWrapper.getCustomRouteInstance("/portalTest/v1", "host", "", "domain"); + RouteServer[] servers_domain = new RouteServer[]{new RouteServer("10.74.165.246","443")}; + + Assert.assertArrayEquals(servers_domain, routeInfo_domain.getServers()); + + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + } + + } + + + private MicroServiceFullInfo buildMicroServiceFullInfo4API(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("apiTest-ns"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(false); + microServiceInfo.setPublish_port("20081"); + microServiceInfo.setProtocol("REST"); + microServiceInfo.setUrl("/api/apiTest/v1"); + microServiceInfo.setVisualRange("1"); + microServiceInfo.setStatus("1"); + microServiceInfo.setNamespace("ns"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4API_path(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("apiTest"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(true); + microServiceInfo.setHost("host"); + microServiceInfo.setPath("/api/apiTest4Path/v1"); + microServiceInfo.setPublish_port("10081|10082"); + microServiceInfo.setProtocol("REST"); + microServiceInfo.setUrl("/api/apiTest/v1"); + microServiceInfo.setVisualRange("0"); + microServiceInfo.setLb_policy("ip_hash"); + microServiceInfo.setStatus("1"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + + private MicroServiceFullInfo buildMicroServiceFullInfo4PORTAL(){ + + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("portalTest"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(true); + microServiceInfo.setHost("host"); + microServiceInfo.setPublish_port("10088"); + microServiceInfo.setProtocol("HTTP"); + microServiceInfo.setUrl("/portalTestUrl/v1"); + microServiceInfo.setVisualRange("0"); + microServiceInfo.setLb_policy("ip_hash"); + microServiceInfo.setStatus("1"); + microServiceInfo.setCustom(RouteUtil.CUSTOM_PORTAL); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.99","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4IUI(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("iuiTest-ns"); + microServiceInfo.setNamespace("ns"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(false); + microServiceInfo.setPublish_port("20081"); + microServiceInfo.setProtocol("UI"); + microServiceInfo.setUrl("/iui/iuiTest"); + microServiceInfo.setVisualRange("1"); + microServiceInfo.setStatus("1"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4IUI_path(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("iuiTest"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(true); + microServiceInfo.setHost("host"); + microServiceInfo.setProtocol("UI"); + microServiceInfo.setUrl("/iui/iuiTest"); + microServiceInfo.setLb_policy("ip_hash"); + microServiceInfo.setPublish_port("10081|10082"); + microServiceInfo.setPath("/iui/iuiTest4Path"); + microServiceInfo.setVisualRange("0"); + microServiceInfo.setStatus("1"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4HTTP(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("httpTest-ns"); + microServiceInfo.setNamespace("ns"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(false); + microServiceInfo.setPublish_port("20081"); + microServiceInfo.setProtocol("HTTP"); + microServiceInfo.setUrl("/httpTest"); + microServiceInfo.setVisualRange("1"); + microServiceInfo.setStatus("1"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + private MicroServiceFullInfo buildMicroServiceFullInfo4HTTP_path(){ + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("httpTest"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setEnable_ssl(true); + microServiceInfo.setHost("host"); + microServiceInfo.setPublish_port("20081"); + microServiceInfo.setProtocol("HTTP"); + microServiceInfo.setUrl("/httpTest"); + microServiceInfo.setVisualRange("0"); + microServiceInfo.setStatus("1"); + microServiceInfo.setLb_policy("ip_hash"); + microServiceInfo.setPublish_port("10081|10082"); + microServiceInfo.setPath("/httpTest4Path"); + Set nodes = new HashSet(); + nodes.add(new Node("10.74.148.88","8080")); + nodes.add(new Node("10.74.148.89","8080")); + microServiceInfo.setNodes(nodes); + + return microServiceInfo; + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/CommonUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/CommonUtilTest.java new file mode 100644 index 0000000..825868c --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/CommonUtilTest.java @@ -0,0 +1,61 @@ +package org.onap.msb.apiroute.wrapper.util; + +import java.util.HashSet; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.util.CommonUtil; + +public class CommonUtilTest { + + + + @Test + public void test_concat() { + Object[] str1 = new String[] {"test1", "test2"}; + Object[] str2 = new String[] {"test3"}; + Object[] str3 = CommonUtil.concat(str1, str2); + + Assert.assertEquals(3, str3.length); + } + + @Test + public void test_containStr() { + String value = "1"; + String array[] = {"1", "2"}; + Assert.assertTrue(CommonUtil.contain(array, value)); + Assert.assertFalse(CommonUtil.contain(array, "3")); + } + + @Test + public void test_containArray() { + String value[] = {"0"}; + String array[] = {"1", "2"}; + String array2[] = {"2", "1"}; + Assert.assertFalse(CommonUtil.contain(array, value)); + Assert.assertTrue(CommonUtil.contain(array, array2)); + } + + @Test + public void test_containStrArray() { + Assert.assertFalse(CommonUtil.contain("0,1,2", "3")); + Assert.assertTrue(CommonUtil.contain("0,1,2", "1")); + } + + @Test + public void test_getDiffrent() { + Set list1 = new HashSet(); + list1.add("test1"); + list1.add("test2"); + + Set list2 = new HashSet(); + list2.add("test2"); + list2.add("test3"); + + Set diff = CommonUtil.getDiffrent(list1, list2); + Assert.assertEquals(1, diff.size()); + Assert.assertTrue(diff.contains("test3")); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ConfigUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ConfigUtilTest.java new file mode 100644 index 0000000..e17c177 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ConfigUtilTest.java @@ -0,0 +1,214 @@ +package org.onap.msb.apiroute.wrapper.util; + + + +import java.lang.reflect.Field; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.ApiRouteAppConfig; +import org.onap.msb.apiroute.api.DiscoverInfo; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ConfigUtil.class}) +public class ConfigUtilTest { + + @Test + public void test_initRootPath() { + try { + ConfigUtil.getInstance().initRootPath(); + String iuiRootPath = ConfigUtil.getInstance().getIUI_ROOT_PATH(); + String apiRootPath = ConfigUtil.getInstance().getAPI_ROOT_PATH(); + Assert.assertEquals("iui", iuiRootPath); + Assert.assertEquals("api", apiRootPath); + } catch (Exception e) { + Assert.fail("throw exception means error occured!" + e.getMessage()); + + } + + } + + @Test + public void test_initApiGatewayPort() { + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("APIGATEWAY_EXPOSE_PORT")).thenReturn(null); + ConfigUtil.getInstance().initApiGatewayPort(); + Assert.assertEquals("80", ConfigUtil.getInstance().getServerPort()); + + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("APIGATEWAY_EXPOSE_PORT")).thenReturn("81"); + + ConfigUtil.getInstance().initApiGatewayPort(); + Assert.assertEquals("81", ConfigUtil.getInstance().getServerPort()); + } + + @Test + public void test_initRouteNameSpaceMatches() { + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("APIGATEWAY_EXPOSE_PORT")).thenReturn(null); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertEquals("all", ConfigUtil.getInstance().getNamespaceMatches()); + + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("net"); + + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertEquals("net", ConfigUtil.getInstance().getNamespaceMatches()); + } + + @Test + public void test_initRouteLabelsMatches() { + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn(null); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertEquals("0", ConfigUtil.getInstance().getVisualRangeMatches()); + Assert.assertEquals("net", ConfigUtil.getInstance().getNetwork_plane_typeMatches()); + Assert.assertTrue(ConfigUtil.getInstance().getLabelMapMatches().containsKey("custom-key")); + + + + + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("visualRange:1,network_plane_type:net,custom:test"); + + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertEquals("1", ConfigUtil.getInstance().getVisualRangeMatches()); + Assert.assertEquals("net", ConfigUtil.getInstance().getNetwork_plane_typeMatches()); + Assert.assertTrue(ConfigUtil.getInstance().getLabelMapMatches().containsKey("custom")); + + } + + @Test + public void test_initRouteWay() { + PowerMockito.mockStatic(System.class); + + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn(null); + ConfigUtil.getInstance().initRouteWay(); + String[] ip_routeWay={"ip"}; + Assert.assertArrayEquals(ip_routeWay, ConfigUtil.getInstance().getRouteWay()); + + PowerMockito.when(System.getenv("ROUTE_WAY")).thenReturn("ip|domain"); + + ConfigUtil.getInstance().initRouteWay(); + String[] routeWay={"ip","domain"}; + Assert.assertArrayEquals(routeWay, ConfigUtil.getInstance().getRouteWay()); + } + + @Test + public void test_initDiscoverInfo() { + PowerMockito.mockStatic(System.class); + + + ApiRouteAppConfig configuration=new ApiRouteAppConfig(); + + DiscoverInfo discoverInfo=new DiscoverInfo(); + discoverInfo.setEnabled(true); + discoverInfo.setIp("127.0.0.1"); + discoverInfo.setPort(10081); + + configuration.setDiscoverInfo(discoverInfo); + PowerMockito.when(System.getenv("SDCLIENT_IP")).thenReturn(null); + ConfigUtil.getInstance().initDiscoverInfo(configuration); + Assert.assertEquals("127.0.0.1:10081", ConfigUtil.getInstance().getDiscoverInfo().toString()); + + PowerMockito.when(System.getenv("SDCLIENT_IP")).thenReturn("10.74.44.86"); + ConfigUtil.getInstance().initDiscoverInfo(configuration); + Assert.assertEquals("10.74.44.86:10081", ConfigUtil.getInstance().getDiscoverInfo().toString()); + } + + @Test + public void test_initNodeMeta() { + + //CONSUL_REGISTER_MODE not catalog + ConfigUtil util=ConfigUtil.getInstance(); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),""); + + //CONSUL_REGISTER_MODE catalog + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("CONSUL_REGISTER_MODE")).thenReturn("agnet"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),""); + + + //CONSUL_REGISTER_MODE catalog + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("CONSUL_REGISTER_MODE")).thenReturn("catalog"); + try { + Field visualRangeField=util.getClass().getDeclaredField("visualRangeMatches"); + visualRangeField.setAccessible(true); + + Field namespaceField = util.getClass().getDeclaredField("namespaceMatches"); + namespaceField.setAccessible(true); + + //0:default; + visualRangeField.set(util, "0"); + namespaceField.set(util, "default"); + + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=external:true&node-meta=ns:default"); + + //1:default; + visualRangeField.set(util, "1"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=internal:true&node-meta=ns:default"); + + //0|1:default + visualRangeField.set(util, "0|1"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=ns:default"); + + //0|1:all + namespaceField.set(util, "all"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),""); + + /////////////////////////////////////////////////////////////////////////// + //1:all + visualRangeField.set(util, "1"); + namespaceField.set(util, "all"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=internal:true"); + + //1:! + namespaceField.set(util, "!default"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=internal:true"); + + //1:& + namespaceField.set(util, "tenant1&tenant2"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=internal:true"); + + //1:| + namespaceField.set(util, "tenant1|tenant2"); + util.initNodeMetaQueryParam(); + System.out.println(util.getNodeMetaQueryParam()); + Assert.assertEquals(util.getNodeMetaQueryParam(),"node-meta=internal:true"); + + } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtilTest.java new file mode 100644 index 0000000..568e4f9 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/HttpClientUtilTest.java @@ -0,0 +1,29 @@ +package org.onap.msb.apiroute.wrapper.util; + +import java.io.IOException; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.util.HttpClientUtil; + +public class HttpClientUtilTest { + + private String testIp="http://10.74.151.26:8500"; + + @Test + public void test_httpGet() { + /*try { + int result = HttpClientUtil.httpGetStatus(testIp); + if(result==200){ + Assert.assertEquals("Consul Agent", HttpClientUtil.httpGet(testIp)); + } + else{ + Assert.assertEquals(500, result); + } + + + } catch (Exception e) { + Assert.assertTrue(e instanceof IOException); + }*/ + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtilTest.java new file mode 100644 index 0000000..f9835d9 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JacksonJsonUtilTest.java @@ -0,0 +1,94 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper.util; + +import java.util.List; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.api.PublishFullAddress; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.wrapper.util.JacksonJsonUtil; + +import com.fasterxml.jackson.core.type.TypeReference; + + +public class JacksonJsonUtilTest { + @Test + public void testBeanToJson(){ + try{ + RouteServer server=new RouteServer("127.0.0.1","80"); + String json=JacksonJsonUtil.beanToJson(server); + Assert.assertEquals("{\"ip\":\"127.0.0.1\",\"port\":\"80\",\"weight\":0}",json); + } + catch(Exception e){ + Assert.fail("Exception" + e.getMessage()); + } + } + + @Test + public void testJsonToBean(){ + try{ + String json="{\"ip\":\"127.0.0.1\",\"port\":\"80\",\"weight\":0}"; + RouteServer server=(RouteServer) JacksonJsonUtil.jsonToBean(json, RouteServer.class); + Assert.assertEquals("127.0.0.1",server.getIp()); + Assert.assertEquals("80",server.getPort()); + } + catch(Exception e){ + Assert.fail("Exception" + e.getMessage()); + } + } + + +// @Test +// public void testJsonToBean_Fail(){ +// try{ +// String json="{\"ip\":\"127.0.0.1\",\"port\":\"80\",\"weight\":0"; +// RouteServer server=(RouteServer) JacksonJsonUtil.jsonToBean(json, RouteServer.class); +// } +// catch(Exception e){ +// Assert.assertEquals("class org.onap.msb.apiroute.api.RouteServer JsonTobean faild",e.getMessage()); +// } +// } + + @Test + public void testJsonToListBean(){ + try{ + String resultJson="[{\"domain\": \"wudith.openpalette.zte.com.cn\",\"port\": \"80\",\"publish_url\": \"/api/wudith/v1\",\"visualRange\": \"0\",\"publish_protocol\": \"http\"}," + + "{\"ip\": \"10.74.165.246\",\"port\": \"80\",\"publish_url\": \"/api/wudith/v1\",\"visualRange\": \"0\",\"publish_protocol\": \"http\"}]"; + List publishFullAddressList = + JacksonJsonUtil.jsonToListBean(resultJson, new TypeReference>() {}); + Assert.assertEquals(2,publishFullAddressList.size()); + Assert.assertEquals("80",publishFullAddressList.get(0).getPort()); + } + catch(Exception e){ + Assert.fail("Exception" + e.getMessage()); + } + } + + @Test + public void testJsonToListBean_Fail(){ + try{ + String resultJson="[\"domain\": \"wudith.openpalette.zte.com.cn\",\"port\": \"80\",\"publish_url\": \"/api/wudith/v1\",\"visualRange\": \"0\",\"publish_protocol\": \"http\"}," + + "{\"ip\": \"10.74.165.246\",\"port\": \"80\",\"publish_url\": \"/api/wudith/v1\",\"visualRange\": \"0\",\"publish_protocol\": \"http\"}]"; + List publishFullAddressList = + JacksonJsonUtil.jsonToListBean(resultJson, new TypeReference>() {}); + } + catch(Exception e){ + Assert.assertTrue(e instanceof Exception); + } + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JedisUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JedisUtilTest.java new file mode 100644 index 0000000..5a92e32 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/JedisUtilTest.java @@ -0,0 +1,20 @@ +package org.onap.msb.apiroute.wrapper.util; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.util.JedisUtil; + +import redis.clients.jedis.exceptions.JedisConnectionException; + +public class JedisUtilTest { + @Test + public void test_initialPool() { + try { + JedisUtil.borrowJedisInstance(); + + } catch (Exception e) { + Assert.assertTrue(e instanceof JedisConnectionException); + + } + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtilTest.java new file mode 100644 index 0000000..2012413 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/MicroServiceUtilTest.java @@ -0,0 +1,45 @@ +package org.onap.msb.apiroute.wrapper.util; + +import javax.servlet.http.HttpServletRequest; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.wrapper.util.MicroServiceUtil; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import redis.clients.jedis.Jedis; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({HttpServletRequest.class}) +public class MicroServiceUtilTest { + + @Test + public void test_getPrefixedKey(){ + Assert.assertEquals("discover:microservices:test:v1",MicroServiceUtil.getPrefixedKey("test","v1")); + } + + @Test + public void test_getServiceKey(){ + Assert.assertEquals("discover:microservices:test:v1",MicroServiceUtil.getServiceKey("test","v1")); + } + + @Test + public void test_getRealIp(){ + HttpServletRequest request=PowerMockito.mock(HttpServletRequest.class); + PowerMockito.when(request.getHeader("X-Forwarded-For")).thenReturn("127.0.0.1"); + Assert.assertEquals("127.0.0.1",MicroServiceUtil.getRealIp(request)); + + PowerMockito.when(request.getHeader("X-Forwarded-For")).thenReturn(""); + PowerMockito.when(request.getHeader("X-Real-IP")).thenReturn("127.0.0.2"); + Assert.assertEquals("127.0.0.2",MicroServiceUtil.getRealIp(request)); + + PowerMockito.when(request.getHeader("X-Forwarded-For")).thenReturn(""); + PowerMockito.when(request.getHeader("X-Real-IP")).thenReturn(""); + PowerMockito.when(request.getRemoteAddr()).thenReturn("127.0.0.3"); + Assert.assertEquals("127.0.0.3",MicroServiceUtil.getRealIp(request)); + + } +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtilTest.java new file mode 100644 index 0000000..11e5907 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RegExpTestUtilTest.java @@ -0,0 +1,96 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper.util; + +import org.junit.Assert; +import org.junit.Test; +import org.onap.msb.apiroute.wrapper.util.RegExpTestUtil; + +public class RegExpTestUtilTest { + + @Test + public void test_HostRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.hostRegExpTest("127.0.0.1:8080")); + Assert.assertFalse(RegExpTestUtil.hostRegExpTest("0.0.0.1:89")); + } + + + + @Test + public void test_IpRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.ipRegExpTest("127.0.0.1")); + Assert.assertFalse(RegExpTestUtil.ipRegExpTest("127.0.0.1.5")); + } + + + + @Test + public void test_PortRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.portRegExpTest("80")); + Assert.assertFalse(RegExpTestUtil.portRegExpTest("898989")); + } + + + @Test + public void test_VersionRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.versionRegExpTest("v1")); + Assert.assertFalse(RegExpTestUtil.versionRegExpTest("23")); + } + + + + @Test + public void test_urlRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.urlRegExpTest("/test")); + Assert.assertTrue(RegExpTestUtil.urlRegExpTest("/")); + Assert.assertFalse(RegExpTestUtil.urlRegExpTest("test")); + } + + + @Test + public void test_apiRouteUrlRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.apiRouteUrlRegExpTest("/api/test/v1")); + Assert.assertFalse(RegExpTestUtil.apiRouteUrlRegExpTest("/test")); + } + + + + @Test + public void test_iuiRouteUrlRegExpTest(){ + Assert.assertTrue(RegExpTestUtil.iuiRouteUrlRegExpTest("/iui/test")); + Assert.assertFalse(RegExpTestUtil.iuiRouteUrlRegExpTest("/test")); + } + + @Test + public void test_apiServiceNameMatch4URL(){ + String[] apiServiceNameArray={"testApiName","v1"}; + Assert.assertArrayEquals(apiServiceNameArray, RegExpTestUtil.apiServiceNameMatch4URL("/api/testApiName/v1")); + + String[] apiServiceNameArray_noversion={"testApiName",""}; + Assert.assertArrayEquals(apiServiceNameArray_noversion, RegExpTestUtil.apiServiceNameMatch4URL("/api/testApiName")); + + Assert.assertNull(RegExpTestUtil.apiServiceNameMatch4URL("/apiw/name/v1")); + } + + @Test + public void test_iuiServiceNameMatch4URL(){ + String iuiServiceName="testIuiName"; + Assert.assertEquals(iuiServiceName, RegExpTestUtil.iuiServiceNameMatch4URL("/iui/testIuiName")); + + Assert.assertNull(RegExpTestUtil.iuiServiceNameMatch4URL("/api/name/v1")); + } + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RouteUtilTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RouteUtilTest.java new file mode 100644 index 0000000..7ddab84 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/RouteUtilTest.java @@ -0,0 +1,373 @@ +/** + * Copyright 2016 ZTE, Inc. and others. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * 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 org.onap.msb.apiroute.wrapper.util; + +import java.util.HashSet; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.MicroServiceFullInfo; +import org.onap.msb.apiroute.api.Node; +import org.onap.msb.apiroute.api.RouteInfo; +import org.onap.msb.apiroute.api.RouteServer; +import org.onap.msb.apiroute.api.exception.UnprocessableEntityException; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ConfigUtil.class}) +public class RouteUtilTest { + + @Test + public void test_getPrefixedKey() { + Assert.assertEquals("msb:routing:test:v1", RouteUtil.getPrefixedKey("", "test", "v1")); + Assert.assertEquals("msb:5656:test:v1", RouteUtil.getPrefixedKey("5656", "test", "v1")); + + } + + @Test + public void test_getPrefixedKey4Host() { + Assert.assertEquals("msb:host:test:v1", RouteUtil.getPrefixedKey4Host("test", "v1")); + + } + + + + @Test + public void test_checkRouteWay() { + try { + RouteUtil.checkRouteWay("ipp"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + + } + + @Test + public void test_checkServiceNameAndVersion() { + try { + RouteUtil.checkServiceNameAndVersion("","v1"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + + try { + RouteUtil.checkServiceNameAndVersion("test","ve1"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkServiceStatus() { + try { + RouteUtil.checkServiceStatus("2"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkRouterInfoFormat() { + RouteInfo routeInfo=new RouteInfo(); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,""); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat_ip() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("name"); + microServiceInfo.setProtocol("REST"); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88.22","8080")); + microServiceInfo.setNodes(nodeSet); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,""); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat_port() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("name"); + microServiceInfo.setProtocol("REST"); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("10.74.148.88.22","808770")); + microServiceInfo.setNodes(nodeSet); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,""); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat_version() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("name"); + microServiceInfo.setProtocol("REST"); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("","8089")); + microServiceInfo.setNodes(nodeSet); + microServiceInfo.setVersion("cv2"); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,"10.74.55.36"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat_url() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("name"); + microServiceInfo.setProtocol("REST"); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("","8089")); + microServiceInfo.setNodes(nodeSet); + microServiceInfo.setVersion("v2"); + microServiceInfo.setUrl("url"); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,"10.74.55.36"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkMicroServiceInfoFormat_protocol() { + MicroServiceFullInfo microServiceInfo=new MicroServiceFullInfo(); + microServiceInfo.setServiceName("name"); + microServiceInfo.setProtocol("REST2"); + Set nodeSet = new HashSet<>(); + nodeSet.add(new Node("","8089")); + microServiceInfo.setNodes(nodeSet); + microServiceInfo.setVersion("v2"); + microServiceInfo.setUrl("/url"); + + try { + RouteUtil.checkMicroServiceInfoFormat(microServiceInfo,"10.74.55.36"); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_getAPIRedisPrefixedKey() { + Assert.assertEquals("msb:20081:api:testApi:v1", RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost","20081","ip")); + Assert.assertEquals("msb:routing:api:testApi:v1", RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost","","ip")); + Assert.assertEquals("msb:host:testHost:api:testApi:v1", RouteUtil.getAPIRedisPrefixedKey("testApi", "v1", "testHost","20081","domain")); + } + + @Test + public void test_getRedisPrefixedKey() { + Assert.assertEquals("msb:20081:custom:/testName/v1", RouteUtil.getRedisPrefixedKey(RouteUtil.CUSTOMROUTE,"/testName/v1", "testHost","20081","ip")); + Assert.assertEquals("msb:routing:custom:/testName/v1", RouteUtil.getRedisPrefixedKey(RouteUtil.CUSTOMROUTE,"/testName/v1", "testHost","","ip")); + Assert.assertEquals("msb:host:testHost:custom:/testName/v1", RouteUtil.getRedisPrefixedKey(RouteUtil.CUSTOMROUTE,"/testName/v1", "testHost","20081","domain")); + + Assert.assertEquals("msb:20081:iui:testName", RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE,"testName", "testHost","20081","ip")); + Assert.assertEquals("msb:routing:iui:testName", RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE,"testName", "testHost","","ip")); + Assert.assertEquals("msb:host:testHost:iui:testName", RouteUtil.getRedisPrefixedKey(RouteUtil.IUIROUTE,"testName", "testHost","20081","domain")); + } + + @Test + public void test_getMutiRedisKey() { + Assert.assertEquals("msb:[^h]*:api:*", RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE,"ip")); + Assert.assertEquals("msb:[^h]*:iui:*", RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE,"ip")); + Assert.assertEquals("msb:[^h]*:custom:*", RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE,"ip")); + + Assert.assertEquals("msb:host:*:api:*", RouteUtil.getMutiRedisKey(RouteUtil.APIROUTE,"domain")); + Assert.assertEquals("msb:host:*:iui:*", RouteUtil.getMutiRedisKey(RouteUtil.IUIROUTE,"domain")); + Assert.assertEquals("msb:host:*:custom:*", RouteUtil.getMutiRedisKey(RouteUtil.CUSTOMROUTE,"domain")); + } + + @Test + public void test_getRouteNameByns() { + Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName","")); + Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName-ns","ns")); + Assert.assertEquals("serviceName-ns", RouteUtil.getRouteNameByns("serviceName-ns-ns","ns")); + Assert.assertEquals("serviceName", RouteUtil.getRouteNameByns("serviceName","default")); + } + + @Test + public void test_getVisualRangeByRouter(){ + Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1")); + Assert.assertEquals("1", RouteUtil.getVisualRangeByRouter("1")); + Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0")); + + + } + + @Test + public void test_getVisualRangeByRouter_muti(){ + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("lab1:val,visualRange:0|1"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertEquals("0", RouteUtil.getVisualRangeByRouter("0|1")); + } + + @Test + public void test_checkRouterInfoFormat_url() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkRouterInfoFormat_visualRangeRange() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + routeInfo.setVisualRange("2"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + + @Test + public void test_checkRouterInfoFormat_controlRangeMatches() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + routeInfo.setVisualRange("0"); + routeInfo.setControl("3"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkRouterInfoFormat_statusRangeMatches() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + routeInfo.setVisualRange("0"); + routeInfo.setControl("0"); + routeInfo.setStatus("3"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + + @Test + public void test_checkRouterInfoFormat_useOwnUpstreamRangeMatches() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88","8080")}); + routeInfo.setVisualRange("0"); + routeInfo.setControl("0"); + routeInfo.setStatus("0"); + routeInfo.setUseOwnUpstream("3"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + @Test + public void test_checkRouterInfoFormat_ip() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88.6","8080")}); + routeInfo.setVisualRange("0"); + routeInfo.setControl("0"); + routeInfo.setStatus("0"); + routeInfo.setUseOwnUpstream("1"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + + @Test + public void test_checkRouterInfoFormat_port() { + RouteInfo routeInfo=new RouteInfo(); + routeInfo.setServiceName("name"); + routeInfo.setUrl("/url"); + routeInfo.setServers( new RouteServer[]{new RouteServer("10.74.148.88.6","757577")}); + routeInfo.setVisualRange("0"); + routeInfo.setControl("0"); + routeInfo.setStatus("0"); + routeInfo.setUseOwnUpstream("1"); + + try { + RouteUtil.checkRouterInfoFormat(routeInfo); + } catch (Exception e) { + Assert.assertTrue(e instanceof UnprocessableEntityException); + } + } + + + + + + + + +} diff --git a/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ServiceFilterTest.java b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ServiceFilterTest.java new file mode 100644 index 0000000..e7c6531 --- /dev/null +++ b/apiroute/apiroute-service/src/test/java/org/onap/msb/apiroute/wrapper/util/ServiceFilterTest.java @@ -0,0 +1,210 @@ +package org.onap.msb.apiroute.wrapper.util; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.junit.Assert; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.msb.apiroute.api.MicroServiceFullInfo; +import org.onap.msb.apiroute.api.Node; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableService; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ImmutableServiceHealth; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.Service; +import org.onap.msb.apiroute.wrapper.consulextend.model.health.ServiceHealth; +import org.onap.msb.apiroute.wrapper.util.ConfigUtil; +import org.onap.msb.apiroute.wrapper.util.ServiceFilter; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import com.orbitz.consul.model.health.ImmutableNode; + +@RunWith(PowerMockRunner.class) +@PrepareForTest({ConfigUtil.class}) +public class ServiceFilterTest { + + + + @Test + public void test_isNeedNotifyByNameSpace() { + + PowerMockito.mockStatic(System.class); + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("all"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("test")); // namespaceMatches:all + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("default"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace("test"));// namespaceMatches:default + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace(""));// namespaceMatches:default + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("default"));// namespaceMatches:default + + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("!default"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("test"));// namespaceMatches:!default + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace(""));// namespaceMatches:!default + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("ns|ns2"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns2")); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns3")); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace("")); + + + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("!ns&!ns2"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns")); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns2")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNameSpace("ns3")); + + } + + /* + * @Test public void test_isNeedNotifyByVisualRange(){ + * + * Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByVisualRange("0")); + * Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByVisualRange("1")); + * Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByVisualRange("0|1")); } + */ + + @Test + public void test_isNeedNotifyByProtocol() { + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByProtocol("HTTP")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByProtocol("UI")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByProtocol("REST")); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByProtocol("TCP")); + } + + @Test + public void test_isNeedNotifyByNetwork_plane_typeMatches() { + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("network_plane_type:network"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNetwork_plane_typeMatches("net")); + Assert.assertTrue(ServiceFilter.getInstance() + .isNeedNotifyByNetwork_plane_typeMatches("network")); + + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("network_plane_type:net1|net2"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByNetwork_plane_typeMatches("net")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNetwork_plane_typeMatches("net1")); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByNetwork_plane_typeMatches("net2")); + + } + + @Test + public void test_isNeedNotifyByRouteLabels() { + Map labelMap = new HashMap(); + labelMap.put("lab1", "val1"); + + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("lab1:val,visualRange:1"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertFalse(ServiceFilter.getInstance().isNeedNotifyByRouteLabels(labelMap)); + + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn("lab1:val1"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + Assert.assertTrue(ServiceFilter.getInstance().isNeedNotifyByRouteLabels(labelMap)); + + } + + @Test + public void test_isFilterService() { + PowerMockito.mockStatic(System.class); + PowerMockito.when(System.getenv("NAMESPACE")).thenReturn("ns1"); + ConfigUtil.getInstance().initRouteNameSpaceMatches(); + + PowerMockito.when(System.getenv("ROUTE_LABELS")).thenReturn( + "visualRange:0,network_plane_type:net,customLabel:custom|custom2"); + ConfigUtil.getInstance().initRouteLabelsMatches(); + + List tagList = new ArrayList(); + tagList.add("\"base\":{\"protocol\":\"REST\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + Assert.assertTrue(ServiceFilter.getInstance().isFilterService(tagList)); + + tagList.clear(); + tagList.add("\"base\":{\"protocol\":\"TCP\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + Assert.assertFalse(ServiceFilter.getInstance().isFilterService(tagList)); + + tagList.clear(); + tagList.add("\"base\":{\"protocol\":\"UI\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns2\"}"); + Assert.assertFalse(ServiceFilter.getInstance().isFilterService(tagList)); + + tagList.clear(); + tagList.add("\"base\":{\"protocol\":\"UI\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"1\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + Assert.assertFalse(ServiceFilter.getInstance().isFilterService(tagList)); + + tagList.clear(); + tagList.add("\"base\":{\"protocol\":\"UI\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net2\",\"customLabel\":\"custom\"}"); + Assert.assertFalse(ServiceFilter.getInstance().isFilterService(tagList)); + + tagList.clear(); + tagList.add("\"base\":{\"protocol\":\"UI\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom3\"}"); + Assert.assertFalse(ServiceFilter.getInstance().isFilterService(tagList)); + + } + + @Test + public void test_transMicroServiceInfoFromConsul() { + List tagList = new ArrayList(); + tagList.add("\"base\":{\"protocol\":\"REST\",\"version\":\"v1\",\"url\":\"/api/msbtest/v1\"}"); + tagList + .add("\"labels\":{\"visualRange\":\"0\",\"network_plane_type\":\"net\",\"customLabel\":\"custom\"}"); + tagList.add("\"ns\":{\"namespace\":\"ns1\"}"); + + Service service = + ImmutableService.builder().id("id").port(8686).address("10.74.165.246").service("msbtest") + .addAllTags(tagList).createIndex(0).modifyIndex(0).build(); + ServiceHealth serviceHealth = + ImmutableServiceHealth.builder().service(service) + .node(ImmutableNode.builder().node("server").address("192.168.1.98").build()).build(); + List serviceHealthList = new ArrayList(); + serviceHealthList.add(serviceHealth); + + Map serviceMap= ServiceFilter.getInstance().transMicroServiceInfoFromConsul(serviceHealthList); + Assert.assertTrue(serviceMap.containsKey("v1")); + + MicroServiceFullInfo microService=new MicroServiceFullInfo(); + microService.setServiceName("msbtest"); + microService.setVersion("v1"); + microService.setUrl("/api/msbtest/v1"); + microService.setProtocol("REST"); + microService.setVisualRange("0"); + microService.setNamespace("ns1"); + + Set nodes=new HashSet(); + nodes.add(new Node("10.74.165.246","8686")); + microService.setNodes(nodes); + + + + Assert.assertEquals(microService,serviceMap.get("v1")); + + + } + + + +} -- cgit 1.2.3-korg