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 java.nio.file.Paths;
  29 import java.util.*;
  30 import javax.servlet.http.HttpServletResponse;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.mockito.ArgumentCaptor;
  34 import org.mockito.InOrder;
  35 import org.mockito.Mock;
  36 import org.mockito.Mockito;
  37 import org.mockito.invocation.InvocationOnMock;
  38 import org.mockito.stubbing.Answer;
  39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider;
  40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager;
  41 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager;
  42 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader;
  43 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager;
  44 import org.onap.vnfmdriver.model.ExtVirtualLinkInfo;
  45 import org.onap.vnfmdriver.model.*;
  46 import org.onap.vnfmdriver.model.ScaleDirection;
  47 import org.threeten.bp.OffsetDateTime;
  48
  49 import static java.lang.Boolean.parseBoolean;
  50 import static java.nio.file.Files.readAllBytes;
  51 import static java.util.Optional.empty;
  52
  53 import static junit.framework.TestCase.*;
  54 import static org.mockito.Matchers.eq;
  55 import static org.mockito.Mockito.*;
  56 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child;
  57 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions;
  58 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
  59 import static org.springframework.test.util.ReflectionTestUtils.setField;
  60
  61 public class TestLifecycleManager extends TestBase {
  62     public static final String JOB_ID = "myJobId";
  63     public static final String CBAM_VNFD_ID = "cbamVnfdId";
  64     public static final String TENANT = "myTenant";
  65     public static final String OPERATION_EXECUTION_ID = "operationExecutionId";
  66     private static final String ONAP_CSAR_ID = "myOnapCsarId";
  67     private static final String VIM_ID = "ownerId_regionId";
  68     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         when(vnfApi.vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 750         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 751         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 752         //when
 753         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 754         //verify
 755         waitForJobToFinishInJobManager(finished);
 756         assertEquals(1, actualTerminationRequest.getAllValues().size());
 757         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 758         assertEquals(JOB_ID, new Gson().toJsonTree(actualTerminationRequest.getValue().getAdditionalParams()).getAsJsonObject().get("jobId").getAsString());
 759         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 760         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 761         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 762         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 763         VOID_OBSERVABLE.assertCalled();
 764         verify(jobManager).spawnJob(VNF_ID, restResponse);
 765         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("termination"), eq(VNF_ID), anyString());
 766     }
 767
 768     /**
 769      * test termination of a non instantiated VNF
 770      * - the VNF is not terminated (only deleted)
 771      */
 772     @Test
 773     public void testTerminationOfNonInstantiated() throws Exception {
 774         //given
 775         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 776         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 777         vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED);
 778         vnfInfo.setOperationExecutions(operationExecutions);
 779         VnfProperty vnfdId = new VnfProperty();
 780         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 781         vnfdId.setValue(ONAP_CSAR_ID);
 782         vnfInfo.getExtensions().add(vnfdId);
 783         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 784         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 785         //when
 786         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 787         //verify
 788         boolean deleted = false;
 789         while (!deleted) {
 790             try {
 791                 Mockito.
 792                         verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 793                 deleted = true;
 794             } catch (Error e) {
 795             }
 796         }
 797         verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 798         verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId");
 799     }
 800
 801     /**
 802      * test that the VNF deletion is not started before the termination finishes
 803      */
 804     @Test
 805     public void testTerminationOperationIsOutwaited() throws Exception {
 806         //given
 807         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 808         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 809         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 810         vnfInfo.setOperationExecutions(operationExecutions);
 811         VnfProperty vnfdId = new VnfProperty();
 812         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 813         vnfdId.setValue(ONAP_CSAR_ID);
 814         vnfInfo.getExtensions().add(vnfdId);
 815         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 816         OperationExecution terminationOperation = new OperationExecution();
 817         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
 818             terminationOperation.setId("terminationId");
 819             operationExecutions.add(terminationOperation);
 820             terminationOperation.setStatus(OperationStatus.STARTED);
 821             return buildObservable(terminationOperation);
 822         });
 823         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 824         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 825         Set<Integer> calls = new HashSet<>();
 826         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(invocation -> {
 827             if (calls.size() == 1000) {
 828                 terminationOperation.setStatus(OperationStatus.FINISHED);
 829             }
 830             calls.add(calls.size());
 831             return buildObservable(operationExecutions);
 832         });
 833         //when
 834         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 835         //verify
 836         waitForJobToFinishInJobManager(finished);
 837         verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
 838         verify(systemFunctions, times(1000)).sleep(5000);
 839     }
 840
 841
 842     /**
 843      * test that failured during waiting for the operation to finish is tolerated (idefineiatelly)
 844      */
 845     @Test
 846     public void testTerminationOperationIsOutwaitedWithErrors() throws Exception {
 847         //given
 848         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 849         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 850         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 851         vnfInfo.setOperationExecutions(operationExecutions);
 852         VnfProperty vnfdId = new VnfProperty();
 853         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 854         vnfdId.setValue(ONAP_CSAR_ID);
 855         vnfInfo.getExtensions().add(vnfdId);
 856         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 857         OperationExecution terminationOperation = new OperationExecution();
 858         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 859             @Override
 860             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 861                 terminationOperation.setId("terminationId");
 862                 operationExecutions.add(terminationOperation);
 863                 terminationOperation.setStatus(OperationStatus.STARTED);
 864                 return buildObservable(terminationOperation);
 865             }
 866         });
 867         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 868         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 869         Set<Integer> calls = new HashSet<>();
 870         List<RuntimeException> expectedExceptions = new ArrayList<>();
 871         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
 872             @Override
 873             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
 874                 if (calls.size() >= 100) {
 875                     terminationOperation.setStatus(OperationStatus.FINISHED);
 876                     return buildObservable(operationExecutions);
 877                 }
 878                 calls.add(calls.size());
 879                 RuntimeException RuntimeException = new RuntimeException();
 880                 expectedExceptions.add(RuntimeException);
 881                 throw RuntimeException;
 882             }
 883         });
 884         //when
 885         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 886         //verify
 887         waitForJobToFinishInJobManager(finished);
 888         verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION);
 889         verify(systemFunctions, times(100)).sleep(5000);
 890         for (RuntimeException expectedException : expectedExceptions) {
 891             verify(logger).warn("Unable to retrieve operations details", expectedException);
 892         }
 893     }
 894
 895     /**
 896      * test gracefull termination
 897      */
 898     @Test
 899     public void testGracefullTermination() throws Exception {
 900         //given
 901         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 902         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 903         terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL);
 904         terminationRequest.setGracefulTerminationTimeout("1234");
 905         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 906         vnfInfo.setOperationExecutions(operationExecutions);
 907         VnfProperty vnfdId = new VnfProperty();
 908         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 909         vnfdId.setValue(ONAP_CSAR_ID);
 910         vnfInfo.getExtensions().add(vnfdId);
 911         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 912         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
 913             @Override
 914             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
 915                 OperationExecution terminationOperation = new OperationExecution();
 916                 terminationOperation.setId("terminationId");
 917                 operationExecutions.add(terminationOperation);
 918                 terminationOperation.setStatus(OperationStatus.FINISHED);
 919                 return buildObservable(terminationOperation);
 920             }
 921         });
 922         doAnswer(invocation -> {
 923             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
 924             return null;
 925         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 926         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 927         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 928         //when
 929         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 930         //verify
 931         waitForJobToFinishInJobManager(finished);
 932         assertEquals(1, actualTerminationRequest.getAllValues().size());
 933         assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType());
 934         assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout());
 935         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 936         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 937         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
 938         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 939     }
 940
 941     /**
 942      * instantiation with missing ONAP csarId to instantiation extra param result in failure
 943      */
 944     @Test
 945     public void testMissingVnfParameters() throws Exception {
 946         //given
 947         VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
 948         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}";
 949         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
 950         //when
 951         try {
 952             VnfInstantiateResponse response = lifecycleManager.createAndInstantiate(VNFM_ID, instantiationRequest, restResponse);
 953             fail();
 954         } catch (Exception e) {
 955             assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage());
 956             verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id");
 957         }
 958     }
 959
 960     /**
 961      * test explicit forceful termination
 962      */
 963     @Test
 964     public void testExplicitForcefulTermination() throws Exception {
 965         //given
 966         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
 967         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
 968         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
 969         terminationRequest.setGracefulTerminationTimeout("1234");
 970         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
 971         vnfInfo.setOperationExecutions(operationExecutions);
 972         VnfProperty vnfdId = new VnfProperty();
 973         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
 974         vnfdId.setValue(ONAP_CSAR_ID);
 975         vnfInfo.getExtensions().add(vnfdId);
 976         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
 977         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(invocation -> {
 978             OperationExecution terminationOperation = new OperationExecution();
 979             terminationOperation.setId("terminationId");
 980             operationExecutions.add(terminationOperation);
 981             terminationOperation.setStatus(OperationStatus.FINISHED);
 982             return buildObservable(terminationOperation);
 983         });
 984         doAnswer(invocation -> {
 985             verify(jobManager, Mockito.never()).jobFinished(JOB_ID);
 986             return null;
 987         }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
 988         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
 989         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
 990         //when
 991         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
 992         //verify
 993         waitForJobToFinishInJobManager(finished);
 994         assertEquals(1, actualTerminationRequest.getAllValues().size());
 995         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
 996         assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout());
 997         InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi);
 998         notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
 999         notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId");
