nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java

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