2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.onap.vid.aai;
23 import static java.util.stream.Collectors.toList;
24 import static org.apache.commons.lang3.StringUtils.equalsIgnoreCase;
25 import static org.hamcrest.MatcherAssert.assertThat;
26 import static org.hamcrest.Matchers.contains;
27 import static org.hamcrest.Matchers.containsInAnyOrder;
28 import static org.hamcrest.Matchers.containsString;
29 import static org.hamcrest.Matchers.either;
30 import static org.hamcrest.Matchers.hasProperty;
31 import static org.hamcrest.Matchers.instanceOf;
32 import static org.hamcrest.Matchers.is;
33 import static org.hamcrest.Matchers.sameInstance;
34 import static org.mockito.ArgumentMatchers.any;
35 import static org.mockito.ArgumentMatchers.anyBoolean;
36 import static org.mockito.ArgumentMatchers.anyString;
37 import static org.mockito.ArgumentMatchers.argThat;
38 import static org.mockito.ArgumentMatchers.eq;
39 import static org.mockito.ArgumentMatchers.isNull;
40 import static org.mockito.ArgumentMatchers.nullable;
41 import static org.mockito.Mockito.mock;
42 import static org.mockito.Mockito.verify;
43 import static org.mockito.Mockito.when;
44 import static org.onap.vid.utils.KotlinUtilsKt.JACKSON_OBJECT_MAPPER;
45 import static org.onap.vid.utils.Unchecked.toURI;
46 import static org.testng.Assert.assertEquals;
47 import static org.testng.Assert.assertFalse;
48 import static org.testng.Assert.assertNull;
49 import static org.testng.Assert.fail;
51 import com.fasterxml.jackson.core.JsonProcessingException;
52 import com.fasterxml.jackson.databind.ObjectMapper;
53 import com.google.common.collect.ImmutableList;
54 import java.io.FileNotFoundException;
55 import java.io.IOException;
57 import java.security.cert.CertificateException;
58 import java.util.ArrayList;
60 import java.util.function.BiConsumer;
61 import java.util.function.Function;
62 import java.util.stream.Stream;
63 import javax.crypto.BadPaddingException;
64 import javax.net.ssl.SSLHandshakeException;
65 import javax.servlet.ServletContext;
66 import javax.ws.rs.ProcessingException;
67 import javax.ws.rs.client.Client;
68 import javax.ws.rs.core.Response;
69 import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
70 import org.apache.commons.lang3.builder.ToStringStyle;
71 import org.apache.commons.lang3.exception.ExceptionUtils;
72 import org.apache.commons.lang3.reflect.FieldUtils;
73 import org.apache.commons.lang3.tuple.Pair;
74 import org.apache.http.HttpStatus;
75 import org.hamcrest.Matcher;
76 import org.mockito.Mockito;
77 import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
78 import org.onap.portalsdk.core.util.SystemProperties;
79 import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse;
80 import org.onap.vid.aai.model.CustomQuerySimpleResult;
81 import org.onap.vid.aai.model.ModelVer;
82 import org.onap.vid.aai.model.ModelVersions;
83 import org.onap.vid.aai.model.PortDetailsTranslator;
84 import org.onap.vid.aai.model.Properties;
85 import org.onap.vid.aai.model.RelatedToProperty;
86 import org.onap.vid.aai.model.ResourceType;
87 import org.onap.vid.aai.model.SimpleResult;
88 import org.onap.vid.aai.util.AAIRestInterface;
89 import org.onap.vid.aai.util.CacheProvider;
90 import org.onap.vid.aai.util.HttpsAuthClient;
91 import org.onap.vid.aai.util.ServletRequestHelper;
92 import org.onap.vid.aai.util.SystemPropertyHelper;
93 import org.onap.vid.controller.LocalWebConfig;
94 import org.onap.vid.exceptions.GenericUncheckedException;
95 import org.onap.vid.model.Subscriber;
96 import org.onap.vid.model.SubscriberList;
97 import org.onap.vid.model.probes.ExternalComponentStatus;
98 import org.onap.vid.model.probes.HttpRequestMetadata;
99 import org.onap.vid.model.probes.StatusMetadata;
100 import org.onap.vid.testUtils.TestUtils;
101 import org.onap.vid.utils.Logging;
102 import org.onap.vid.utils.Unchecked;
103 import org.springframework.http.HttpMethod;
104 import org.springframework.test.context.ContextConfiguration;
105 import org.springframework.test.context.web.WebAppConfiguration;
106 import org.testng.Assert;
107 import org.testng.annotations.BeforeMethod;
108 import org.testng.annotations.DataProvider;
109 import org.testng.annotations.Test;
110 import sun.security.provider.certpath.SunCertPathBuilderException;
111 import sun.security.validator.ValidatorException;
113 @ContextConfiguration(classes = {LocalWebConfig.class, SystemProperties.class})
115 public class AaiClientTest {
117 private final String NO_LCP_REGION_AND_TENANTS_MSG = "A&AI has no LCP Region & Tenants associated to subscriber 'subscriberId' and service type 'serviceType'";
118 private AaiClient aaiClientMock;
119 private ServletContext servletContext;
122 public void initMocks(){
123 aaiClientMock = mock(AaiClient.class);
124 aaiClientMock.logger = mock(EELFLoggerDelegate.class);
125 aaiClientMock.objectMapper = new ObjectMapper();
126 servletContext = mock(ServletContext.class);
128 when(servletContext.getRealPath(any(String.class))).thenReturn("");
130 when(aaiClientMock.doAaiGet(any(String.class),any(Boolean.class))).thenReturn(null);
131 when(aaiClientMock.doAaiGet(any(URI.class), anyBoolean(), anyBoolean())).thenReturn(null);
135 public static Object[][] logicalLinkData() {
136 return new Object[][] {
137 {"", "network/logical-links/logical-link/"},
138 {"link", "network/logical-links/logical-link/link"}
142 private static String nfRoleOnly = "{\"start\":[\"/business/customers/customer/globalCustomerId1-360-as988q/service-subscriptions/service-subscription/TEST1-360/service-instances\"],\"query\":\"query/vnfs-fromServiceInstance-filter?nfRole=test360\"}";
143 private static String nfRoleAndCloudRegion = "{\"start\":[\"/business/customers/customer/globalCustomerId1-360-as988q/service-subscriptions/service-subscription/TEST1-360/service-instances\"],\"query\":\"query/vnfs-fromServiceInstance-filterByCloudRegion?nfRole=test360&cloudRegionID=cloudRegion-1\"}";
144 private static String cloudRegionOnly = "{\"start\":[\"/business/customers/customer/globalCustomerId1-360-as988q/service-subscriptions/service-subscription/TEST1-360/service-instances\"],\"query\":\"query/vnfs-fromServiceInstance-filterByCloudRegion?cloudRegionID=cloudRegion-1\"}";
145 private static String withoutNfroleAndCloudRegion = "{\"start\":[\"/business/customers/customer/globalCustomerId1-360-as988q/service-subscriptions/service-subscription/TEST1-360/service-instances\"],\"query\":\"query/vnfs-fromServiceInstance-filter\"}";
146 private static String withoutNfroleAndCloudRegionWithSpace = "{\"start\":[\"/business/customers/customer/globalCustomerId1with%20space%20360-as988q/service-subscriptions/service-subscription/TEST1%20360/service-instances\"],\"query\":\"query/vnfs-fromServiceInstance-filter\"}";
148 private static String responseJsonNfRole = "/payload_jsons/changeManagement/vnfs-fromServiceInstance-filterNfRole.json";
149 private static String responseJsonCloudRegion ="/payload_jsons/changeManagement/vnfs-fromServiceInstance-filterByCloudRegion.json";
151 private static String responseJsonDSLServiceInstance ="/payload_jsons/service-instance-by-subscriberid.json";
152 private static String dslQueryPayloadByServiceInstanceId = "{\"dsl\":\"customer*('global-customer-id','SOME_GLOBAL_CUST_ID')>service-subscription>service-instance*('service-instance-id','SOME_SERVICE_INSTANCE_ID')\"}";
153 private static String dslQueryPayloadByServiceInstanceName = "{\"dsl\":\"customer*('global-customer-id','SOME_GLOBAL_CUST_ID')>service-subscription>service-instance*('service-instance-name','SOME_SERVICE_INSTANCE_NAME')\"}";
156 public static Object[][] aaiPutCustomQueryData() {
157 return new Object[][] {
158 {"globalCustomerId1-360-as988q", "TEST1-360", "test360", null, nfRoleOnly, responseJsonNfRole, "908419144", 200},
159 {"globalCustomerId1-360-as988q", "TEST1-360", null, "cloudRegion-1", cloudRegionOnly, responseJsonCloudRegion, "1165906024", 200},
160 {"globalCustomerId1-360-as988q", "TEST1-360", "test360", "cloudRegion-1", nfRoleAndCloudRegion,
161 responseJsonCloudRegion, "1165906024", 200},
162 {"globalCustomerId1with space 360-as988q", "TEST1 360", null, null, withoutNfroleAndCloudRegionWithSpace, responseJsonNfRole, "908419144", 200},
163 {"globalCustomerId1-360-as988q", "TEST1-360", null, null, withoutNfroleAndCloudRegion, responseJsonNfRole, "908419144", 200},
167 @Test(dataProvider = "aaiPutCustomQueryData")
168 public void testAaiPutCustomQueryByParams(String globalCustomerId, String serviceType, String nfRole, String cloudRegion, String expectedPayload, String responseBody, String expectedId, int responseHttpCode) {
169 String queryFormat = "query?format=simple";
170 final ResponseWithRequestInfo mockedResponseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK,
171 TestUtils.readFileAsString(responseBody),
172 "query?format=simple&Mock=True",
174 when(aaiClientMock.doAaiPut(eq(queryFormat), anyString(), anyBoolean(), anyBoolean())).thenReturn(mockedResponseWithRequestInfo);
175 when(aaiClientMock.getVnfsByParamsForChangeManagement(anyString(), anyString(), nullable(String.class), nullable(String.class))).thenCallRealMethod();
176 AaiResponse<AaiGetVnfResponse> response = aaiClientMock.getVnfsByParamsForChangeManagement(globalCustomerId, serviceType, nfRole, cloudRegion);
177 verify(aaiClientMock).doAaiPut(eq(queryFormat), eq(expectedPayload), eq(false), eq(false));
178 assertEquals(response.getHttpCode(), responseHttpCode);
179 assertEquals(response.getT().getResults().get(0).id, expectedId);
182 @Test(dataProvider = "logicalLinkData")
183 public void getLogicalLink_Link_Is_Empty(String link, String expectedUrl) {
185 when(aaiClientMock.getLogicalLink(any(String.class))).thenCallRealMethod();
186 aaiClientMock.getLogicalLink(link);
187 verify(aaiClientMock).doAaiGet(argThat(s -> equalsIgnoreCase(s, expectedUrl)),any(Boolean.class));
191 public static Object[][] subscribersResults() {
192 return new Object[][] {
193 {new SubscriberList(new ArrayList<Subscriber>() {{ add(new Subscriber()); add(new Subscriber()); }}), true},
194 {new SubscriberList(new ArrayList<Subscriber>() {{ add(new Subscriber()); }}), true},
195 {new SubscriberList(new ArrayList<Subscriber>()), false}
199 @Test(dataProvider = "subscribersResults")
200 public void testProbeAaiGetAllSubscribers_returnsTwoToZeroSubscribers_ResultsAsExpected(SubscriberList subscribers, boolean isAvailable){
201 ExternalComponentStatus expectedStatus = new ExternalComponentStatus(ExternalComponentStatus.Component.AAI,isAvailable, new HttpRequestMetadata(
206 isAvailable ? "OK" : "No subscriber received",
209 Mockito.when(aaiClientMock.getAllSubscribers(true)).thenReturn(
210 new AaiResponseWithRequestInfo<>(
211 HttpMethod.GET, "url", new AaiResponse<>(subscribers, null, 200),
213 Mockito.when(aaiClientMock.probeComponent()).thenCallRealMethod();
214 ExternalComponentStatus result = aaiClientMock.probeComponent();
215 assertThat(statusDataReflected(result),is(statusDataReflected(expectedStatus)));
216 assertThat(requestMetadataReflected(result.getMetadata()),is(requestMetadataReflected(expectedStatus.getMetadata())));
219 @Test(expectedExceptions = Exception.class)
220 public void typedAaiGet_aaiRestInterfaceRestGetReturnsError_exceptionIsThrown() {
221 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
222 final ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.INTERNAL_SERVER_ERROR, "entity");
223 mockForGetRequest(aaiRestInterface, responseWithRequestInfo);
224 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
228 aaiClient.typedAaiGet(toURI("/irrelevant/url"), RelatedToProperty.class);
230 } catch (Exception e) {
231 assertThat(ExceptionUtils.getStackTrace(e), e, instanceOf(ExceptionWithRequestInfo.class));
232 ExceptionWithRequestInfo e2 = ((ExceptionWithRequestInfo) e);
233 assertThat(e2.getHttpCode(), is(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()));
234 assertThat(e2.getRawData(), is("entity"));
235 assertThat(e2.getHttpMethod(), is(HttpMethod.GET));
236 assertThat(e2.getRequestedUrl(), is("/my/mocked/url"));
242 @Test(expectedExceptions = Exception.class)
243 public void typedAaiGet_aaiRestInterfaceRestGetReturnsInparsableResponse_exceptionIsThrown() {
244 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
245 final ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK, "entity");
246 mockForGetRequest(aaiRestInterface, responseWithRequestInfo);
247 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
251 aaiClient.typedAaiGet(toURI("/irrelevant/url"), RelatedToProperty.class);
253 } catch (Exception e) {
254 assertThat(ExceptionUtils.getStackTrace(e), e, instanceOf(ExceptionWithRequestInfo.class));
255 assertThat(e.getCause(),
256 hasProperty("cause", is(instanceOf(com.fasterxml.jackson.core.JsonParseException.class)))
263 public void typedAaiGet_aaiRestInterfaceRestGetReturns_objectIsFine() {
264 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
265 final ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK,
266 "{ \"property-key\": \"foo\", \"property-value\": \"bar\" }");
267 mockForGetRequest(aaiRestInterface, responseWithRequestInfo);
269 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
271 final RelatedToProperty relatedToPropertyAaiResponse = aaiClient.typedAaiGet(toURI("/irrelevant/url"), RelatedToProperty.class);
273 assertThat(relatedToPropertyAaiResponse.getPropertyKey(), is("foo"));
274 assertThat(relatedToPropertyAaiResponse.getPropertyValue(), is("bar"));
277 private ResponseWithRequestInfo mockedResponseWithRequestInfo(Response.Status status, String entity) {
278 return mockedResponseWithRequestInfo(status, entity, "/my/mocked/url", HttpMethod.GET);
281 private ResponseWithRequestInfo mockedResponseWithRequestInfo(Response.Status status, String entity, String requestUrl, HttpMethod method) {
282 final Response mockResponse = mock(Response.class);
283 when(mockResponse.getStatus()).thenReturn(status.getStatusCode());
284 when(mockResponse.getStatusInfo()).thenReturn(status);
285 when(mockResponse.readEntity(String.class)).thenReturn(entity);
286 return new ResponseWithRequestInfo(mockResponse, requestUrl, method);
289 //serialize fields except of fields we cannot know ahead of time
290 private static String requestMetadataReflected(StatusMetadata metadata) {
291 return new ReflectionToStringBuilder(metadata, ToStringStyle.SHORT_PREFIX_STYLE)
292 .setExcludeFieldNames("duration")
296 private static String statusDataReflected(ExternalComponentStatus status) {
297 return new ReflectionToStringBuilder(status, ToStringStyle.SHORT_PREFIX_STYLE)
298 .setExcludeFieldNames("metadata")
303 public static Object[][] rawData() {
304 return new Object[][]{
305 {"errorMessage", }, {""}, {null}
309 @Test(dataProvider = "rawData")
310 public void testProbeAaiGetFullSubscribersWithNullResponse_returnsNotAvailableWithErrorRawData(String rawData){
311 Mockito.when(aaiClientMock.getAllSubscribers(true)).thenReturn(
312 new AaiResponseWithRequestInfo<>(HttpMethod.GET, "url", null,
314 ExternalComponentStatus result = callProbeAaiGetAllSubscribersAndAssertNotAvailable();
315 assertThat(result.getMetadata(), instanceOf(HttpRequestMetadata.class));
316 assertEquals(((HttpRequestMetadata) result.getMetadata()).getRawData(), rawData);
320 public static Object[][] exceptions() {
321 return new Object[][] {
322 {"NullPointerException", "errorMessage",
323 new ExceptionWithRequestInfo(HttpMethod.GET, "url",
324 "errorMessage", null, new NullPointerException())},
325 {"RuntimeException", null,
326 new ExceptionWithRequestInfo(HttpMethod.GET, "url",
327 null, null, new RuntimeException())},
328 {"RuntimeException", null,
329 new RuntimeException()},
333 @Test(dataProvider = "exceptions")
334 public void testProbeAaiGetFullSubscribersWithNullResponse_returnsNotAvailableWithErrorRawData(String description, String expectedRawData, Exception exception){
335 Mockito.when(aaiClientMock.getAllSubscribers(true)).thenThrow(exception);
336 ExternalComponentStatus result = callProbeAaiGetAllSubscribersAndAssertNotAvailable();
337 if (exception instanceof ExceptionWithRequestInfo) {
338 assertThat(result.getMetadata(), instanceOf(HttpRequestMetadata.class));
339 assertEquals(((HttpRequestMetadata) result.getMetadata()).getRawData(), expectedRawData);
341 assertThat(result.getMetadata().getDescription(), containsString(description));
344 private ExternalComponentStatus callProbeAaiGetAllSubscribersAndAssertNotAvailable() {
345 Mockito.when(aaiClientMock.probeComponent()).thenCallRealMethod();
346 ExternalComponentStatus result = aaiClientMock.probeComponent();
347 assertFalse(result.isAvailable());
353 public void getTenants_Arguments_Are_Null_Or_Empty() {
355 when(aaiClientMock.getTenants(any(), any())).thenCallRealMethod();
357 AaiResponse response = aaiClientMock.getTenants("", "");
359 assertEquals(response.getErrorMessage(), "{\"statusText\":\" Failed to retrieve LCP Region & Tenants from A&AI, Subscriber ID or Service Type is missing.\"}");
362 response = aaiClientMock.getTenants(null, null);
364 assertEquals(response.getErrorMessage(), "{\"statusText\":\" Failed to retrieve LCP Region & Tenants from A&AI, Subscriber ID or Service Type is missing.\"}");
367 @Test(expectedExceptions = AaiClient.ParsingGetTenantsResponseFailure.class, expectedExceptionsMessageRegExp = NO_LCP_REGION_AND_TENANTS_MSG)
368 public void getTenants_Arguments_Are_Valid_But_Tenants_Not_Exist() {
370 when(aaiClientMock.getTenantsNonCached(any(String.class),any(String.class))).thenCallRealMethod();
372 Response generalEmptyResponse = mock(Response.class);
373 when(aaiClientMock.doAaiGet(any(String.class),any(Boolean.class))).thenReturn(generalEmptyResponse);
375 aaiClientMock.getTenantsNonCached("subscriberId", "serviceType");
379 public void whenCacheThrowException_thenGetTenantReturnAaiResponse() {
380 CacheProvider mockCacheProvider = mock(CacheProvider.class);
381 CacheProvider.Cache mockCache = mock(CacheProvider.Cache.class);
382 AaiClient aaiClientUnderTest = new AaiClient(null, null, mockCacheProvider);
384 when(mockCacheProvider.aaiClientCacheFor(any(), any())).thenReturn(mockCache);
385 when(mockCache.get(any())).thenThrow(new AaiClient.ParsingGetTenantsResponseFailure(NO_LCP_REGION_AND_TENANTS_MSG));
386 AaiResponse aaiResponse = aaiClientUnderTest.getTenants("subscriberId", "serviceType");
387 assertEquals(HttpStatus.SC_INTERNAL_SERVER_ERROR, aaiResponse.getHttpCode());
388 assertEquals("{\"statusText\":\""+NO_LCP_REGION_AND_TENANTS_MSG+"\"}", aaiResponse.getErrorMessage());
392 public void getTenants_Arguments_Are_Valid_Get_The_Tenanats() {
394 when(aaiClientMock.getTenantsNonCached(any(String.class),any(String.class))).thenCallRealMethod();
397 Response generalEmptyResponse = mock(Response.class);
399 when(generalEmptyResponse.readEntity(String.class)).thenReturn(tenantResponseRaw);
400 when(generalEmptyResponse.getStatus()).thenReturn(200);
401 when(generalEmptyResponse.getStatusInfo()).thenReturn(Response.Status.OK);
404 when(aaiClientMock.doAaiGet(any(String.class),any(Boolean.class))).thenReturn(generalEmptyResponse);
406 AaiResponse<GetTenantsResponse[]> response = aaiClientMock.getTenantsNonCached("subscriberId", "serviceType");
408 GetTenantsResponse[] tenants = response.getT();
410 Assert.assertTrue(response.t.length> 0);
412 Assert.assertEquals(tenants[0].cloudOwner,"irma-aic-cloud-owner");
415 final String tenantResponseRaw ="" +
417 "\"service-type\": \"VIRTUAL USP\"," +
418 "\"resource-version\": \"1494001841964\"," +
419 "\"relationship-list\": {" +
420 "\"relationship\": [{" +
421 "\"related-to\": \"tenant\"," +
422 "\"related-link\": \"/aai/v11/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/AAIAIC25/tenants/tenant/092eb9e8e4b7412e8787dd091bc58e86\"," +
423 "\"relationship-data\": [{" +
424 "\"relationship-key\": \"cloud-region.cloud-owner\"," +
425 "\"relationship-value\": \"irma-aic-cloud-owner\"" +
428 "\"relationship-key\": \"cloud-region.cloud-region-id\"," +
429 "\"relationship-value\": \"AAIAIC25\"" +
432 "\"relationship-key\": \"tenant.tenant-id\"," +
433 "\"relationship-value\": \"092eb9e8e4b7412e8787dd091bc58e86\"" +
436 "\"related-to-property\": [{" +
437 "\"property-key\": \"tenant.tenant-name\"," +
438 "\"property-value\": \"USP-SIP-IC-24335-T-01\"" +
444 final String vfModuleHomingResponseRaw ="{" +
445 " \"vf-module-id\": \"ed02354a-3217-45ce-a1cd-e0b69b7a8cea\"," +
446 " \"vf-module-name\": \"apndns_az_02_module_1\"," +
447 " \"heat-stack-id\": \"apndns_az_02_module_1/97a319f3-b095-4fff-befa-c657508ecaf8\"," +
448 " \"orchestration-status\": \"active\"," +
449 " \"is-base-vf-module\": false," +
450 " \"resource-version\": \"1530559380383\"," +
451 " \"model-invariant-id\": \"74450b48-0aa0-4743-8314-9163e92b7862\"," +
452 " \"model-version-id\": \"6bc01a2b-bc48-4991-b9fe-e22c2215d801\"," +
453 " \"model-customization-id\": \"74f638c2-0368-4212-8f73-e961005af17c\"," +
454 " \"module-index\": 0," +
455 " \"relationship-list\": {" +
456 " \"relationship\": [" +
458 " \"related-to\": \"l3-network\"," +
459 " \"relationship-label\": \"org.onap.relationships.inventory.DependsOn\"," +
460 " \"related-link\": \"/aai/v12/network/l3-networks/l3-network/335e62be-73a3-41e8-930b-1a677bcafea5\"," +
461 " \"relationship-data\": [" +
463 " \"relationship-key\": \"l3-network.network-id\"," +
464 " \"relationship-value\": \"335e62be-73a3-41e8-930b-1a677bcafea5\"" +
467 " \"related-to-property\": [" +
469 " \"property-key\": \"l3-network.network-name\"," +
470 " \"property-value\": \"MNS-FN-25180-T-02Shared_oam_protected_net_1\"" +
475 " \"related-to\": \"l3-network\"," +
476 " \"relationship-label\": \"org.onap.relationships.inventory.DependsOn\"," +
477 " \"related-link\": \"/aai/v12/network/l3-networks/l3-network/2db4ee3e-2ac7-4fc3-8739-ecf53416459e\"," +
478 " \"relationship-data\": [" +
480 " \"relationship-key\": \"l3-network.network-id\"," +
481 " \"relationship-value\": \"2db4ee3e-2ac7-4fc3-8739-ecf53416459e\"" +
484 " \"related-to-property\": [" +
486 " \"property-key\": \"l3-network.network-name\"," +
487 " \"property-value\": \"Mobisupport-FN-27099-T-02_int_apn_dns_net_1\"" +
492 " \"related-to\": \"volume-group\"," +
493 " \"relationship-label\": \"org.onap.relationships.inventory.Uses\"," +
494 " \"related-link\": \"/aai/v12/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/volume-groups/volume-group/66013ebe-0c81-44b9-a24f-7c6acba73a39\"," +
495 " \"relationship-data\": [" +
497 " \"relationship-key\": \"cloud-region.cloud-owner\"," +
498 " \"relationship-value\": \"irma-aic\"" +
501 " \"relationship-key\": \"cloud-region.cloud-region-id\"," +
502 " \"relationship-value\": \"rdm5b\"" +
505 " \"relationship-key\": \"volume-group.volume-group-id\"," +
506 " \"relationship-value\": \"66013ebe-0c81-44b9-a24f-7c6acba73a39\"" +
511 " \"related-to\": \"vserver\"," +
512 " \"relationship-label\": \"org.onap.relationships.inventory.Uses\"," +
513 " \"related-link\": \"/aai/v12/cloud-infrastructure/cloud-regions/cloud-region/irma-aic/rdm5b/tenants/tenant/db1818f7f2e34862b378bfb2cc520f91/vservers/vserver/5eef9f6d-9933-4bc6-9a1a-862d61309437\"," +
514 " \"relationship-data\": [" +
516 " \"relationship-key\": \"cloud-region.cloud-owner\"," +
517 " \"relationship-value\": \"irma-aic\"" +
520 " \"relationship-key\": \"cloud-region.cloud-region-id\"," +
521 " \"relationship-value\": \"rdm5b\"" +
524 " \"relationship-key\": \"tenant.tenant-id\"," +
525 " \"relationship-value\": \"db1818f7f2e34862b378bfb2cc520f91\"" +
528 " \"relationship-key\": \"vserver.vserver-id\"," +
529 " \"relationship-value\": \"5eef9f6d-9933-4bc6-9a1a-862d61309437\"" +
532 " \"related-to-property\": [" +
534 " \"property-key\": \"vserver.vserver-name\"," +
535 " \"property-value\": \"zrdm5bfapn01dns002\"" +
543 public void get_homingDataForVfModule() {
544 when(aaiClientMock.getHomingDataByVfModule(any(String.class), any(String.class))).thenCallRealMethod();
546 Response homingResponse = mock(Response.class);
548 when(homingResponse.readEntity(String.class)).thenReturn(vfModuleHomingResponseRaw);
549 when(homingResponse.getStatus()).thenReturn(200);
550 when(homingResponse.getStatusInfo()).thenReturn(Response.Status.OK);
553 when(aaiClientMock.doAaiGet(any(String.class), any(Boolean.class))).thenReturn(homingResponse);
555 GetTenantsResponse tenant = aaiClientMock.getHomingDataByVfModule("vnfInstanceId", "vfModuleId");
557 Assert.assertEquals(tenant.cloudOwner,"irma-aic" );
558 Assert.assertEquals(tenant.cloudRegionID,"rdm5b");
559 Assert.assertEquals(tenant.tenantID,"db1818f7f2e34862b378bfb2cc520f91");
562 @Test(expectedExceptions = GenericUncheckedException.class, expectedExceptionsMessageRegExp = "A&AI has no homing data associated to vfModule 'vfModuleId' of vnf 'vnfInstanceId'")
563 public void getVfModule_Homing_Arguments_Are_Valid_But_Not_Exists() {
564 when(aaiClientMock.getHomingDataByVfModule(any(String.class), any(String.class))).thenCallRealMethod();
566 Response generalEmptyResponse = mock(Response.class);
567 when(aaiClientMock.doAaiGet(any(String.class),any(Boolean.class))).thenReturn(generalEmptyResponse);
569 aaiClientMock.getHomingDataByVfModule("vnfInstanceId", "vfModuleId");
573 public static Object[][] invalidDataId() {
574 return new String[][] {
580 @Test(dataProvider = "invalidDataId", expectedExceptions = GenericUncheckedException.class, expectedExceptionsMessageRegExp = "Failed to retrieve homing data associated to vfModule from A&AI, VNF InstanceId or VF Module Id is missing.")
581 public void getVfModule_Homing_Arguments_Are_Empty_Or_Null(String data) {
582 when(aaiClientMock.getHomingDataByVfModule(any(), any())).thenCallRealMethod();
583 aaiClientMock.getHomingDataByVfModule(data, data);
587 public static Object[][] resourceTypesProvider() {
588 return new Object[][] {
589 {"service-instance", ResourceType.SERVICE_INSTANCE},
590 {"generic-vnf", ResourceType.GENERIC_VNF},
591 {"vf-module", ResourceType.VF_MODULE}
596 public static Object[][] nameAndResourceTypeProvider() {
597 return new Object[][] {
598 {"SRIOV_SVC", ResourceType.SERVICE_INSTANCE, "nodes/service-instances?service-instance-name=SRIOV_SVC"},
599 {"b1707vidnf", ResourceType.GENERIC_VNF, "nodes/generic-vnfs?vnf-name=b1707vidnf"},
600 {"connectivity_test", ResourceType.VF_MODULE, "nodes/vf-modules?vf-module-name=connectivity_test"},
601 {"ByronPace", ResourceType.INSTANCE_GROUP, "nodes/instance-groups?instance-group-name=ByronPace"},
602 {"MjVg1234", ResourceType.VOLUME_GROUP, "nodes/volume-groups?volume-group-name=MjVg1234"}
606 @Test(dataProvider = "nameAndResourceTypeProvider")
607 public void whenSearchNodeTypeByName_callRightAaiPath(String name, ResourceType type, String expectedUrl) {
608 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
609 ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK, "{}");
611 when(aaiRestInterface.RestGet(anyString(), anyString(), eq(toURI(expectedUrl)), anyBoolean(), anyBoolean()))
612 .thenReturn(responseWithRequestInfo);
614 AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
616 aaiClient.isNodeTypeExistsByName(name, type);
620 public static Object[][] aaiClientInternalExceptions() {
621 return Stream.<Pair<Class<? extends Throwable>, UncheckedBiConsumer<HttpsAuthClient, Client>>>of(
623 // Exception out of httpsAuthClientMock
624 Pair.of(CertificateException.class, (httpsAuthClientMock, javaxClientMock) -> {
625 final CertificateException e0 = new CertificateException("No X509TrustManager implementation available");
626 SSLHandshakeException e = new SSLHandshakeException(e0.toString());
629 when(httpsAuthClientMock.getClient(any())).thenThrow(e);
632 Pair.of(StringIndexOutOfBoundsException.class, mockExceptionOnClientProvider(new StringIndexOutOfBoundsException(4))),
634 Pair.of(NullPointerException.class, mockExceptionOnClientProvider(new NullPointerException("null"))),
636 Pair.of(FileNotFoundException.class, mockExceptionOnClientProvider(new FileNotFoundException("vid/WEB-INF/cert/aai-client-cert.p12"))),
638 Pair.of(BadPaddingException.class, mockExceptionOnClientProvider(
639 new IOException("keystore password was incorrect", new BadPaddingException("Given final block not properly padded")))
641 Pair.of(GenericUncheckedException.class, mockExceptionOnClientProvider(new GenericUncheckedException("basa"))),
643 Pair.of(NullPointerException.class, (httpsAuthClientMock, javaxClientMock) ->
644 when(httpsAuthClientMock.getClient(any())).thenReturn(null)),
647 // Exception out of javax's Client
648 Pair.of(SSLHandshakeException.class, (httpsAuthClientMock, javaxClientMock) -> {
649 when(javaxClientMock.target(nullable(String.class))).thenThrow(
650 new ProcessingException(new SSLHandshakeException("Received fatal alert: certificate_expired"))
654 Pair.of(SunCertPathBuilderException.class, (httpsAuthClientMock, javaxClientMock) -> {
655 SunCertPathBuilderException e0 = new SunCertPathBuilderException("unable to find valid certification path to requested target");
656 when(javaxClientMock.target(nullable(String.class))).thenThrow(
657 new ProcessingException(new ValidatorException("PKIX path building failed: " + e0.toString(), e0))
661 Pair.of(GenericUncheckedException.class, (httpsAuthClientMock, javaxClientMock) ->
662 when(javaxClientMock.target(nullable(String.class))).thenThrow(new GenericUncheckedException("basa")))
664 ).flatMap(l -> Stream.of(
665 // double each case to propagateExceptions = true/false, to verify that "don't propagate" really still work
666 ImmutableList.of(l.getLeft(), l.getRight(), true).toArray(),
667 ImmutableList.of(l.getLeft(), l.getRight(), false).toArray()
668 )).collect(toList()).toArray(new Object[][]{});
671 private static UncheckedBiConsumer<HttpsAuthClient, Client> mockExceptionOnClientProvider(Exception e) {
672 return (httpsAuthClientMock, javaxClientMock) ->
673 when(httpsAuthClientMock.getClient(any())).thenThrow(e);
676 @Test(dataProvider = "aaiClientInternalExceptions")
677 public void propagateExceptions_internalsThrowException_ExceptionRethrown(Class<? extends Throwable> expectedType, BiConsumer<HttpsAuthClient, Client> setupMocks, boolean propagateExceptions) throws Exception {
680 this test -> AaiClient -> AAIRestInterface -> HttpsAuthClient -> javax's Client
682 In this test, *AaiClient* and *AAIRestInterface* are under test (actual
683 implementation is used), while HttpsAuthClient and the javax's Client are
684 mocked to return pseudo-responses or - better- throw exceptions.
688 HttpsAuthClient httpsAuthClientMock = mock(HttpsAuthClient.class);
689 TestUtils.JavaxRsClientMocks mocks = new TestUtils.JavaxRsClientMocks();
690 Client javaxClientMock = mocks.getFakeClient();
691 Response responseMock = mocks.getFakeResponse();
693 // prepare real AAIRestInterface and AaiClient, and wire mocks
694 AAIRestInterface aaiRestInterface = new AAIRestInterface(httpsAuthClientMock,
695 mock(ServletRequestHelper.class),
696 mock(SystemPropertyHelper.class),
697 mock(Logging.class));
698 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
699 when(httpsAuthClientMock.getClient(any())).thenReturn(javaxClientMock);
701 // define atomic method under test, including reset of "aaiRestInterface.client"
702 final Function<Boolean, Response> doAaiGet = (propagateExceptions1) -> {
704 FieldUtils.writeField(aaiRestInterface, "client", null, true);
705 return aaiClient.doAaiGet("uri", false, propagateExceptions1).getResponse();
706 } catch (IllegalAccessException e) {
707 throw new RuntimeException(e);
711 // verify setup again
712 assertThat("mocks setup should make doAaiGet return our responseMock", doAaiGet.apply(true), is(sameInstance(responseMock)));
716 setupMocks.accept(httpsAuthClientMock, javaxClientMock);
719 final Response response = doAaiGet.apply(propagateExceptions);
720 } catch (Exception e) {
721 if (propagateExceptions) {
722 assertThat("root cause incorrect for " + ExceptionUtils.getStackTrace(e), ExceptionUtils.getRootCause(e), instanceOf(expectedType));
725 // Verify that "don't propagate" really still work
726 Assert.fail("calling doAaiGet when propagateExceptions is false must result with no exception", e);
730 // If no exception caught
731 // We're asserting that the legacy behaviour is still in place. Hopefully
732 // one day we will remove the non-propagateExceptions case
733 assertFalse(propagateExceptions, "calling doAaiGet when propagateExceptions is 'true' must result with an exception (in this test)");
737 public static Object[][] aaiClientGetCloudOwnerByCloudRegionId() {
739 final String cloudRegion = "{" +
740 " \"cloud-owner\": \"mure-royo-ru22\"," +
741 " \"cloud-region-id\": \"ravitu\"," +
742 " \"cloud-type\": \"openstack\"," +
743 " \"resource-version\": \"1523631256125\"," +
744 " \"relationship-list\": {" +
745 " \"relationship\": [{" +
746 " \"related-to\": \"pserver\"" +
752 String bodyWith0 = "{ \"cloud-region\": [" + " ]}";
753 String bodyWith1 = "{ \"cloud-region\": [" + cloudRegion + " ]}";
754 String bodyWith2 = "{ \"cloud-region\": [" + cloudRegion + ", " + cloudRegion + " ]}";
755 String bodyWithDifferent2 = "{ \"cloud-region\": [" + cloudRegion + ", " +
756 cloudRegion.replace("mure-royo-ru22", "nolay-umaxo") +
759 return new Object[][] {
760 { "regular single result", bodyWith1, false },
761 { "exceptional empty result", bodyWith0, true },
762 { "two same results", bodyWith2, false },
763 { "two incoherent results", bodyWithDifferent2, true },
767 @Test(dataProvider = "aaiClientGetCloudOwnerByCloudRegionId")
768 public void getCloudOwnerByCloudRegionIdNonCached(String desc, String body, boolean expectingException) {
769 final String cloudRegion = "ravitu";
770 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
771 final ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK, body);
772 when(aaiRestInterface.doRest(anyString(), anyString(), eq(Unchecked.toURI("cloud-infrastructure/cloud-regions?cloud-region-id=" + cloudRegion)),
773 isNull(), eq(HttpMethod.GET), anyBoolean(), anyBoolean()))
774 .thenReturn(responseWithRequestInfo);
776 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
779 final String result = aaiClient.getCloudOwnerByCloudRegionIdNonCached(cloudRegion);
780 if (expectingException) fail("expected failure on " + desc + ", got " + result);
782 assertThat(result, is("mure-royo-ru22"));
784 } catch (Exception e) {
785 if (!expectingException) throw e;
787 assertThat(e.toString(), either(
788 containsString("No cloud-owner found for " + cloudRegion))
789 .or(containsString("Conflicting cloud-owner found for " + cloudRegion)));
795 public static Object[][] cloudRegionAndTenantDataProvider() {
796 return new Object[][] {
797 { "APPC-24595-T-IST-02C", "mtn23b" },
798 { "APPC-24595-T-IST-02C", null },
805 public static Object[][] versionsDataProvider() {
806 return new Object[][] {
807 { Stream.of("20","10","30"), Stream.of("30","20","10"), "30" },
808 { Stream.of("10","20","20"), Stream.of("20","20","10"), "20" },
809 { Stream.of("c","b","a"), Stream.of("c","b","a"), "c" },
810 { Stream.of("1.0","2.0","1.8"), Stream.of("2.0","1.8","1.0"), "2.0" },
811 { Stream.of("1.0.7","2.0.9","2.0.2"), Stream.of("2.0.9","2.0.2","1.0.7"), "2.0.9" },
812 { Stream.of("0","0","0"), Stream.of("0","0","0"), "0" },
813 { Stream.of("","10"), Stream.of("10",""), "10" },
817 @Test(dataProvider = "versionsDataProvider")
818 public void sortedModelVer(Stream<String> input, Stream<String> expectedSorted, String expectedMax) {
819 Stream<ModelVer> modelVerStream = input.map(version -> {
820 ModelVer mv = new ModelVer();
821 mv.setModelVersion(version);
825 final AaiClient aaiClient = new AaiClient(null, null, null);
827 assertThat(aaiClient.sortedModelVer(modelVerStream),
829 expectedSorted.map(it -> hasProperty("modelVersion", is(it))).toArray(Matcher[]::new)
833 @Test(dataProvider = "versionsDataProvider")
834 public void maxModelVer(Stream<String> input, Stream<String> expectedSorted, String expectedMax) {
835 Stream<ModelVer> modelVerStream = input.map(version -> {
836 ModelVer mv = new ModelVer();
837 mv.setModelVersion(version);
841 final AaiClient aaiClient = new AaiClient(null, null, null);
843 assertThat(aaiClient.maxModelVer(modelVerStream), hasProperty("modelVersion", is(expectedMax)));
846 @Test(expectedExceptions = GenericUncheckedException.class)
847 public void maxModelVerException() {
848 final AaiClient aaiClient = new AaiClient(null, null, null);
849 aaiClient.maxModelVer(Stream.of(new ModelVer()));
851 @Test(dataProvider = "cloudRegionAndTenantDataProvider")
852 public void getCloudRegionAndTenantByVnfId(String tenantName, String cloudRegionId) throws JsonProcessingException {
853 SimpleResult tenant = new SimpleResult();
854 if (tenantName != null) {
855 tenant.setJsonNodeType("tenant");
856 Properties tenantProps = new Properties();
857 tenantProps.setTenantName(tenantName);
858 tenant.setJsonProperties(tenantProps);
861 SimpleResult cloudRegion = new SimpleResult();
862 if (cloudRegionId != null) {
863 cloudRegion.setJsonNodeType("cloud-region");
864 Properties cloudRegionProps = new Properties();
865 cloudRegionProps.setCloudRegionId(cloudRegionId);
866 cloudRegion.setJsonProperties(cloudRegionProps);
869 CustomQuerySimpleResult customQuerySimpleResult = new CustomQuerySimpleResult(ImmutableList.of(tenant, cloudRegion));
870 String mockedBody = new ObjectMapper().writeValueAsString(customQuerySimpleResult);
872 AAIRestInterface aaiRestInterface = mock(AAIRestInterface.class);
873 final ResponseWithRequestInfo responseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK, mockedBody, "query?format=simple", HttpMethod.PUT);
874 when(aaiRestInterface.doRest(anyString(), anyString(), eq(Unchecked.toURI("query?format=simple")),
875 any(), eq(HttpMethod.PUT), anyBoolean(), anyBoolean()))
876 .thenReturn(responseWithRequestInfo);
878 final AaiClient aaiClient = new AaiClient(aaiRestInterface, null, null);
879 Map<String, Properties> result = aaiClient.getCloudRegionAndTenantByVnfId("anyVnfId");
880 if (tenantName != null) {
881 assertEquals(result.get("tenant").getTenantName(), tenantName);
883 assertNull(result.get("tenant"));
886 if (cloudRegionId != null) {
887 assertEquals(result.get("cloud-region").getCloudRegionId(), cloudRegionId);
889 assertNull(result.get("cloud-region"));
893 protected void mockForGetRequest(AAIRestInterface aaiRestInterface, ResponseWithRequestInfo responseWithRequestInfo) {
894 when(aaiRestInterface.doRest(anyString(), anyString(), any(URI.class), isNull(), eq(HttpMethod.GET) ,anyBoolean(), anyBoolean()))
895 .thenReturn(responseWithRequestInfo);
899 public void shouldProperlyReadResponseOnceWhenSubscribersAreNotPresent() {
900 AAIRestInterface restInterface = mock(AAIRestInterface.class);
901 PortDetailsTranslator portDetailsTranslator = mock(PortDetailsTranslator.class);
902 Response response = mock(Response.class);
903 when(response.getStatus()).thenReturn(404);
904 when(response.readEntity(String.class)).thenReturn("sampleEntity");
905 when(response.getStatusInfo()).thenReturn(Response.Status.NOT_FOUND);
906 ResponseWithRequestInfo responseWithRequestInfo = new ResponseWithRequestInfo(response, "test", HttpMethod.GET);
907 when(restInterface.RestGet(eq("VidAaiController"), any(String.class),
908 eq(Unchecked.toURI("business/customers?subscriber-type=INFRA&depth=0")), eq(false), eq(true))).thenReturn(responseWithRequestInfo);
909 AaiClient aaiClient = new AaiClient(restInterface, portDetailsTranslator, null);
912 aaiClient.getAllSubscribers(true);
914 verify(response).readEntity(String.class);
918 public interface UncheckedBiConsumer<T, U> extends BiConsumer<T, U> {
920 default void accept(T t, U u) {
923 } catch (Exception e) {
924 throw new RuntimeException(e);
928 void acceptThrows(T t, U u) throws Exception;
932 public void getLatestVersionByInvariantId_verifyCallingExpectedApi(){
934 when(aaiClientMock.getLatestVersionByInvariantId(anyString())).thenCallRealMethod();
936 aaiClientMock.getLatestVersionByInvariantId("model-invariant-id");
938 Mockito.verify(aaiClientMock).doAaiPut(argThat(url -> url.endsWith("query?format=resource&depth=0")),argThat(payload -> payload.contains("service-design-and-creation/models/model/model-invariant-id")),anyBoolean());
943 public static Object[][] getSubscriberDataDataProvider() {
944 return new Object[][] {
946 { "another id 123", false },
950 @Test(dataProvider = "getSubscriberDataDataProvider")
951 public void getSubscriberDataParams(String subscriberId, boolean omitServiceInstances) {
952 String depth = omitServiceInstances ? "1" : "2";
953 when(aaiClientMock.getSubscriberData(anyString(),anyBoolean())).thenCallRealMethod();
954 aaiClientMock.getSubscriberData(subscriberId, omitServiceInstances);
955 Mockito.verify(aaiClientMock).doAaiGet(argThat(s -> s.contains("customer/" + subscriberId + "?") && s.contains("depth=" + depth)),any(Boolean.class));
960 public static Object[][] aaiDSLPutServiceInstanceQueryData() {
961 return new Object[][] {
962 {"SOME_GLOBAL_CUST_ID", "Service Instance Id", "SOME_SERVICE_INSTANCE_ID",
963 dslQueryPayloadByServiceInstanceId, responseJsonDSLServiceInstance, "SOME_SERVICE_INSTANCE_ID", 200},
964 {"SOME_GLOBAL_CUST_ID", "Service Instance Name", "SOME_SERVICE_INSTANCE_NAME",
965 dslQueryPayloadByServiceInstanceName, responseJsonDSLServiceInstance, "SOME_SERVICE_INSTANCE_ID", 200},
966 {"SOME_GLOBAL_CUST_ID", "Service Instance Name", "SOME_SERVICE_INSTANCE_NAME",
967 dslQueryPayloadByServiceInstanceName, responseJsonDSLServiceInstance, "SOME_SERVICE_INSTANCE_ID",200},
972 @Test(dataProvider = "aaiDSLPutServiceInstanceQueryData")
973 public void testAaiDSLPutServiceInstanceQueryByParams( String globalCustomerId,
974 String identifierType,
976 String expectedPayload,
979 int responseHttpCode) {
981 String queryFormat = "dsl?format=resource&nodesOnly=true&depth=0&as-tree=true";
983 final ResponseWithRequestInfo mockedResponseWithRequestInfo = mockedResponseWithRequestInfo(Response.Status.OK,
984 TestUtils.readFileAsString(responseBody),
985 "dsl?format=resource&nodesOnly=true&depth=0&as-tree=true&Mock=True",
988 when(aaiClientMock.doAaiPut(eq(queryFormat), anyString(), anyBoolean(), anyBoolean())).thenReturn(mockedResponseWithRequestInfo);
989 when(aaiClientMock.getServiceInstanceBySubscriberIdAndInstanceIdentifier(anyString(), anyString(), anyString())).thenCallRealMethod();
991 AaiResponse<DSLQuerySimpleResponse> response = aaiClientMock.getServiceInstanceBySubscriberIdAndInstanceIdentifier(globalCustomerId, identifierType, identifier);
993 verify(aaiClientMock).doAaiPut(eq(queryFormat), eq(expectedPayload), eq(false), eq(false));
995 assertEquals(response.getHttpCode(), responseHttpCode);
996 assertEquals(response.getT().getResults().get(0).getCustomer().getCustomerRelatedNodes().get(0).getCustomerServiceSubscription().
997 getServiceSubscriptionRelatedNodes().get(0).getServiceInstance().serviceInstanceId, expectedSiId);
999 assertEquals(response.getT().getResults().get(0).getCustomer().getSubscriberName(), "Mobility");
1001 assertEquals(response.getT().getResults().get(0).getCustomer().getCustomerRelatedNodes().get(0).getCustomerServiceSubscription().
1002 getServiceSubscriptionRelatedNodes().get(0).getServiceInstance().orchestrationStatus, "SOME_ORCH_STATUS");
1007 public void testToModelVerStream() throws IOException {
1009 ModelVersions modelVersions = JACKSON_OBJECT_MAPPER.readValue("" +
1011 " \"results\": [\n" +
1014 " \"model-invariant-id\": \"f6342be5-d66b-4d03-a1aa-c82c3094c4ea\",\n" +
1015 " \"model-type\": \"service\",\n" +
1016 " \"resource-version\": \"1534274421300\"\n" +
1020 " \"model-ver\": {\n" +
1021 " \"model-version-id\": \"a92f899d-a3ec-465b-baed-1663b0a5aee1\",\n" +
1022 " \"model-name\": \"NCM_VLAN_SVC_ym161f\",\n" +
1023 " \"model-version\": \"bbb\",\n" +
1024 " \"distribution-status\": \"DISTRIBUTION_COMPLETE_OK\",\n" +
1025 " \"model-description\": \"Network Collection service for vLAN tagging\",\n" +
1026 " \"resource-version\": \"1534788756086\"\n" +
1030 " \"model-ver\": {\n" +
1031 " \"model-version-id\": \"d2fda667-e92e-4cfa-9620-5da5de01a319\",\n" +
1032 " \"model-name\": \"NCM_VLAN_SVC_ym161f\",\n" +
1033 " \"model-version\": \"aaa\",\n" +
1034 " \"distribution-status\": \"DISTRIBUTION_COMPLETE_OK\",\n" +
1035 " \"model-description\": \"Network Collection service for vLAN tagging\",\n" +
1036 " \"resource-version\": \"1534444087221\"\n" +
1038 " }]}", ModelVersions.class);
1041 final AaiClient aaiClient = new AaiClient(null, null, null);
1043 assertThat(aaiClient.toModelVerStream(modelVersions).collect(toList()),
1045 hasProperty("modelVersionId", is("a92f899d-a3ec-465b-baed-1663b0a5aee1")),
1046 hasProperty("modelVersionId", is("d2fda667-e92e-4cfa-9620-5da5de01a319"))