vid-app-common/src/test/java/org/onap/vid/mso/MsoBusinessLogicImplTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.vid.mso;
  23
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
  26 import static org.assertj.core.api.Assertions.tuple;
  27 import static org.hamcrest.Matchers.allOf;
  28 import static org.hamcrest.Matchers.containsString;
  29 import static org.hamcrest.Matchers.equalTo;
  30 import static org.hamcrest.Matchers.hasEntry;
  31 import static org.hamcrest.Matchers.instanceOf;
  32 import static org.hamcrest.Matchers.is;
  33 import static org.hamcrest.Matchers.startsWith;
  34 import static org.junit.Assert.assertEquals;
  35 import static org.mockito.ArgumentMatchers.any;
  36 import static org.mockito.ArgumentMatchers.anyBoolean;
  37 import static org.mockito.ArgumentMatchers.anyString;
  38 import static org.mockito.ArgumentMatchers.argThat;
  39 import static org.mockito.ArgumentMatchers.endsWith;
  40 import static org.mockito.ArgumentMatchers.eq;
  41 import static org.mockito.ArgumentMatchers.isA;
  42 import static org.mockito.BDDMockito.given;
  43 import static org.mockito.Mockito.doThrow;
  44 import static org.mockito.Mockito.mock;
  45 import static org.mockito.Mockito.verify;
  46 import static org.mockito.Mockito.when;
  47 import static org.onap.vid.controller.MsoController.CONFIGURATION_ID;
  48 import static org.onap.vid.controller.MsoController.REQUEST_TYPE;
  49 import static org.onap.vid.controller.MsoController.SVC_INSTANCE_ID;
  50 import static org.onap.vid.controller.MsoController.VNF_INSTANCE_ID;
  51 import static org.onap.vid.model.probes.ExternalComponentStatus.Component.MSO;
  52 import static org.onap.vid.mso.MsoBusinessLogicImpl.validateEndpointPath;
  53
  54 import com.fasterxml.jackson.core.type.TypeReference;
  55 import com.fasterxml.jackson.databind.ObjectMapper;
  56 import io.joshworks.restclient.http.HttpResponse;
  57 import java.io.IOException;
  58 import java.net.URL;
  59 import java.nio.file.Path;
  60 import java.nio.file.Paths;
  61 import java.util.ArrayList;
  62 import java.util.HashMap;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.UUID;
  66 import java.util.stream.Collectors;
  67 import javax.ws.rs.BadRequestException;
  68 import org.apache.commons.io.IOUtils;
  69 import org.apache.http.HttpException;
  70 import org.hamcrest.Matcher;
  71 import org.hamcrest.MatcherAssert;
  72 import org.jetbrains.annotations.NotNull;
  73 import org.mockito.ArgumentMatcher;
  74 import org.mockito.Mock;
  75 import org.mockito.Mockito;
  76 import org.mockito.MockitoAnnotations;
  77 import org.mockito.hamcrest.MockitoHamcrest;
  78 import org.onap.portalsdk.core.util.SystemProperties;
  79 import org.onap.vid.aai.ExceptionWithRequestInfo;
  80 import org.onap.vid.aai.HttpResponseWithRequestInfo;
  81 import org.onap.vid.changeManagement.ChangeManagementRequest;
  82 import org.onap.vid.changeManagement.WorkflowRequestDetail;
  83 import org.onap.vid.controller.OperationalEnvironmentController;
  84 import org.onap.vid.exceptions.GenericUncheckedException;
  85 import org.onap.vid.model.SOWorkflowList;
  86 import org.onap.vid.model.SoftDeleteRequest;
  87 import org.onap.vid.model.probes.ErrorMetadata;
  88 import org.onap.vid.model.probes.ExternalComponentStatus;
  89 import org.onap.vid.model.probes.HttpRequestMetadata;
  90 import org.onap.vid.mso.model.CloudConfiguration;
  91 import org.onap.vid.mso.model.ModelInfo;
  92 import org.onap.vid.mso.model.OperationalEnvironmentActivateInfo;
  93 import org.onap.vid.mso.model.OperationalEnvironmentDeactivateInfo;
  94 import org.onap.vid.mso.model.RequestInfo;
  95 import org.onap.vid.mso.model.RequestParameters;
  96 import org.onap.vid.mso.rest.OperationalEnvironment.OperationEnvironmentRequestDetails;
  97 import org.onap.vid.mso.rest.Request;
  98 import org.onap.vid.mso.rest.RequestDetails;
  99 import org.onap.vid.mso.rest.RequestDetailsWrapper;
 100 import org.onap.vid.mso.rest.Task;
 101 import org.onap.vid.testUtils.TestUtils;
 102 import org.springframework.http.HttpMethod;
 103 import org.springframework.http.HttpStatus;
 104 import org.springframework.test.context.ContextConfiguration;
 105 import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
 106 import org.testng.annotations.BeforeClass;
 107 import org.testng.annotations.DataProvider;
 108 import org.testng.annotations.Test;
 109
 110 @ContextConfiguration(classes = {SystemProperties.class})
 111 public class MsoBusinessLogicImplTest extends AbstractTestNGSpringContextTests {
 112
 113     private static final ObjectMapper objectMapper = new ObjectMapper();
 114     private static final String MY_PRETTY_URL = "my pretty url";
 115
 116     @Mock
 117     private MsoInterface msoInterface;
 118
 119     @Mock
 120     private SOWorkflowList workflowList;
 121
 122     @Mock
 123     private HttpResponse<SOWorkflowList> workflowListResponse;
 124
 125     @Mock
 126     private RequestDetails msoRequest;
 127
 128
 129     private MsoBusinessLogicImpl msoBusinessLogic;
 130     private String userId = "testUserId";
 131     private String operationalEnvironmentId = "testOperationalEnvironmentId";
 132
 133     @BeforeClass
 134     public void setUp() {
 135         MockitoAnnotations.initMocks(this);
 136         msoBusinessLogic = new MsoBusinessLogicImpl(msoInterface);
 137     }
 138
 139     @Test
 140     public void shouldProperlyCreateConfigurationInstanceWithCorrectServiceInstanceId() throws Exception {
 141         // given
 142         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 143         String endpointTemplate = String.format("/serviceInstances/v6/%s/configurations", serviceInstanceId);
 144         RequestDetailsWrapper requestDetailsWrapper = createRequestDetails();
 145         MsoResponseWrapper expectedResponse = createOkResponse();
 146         given(msoInterface.createConfigurationInstance(requestDetailsWrapper, endpointTemplate))
 147                 .willReturn(expectedResponse);
 148
 149         // when
 150         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 151                 .createConfigurationInstance(requestDetailsWrapper, serviceInstanceId);
 152
 153         // then
 154         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedResponse);
 155     }
 156
 157     private RequestDetailsWrapper createRequestDetails() throws Exception {
 158         final URL resource = this.getClass().getResource("/payload_jsons/mso_request_create_configuration.json");
 159         RequestDetails requestDetails = objectMapper.readValue(resource, RequestDetails.class);
 160         return new RequestDetailsWrapper(requestDetails);
 161     }
 162
 163     @Test
 164     public void shouldProperlyValidateEndpointPathWheEendPointIsNotEmptyAndValid() {
 165         System.setProperty("TestEnv", "123");
 166         String foundEndPoint = validateEndpointPath("TestEnv");
 167         assertEquals("123", foundEndPoint);
 168     }
 169
 170     @Test
 171     public void shouldThrowRuntimeExceptionWhenValidateEndpointPathEndPointIsNotEmptyAndValid() {
 172         assertThatExceptionOfType(RuntimeException.class)
 173                 .isThrownBy(() -> validateEndpointPath("NotExists"));
 174     }
 175
 176     @Test
 177     public void shouldThrowRuntimeExceptionWhenValidateEndpointPathWhenEndPointIsNotEmptyButDoesntExists() {
 178         String endPoint = "EmptyEndPoint";
 179         System.setProperty(endPoint, "");
 180         assertThatExceptionOfType(GenericUncheckedException.class)
 181                 .isThrownBy(() -> validateEndpointPath(endPoint))
 182                 .withMessage(endPoint + " env variable is not defined");
 183     }
 184
 185     @Test
 186     public void shouldProperlyCreateSvcInstanceWithProperParameters() {
 187
 188         MsoResponseWrapper expectedResponse = createOkResponse();
 189         String svcEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_SVC_INSTANCE);
 190         given(msoInterface.createSvcInstance(msoRequest, svcEndpoint)).willReturn(expectedResponse);
 191
 192         MsoResponseWrapper response = msoBusinessLogic.createSvcInstance(msoRequest);
 193
 194         // then
 195         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 196     }
 197
 198     @Test
 199     public void shouldProperlyCreateE2eSvcInstanceWithProperParameters() {
 200         //  given
 201         MsoResponseWrapper expectedResponse = createOkResponse();
 202         String svcEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE);
 203         given(msoInterface.createE2eSvcInstance(msoRequest, svcEndpoint)).willReturn(expectedResponse);
 204
 205         //  when
 206         MsoResponseWrapper response = msoBusinessLogic.createE2eSvcInstance(msoRequest);
 207
 208         // then
 209         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 210     }
 211
 212     @Test
 213     public void shouldProperlyCreateVnfWithProperParameters() {
 214
 215         MsoResponseWrapper expectedResponse = createOkResponse();
 216         String endpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 217         String vnfInstanceId = "testVnfInstanceTempId";
 218         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, vnfInstanceId);
 219
 220         given(msoInterface.createVnf(msoRequest, vnfEndpoint)).willReturn(expectedResponse);
 221
 222         MsoResponseWrapper response = msoBusinessLogic.createVnf(msoRequest, vnfInstanceId);
 223
 224         // then
 225         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 226     }
 227
 228     @Test
 229     public void shouldProperlyCreateNwInstanceWithProperParameters() {
 230
 231         MsoResponseWrapper expectedResponse = createOkResponse();
 232         String vnfInstanceId = "testNwInstanceTempId";
 233         String nwEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 234         String nw_endpoint = nwEndpoint.replaceFirst(SVC_INSTANCE_ID, vnfInstanceId);
 235
 236         given(msoInterface.createNwInstance(msoRequest, nw_endpoint)).willReturn(expectedResponse);
 237
 238         MsoResponseWrapper response = msoBusinessLogic.createNwInstance(msoRequest, vnfInstanceId);
 239
 240         // then
 241         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 242     }
 243
 244     @Test
 245     public void shouldProperlyCreateVolumeGroupInstanceWithProperParameters() {
 246         MsoResponseWrapper expectedResponse = createOkResponse();
 247         String serviceInstanceId = "testServiceInstanceTempId";
 248         String vnfInstanceId = "testVnfInstanceTempId";
 249         String nwEndpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 250         String vnfEndpoint = nwEndpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 251         vnfEndpoint = vnfEndpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 252
 253         given(msoInterface.createVolumeGroupInstance(msoRequest, vnfEndpoint)).willReturn(expectedResponse);
 254
 255         MsoResponseWrapper response = msoBusinessLogic.createVolumeGroupInstance(msoRequest, serviceInstanceId, vnfInstanceId);
 256
 257         // then
 258         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 259     }
 260
 261     @Test
 262     public void shouldProperlyCreateVfModuleInstanceWithProperParameters() {
 263         MsoResponseWrapper expectedResponse = createOkResponse();
 264         String serviceInstanceId = "testServiceInstanceTempId";
 265         String vnfInstanceId = "testVnfInstanceTempId";
 266         String partial_endpoint = SystemProperties.getProperty(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 267         String vf_module_endpoint = partial_endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 268         vf_module_endpoint = vf_module_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 269
 270         given(msoInterface.createVfModuleInstance(msoRequest, vf_module_endpoint)).willReturn(expectedResponse);
 271
 272         MsoResponseWrapper response = msoBusinessLogic.createVfModuleInstance(msoRequest, serviceInstanceId, vnfInstanceId);
 273
 274         // then
 275         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 276     }
 277
 278     @Test
 279     public void shouldProperlyDeleteE2eSvcInstanceWithProperParameters() {
 280         MsoResponseWrapper expectedResponse = createOkResponse();
 281         String serviceInstanceId = "testDeleteE2eSvcInstanceTempId";
 282         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_E2E_SVC_INSTANCE) + "/" + serviceInstanceId;
 283
 284         given(msoInterface.deleteE2eSvcInstance(msoRequest, endpoint)).willReturn(expectedResponse);
 285
 286         MsoResponseWrapper response = msoBusinessLogic.deleteE2eSvcInstance(msoRequest, serviceInstanceId);
 287
 288         // then
 289         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 290     }
 291
 292     @DataProvider
 293     public Object[][] deleteSvcInstanceShouldDelete() {
 294         return new Object[][]{{"Active"}, {"unexpected-status"}};
 295     }
 296
 297     @DataProvider
 298     public Object[][] deleteSvcInstanceShouldUnassign() {
 299         return new Object[][]{{"Created"}, {"Pendingdelete"}, {"pending-Delete"}, {"Assigned"}};
 300     }
 301
 302
 303     @Test(dataProvider = "deleteSvcInstanceShouldDelete")
 304     public void shouldProperlyDeleteSvcInstanceWithProperParametersShouldDelete(String status) {
 305         // given
 306         String endpointTemplate = "/serviceInstantiation/v7/serviceInstances/%s";
 307         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 308         String svcEndpoint = String.format(endpointTemplate, serviceInstanceId);
 309         RequestDetails requestDetails = new RequestDetails();
 310         MsoResponseWrapper expectedResponse = createOkResponse();
 311         given(msoInterface.deleteSvcInstance(requestDetails, svcEndpoint)).willReturn(expectedResponse);
 312
 313         // when
 314         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 315                 .deleteSvcInstance(requestDetails, serviceInstanceId, status);
 316
 317         // then
 318         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedResponse);
 319     }
 320
 321     @Test(dataProvider = "deleteSvcInstanceShouldUnassign")
 322     public void shouldProperlyDeleteSvcInstanceWithProperParametersShouldUnassign(String status) {
 323         // given
 324         String endpointTemplate = "/serviceInstantiation/v7/serviceInstances/%s/unassign";
 325         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 326         String svcEndpoint = String.format(endpointTemplate, serviceInstanceId);
 327         RequestDetails requestDetails = new RequestDetails();
 328         MsoResponseWrapper expectedResponse = createOkResponse();
 329         given(msoInterface.unassignSvcInstance(requestDetails, svcEndpoint)).willReturn(expectedResponse);
 330
 331         // when
 332         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 333                 .deleteSvcInstance(requestDetails, serviceInstanceId, status);
 334
 335         // then
 336         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedResponse);
 337     }
 338
 339     @Test
 340     public void shouldProperlyDeleteVnfWithProperParameters() {
 341         // when
 342         String endpointTemplate = "/serviceInstantiation/v7/serviceInstances/%s/vnfs/%s";
 343         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 344         String vnfInstanceId = "testVnfInstanceTempId";
 345         String vnfEndpoint = String.format(endpointTemplate, serviceInstanceId, vnfInstanceId);
 346         RequestDetails requestDetails = new RequestDetails();
 347         MsoResponseWrapper expectedResponse = createOkResponse();
 348         given(msoInterface.deleteVnf(requestDetails, vnfEndpoint)).willReturn(expectedResponse);
 349
 350         // when
 351         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 352                 .deleteVnf(requestDetails, serviceInstanceId, vnfInstanceId);
 353
 354         // then
 355         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedResponse);
 356     }
 357
 358     @Test
 359     public void shouldProperlyDeleteVfModuleWithProperParameters() {
 360         // when
 361         String endpointTemplate = "/serviceInstantiation/v7/serviceInstances/%s/vnfs/%s/vfModules/%s";
 362         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 363         String vnfInstanceId = "testVnfInstanceTempId";
 364         String vfModuleId = "testVfModuleId";
 365         String vnfEndpoint = String.format(endpointTemplate, serviceInstanceId, vnfInstanceId, vfModuleId);
 366         RequestDetails requestDetails = new RequestDetails();
 367         MsoResponseWrapper expectedResponse = createOkResponse();
 368         given(msoInterface.deleteVfModule(requestDetails, vnfEndpoint)).willReturn(expectedResponse);
 369
 370         // when
 371         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 372                 .deleteVfModule(requestDetails, serviceInstanceId, vnfInstanceId, vfModuleId);
 373         // then
 374         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedResponse);
 375     }
 376
 377     @Test
 378     public void shouldProperlyDeleteVolumeGroupInstanceWithProperParameters() {
 379         MsoResponseWrapper expectedResponse = createOkResponse();
 380         String serviceInstanceId = "testServiceInstanceTempId";
 381         String vnfInstanceId = "testVnfInstanceTempId";
 382         String volumeGroupId = "testvolumeGroupIdTempId";
 383
 384         String deleteVolumeGroupEndpoint = getDeleteVolumeGroupEndpoint(serviceInstanceId, vnfInstanceId, volumeGroupId);
 385
 386         given(msoInterface.deleteVolumeGroupInstance(msoRequest, deleteVolumeGroupEndpoint)).willReturn(expectedResponse);
 387
 388         MsoResponseWrapper response = msoBusinessLogic.deleteVolumeGroupInstance(msoRequest, serviceInstanceId, vnfInstanceId, volumeGroupId);
 389
 390         // then
 391         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 392     }
 393
 394     @NotNull
 395     private String getDeleteVolumeGroupEndpoint(String serviceInstanceId, String vnfInstanceId, String volumeGroupId) {
 396         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VOLUME_GROUP_INSTANCE);
 397         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 398         String vnfEndpoint = svc_endpoint.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 399         return vnfEndpoint + "/" + volumeGroupId;
 400     }
 401
 402     @Test
 403     public void shouldProperlyDeleteNwInstanceWithProperParameters() {
 404         MsoResponseWrapper expectedResponse = createOkResponse();
 405         String serviceInstanceId = "testServiceInstanceTempId";
 406         String networkInstanceId = "testNetworkInstanceTempId";
 407
 408         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_NETWORK_INSTANCE);
 409         String svc_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 410         String delete_nw_endpoint = svc_endpoint + "/" + networkInstanceId;
 411
 412         given(msoInterface.deleteNwInstance(msoRequest, delete_nw_endpoint)).willReturn(expectedResponse);
 413
 414         MsoResponseWrapper response = msoBusinessLogic.deleteNwInstance(msoRequest, serviceInstanceId, networkInstanceId);
 415
 416         // then
 417         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 418     }
 419
 420     @Test
 421     public void shouldProperlyGetOrchestrationRequestWithProperParameters() {
 422         MsoResponseWrapper expectedResponse = createOkResponse();
 423         String requestId = "testRequestTempId";
 424         String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
 425         String path = p + "/" + requestId;
 426
 427         given(msoInterface.getOrchestrationRequest(path)).willReturn(expectedResponse);
 428
 429         MsoResponseWrapper response = msoBusinessLogic.getOrchestrationRequest(requestId);
 430         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 431     }
 432
 433     @Test(expectedExceptions = MsoTestException.class)
 434     public void shouldProperlyGetOrchestrationRequestWithWrongParameters() {
 435         String requestId = "testWrongRequestTempId";
 436         String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQ);
 437         String path = p + "/" + requestId;
 438
 439         given(msoInterface.getOrchestrationRequest(path)).willThrow(new MsoTestException("testException"));
 440
 441         msoBusinessLogic.getOrchestrationRequest(requestId);
 442     }
 443
 444     @Test
 445     public void shouldProperlyGetOrchestrationRequestsWithProperParameters() {
 446         MsoResponseWrapper expectedResponse = createOkResponse();
 447         String filterString = "testRequestsTempId";
 448         String url = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 449         String path = url + filterString;
 450
 451         given(msoInterface.getOrchestrationRequest(path)).willReturn(expectedResponse);
 452
 453         MsoResponseWrapper response = msoBusinessLogic.getOrchestrationRequests(filterString);
 454         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 455     }
 456
 457     @Test(expectedExceptions = MsoTestException.class)
 458     public void shouldThrowExceptionWhenGetOrchestrationRequestsWithWrongParameters() {
 459         String filterString = "testRequestsTempId";
 460         String p = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_ORC_REQS);
 461         String path = p + filterString;
 462
 463         given(msoInterface.getOrchestrationRequest(path)).willThrow(new MsoTestException("testException"));
 464
 465         msoBusinessLogic.getOrchestrationRequests(filterString);
 466     }
 467
 468     @Test
 469     public void shouldSendProperScaleOutRequest() throws IOException {
 470         // given
 471         String serviceInstanceId = "3f93c7cb-2fd0-4557-9514-e189b7b04f9d";
 472         String vnfInstanceId = "testVnfInstanceTempId";
 473         String endpointTemplate = "/serviceInstantiation/v7/serviceInstances/%s/vnfs/%s/vfModules/scaleOut";
 474         String vnfEndpoint = String.format(endpointTemplate, serviceInstanceId, vnfInstanceId);
 475         org.onap.vid.changeManagement.RequestDetails requestDetails = readRequest();
 476         org.onap.vid.changeManagement.RequestDetailsWrapper<org.onap.vid.changeManagement.RequestDetails> expectedRequest = readExpectedRequest();
 477         MsoResponseWrapper expectedMsoResponseWrapper = createOkResponse();
 478         given(
 479                 msoInterface
 480                         .scaleOutVFModuleInstance(argThat(new MsoRequestWrapperMatcher(expectedRequest)),
 481                                 eq(vnfEndpoint)))
 482                 .willReturn(expectedMsoResponseWrapper);
 483
 484         // when
 485         MsoResponseWrapper msoResponseWrapper = msoBusinessLogic
 486                 .scaleOutVfModuleInstance(requestDetails, serviceInstanceId, vnfInstanceId);
 487
 488         // then
 489         assertThat(msoResponseWrapper).isEqualToComparingFieldByField(expectedMsoResponseWrapper);
 490     }
 491
 492     private org.onap.vid.changeManagement.RequestDetails readRequest() throws IOException {
 493         Path path = Paths.get("payload_jsons", "scaleOutVfModulePayload.json");
 494         URL url = this.getClass().getClassLoader().getResource(path.toString());
 495         return objectMapper.readValue(url, org.onap.vid.changeManagement.RequestDetails.class);
 496     }
 497
 498     private org.onap.vid.changeManagement.RequestDetailsWrapper<org.onap.vid.changeManagement.RequestDetails> readExpectedRequest()
 499             throws IOException {
 500         Path path = Paths.get("payload_jsons", "scaleOutVfModulePayloadToMso.json");
 501         URL url = this.getClass().getClassLoader().getResource(path.toString());
 502         return objectMapper.readValue(url,
 503                 new TypeReference<org.onap.vid.changeManagement.RequestDetailsWrapper<org.onap.vid.changeManagement.RequestDetails>>() {
 504                 });
 505     }
 506
 507
 508     @Test
 509     public void shouldFilterOutOrchestrationRequestsNotAllowedInDashboard() throws Exception {
 510         //given
 511         String vnfModelTypeOrchestrationRequests = getFileContentAsString("mso_model_info_sample_response.json");
 512         String scaleOutActionOrchestrationRequests = getFileContentAsString("mso_action_scaleout_sample_response.json");
 513
 514         HttpResponse<String> httpResponse = mockForGetOrchestrationRequest();
 515         given(httpResponse.getBody())
 516                 .willReturn(vnfModelTypeOrchestrationRequests, scaleOutActionOrchestrationRequests);
 517
 518         //when
 519         List<Request> filteredOrchestrationReqs = msoBusinessLogic.getOrchestrationRequestsForDashboard();
 520         //then
 521         assertThat(filteredOrchestrationReqs).hasSize(3);
 522         assertThat(MsoBusinessLogicImpl.DASHBOARD_ALLOWED_TYPES)
 523                 .containsAll(filteredOrchestrationReqs
 524                         .stream()
 525                         .map(el -> el.getRequestType().toUpperCase())
 526                         .collect(Collectors.toList()));
 527         assertThat(filteredOrchestrationReqs)
 528                 .extracting(Request::getRequestScope)
 529                 .containsOnly("vnf", "vfModule");
 530     }
 531
 532     @Test(expectedExceptions = GenericUncheckedException.class)
 533     public void shouldThrowGenericUncheckedExceptionWhenGetOrchestrationRequestsForDashboardWithWrongJsonFile_() throws Exception {
 534         //given
 535         String vnfModelTypeOrchestrationRequests = getFileContentAsString("mso_model_info_sample_wrong_response.json");
 536
 537         mockForGetOrchestrationRequest(200, vnfModelTypeOrchestrationRequests);
 538
 539         //when
 540         msoBusinessLogic.getOrchestrationRequestsForDashboard();
 541     }
 542
 543     @Test
 544     public void shouldProperlyGetManualTasksByRequestIdWithProperParameters() throws Exception {
 545         //given
 546         String manualTasksList = getFileContentAsString("manual_tasks_by_requestId_test.json");
 547
 548         MsoResponseWrapper msoResponseWrapperMock = mock(MsoResponseWrapper.class);
 549         given(msoInterface
 550                 .getManualTasksByRequestId(any(String.class), any(String.class), any(String.class),
 551                         any(RestObject.class)))
 552                 .willReturn(msoResponseWrapperMock);
 553         given(msoResponseWrapperMock.getEntity())
 554                 .willReturn(manualTasksList);
 555
 556         //when
 557         List<Task> filteredOrchestrationReqs = msoBusinessLogic.getManualTasksByRequestId("TestId");
 558
 559         //then
 560         assertThat(filteredOrchestrationReqs).hasSize(2);
 561         assertThat(filteredOrchestrationReqs).extracting("taskId", "type").
 562                 contains(
 563                         tuple("123123abc", "testTask"),
 564                         tuple("321321abc", "testTask")
 565                 );
 566     }
 567
 568     @Test(expectedExceptions = GenericUncheckedException.class)
 569     public void shouldThrowGenericUncheckedExceptionWhenGetManualTasksByRequestIdWithWrongJsonFile() throws Exception {
 570         //given
 571         String manualTasksList = getFileContentAsString("manual_tasks_by_requestId_wrongJson_test.json");
 572
 573         MsoResponseWrapper msoResponseWrapperMock = mock(MsoResponseWrapper.class);
 574         given(msoInterface
 575                 .getManualTasksByRequestId(any(String.class), any(String.class), any(String.class),
 576                         any(RestObject.class)))
 577                 .willReturn(msoResponseWrapperMock);
 578         given(msoResponseWrapperMock.getEntity())
 579                 .willReturn(manualTasksList);
 580
 581         //when
 582         msoBusinessLogic.getManualTasksByRequestId("TestId");
 583     }
 584
 585     @Test(expectedExceptions = MsoTestException.class)
 586     public void getManualTasksByRequestIdWithArgument_shouldThrowException() {
 587         //given
 588         given(msoInterface
 589                 .getManualTasksByRequestId(any(String.class), any(String.class), any(String.class),
 590                         any(RestObject.class)))
 591                 .willThrow(MsoTestException.class);
 592
 593         //when
 594         msoBusinessLogic.getManualTasksByRequestId("TestId");
 595     }
 596
 597     @Test
 598     public void shouldProperlyCompleteManualTaskWithProperParameters() {
 599         //given
 600         MsoResponseWrapper expectedResponse = createOkResponse();
 601         RequestDetails requestDetails = new RequestDetails();
 602         String taskId = "testTaskId";
 603
 604         String url = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 605         String path = url + "/" + taskId + "/complete";
 606
 607         given(msoInterface.completeManualTask(eq(requestDetails), any(String.class), any(String.class), eq(path), any(RestObject.class))).willReturn(expectedResponse);
 608
 609         //when
 610         MsoResponseWrapper response = msoBusinessLogic.completeManualTask(requestDetails, taskId);
 611
 612         //then
 613         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 614
 615     }
 616
 617     @Test
 618     public void shouldProperlyActivateServiceInstanceWithProperParameters() {
 619         //given
 620         RequestDetails detail = new RequestDetails();
 621         String taskId = "testTaskId";
 622
 623         RestObject<String> restObjStr = new RestObject<>();
 624         restObjStr.set("");
 625         MsoResponseWrapper expectedResponse = MsoUtil.wrapResponse(restObjStr);
 626
 627         //when
 628         MsoResponseWrapper response = msoBusinessLogic.activateServiceInstance(detail, taskId);
 629
 630         //then
 631         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 632
 633     }
 634
 635     @Test(expectedExceptions = MsoTestException.class)
 636     public void shouldThrowExceptionWhenManualTaskWithWrongParameters() {
 637         //given
 638         RequestDetails requestDetails = new RequestDetails();
 639         String taskId = "";
 640
 641         String url = SystemProperties.getProperty(MsoProperties.MSO_REST_API_GET_MAN_TASKS);
 642         String path = url + "/" + taskId + "/complete";
 643
 644         given(msoInterface.completeManualTask(eq(requestDetails), any(String.class), any(String.class), eq(path), any(RestObject.class))).willThrow(new MsoTestException("empty path"));
 645
 646         //when
 647         msoBusinessLogic.completeManualTask(requestDetails, taskId);
 648     }
 649
 650     @Test
 651     public void shouldProperlyUpdateVnfWithProperParameters() {
 652         //given
 653         MsoResponseWrapper expectedResponse = createOkResponse();
 654         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 655
 656         String serviceInstanceId = "testServiceId";
 657         String vnfInstanceId = "testVnfInstanceId";
 658
 659         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
 660         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 661         vnfEndpoint = vnfEndpoint + '/' + vnfInstanceId;
 662
 663         given(msoInterface.updateVnf(requestDetails, vnfEndpoint)).willReturn(expectedResponse);
 664
 665         //when
 666         MsoResponseWrapper response = (MsoResponseWrapper) msoBusinessLogic.updateVnf(requestDetails, serviceInstanceId, vnfInstanceId);
 667
 668         //then
 669         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 670     }
 671
 672     @Test
 673     public void shouldProperlyReplaceVnfWithProperParameters() {
 674         //given
 675         MsoResponseWrapper expectedResponse = createOkResponse();
 676         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 677
 678         String serviceInstanceId = "testServiceId";
 679         String vnfInstanceId = "testVnfInstanceId";
 680
 681         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_CHANGE_MANAGEMENT_INSTANCE);
 682         String vnfEndpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 683         vnfEndpoint = vnfEndpoint.replace(VNF_INSTANCE_ID, vnfInstanceId);
 684         vnfEndpoint = vnfEndpoint.replace(REQUEST_TYPE, ChangeManagementRequest.MsoChangeManagementRequest.REPLACE);
 685
 686         given(msoInterface.replaceVnf(requestDetails, vnfEndpoint)).willReturn(expectedResponse);
 687
 688         //when
 689         MsoResponseWrapper response = (MsoResponseWrapper) msoBusinessLogic.replaceVnf(requestDetails, serviceInstanceId, vnfInstanceId);
 690
 691         //then
 692         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
 693     }
 694
 695     @Test
 696     public void shouldProperlyGenerateInPlaceMsoRequestWithProperParameters() {
 697         //given
 698         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 699
 700         requestDetails.setVnfInstanceId("testVnfInstanceId");
 701         requestDetails.setVnfName("testVnfName");
 702         requestDetails.setRequestParameters(new RequestParameters());
 703
 704         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 705                 "\"existing_software_version\": \"testExistingSoftwareParam\"," +
 706                 "\"new_software_version\": \"testNewSoftwareParam\"," +
 707                 "\"operations_timeout\": \"100\"" +
 708                 "}");
 709
 710         RequestDetails inPlaceSoftwareUpdateRequest = new RequestDetails();
 711         inPlaceSoftwareUpdateRequest.setCloudConfiguration(requestDetails.getCloudConfiguration());
 712         inPlaceSoftwareUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 713         inPlaceSoftwareUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 714         org.onap.vid.changeManagement.RequestDetailsWrapper requestDetailsWrapper = new org.onap.vid.changeManagement.RequestDetailsWrapper();
 715         requestDetailsWrapper.requestDetails = inPlaceSoftwareUpdateRequest;
 716
 717         //when
 718         org.onap.vid.changeManagement.RequestDetailsWrapper response = msoBusinessLogic.generateInPlaceMsoRequest(requestDetails);
 719
 720         //then
 721         assertThat(response).isEqualToComparingFieldByField(requestDetailsWrapper);
 722     }
 723
 724     @Test(expectedExceptions = BadRequestException.class)
 725     public void shouldThrowExceptionWhenGenerateInPlaceMsoRequestWithParametersWithWrongCharacters() {
 726         //given
 727         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 728
 729         requestDetails.setVnfInstanceId("testVnfInstanceId");
 730         requestDetails.setVnfName("testVnfName");
 731         requestDetails.setRequestParameters(new RequestParameters());
 732
 733         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 734                 "\"existing_software_version\": \"#####\"," +
 735                 "\"new_software_version\": \"testNewSoftwareParam\"" +
 736                 "}");
 737
 738         //when
 739         msoBusinessLogic.generateInPlaceMsoRequest(requestDetails);
 740     }
 741
 742     @Test(expectedExceptions = BadRequestException.class)
 743     public void shouldThrowExceptionWhenGenerateInPlaceMsoRequestWithWrongParameters() {
 744         //given
 745         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 746
 747         requestDetails.setVnfInstanceId("testVnfInstanceId");
 748         requestDetails.setVnfName("testVnfName");
 749         requestDetails.setRequestParameters(new RequestParameters());
 750
 751         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 752                 "\"test-wrong-parameter\": \"testParam\"," +
 753                 "\"new_software_version\": \"testNewSoftwareParam\"" +
 754                 "}");
 755
 756         //when
 757         msoBusinessLogic.generateInPlaceMsoRequest(requestDetails);
 758     }
 759
 760     @Test
 761     public void shouldProprleyGenerateConfigMsoRequestWithProperParameters() {
 762         //given
 763         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 764
 765         requestDetails.setVnfInstanceId("testVnfInstanceId");
 766         requestDetails.setVnfName("testVnfName");
 767         requestDetails.setRequestParameters(new RequestParameters());
 768
 769         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 770                 "\"request-parameters\": \"testRequestParam\"," +
 771                 "\"configuration-parameters\": \"testConfigParams\"" +
 772                 "}");
 773
 774         RequestDetails configUpdateRequest = new RequestDetails();
 775         configUpdateRequest.setRequestParameters(requestDetails.getRequestParameters());
 776         configUpdateRequest.setRequestInfo(requestDetails.getRequestInfo());
 777
 778         org.onap.vid.changeManagement.RequestDetailsWrapper requestDetailsWrapper = new org.onap.vid.changeManagement.RequestDetailsWrapper();
 779         requestDetailsWrapper.requestDetails = configUpdateRequest;
 780
 781         //when
 782         org.onap.vid.changeManagement.RequestDetailsWrapper response = msoBusinessLogic.generateConfigMsoRequest(requestDetails);
 783
 784         //then
 785         assertThat(response).isEqualToComparingFieldByField(requestDetailsWrapper);
 786     }
 787
 788     @Test(expectedExceptions = BadRequestException.class)
 789     public void shouldThrowExceptionGenerateConfigMsoRequestWithoutAdditionalParameters() {
 790         //given
 791         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 792
 793         requestDetails.setVnfInstanceId("testVnfInstanceId");
 794         requestDetails.setVnfName("testVnfName");
 795         requestDetails.setRequestParameters(null);
 796
 797         //when
 798         msoBusinessLogic.generateConfigMsoRequest(requestDetails);
 799     }
 800
 801     @Test(expectedExceptions = BadRequestException.class)
 802     public void shouldThrowExceptionWhenGenerateConfigMsoRequestWithWrongPayload() {
 803         //given
 804         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 805
 806         requestDetails.setVnfInstanceId("testVnfInstanceId");
 807         requestDetails.setVnfName("testVnfName");
 808         requestDetails.setRequestParameters(new RequestParameters());
 809
 810         requestDetails.getRequestParameters().setAdditionalProperty("payload", null);
 811
 812         //when
 813         msoBusinessLogic.generateConfigMsoRequest(requestDetails);
 814     }
 815
 816     @Test(expectedExceptions = BadRequestException.class)
 817     public void shouldThrowExceptionGenerateConfigMsoRequestWithoutAnyParameter() {
 818         //given
 819         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 820
 821         requestDetails.setVnfInstanceId("testVnfInstanceId");
 822         requestDetails.setVnfName("testVnfName");
 823         requestDetails.setRequestParameters(new RequestParameters());
 824
 825         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 826                 "\"test-wrong-parameter\": \"testParam\"," +
 827                 "\"configuration-parameters\": \"testConfigParam\"" +
 828                 "}");
 829
 830         //when
 831         msoBusinessLogic.generateConfigMsoRequest(requestDetails);
 832     }
 833
 834     @Test
 835     public void shouldProperlyGetActivateFabricConfigurationPathWithProperParameters() {
 836         // given
 837         String serviceInstanceId = "testServiceId";
 838         String path = validateEndpointPath(MsoProperties.MSO_REST_API_SERVICE_INSTANCE_CREATE);
 839         path += "/" + serviceInstanceId + "/activateFabricConfiguration";
 840
 841         // when
 842         String response = msoBusinessLogic.getActivateFabricConfigurationPath(serviceInstanceId);
 843
 844         // then
 845         assertThat(response).isEqualTo(path);
 846     }
 847
 848     @Test
 849     public void shouldProperlyGetDeactivateAndCloudDeletePathWithProperParameters() {
 850         // given
 851         String serviceInstanceId = "testServiceId";
 852         String vnfInstanceId = "testVnfInstanceId";
 853         String vfModuleInstanceId = "testVfModuleInstanceId";
 854         String path = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
 855         path = path.replaceFirst(SVC_INSTANCE_ID, serviceInstanceId);
 856         path = path.replaceFirst(VNF_INSTANCE_ID, vnfInstanceId);
 857         path += "/" + vfModuleInstanceId + "/deactivateAndCloudDelete";
 858
 859         // when
 860         String response = msoBusinessLogic.getDeactivateAndCloudDeletePath(serviceInstanceId, vnfInstanceId, vfModuleInstanceId);
 861
 862         // then
 863         assertThat(response).isEqualTo(path);
 864     }
 865
 866     @Test
 867     public void shouldProperlyBuildRequestDetailsForSoftDeleteWithProperParameters() {
 868         //  given
 869         SoftDeleteRequest softDeleteRequest = new SoftDeleteRequest();
 870         RequestDetails requestDetails = new RequestDetails();
 871
 872         String userId = "testUserID";
 873         String tenantId = "testTenantId ";
 874         String cloudRegionId = "testCloudId";
 875
 876
 877         RequestInfo requestInfo = new RequestInfo();
 878         requestInfo.setSource("VID");
 879         requestInfo.setRequestorId(userId);
 880         requestDetails.setRequestInfo(requestInfo);
 881
 882         CloudConfiguration cloudConfiguration = new CloudConfiguration();
 883         cloudConfiguration.setTenantId(tenantId);
 884         cloudConfiguration.setLcpCloudRegionId(cloudRegionId);
 885         requestDetails.setCloudConfiguration(cloudConfiguration);
 886
 887         setModelInfoForRequestDetails(requestDetails);
 888
 889         setRequestParametersForRequestDetails(requestDetails);
 890
 891         softDeleteRequest.setLcpCloudRegionId(cloudRegionId);
 892         softDeleteRequest.setTenantId(tenantId);
 893         softDeleteRequest.setUserId(userId);
 894
 895         //  when
 896         RequestDetails response = msoBusinessLogic.buildRequestDetailsForSoftDelete(softDeleteRequest);
 897
 898         //  then
 899         assertThat(response).isEqualTo(requestDetails);
 900     }
 901
 902     private void setRequestParametersForRequestDetails(RequestDetails requestDetails) {
 903         RequestParameters requestParameters = new RequestParameters();
 904         requestParameters.setTestApi("GR_API");
 905         requestDetails.setRequestParameters(requestParameters);
 906     }
 907
 908     private void setModelInfoForRequestDetails(RequestDetails requestDetails) {
 909         ModelInfo modelInfo = new ModelInfo();
 910         modelInfo.setModelType("vfModule");
 911         requestDetails.setModelInfo(modelInfo);
 912     }
 913
 914     @Test
 915     public void shouldProperlyUpdateVnfSoftwareWithProperParameters() {
 916         //  given
 917         String serviceInstanceId = "testServiceId";
 918         String vnfInstanceId = "testVnfInstanceId";
 919
 920         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 921
 922         requestDetails.setVnfInstanceId("testVnfInstanceId");
 923         requestDetails.setVnfName("testVnfName");
 924         requestDetails.setRequestParameters(new RequestParameters());
 925
 926         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 927                 "\"existing_software_version\": \"testExistingSoftwareParam\"," +
 928                 "\"new_software_version\": \"testNewSoftwareParam\"," +
 929                 "\"operations_timeout\": \"100\"" +
 930                 "}");
 931
 932         MsoResponseWrapper okResponse = createOkResponse();
 933
 934         given(msoInterface.changeManagementUpdate(isA(org.onap.vid.changeManagement.RequestDetailsWrapper.class), any(String.class))).willReturn(okResponse);
 935
 936         //  when
 937         MsoResponseWrapper response = (MsoResponseWrapper) msoBusinessLogic.updateVnfSoftware(requestDetails, serviceInstanceId, vnfInstanceId);
 938
 939         //  then
 940         assertThat(response).isEqualToComparingFieldByField(okResponse);
 941     }
 942
 943     @Test
 944     public void shouldProperlyUpdateVnfConfigWithProperParameters() {
 945         //  given
 946         String serviceInstanceId = "testServiceId";
 947         String vnfInstanceId = "testVnfInstanceId";
 948
 949         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 950
 951         requestDetails.setVnfInstanceId("testVnfInstanceId");
 952         requestDetails.setVnfName("testVnfName");
 953         requestDetails.setRequestParameters(new RequestParameters());
 954
 955         requestDetails.getRequestParameters().setAdditionalProperty("payload", "{" +
 956                 "\"request-parameters\": \"testRequestParam\"," +
 957                 "\"configuration-parameters\": \"testConfigParams\"" +
 958                 "}");
 959
 960         MsoResponseWrapper okResponse = createOkResponse();
 961
 962         given(msoInterface.changeManagementUpdate(isA(org.onap.vid.changeManagement.RequestDetailsWrapper.class), any(String.class))).willReturn(okResponse);
 963
 964         //  when
 965         MsoResponseWrapper response = (MsoResponseWrapper) msoBusinessLogic.updateVnfConfig(requestDetails, serviceInstanceId, vnfInstanceId);
 966
 967         //  then
 968         assertThat(response).isEqualToComparingFieldByField(okResponse);
 969     }
 970
 971     @Test
 972     public void shouldProperlyDeleteConfigurationWithProperParameters() {
 973         //  given
 974         String serviceInstanceId = "testServiceId";
 975         String configurationId = "testConfigurationId";
 976
 977         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
 978
 979         requestDetails.setVnfInstanceId("testVnfInstanceId");
 980         requestDetails.setVnfName("testVnfName");
 981
 982         MsoResponseWrapper okResponse = createOkResponse();
 983         RequestDetailsWrapper wrappedRequestDetail = new RequestDetailsWrapper(requestDetails);
 984
 985         given(msoInterface.deleteConfiguration(eq(wrappedRequestDetail), any(String.class))).willReturn(okResponse);
 986
 987         //  when
 988         MsoResponseWrapper response = msoBusinessLogic.deleteConfiguration(wrappedRequestDetail, serviceInstanceId, configurationId);
 989
 990         //  then
 991         assertThat(response).isEqualToComparingFieldByField(okResponse);
 992     }
 993
 994     @Test
 995     public void shouldProperlySetConfigurationActiveStatusActiveWithProperParameters() {
 996         //  given
 997         String serviceInstanceId = "testServiceId";
 998         String configurationId = "testConfigurationId";
 999
1000         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1001
1002         requestDetails.setVnfInstanceId("testVnfInstanceId");
1003         requestDetails.setVnfName("testVnfName");
1004
1005         MsoResponseWrapper okResponse = createOkResponse();
1006
1007         String endpoint =
1008                 validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE)
1009                         .replace(SVC_INSTANCE_ID, serviceInstanceId)
1010                         .replace(CONFIGURATION_ID, configurationId)
1011                         + "/activate";
1012
1013         given(msoInterface.setConfigurationActiveStatus(eq(requestDetails), eq(endpoint))).willReturn(okResponse);
1014
1015         //  when
1016         MsoResponseWrapper response = msoBusinessLogic.setConfigurationActiveStatus(requestDetails, serviceInstanceId, configurationId, true);
1017
1018         //  then
1019         assertThat(response).isEqualToComparingFieldByField(okResponse);
1020     }
1021
1022     @Test
1023     public void shouldProperlySetConfigurationActiveStatusDeactivateWithProperParameters() {
1024         //  given
1025         String serviceInstanceId = "testServiceId";
1026         String configurationId = "testConfigurationId";
1027
1028         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1029
1030         requestDetails.setVnfInstanceId("testVnfInstanceId");
1031         requestDetails.setVnfName("testVnfName");
1032
1033         MsoResponseWrapper okResponse = createOkResponse();
1034
1035         String endpoint =
1036                 validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE)
1037                         .replace(SVC_INSTANCE_ID, serviceInstanceId)
1038                         .replace(CONFIGURATION_ID, configurationId)
1039                         + "/deactivate";
1040
1041         given(msoInterface.setConfigurationActiveStatus(eq(requestDetails), eq(endpoint))).willReturn(okResponse);
1042
1043         //  when
1044         MsoResponseWrapper response = msoBusinessLogic.setConfigurationActiveStatus(requestDetails, serviceInstanceId, configurationId, false);
1045
1046         //  then
1047         assertThat(response).isEqualToComparingFieldByField(okResponse);
1048     }
1049
1050     @Test
1051     public void shouldProperlySetServiceInstanceStatusActiveWithProperParameters() {
1052         //  given
1053         String serviceInstanceId = "testServiceId";
1054         MsoResponseWrapper okResponse = createOkResponse();
1055
1056         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1057
1058         given(msoInterface.setServiceInstanceStatus(eq(requestDetails), endsWith(serviceInstanceId + "/activate"))).willReturn(okResponse);
1059
1060         //  when
1061         MsoResponseWrapper response = msoBusinessLogic.setServiceInstanceStatus(requestDetails, serviceInstanceId, true);
1062
1063         //  then
1064         assertThat(response).isEqualToComparingFieldByField(okResponse);
1065     }
1066
1067     @Test
1068     public void shouldProperlySetServiceInstanceStatusDeactivateWithProperParameters() {
1069         //  given
1070         String serviceInstanceId = "testServiceId";
1071         MsoResponseWrapper okResponse = createOkResponse();
1072
1073         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1074
1075         given(msoInterface.setServiceInstanceStatus(eq(requestDetails), endsWith(serviceInstanceId + "/deactivate"))).willReturn(okResponse);
1076
1077         //  when
1078         MsoResponseWrapper response = msoBusinessLogic.setServiceInstanceStatus(requestDetails, serviceInstanceId, false);
1079
1080         //  then
1081         assertThat(response).isEqualToComparingFieldByField(okResponse);
1082     }
1083
1084     @Test(expectedExceptions = MsoTestException.class)
1085     public void shouldThrowExceptionWhenSetServiceInstanceStatusWithWrongParameters() {
1086         //  given
1087         String serviceInstanceId = "testServiceId";
1088
1089         doThrow(new MsoTestException("testException")).
1090                 when(msoInterface).setServiceInstanceStatus(eq(null), any(String.class));
1091
1092         //  when
1093         msoBusinessLogic.setServiceInstanceStatus(null, serviceInstanceId, true);
1094     }
1095
1096     @Test
1097     public void shouldProperlySetPortOnConfigurationStatusEnableWithProperParameters() {
1098         //  given
1099         String serviceInstanceId = "testServiceId";
1100         String configurationId = "testConfigurationId";
1101         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1102         requestDetails.setVnfInstanceId("testVnfInstanceId");
1103         requestDetails.setVnfName("testVnfName");
1104         MsoResponseWrapper okResponse = createOkResponse();
1105
1106         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE)
1107                 .replace(SVC_INSTANCE_ID, serviceInstanceId)
1108                 .replace(CONFIGURATION_ID, configurationId)
1109                 + "/enablePort";
1110
1111         given(msoInterface.setPortOnConfigurationStatus(eq(requestDetails), eq(endpoint))).willReturn(okResponse);
1112
1113         //  when
1114         MsoResponseWrapper response = msoBusinessLogic.setPortOnConfigurationStatus(requestDetails, serviceInstanceId, configurationId, true);
1115
1116         //  then
1117         assertThat(response).isEqualToComparingFieldByField(okResponse);
1118     }
1119
1120     @Test
1121     public void shouldProperlySetPortOnConfigurationStatusDisableWithProperParameters() {
1122         //  given
1123         String serviceInstanceId = "testServiceId";
1124         String configurationId = "testConfigurationId";
1125         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1126         requestDetails.setVnfInstanceId("testVnfInstanceId");
1127         requestDetails.setVnfName("testVnfName");
1128         MsoResponseWrapper okResponse = createOkResponse();
1129
1130         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_CONFIGURATION_INSTANCE)
1131                 .replace(SVC_INSTANCE_ID, serviceInstanceId)
1132                 .replace(CONFIGURATION_ID, configurationId)
1133                 + "/disablePort";
1134
1135         given(msoInterface.setPortOnConfigurationStatus(eq(requestDetails), eq(endpoint))).willReturn(okResponse);
1136
1137         //  when
1138         MsoResponseWrapper response = msoBusinessLogic.setPortOnConfigurationStatus(requestDetails, serviceInstanceId, configurationId, false);
1139
1140         //  then
1141         assertThat(response).isEqualToComparingFieldByField(okResponse);
1142     }
1143
1144     @Test
1145     public void shouldProperlyCreateOperationalEnvironmentActivationRequestDetailsWithProperParameters() {
1146         //  given
1147         OperationalEnvironmentActivateInfo details = createTestOperationalEnvironmentActivateInfo();
1148         //  when
1149         org.onap.vid.changeManagement.RequestDetailsWrapper<RequestDetails> requestDetails = msoBusinessLogic.createOperationalEnvironmentActivationRequestDetails(details);
1150
1151         //  then
1152         assertThat(requestDetails.requestDetails.getRequestParameters().getAdditionalProperties().values()).contains(details.getWorkloadContext(), details.getManifest());
1153         assertThat(requestDetails.requestDetails.getRequestInfo().getRequestorId()).isEqualTo(userId);
1154     }
1155
1156     @Test
1157     public void shouldProperlyGetOperationalEnvironmentActivationPathWithProperParameters() {
1158         // given
1159         OperationalEnvironmentActivateInfo details = createTestOperationalEnvironmentActivateInfo();
1160
1161         // when
1162         String response = msoBusinessLogic.getOperationalEnvironmentActivationPath(details);
1163
1164         // then
1165         assertThat(response).contains(operationalEnvironmentId);
1166     }
1167
1168     @Test
1169     public void shouldProperlyCreateOperationalEnvironmentDeactivationRequestDetailsWithProperParameters() {
1170         // given
1171         OperationalEnvironmentDeactivateInfo details = createTestOperationalEnvironmentDeactivateInfo();
1172
1173         // when
1174         org.onap.vid.changeManagement.RequestDetailsWrapper<RequestDetails> response;
1175         response = msoBusinessLogic.createOperationalEnvironmentDeactivationRequestDetails(details);
1176
1177         // then
1178         assertThat(response.requestDetails.getRequestInfo().getRequestorId()).isEqualTo(userId);
1179     }
1180
1181     @Test
1182     public void shouldProperlyGetCloudResourcesRequestsStatusPathWithProperParameters() {
1183         // given
1184         String requestId = "testRequestId";
1185
1186         // when
1187         String response = msoBusinessLogic.getCloudResourcesRequestsStatusPath(requestId);
1188
1189         // then
1190         assertThat(response).contains(requestId);
1191     }
1192
1193     @Test
1194     public void shouldProperlyGetOperationalEnvironmentDeactivationPathWithProperParameters() {
1195         // given
1196         OperationalEnvironmentDeactivateInfo details = createTestOperationalEnvironmentDeactivateInfo();
1197
1198         // when
1199         String response = msoBusinessLogic.getOperationalEnvironmentDeactivationPath(details);
1200
1201         // then
1202         assertThat(response).contains(operationalEnvironmentId);
1203     }
1204
1205     @Test
1206     public void shouldProperlyGetOperationalEnvironmentCreationPathWithProperParameters() {
1207         // when
1208         String response = msoBusinessLogic.getOperationalEnvironmentCreationPath();
1209
1210         // then
1211         assertThat(response).isNotBlank();
1212     }
1213
1214     @Test
1215     public void shouldProperlyConvertParametersToRequestDetailsWithProperParameters() {
1216         // given
1217         OperationalEnvironmentController.OperationalEnvironmentCreateBody input = createTestOperationalEnvironmentCreateBody();
1218
1219         // when
1220         org.onap.vid.changeManagement.RequestDetailsWrapper<OperationEnvironmentRequestDetails> response
1221                 = msoBusinessLogic.convertParametersToRequestDetails(input, userId);
1222
1223         // then
1224         assertThat(response.requestDetails.getRequestInfo().getInstanceName()).isEqualTo(input.getInstanceName());
1225         assertThat(response.requestDetails.getRequestInfo().getRequestorId()).isEqualTo(userId);
1226         assertThat(response.requestDetails.getRequestParameters().getOperationalEnvironmentType()).isEqualTo(input.getOperationalEnvironmentType());
1227         assertThat(response.requestDetails.getRequestParameters().getTenantContext()).isEqualTo(input.getTenantContext());
1228         assertThat(response.requestDetails.getRequestParameters().getWorkloadContext()).isEqualTo(input.getWorkloadContext());
1229     }
1230
1231     @Test
1232     public void shouldProperlyRemoveRelationshipFromServiceInstanceWithProperParameters() {
1233         // given
1234         MsoResponseWrapper expectedResponse = createOkResponse();
1235         String serviceInstanceId = "testServiceId";
1236         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1237
1238         given(msoInterface.removeRelationshipFromServiceInstance(eq(requestDetails), endsWith("/" + serviceInstanceId + "/removeRelationships")))
1239                 .willReturn(expectedResponse);
1240
1241         // when
1242         MsoResponseWrapper response = msoBusinessLogic.removeRelationshipFromServiceInstance(requestDetails, serviceInstanceId);
1243
1244         // then
1245         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
1246     }
1247
1248     @Test
1249     public void shouldProperlyAddRelationshipToServiceInstanceWithProperParameters() {
1250         // given
1251         MsoResponseWrapper expectedResponse = createOkResponse();
1252         String serviceInstanceId = "testServiceId";
1253         org.onap.vid.changeManagement.RequestDetails requestDetails = new org.onap.vid.changeManagement.RequestDetails();
1254
1255         given(msoInterface.addRelationshipToServiceInstance(eq(requestDetails), endsWith("/" + serviceInstanceId + "/addRelationships")))
1256                 .willReturn(expectedResponse);
1257
1258         // when
1259         MsoResponseWrapper response = msoBusinessLogic.addRelationshipToServiceInstance(requestDetails, serviceInstanceId);
1260
1261         // then
1262         assertThat(response).isEqualToComparingFieldByField(expectedResponse);
1263     }
1264
1265     @Test
1266     public void shouldProperlyRequestTypeFromValueWithValidParameters() {
1267         // given
1268         String testValue = "createInstance";
1269         // when
1270         MsoBusinessLogicImpl.RequestType response = MsoBusinessLogicImpl.RequestType.fromValue(testValue);
1271
1272         // then
1273         assertThat(response.toString()).isEqualTo(testValue);
1274     }
1275
1276     @Test(expectedExceptions = IllegalArgumentException.class)
1277     public void shouldThrowExceptionWhenRequestTypeFromValueWithWrongParameter() {
1278         // given
1279         String testValue = "notExistingParameter";
1280         // when
1281         MsoBusinessLogicImpl.RequestType.fromValue(testValue);
1282     }
1283
1284     @Test
1285     public void shouldProperlyInvokeVnfWorkflowWithValidParameters() {
1286         // given
1287         MsoResponseWrapper okResponse = createOkResponse();
1288         WorkflowRequestDetail request = createWorkflowRequestDetail();
1289         UUID serviceInstanceId = new UUID(1,10);
1290         UUID vnfInstanceId = new UUID(2,20);
1291         UUID workflow_UUID = new UUID(3,30);
1292         String path = "/instanceManagement/v1/serviceInstances/"+serviceInstanceId+"/vnfs/"+vnfInstanceId+"/workflows/"+workflow_UUID;
1293
1294         given(msoInterface.invokeWorkflow(eq(request), eq(path), MockitoHamcrest.argThat(allOf(hasEntry("X-RequestorID", "testRequester"),hasEntry("X-ONAP-PartnerName", "VID"))))).willReturn(okResponse);
1295
1296         // when
1297         MsoResponseWrapper response = msoBusinessLogic.invokeVnfWorkflow(request, "testRequester", serviceInstanceId, vnfInstanceId, workflow_UUID);
1298
1299         // then
1300         assertThat(response).isEqualToComparingFieldByField(okResponse);
1301     }
1302
1303
1304     @Test
1305     public void shouldReturnWorkflowListForGivenModelId() {
1306         given(msoInterface.getWorkflowListByModelId(anyString())).willReturn(workflowListResponse);
1307         given(workflowListResponse.getBody()).willReturn(workflowList);
1308         given(workflowListResponse.getStatus()).willReturn(HttpStatus.ACCEPTED.value());
1309
1310         SOWorkflowList workflows = msoBusinessLogic.getWorkflowListByModelId("sampleModelId");
1311
1312         assertThat(workflows).isEqualTo(workflowList);
1313     }
1314
1315     @Test(expectedExceptions = {MsoBusinessLogicImpl.WorkflowListException.class})
1316     public void shouldRaiseExceptionWhenRetrievingWorkflowsFailed() {
1317         given(msoInterface.getWorkflowListByModelId(anyString())).willReturn(workflowListResponse);
1318         given(workflowListResponse.getStatus()).willReturn(HttpStatus.INTERNAL_SERVER_ERROR.value());
1319
1320         msoBusinessLogic.getWorkflowListByModelId("sampleModelId");
1321     }
1322
1323
1324     @Test
1325     public void probeShouldReturnOrchestrationRequestsAndConnectionStatus(){
1326         String body =
1327                 "{"
1328                 + "  \"requestList\":"
1329                 + "  [{"
1330                 + "      \"request\": {}"
1331                 + "    }"
1332                 + "  ]"
1333                 + "}";
1334         mockForGetOrchestrationRequest(200, body);
1335
1336         ExternalComponentStatus externalComponentStatus = msoBusinessLogic.probeComponent();
1337
1338         assertThat(externalComponentStatus.isAvailable()).isTrue();
1339         assertThat(externalComponentStatus.getComponent()).isEqualTo(ExternalComponentStatus.Component.MSO);
1340     }
1341
1342     private WorkflowRequestDetail createWorkflowRequestDetail() {
1343         WorkflowRequestDetail workflowRequestDetail = new WorkflowRequestDetail();
1344         org.onap.vid.changeManagement.RequestParameters requestParameters = new org.onap.vid.changeManagement.RequestParameters();
1345         HashMap<String,String> paramsMap = new HashMap<>();
1346         paramsMap.put("testKey1","testValue1");
1347         paramsMap.put("testKey2","testValue2");
1348
1349         List<Map<String,String>> mapArray= new ArrayList<>();
1350         mapArray.add(paramsMap);
1351         requestParameters.setUserParams(mapArray);
1352
1353         CloudConfiguration cloudConfiguration = new CloudConfiguration();
1354         cloudConfiguration.setCloudOwner("testOwne");
1355         cloudConfiguration.setTenantId("testId");
1356         cloudConfiguration.setLcpCloudRegionId("testLcpCloudId");
1357
1358         workflowRequestDetail.setRequestParameters(requestParameters);
1359         workflowRequestDetail.setCloudConfiguration(cloudConfiguration);
1360         return workflowRequestDetail;
1361     }
1362
1363     private OperationalEnvironmentActivateInfo createTestOperationalEnvironmentActivateInfo() {
1364         OperationalEnvironmentController.OperationalEnvironmentActivateBody operationalEnvironmentActivateBody = new OperationalEnvironmentController.OperationalEnvironmentActivateBody(
1365                 "testRelatedInstanceId",
1366                 "testRelatedInstanceName",
1367                 "testWorkloadContext",
1368                 new OperationalEnvironmentController.OperationalEnvironmentManifest()
1369         );
1370         return new OperationalEnvironmentActivateInfo(operationalEnvironmentActivateBody, userId, operationalEnvironmentId);
1371     }
1372
1373     private OperationalEnvironmentDeactivateInfo createTestOperationalEnvironmentDeactivateInfo() {
1374         return new OperationalEnvironmentDeactivateInfo(userId, operationalEnvironmentId);
1375     }
1376
1377     private OperationalEnvironmentController.OperationalEnvironmentCreateBody createTestOperationalEnvironmentCreateBody() {
1378         return new OperationalEnvironmentController.OperationalEnvironmentCreateBody(
1379                 "testInstanceName",
1380                 "testEcompInstanceId",
1381                 "testEcompInstanceName",
1382                 "testOperationalEnvironmentType",
1383                 "testTenantContext",
1384                 "testWorkloadContext"
1385         );
1386     }
1387
1388     private MsoResponseWrapper createOkResponse() {
1389         HttpStatus expectedStatus = HttpStatus.ACCEPTED;
1390         String expectedBody = " \"body\": {\n" +
1391                 "      \"requestReferences\": {\n" +
1392                 "        \"instanceId\": \" 123456 \",\n" +
1393                 "        \"requestId\": \"b6dc9806-b094-42f7-9386-a48de8218ce8\"\n" +
1394                 "      }";
1395         MsoResponseWrapper responseWrapper = new MsoResponseWrapper();
1396         responseWrapper.setEntity(expectedBody);
1397         responseWrapper.setStatus(expectedStatus.value());
1398         return responseWrapper;
1399     }
1400
1401     private String getFileContentAsString(String resourceName) throws Exception {
1402         Path path = Paths.get("payload_jsons", resourceName);
1403         URL url = this.getClass().getClassLoader().getResource(path.toString());
1404         String result = "";
1405         if (url != null) {
1406             result = IOUtils.toString(url.toURI(), "UTF-8");
1407         }
1408         return result;
1409     }
1410
1411     private static class MsoRequestWrapperMatcher implements
1412             ArgumentMatcher<org.onap.vid.changeManagement.RequestDetailsWrapper> {
1413
1414         private final org.onap.vid.changeManagement.RequestDetailsWrapper expectedRequest;
1415
1416         MsoRequestWrapperMatcher(org.onap.vid.changeManagement.RequestDetailsWrapper expectedRequest) {
1417             this.expectedRequest = expectedRequest;
1418         }
1419
1420         @Override
1421         public boolean matches(org.onap.vid.changeManagement.RequestDetailsWrapper argument) {
1422             return expectedRequest.requestDetails.equals(argument.requestDetails);
1423         }
1424     }
1425
1426     private class MsoTestException extends RuntimeException {
1427         MsoTestException(String testException) {
1428             super(testException);
1429         }
1430     }
1431
1432     //you need to add mocks to httpResponse
1433     private HttpResponse<String> mockForGetOrchestrationRequest() {
1434
1435         HttpResponse<String> httpResponse = mock(HttpResponse.class);
1436         HttpResponseWithRequestInfo<String> httpResponseWithRequestInfo = new HttpResponseWithRequestInfo<>(httpResponse, MY_PRETTY_URL, HttpMethod.GET);
1437         when(msoInterface.getOrchestrationRequest(any(String.class),anyBoolean()))
1438             .thenReturn(httpResponseWithRequestInfo);
1439         return httpResponse;
1440     }
1441
1442     private HttpResponse<String> mockForGetOrchestrationRequest(int statusCode, String body) {
1443
1444         HttpResponse<String> httpResponse = mockForGetOrchestrationRequest();
1445         when(httpResponse.getStatus()).thenReturn(statusCode);
1446         when(httpResponse.getBody()).thenReturn(body);
1447         TestUtils.mockGetRawBodyWithStringBody(httpResponse, body);
1448         return httpResponse;
1449     }
1450
1451     @Test
1452     public void probeComponent_verifyGoodRequest(){
1453         String responseString = "" +
1454             "{ " +
1455             " \"requestList\": [{ " +
1456             "   \"request\": { " +
1457             "    \"requestDetails\": { " +
1458             "     \"cloudConfiguration\": { " +
1459             "      \"lcpCloudRegionId\": \"hvf6\", " +
1460             "      \"cloudOwner\": \"irma-aic\", " +
1461             "      \"tenantId\": \"ffdf52b5e5104b0e8f329b0b1637ee2e\" " +
1462             "     }, " +
1463             "     \"modelInfo\": { " +
1464             "      \"modelCustomizationName\": \"VSP1710PID298109_vWINIFRED 0\", " +
1465             "      \"modelCustomizationId\": \"24d43fdb-9aa6-4287-a68e-1e702ea89d13\", " +
1466             "      \"modelInvariantId\": \"e7961100-cde6-4b5a-bcda-b8945086950a\", " +
1467             "      \"modelVersionId\": \"959a7ba0-89ee-4984-9af6-65d5bdda4b0e\", " +
1468             "      \"modelName\": \"VSP1710PID298109_vWINIFRED\", " +
1469             "      \"modelType\": \"vnf\", " +
1470             "      \"modelVersion\": \"1.0\" " +
1471             "     }, " +
1472             "     \"relatedModelList\": [{ " +
1473             "       \"relatedInstance\": { " +
1474             "        \"instanceId\": \"6dd0f8de-93c7-48a2-914b-1a8d58e0eb48\", " +
1475             "        \"modelInfo\": { " +
1476             "         \"modelInvariantId\": \"57e00952-0af7-4f0f-b19a-408a6f73c8df\", " +
1477             "         \"modelType\": \"service\", " +
1478             "         \"modelName\": \"ServicevWINIFREDPID298109\", " +
1479             "         \"modelVersion\": \"1.0\", " +
1480             "         \"modelVersionId\": \"fe6985cd-ea33-3346-ac12-ab121484a3fe\" " +
1481             "        } " +
1482             "       } " +
1483             "      } " +
1484             "     ], " +
1485             "     \"requestInfo\": { " +
1486             "      \"source\": \"VID\", " +
1487             "      \"suppressRollback\": false, " +
1488             "      \"requestorId\": \"ds828e\" " +
1489             "     }, " +
1490             "     \"requestParameters\": { " +
1491             "      \"userParams\": [ " +
1492             "      ], " +
1493             "      \"aLaCarte\": false, " +
1494             "      \"usePreload\": true, " +
1495             "      \"rebuildVolumeGroups\": false, " +
1496             "      \"autoBuildVfModules\": false, " +
1497             "      \"cascadeDelete\": false " +
1498             "     }, " +
1499             "     \"relatedInstanceList\": [{ " +
1500             "       \"relatedInstance\": { " +
1501             "        \"instanceId\": \"6dd0f8de-93c7-48a2-914b-1a8d58e0eb48\", " +
1502             "        \"modelInfo\": { " +
1503             "         \"modelInvariantId\": \"57e00952-0af7-4f0f-b19a-408a6f73c8df\", " +
1504             "         \"modelType\": \"service\", " +
1505             "         \"modelName\": \"ServicevWINIFREDPID298109\", " +
1506             "         \"modelVersion\": \"1.0\", " +
1507             "         \"modelVersionId\": \"fe6985cd-ea33-3346-ac12-ab121484a3fe\" " +
1508             "        } " +
1509             "       } " +
1510             "      } " +
1511             "     ] " +
1512             "    }, " +
1513             "    \"requestId\": \"d352c70d-5ef8-4977-9ea8-4c8cbe860422\", " +
1514             "    \"requestScope\": \"vnf\", " +
1515             "    \"requestStatus\": { " +
1516             "     \"percentProgress\": 100.0, " +
1517             "     \"requestState\": \"Some Unknown Value\", " +
1518             "     \"statusMessage\": \"Update Is In Progress\", " +
1519             "     \"finishTime\": \"Fri, 08 Sep 2017 19:34:33 GMT\" " +
1520             "    }, " +
1521             "    \"requestType\": \"updateInstance\", " +
1522             "    \"startTime\": \"<IN_PROGRESS_DATE>\", " +
1523             "    \"instanceReferences\": { " +
1524             "     \"serviceInstanceId\": \"6dd0f8de-93c7-48a2-914b-1a8d58e0eb48\", " +
1525             "     \"vnfInstanceId\": \"7c00cc1e-6425-4fc3-afc3-0289db288d4c\", " +
1526             "     \"requestorId\": \"ds828e\" " +
1527             "    } " +
1528             "   } " +
1529             "  } " +
1530             " ] " +
1531             "} ";
1532
1533         mockForGetOrchestrationRequest(200, responseString);
1534
1535         final ExternalComponentStatus msoStatus = msoBusinessLogic.probeComponent();
1536
1537         assertMsoStatus(msoStatus, true);
1538         assertMetadata(msoStatus, 200, startsWith(responseString.substring(0, 400)), MY_PRETTY_URL, equalTo("OK"));
1539     }
1540
1541     @Test
1542     public void probeComponent_response200OkButEmptyPayload_shouldDescribeCorrectly() {
1543         String responseString = "" +
1544             "{ " +
1545             " \"requestList\": []" +
1546             "}";
1547
1548         mockForGetOrchestrationRequest(200, responseString);
1549
1550         final ExternalComponentStatus msoStatus = msoBusinessLogic.probeComponent();
1551
1552         assertMsoStatus(msoStatus, true);
1553
1554         assertMetadata(msoStatus, 200, equalTo(responseString), MY_PRETTY_URL, containsString("OK"));
1555     }
1556
1557     @Test
1558     public void probeComponent_response200OkButInvalidPayload_shouldDescribeCorrectly() {
1559         String responseString = "this payload is an invalid json";
1560
1561         mockForGetOrchestrationRequest(200, responseString);
1562
1563         final ExternalComponentStatus msoStatus = msoBusinessLogic.probeComponent();
1564
1565         assertMsoStatus(msoStatus, false);
1566
1567         assertMetadata(msoStatus, 200, equalTo(responseString), MY_PRETTY_URL, containsString("JsonParseException: Unrecognized token"));
1568     }
1569
1570     @Test
1571     public void probeComponent_verifyResponse406() {
1572         String responseString = "my raw data";
1573
1574         when(msoInterface.getOrchestrationRequest(any(), eq(true))).thenThrow(
1575             new ExceptionWithRequestInfo(HttpMethod.GET, MY_PRETTY_URL, responseString, 406,
1576                 new GenericUncheckedException(
1577                     new HttpException("Simulating as 406 was returned (200 or 202 expected)"))));
1578
1579         final ExternalComponentStatus msoStatus = msoBusinessLogic.probeComponent();
1580
1581         assertMsoStatus(msoStatus, false);
1582
1583         assertMetadata(msoStatus, 406, equalTo(responseString), MY_PRETTY_URL, containsString("HttpException: Simulating as 406 was returned"));
1584     }
1585
1586
1587     @Test
1588     public void probeComponent_throwNullPointerException_resultIsWithErrorMetadata() {
1589         when(msoInterface.getOrchestrationRequest(any(), eq(true))).thenThrow(new NullPointerException());
1590
1591         final ExternalComponentStatus msoStatus = msoBusinessLogic.probeComponent();
1592
1593         MatcherAssert.assertThat(msoStatus.isAvailable(), is(false));
1594         MatcherAssert.assertThat(msoStatus.getComponent(), is(MSO));
1595         MatcherAssert.assertThat(msoStatus.getMetadata(), instanceOf(ErrorMetadata.class));
1596
1597         final ErrorMetadata metadata = ((ErrorMetadata) msoStatus.getMetadata());
1598         org.junit.Assert.assertThat(metadata.getDescription(), containsString("NullPointerException"));
1599     }
1600
1601     private void assertMsoStatus(ExternalComponentStatus msoStatus, boolean isAvailable) {
1602         MatcherAssert.assertThat(msoStatus.isAvailable(), is(isAvailable));
1603         MatcherAssert.assertThat(msoStatus.getComponent(), is(MSO));
1604         MatcherAssert.assertThat(msoStatus.getMetadata(), instanceOf(HttpRequestMetadata.class));
1605     }
1606
1607     private void assertMetadata(ExternalComponentStatus msoStatus, int httpCode, Matcher<String> rawData, String url, Matcher<String> descriptionMatcher) {
1608         final HttpRequestMetadata metadata = ((HttpRequestMetadata) msoStatus.getMetadata());
1609         org.junit.Assert.assertThat(metadata.getHttpMethod(), equalTo(HttpMethod.GET));
1610         org.junit.Assert.assertThat(metadata.getHttpCode(), equalTo(httpCode));
1611         org.junit.Assert.assertThat(metadata.getUrl(), equalTo(url));
1612         org.junit.Assert.assertThat(metadata.getRawData(), rawData);
1613         org.junit.Assert.assertThat(metadata.getDescription(), descriptionMatcher);
1614     }
1615
1616     @Test(dataProvider = "unAssignOrDeleteParams")
1617     public void deleteSvcInstance_verifyEndPointPathConstructing(String status) {
1618         Mockito.reset(msoInterface);
1619         String endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
1620         RequestDetails requestDetails = new RequestDetails();
1621
1622
1623         msoBusinessLogic.deleteSvcInstance(requestDetails, "tempId", status);
1624
1625         verify(msoInterface).deleteSvcInstance(requestDetails, endpoint + "/tempId");
1626     }
1627
1628     @DataProvider
1629     public Object[][] unAssignOrDeleteParams() {
1630         return new Object[][]{
1631             {"Active"},
1632             {"unexpected-status"},
1633         };
1634     }
1635
1636     @Test(dataProvider = "unAssignStatus")
1637     public void deleteSvcInstance_verifyEndPointPathConstructing_unAssignFeatureOn(String status) {
1638         Mockito.reset(msoInterface);
1639         String endpoint = validateEndpointPath(MsoProperties.MSO_DELETE_OR_UNASSIGN_REST_API_SVC_INSTANCE);
1640         RequestDetails requestDetails = new RequestDetails();
1641
1642         msoBusinessLogic.deleteSvcInstance(requestDetails, "tempId", status);
1643
1644         verify(msoInterface).unassignSvcInstance(requestDetails, endpoint + "/tempId/unassign");
1645     }
1646
1647     @DataProvider
1648     public Object[][] unAssignStatus() {
1649         return new Object[][]{
1650             {"Created"},
1651             {"Pendingdelete"},
1652             {"pending-Delete"},
1653             {"Assigned"}
1654         };
1655     }
1656
1657     @Test
1658     public void deleteVnf_verifyEndPointPathConstructing() {
1659         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VNF_INSTANCE);
1660         RequestDetails requestDetails = new RequestDetails();
1661
1662         String vnf_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, "serviceInstanceTempId");
1663
1664         msoBusinessLogic.deleteVnf(requestDetails, "serviceInstanceTempId", "vnfInstanceTempId");
1665         verify(msoInterface).deleteVnf(requestDetails, vnf_endpoint + "/vnfInstanceTempId");
1666     }
1667
1668     @Test
1669     public void deleteVfModule_verifyEndPointPathConstructing() {
1670         String endpoint = validateEndpointPath(MsoProperties.MSO_REST_API_VF_MODULE_INSTANCE);
1671         RequestDetails requestDetails = new RequestDetails();
1672
1673         String vf__modules_endpoint = endpoint.replaceFirst(SVC_INSTANCE_ID, "serviceInstanceTempId").replaceFirst(VNF_INSTANCE_ID, "vnfInstanceTempId");
1674
1675         msoBusinessLogic.deleteVfModule(requestDetails, "serviceInstanceTempId", "vnfInstanceTempId", "vfModuleTempId");
1676         verify(msoInterface).deleteVfModule(requestDetails, vf__modules_endpoint + "/vfModuleTempId");
1677     }
1678 }
1679