gerrit.onap Code Review - vfc/nfvo/driver/vnfm/svnfm.git/blob

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
  17
  18 import com.google.gson.Gson;
  19 import com.google.gson.JsonElement;
  20 import com.google.gson.JsonObject;
  21 import com.google.gson.JsonParser;
  22 import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage;
  23 import com.nokia.cbam.lcm.v32.model.*;
  24 import com.nokia.cbam.lcm.v32.model.OperationType;
  25 import com.nokia.cbam.lcm.v32.model.VimInfo;
  26 import com.nokia.cbam.lcm.v32.model.VnfInfo;
  27 import io.reactivex.Observable;
  28 import java.nio.file.Paths;
  29 import java.util.*;
  30 import javax.servlet.http.HttpServletResponse;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.ArgumentCaptor;
  34 import org.mockito.InOrder;
  35 import org.mockito.Mock;
  36 import org.mockito.Mockito;
  37 import org.mockito.invocation.InvocationOnMock;
  38 import org.mockito.stubbing.Answer;
  39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
  40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
  41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
  42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
  43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
  44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
  45 import org.onap.vnfmdriver.model.*;
  46 import org.onap.vnfmdriver.model.ScaleDirection;
  47 import org.threeten.bp.OffsetDateTime;
  48
  49 import static java.lang.Boolean.parseBoolean;
  50 import static java.nio.file.Files.readAllBytes;
  51 import static java.util.Optional.empty;
  52
  53 import static junit.framework.TestCase.*;
  54 import static org.mockito.Matchers.eq;
  55 import static org.mockito.Mockito.*;
  56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
  57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
  58 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  59 import static org.springframework.test.util.ReflectionTestUtils.setField;
  60
  61 public class TestLifecycleManager extends TestBase {
  62     public static final String JOB_ID = "myJobId";
  63     public static final String CBAM_VNFD_ID = "cbamVnfdId";
  64     public static final String TENANT = "myTenant";
  65     public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
  66     private static final String ONAP_CSAR_ID = "myOnapCsarId";
  67     private static final String VIM_ID = "ownerId_regionId";
  68     @Mock
  69     private CatalogManager catalogManager;
  70     @Mock
  71     private VfcGrantManager vfcGrantManager;
  72     @Mock
  73     private JobManager jobManager;
  74     @Mock
  75     private LifecycleChangeNotificationManager notificationManager;
  76     @Mock
  77     private HttpServletResponse restResponse;
  78     @Mock
  79     private VimInfoProvider vimInfoProvider;
  80
  81     private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class);
  82     private AdditionalParameters additionalParam = new AdditionalParameters();
  83     private String INSTANTIATION_LEVEL = "level1";
  84     private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim();
  85     private String cbamVnfdContent;
  86     private OperationExecution instantiationOperationExecution = new OperationExecution();
  87     private OperationExecution modifyPropertyoperationExecution = new OperationExecution();
  88     private OperationExecution scaleOperationExecution = new OperationExecution();
  89     private OperationExecution healOperationExecution = new OperationExecution();
  90     private OperationExecution customOperationExecution = new OperationExecution();
  91
  92
  93     private VnfInfo vnfInfo = new VnfInfo();
  94     private List<OperationExecution> operationExecutions = new ArrayList<>();
  95     private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo();
  96     private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo();
  97     private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData();
  98     private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class);
  99     private Set<Boolean> finished = new HashSet<>();
 100     private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class);
 101     private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class);
 102     private ArgumentCaptor<CustomOperationRequest> customOperationRequestArgumentCaptor = ArgumentCaptor.forClass(CustomOperationRequest.class);
 103     private ArgumentCaptor<String> operationIdCaptor = ArgumentCaptor.forClass(String.class);
 104
 105     private LifecycleManager lifecycleManager;
 106
 107     @Before
 108     public void initMocks() throws Exception {
 109         vnfInfo.setExtensions(new ArrayList<>());
 110         vnfInfo.setOperationExecutions(new ArrayList<>());
 111         lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager);
 112         cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI())));
 113         setField(LifecycleManager.class, "logger", logger);
 114         CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage();
 115         when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage);
 116         cbamPackage.setVnfdId(CBAM_VNFD_ID);
 117         vnfInfo.setVnfdId(CBAM_VNFD_ID);
 118         vnfInfo.setId(VNF_ID);
 119         when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID);
 120         when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent);
 121         cbamPackage.setId(CBAM_VNFD_ID);
 122         vimInfo.setUrl("cloudUrl");
 123         vimInfo.setPassword("vimPassword");
 124         vimInfo.setUserName("vimUsername");
 125         vimInfo.setSslInsecure("true");
 126         vimInfo.setVimId(VIM_ID);
 127         vimInfo.setName("vimName");
 128         when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo);
 129         instantiationOperationExecution.setId(OPERATION_EXECUTION_ID);
 130         instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE);
 131         instantiationOperationExecution.setStartTime(OffsetDateTime.now());
 132         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(operationExecutions));
 133         operationExecutions.add(modifyPropertyoperationExecution);
 134         modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now());
 135         modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO);
 136         operationExecutions.add(instantiationOperationExecution);
 137         instantiationOperationExecution.setStatus(OperationStatus.FINISHED);
 138         modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED);
 139         customOperationExecution.setStatus(OperationStatus.FINISHED);
 140         modifyPropertyoperationExecution.setId(UUID.randomUUID().toString());
 141         scaleOperationExecution.setId(UUID.randomUUID().toString());
 142         healOperationExecution.setId(UUID.randomUUID().toString());
 143         customOperationExecution.setId(UUID.randomUUID().toString());
 144
 145         when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(modifyPropertyoperationExecution));
 146         doAnswer(new Answer() {
 147             @Override
 148             public Object answer(InvocationOnMock invocation) throws Throwable {
 149                 finished.add(Boolean.TRUE);
 150                 return null;
 151             }
 152         }).when(jobManager).jobFinished(JOB_ID);
 153         when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 154             @Override
 155             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 156                 operationExecutions.add(scaleOperationExecution);
 157                 return buildObservable(scaleOperationExecution);
 158             }
 159         });
 160         when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 161             @Override
 162             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 163                 operationExecutions.add(healOperationExecution);
 164                 return buildObservable(healOperationExecution);
 165             }
 166         });
 167         when(vnfApi.vnfsVnfInstanceIdCustomCustomOperationNamePost(eq(VNF_ID), operationIdCaptor.capture(), customOperationRequestArgumentCaptor.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 168             @Override
 169             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 170                 operationExecutions.add(customOperationExecution);
 171                 return buildObservable(customOperationExecution);
 172             }
 173         });
 174     }
 175
 176     /**
 177      * test instantiation
 178      */
 179     @Test
 180     public void testInstantiation() throws Exception {
 181         //given
 182         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 183
 184         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 185         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 186         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 187         grantResponse.setVimId(VIM_ID);
 188         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 189         accessInfo.setTenant(TENANT);
 190         grantResponse.setAccessInfo(accessInfo);
 191         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 192         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 193         //when
 194         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 195         waitForJobToFinishInJobManager(finished);
 196         //verify
 197         assertEquals(VNF_ID, response.getVnfInstanceId());
 198         assertEquals(JOB_ID, response.getJobId());
 199         assertEquals(createRequest.getAllValues().size(), 1);
 200         assertEquals("myDescription", createRequest.getValue().getDescription());
 201         assertEquals("vnfName", createRequest.getValue().getName());
 202         assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
 203         assertEquals(1, actualInstantiationRequest.getAllValues().size());
 204         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 205         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 206         assertEquals(VIM_ID, actualVim.getId());
 207         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
 208         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 209         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 210         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 211         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 212         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 213         assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
 214         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 215         assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
 216         assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
 217         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
 218         assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
 219         assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
 220         assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
 221         assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
 222
 223         assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
 224         assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
 225         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
 226         assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
 227
 228         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
 229         assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
 230         assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
 231         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
 232
 233
 234         assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
 235         assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
 236         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
 237         assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
 238         assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
 239         assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
 240
 241         assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
 242         assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
 243         assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
 244         assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
 245         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
 246         assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
 247         assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
 248         assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
 249         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
 250         assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
 251         assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
 252         String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
 253         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
 254         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 255         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 256
 257         assertEquals(1, actualVnfModifyRequest.getAllValues().size());
 258         assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
 259         assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
 260         assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
 261         assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
 262         assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
 263
 264         //the 3.2 API does not accept empty array
 265         assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
 266         verify(jobManager).spawnJob(VNF_ID, restResponse);
 267         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 268         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 269     }
 270
 271     /**
 272      * invalid VIM type results in failure
 273      */
 274     @Test
 275     public void testInstantiationWithInvalidVimType() throws Exception {
 276         //given
 277         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
 278         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 279         when(logger.isInfoEnabled()).thenReturn(false);
 280         //when
 281         try {
 282             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 283             //verify
 284             fail();
 285         } catch (Exception e) {
 286             assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage());
 287         }
 288         verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any());
 289         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 290         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 291         verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types");
 292     }
 293
 294     /**
 295      * test instantiation with KeyStone V2 based with SSL
 296      */
 297     @Test
 298     public void testInstantiationV2WithSsl() throws Exception {
 299         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 300         when(logger.isInfoEnabled()).thenReturn(false);
 301         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 302         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 303         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 304         grantResponse.setVimId(VIM_ID);
 305         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 306         accessInfo.setTenant(TENANT);
 307         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 308         vimInfo.setSslInsecure("false");
 309         vimInfo.setSslCacert(caCert);
 310         grantResponse.setAccessInfo(accessInfo);
 311         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 312         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 313         JsonObject inputs = child((JsonObject) instantiationRequest.getAdditionalParam(), "inputs");
 314         JsonObject vnfs = child(child(inputs, "vnfs"), ONAP_CSAR_ID);
 315         vnfs.remove("additionalParams");
 316         //when
 317         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 318         waitForJobToFinishInJobManager(finished);
 319         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 320         //verify
 321         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 322         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 323         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 324         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 325         verify(logger).warn("No additional parameters were specified for the operation");
 326         verify(logger, never()).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), anyString(), anyString(), anyString());
 327     }
 328
 329     /**
 330      * non specified SSL verification means not verified
 331      */
 332     @Test
 333     public void testInstantiationV2WithoutSsl() throws Exception {
 334         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 335
 336         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 337         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 338         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 339         grantResponse.setVimId(VIM_ID);
 340         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 341         accessInfo.setTenant(TENANT);
 342         vimInfo.setSslInsecure(null);
 343         grantResponse.setAccessInfo(accessInfo);
 344         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 345         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 346         //when
 347         lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 348         waitForJobToFinishInJobManager(finished);
 349         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 350         //verify
 351         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 352         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 353         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 354     }
 355
 356     /**
 357      * test instantiation with KeyStone V3 based
 358      */
 359     @Test
 360     public void testInstantiationV3() throws Exception {
 361         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 362         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 363         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 364         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 365         grantResponse.setVimId(VIM_ID);
 366         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 367         accessInfo.setTenant(TENANT);
 368         grantResponse.setAccessInfo(accessInfo);
 369         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 370         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 371         //when
 372         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 373         waitForJobToFinishInJobManager(finished);
 374         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 375         //verify
 376         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 377         assertEquals(VIM_ID, actualVim.getId());
 378         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 379         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 380         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 381         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 382         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 383         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 384         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 385         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 386         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 387         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 388         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 389     }
 390
 391     /**
 392      * test instantiation with backward compatibility test with Amsterdam release
 393      * - the vim identifier is supplied as vimid with not camel case
 394      */
 395     @Test
 396     public void testInstantiationNoVimId() throws Exception {
 397         //given
 398         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 399         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 400         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 401         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 402         grantResponse.setVimid(VIM_ID);
 403         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 404         accessInfo.setTenant(TENANT);
 405         grantResponse.setAccessinfo(accessInfo);
 406         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 407         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 408         //when
 409         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 410         waitForJobToFinishInJobManager(finished);
 411         //verify
 412         assertEquals(VNF_ID, response.getVnfInstanceId());
 413         assertEquals(JOB_ID, response.getJobId());
 414         assertEquals(createRequest.getAllValues().size(), 1);
 415         assertEquals("myDescription", createRequest.getValue().getDescription());
 416         assertEquals("vnfName", createRequest.getValue().getName());
 417         assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId());
 418         assertEquals(1, actualInstantiationRequest.getAllValues().size());
 419         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 420         OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0);
 421         assertEquals(VIM_ID, actualVim.getId());
 422         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType());
 423         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 424         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 425         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 426         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 427         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 428         assertEquals("myTenant", actualVim.getAccessInfo().getTenant());
 429         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 430         assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size());
 431         assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId());
 432         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId());
 433         assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId());
 434         assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size());
 435         assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0));
 436         assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size());
 437
 438         assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId());
 439         assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId());
 440         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size());
 441         assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId());
 442
 443         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId());
 444         assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId());
 445         assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId());
 446         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size());
 447
 448
 449         assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses());
 450         assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId());
 451         assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size());
 452         assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp());
 453         assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac());
 454         assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId());
 455
 456         assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId());
 457         assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode());
 458         assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId());
 459         assertEquals(1, actualInstantiationRequest.getValue().getZones().size());
 460         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId());
 461         assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId());
 462         assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId());
 463         assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size());
 464         assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId());
 465         assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId());
 466         assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId());
 467         String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams());
 468         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams));
 469         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 470         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 471
 472         assertEquals(1, actualVnfModifyRequest.getAllValues().size());
 473         assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size());
 474         assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName());
 475         assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue());
 476         assertEquals(LifecycleManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName());
 477         assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue());
 478
 479         //the 3.2 API does not accept empty array
 480         assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties());
 481         verify(jobManager).spawnJob(VNF_ID, restResponse);
 482         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("creation"), eq("not yet specified"), anyString());
 483         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("instantiation"), eq(VNF_ID), anyString());
 484     }
 485
 486     /**
 487      * test instantiation with KeyStone V3 based with SSL
 488      */
 489     @Test
 490     public void testInstantiationV3WithSsl() throws Exception {
 491         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 492         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 493         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 494         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 495         grantResponse.setVimId(VIM_ID);
 496         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 497         accessInfo.setTenant(TENANT);
 498         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 499         vimInfo.setSslInsecure("false");
 500         vimInfo.setSslCacert(caCert);
 501         grantResponse.setAccessInfo(accessInfo);
 502         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 503         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 504         //when
 505         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 506         waitForJobToFinishInJobManager(finished);
 507         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 508         //verify
 509         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 510         assertEquals(VIM_ID, actualVim.getId());
 511         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 512         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 513         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 514         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 515         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 516         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 517         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 518         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 519         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 520         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 521         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 522         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 523     }
 524
 525     /**
 526      * non specified SSL verification meams not verified for KeyStone V3 based
 527      */
 528     @Test
 529     public void testInstantiationV3WithNonSpecifiedSsl() throws Exception {
 530         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 531         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 532         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 533         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 534         grantResponse.setVimId(VIM_ID);
 535         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 536         accessInfo.setTenant(TENANT);
 537         vimInfo.setSslInsecure(null);
 538         grantResponse.setAccessInfo(accessInfo);
 539         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 540         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 541         //when
 542         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 543         waitForJobToFinishInJobManager(finished);
 544         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 545         //verify
 546         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 547         assertEquals(VIM_ID, actualVim.getId());
 548         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 549         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 550         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 551         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 552         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 553         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 554         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 555         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 556         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 557         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 558     }
 559
 560     /**
 561      * verify backward compatibility with Amsterdam release
 562      */
 563     @Test
 564     public void testInstantiationV3WithNoDomain() throws Exception {
 565         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 566         additionalParam.setDomain("myDomain");
 567         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 568         vimInfo.setDomain(null);
 569         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 570         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 571         grantResponse.setVimId(VIM_ID);
 572         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 573         accessInfo.setTenant(TENANT);
 574         vimInfo.setSslInsecure(null);
 575         grantResponse.setAccessInfo(accessInfo);
 576         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 577         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 578         //when
 579         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 580         waitForJobToFinishInJobManager(finished);
 581         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 582         //verify
 583         OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0);
 584         assertEquals(VIM_ID, actualVim.getId());
 585         assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType());
 586         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 587         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 588         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 589         assertEquals("regionId", actualVim.getAccessInfo().getRegion());
 590         assertEquals("myTenant", actualVim.getAccessInfo().getProject());
 591         assertEquals("myDomain", actualVim.getAccessInfo().getDomain());
 592         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 593         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 594         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 595         verify(logger).warn("Setting domain from additional parameters");
 596     }
 597
 598     /**
 599      * verify backward compatibility with Amsterdam release
 600      * if no domain is specified error is propagated
 601      */
 602     @Test
 603     public void testInstantiationV3WithNoDomainFail() throws Exception {
 604         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
 605         vimInfo.setDomain(null);
 606         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 607         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 608         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 609         grantResponse.setVimId(VIM_ID);
 610         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 611         accessInfo.setTenant(TENANT);
 612         vimInfo.setSslInsecure(null);
 613         grantResponse.setAccessInfo(accessInfo);
 614         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 615         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 616         //when
 617         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 618         waitForJobToFinishInJobManager(finished);
 619         assertEquals(0, actualInstantiationRequest.getAllValues().size());
 620         //verify
 621         verify(logger).error("The cloud did not supply the cloud domain (Amsterdam release) and was not supplied as additional data");
 622     }
 623
 624     /**
 625      * test instantiation with vcloud
 626      */
 627     @Test
 628     public void testInstantiationVcloud() throws Exception {
 629         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 630
 631         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 632         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 633         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 634         grantResponse.setVimId(VIM_ID);
 635         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 636         accessInfo.setTenant(TENANT);
 637         grantResponse.setAccessInfo(accessInfo);
 638         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 639         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 640         //when
 641         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 642         waitForJobToFinishInJobManager(finished);
 643         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 644         //verify
 645         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 646         assertEquals(VIM_ID, actualVim.getId());
 647         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 648         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 649         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 650         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 651         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 652         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 653         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 654         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 655         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 656     }
 657
 658     /**
 659      * test instantiation with vCloud with SSL
 660      */
 661     @Test
 662     public void testInstantiationVcloudWithSsl() throws Exception {
 663         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 664
 665         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 666         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 667         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 668         grantResponse.setVimId(VIM_ID);
 669         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 670         accessInfo.setTenant(TENANT);
 671         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 672         vimInfo.setSslInsecure("false");
 673         vimInfo.setSslCacert(caCert);
 674         grantResponse.setAccessInfo(accessInfo);
 675         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 676         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 677         //when
 678         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 679         waitForJobToFinishInJobManager(finished);
 680         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 681         //verify
 682         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 683         assertEquals(VIM_ID, actualVim.getId());
 684         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 685         assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification());
 686         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 687         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 688         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 689         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 690         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 691         assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0)));
 692         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification());
 693         assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 694     }
 695
 696     /**
 697      * test instantiation with vCloud with SSL
 698      */
 699     @Test
 700     public void testInstantiationVcloudWithNonSecifedSSl() throws Exception {
 701         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
 702
 703         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 704         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 705         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 706         grantResponse.setVimId(VIM_ID);
 707         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 708         accessInfo.setTenant(TENANT);
 709         vimInfo.setSslInsecure(null);
 710         grantResponse.setAccessInfo(accessInfo);
 711         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 712         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 713         //when
 714         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 715         waitForJobToFinishInJobManager(finished);
 716         assertEquals(1, actualInstantiationRequest.getValue().getVims().size());
 717         //verify
 718         VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0);
 719         assertEquals(VIM_ID, actualVim.getId());
 720         assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType());
 721         assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint());
 722         //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates());
 723         assertEquals("vimPassword", actualVim.getAccessInfo().getPassword());
 724         assertEquals("regionId", actualVim.getAccessInfo().getOrganization());
 725         assertEquals("vimUsername", actualVim.getAccessInfo().getUsername());
 726         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification());
 727         assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck());
 728     }
 729
 730     /**
 731      * test failure in the instantiation request marks the job to be finished in job manager
 732      */
 733     @Test
 734     public void testFailureInTheInstantiationRequest() throws Exception {
 735         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 736         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 737         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 738         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 739         grantResponse.setVimId(VIM_ID);
 740         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 741         accessInfo.setTenant(TENANT);
 742         grantResponse.setAccessInfo(accessInfo);
 743         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 744         RuntimeException expectedException = new RuntimeException();
 745         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 746
 747         //when
 748         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 749         //verfiy
 750         waitForJobToFinishInJobManager(finished);
 751         assertEquals(VNF_ID, response.getVnfInstanceId());
 752         assertEquals(JOB_ID, response.getJobId());
 753         verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException);
 754     }
 755
 756     /**
 757      * instantiation fails if VF-C does not send vim identifier in grant response
 758      */
 759     @Test
 760     public void testVfcFailsToSendVimId() throws Exception {
 761         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 762
 763         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 764         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 765         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 766         //grantResponse.setVimId(VIM_ID);
 767         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 768         accessInfo.setTenant(TENANT);
 769         String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI())));
 770         vimInfo.setSslInsecure("false");
 771         vimInfo.setSslCacert(caCert);
 772         grantResponse.setAccessInfo(accessInfo);
 773         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 774         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 775         //when
 776         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 777         waitForJobToFinishInJobManager(finished);
 778         assertEquals(0, actualInstantiationRequest.getAllValues().size());
 779         //verify
 780         verify(logger).error("VF-C did not send VIM identifier in grant response");
 781
 782     }
 783
 784     /**
 785      * test operation execution polling is retried in case of failures
 786      */
 787     @Test
 788     public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception {
 789         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 790         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 791         additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL);
 792         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 793         grantResponse.setVimId(VIM_ID);
 794         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 795         accessInfo.setTenant(TENANT);
 796         grantResponse.setAccessInfo(accessInfo);
 797         ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class);
 798         List<RuntimeException> polling = new ArrayList<>();
 799         when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(instantiationOperationExecution));
 800         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<Observable<List<OperationExecution>>>() {
 801             @Override
 802             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
 803                 if (polling.size() > 2) {
 804                     return buildObservable(operationExecutions);
 805                 }
 806                 RuntimeException runtimeException = new RuntimeException();
 807                 polling.add(runtimeException);
 808                 throw runtimeException;
 809             }
 810         });
 811         //when
 812         VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 813         //verfiy
 814         waitForJobToFinishInJobManager(finished);
 815         assertEquals(VNF_ID, response.getVnfInstanceId());
 816         assertEquals(JOB_ID, response.getJobId());
 817         assertEquals(3, polling.size());
 818         for (RuntimeException e : polling) {
 819             verify(logger).warn("Unable to retrieve operations details", e);
 820         }
 821         verify(systemFunctions, Mockito.times(3)).sleep(5000);
 822     }
 823
 824     /**
 825      * failure in VNF creation is logged an proagated
 826      */
 827     @Test
 828     public void failureInVnfCreationIsPropagated() throws Exception {
 829         //given
 830         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 831
 832         RuntimeException expectedException = new RuntimeException();
 833         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 834         //when
 835         try {
 836             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 837             //verify
 838             fail();
 839         } catch (RuntimeException e) {
 840             assertEquals(expectedException, e.getCause());
 841             verify(logger).error("Unable to create the VNF", expectedException);
 842         }
 843     }
 844
 845     /**
 846      * failure in updating the modifyable attributes of the VNF  is logged an proagated
 847      */
 848     @Test
 849     public void failureInVnfModificationIsPropagated() throws Exception {
 850         //given
 851         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 852
 853         RuntimeException expectedException = new RuntimeException();
 854         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 855         when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException);
 856
 857         //when
 858         try {
 859             lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 860             //verify
 861             fail();
 862         } catch (RuntimeException e) {
 863             assertEquals(expectedException, e.getCause().getCause());
 864             verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException);
 865         }
 866     }
 867
 868     /**
 869      * if the VIM info can not be queried the VNF is not instantiated and
 870      * error propagated through job
 871      */
 872     @Test
 873     public void testFailureInQueryVimInfo() throws Exception {
 874         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 875         when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(buildObservable(vnfInfo));
 876         when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse);
 877         grantResponse.setVimId(VIM_ID);
 878         GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo();
 879         accessInfo.setTenant(TENANT);
 880         grantResponse.setAccessInfo(accessInfo);
 881
 882         when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException());
 883         //when
 884         lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 885         //verify
 886         waitForJobToFinishInJobManager(finished);
 887         verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any());
 888     }
 889
 890     /**
 891      * test termination basic success scenario
 892      * - the VNF is not deleted before the notifications are processed
 893      */
 894     @Test
 895     public void testTerminationAndDeletion() throws Exception {
 896         //given
 897         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 898         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 899         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 900         vnfInfo.setOperationExecutions(operationExecutions);
 901         VnfProperty vnfdId = new VnfProperty();
 902         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 903         vnfdId.setValue(ONAP_CSAR_ID);
 904         vnfInfo.getExtensions().add(vnfdId);
 905         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 906         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 907             @Override
 908             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 909                 OperationExecution terminationOperation = new OperationExecution();
 910                 terminationOperation.setId("terminationId");
 911                 operationExecutions.add(terminationOperation);
 912                 terminationOperation.setStatus(OperationStatus.FINISHED);
 913                 return buildObservable(terminationOperation);
 914             }
 915         });
 916         when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 917         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 918         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 919         //when
 920         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 921         //verify
 922         waitForJobToFinishInJobManager(finished);
 923         assertEquals(1, actualTerminationRequest.getAllValues().size());
 924         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 925         assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
 926         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 927         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 928         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 929         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 930         VOID_OBSERVABLE.assertCalled();
 931         verify(jobManager).spawnJob(VNF_ID, restResponse);
 932         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
 933     }
 934
 935     /**
 936      * test termination basic success scenario
 937      * - the VNF is not deleted before the notifications are processed
 938      */
 939     @Test
 940     public void testTermination() throws Exception {
 941         //given
 942         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 943         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 944         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 945         vnfInfo.setOperationExecutions(operationExecutions);
 946         VnfProperty vnfdId = new VnfProperty();
 947         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 948         vnfdId.setValue(ONAP_CSAR_ID);
 949         vnfInfo.getExtensions().add(vnfdId);
 950         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 951         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 952             @Override
 953             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 954                 OperationExecution terminationOperation = new OperationExecution();
 955                 terminationOperation.setId("terminationId");
 956                 operationExecutions.add(terminationOperation);
 957                 terminationOperation.setStatus(OperationStatus.FINISHED);
 958                 return buildObservable(terminationOperation);
 959             }
 960         });
 961         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 962         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 963         //when
 964         JobInfo jobInfo = lifecycleManager.terminate(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 965         //verify
 966         waitForJobToFinishInJobManager(finished);
 967         assertEquals(1, actualTerminationRequest.getAllValues().size());
 968         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 969         assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
 970         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 971         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 972         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 973         verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 974         verify(jobManager).spawnJob(VNF_ID, restResponse);
 975         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
 976     }
 977
 978     /**
 979      * test termination of a non instantiated VNF
 980      * - the VNF is not terminated (only deleted)
 981      */
 982     @Test
 983     public void testTerminationOfNonInstantiated() throws Exception {
 984         //given
 985         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 986         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 987         vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
 988         vnfInfo.setOperationExecutions(operationExecutions);
 989         VnfProperty vnfdId = new VnfProperty();
 990         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 991         vnfdId.setValue(ONAP_CSAR_ID);
 992         vnfInfo.getExtensions().add(vnfdId);
 993         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 994         when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 995         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 996         //when
 997         lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 998         //verify
 999         boolean deleted = false;
1000         while (!deleted) {
1001             try {
1002                 verify(logger).info("The VNF with {} identifier has been deleted", VNF_ID);
1003                 deleted = true;
1004             } catch (Error e) {
1005             }
1006         }
1007         verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1008         verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
1009         verify(logger).warn("The VNF with {} identifier is not instantiated no termination is required", VNF_ID);
1010         verify(logger).info("Deleting VNF with {} identifier", VNF_ID);
1011         verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1012         VOID_OBSERVABLE.assertCalled();
1013     }
1014
1015     /**
1016      * test that the VNF deletion is not started before the termination finishes
1017      */
1018     @Test
1019     public void testTerminationOperationIsOutwaited() throws Exception {
1020         //given
1021         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1022         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1023         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1024         vnfInfo.setOperationExecutions(operationExecutions);
1025         VnfProperty vnfdId = new VnfProperty();
1026         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1027         vnfdId.setValue(ONAP_CSAR_ID);
1028         vnfInfo.getExtensions().add(vnfdId);
1029         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1030         OperationExecution terminationOperation = new OperationExecution();
1031         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1032             terminationOperation.setId("terminationId");
1033             operationExecutions.add(terminationOperation);
1034             terminationOperation.setStatus(OperationStatus.STARTED);
1035             return buildObservable(terminationOperation);
1036         });
1037         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1038         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1039         Set<Integer> calls = new HashSet<>();
1040         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
1041             if (calls.size() == 1000) {
1042                 terminationOperation.setStatus(OperationStatus.FINISHED);
1043             }
1044             calls.add(calls.size());
1045             return buildObservable(operationExecutions);
1046         });
1047         //when
1048         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1049         //verify
1050         waitForJobToFinishInJobManager(finished);
1051         verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1052         verify(systemFunctions, times(1000)).sleep(5000);
1053     }
1054
1055
1056     /**
1057      * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
1058      */
1059     @Test
1060     public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
1061         //given
1062         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1063         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1064         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1065         vnfInfo.setOperationExecutions(operationExecutions);
1066         VnfProperty vnfdId = new VnfProperty();
1067         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1068         vnfdId.setValue(ONAP_CSAR_ID);
1069         vnfInfo.getExtensions().add(vnfdId);
1070         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1071         OperationExecution terminationOperation = new OperationExecution();
1072         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1073             @Override
1074             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1075                 terminationOperation.setId("terminationId");
1076                 operationExecutions.add(terminationOperation);
1077                 terminationOperation.setStatus(OperationStatus.STARTED);
1078                 return buildObservable(terminationOperation);
1079             }
1080         });
1081         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1082         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1083         Set<Integer> calls = new HashSet<>();
1084         List<RuntimeException> expectedExceptions = new ArrayList<>();
1085         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1086             @Override
1087             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1088                 if (calls.size() >= 100) {
1089                     terminationOperation.setStatus(OperationStatus.FINISHED);
1090                     return buildObservable(operationExecutions);
1091                 }
1092                 calls.add(calls.size());
1093                 RuntimeException RuntimeException = new RuntimeException();
1094                 expectedExceptions.add(RuntimeException);
1095                 throw RuntimeException;
1096             }
1097         });
1098         //when
1099         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1100         //verify
1101         waitForJobToFinishInJobManager(finished);
1102         verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
1103         verify(systemFunctions, times(100)).sleep(5000);
1104         for (RuntimeException expectedException : expectedExceptions) {
1105             verify(logger).warn("Unable to retrieve operations details", expectedException);
1106         }
1107     }
1108
1109     /**
1110      * test gracefull termination
1111      */
1112     @Test
1113     public void testGracefullTermination() throws Exception {
1114         //given
1115         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1116         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1117         terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
1118         terminationRequest.setGracefulTerminationTimeout("1234");
1119         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1120         vnfInfo.setOperationExecutions(operationExecutions);
1121         VnfProperty vnfdId = new VnfProperty();
1122         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1123         vnfdId.setValue(ONAP_CSAR_ID);
1124         vnfInfo.getExtensions().add(vnfdId);
1125         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1126         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1127             @Override
1128             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1129                 OperationExecution terminationOperation = new OperationExecution();
1130                 terminationOperation.setId("terminationId");
1131                 operationExecutions.add(terminationOperation);
1132                 terminationOperation.setStatus(OperationStatus.FINISHED);
1133                 return buildObservable(terminationOperation);
1134             }
1135         });
1136         doAnswer(invocation -> {
1137             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1138             return null;
1139         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1140         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1141         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1142         //when
1143         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1144         //verify
1145         waitForJobToFinishInJobManager(finished);
1146         assertEquals(1, actualTerminationRequest.getAllValues().size());
1147         assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
1148         assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1149         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1150         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1151         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1152         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1153     }
1154
1155     /**
1156      * instantiation with missing ONAP csarId to instantiation extra param result in failure
1157      */
1158     @Test
1159     public void testMissingVnfParameters() throws Exception {
1160         //given
1161         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1162         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
1163         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1164         //when
1165         try {
1166             VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
1167             fail();
1168         } catch (Exception e) {
1169             assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
1170             verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
1171         }
1172     }
1173
1174     /**
1175      * test explicit forceful termination
1176      */
1177     @Test
1178     public void testExplicitForcefulTermination() throws Exception {
1179         //given
1180         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1181         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1182         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1183         terminationRequest.setGracefulTerminationTimeout("1234");
1184         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1185         vnfInfo.setOperationExecutions(operationExecutions);
1186         VnfProperty vnfdId = new VnfProperty();
1187         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1188         vnfdId.setValue(ONAP_CSAR_ID);
1189         vnfInfo.getExtensions().add(vnfdId);
1190         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1191         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
1192             OperationExecution terminationOperation = new OperationExecution();
1193             terminationOperation.setId("terminationId");
1194             operationExecutions.add(terminationOperation);
1195             terminationOperation.setStatus(OperationStatus.FINISHED);
1196             return buildObservable(terminationOperation);
1197         });
1198         doAnswer(invocation -> {
1199             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
1200             return null;
1201         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1202         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1203         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1204         //when
1205         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1206         //verify
1207         waitForJobToFinishInJobManager(finished);
1208         assertEquals(1, actualTerminationRequest.getAllValues().size());
1209         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1210         assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
1211         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
1212         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1213         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1214         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1215     }
1216
1217     /**
1218      * test failure in the termination workflow finishes the job
1219      */
1220     @Test
1221     public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1222         //given
1223         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1224         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1225         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1226         terminationRequest.setGracefulTerminationTimeout("1234");
1227         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1228         vnfInfo.setOperationExecutions(operationExecutions);
1229         VnfProperty vnfdId = new VnfProperty();
1230         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1231         vnfdId.setValue(ONAP_CSAR_ID);
1232         vnfInfo.getExtensions().add(vnfdId);
1233         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1234         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1235             @Override
1236             public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1237                 OperationExecution terminationOperation = new OperationExecution();
1238                 terminationOperation.setId("terminationId");
1239                 operationExecutions.add(terminationOperation);
1240                 terminationOperation.setStatus(OperationStatus.FINISHED);
1241                 return terminationOperation;
1242             }
1243         });
1244         RuntimeException expectedException = new RuntimeException();
1245         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1246         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1247         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1248         //when
1249         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1250         //verify
1251         waitForJobToFinishInJobManager(finished);
1252         assertEquals(0, actualTerminationRequest.getAllValues().size());
1253         Mockito.verifyZeroInteractions(vfcGrantManager);
1254     }
1255
1256     /**
1257      * if termination fails the VNF is not deleted
1258      */
1259     @Test
1260     public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1261         //given
1262         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1263         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1264         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1265         vnfInfo.setOperationExecutions(operationExecutions);
1266         VnfProperty vnfdId = new VnfProperty();
1267         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1268         vnfdId.setValue(ONAP_CSAR_ID);
1269         vnfInfo.getExtensions().add(vnfdId);
1270         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1271         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1272             @Override
1273             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1274                 OperationExecution terminationOperation = new OperationExecution();
1275                 terminationOperation.setId("terminationId");
1276                 operationExecutions.add(terminationOperation);
1277                 terminationOperation.setStatus(OperationStatus.FAILED);
1278                 return buildObservable(terminationOperation);
1279             }
1280         });
1281         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1282         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1283         //when
1284         JobInfo jobInfo = lifecycleManager.terminateAndDelete(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1285         //verify
1286         waitForJobToFinishInJobManager(finished);
1287         assertEquals(1, actualTerminationRequest.getAllValues().size());
1288         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1289         verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1290         verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1291         verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1292     }
1293
1294     /**
1295      * test VNF query basic success scenario
1296      */
1297     @Test
1298     public void testQuery() throws Exception {
1299         vnfInfo.setDescription("myDescription");
1300         vnfInfo.setName("myName");
1301         vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1302         vnfInfo.setVnfProvider("myProvider");
1303         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1304         VnfProperty prop = new VnfProperty();
1305         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1306         prop.setValue(ONAP_CSAR_ID);
1307         vnfInfo.getExtensions().add(prop);
1308         //when
1309         org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1310         //verify
1311         assertEquals(VNF_ID, vnf.getVnfInstanceId());
1312         //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1313         assertEquals("vnfSoftwareVersion", vnf.getVersion());
1314         assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1315         assertEquals("myDescription", vnf.getVnfInstanceDescription());
1316         assertEquals("myName", vnf.getVnfInstanceName());
1317         assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1318         assertEquals("myProvider", vnf.getVnfProvider());
1319         //FIXME (in swagger schema )
1320         assertEquals("ACTIVE", vnf.getVnfStatus());
1321         assertEquals("Kuku", vnf.getVnfType());
1322     }
1323
1324     /**
1325      * error is propagated and logged if the queried VNF does not exist
1326      */
1327     @Test
1328     public void testQueryForNonExistingVnf() throws Exception {
1329
1330         RuntimeException expectedException = new RuntimeException();
1331         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1332         //when
1333         try {
1334             lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1335             //verify
1336             fail();
1337         } catch (Exception e) {
1338             verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1339             assertEquals(expectedException, e.getCause());
1340         }
1341     }
1342
1343     /**
1344      * test scale basic scenario
1345      */
1346     @Test
1347     public void testScale() throws Exception {
1348         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1349         scaleRequest.setNumberOfSteps("2");
1350         scaleRequest.setAspectId("myAspect");
1351         scaleRequest.setType(ScaleDirection.IN);
1352         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1353         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1354         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1355         VnfProperty prop = new VnfProperty();
1356         prop.setValue(ONAP_CSAR_ID);
1357         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1358         vnfInfo.getExtensions().add(prop);
1359         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1360         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1361         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1362         //when
1363         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1364         //verify
1365         waitForJobToFinishInJobManager(finished);
1366         assertEquals(1, actualScaleRequest.getAllValues().size());
1367         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1368         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1369         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1370         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1371         assertEquals("myAspect", sRequest.getAspectId());
1372         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1373         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1374         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1375         verify(jobManager).spawnJob(VNF_ID, restResponse);
1376         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1377
1378     }
1379
1380     /**
1381      * the VNFM should tolerate that no additional params were supplied
1382      */
1383     @Test
1384     public void testScaleWithoutAddtionalParams() throws Exception {
1385         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1386         scaleRequest.setNumberOfSteps("2");
1387         scaleRequest.setAspectId("myAspect");
1388         scaleRequest.setType(ScaleDirection.IN);
1389         scaleRequest.setAdditionalParam(null);
1390         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1391         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1392         VnfProperty prop = new VnfProperty();
1393         prop.setValue(ONAP_CSAR_ID);
1394         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1395         vnfInfo.getExtensions().add(prop);
1396         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1397         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1398         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1399         //when
1400         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1401         //verify
1402         waitForJobToFinishInJobManager(finished);
1403         assertEquals(1, actualScaleRequest.getAllValues().size());
1404         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1405         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1406         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1407         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1408         assertEquals("myAspect", sRequest.getAspectId());
1409         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1410         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1411         assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1412         verify(jobManager).spawnJob(VNF_ID, restResponse);
1413     }
1414
1415     /**
1416      * test scale out basic scenario
1417      */
1418     @Test
1419     public void testScaleOut() throws Exception {
1420         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1421         scaleRequest.setNumberOfSteps("2");
1422         scaleRequest.setAspectId("myAspect");
1423         scaleRequest.setType(ScaleDirection.OUT);
1424         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1425         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1426         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1427         VnfProperty prop = new VnfProperty();
1428         prop.setValue(ONAP_CSAR_ID);
1429         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1430         vnfInfo.getExtensions().add(prop);
1431         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1432         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1433         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1434         //when
1435         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1436         //verify
1437         waitForJobToFinishInJobManager(finished);
1438         assertEquals(1, actualScaleRequest.getAllValues().size());
1439         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1440         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1441         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1442         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1443         assertEquals("myAspect", sRequest.getAspectId());
1444         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1445         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1446         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1447     }
1448
1449     /**
1450      * test scale operation is out waited
1451      */
1452     @Test
1453     public void testScaleOutwait() throws Exception {
1454         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1455         scaleRequest.setNumberOfSteps("2");
1456         scaleRequest.setAspectId("myAspect");
1457         scaleRequest.setType(ScaleDirection.IN);
1458         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1459         scaleOperationExecution.setStatus(OperationStatus.STARTED);
1460         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1461         VnfProperty prop = new VnfProperty();
1462         prop.setValue(ONAP_CSAR_ID);
1463         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1464         vnfInfo.getExtensions().add(prop);
1465         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1466         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1467         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1468         List<RuntimeException> expectedExceptions = new ArrayList<>();
1469         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1470             if (expectedExceptions.size() >= 100) {
1471                 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1472                 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1473                 return buildObservable(operationExecutions);
1474             }
1475             RuntimeException RuntimeException = new RuntimeException();
1476             expectedExceptions.add(RuntimeException);
1477             throw RuntimeException;
1478         });
1479
1480         //when
1481         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1482         //verify
1483         waitForJobToFinishInJobManager(finished);
1484         assertEquals(100, expectedExceptions.size());
1485         for (RuntimeException expectedException : expectedExceptions) {
1486             verify(logger).warn("Unable to retrieve operations details", expectedException);
1487         }
1488         verify(systemFunctions, times(100)).sleep(5000);
1489     }
1490
1491     /**
1492      * test scale failure propagation
1493      */
1494     @Test
1495     public void testScaleFailurePropagation() throws Exception {
1496         RuntimeException expectedException = new RuntimeException();
1497         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1498         scaleRequest.setNumberOfSteps("2");
1499         scaleRequest.setAspectId("myAspect");
1500         scaleRequest.setType(ScaleDirection.IN);
1501         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1502         //when
1503         lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1504         //verify
1505         waitForJobToFinishInJobManager(finished);
1506         verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1507     }
1508
1509     /**
1510      * test heal basic scenario
1511      */
1512     @Test
1513     public void testHeal() throws Exception {
1514         VnfHealRequest healRequest = new VnfHealRequest();
1515         healRequest.setAction("myAction");
1516         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1517         affectedVm.setVmname("vmName");
1518         healRequest.setAffectedvm(affectedVm);
1519         healOperationExecution.setStatus(OperationStatus.FINISHED);
1520         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1521         VnfProperty prop = new VnfProperty();
1522         prop.setValue(ONAP_CSAR_ID);
1523         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1524         vnfInfo.getExtensions().add(prop);
1525         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1526         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1527         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1528         //when
1529         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1530         //verify
1531         waitForJobToFinishInJobManager(finished);
1532         assertEquals(1, actualHealRequest.getAllValues().size());
1533         HealVnfRequest sRequest = actualHealRequest.getValue();
1534         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1535         workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1536         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1537         JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1538         assertEquals("myAction", root.get("action").getAsString());
1539         assertEquals("vmName", root.get("vmName").getAsString());
1540         assertEquals(JOB_ID, root.get("jobId").getAsString());
1541         verify(jobManager).spawnJob(VNF_ID, restResponse);
1542         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1543     }
1544
1545     /**
1546      * test heal operation is out waited
1547      */
1548     @Test
1549     public void testHealOutwait() throws Exception {
1550         VnfHealRequest healRequest = new VnfHealRequest();
1551         healRequest.setAction("myAction");
1552         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1553         affectedVm.setVmname("vmName");
1554         healRequest.setAffectedvm(affectedVm);
1555         healOperationExecution.setStatus(OperationStatus.FINISHED);
1556         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1557         VnfProperty prop = new VnfProperty();
1558         prop.setValue(ONAP_CSAR_ID);
1559         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1560         vnfInfo.getExtensions().add(prop);
1561         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1562         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1563         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1564         List<RuntimeException> expectedExceptions = new ArrayList<>();
1565         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1566             @Override
1567             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1568                 if (expectedExceptions.size() >= 100) {
1569                     scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1570                     return buildObservable(operationExecutions);
1571                 }
1572                 RuntimeException RuntimeException = new RuntimeException();
1573                 expectedExceptions.add(RuntimeException);
1574                 throw RuntimeException;
1575             }
1576         });
1577         //when
1578         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1579         //verify
1580         waitForJobToFinishInJobManager(finished);
1581         assertEquals(100, expectedExceptions.size());
1582         for (RuntimeException expectedException : expectedExceptions) {
1583             verify(logger).warn("Unable to retrieve operations details", expectedException);
1584         }
1585         verify(systemFunctions, times(100)).sleep(5000);
1586     }
1587
1588     /**
1589      * failure in heal propagates in error
1590      */
1591     @Test
1592     public void testHealFailurePropagation() throws Exception {
1593         RuntimeException expectedException = new RuntimeException();
1594         VnfHealRequest healRequest = new VnfHealRequest();
1595         healRequest.setAction("myAction");
1596         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1597         affectedVm.setVmname("vmName");
1598         healRequest.setAffectedvm(affectedVm);
1599         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1600         //when
1601         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1602         //verify
1603         waitForJobToFinishInJobManager(finished);
1604         verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1605     }
1606
1607
1608     /**
1609      * test custom operation basic scenario
1610      */
1611     @Test
1612     public void testCustomOperation() throws Exception {
1613         String operationId = "operationIdCaptor";
1614         Object additionalParams = new JsonObject();
1615         //when
1616         JobInfo job = lifecycleManager.customOperation(VNFM_ID, VNF_ID, operationId, additionalParams, restResponse);
1617         //verify
1618         waitForJobToFinishInJobManager(finished);
1619         assertEquals(operationId, operationIdCaptor.getValue());
1620         assertEquals(additionalParams, customOperationRequestArgumentCaptor.getValue().getAdditionalParams());
1621     }
1622
1623     private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1624         while (finished.size() == 0) {
1625             systemFunctions().sleep(100);
1626         }
1627     }
1628
1629     private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1630         VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1631         instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1632         instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1633         instantiationRequest.setVnfInstanceDescription("myDescription");
1634         instantiationRequest.setVnfInstanceName("vnfName");
1635         additionalParam.setInstantiationLevel("level1");
1636         switch (cloudType) {
1637             case OPENSTACK_V2_INFO:
1638                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1639                 break;
1640             case OPENSTACK_V3_INFO:
1641                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1642                 vimInfo.setDomain("myDomain");
1643                 break;
1644             case VMWARE_VCLOUD_INFO:
1645                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1646                 break;
1647             default:
1648                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1649         }
1650
1651         Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1652         exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1653         NetworkAddress networkAddress = new NetworkAddress();
1654         networkAddress.setIp("1.2.3.4");
1655         networkAddress.setMac("mac");
1656         networkAddress.setSubnetId("subnetId");
1657         exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1658         additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1659         VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1660         flavor.setResourceId("flavourProviderId");
1661         flavor.setVimId(VIM_ID);
1662         flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1663         additionalParam.getComputeResourceFlavours().add(flavor);
1664         ExtVirtualLinkData evl = new ExtVirtualLinkData();
1665         evl.setResourceId("networkProviderId1");
1666         evl.setVimId(VIM_ID);
1667         evl.setExtVirtualLinkId("evlId1");
1668         VnfExtCpData ecp2 = new VnfExtCpData();
1669         ecp2.setCpdId("cpdId3");
1670         ecp2.setAddresses(new ArrayList<>());
1671         ecp2.getAddresses().add(networkAddress);
1672         ecp2.setNumDynamicAddresses(2);
1673         evl.getExtCps().add(ecp2);
1674         additionalParam.getExtVirtualLinks().add(evl);
1675         externalVirtualLink.setCpdId("myCpdId");
1676         externalVirtualLink.setResourceId("myNetworkProviderId");
1677         externalVirtualLink.setVlInstanceId("myEVlId");
1678         externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1679         instantiationRequest.setExtVirtualLink(new ArrayList<>());
1680         instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1681         additionalParam.getExtManagedVirtualLinks().add(extManVl);
1682         ZoneInfo zone = new ZoneInfo();
1683         zone.setId("zoneId");
1684         zone.setResourceId("zoneProviderId");
1685         zone.setVimId(VIM_ID);
1686         additionalParam.getZones().add(zone);
1687         VimSoftwareImage image = new VimSoftwareImage();
1688         image.setResourceId("imageProviderId");
1689         image.setVimId(VIM_ID);
1690         image.setVnfdSoftwareImageId("imageId");
1691         additionalParam.getSoftwareImages().add(image);
1692         additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1693         String params = new Gson().toJson(additionalParam);
1694         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1695         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1696         return instantiationRequest;
1697     }
1698
1699     /**
1700      * Test vimId decomposition
1701      */
1702     @Test
1703     public void testVimIdSplitting() {
1704         assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1705         assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));
1706     }
1707 }