From 6ad41e3ccd398a2721f41ad61c80b7bb03f7d127 Mon Sep 17 00:00:00 2001 From: Ittay Stern Date: Mon, 31 Dec 2018 17:21:27 +0200 Subject: Merge from ECOMP's repository Main Features -------------- - Async-Instantiation jobs mechanism major update; still WIP (package `org.onap.vid.job`) - New features in View/Edit: Activate fabric configuration; show related networks; soft delete - Support AAI service-tree traversal (`AAIServiceTree`) - In-memory cache for SDC models and certain A&AI queries (`CacheProviderWithLoadingCache`) - Upgrade TOSCA Parser and add parsing options; fix malformed TOSCA models - Resolve Cloud-Owner values for MSO - Pass X-ONAP headers to MSO Infrastructure -------------- - Remove codehaus' jackson mapper; use soley fasterxml 2.9.7 - Surefire invokes both TestNG and JUnit tests - Support Kotlin source files - AaiController2 which handles errors in a "Spring manner" - Inline generated-sources and remove jsonschema2pojo Quality -------- - Cumulative bug fixes (A&AI API, UI timeouts, and many more) - Many Sonar issues cleaned-up - Some unused classes removed - Minor changes in vid-automation project, allowing some API verification to run Hard Merges ------------ - HTTP Clients (MSO, A&AI, WebConfig, OutgoingRequestHeadersTest) - Moved `package org.onap.vid.controllers` to `controller`, without plural -- just to keep semantic sync with ECOMP. Reference commit in ECOMP: 3d1141625 Issue-ID: VID-378 Change-Id: I9c8d1e74caa41815891d441fc0760bb5f29c5788 Signed-off-by: Ittay Stern --- .../org/onap/vid/aai/util/CacheConfigTest.java | 32 ++ .../org/onap/vid/aai/util/CacheProviderTest.java | 41 +++ .../util/CacheProviderWithLoadingCacheTest.java | 313 ++++++++++++++++ .../org/onap/vid/aai/util/HttpsAuthClientTest.java | 41 ++- .../onap/vid/aai/util/NonCachingCacheProvider.java | 14 + .../aai/util/ServiceInstanceStandardQueryTest.java | 405 +++++++++++++++++++++ .../vid/aai/util/SingleAAIRestInterfaceTest.java | 75 ++-- 7 files changed, 868 insertions(+), 53 deletions(-) create mode 100644 vid-app-common/src/test/java/org/onap/vid/aai/util/CacheConfigTest.java create mode 100644 vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderTest.java create mode 100644 vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderWithLoadingCacheTest.java create mode 100644 vid-app-common/src/test/java/org/onap/vid/aai/util/NonCachingCacheProvider.java create mode 100644 vid-app-common/src/test/java/org/onap/vid/aai/util/ServiceInstanceStandardQueryTest.java (limited to 'vid-app-common/src/test/java/org/onap/vid/aai/util') diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheConfigTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheConfigTest.java new file mode 100644 index 000000000..1faaee3aa --- /dev/null +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheConfigTest.java @@ -0,0 +1,32 @@ +package org.onap.vid.aai.util; + +import org.testng.annotations.Test; + +import static org.testng.AssertJUnit.assertEquals; + +public class CacheConfigTest { + + @Test + public void whenDeserializeJson_ValuesReadAsExpected() { + CacheConfigProvider cacheConfigProvider = new CacheConfigProviderImpl(); + CacheConfig cacheConfigA = cacheConfigProvider.getCacheConfig("a"); + assertEquals(true, cacheConfigA.isActive()); + assertEquals(6L, cacheConfigA.getExpireAfterWriteHours()); + assertEquals(9L, cacheConfigA.getRefreshAfterWriteSeconds()); + + //entry exist in configuration, but with no values + CacheConfig cacheConfigB = cacheConfigProvider.getCacheConfig("b"); + assertEquals(cacheConfigB.isActive(), CacheConfig.Companion.getDefaultCacheConfig().isActive()); + assertEquals(cacheConfigB.getExpireAfterWriteHours(), CacheConfig.Companion.getDefaultCacheConfig().getExpireAfterWriteHours()); + assertEquals(cacheConfigB.getRefreshAfterWriteSeconds(), CacheConfig.Companion.getDefaultCacheConfig().getRefreshAfterWriteSeconds()); + + + //entry doesn't exist in configuration + CacheConfig cacheConfigC = cacheConfigProvider.getCacheConfig("c"); + assertEquals(CacheConfig.Companion.getDefaultCacheConfig(), cacheConfigC); + + CacheConfig cacheConfigD = cacheConfigProvider.getCacheConfig("d"); + assertEquals(false, cacheConfigD.isActive()); + + } +} diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderTest.java new file mode 100644 index 000000000..95daf9038 --- /dev/null +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderTest.java @@ -0,0 +1,41 @@ +package org.onap.vid.aai.util; + +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; + +import java.util.Arrays; +import java.util.List; + +import static org.hamcrest.Matchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.onap.vid.aai.util.CacheProvider.compileKey; +import static org.onap.vid.aai.util.CacheProvider.decompileKey; + +public class CacheProviderTest { + @Test(dataProvider = "aaiClientCompileDecompileKeySameData") + public void compileDecompileKeySameTest(List args) { + assertThat(decompileKey(compileKey(args)), is(args.toArray())); + } + + @Test(dataProvider = "aaiClientCompileDecompileKeyDifferentData") + public void compileDecompileKeyDifferentTest(List expectedResult, List args) { + assertThat(decompileKey(compileKey(args)), is(expectedResult.toArray())); + } + + @DataProvider + public static Object[][] aaiClientCompileDecompileKeySameData() { + return new Object[][] { + {Arrays.asList( "a", "b", "c")}, + {Arrays.asList("a")}, + {Arrays.asList("a!", "@#?b")}, + {Arrays.asList("a", "", "c")} + }; + } + + @DataProvider + public static Object[][] aaiClientCompileDecompileKeyDifferentData() { + return new Object[][] { + {Arrays.asList("a", "", "c"), Arrays.asList("a", null, "c")} + }; + } +} diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderWithLoadingCacheTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderWithLoadingCacheTest.java new file mode 100644 index 000000000..9a9b28905 --- /dev/null +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/CacheProviderWithLoadingCacheTest.java @@ -0,0 +1,313 @@ +package org.onap.vid.aai.util; + +import com.google.common.cache.CacheBuilder; +import com.google.common.collect.ImmutableList; +import org.apache.commons.lang3.RandomUtils; +import org.apache.commons.lang3.mutable.MutableInt; +import org.apache.commons.lang3.reflect.FieldUtils; +import org.apache.commons.lang3.tuple.Pair; +import org.onap.vid.exceptions.GenericUncheckedException; +import org.onap.vid.properties.Features; +import org.testng.Assert; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import org.togglz.core.manager.FeatureManager; + +import java.util.concurrent.TimeUnit; +import java.util.function.Consumer; +import java.util.function.Function; + +import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric; +import static org.hamcrest.CoreMatchers.sameInstance; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.*; +import static org.hamcrest.core.Is.is; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.*; +import static org.testng.AssertJUnit.assertEquals; + +public class CacheProviderWithLoadingCacheTest { + private final FeatureManager featureManager = mock(FeatureManager.class); + private final CacheConfigProvider cacheConfigProvider = mock(CacheConfigProvider.class); + + @BeforeMethod + public void activateCacheFeatureFlag() { + reset(featureManager); + when(featureManager.isActive(Features.FLAG_1810_AAI_LOCAL_CACHE)).thenReturn(true); + when(cacheConfigProvider.getCacheConfig(any())).thenReturn(CacheConfig.Companion.getDefaultCacheConfig()); + } + + private CacheProviderWithLoadingCache createNewCacheProvider() { + return new CacheProviderWithLoadingCache(featureManager, cacheConfigProvider); + } + + private String RAND() { + return randomAlphanumeric(5); + } + + @Test + public void cacheProvider_requestingCache_CreatesNewCache() { + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(RAND(), (Integer i) -> i + 4); + + assertThat(integerIntegerCache, notNullValue()); + assertThat(integerIntegerCache.get(5), is(9)); + } + + @Test + public void cacheProvider_requestingCacheSameNameTwice_ReturnsFirstCacheInstance() { + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final String name = RAND(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(name, (Integer i) -> i + 4); + final CacheProvider.Cache integerIntegerCache2 = provider.aaiClientCacheFor(name, (Integer i) -> i + 6); + + assertThat(integerIntegerCache2, sameInstance(integerIntegerCache)); + assertThat(integerIntegerCache.get(5), is(9)); // as the first one + } + + @Test + public void cacheProvider_requestingCacheSameNameTwiceOutOfSeveral_ReturnsFirstCacheInstance() { + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + + final String name = RAND(); + provider.aaiClientCacheFor(RAND(), (Integer i) -> i + 2); + provider.aaiClientCacheFor(RAND(), (Integer i) -> i + 3); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(name, (Integer i) -> i + 4); + provider.aaiClientCacheFor(RAND(), (Integer i) -> i + 5); + provider.aaiClientCacheFor(RAND(), (Integer i) -> i + 6); + final CacheProvider.Cache integerIntegerCache2 = provider.aaiClientCacheFor(name, (Integer i) -> i + 4); + + assertThat(integerIntegerCache2, sameInstance(integerIntegerCache)); + } + + @Test + public void cacheProvider_sameProviderSupportDifferentKV() { + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + + assertThat(provider.aaiClientCacheFor(RAND(), + (Integer i) -> i + 2).get(0), is(2)); + assertThat(provider.aaiClientCacheFor(RAND(), + (Integer i) -> i + 3).get(0), is(3)); + assertThat(provider.aaiClientCacheFor(RAND(), + (String s) -> s + 5).get("0"), is("05")); + assertThat(provider.aaiClientCacheFor(RAND(), + (Integer i) -> "0" + i).get(0), is("00")); + assertThat(provider.aaiClientCacheFor(RAND(), + (Pair p) -> ImmutableList.of(p.getLeft(), p.getRight())).get(Pair.of(7, "B")), contains(7, "B")); + } + + @Test + public void cache_callMultiTimesGetFromCahce_loaderCalledOncePairValue(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(RAND(), (Integer i) -> RandomUtils.nextInt()); + int key = RandomUtils.nextInt(); + Integer result1 = integerIntegerCache.get(key); + Integer result2 = integerIntegerCache.get(key + 1); + Integer result3 = integerIntegerCache.get(key); + + Assert.assertNotEquals(result1,result2); + Assert.assertEquals(result1,result3); + } + + @Test + public void cache_callMultiTimesGetFromCahce_loaderCalledOnce(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final MutableInt counter = new MutableInt(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(RAND(), (Integer i) -> { + counter.increment(); + return i; + }); + + int key = RandomUtils.nextInt(); + Integer result1 = integerIntegerCache.get(key); + Integer result2 = integerIntegerCache.get(key); + Integer result3 = integerIntegerCache.get(key); + + Assert.assertEquals(result1.intValue(),key); + Assert.assertEquals(result2.intValue(),key); + Assert.assertEquals(result3.intValue(),key); + Assert.assertEquals(counter.intValue(),1); + } + + @Test(expectedExceptions = GenericUncheckedException.class, expectedExceptionsMessageRegExp ="boom" ) + public void cache_inCaseLoaderMethodThrowsException_cacheThrowsSameException(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final CacheProvider.Cache stringIntegerCache = provider.aaiClientCacheFor(RAND(), (String s) -> { throw new GenericUncheckedException("boom");}); + + stringIntegerCache.get("Whatever"); + } + + @Test + public void cache_inCaseLoaderMethodThrowsException_nextCallUseLoaderMethod(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(RAND(), new Function() { + private boolean firstTime = true; + @Override + public Integer apply(Integer i) { + if (firstTime) { + firstTime = false; + throw new GenericUncheckedException("boom"); + } + else { + return i; + } + } + }); + + try { + integerIntegerCache.get(1); + } + catch (GenericUncheckedException e) {} + + assertEquals(new Integer(1), integerIntegerCache.get(1)); + } + + @Test + public void cache_getIsCalledMoreThanOnce_loaderNotCalledAgainForSameInputValue(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final MutableInt counter = new MutableInt(); + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(RAND(), (Integer i) -> { counter.increment(); return i; }); + + int key1 = RandomUtils.nextInt(); + int key2 = RandomUtils.nextInt(); + integerIntegerCache.get(key1); + Assert.assertEquals(counter.intValue(),1); + integerIntegerCache.get(key2); + Assert.assertEquals(counter.intValue(),2); + integerIntegerCache.get(key1); + Assert.assertEquals(counter.intValue(),2); + } + + @Test + public void cache_getIsCalledMoreThanOnce_loaderIsCalledAgainAfterReset(){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final MutableInt counter = new MutableInt(); + String cacheName = RAND(); + + int key1 = RandomUtils.nextInt(); + provider.aaiClientCacheFor(cacheName, (Integer i) -> { counter.increment(); return i; }).get(key1); + Assert.assertEquals(counter.intValue(), 1); + provider.aaiClientCacheFor(cacheName, (Integer i) -> { counter.increment(); return i; }).get(key1); + Assert.assertEquals(counter.intValue(), 1); + + provider.resetCache(cacheName); + provider.aaiClientCacheFor(cacheName, (Integer i) -> { counter.increment(); return i; }).get(key1); + Assert.assertEquals(counter.intValue(), 2); + + } + + + public static class TestData { + public FeatureManager featureManager; + public String cacheName; + public CacheConfigProvider cacheConfigProvider; + + public TestData(FeatureManager featureManager, String cacheName, CacheConfigProvider cacheConfigProvider) { + this.featureManager = featureManager; + this.cacheName = cacheName; + this.cacheConfigProvider = cacheConfigProvider; + } + } + + + @DataProvider + public static Object[][] mockForCacheIsNotActive() { + + Consumer mockFeatureOff = (testData)->{ + when(testData.featureManager.isActive(Features.FLAG_1810_AAI_LOCAL_CACHE)).thenReturn(false); + when(testData.cacheConfigProvider.getCacheConfig(testData.cacheName)).thenReturn(new CacheConfig(true, 10L, 10L)); + }; + Consumer mockFeatureOnCacheOff = (testData)->{ + when(testData.featureManager.isActive(Features.FLAG_1810_AAI_LOCAL_CACHE)).thenReturn(true); + when(testData.cacheConfigProvider.getCacheConfig(testData.cacheName)).thenReturn(new CacheConfig(false, 10L, 10L)); + }; + + + return new Object[][]{ + {mockFeatureOff}, + {mockFeatureOnCacheOff} + }; + } + + + @Test(dataProvider = "mockForCacheIsNotActive") + public void cache_featureFlagToggleIsOff_loaderIsCalledForEachGet(Consumer mocker){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final MutableInt counter = new MutableInt(); + String cacheName = RAND(); + + final CacheProvider.Cache integerIntegerCache = provider.aaiClientCacheFor(cacheName, (Integer i) -> { + counter.increment(); + return i; + }); + + mocker.accept(new TestData(featureManager, cacheName, cacheConfigProvider)); + counter.setValue(0); + int key = RandomUtils.nextInt(); + integerIntegerCache.get(key); + integerIntegerCache.get(key); + + Assert.assertEquals(counter.intValue(),2); + } + + @Test + public void cache_loaderReturnsRandomValue_sameValueIsReturnedForSameKey() { + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final String name = RAND(); + final CacheProvider.Cache integerRandomStringCache = provider.aaiClientCacheFor(name, (Integer i) -> RAND()); + + String firstGet = integerRandomStringCache.get(1); + String secondGet = integerRandomStringCache.get(1); + + Assert.assertEquals(firstGet,secondGet); + } + + @Test(dataProvider = "mockForCacheIsNotActive") + public void cache_toggleFlagOff_ResetCache(Consumer mocker){ + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + final String cacheName = RAND(); + final CacheProvider.Cache integerRandomStringCache = provider.aaiClientCacheFor(cacheName, (Integer i) -> RAND()); + int key = RandomUtils.nextInt(); + String result1 = integerRandomStringCache.get(key); + String result2 = integerRandomStringCache.get(key); + Assert.assertEquals(result1,result2); + + mocker.accept(new TestData(featureManager, cacheName, cacheConfigProvider)); + String result3 = integerRandomStringCache.get(key); + Assert.assertNotEquals(result1, result3); + } + + @DataProvider + public static Object[][] mockForCacheBuilderConfig() { + return new Object[][]{ + {2L, 2L, 3L, 3L}, + {null, 10L, null, 24L} //null meaning use the default, which is 10L,24L + }; + } + + @Test(dataProvider = "mockForCacheBuilderConfig") + public void cacheBuilderConfiguredWithValues_andWithDefaults( + Long refreshAfterWriteSeconds, + long expectedRefreshAfterWriteSeconds, + Long expireAfterWriteHours, + long expectedExpireAfterWriteHours + ) throws IllegalAccessException { + final String cacheName = RAND(); + when(cacheConfigProvider.getCacheConfig(cacheName)).thenReturn(new CacheConfig(true, expireAfterWriteHours, refreshAfterWriteSeconds)); + final CacheProviderWithLoadingCache provider = createNewCacheProvider(); + CacheBuilder cacheBuilder = provider.createCacheBuilder(cacheName); + + + //Unfortunately CacheBuilder doesn't expose public getters + //Since it's only unit test I let myself do some fouls and use reflection + Long actualRefreshNanos = (Long)FieldUtils.readDeclaredField(cacheBuilder, "refreshNanos", true); + assertThat(actualRefreshNanos, equalTo(TimeUnit.NANOSECONDS.convert(expectedRefreshAfterWriteSeconds, TimeUnit.SECONDS))); + + Long actualExpireAfterWriteNanos = (Long)FieldUtils.readDeclaredField(cacheBuilder, "expireAfterWriteNanos", true); + assertThat(actualExpireAfterWriteNanos, equalTo(TimeUnit.NANOSECONDS.convert(expectedExpireAfterWriteHours, TimeUnit.HOURS))); + + } +} + diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/HttpsAuthClientTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/HttpsAuthClientTest.java index ce957ab67..44678ec24 100644 --- a/vid-app-common/src/test/java/org/onap/vid/aai/util/HttpsAuthClientTest.java +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/HttpsAuthClientTest.java @@ -21,11 +21,20 @@ package org.onap.vid.aai.util; +import org.junit.Before; +import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; +import org.onap.vid.aai.exceptions.HttpClientBuilderException; +import org.onap.vid.exceptions.GenericUncheckedException; +import org.togglz.core.manager.FeatureManager; import javax.net.ssl.SSLContext; +import java.util.Optional; + +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.*; @RunWith(MockitoJUnitRunner.class) public class HttpsAuthClientTest { @@ -38,47 +47,43 @@ public class HttpsAuthClientTest { public static final String CERT_FILE_PATH = "any_path"; - /* - TO BE IMPLEMENTED - private HttpsAuthClient createTestSubject() { - return new HttpsAuthClient(systemPropertyHelper, sslContextProvider); + return new HttpsAuthClient(CERT_FILE_PATH, systemPropertyHelper, sslContextProvider, mock(FeatureManager.class)); } @Before public void setUp() throws Exception { when(systemPropertyHelper.getAAITruststoreFilename()).thenReturn(Optional.of("filename")); - when(systemPropertyHelper.getEncodedTruststorePassword()).thenReturn("password"); + when(systemPropertyHelper.getDecryptedKeystorePassword()).thenReturn("password"); + when(systemPropertyHelper.getDecryptedTruststorePassword()).thenReturn("password"); } @Test(expected = HttpClientBuilderException.class) - public void testHttpClientBuilderExceptionOnGetClient() throws HttpClientBuilderException { + public void testHttpClientBuilderExceptionOnGetClient() throws Exception { //when - when(systemPropertyHelper.getAAIUseClientCert()).thenReturn(Optional.of("true")); - when(sslContextProvider.getSslContext(anyString(), anyString())).thenThrow(new HttpClientBuilderException()); - createTestSubject().getClient("nonExistingFile"); + when(systemPropertyHelper.isClientCertEnabled()).thenReturn(true); + when(sslContextProvider.getSslContext(anyString(), anyString(), any())).thenThrow(new HttpClientBuilderException(new GenericUncheckedException("msg"))); + createTestSubject().getClient(HttpClientMode.WITH_KEYSTORE); } @Test public void testGetSecuredClient() throws Exception { // when - when(systemPropertyHelper.getAAIUseClientCert()).thenReturn(Optional.of("true")); - when(sslContextProvider.getSslContext(anyString(), anyString())).thenReturn(sslContext); - createTestSubject().getClient(CERT_FILE_PATH); + when(systemPropertyHelper.isClientCertEnabled()).thenReturn(true); + when(sslContextProvider.getSslContext(anyString(), anyString(), any())).thenReturn(sslContext); + createTestSubject().getClient(HttpClientMode.WITH_KEYSTORE); //then - verify(sslContextProvider).getSslContext(anyString(), anyString()); + verify(sslContextProvider).getSslContext(anyString(), anyString(), any()); } @Test public void testGetUnsecuredClient() throws Exception { // when - when(systemPropertyHelper.getAAIUseClientCert()).thenReturn(Optional.of("false")); - when(sslContextProvider.getSslContext(anyString(), anyString())).thenReturn(sslContext); - createTestSubject().getClient(CERT_FILE_PATH); + when(systemPropertyHelper.isClientCertEnabled()).thenReturn(false); + createTestSubject().getClient(HttpClientMode.WITH_KEYSTORE); //then - verify(sslContextProvider, never()).getSslContext(anyString(), anyString()); + verify(sslContextProvider, never()).getSslContext(anyString(), anyString(), any()); } - */ } \ No newline at end of file diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/NonCachingCacheProvider.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/NonCachingCacheProvider.java new file mode 100644 index 000000000..b43370763 --- /dev/null +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/NonCachingCacheProvider.java @@ -0,0 +1,14 @@ +package org.onap.vid.aai.util; + +import java.util.function.Function; + +public class NonCachingCacheProvider implements CacheProvider { + + @Override + public Cache aaiClientCacheFor(String name, Function loader) { + return loader::apply; + } + + @Override + public void resetCache(String name) {} +} diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/ServiceInstanceStandardQueryTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/ServiceInstanceStandardQueryTest.java new file mode 100644 index 000000000..99cd928c2 --- /dev/null +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/ServiceInstanceStandardQueryTest.java @@ -0,0 +1,405 @@ +package org.onap.vid.aai.util; + +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.google.common.collect.ImmutableList; +import org.apache.log4j.LogManager; +import org.apache.log4j.Logger; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.onap.vid.aai.AaiClientInterface; +import org.onap.vid.aai.ExceptionWithRequestInfo; +import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Network; +import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.ServiceInstance; +import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Vlan; +import org.onap.vid.aai.model.AaiGetNetworkCollectionDetails.Vnf; +import org.onap.vid.utils.Multival; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.web.client.HttpClientErrorException; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import java.io.IOException; +import java.net.URI; +import java.util.List; +import java.util.stream.Collectors; + +import static org.hamcrest.CoreMatchers.everyItem; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.*; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.when; +import static org.onap.vid.utils.Unchecked.toURI; + + +public class ServiceInstanceStandardQueryTest { + private static final Logger logger = LogManager.getLogger(ServiceInstanceStandardQueryTest.class); + private static final ObjectMapper MAPPER = new ObjectMapper(); + private final String serviceInstanceId = "9cdd1b2a-43a7-47bc-a88e-759ba2399f0b"; + private final String vnfInstanceId_1 = "c015cc0f-0f37-4488-aabf-53795fd93cd3"; + private final String vnfInstanceId_2 = "0846287b-65bf-45a6-88f6-6a1af4149fac"; + private final String networkInstanceId_1 = "7989a6d2-ba10-4a5d-8f15-4520bc833090"; + private final String networkInstanceId_2 = "82373aaa-c561-4e2b-96f1-7ef6f7f7b0e9"; + private final String vlanTagInstanceId_1 = "701edbb2-37e4-4473-a2a6-405cb3ab2e37"; + private final String vlanTagInstanceId_2 = "531571f4-e133-4780-8ba8-d79e63804084"; + private final String vlanTagInstanceId_3 = "df674e8c-1773-4d39-a9e9-bddd2b339d0a"; + private final String SERVICE_TYPE = "service"; + private final String VNF_TYPE = "vnf"; + + @Mock + AaiClientInterface aaiClient; + @InjectMocks + private ServiceInstanceStandardQuery serviceInstanceStandardQuery; + + @BeforeMethod + public void initMocks() { + MockitoAnnotations.initMocks(this); + + when(aaiClient.typedAaiGet(any(URI.class), any(Class.class))) + .thenAnswer(invocationOnMock -> { + final URI uri = (URI) invocationOnMock.getArguments()[0]; + final String lastPart = uri.toString().replaceAll(".*/", ""); + switch (lastPart) { + case serviceInstanceId: + return getAaiObject(ServiceInstance.class); + case vnfInstanceId_1: + case vnfInstanceId_2: + return getAaiObject(Vnf.class); + case networkInstanceId_1: + case networkInstanceId_2: + return getAaiObject(Network.class); + case vlanTagInstanceId_1: + case vlanTagInstanceId_2: + case vlanTagInstanceId_3: + return getAaiObject(Vlan.class); + default: + throw new ExceptionWithRequestInfo(HttpMethod.GET, uri.toASCIIString(), getAaiObjectString(true), 404, + new HttpClientErrorException(HttpStatus.NOT_FOUND)); + } + }); + } + + @Test + public void pathToObject_serviceInstanceUri_yieldsAaiObject() { + final ServiceInstance serviceInstance = serviceInstanceStandardQuery.objectByUri(ServiceInstance.class, toURI("/aai/v12/business/customers/customer/a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb/service-subscriptions/service-subscription/vMOG/service-instances/service-instance/" + serviceInstanceId)); + assertThat(serviceInstance.getServiceInstanceId(), is(serviceInstanceId)); + assertThat(serviceInstance.getServiceInstanceName(), is("Network_repl_vMOG_rk")); + } + + @Test + public void pathToObject_networkUri_yieldsAaiObject() { + final Network network = serviceInstanceStandardQuery.objectByUri(Network.class, toURI("/aai/v12/network/l3-networks/l3-network/" + networkInstanceId_1 + "")); + assertThat(network.getNetworkId(), is(networkInstanceId_1)); + assertThat(network.getNetworkName(), is("APPC-24595-T-IST-02AShared_cor_direct_net_1")); + } + + @Test + public void pathToObject_vlanTagUri_yieldsAaiObject() { + final Vlan vlan = serviceInstanceStandardQuery.objectByUri(Vlan.class, toURI("/this is an invented link/aai/v12/tag/vlan-tags/vlan-tag/" + vlanTagInstanceId_1 + "")); + assertThat(vlan.getVlanInterface(), is("US-10688-genvnf-vlan-interface1")); + assertThat(vlan.getVlanIdInner(), is("917")); + } + + @Test(expectedExceptions = Exception.class) + public void pathToObject_oneUnknownUri_throwsException() { + serviceInstanceStandardQuery.objectByUri(ServiceInstance.class, toURI("/aai/v12/non existing path")); + } + + @Test + public void vnfsForServiceInstance_noRelatedButManyOthers_emptyResult() { + final Multival vnfs = + serviceInstanceStandardQuery.fetchRelatedVnfs(getAaiObject(false, ServiceInstance.class)); + assertThat(vnfs.getValues(), is(empty())); + } + + @Test + public void vnfsForServiceInstance_2RelatedAndManyOthers_Result2CorrectPath2() { + final Multival vnfs = + serviceInstanceStandardQuery.fetchRelatedVnfs(getAaiObject(ServiceInstance.class)); + + assertThat(vnfs.getValues(), hasSize(2)); + } + + @Test + public void serviceInstanceToL3Networks_noRelatedButManyOthers_emptyResult() { + final Multival l3Networks = + serviceInstanceStandardQuery.fetchRelatedL3Networks(SERVICE_TYPE, getAaiObject(false, ServiceInstance.class)); + assertThat(l3Networks.getValues(), is(empty())); + } + + @Test + public void serviceInstanceToL3Networks_2RelatedAndManyOthers_Result2CorrectPath2() { + final Multival l3Networks = + serviceInstanceStandardQuery.fetchRelatedL3Networks(SERVICE_TYPE, getAaiObject(ServiceInstance.class)); + + assertThat(l3Networks.getValues(), hasSize(2)); + } + + @Test + public void l3NetworkToVlanTags_noRelatedButManyOthers_emptyResult() { + final Multival vlanTags = + serviceInstanceStandardQuery.fetchRelatedVlanTags(getAaiObject(false, Network.class)); + assertThat(vlanTags.getValues(), is(empty())); + } + + @Test + public void l3NetworkToVlanTags__2RelatedAndManyOthers_Result2CorrectPath() { + final Multival vlanTags = + serviceInstanceStandardQuery.fetchRelatedVlanTags(getAaiObject(Network.class)); + + assertThat(vlanTags.getValues(), hasSize(3)); + } + + private T getAaiObject(Class valueType) { + return getAaiObject(true, valueType); + } + + private T getAaiObject(boolean withRelated, Class valueType) { + try { + return MAPPER.readValue(getAaiObjectString(withRelated), valueType); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + @Test + public void integrativeUsageWithLinearInvocation() throws JsonProcessingException { + final ServiceInstanceStandardQuery srv = this.serviceInstanceStandardQuery; + final ServiceInstance service = srv.fetchServiceInstance(toURI("path of service/" + serviceInstanceId + "")); + final Network l3Network = ImmutableList.copyOf(srv.fetchRelatedL3Networks(SERVICE_TYPE, service).getValues()).get(0); + final Vlan vlanTag = ImmutableList.copyOf(srv.fetchRelatedVlanTags(l3Network).getValues()).get(0); + + assertThat(vlanTag.getVlanInterface(), is("US-10688-genvnf-vlan-interface1")); + assertThat(vlanTag.getVlanIdInner(), is("917")); + } + + @Test + public void integrativeUsageWithGenericAccessors() throws JsonProcessingException { + final ServiceInstanceStandardQuery srv = this.serviceInstanceStandardQuery; + + final ServiceInstance serviceInstance = srv.fetchServiceInstance(toURI("path of service/" + serviceInstanceId + "")); + + final Multival serviceToNetworks = + srv.fetchRelatedL3Networks(SERVICE_TYPE, serviceInstance); + + final Multival> serviceToNetworksToVlans = + serviceToNetworks.mapEachVal(srv::fetchRelatedVlanTags); + + logger.info(MAPPER.writeValueAsString(serviceToNetworksToVlans)); + + // check all tags are in place + final List vlanTags = serviceToNetworksToVlans + .getValues().stream() + .flatMap(networkVlanMultival -> networkVlanMultival.getValues().stream()) + .collect(Collectors.toList()); + + assertThat(vlanTags, hasSize(6)); // 2 networks, with 3 vlans each + assertThat(vlanTags, everyItem(hasProperty("vlanInterface", is("US-10688-genvnf-vlan-interface1")))); + assertThat(vlanTags, everyItem(hasProperty("vlanIdInner", is("917")))); + } + + private String getAaiObjectString(boolean withRelated) { + final String relatedToVnfs = "" + + " { " + + " \"related-to\": \"generic-vnf\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/aai/v12/network/generic-vnfs/generic-vnf/" + vnfInstanceId_1 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"generic-vnf.vnf-id\", " + + " \"relationship-value\": \"" + vlanTagInstanceId_1 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"generic-vnf.vnf-name\", " + + " \"property-value\": \"\" " + + " } " + + " ] " + + " }, { " + + " \"related-to\": \"generic-vnf\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/aai/v12/network/generic-vnfs/generic-vnf/" + vnfInstanceId_2 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"generic-vnf.vnf-id\", " + + " \"relationship-value\": \"" + vlanTagInstanceId_2 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"generic-vnf.vnf-name\", " + + " \"property-value\": \"\" " + + " } " + + " ] " + + " }, "; + + + final String relatedToL3Networks = "" + + " { " + + " \"related-to\": \"l3-network\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/aai/v12/network/l3-networks/l3-network/" + networkInstanceId_1 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"l3-network.network-id\", " + + " \"relationship-value\": \"" + networkInstanceId_1 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"l3-network.network-name\", " + + " \"property-value\": \"APPC-24595-T-IST-02AShared_cor_direct_net_1\" " + + " } " + + " ] " + + " }, { " + + " \"related-to\": \"l3-network\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/aai/v12/network/l3-networks/l3-network/" + networkInstanceId_2 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"l3-network.network-id\", " + + " \"relationship-value\": \"" + networkInstanceId_2 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"l3-network.network-name\", " + + " \"property-value\": \"APPC-24595-T-IST-02AShared_cor_direct_net_1\" " + + " } " + + " ] " + + " }, "; + + final String relatedToVlanTags = "" + + " { " + + " \"related-to\": \"vlan-tag\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/this is an invented link/aai/v12/tag/vlan-tags/vlan-tag/" + vlanTagInstanceId_2 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"vlan-tag.vlan-tag-id\", " + + " \"relationship-value\": \"" + vlanTagInstanceId_2 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"vlan-tag.vlan-tag-name\", " + + " \"property-value\": \"Behram_smeralda_56\" " + + " } " + + " ] " + + " }, { " + + " \"related-to\": \"vlan-tag\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/this is an invented link/aai/v12/tag/vlan-tags/vlan-tag/" + vlanTagInstanceId_3 + "\" " + + " }, { " + + " \"related-to\": \"vlan-tag\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/this is an invented link/aai/v12/tag/vlan-tags/vlan-tag/" + vlanTagInstanceId_1 + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"vlan-tag.vlan-tag-id\", " + + " \"relationship-value\": \"" + vlanTagInstanceId_1 + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"vlan-tag.vlan-tag-name\", " + + " \"property-value\": \"Alexandra_Liron_3\" " + + " } " + + " ] " + + " }, "; + + return "" + + "{ " + + + // vlan props + " \"vlan-interface\": \"US-10688-genvnf-vlan-interface1\", " + + " \"vlan-id-inner\": 917, " + + " \"resource-version\": \"1518934744675\", " + + " \"in-maint\": false, " + + " \"is-ip-unnumbered\": false, " + + // imaginary vlan props + " \"vlan-tag-id\": \"" + vlanTagInstanceId_2 + "\", " + + " \"vlan-tag-name\": \"Alexandra_Liron_3\", " + + " \"vlan-tag-type\": \"SUNIWOBA\", " + + + // service-instance props + " \"service-instance-name\": \"Network_repl_vMOG_rk\", " + + " \"service-instance-id\": \"" + serviceInstanceId + "\", " + + " \"environment-context\": \"General_Revenue-Bearing\", " + + " \"workload-context\": \"Production\", " + + " \"model-invariant-id\": \"92a72881-0a97-4d16-8c29-4831062e7e9b\", " + + " \"model-version-id\": \"5a3ad576-c01d-4bed-8194-0e72b4a3d020\", " + + " \"resource-version\": \"1516045827731\", " + + " \"orchestration-status\": \"Active\", " + + + // network props + " \"network-id\": \"" + networkInstanceId_1 + "\", " + + " \"network-name\": \"APPC-24595-T-IST-02AShared_cor_direct_net_1\", " + + " \"network-type\": \"CONTRAIL30_BASIC\", " + + " \"network-role\": \"repl\", " + + " \"network-technology\": \"contrail\", " + + " \"neutron-network-id\": \"66ee6123-1c45-4e71-b6c0-a748ae0fee88\", " + + " \"is-bound-to-vpn\": true, " + + " \"service-id\": \"db171b8f-115c-4992-a2e3-ee04cae357e0\", " + + " \"network-role-instance\": 0, " + + " \"resource-version\": \"1516046029762\", " + + " \"heat-stack-id\": \"APPC-24595-T-IST-02AShared_cor_direct_net_1/e8b256aa-8ce1-4384-9d99-6606eaca9eac\", " + + " \"contrail-network-fqdn\": \"default-domain:APPC-24595-T-IST-02C:APPC-24595-T-IST-02AShared_cor_direct_net_1\", " + + " \"physical-network-name\": \"FALSE\", " + + " \"is-provider-network\": false, " + + " \"is-shared-network\": true, " + + " \"is-external-network\": true, " + + + " \"relationship-list\": { " + + " \"relationship\": [{ " + + " \"related-to\": \"service-instance\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.ComposedOf\", " + + " \"related-link\": \"/aai/v12/business/customers/customer/a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb/service-subscriptions/service-subscription/vMOG/service-instances/service-instance/" + serviceInstanceId + "\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"customer.global-customer-id\", " + + " \"relationship-value\": \"a9a77d5a-123e-4ca2-9eb9-0b015d2ee0fb\" " + + " }, { " + + " \"relationship-key\": \"service-subscription.service-type\", " + + " \"relationship-value\": \"vMOG\" " + + " }, { " + + " \"relationship-key\": \"service-instance.service-instance-id\", " + + " \"relationship-value\": \"" + serviceInstanceId + "\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"service-instance.service-instance-name\", " + + " \"property-value\": \"Network_repl_vMOG_rk\" " + + " } " + + " ] " + + " }, { " + + " \"related-to\": \"vpn-binding\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.Uses\", " + + " \"related-link\": \"/aai/v12/network/vpn-bindings/vpn-binding/13e94b71-3ce1-4988-ab0e-61208fc91f1c\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"vpn-binding.vpn-id\", " + + " \"relationship-value\": \"13e94b71-3ce1-4988-ab0e-61208fc91f1c\" " + + " } " + + " ], " + + " \"related-to-property\": [{ " + + " \"property-key\": \"vpn-binding.vpn-name\", " + + " \"property-value\": \"vMDNS\" " + + " }, { " + + " \"property-key\": \"vpn-binding.vpn-type\" " + + " } " + + " ] " + + " }, " + (withRelated ? relatedToVlanTags : "") + "{ " + + " \"related-to\": \"project\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.Uses\", " + + " \"related-link\": \"/aai/v12/business/projects/project/project1\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"project.project-name\", " + + " \"relationship-value\": \"project1\" " + + " } " + + " ] " + + " }, " + (withRelated ? relatedToL3Networks + relatedToVnfs : "") + "{ " + + " \"related-to\": \"owning-entity\", " + + " \"relationship-label\": \"org.onap.relationships.inventory.BelongsTo\", " + + " \"related-link\": \"/aai/v12/business/owning-entities/owning-entity/589fe0db-26c4-45e5-9f4e-a246c74fce76\", " + + " \"relationship-data\": [{ " + + " \"relationship-key\": \"owning-entity.owning-entity-id\", " + + " \"relationship-value\": \"589fe0db-26c4-45e5-9f4e-a246c74fce76\" " + + " } " + + " ] " + + " } " + + " ] " + + " } " + + "} "; + } +} diff --git a/vid-app-common/src/test/java/org/onap/vid/aai/util/SingleAAIRestInterfaceTest.java b/vid-app-common/src/test/java/org/onap/vid/aai/util/SingleAAIRestInterfaceTest.java index 7fad9019c..b5f8ff942 100644 --- a/vid-app-common/src/test/java/org/onap/vid/aai/util/SingleAAIRestInterfaceTest.java +++ b/vid-app-common/src/test/java/org/onap/vid/aai/util/SingleAAIRestInterfaceTest.java @@ -26,7 +26,11 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.Mockito; import org.mockito.junit.MockitoJUnitRunner; +import org.onap.vid.aai.ExceptionWithRequestInfo; import org.onap.vid.aai.exceptions.InvalidPropertyException; +import org.onap.vid.exceptions.GenericUncheckedException; +import org.onap.vid.utils.Unchecked; +import org.springframework.http.HttpMethod; import org.testng.Assert; import javax.servlet.http.HttpServletRequest; @@ -37,10 +41,14 @@ import javax.ws.rs.client.WebTarget; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import java.io.UnsupportedEncodingException; +import java.net.URI; import java.util.Optional; import java.util.UUID; import static javax.ws.rs.core.Response.Status.*; +import static junit.framework.TestCase.fail; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -56,6 +64,8 @@ public class SingleAAIRestInterfaceTest { @Mock private Invocation.Builder builder; @Mock + private Invocation invocation; + @Mock private ServletRequestHelper servletRequestHelper; @Mock private HttpsAuthClient httpsAuthClient; @@ -76,6 +86,9 @@ public class SingleAAIRestInterfaceTest { when(webTarget.request()).thenReturn(builder); when(builder.accept(Mockito.anyString())).thenReturn(builder); when(builder.header(Mockito.anyString(), Mockito.anyString())).thenReturn(builder); + when(builder.build(Mockito.anyString())).thenReturn(invocation); + when(builder.build(Mockito.anyString(), any(Entity.class))).thenReturn(invocation); + when(invocation.invoke()).thenReturn(response); when(servletRequestHelper.extractOrGenerateRequestId()).thenReturn(UUID.randomUUID().toString()); } @@ -90,70 +103,67 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testSetRestSrvrBaseURLWithNullValue() throws Exception { + public void testSetRestSrvrBaseURLWithNullValue() { testSubject.SetRestSrvrBaseURL(null); } @Test - public void testSetRestSrvrBaseURL() throws Exception { + public void testSetRestSrvrBaseURL() { String baseUrl = "anything"; testSubject.SetRestSrvrBaseURL(baseUrl); Assert.assertEquals(testSubject.getRestSrvrBaseURL(), baseUrl); } @Test - public void testRestJsonPutWithResponse200() throws Exception { + public void testRestJsonPutWithResponse200() { // given String methodName = "RestPut"; String payload = "{\"id\": 1}"; Entity entity = Entity.entity(payload, MediaType.APPLICATION_JSON); // when - when(builder.put(Mockito.any(Entity.class))).thenReturn(response); when(response.getStatusInfo()).thenReturn(OK); - Response finalResponse = testSubject.RestPut("", PATH, payload, false); + Response finalResponse = testSubject.RestPut("", PATH, payload, false, true).getResponse(); // then - verify(builder).put(entity); + verify(builder).build(HttpMethod.PUT.name(), entity); Assert.assertEquals(response, finalResponse); } - @Test - public void testFailedRestJsonPut() throws Exception { + @Test(expected = ExceptionWithRequestInfo.class) + public void testFailedRestJsonPut() { // given String methodName = "RestPut"; String payload = "{\"id\": 1}"; Entity entity = Entity.entity(payload, MediaType.APPLICATION_JSON); // when - when(builder.put(Mockito.any(Entity.class))).thenThrow(new RuntimeException()); - Response finalResponse = testSubject.RestPut("", PATH, payload, false); + when(builder.build(eq(HttpMethod.PUT.name()), any(Entity.class))).thenThrow(new GenericUncheckedException("msg")); + Response finalResponse = testSubject.RestPut("", PATH, payload, false, true).getResponse(); // then - verify(builder).put(entity); - Assert.assertEquals(finalResponse, null); + fail("expected unreachable: exception to be thrown"); } @Test - public void testRestJsonPutWithResponse400() throws Exception { + public void testRestJsonPutWithResponse400() { // given String methodName = "RestPut"; String payload = "{\"id\": 1}"; Entity entity = Entity.entity(payload, MediaType.APPLICATION_JSON); // when - when(builder.put(Mockito.any(Entity.class))).thenReturn(response); when(response.getStatusInfo()).thenReturn(BAD_REQUEST); when(response.getStatus()).thenReturn(BAD_REQUEST.getStatusCode()); - Response finalResponse = testSubject.RestPut("", PATH, payload, false); + Response finalResponse = testSubject.RestPut("", PATH, payload, false, true).getResponse(); // then - verify(builder).put(entity); + verify(builder).build(HttpMethod.PUT.name(), entity); Assert.assertEquals(response, finalResponse); } @Test - public void testRestPostWithResponse200() throws Exception { + public void testRestPostWithResponse200() { // given String methodName = "RestPost"; String payload = "{\"id\": 1}"; @@ -170,7 +180,7 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testRestPostWithResponse400() throws Exception { + public void testRestPostWithResponse400() { // given String methodName = "RestPost"; String payload = "{\"id\": 1}"; @@ -188,7 +198,7 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testFailedRestPost() throws Exception { + public void testFailedRestPost() { // given String methodName = "RestPost"; String payload = "{\"id\": 1}"; @@ -204,7 +214,7 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testRestDeleteWithResponse400() throws Exception { + public void testRestDeleteWithResponse400() { // given String methodName = "Delete"; @@ -222,7 +232,7 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testRestDeleteWithResponse404() throws Exception { + public void testRestDeleteWithResponse404() { // given String methodName = "Delete"; @@ -240,7 +250,7 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testFailedRestDelete() throws Exception { + public void testFailedRestDelete() { // given String methodName = "Delete"; @@ -254,54 +264,49 @@ public class SingleAAIRestInterfaceTest { } @Test - public void testRestJsonGetWithResponse200() throws Exception { + public void testRestJsonGetWithResponse200() { // given String methodName = "RestGet"; // when - when(builder.get()).thenReturn(response); when(response.getStatusInfo()).thenReturn(OK); - Response finalResponse = testSubject.RestGet("", "", PATH, false).getResponse(); + Response finalResponse = testSubject.RestGet("", "", Unchecked.toURI(PATH), false).getResponse(); // then Assert.assertEquals(response, finalResponse); } @Test - public void testRestJsonGetWithResponse400() throws Exception { + public void testRestJsonGetWithResponse400() { // given String methodName = "RestGet"; // when - when(builder.get()).thenReturn(response); when(response.getStatusInfo()).thenReturn(BAD_REQUEST); when(response.getStatus()).thenReturn(BAD_REQUEST.getStatusCode()); - Response finalResponse = testSubject.RestGet("", "", PATH, false).getResponse(); + Response finalResponse = testSubject.RestGet("", "", Unchecked.toURI(PATH), false).getResponse(); // then Assert.assertEquals(response, finalResponse); } @Test - public void testFailedRestGet() throws Exception { + public void testFailedRestGet() { // given String methodName = "RestGet"; // when - when(builder.get()).thenThrow(new RuntimeException()); - Response finalResponse = testSubject.RestGet("", "", PATH, false).getResponse(); + when(builder.build(HttpMethod.GET.name())).thenThrow(new RuntimeException()); + Response finalResponse = testSubject.RestGet("", "", Unchecked.toURI(PATH), false).getResponse(); // then Assert.assertEquals(finalResponse, null); } private void mockSystemProperties() throws UnsupportedEncodingException, InvalidPropertyException { - when(systemPropertyHelper.getAAIServerUrl()).thenReturn(Optional.of(HTTP_LOCALHOST)); - when(systemPropertyHelper.getAAIUseClientCert()).thenReturn(Optional.of("cert")); - when(systemPropertyHelper.getAAIVIDPasswd()).thenReturn(Optional.of("passwd")); - when(systemPropertyHelper.getAAIVIDUsername()).thenReturn(Optional.of("user")); when(systemPropertyHelper.getEncodedCredentials()).thenReturn("someCredentials"); when(systemPropertyHelper.getFullServicePath(Mockito.anyString())).thenReturn("http://localhost/path"); + when(systemPropertyHelper.getFullServicePath(Mockito.any(URI.class))).thenReturn("http://localhost/path"); when(systemPropertyHelper.getServiceBasePath(Mockito.anyString())).thenReturn("http://localhost/path"); } -- cgit 1.2.3-korg