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