1000         notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1001     }
1002
1003     /**
1004      * test failure in the termination workflow finishes the job
1005      */
1006     @Test
1007     public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception {
1008         //given
1009         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1010         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1011         terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL);
1012         terminationRequest.setGracefulTerminationTimeout("1234");
1013         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1014         vnfInfo.setOperationExecutions(operationExecutions);
1015         VnfProperty vnfdId = new VnfProperty();
1016         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1017         vnfdId.setValue(ONAP_CSAR_ID);
1018         vnfInfo.getExtensions().add(vnfdId);
1019         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1020         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() {
1021             @Override
1022             public OperationExecution answer(InvocationOnMock invocation) throws Throwable {
1023                 OperationExecution terminationOperation = new OperationExecution();
1024                 terminationOperation.setId("terminationId");
1025                 operationExecutions.add(terminationOperation);
1026                 terminationOperation.setStatus(OperationStatus.FINISHED);
1027                 return terminationOperation;
1028             }
1029         });
1030         RuntimeException expectedException = new RuntimeException();
1031         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1032         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1033         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1034         //when
1035         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1036         //verify
1037         waitForJobToFinishInJobManager(finished);
1038         assertEquals(0, actualTerminationRequest.getAllValues().size());
1039         Mockito.verifyZeroInteractions(vfcGrantManager);
1040     }
1041
1042     /**
1043      * if termination fails the VNF is not deleted
1044      */
1045     @Test
1046     public void testFailedTerminationAbortsTerminationWorkflow() throws Exception {
1047         //given
1048         VnfTerminateRequest terminationRequest = new VnfTerminateRequest();
1049         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1050         vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED);
1051         vnfInfo.setOperationExecutions(operationExecutions);
1052         VnfProperty vnfdId = new VnfProperty();
1053         vnfdId.setName(LifecycleManager.ONAP_CSAR_ID);
1054         vnfdId.setValue(ONAP_CSAR_ID);
1055         vnfInfo.getExtensions().add(vnfdId);
1056         ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class);
1057         when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<Observable<OperationExecution>>() {
1058             @Override
1059             public Observable<OperationExecution> answer(InvocationOnMock invocation) throws Throwable {
1060                 OperationExecution terminationOperation = new OperationExecution();
1061                 terminationOperation.setId("terminationId");
1062                 operationExecutions.add(terminationOperation);
1063                 terminationOperation.setStatus(OperationStatus.FAILED);
1064                 return buildObservable(terminationOperation);
1065             }
1066         });
1067         JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } ");
1068         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(instantiationParameters));
1069         //when
1070         JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse);
1071         //verify
1072         waitForJobToFinishInJobManager(finished);
1073         assertEquals(1, actualTerminationRequest.getAllValues().size());
1074         assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType());
1075         verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID);
1076         verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION);
1077         verify(logger).error("Unable to terminate VNF the operation did not finish with success");
1078     }
1079
1080     /**
1081      * test VNF query basic success scenario
1082      */
1083     @Test
1084     public void testQuery() throws Exception {
1085         vnfInfo.setDescription("myDescription");
1086         vnfInfo.setName("myName");
1087         vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion");
1088         vnfInfo.setVnfProvider("myProvider");
1089         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1090         VnfProperty prop = new VnfProperty();
1091         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1092         prop.setValue(ONAP_CSAR_ID);
1093         vnfInfo.getExtensions().add(prop);
1094         //when
1095         org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1096         //verify
1097         assertEquals(VNF_ID, vnf.getVnfInstanceId());
1098         //FIXME ? (do not know what exactly the vnf version mean in core terminology)
1099         assertEquals("vnfSoftwareVersion", vnf.getVersion());
1100         assertEquals(ONAP_CSAR_ID, vnf.getVnfdId());
1101         assertEquals("myDescription", vnf.getVnfInstanceDescription());
1102         assertEquals("myName", vnf.getVnfInstanceName());
1103         assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId());
1104         assertEquals("myProvider", vnf.getVnfProvider());
1105         //FIXME (in swagger schema )
1106         assertEquals("ACTIVE", vnf.getVnfStatus());
1107         assertEquals("Kuku", vnf.getVnfType());
1108     }
1109
1110     /**
1111      * error is propagated and logged if the queried VNF does not exist
1112      */
1113     @Test
1114     public void testQueryForNonExistingVnf() throws Exception {
1115
1116         RuntimeException expectedException = new RuntimeException();
1117         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1118         //when
1119         try {
1120             lifecycleManager.queryVnf(VNFM_ID, VNF_ID);
1121             //verify
1122             fail();
1123         } catch (Exception e) {
1124             verify(logger).error("Unable to query VNF (myVnfId)", expectedException);
1125             assertEquals(expectedException, e.getCause());
1126         }
1127     }
1128
1129     /**
1130      * test scale basic scenario
1131      */
1132     @Test
1133     public void testScale() throws Exception {
1134         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1135         scaleRequest.setNumberOfSteps("2");
1136         scaleRequest.setAspectId("myAspect");
1137         scaleRequest.setType(ScaleDirection.IN);
1138         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }"));
1139         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1140         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1141         VnfProperty prop = new VnfProperty();
1142         prop.setValue(ONAP_CSAR_ID);
1143         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1144         vnfInfo.getExtensions().add(prop);
1145         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1146         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1147         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1148         //when
1149         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1150         //verify
1151         waitForJobToFinishInJobManager(finished);
1152         assertEquals(1, actualScaleRequest.getAllValues().size());
1153         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1154         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1155         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1156         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1157         assertEquals("myAspect", sRequest.getAspectId());
1158         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1159         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1160         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1161         verify(jobManager).spawnJob(VNF_ID, restResponse);
1162         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("scale"), eq(VNF_ID), anyString());
1163
1164     }
1165
1166     /**
1167      * the VNFM should tolerate that no additional params were supplied
1168      */
1169     @Test
1170     public void testScaleWithoutAddtionalParams() throws Exception {
1171         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1172         scaleRequest.setNumberOfSteps("2");
1173         scaleRequest.setAspectId("myAspect");
1174         scaleRequest.setType(ScaleDirection.IN);
1175         scaleRequest.setAdditionalParam(null);
1176         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1177         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1178         VnfProperty prop = new VnfProperty();
1179         prop.setValue(ONAP_CSAR_ID);
1180         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1181         vnfInfo.getExtensions().add(prop);
1182         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1183         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1184         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1185         //when
1186         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1187         //verify
1188         waitForJobToFinishInJobManager(finished);
1189         assertEquals(1, actualScaleRequest.getAllValues().size());
1190         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1191         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1192         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1193         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1194         assertEquals("myAspect", sRequest.getAspectId());
1195         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType());
1196         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1197         assertEquals("{\"jobId\":\"myJobId\"}", new Gson().toJson(sRequest.getAdditionalParams()));
1198         verify(jobManager).spawnJob(VNF_ID, restResponse);
1199     }
1200
1201     /**
1202      * test scale out basic scenario
1203      */
1204     @Test
1205     public void testScaleOut() throws Exception {
1206         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1207         scaleRequest.setNumberOfSteps("2");
1208         scaleRequest.setAspectId("myAspect");
1209         scaleRequest.setType(ScaleDirection.OUT);
1210         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1211         scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1212         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1213         VnfProperty prop = new VnfProperty();
1214         prop.setValue(ONAP_CSAR_ID);
1215         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1216         vnfInfo.getExtensions().add(prop);
1217         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1218         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1219         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1220         //when
1221         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1222         //verify
1223         waitForJobToFinishInJobManager(finished);
1224         assertEquals(1, actualScaleRequest.getAllValues().size());
1225         ScaleVnfRequest sRequest = actualScaleRequest.getValue();
1226         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1227         workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID));
1228         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1229         assertEquals("myAspect", sRequest.getAspectId());
1230         assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType());
1231         assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps());
1232         assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())));
1233     }
1234
1235     /**
1236      * test scale operation is out waited
1237      */
1238     @Test
1239     public void testScaleOutwait() throws Exception {
1240         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1241         scaleRequest.setNumberOfSteps("2");
1242         scaleRequest.setAspectId("myAspect");
1243         scaleRequest.setType(ScaleDirection.IN);
1244         scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }"));
1245         scaleOperationExecution.setStatus(OperationStatus.STARTED);
1246         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1247         VnfProperty prop = new VnfProperty();
1248         prop.setValue(ONAP_CSAR_ID);
1249         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1250         vnfInfo.getExtensions().add(prop);
1251         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1252         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1253         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1254         List<RuntimeException> expectedExceptions = new ArrayList<>();
1255         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<Observable<List<OperationExecution>>>) invocation -> {
1256             if (expectedExceptions.size() >= 100) {
1257                 when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(scaleOperationExecution));
1258                 scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1259                 return buildObservable(operationExecutions);
1260             }
1261             RuntimeException RuntimeException = new RuntimeException();
1262             expectedExceptions.add(RuntimeException);
1263             throw RuntimeException;
1264         });
1265
1266         //when
1267         JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1268         //verify
1269         waitForJobToFinishInJobManager(finished);
1270         assertEquals(100, expectedExceptions.size());
1271         for (RuntimeException expectedException : expectedExceptions) {
1272             verify(logger).warn("Unable to retrieve operations details", expectedException);
1273         }
1274         verify(systemFunctions, times(100)).sleep(5000);
1275     }
1276
1277     /**
1278      * test scale failure propagation
1279      */
1280     @Test
1281     public void testScaleFailurePropagation() throws Exception {
1282         RuntimeException expectedException = new RuntimeException();
1283         VnfScaleRequest scaleRequest = new VnfScaleRequest();
1284         scaleRequest.setNumberOfSteps("2");
1285         scaleRequest.setAspectId("myAspect");
1286         scaleRequest.setType(ScaleDirection.IN);
1287         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1288         //when
1289         lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse);
1290         //verify
1291         waitForJobToFinishInJobManager(finished);
1292         verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException);
1293     }
1294
1295     /**
1296      * test heal basic scenario
1297      */
1298     @Test
1299     public void testHeal() throws Exception {
1300         VnfHealRequest healRequest = new VnfHealRequest();
1301         healRequest.setAction("myAction");
1302         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1303         affectedVm.setVmname("vmName");
1304         healRequest.setAffectedvm(affectedVm);
1305         healOperationExecution.setStatus(OperationStatus.FINISHED);
1306         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1307         VnfProperty prop = new VnfProperty();
1308         prop.setValue(ONAP_CSAR_ID);
1309         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1310         vnfInfo.getExtensions().add(prop);
1311         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1312         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1313         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1314         //when
1315         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1316         //verify
1317         waitForJobToFinishInJobManager(finished);
1318         assertEquals(1, actualHealRequest.getAllValues().size());
1319         HealVnfRequest sRequest = actualHealRequest.getValue();
1320         InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi);
1321         workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID));
1322         workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION);
1323         JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject();
1324         assertEquals("myAction", root.get("action").getAsString());
1325         assertEquals("vmName", root.get("vmName").getAsString());
1326         assertEquals(JOB_ID, root.get("jobId").getAsString());
1327         verify(jobManager).spawnJob(VNF_ID, restResponse);
1328         verify(logger).info(eq("Starting {} operation on VNF with {} identifier with {} parameter"), eq("heal"), eq(VNF_ID), anyString());
1329     }
1330
1331     /**
1332      * test heal operation is out waited
1333      */
1334     @Test
1335     public void testHealOutwait() throws Exception {
1336         VnfHealRequest healRequest = new VnfHealRequest();
1337         healRequest.setAction("myAction");
1338         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1339         affectedVm.setVmname("vmName");
1340         healRequest.setAffectedvm(affectedVm);
1341         healOperationExecution.setStatus(OperationStatus.FINISHED);
1342         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(vnfInfo));
1343         VnfProperty prop = new VnfProperty();
1344         prop.setValue(ONAP_CSAR_ID);
1345         prop.setName(LifecycleManager.ONAP_CSAR_ID);
1346         vnfInfo.getExtensions().add(prop);
1347         vnfInfo.getOperationExecutions().add(instantiationOperationExecution);
1348         String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }";
1349         when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(buildObservable(new JsonParser().parse(instantiationParams)));
1350         List<RuntimeException> expectedExceptions = new ArrayList<>();
1351         when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<Observable<List<OperationExecution>>>() {
1352             @Override
1353             public Observable<List<OperationExecution>> answer(InvocationOnMock invocation) throws Throwable {
1354                 if (expectedExceptions.size() >= 100) {
1355                     scaleOperationExecution.setStatus(OperationStatus.FINISHED);
1356                     return buildObservable(operationExecutions);
1357                 }
1358                 RuntimeException RuntimeException = new RuntimeException();
1359                 expectedExceptions.add(RuntimeException);
1360                 throw RuntimeException;
1361             }
1362         });
1363         //when
1364         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1365         //verify
1366         waitForJobToFinishInJobManager(finished);
1367         assertEquals(100, expectedExceptions.size());
1368         for (RuntimeException expectedException : expectedExceptions) {
1369             verify(logger).warn("Unable to retrieve operations details", expectedException);
1370         }
1371         verify(systemFunctions, times(100)).sleep(5000);
1372     }
1373
1374     /**
1375      * failure in heal propagates in error
1376      */
1377     @Test
1378     public void testHealFailurePropagation() throws Exception {
1379         RuntimeException expectedException = new RuntimeException();
1380         VnfHealRequest healRequest = new VnfHealRequest();
1381         healRequest.setAction("myAction");
1382         VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm();
1383         affectedVm.setVmname("vmName");
1384         healRequest.setAffectedvm(affectedVm);
1385         when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException);
1386         //when
1387         JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, empty(), restResponse);
1388         //verify
1389         waitForJobToFinishInJobManager(finished);
1390         verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException);
1391     }
1392
1393     private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException {
1394         while (finished.size() == 0) {
1395             systemFunctions().sleep(100);
1396         }
1397     }
1398
1399     private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) {
1400         VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest();
1401         instantiationRequest.setVnfPackageId(ONAP_CSAR_ID);
1402         instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID);
1403         instantiationRequest.setVnfInstanceDescription("myDescription");
1404         instantiationRequest.setVnfInstanceName("vnfName");
1405         additionalParam.setInstantiationLevel("level1");
1406         switch (cloudType) {
1407             case OPENSTACK_V2_INFO:
1408                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO);
1409                 break;
1410             case OPENSTACK_V3_INFO:
1411                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO);
1412                 additionalParam.setDomain("myDomain");
1413                 break;
1414             case VMWARE_VCLOUD_INFO:
1415                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO);
1416                 break;
1417             default:
1418                 additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO);
1419         }
1420
1421         Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>();
1422         exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>());
1423         NetworkAddress networkAddress = new NetworkAddress();
1424         networkAddress.setIp("1.2.3.4");
1425         networkAddress.setMac("mac");
1426         networkAddress.setSubnetId("subnetId");
1427         exteranalConnectionPointAddresses.get("ecp1").add(networkAddress);
1428         additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses);
1429         VimComputeResourceFlavour flavor = new VimComputeResourceFlavour();
1430         flavor.setResourceId("flavourProviderId");
1431         flavor.setVimId(VIM_ID);
1432         flavor.setVnfdVirtualComputeDescId("virtualComputeDescId");
1433         additionalParam.getComputeResourceFlavours().add(flavor);
1434         ExtVirtualLinkData evl = new ExtVirtualLinkData();
1435         evl.setResourceId("networkProviderId1");
1436         evl.setVimId(VIM_ID);
1437         evl.setExtVirtualLinkId("evlId1");
1438         VnfExtCpData ecp2 = new VnfExtCpData();
1439         ecp2.setCpdId("cpdId3");
1440         ecp2.setAddresses(new ArrayList<>());
1441         ecp2.getAddresses().add(networkAddress);
1442         ecp2.setNumDynamicAddresses(2);
1443         evl.getExtCps().add(ecp2);
1444         additionalParam.getExtVirtualLinks().add(evl);
1445         externalVirtualLink.setCpdId("myCpdId");
1446         externalVirtualLink.setResourceId("myNetworkProviderId");
1447         externalVirtualLink.setVlInstanceId("myEVlId");
1448         externalVirtualLink.setResourceSubnetId("notUsedSubnetId");
1449         instantiationRequest.setExtVirtualLink(new ArrayList<>());
1450         instantiationRequest.getExtVirtualLink().add(externalVirtualLink);
1451         additionalParam.getExtManagedVirtualLinks().add(extManVl);
1452         ZoneInfo zone = new ZoneInfo();
1453         zone.setId("zoneId");
1454         zone.setResourceId("zoneProviderId");
1455         zone.setVimId(VIM_ID);
1456         additionalParam.getZones().add(zone);
1457         VimSoftwareImage image = new VimSoftwareImage();
1458         image.setResourceId("imageProviderId");
1459         image.setVimId(VIM_ID);
1460         image.setVnfdSoftwareImageId("imageId");
1461         additionalParam.getSoftwareImages().add(image);
1462         additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }"));
1463         String params = new Gson().toJson(additionalParam);
1464         String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}";
1465         instantiationRequest.setAdditionalParam(new JsonParser().parse(src));
1466         return instantiationRequest;
1467     }
1468
1469     /**
1470      * Test vimId decomposition
1471      */
1472     @Test
1473     public void testVimIdSplitting() {
1474         assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId"));
1475         assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId"));
1476     }
1477 }