diff options
author | Denes Nemeth <denes.nemeth@nokia.com> | 2018-02-12 20:55:54 +0100 |
---|---|---|
committer | Denes Nemeth <denes.nemeth@nokia.com> | 2018-02-23 11:44:45 +0100 |
commit | b17042b955489d8a023d09abad5436ff9b900dc3 (patch) | |
tree | 1e4392ac04a2fb1ed8d17075d504cf6594acaf16 /nokiav2/driver/src/test | |
parent | d4982f7b1777e9cdae9a4cc7d0d104263889ac69 (diff) |
Updating Nokia driver
Change-Id: I950afe6acbdb359cd67a448024f006a45e8fc293
Signed-off-by: Denes Nemeth <denes.nemeth@nokia.com>
Issue-ID: VFC-728
Diffstat (limited to 'nokiav2/driver/src/test')
66 files changed, 8697 insertions, 0 deletions
diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/FullUnitTestSuite.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/FullUnitTestSuite.java new file mode 100644 index 00000000..f5f60fb1 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/FullUnitTestSuite.java @@ -0,0 +1,99 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestCbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestGenericExternalSystemInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestIpMappingProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.TestMsbApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestCbamVnfPackageBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestCbamVnfdBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestOnapVnfPackageBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.TestOnapVnfdBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.TestConditions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.TestRealConfig; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring.TestServletInitializer; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestCbamUtils; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestStoreLoader; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestSystemFunctions; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.TestLifecycleChangeNotificationManager; + +@RunWith(Suite.class) +@Suite.SuiteClasses({ + + TestCbamRestApiProvider.class, + TestGenericExternalSystemInfoProvider.class, + TestIpMappingProvider.class, + TestMsbApiProvider.class, + + TestVfcExternalSystemInfoProvider.class, + TestVfcGrantManager.class, + TestVfcPackageProvider.class, + TestVfcRestApiProvider.class, + TestVfcNotificationSender.class, + + TestCbamVnfdBuilder.class, + TestOnapVnfdBuilder.class, + TestCbamVnfPackageBuilder.class, + TestOnapVnfPackageBuilder.class, + + TestConverterApi.class, + TestLcmApi.class, + TestLcnApi.class, + TestSwaggerApi.class, + TestSwaggerDefinitionConsistency.class, + + TestConditions.class, + TestServletInitializer.class, + TestRealConfig.class, + + TestCbamUtils.class, + TestStoreLoader.class, + TestSystemFunctions.class, + + TestAdditionalParams.class, + TestCbamCatalogManager.class, + TestCbamTokenProvider.class, + TestDriverProperties.class, + TestJobManager.class, + TestVfcGrantManager.class, + TestLifecycleChangeNotificationManager.class, + TestLifecycleManager.class, + TestSelfRegistrationManager.class, + + TestNokiaSvnfmApplication.class, + +}) +public class FullUnitTestSuite { +} + + + + + + + + + + + + + diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/TestNokiaSvnfmApplication.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/TestNokiaSvnfmApplication.java new file mode 100644 index 00000000..47e441ff --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/TestNokiaSvnfmApplication.java @@ -0,0 +1,151 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia; + +import junit.framework.TestCase; +import org.apache.log4j.Logger; +import org.junit.Before; +import org.junit.Test; +import org.mockito.*; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager; +import org.springframework.boot.context.event.ApplicationReadyEvent; +import org.springframework.context.event.ContextClosedEvent; +import org.springframework.test.util.ReflectionTestUtils; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertTrue; +import static org.mockito.Mockito.verify; + + +public class TestNokiaSvnfmApplication { + @Mock + private SelfRegistrationManager selfRegistrationManager; + @Mock + private JobManager jobManager; + @Mock + private Logger logger; + @InjectMocks + private NokiaSvnfmApplication.SelfRegistrationTrigger selfRegistrationTriggerer; + @InjectMocks + private NokiaSvnfmApplication.SelfDeRegistrationTrigger selfUnregistrationTriggerer; + + + @Before + public void initMocks() throws Exception { + MockitoAnnotations.initMocks(this); + ReflectionTestUtils.setField(NokiaSvnfmApplication.class, "logger", logger); + } + + /** + * Assert that the entry point of the application does not change + */ + @Test + public void doNotRename() { + //verify + //1. if the entry point is renamed the main class of spring boot in the driverwar must also be changed + //2. all classes that use @Autowrire must be in a subpackage relative to this class + assertEquals("org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.NokiaSvnfmApplication", NokiaSvnfmApplication.class.getCanonicalName()); + } + + /** + * Assert that the self registration process is started after the servlet is up and is able to answer REST requests. + */ + @Test + public void testRegistrationIsCalledAfterComponentIsUp() throws Exception { + //given + ApplicationReadyEvent event = Mockito.mock(ApplicationReadyEvent.class); + //when + selfRegistrationTriggerer.onApplicationEvent(event); + //verify + verify(selfRegistrationManager).register(); + verify(logger).info("Self registration started"); + verify(logger).info("Self registration finished"); + // this forces the event to be fired after the servlet is up (prevents refactor) + assertTrue(ApplicationReadyEvent.class.isAssignableFrom(event.getClass())); + } + + /** + * Assert that the self de-registration process is started after the servlet has been ramped down + */ + @Test + public void testUnRegistrationIsCalledAfterComponentIsUp() throws Exception { + //given + ContextClosedEvent event = Mockito.mock(ContextClosedEvent.class); + //when + selfUnregistrationTriggerer.onApplicationEvent(event); + //verify + InOrder inOrder = Mockito.inOrder(jobManager, selfRegistrationManager); + inOrder.verify(jobManager).prepareForShutdown(); + inOrder.verify(selfRegistrationManager).deRegister(); + verify(logger).info("Self de-registration started"); + verify(logger).info("Self de-registration finished"); + // this forces the event to be fired after the servlet is down (prevents refactor) + assertTrue(ContextClosedEvent.class.isAssignableFrom(event.getClass())); + } + + /** + * Failures in registration is logged and propagated + */ + @Test + public void failedRegistration() { + //given + RuntimeException expectedException = new RuntimeException(); + Mockito.doThrow(expectedException).when(selfRegistrationManager).register(); + ApplicationReadyEvent event = Mockito.mock(ApplicationReadyEvent.class); + //when + try { + selfRegistrationTriggerer.onApplicationEvent(event); + //verify + TestCase.fail(); + } catch (RuntimeException e) { + assertEquals(e, expectedException); + } + verify(logger).error("Self registration failed", expectedException); + } + + /** + * Failures in de-registration is logged and propagated + */ + @Test + public void failedDeRegistration() { + //given + RuntimeException expectedException = new RuntimeException(); + Mockito.doThrow(expectedException).when(selfRegistrationManager).deRegister(); + ContextClosedEvent event = Mockito.mock(ContextClosedEvent.class); + //when + try { + selfUnregistrationTriggerer.onApplicationEvent(event); + //verify + TestCase.fail(); + } catch (RuntimeException e) { + assertEquals(e, expectedException); + } + verify(logger).error("Self de-registration failed", expectedException); + } + + /** + * static entry point calling an other static entry point can not be tested + */ + @Test + public void useless() throws Exception { + try { + NokiaSvnfmApplication.main(null); + } catch (Exception e) { + + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTReal.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTReal.java new file mode 100644 index 00000000..e013142a --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/ct/CTReal.java @@ -0,0 +1,42 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.ct; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.NokiaSvnfmApplication; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; + +@RunWith(value = SpringRunner.class) +@SpringBootTest(classes = NokiaSvnfmApplication.class, webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) +@ActiveProfiles("real") +public class CTReal { + + /** + * The following is not a real test, but only start the driver locally. + * It takes parameters from application-real.properties + */ + @Test + public void testBasicWorkflow() throws Exception { + + + Thread.sleep(10000000 * 1000L); + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestCbamRestApiProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestCbamRestApiProvider.java new file mode 100644 index 00000000..45a3216a --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestCbamRestApiProvider.java @@ -0,0 +1,236 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core; + +import com.nokia.cbam.catalog.v1.api.DefaultApi; +import com.nokia.cbam.lcm.v32.ApiClient; +import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi; +import com.nokia.cbam.lcm.v32.api.VnfsApi; +import com.nokia.cbam.lcn.v32.api.SubscriptionsApi; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo; +import org.onap.msb.sdk.discovery.entity.NodeInfo; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VnfmInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamTokenProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.model.VnfmInfo; +import org.springframework.core.env.Environment; + +import java.util.Base64; +import java.util.HashSet; +import java.util.Set; + +import static junit.framework.TestCase.*; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestCbamRestApiProvider extends TestBase { + @Mock + private Environment environment; + @Mock + private CbamTokenProvider cbamTokenProvider; + private MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo(); + private Set<NodeInfo> nodes = new HashSet<>(); + + private CbamRestApiProvider cbamRestApiProvider; + + @Before + public void init() { + microServiceInfo.setNodes(nodes); + CbamRestApiProvider real = new CbamRestApiProvider(driverProperties, cbamTokenProvider, vnfmInfoProvider); + setField(real, "trustedCertificates", "mytrustedCertificates"); + setField(real, "skipCertificateVerification", true); + cbamRestApiProvider = spy(real); + when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn(""); + when(environment.getProperty(VnfmInfoProvider.VNFM_INFO_CACHE_EVICTION_IN_MS, Long.class, Long.valueOf(10 * 60 * 1000))).thenReturn(10 * 60 * 1000L); + } + + /** + * test CBAM LCM API retrieval without SSL verification + */ + @Test + public void testCbamLcmApi() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + expectedVnfmInfo.setUrl("https://cbamUrl:123/d"); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + //when + VnfsApi cbamLcmApi = cbamRestApiProvider.getCbamLcmApi(VNFM_ID); + //verify + ApiClient apiClient = cbamLcmApi.getApiClient(); + assertEquals("https://cbamUrl:123/d", apiClient.getBasePath()); + assertNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size()); + assertTrue(!cbamLcmApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM LCM API retrieval with SSL verification + */ + @Test + public void testCbamLcmApiWithSslVerfy() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + expectedVnfmInfo.setUrl("https://cbamUrl:123/d"); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + setField(cbamRestApiProvider, "skipCertificateVerification", false); + setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem"))); + //when + VnfsApi cbamLcmApi = cbamRestApiProvider.getCbamLcmApi(VNFM_ID); + //verify + ApiClient apiClient = cbamLcmApi.getApiClient(); + assertEquals("https://cbamUrl:123/d", apiClient.getBasePath()); + assertNotNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size()); + assertTrue(cbamLcmApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM Catalog API retrieval without SSL verification + */ + @Test + public void testCbamCatalogApi() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + when(driverProperties.getCbamCatalogUrl()).thenReturn("https://1.2.3.4/path"); + //when + DefaultApi cbamCatalogApi = cbamRestApiProvider.getCbamCatalogApi(VNFM_ID); + //verify + com.nokia.cbam.catalog.v1.ApiClient apiClient = cbamCatalogApi.getApiClient(); + assertEquals("https://1.2.3.4/path", apiClient.getBasePath()); + assertNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.catalog.v1.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamCatalogApi.getApiClient().getAuthentications().size()); + assertTrue(!cbamCatalogApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM Catalog API retrieval with SSL verification + */ + @Test + public void testCbamCatalogApiWithSslVerfy() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + when(driverProperties.getCbamCatalogUrl()).thenReturn("https://1.2.3.4/path"); + setField(cbamRestApiProvider, "skipCertificateVerification", false); + setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem"))); + //when + DefaultApi cbamLcmApi = cbamRestApiProvider.getCbamCatalogApi(VNFM_ID); + //verify + com.nokia.cbam.catalog.v1.ApiClient apiClient = cbamLcmApi.getApiClient(); + assertEquals("https://1.2.3.4/path", apiClient.getBasePath()); + assertNotNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.catalog.v1.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcmApi.getApiClient().getAuthentications().size()); + assertTrue(cbamLcmApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM Lcn API retrieval without SSL verification + */ + @Test + public void testCbamLcnApi() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + when(driverProperties.getCbamLcnUrl()).thenReturn("https://1.2.3.4/path"); + //when + SubscriptionsApi cbamLcnApi = cbamRestApiProvider.getCbamLcnApi(VNFM_ID); + //verify + com.nokia.cbam.lcn.v32.ApiClient apiClient = cbamLcnApi.getApiClient(); + assertEquals("https://1.2.3.4/path", apiClient.getBasePath()); + assertNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcn.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size()); + assertTrue(!cbamLcnApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM Lcn API retrieval with SSL verification + */ + @Test + public void testCbamLcnApiWithSslVerfy() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + when(driverProperties.getCbamLcnUrl()).thenReturn("https://1.2.3.4/path"); + setField(cbamRestApiProvider, "skipCertificateVerification", false); + setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem"))); + //when + SubscriptionsApi cbamLcnApi = cbamRestApiProvider.getCbamLcnApi(VNFM_ID); + //verify + com.nokia.cbam.lcn.v32.ApiClient apiClient = cbamLcnApi.getApiClient(); + assertEquals("https://1.2.3.4/path", apiClient.getBasePath()); + assertNotNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcn.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size()); + assertTrue(cbamLcnApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM operation exeution API retrieval without SSL verification + */ + @Test + public void testCbamOpexApi() throws Exception { + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + expectedVnfmInfo.setUrl("https://cbamUrl:123/d"); + //when + OperationExecutionsApi cbamLcnApi = cbamRestApiProvider.getCbamOperationExecutionApi(VNFM_ID); + //verify + ApiClient apiClient = cbamLcnApi.getApiClient(); + assertEquals("https://cbamUrl:123/d", apiClient.getBasePath()); + assertNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size()); + assertTrue(!cbamLcnApi.getApiClient().isVerifyingSsl()); + } + + /** + * test CBAM operation execution API retrieval with SSL verification + */ + @Test + public void testCbamOpexApiWithSslVerfy() throws Exception { + when(cbamTokenProvider.getToken(VNFM_ID)).thenReturn("myToken"); + setField(cbamRestApiProvider, "skipCertificateVerification", false); + setField(cbamRestApiProvider, "trustedCertificates", Base64.getEncoder().encodeToString(TestUtil.loadFile("unittests/sample.cert.pem"))); + VnfmInfo expectedVnfmInfo = new VnfmInfo(); + when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + expectedVnfmInfo.setUrl("https://cbamUrl:123/d"); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(expectedVnfmInfo); + //when + OperationExecutionsApi cbamLcnApi = cbamRestApiProvider.getCbamOperationExecutionApi(VNFM_ID); + //verify + ApiClient apiClient = cbamLcnApi.getApiClient(); + assertEquals("https://cbamUrl:123/d", apiClient.getBasePath()); + assertNotNull(apiClient.getSslCaCert()); + assertEquals("myToken", ((com.nokia.cbam.lcm.v32.auth.OAuth) apiClient.getAuthentication("OauthClient")).getAccessToken()); + assertEquals(2, cbamLcnApi.getApiClient().getAuthentications().size()); + assertTrue(cbamLcnApi.getApiClient().isVerifyingSsl()); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestGenericExternalSystemInfoProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestGenericExternalSystemInfoProvider.java new file mode 100644 index 00000000..44263835 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestGenericExternalSystemInfoProvider.java @@ -0,0 +1,104 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.model.VimInfo; +import org.onap.vnfmdriver.model.VnfmInfo; +import org.springframework.core.env.Environment; +import org.springframework.test.util.ReflectionTestUtils; + +import static java.lang.Long.valueOf; +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.*; + +public class TestGenericExternalSystemInfoProvider extends TestBase { + + private GenericExternalSystemInfoProvider genericExternalSystemInfoProvider; + + @Before + public void init() { + when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn(""); + ReflectionTestUtils.setField(GenericExternalSystemInfoProvider.class, "logger", logger); + genericExternalSystemInfoProvider = Mockito.spy(new TestClass(environment)); + } + + /** + * the VNFM info is not retrieved within the cache eviction period + */ + @Test + public void testQueryVnfmInfoWithin() throws Exception { + VnfmInfo expectedVnfmInfo = Mockito.mock(VnfmInfo.class); + when(genericExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(environment.getProperty(GenericExternalSystemInfoProvider.VNFM_INFO_CACHE_EVICTION_IN_MS, Long.class, valueOf(GenericExternalSystemInfoProvider.DEFAULT_CACHE_EVICTION_TIMEOUT_IN_MS))).thenReturn(Long.valueOf(1234)); + genericExternalSystemInfoProvider.afterPropertiesSet(); + //when + VnfmInfo vnfmInfo = genericExternalSystemInfoProvider.getVnfmInfo(VNFM_ID); + //verify + verify(logger).info("Quering VNFM info from source with " + VNFM_ID + " identifier"); + assertEquals(expectedVnfmInfo, vnfmInfo); + //when + VnfmInfo vnfmInfo2 = genericExternalSystemInfoProvider.getVnfmInfo(VNFM_ID); + //verify source system not called again + verify(logger).info("Quering VNFM info from source with " + VNFM_ID + " identifier"); + verify(genericExternalSystemInfoProvider, Mockito.times(1)).queryVnfmInfoFromSource(VNFM_ID); + } + + /** + * the VNFM info is retrieved without the cache eviction period + */ + @Test + public void testQueryVnfmInfoOutside() throws Exception { + VnfmInfo expectedVnfmInfo = Mockito.mock(VnfmInfo.class); + when(genericExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID)).thenReturn(expectedVnfmInfo); + when(environment.getProperty(GenericExternalSystemInfoProvider.VNFM_INFO_CACHE_EVICTION_IN_MS, Long.class, valueOf(GenericExternalSystemInfoProvider.DEFAULT_CACHE_EVICTION_TIMEOUT_IN_MS))).thenReturn(Long.valueOf(1)); + genericExternalSystemInfoProvider.afterPropertiesSet(); + + //when + VnfmInfo vnfmInfo = genericExternalSystemInfoProvider.getVnfmInfo(VNFM_ID); + //verify + assertEquals(expectedVnfmInfo, vnfmInfo); + //when + //sleeping is required to make time pass (for cache to notice the change) + Thread.sleep(10); + VnfmInfo vnfmInfo2 = genericExternalSystemInfoProvider.getVnfmInfo(VNFM_ID); + //verify source system called again + verify(logger, times(2)).info("Quering VNFM info from source with " + VNFM_ID + " identifier"); + verify(genericExternalSystemInfoProvider, Mockito.times(2)).queryVnfmInfoFromSource(VNFM_ID); + } + + class TestClass extends GenericExternalSystemInfoProvider { + + TestClass(Environment environment) { + super(environment); + } + + @Override + public VnfmInfo queryVnfmInfoFromSource(String vnfmId) { + return null; + } + + @Override + public VimInfo getVimInfo(String vimId) { + return null; + } + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestIpMappingProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestIpMappingProvider.java new file mode 100644 index 00000000..a1f91855 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestIpMappingProvider.java @@ -0,0 +1,61 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core; + +import org.junit.Before; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.springframework.core.env.Environment; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.when; + +public class TestIpMappingProvider extends TestBase { + + private IpMappingProvider ipMappingProvider; + + @Before + public void init() { + ipMappingProvider = new TestClass(environment); + } + + /** + * the IP addresses are correctly mapped + */ + @Test + public void testIpMapping() throws Exception { + when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn(" 1.2.3.4 -> 2.3.4.5 , 1.2.3.5 -> 3.4.5.6"); + //when + ipMappingProvider.afterPropertiesSet(); + //verify + assertEquals("2.3.4.5", ipMappingProvider.mapPrivateIpToPublicIp("1.2.3.4")); + assertEquals(".......", ipMappingProvider.mapPrivateIpToPublicIp(".......")); + assertEquals("3.4.5.6", ipMappingProvider.mapPrivateIpToPublicIp("1.2.3.5")); + assertEquals("1.2.3.5.", ipMappingProvider.mapPrivateIpToPublicIp("1.2.3.5.")); + + } + + class TestClass extends IpMappingProvider { + + TestClass(Environment environment) { + super(environment); + } + + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestMsbApiProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestMsbApiProvider.java new file mode 100644 index 00000000..e6d8ebb4 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/core/TestMsbApiProvider.java @@ -0,0 +1,146 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.onap.msb.sdk.discovery.common.RouteException; +import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo; +import org.onap.msb.sdk.discovery.entity.NodeInfo; +import org.onap.msb.sdk.httpclient.msb.MSBServiceClient; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamTokenProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.springframework.core.env.Environment; + +import java.util.HashSet; +import java.util.Set; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestMsbApiProvider extends TestBase { + @Mock + private Environment environment; + @Mock + private CbamTokenProvider cbamTokenProvider; + private MicroServiceFullInfo microServiceInfo = new MicroServiceFullInfo(); + private Set<NodeInfo> nodes = new HashSet<>(); + private MsbApiProvider msbApiProvider; + + @Before + public void init() { + setField(MsbApiProvider.class, "logger", logger); + msbApiProvider = new MsbApiProvider(environment); + microServiceInfo.setNodes(nodes); + } + + /** + * test MSB client is created based on driver properties + */ + @Test + public void testMsbClient() { + setFieldWithPropertyAnnotation(msbApiProvider, "${messageBusIp}", "mymessageBusIp"); + setFieldWithPropertyAnnotation(msbApiProvider, "${messageBusPort}", "123"); + //when + MSBServiceClient msbClient = msbApiProvider.getMsbClient(); + //verify + assertEquals("mymessageBusIp:123", msbClient.getMsbSvrAddress()); + } + + /** + * error is propagated if no suitable micro service endpoint is found + */ + @Test + public void testNoSuitableMicroService() throws Exception { + NodeInfo dockerAccessPoint = new NodeInfo(); + dockerAccessPoint.setIp("172.1.2.3"); + microServiceInfo.setServiceName("serviceName"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setUrl("/lead/nslcm/v1"); + when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn(""); + nodes.add(dockerAccessPoint); + msbApiProvider = new MsbApiProvider(environment) { + @Override + public MSBServiceClient getMsbClient() { + return msbClient; + } + }; + when(msbClient.queryMicroServiceInfo("serviceName", "v1")).thenReturn(microServiceInfo); + //when + try { + msbApiProvider.getMicroServiceUrl("serviceName", "v1"); + fail(); + } catch (Exception e) { + assertEquals("The serviceName service with v1 does not have any valid nodes[172.1.2.3:null ttl:]", e.getMessage()); + verify(logger).error("The serviceName service with v1 does not have any valid nodes[172.1.2.3:null ttl:]"); + } + } + + /** + * non Docker endpoint is selected + */ + @Test + public void testExistingValidEndpoint() throws Exception { + NodeInfo nonDocker = new NodeInfo(); + nonDocker.setIp("173.1.2.3"); + nonDocker.setPort("234"); + microServiceInfo.setServiceName("serviceName"); + microServiceInfo.setVersion("v1"); + microServiceInfo.setUrl("/lead/nslcm/v1"); + when(environment.getProperty(IpMappingProvider.IP_MAP, String.class, "")).thenReturn("173.1.2.3->1.2.3.4"); + nodes.add(nonDocker); + msbApiProvider = new MsbApiProvider(environment) { + @Override + public MSBServiceClient getMsbClient() { + return msbClient; + } + }; + when(msbClient.queryMicroServiceInfo("serviceName", "v1")).thenReturn(microServiceInfo); + msbApiProvider.afterPropertiesSet(); + //when + assertEquals("http://1.2.3.4:234/lead/nslcm/v1", msbApiProvider.getMicroServiceUrl("serviceName", "v1")); + } + + /** + * if unable to get micro service info the error is propagated + */ + @Test + public void testUnableQueryMicroserviInfo() throws Exception { + msbApiProvider = new MsbApiProvider(environment) { + @Override + public MSBServiceClient getMsbClient() { + return msbClient; + } + }; + RouteException expectedException = new RouteException(); + when(msbClient.queryMicroServiceInfo("serviceName", "v1")).thenThrow(expectedException); + + //when + try { + msbApiProvider.getMicroServiceUrl("serviceName", "v1"); + fail(); + } catch (Exception e) { + assertEquals("Unable to get micro service URL for serviceName with version v1", e.getMessage()); + verify(logger).error("Unable to get micro service URL for serviceName with version v1", expectedException); + } + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcExternalSystemInfoProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcExternalSystemInfoProvider.java new file mode 100644 index 00000000..1081b93c --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcExternalSystemInfoProvider.java @@ -0,0 +1,100 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc; + +import org.junit.Before; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.ApiException; +import org.onap.vnfmdriver.model.VimInfo; +import org.onap.vnfmdriver.model.VnfmInfo; +import org.springframework.test.util.ReflectionTestUtils; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +public class TestVfcExternalSystemInfoProvider extends TestBase { + private VfcExternalSystemInfoProvider vfcExternalSystemInfoProvider; + + @Before + public void init() { + vfcExternalSystemInfoProvider = new VfcExternalSystemInfoProvider(environment, vfcRestApiProvider); + ReflectionTestUtils.setField(VfcExternalSystemInfoProvider.class, "logger", logger); + } + + /** + * VIM is queried using VF-C APIs + */ + @Test + public void testVimRetrieval() throws Exception { + VimInfo expectedVimInfo = new VimInfo(); + when(nsLcmApi.queryVIMInfo(VIM_ID)).thenReturn(expectedVimInfo); + //when + VimInfo vimInfo = vfcExternalSystemInfoProvider.getVimInfo(VIM_ID); + //verify + assertEquals(expectedVimInfo, vimInfo); + } + + /** + * failure to retrieve VIM from VF-C is propagated + */ + @Test + public void testUnableToQueryVim() throws Exception { + ApiException expectedException = new ApiException(); + when(nsLcmApi.queryVIMInfo(VIM_ID)).thenThrow(expectedException); + //when + try { + vfcExternalSystemInfoProvider.getVimInfo(VIM_ID); + fail(); + } catch (Exception e) { + assertEquals("Unable to query VIM from VF-C with myVimId identifier", e.getMessage()); + verify(logger).error("Unable to query VIM from VF-C with myVimId identifier", expectedException); + } + } + + /** + * VNFM is queried using VF-C APIs + */ + @Test + public void testVnfmRetrieval() throws Exception { + VnfmInfo expectedVimInfo = new VnfmInfo(); + when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenReturn(expectedVimInfo); + //when + VnfmInfo vimInfo = vfcExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID); + //verify + assertEquals(expectedVimInfo, vimInfo); + } + + /** + * failure to retrieve VNFM from VF-C is propagated + */ + @Test + public void testUnableToQueryVnfm() throws Exception { + ApiException expectedException = new ApiException(); + when(nsLcmApi.queryVnfmInfo(VNFM_ID)).thenThrow(expectedException); + //when + try { + vfcExternalSystemInfoProvider.queryVnfmInfoFromSource(VNFM_ID); + fail(); + } catch (Exception e) { + assertEquals("Unable to query VNFM from VF-C with myVnfmId identifier", e.getMessage()); + verify(logger).error("Unable to query VNFM from VF-C with myVnfmId identifier", expectedException); + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcGrantManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcGrantManager.java new file mode 100644 index 00000000..7ca19d63 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcGrantManager.java @@ -0,0 +1,337 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc; + +import com.google.common.collect.Lists; +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import com.nokia.cbam.lcm.v32.model.*; +import com.nokia.cbam.lcm.v32.model.VnfInfo; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.ApiException; +import org.onap.vnfmdriver.model.*; +import org.onap.vnfmdriver.model.ScaleDirection; + +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +import static java.nio.file.Files.readAllBytes; +import static junit.framework.TestCase.*; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestVfcGrantManager extends TestBase { + + private ArgumentCaptor<GrantVNFRequest> grantRequest = ArgumentCaptor.forClass(GrantVNFRequest.class); + private GrantVNFResponseVim vim = new GrantVNFResponseVim(); + private GrantVNFResponse grantResponse = new GrantVNFResponse(); + @Mock + private CatalogManager cbamCatalogManager; + @InjectMocks + private VfcGrantManager vfcGrantManager; + + @Before + public void initMocks() throws Exception { + setField(VfcGrantManager.class, "logger", logger); + when(nsLcmApi.grantvnf(grantRequest.capture())).thenReturn(grantResponse); + grantResponse.setVim(vim); + } + + /** + * test grant request for instantiation + */ + @Test + public void testGrantDuringInstantiation() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI()))); + //when + vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, "level1", cbamVnfdContent, JOB_ID); + //verify + assertEquals(1, grantRequest.getAllValues().size()); + GrantVNFRequest request = grantRequest.getValue(); + assertVduInGrant(request.getAddResource(), "vdu1", 1); + assertVduInGrant(request.getAddResource(), "vdu2", 2); + assertEquals(0, request.getRemoveResource().size()); + assertBasicGrantAttributes(request, org.onap.vnfmdriver.model.OperationType.INSTANTIATE); + } + + /** + * test failure logging & propagation during grant request for instantiation + */ + @Test + public void testFailureDuringGrantPreparation() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI()))); + //when + try { + vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, "missingLevel", cbamVnfdContent, JOB_ID); + //verify + fail(); + } catch (RuntimeException e) { + verify(logger).error(Mockito.eq("Unable to prepare grant request for instantiation"), Mockito.any(RuntimeException.class)); + verifyNoMoreInteractions(nsLcmApi); + } + } + + /** + * test grant request for instantiation + */ + @Test + public void testFailureDuringGrantRequest() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.instantiation.yaml").toURI()))); + ApiException expectedException = new ApiException("a"); + when(nsLcmApi.grantvnf(Mockito.any())).thenThrow(expectedException); + //when + try { + vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, "level1", cbamVnfdContent, JOB_ID); + //verify + fail(); + } catch (RuntimeException e) { + verify(logger).error("Unable to request grant", expectedException); + } + } + + /** + * No grant is requested for termination if the the VNF is not instantiated + */ + @Test + public void testNoGrantIsRequestedIfNotInstantiated() { + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnf.setInstantiationState(InstantiationState.NOT_INSTANTIATED); + //when + vfcGrantManager.requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnf, JOB_ID); + //verify + verifyNoMoreInteractions(nsLcmApi); + } + + /** + * grant is requested for termination if the the VNF is instantiated + */ + @Test + public void testGrantIsRequestedIfInstantiated() { + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnf.setInstantiationState(InstantiationState.INSTANTIATED); + InstantiatedVnfInfo instantiatedVnfInfo = new InstantiatedVnfInfo(); + VnfcResourceInfo vnfc = new VnfcResourceInfo(); + vnfc.setId("vnfcId1"); + vnfc.setVduId("vdu1"); + instantiatedVnfInfo.setVnfcResourceInfo(new ArrayList<>()); + instantiatedVnfInfo.getVnfcResourceInfo().add(vnfc); + vnf.setInstantiatedVnfInfo(instantiatedVnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + prop.setValue(ONAP_CSAR_ID); + vnf.setVnfConfigurableProperties(new ArrayList<>()); + vnf.getVnfConfigurableProperties().add(prop); + //when + vfcGrantManager.requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnf, JOB_ID); + //verify + assertEquals(1, grantRequest.getAllValues().size()); + GrantVNFRequest request = grantRequest.getValue(); + assertVduInGrant(request.getRemoveResource(), "vdu1", 1); + assertVduInGrant(request.getRemoveResource(), "vdu2", 0); + assertEquals(0, request.getAddResource().size()); + assertBasicGrantAttributes(request, org.onap.vnfmdriver.model.OperationType.TERMINAL); + } + + /** + * test failure logging & propagation during grant request for instantiation + */ + @Test + public void testFailureDuringTerminationGrantPreparation() throws Exception { + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnf.setInstantiatedVnfInfo(null); + vnf.setInstantiationState(InstantiationState.INSTANTIATED); + //when + try { + vfcGrantManager.requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnf, JOB_ID); + //verify + fail(); + } catch (RuntimeException e) { + verify(logger).error(Mockito.eq("Unable to prepare grant request for termination"), Mockito.any(RuntimeException.class)); + verifyNoMoreInteractions(nsLcmApi); + } + } + + /** + * failuire is to request grant is logged + */ + @Test + public void testFailureToRequestGrantIsLogged() throws Exception { + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnf.setInstantiationState(InstantiationState.INSTANTIATED); + InstantiatedVnfInfo instantiatedVnfInfo = new InstantiatedVnfInfo(); + VnfcResourceInfo vnfc = new VnfcResourceInfo(); + vnfc.setId("vnfcId1"); + vnfc.setVduId("vdu1"); + instantiatedVnfInfo.setVnfcResourceInfo(new ArrayList<>()); + instantiatedVnfInfo.getVnfcResourceInfo().add(vnfc); + vnf.setInstantiatedVnfInfo(instantiatedVnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + prop.setValue(ONAP_CSAR_ID); + vnf.setVnfConfigurableProperties(new ArrayList<>()); + vnf.getVnfConfigurableProperties().add(prop); + ApiException expectedException = new ApiException(); + when(nsLcmApi.grantvnf(Mockito.any())).thenThrow(expectedException); + //when + try { + vfcGrantManager.requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnf, JOB_ID); + //verify + fail(); + } catch (RuntimeException e) { + verify(logger).error(Mockito.eq("Unable to request grant"), Mockito.eq(expectedException)); + } + } + + /** + * failuire is to request grant is logged + */ + @Test + public void testFailureToRequestGrantForScaleIsLogged() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.scale.yaml").toURI()))); + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setType(ScaleDirection.OUT); + scaleRequest.setAspectId("aspect1"); + scaleRequest.setNumberOfSteps("2"); + com.nokia.cbam.lcm.v32.ApiException expectedException = new com.nokia.cbam.lcm.v32.ApiException(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + vfcGrantManager.requestGrantForScale(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, scaleRequest, JOB_ID); + //verify + fail(); + } catch (RuntimeException e) { + verify(logger).error(Mockito.eq("Unable to query VNF myVnfId"), Mockito.eq(expectedException)); + assertEquals(e.getCause(), expectedException); + } + } + + /** + * test grant request for scale out + */ + @Test + public void testGrantDuringScaleOut() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.scale.yaml").toURI()))); + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setType(ScaleDirection.OUT); + scaleRequest.setAspectId("aspect1"); + scaleRequest.setNumberOfSteps("2"); + VnfInfo vnf = new VnfInfo(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf); + vnf.setVnfdId(CBAM_VNFD_ID); + when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent); + //when + vfcGrantManager.requestGrantForScale(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, scaleRequest, JOB_ID); + //verify + assertEquals(1, grantRequest.getAllValues().size()); + GrantVNFRequest request = grantRequest.getValue(); + assertVduInGrant(request.getAddResource(), "vdu1", 4); + assertVduInGrant(request.getAddResource(), "vdu2", 2); + assertEquals(0, request.getRemoveResource().size()); + assertBasicGrantAttributes(request, org.onap.vnfmdriver.model.OperationType.SCALEOUT); + } + + /** + * test grant request for scale in + */ + @Test + public void testGrantDuringScaleIn() throws Exception { + String cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.scale.yaml").toURI()))); + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setType(ScaleDirection.IN); + scaleRequest.setAspectId("aspect1"); + scaleRequest.setNumberOfSteps("2"); + VnfInfo vnf = new VnfInfo(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf); + vnf.setVnfdId(CBAM_VNFD_ID); + when(cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent); + //when + vfcGrantManager.requestGrantForScale(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, scaleRequest, JOB_ID); + //verify + assertEquals(1, grantRequest.getAllValues().size()); + GrantVNFRequest request = grantRequest.getValue(); + assertVduInGrant(request.getRemoveResource(), "vdu1", 4); + assertVduInGrant(request.getRemoveResource(), "vdu2", 2); + assertEquals(0, request.getAddResource().size()); + assertBasicGrantAttributes(request, org.onap.vnfmdriver.model.OperationType.SCALEIN); + } + + + /** + * test grant request for healing + */ + @Test + public void testGrantDuringHealing() throws Exception { + //when + VnfHealRequest healRequest = new VnfHealRequest(); + VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm(); + affectedVm.setVduid("vdu1"); + healRequest.setAffectedvm(affectedVm); + vfcGrantManager.requestGrantForHeal(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, healRequest, JOB_ID); + //verify + assertEquals(1, grantRequest.getAllValues().size()); + GrantVNFRequest request = grantRequest.getValue(); + assertVduInGrant(request.getAddResource(), "vdu1", 1); + assertVduInGrant(request.getRemoveResource(), "vdu1", 1); + assertBasicGrantAttributes(request, org.onap.vnfmdriver.model.OperationType.HEAL); + } + + private void assertBasicGrantAttributes(GrantVNFRequest request, org.onap.vnfmdriver.model.OperationType type) { + assertEquals(JOB_ID, request.getJobId()); + assertEquals(type, request.getLifecycleOperation()); + assertEquals(ONAP_CSAR_ID, request.getVnfDescriptorId()); + assertEquals(VNF_ID, request.getVnfInstanceId()); + JsonObject additionalParams = new Gson().toJsonTree(request.getAdditionalParam()).getAsJsonObject(); + assertEquals(VIM_ID, additionalParams.get("vimId").getAsString()); + assertEquals(VNFM_ID, additionalParams.get("vnfmId").getAsString()); + } + + private void assertVduInGrant(List<ResourceChange> changes, String vduName, int count) { + ArrayList<ResourceChange> clonedChanges = Lists.newArrayList(changes); + for (int i = 0; i < count + 1; i++) { + Iterator<ResourceChange> iter = clonedChanges.iterator(); + boolean found = false; + while (iter.hasNext()) { + ResourceChange change = iter.next(); + if (change.getVdu().equals(vduName)) { + iter.remove(); + found = true; + break; + } + } + if (i >= count) { + assertFalse(found); + } else { + assertTrue(found); + } + } + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcNotificationSender.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcNotificationSender.java new file mode 100644 index 00000000..42906c7b --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcNotificationSender.java @@ -0,0 +1,760 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc; + +import com.google.common.collect.Lists; +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import com.nokia.cbam.lcm.v32.model.AffectedVirtualLink; +import com.nokia.cbam.lcm.v32.model.AffectedVirtualStorage; +import com.nokia.cbam.lcm.v32.model.AffectedVnfc; +import com.nokia.cbam.lcm.v32.model.ChangeType; +import com.nokia.cbam.lcm.v32.model.*; +import com.nokia.cbam.lcm.v32.model.OperationType; +import com.nokia.cbam.lcm.v32.model.ScaleDirection; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedConnectionPoints; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.ReportedAffectedCp; +import org.onap.vnfmdriver.ApiException; +import org.onap.vnfmdriver.model.*; +import org.threeten.bp.OffsetDateTime; + +import java.util.ArrayList; +import java.util.List; + +import static junit.framework.TestCase.*; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestVfcNotificationSender extends TestBase { + private VfcNotificationSender vfcNotificationSender; + private ArgumentCaptor<VNFLCMNotification> sentLcnToVfc = ArgumentCaptor.forClass(VNFLCMNotification.class); + private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification(); + private List<OperationExecution> operationExecutions = new ArrayList<>(); + private OperationExecution instantiationOperation = new OperationExecution(); + private OperationExecution scaleOperation = new OperationExecution(); + private OperationExecution healOperation = new OperationExecution(); + private OperationExecution terminationOperation = new OperationExecution(); + private ReportedAffectedConnectionPoints affectedCp; + + + @Before + public void init() throws Exception { + vfcNotificationSender = new VfcNotificationSender(driverProperties, vfcRestApiProvider); + setField(VfcNotificationSender.class, "logger", logger); + Mockito.doNothing().when(nsLcmApi).vNFLCMNotification(eq(VNFM_ID), eq(VNF_ID), sentLcnToVfc.capture()); + instantiationOperation.setId("instantiationOperationExecutionId"); + instantiationOperation.setStartTime(OffsetDateTime.now()); + instantiationOperation.setOperationType(OperationType.INSTANTIATE); + scaleOperation.setId("scaleOperationExecutionId"); + scaleOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + scaleOperation.setOperationType(OperationType.SCALE); + terminationOperation.setId("terminationExecutionId"); + terminationOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + terminationOperation.setOperationType(OperationType.TERMINATE); + healOperation.setId("healOperaitonExecutionId"); + healOperation.setOperationType(OperationType.HEAL); + healOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions); + prepOperation(instantiationOperation); + prepOperation(scaleOperation); + prepOperation(healOperation); + prepOperation(terminationOperation); + recievedLcn.setVnfInstanceId(VNF_ID); + } + + private void prepOperation(OperationExecution operationExecution) throws com.nokia.cbam.lcm.v32.ApiException { + addEmptyModifiedConnectionPoints(operationExecution); + JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}"); + operationExecution.setOperationParams(root); + switch (operationExecution.getOperationType()) { + case TERMINATE: + root.getAsJsonObject().addProperty("terminationType", "GRACEFULL"); + } + when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationExecution); + operationExecutions.add(operationExecution); + } + + private void addEmptyModifiedConnectionPoints(OperationExecution operationExecution) { + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = new ReportedAffectedConnectionPoints(); + JsonElement additionalData = new Gson().toJsonTree(operationResult); + operationExecution.setAdditionalData(additionalData); + } + + /** + * test start notification success scenario + * - the affected resources are not processed even if present + * - LCN is sent to VF-C + */ + @Test + public void testStartLcn() { + recievedLcn.setStatus(OperationStatus.STARTED); + recievedLcn.setOperation(OperationType.INSTANTIATE); + //when + vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedCp, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + assertNull(sentLcnToVfc.getValue().getAffectedVl()); + assertNull(sentLcnToVfc.getValue().getAffectedVnfc()); + assertNull(sentLcnToVfc.getValue().getAffectedCp()); + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.START, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * test end notification success scenario + * - LCN is sent to VF-C + */ + @Test + public void testFinishLcn() { + //given + recievedLcn.setOperation(OperationType.INSTANTIATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.ADDED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(ChangeType.ADDED); + affectedVirtualLink.setId("vlId"); + affectedVirtualLink.setVirtualLinkDescId("vlVnfdId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setVimId(VIM_ID); + affectedVirtualLink.getResource().setResourceId("networkProviderId"); + recievedLcn.setAffectedVirtualLinks(new ArrayList<>()); + recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink); + + AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage(); + affectedStorage.setChangeType(ChangeType.ADDED); + affectedStorage.setId("storageId"); + affectedStorage.setVirtualStorageDescId("storageVnfdId"); + affectedStorage.setResource(new ResourceHandle()); + affectedStorage.getResource().setVimId(VIM_ID); + affectedStorage.getResource().setResourceId("storageProviderId"); + recievedLcn.setAffectedVirtualStorages(new ArrayList<>()); + recievedLcn.getAffectedVirtualStorages().add(affectedStorage); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.ADDED); + affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + instantiationOperation.setAdditionalData(additionalData); + //when + vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size()); + org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType()); + assertEquals("vlVnfdId", actualAffectedVl.getVldid()); + assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId()); + assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId()); + assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size()); + org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0); + assertEquals("myVduId", actualAffectdVnfc.getVduId()); + assertEquals(VIM_ID, actualAffectdVnfc.getVimid()); + assertEquals("myVmName", actualAffectdVnfc.getVmname()); + assertEquals("serverProviderId", actualAffectdVnfc.getVmid()); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType()); + assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("cpVnfdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType()); + + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.INSTANTIATE, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * test end notification success scenario for ECP + */ + @Test + public void testFinishLcnForEcp() { + //given + recievedLcn.setOperation(OperationType.INSTANTIATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.ADDED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.ADDED); + //affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + affectedCp.setEcpdId("ecpdId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + instantiationOperation.setAdditionalData(additionalData); + //when + vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("ecpdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType()); + } + + /** + * test end notification success scenario with termination + */ + @Test + public void testFinishLcnWithTerminate() { + //given + recievedLcn.setOperation(OperationType.TERMINATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.REMOVED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(ChangeType.REMOVED); + affectedVirtualLink.setId("vlId"); + affectedVirtualLink.setVirtualLinkDescId("vlVnfdId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setVimId(VIM_ID); + affectedVirtualLink.getResource().setResourceId("networkProviderId"); + recievedLcn.setAffectedVirtualLinks(new ArrayList<>()); + recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink); + + AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage(); + affectedStorage.setChangeType(ChangeType.REMOVED); + affectedStorage.setId("storageId"); + affectedStorage.setVirtualStorageDescId("storageVnfdId"); + affectedStorage.setResource(new ResourceHandle()); + affectedStorage.getResource().setVimId(VIM_ID); + affectedStorage.getResource().setResourceId("storageProviderId"); + recievedLcn.setAffectedVirtualStorages(new ArrayList<>()); + recievedLcn.getAffectedVirtualStorages().add(affectedStorage); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.REMOVED); + affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + + // affectedCp.setEcpdId("ecpdId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + instantiationOperation.setAdditionalData(additionalData); + //when + vfcNotificationSender.processNotification(recievedLcn, terminationOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size()); + org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType()); + assertEquals("vlVnfdId", actualAffectedVl.getVldid()); + assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId()); + assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId()); + assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size()); + org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0); + assertEquals("myVduId", actualAffectdVnfc.getVduId()); + assertEquals(VIM_ID, actualAffectdVnfc.getVimid()); + assertEquals("myVmName", actualAffectdVnfc.getVmname()); + assertEquals("serverProviderId", actualAffectdVnfc.getVmid()); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType()); + assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("cpVnfdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.TERMINAL, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * test end notification success scenario for modifiction (heal) + * - LCN is sent to VF-C + */ + @Test + public void testFinishLcnForModification() { + //given + recievedLcn.setOperation(OperationType.HEAL); + recievedLcn.setStatus(OperationStatus.FINISHED); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.MODIFIED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(ChangeType.MODIFIED); + affectedVirtualLink.setId("vlId"); + affectedVirtualLink.setVirtualLinkDescId("vlVnfdId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setVimId(VIM_ID); + affectedVirtualLink.getResource().setResourceId("networkProviderId"); + recievedLcn.setAffectedVirtualLinks(new ArrayList<>()); + recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink); + + + AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage(); + affectedStorage.setChangeType(ChangeType.MODIFIED); + affectedStorage.setId("storageId"); + affectedStorage.setVirtualStorageDescId("storageVnfdId"); + affectedStorage.setResource(new ResourceHandle()); + affectedStorage.getResource().setVimId(VIM_ID); + affectedStorage.getResource().setResourceId("storageProviderId"); + recievedLcn.setAffectedVirtualStorages(new ArrayList<>()); + recievedLcn.getAffectedVirtualStorages().add(affectedStorage); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.MODIFIED); + affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + + // affectedCp.setEcpdId("ecpdId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + instantiationOperation.setAdditionalData(additionalData); + //when + vfcNotificationSender.processNotification(recievedLcn, healOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size()); + org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectedVl.getChangeType()); + assertEquals("vlVnfdId", actualAffectedVl.getVldid()); + assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId()); + assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId()); + assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size()); + org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0); + assertEquals("myVduId", actualAffectdVnfc.getVduId()); + assertEquals(VIM_ID, actualAffectdVnfc.getVimid()); + assertEquals("myVmName", actualAffectdVnfc.getVmname()); + assertEquals("serverProviderId", actualAffectdVnfc.getVmid()); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.MODIFIED, actualAffectdVnfc.getChangeType()); + assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("cpVnfdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + assertEquals(VnfCpNotificationType.CHANGED, actualAffectedCp.getChangeType()); + + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.HEAL, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * test end notification success scenario for scale-out + * - LCN is sent to VF-C + */ + @Test + public void testFinishLcnForScaleout() { + //given + recievedLcn.setOperation(OperationType.SCALE); + recievedLcn.setStatus(OperationStatus.FINISHED); + recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId()); + ScaleVnfRequest request = new ScaleVnfRequest(); + request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }")); + request.setType(ScaleDirection.OUT); + scaleOperation.setOperationParams(request); + scaleOperation.setOperationType(OperationType.SCALE); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.ADDED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(ChangeType.ADDED); + affectedVirtualLink.setId("vlId"); + affectedVirtualLink.setVirtualLinkDescId("vlVnfdId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setVimId(VIM_ID); + affectedVirtualLink.getResource().setResourceId("networkProviderId"); + recievedLcn.setAffectedVirtualLinks(new ArrayList<>()); + recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink); + + + AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage(); + affectedStorage.setChangeType(ChangeType.ADDED); + affectedStorage.setId("storageId"); + affectedStorage.setVirtualStorageDescId("storageVnfdId"); + affectedStorage.setResource(new ResourceHandle()); + affectedStorage.getResource().setVimId(VIM_ID); + affectedStorage.getResource().setResourceId("storageProviderId"); + recievedLcn.setAffectedVirtualStorages(new ArrayList<>()); + recievedLcn.getAffectedVirtualStorages().add(affectedStorage); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.ADDED); + affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + + // affectedCp.setEcpdId("ecpdId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + scaleOperation.setAdditionalData(additionalData); + //when + vfcNotificationSender.processNotification(recievedLcn, scaleOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size()); + org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectedVl.getChangeType()); + assertEquals("vlVnfdId", actualAffectedVl.getVldid()); + assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId()); + assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId()); + assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size()); + org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0); + assertEquals("myVduId", actualAffectdVnfc.getVduId()); + assertEquals(VIM_ID, actualAffectdVnfc.getVimid()); + assertEquals("myVmName", actualAffectdVnfc.getVmname()); + assertEquals("serverProviderId", actualAffectdVnfc.getVmid()); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.ADDED, actualAffectdVnfc.getChangeType()); + assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("cpVnfdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + assertEquals(VnfCpNotificationType.ADDED, actualAffectedCp.getChangeType()); + + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEOUT, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * test end notification success scenario for scale-out + * - LCN is sent to VF-C + */ + @Test + public void testFinishLcnForScaleIn() { + //given + recievedLcn.setOperation(OperationType.SCALE); + recievedLcn.setStatus(OperationStatus.FINISHED); + recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId()); + ScaleVnfRequest request = new ScaleVnfRequest(); + request.setAdditionalParams(new JsonParser().parse("{ \"jobId\" : \"" + JOB_ID + "\" }")); + request.setType(ScaleDirection.IN); + scaleOperation.setOperationParams(request); + AffectedVnfc affectedVnfc = new AffectedVnfc(); + affectedVnfc.setChangeType(ChangeType.REMOVED); + affectedVnfc.setId("myVnfcId"); + affectedVnfc.setVduId("myVduId"); + affectedVnfc.setStorageResourceIds(Lists.newArrayList("storageId1")); + affectedVnfc.setComputeResource(new ResourceHandle()); + affectedVnfc.getComputeResource().setResourceId("serverProviderId"); + affectedVnfc.getComputeResource().setVimId(VIM_ID); + affectedVnfc.getComputeResource().setAdditionalData(new JsonParser().parse("{ \"name\" : \"myVmName\" } ")); + recievedLcn.setAffectedVnfcs(new ArrayList<>()); + recievedLcn.getAffectedVnfcs().add(affectedVnfc); + + AffectedVirtualLink affectedVirtualLink = new AffectedVirtualLink(); + affectedVirtualLink.setChangeType(ChangeType.REMOVED); + affectedVirtualLink.setId("vlId"); + affectedVirtualLink.setVirtualLinkDescId("vlVnfdId"); + affectedVirtualLink.setResource(new ResourceHandle()); + affectedVirtualLink.getResource().setVimId(VIM_ID); + affectedVirtualLink.getResource().setResourceId("networkProviderId"); + recievedLcn.setAffectedVirtualLinks(new ArrayList<>()); + recievedLcn.getAffectedVirtualLinks().add(affectedVirtualLink); + + + AffectedVirtualStorage affectedStorage = new AffectedVirtualStorage(); + affectedStorage.setChangeType(ChangeType.REMOVED); + affectedStorage.setId("storageId"); + affectedStorage.setVirtualStorageDescId("storageVnfdId"); + affectedStorage.setResource(new ResourceHandle()); + affectedStorage.getResource().setVimId(VIM_ID); + affectedStorage.getResource().setResourceId("storageProviderId"); + recievedLcn.setAffectedVirtualStorages(new ArrayList<>()); + recievedLcn.getAffectedVirtualStorages().add(affectedStorage); + + ReportedAffectedConnectionPoints affectedConnectionPoints = new ReportedAffectedConnectionPoints(); + ReportedAffectedCp affectedCp = new ReportedAffectedCp(); + affectedCp.setChangeType(ChangeType.REMOVED); + affectedCp.setCpdId("cpVnfdId"); + affectedCp.setIpAddress("1.2.3.4"); + affectedCp.setMacAddress("myMac"); + affectedCp.setName("myPortName"); + affectedCp.setCpId("cpId"); + + // affectedCp.setEcpdId("ecpdId"); + affectedCp.setNetworkProviderId("networkProviderId"); + affectedCp.setProviderId("portProviderId"); + affectedCp.setServerProviderId("serverProviderId"); + affectedCp.setTenantId("tenantId"); + affectedConnectionPoints.getPost().add(affectedCp); + + + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = affectedConnectionPoints; + JsonElement additionalData = new Gson().toJsonTree(operationResult); + scaleOperation.setAdditionalData(additionalData); + scaleOperation.setOperationType(OperationType.SCALE); + //when + vfcNotificationSender.processNotification(recievedLcn, scaleOperation, affectedConnectionPoints, VIM_ID); + //verify + assertEquals(1, sentLcnToVfc.getAllValues().size()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVl().size()); + org.onap.vnfmdriver.model.AffectedVirtualLink actualAffectedVl = sentLcnToVfc.getValue().getAffectedVl().get(0); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectedVl.getChangeType()); + assertEquals("vlVnfdId", actualAffectedVl.getVldid()); + assertEquals("myVnfId_vlId", actualAffectedVl.getVlInstanceId()); + assertEquals("networkProviderId", actualAffectedVl.getNetworkResource().getResourceId()); + assertEquals(AffectedVirtualLinkType.NETWORK, actualAffectedVl.getNetworkResource().getResourceType()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedVnfc().size()); + org.onap.vnfmdriver.model.AffectedVnfc actualAffectdVnfc = sentLcnToVfc.getValue().getAffectedVnfc().get(0); + assertEquals("myVduId", actualAffectdVnfc.getVduId()); + assertEquals(VIM_ID, actualAffectdVnfc.getVimid()); + assertEquals("myVmName", actualAffectdVnfc.getVmname()); + assertEquals("serverProviderId", actualAffectdVnfc.getVmid()); + assertEquals(org.onap.vnfmdriver.model.VnfNotificationType.REMOVED, actualAffectdVnfc.getChangeType()); + assertEquals("myVnfId_myVnfcId", actualAffectdVnfc.getVnfcInstanceId()); + + assertEquals(1, sentLcnToVfc.getValue().getAffectedCp().size()); + AffectedCp actualAffectedCp = sentLcnToVfc.getValue().getAffectedCp().get(0); + assertEquals("cpVnfdId", actualAffectedCp.getCpdid()); + assertEquals("myVnfId_cpId", actualAffectedCp.getCpinstanceid()); + assertEquals(null, actualAffectedCp.getOwnerId()); + assertEquals(null, actualAffectedCp.getOwnerType()); + assertEquals("networkProviderId", actualAffectedCp.getVirtualLinkInstanceId()); + assertEquals("1.2.3.4", actualAffectedCp.getPortResource().getIpAddress()); + assertEquals("myMac", actualAffectedCp.getPortResource().getMacAddress()); + assertEquals("tenantId", actualAffectedCp.getPortResource().getTenant()); + assertEquals(VIM_ID, actualAffectedCp.getPortResource().getVimid()); + assertEquals("serverProviderId", actualAffectedCp.getPortResource().getInstId()); + assertEquals("portProviderId", actualAffectedCp.getPortResource().getResourceid()); + assertEquals("myPortName", actualAffectedCp.getPortResource().getResourceName()); + assertEquals(VnfCpNotificationType.REMOVED, actualAffectedCp.getChangeType()); + + assertNull(sentLcnToVfc.getValue().getAffectedVirtualStorage()); + assertEquals(JOB_ID, sentLcnToVfc.getValue().getJobId()); + assertEquals(org.onap.vnfmdriver.model.OperationType.SCALEIN, sentLcnToVfc.getValue().getOperation()); + assertEquals(VnfLcmNotificationStatus.RESULT, sentLcnToVfc.getValue().getStatus()); + assertEquals(VNF_ID, sentLcnToVfc.getValue().getVnfInstanceId()); + } + + /** + * Unable to send notification to VF-C results in error + */ + @Test + public void testUnableToSendNotificationToVfc() throws Exception { + ApiException expectedException = new ApiException(); + doThrow(expectedException).when(nsLcmApi).vNFLCMNotification(any(), any(), any()); + recievedLcn.setStatus(OperationStatus.STARTED); + recievedLcn.setOperation(OperationType.INSTANTIATE); + //when + try { + vfcNotificationSender.processNotification(recievedLcn, instantiationOperation, affectedCp, VIM_ID); + //verify + fail(); + } catch (Exception e) { + verify(logger).error("Unable to send LCN to VF-C", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + class OperationResult { + ReportedAffectedConnectionPoints operationResult; + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcPackageProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcPackageProvider.java new file mode 100644 index 00000000..62ffdb4f --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcPackageProvider.java @@ -0,0 +1,156 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc; + +import org.apache.http.HttpHeaders; +import org.apache.http.client.methods.HttpGet; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.IpMappingProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfccatalog.ApiException; +import org.onap.vfccatalog.model.VnfPkgDetailInfo; +import org.onap.vfccatalog.model.VnfPkgInfo; + +import java.io.ByteArrayInputStream; +import java.io.IOException; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestVfcPackageProvider extends TestBase { + + private static final String CSAR_ID = "csarId"; + private static final String CBAM_VNFD_ID = "CBAM_VNFD_ID"; + @Mock + private IpMappingProvider ipMappingProvider; + + @Mock + private VfcPackageProvider vfcPackageProvider; + + + @Before + public void initMocks() throws Exception { + setField(VfcPackageProvider.class, "logger", logger); + vfcPackageProvider = new VfcPackageProvider(vfcRestApiProvider, ipMappingProvider); + } + + /** + * query CBAM VNFD identifier from VF-C catalog + */ + @Test + public void testGetCbamVnfd() throws Exception { + VnfPkgDetailInfo vnfPackageDetails = new VnfPkgDetailInfo(); + vnfPackageDetails.setCsarId(CSAR_ID); + vnfPackageDetails.setPackageInfo(new VnfPkgInfo()); + vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}"); + vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar"); + when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails); + //when + String cbamVnfdId = vfcPackageProvider.getCbamVnfdId(CSAR_ID); + //verify + assertEquals(CBAM_VNFD_ID, cbamVnfdId); + } + + /** + * download ONAP VNFD from VF-C catalog + */ + @Test + public void testDownload() throws Exception { + VnfPkgDetailInfo vnfPackageDetails = new VnfPkgDetailInfo(); + vnfPackageDetails.setCsarId(CSAR_ID); + vnfPackageDetails.setPackageInfo(new VnfPkgInfo()); + vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}"); + vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar"); + when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails); + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(ipMappingProvider.mapPrivateIpToPublicIp("127.0.0.1")).thenReturn("1.2.3.4"); + when(entity.getContent()).thenReturn(new ByteArrayInputStream(onapPackageContent)); + //when + byte[] actualContent = vfcPackageProvider.getPackage(CSAR_ID); + //verify + Assert.assertArrayEquals(onapPackageContent, actualContent); + assertEquals(HttpGet.class, request.getValue().getClass()); + assertEquals("http://1.2.3.4/a.csar", request.getValue().getURI().toString()); + assertEquals("application/octet-stream", request.getValue().getFirstHeader(HttpHeaders.ACCEPT).getValue()); + } + + /** + * failure to query package from VF-C is propagated + */ + @Test + public void unableToGetCbamVnfdFromCatalog() throws Exception { + ApiException expectedException = new ApiException(); + when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenThrow(expectedException); + //when + try { + vfcPackageProvider.getCbamVnfdId(CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VNF package with csarId from VF-C", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * failure to download package from VF-C is propagated + */ + @Test + public void unableToDownloadFromCatalog() throws Exception { + VnfPkgDetailInfo vnfPackageDetails = new VnfPkgDetailInfo(); + vnfPackageDetails.setCsarId(CSAR_ID); + vnfPackageDetails.setPackageInfo(new VnfPkgInfo()); + vnfPackageDetails.getPackageInfo().setVnfdModel("{ \"metadata\" : { \"resourceVendorModelNumber\" : \"" + CBAM_VNFD_ID + "\" }}"); + vnfPackageDetails.getPackageInfo().setDownloadUrl("http://127.0.0.1/a.csar"); + when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenReturn(vnfPackageDetails); + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(ipMappingProvider.mapPrivateIpToPublicIp("127.0.0.1")).thenReturn("1.2.3.4"); + IOException expectedException = new IOException(); + when(httpClient.execute(Mockito.any())).thenThrow(expectedException); + //when + try { + vfcPackageProvider.getPackage(CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to download package from http://1.2.3.4/a.csar from VF-C", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * failure to query package for download package from VF-C is propagated + */ + @Test + public void unableToQueryPackageForDownloadFromCatalog() throws Exception { + ApiException expectedException = new ApiException(); + when(vfcCatalogApi.queryVnfPackage(CSAR_ID)).thenThrow(expectedException); + //when + try { + vfcPackageProvider.getPackage(CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VNF package with csarId from VF-C", expectedException); + assertEquals(expectedException, e.getCause()); + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcRestApiProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcRestApiProvider.java new file mode 100644 index 00000000..a527b568 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/onap/vfc/TestVfcRestApiProvider.java @@ -0,0 +1,64 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc; + +import org.junit.Before; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfccatalog.api.VnfpackageApi; +import org.onap.vnfmdriver.api.NslcmApi; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNull; +import static org.mockito.Mockito.when; + +public class TestVfcRestApiProvider extends TestBase { + private VfcRestApiProvider vfcRestApiProvider; + + @Before + public void init() { + vfcRestApiProvider = new VfcRestApiProvider(msbApiProvider); + } + + /** + * test VF-C NSLCM API retrieval + */ + @Test + public void testNsLcmApi() throws Exception { + when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSLCM_API_SERVICE_NAME, VfcRestApiProvider.NSLCM_API_VERION)).thenReturn("http://1.2.3.4:1234/nslcm/v1/lead"); + //when + NslcmApi nsLcmApi = vfcRestApiProvider.getNsLcmApi(); + //verify + assertEquals("http://1.2.3.4:1234/lead", nsLcmApi.getApiClient().getBasePath()); + assertNull(nsLcmApi.getApiClient().getSslCaCert()); + assertEquals(0, nsLcmApi.getApiClient().getAuthentications().size()); + } + + /** + * test VF-C catalog API retrieval + */ + @Test + public void testNsCatalogApi() throws Exception { + when(msbApiProvider.getMicroServiceUrl(VfcRestApiProvider.NSCATALOG_SERVICE_NAME, VfcRestApiProvider.NSCATALOG_API_VERSION)).thenReturn("http://1.2.3.4:1234/lead"); + //when + VnfpackageApi nsCatalogApi = vfcRestApiProvider.getOnapCatalogApi(); + //verify + assertEquals("http://1.2.3.4:1234/lead", nsCatalogApi.getApiClient().getBasePath()); + assertNull(nsCatalogApi.getApiClient().getSslCaCert()); + assertEquals(0, nsCatalogApi.getApiClient().getAuthentications().size()); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfPackageBuilder.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfPackageBuilder.java new file mode 100644 index 00000000..3b80eca0 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfPackageBuilder.java @@ -0,0 +1,54 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import static org.mockito.Mockito.when; + + +public class TestCbamVnfPackageBuilder extends TestBase { + private CbamVnfPackageBuilder cbamVnfPackageBuilder = new CbamVnfPackageBuilder(); + + /** + * + */ + @Test + public void testEmpty() throws Exception { + byte[] zipContent = TestUtil.loadFile("unittests/packageconverter/cbam.package.zip"); + when(systemFunctions.loadFile("cbam.pre.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.post.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.collectConnectionPoints.js")).thenCallRealMethod(); + + //when + byte[] modifiedContent = cbamVnfPackageBuilder.toModifiedCbamVnfPackage(zipContent, "vnfdloc/a.yaml", "modifiedContent"); + //verify + assertFileInZip(modifiedContent, "keep/me", "kuku\n".getBytes()); + assertFileInZip(modifiedContent, "TOSCA-Metadata/TOSCA.meta", ("TOSCA-Meta-File-Version: 1.0\n" + + "CSAR-Version: 1.1\n" + + "Created-By: Nokia\n" + + "Entry-Definitions: vnfdloc/a.yaml\n").getBytes()); + assertFileInZip(modifiedContent, "javascript/cbam.pre.collectConnectionPoints.js", TestUtil.loadFile("cbam.pre.collectConnectionPoints.js")); + assertFileInZip(modifiedContent, "javascript/cbam.post.collectConnectionPoints.js", TestUtil.loadFile("cbam.post.collectConnectionPoints.js")); + assertFileInZip(modifiedContent, "javascript/cbam.collectConnectionPoints.js", TestUtil.loadFile("cbam.collectConnectionPoints.js")); + + + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfdBuilder.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfdBuilder.java new file mode 100644 index 00000000..5840ef4e --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestCbamVnfdBuilder.java @@ -0,0 +1,47 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import static junit.framework.TestCase.assertEquals; + + +public class TestCbamVnfdBuilder extends TestBase { + private CbamVnfdBuilder packageTransformer = new CbamVnfdBuilder(); + + /** + * test package conversion on the most mininal VNFD possible + */ + @Test + public void testEmpty() throws Exception { + String out = packageTransformer.build(new String(TestUtil.loadFile("unittests/packageconverter/cbam.minimal.original.vnfd.yaml"))); + String expected = new String(TestUtil.loadFile("unittests/packageconverter/cbam.minimal.modified.vnfd.yaml")); + assertEquals(expected, out); + } + + /** + * test package conversion on the most full VNFD possible + */ + @Test + public void testFull() throws Exception { + String out = packageTransformer.build(new String(TestUtil.loadFile("unittests/packageconverter/cbam.full.original.vnfd.yaml"))); + String expected = new String(TestUtil.loadFile("unittests/packageconverter/cbam.full.modified.vnfd.yaml")); + assertEquals(expected, out); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfPackageBuilder.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfPackageBuilder.java new file mode 100644 index 00000000..9c9f7958 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfPackageBuilder.java @@ -0,0 +1,74 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; + +import static junit.framework.TestCase.assertEquals; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getFileInZip; + + +public class TestOnapVnfPackageBuilder extends TestBase { + + /** + * The the main reads from standard in and writes to standard out + */ + @Test + public void testInputStreams() throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + PrintStream actualOut = new PrintStream(bos, true); + when(systemFunctions.out()).thenReturn(actualOut); + when(systemFunctions.in()).thenReturn(new ByteArrayInputStream(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip"))); + when(systemFunctions.loadFile("cbam.pre.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.post.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("TOSCA.meta")).thenCallRealMethod(); + when(systemFunctions.loadFile("MainServiceTemplate.meta")).thenCallRealMethod(); + + + String cbamVnfd = new String(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip.vnfd")); + String expectedOnapVnfd = new OnapVnfdBuilder().toOnapVnfd(cbamVnfd); + + //when + OnapVnfPackageBuilder.main(null); + //verify + assertFileInZip(bos.toByteArray(), "TOSCA-Metadata/TOSCA.meta", TestUtil.loadFile("TOSCA.meta")); + assertFileInZip(bos.toByteArray(), "Definitions/MainServiceTemplate.yaml", expectedOnapVnfd.getBytes()); + assertFileInZip(bos.toByteArray(), "MainServiceTemplate.yaml", expectedOnapVnfd.getBytes()); + assertFileInZip(bos.toByteArray(), "MainServiceTemplate.meta", TestUtil.loadFile("MainServiceTemplate.meta")); + ByteArrayOutputStream actualModifiedCbamVnfPackage = getFileInZip(new ByteArrayInputStream(bos.toByteArray()), "Artifacts/Deployment/OTHER/cbam.package.zip"); + byte[] expectedModifiedCbamPackage = new CbamVnfPackageBuilder().toModifiedCbamVnfPackage(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip"), "vnfdloc/a.yaml", new CbamVnfdBuilder().build(cbamVnfd)); + assertItenticalZips(expectedModifiedCbamPackage, actualModifiedCbamVnfPackage.toByteArray()); + } + + + /** + * Prevents moving the class (customer documentation) must be updated + */ + @Test + public void testPreventMove() { + assertEquals("org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.OnapVnfPackageBuilder", OnapVnfPackageBuilder.class.getCanonicalName()); + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfdBuilder.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfdBuilder.java new file mode 100644 index 00000000..1edf5eca --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/packagetransformer/TestOnapVnfdBuilder.java @@ -0,0 +1,60 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import java.util.NoSuchElementException; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; + + +public class TestOnapVnfdBuilder extends TestBase { + private OnapVnfdBuilder packageTransformer = new OnapVnfdBuilder(); + + /** + * Test empty VNFD conversion + */ + @Test + public void testEmpty() { + assertEquals(new String(TestUtil.loadFile("unittests/packageconverter/empty.vnfd.onap.yaml")), packageTransformer.toOnapVnfd(new String(TestUtil.loadFile("unittests/packageconverter/empty.vnfd.cbam.yaml")))); + } + + /** + * Test all Tosca nodes conversions for successful scenario + */ + @Test + public void testNodes() { + assertEquals(new String(TestUtil.loadFile("unittests/packageconverter/nodes.vnfd.onap.yaml")), packageTransformer.toOnapVnfd(new String(TestUtil.loadFile("unittests/packageconverter/nodes.vnfd.cbam.yaml")))); + } + + /** + * if a node refers to a non existing node it results in a failure + */ + @Test + public void testInconsitentVnfd() { + try { + packageTransformer.toOnapVnfd(new String(TestUtil.loadFile("unittests/packageconverter/nodes.vnfd.inconsistent.cbam.yaml"))); + fail(); + } catch (NoSuchElementException e) { + assertEquals("The VNFD does not have a node called myComputeMissing but required by an other node", e.getMessage()); + } + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestConverterApi.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestConverterApi.java new file mode 100644 index 00000000..9ac38914 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestConverterApi.java @@ -0,0 +1,114 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi; + +import com.google.common.collect.Lists; +import junit.framework.TestCase; +import org.apache.http.entity.ContentType; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.CbamVnfPackageBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.CbamVnfdBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.packagetransformer.OnapVnfdBuilder; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.mock.web.DelegatingServletOutputStream; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.Part; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.PrintStream; +import java.util.Arrays; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getFileInZip; +import static org.springframework.test.util.ReflectionTestUtils.setField; + + +public class TestConverterApi extends TestBase { + + + @InjectMocks + private ConverterApi converterApi; + @Mock + private HttpServletRequest httpRequest; + + @Before + public void initMocks() throws Exception { + setField(ConverterApi.class, "logger", logger); + } + + /** + */ + @Test + public void test() throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + PrintStream actualOut = new PrintStream(bos, true); + when(systemFunctions.out()).thenReturn(actualOut); + when(systemFunctions.loadFile("cbam.pre.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("cbam.post.collectConnectionPoints.js")).thenCallRealMethod(); + when(systemFunctions.loadFile("TOSCA.meta")).thenCallRealMethod(); + when(systemFunctions.loadFile("MainServiceTemplate.meta")).thenCallRealMethod(); + when(httpResponse.getOutputStream()).thenReturn(new DelegatingServletOutputStream(actualOut)); + Part part = Mockito.mock(Part.class); + when(part.getInputStream()).thenReturn(new ByteArrayInputStream(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip"))); + when(httpRequest.getParts()).thenReturn(Lists.newArrayList(part)); + //when + converterApi.convert(httpResponse, httpRequest); + //verify + verifyVnfPackageWritterToOutputStream(bos); + verify(httpResponse).addHeader(HttpHeaders.CONTENT_TYPE, ContentType.APPLICATION_OCTET_STREAM.getMimeType()); + verify(httpResponse).setStatus(HttpStatus.OK.value()); + verify(httpResponse).addHeader(HttpHeaders.CONTENT_LENGTH, Integer.toString(bos.toByteArray().length)); + verify(httpResponse).addHeader(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + "core.csar" + "\""); + } + + private void verifyVnfPackageWritterToOutputStream(ByteArrayOutputStream bos) throws Exception { + String cbamVnfd = new String(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip.vnfd")); + String expectedOnapVnfd = new OnapVnfdBuilder().toOnapVnfd(cbamVnfd); + assertFileInZip(bos.toByteArray(), "TOSCA-Metadata/TOSCA.meta", TestUtil.loadFile("TOSCA.meta")); + assertFileInZip(bos.toByteArray(), "Definitions/MainServiceTemplate.yaml", expectedOnapVnfd.getBytes()); + assertFileInZip(bos.toByteArray(), "MainServiceTemplate.yaml", expectedOnapVnfd.getBytes()); + assertFileInZip(bos.toByteArray(), "MainServiceTemplate.meta", TestUtil.loadFile("MainServiceTemplate.meta")); + ByteArrayOutputStream actualModifiedCbamVnfPackage = getFileInZip(new ByteArrayInputStream(bos.toByteArray()), "Artifacts/Deployment/OTHER/cbam.package.zip"); + byte[] expectedModifiedCbamPackage = new CbamVnfPackageBuilder().toModifiedCbamVnfPackage(TestUtil.loadFile("unittests/packageconverter/cbam.package.zip"), "vnfdloc/a.yaml", new CbamVnfdBuilder().build(cbamVnfd)); + assertItenticalZips(expectedModifiedCbamPackage, actualModifiedCbamVnfPackage.toByteArray()); + } + + @Test + public void testDownloaderPage() throws Exception { + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + PrintStream actualOut = new PrintStream(bos, true); + when(httpResponse.getOutputStream()).thenReturn(new DelegatingServletOutputStream(actualOut)); + when(systemFunctions.loadFile("upload.html")).thenCallRealMethod(); + //when + converterApi.getUploadPageForConvertingVnfd(httpResponse); + //verify + TestCase.assertTrue(Arrays.equals(TestUtil.loadFile("upload.html"), bos.toByteArray())); + verify(httpResponse).addHeader(HttpHeaders.CONTENT_LENGTH, Integer.toString(bos.toByteArray().length)); + + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcmApi.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcmApi.java new file mode 100644 index 00000000..1fdeb323 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcmApi.java @@ -0,0 +1,130 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vnfmdriver.model.VnfHealRequest; +import org.onap.vnfmdriver.model.VnfInstantiateRequest; +import org.onap.vnfmdriver.model.VnfScaleRequest; +import org.onap.vnfmdriver.model.VnfTerminateRequest; + +import static org.apache.http.HttpStatus.SC_CREATED; +import static org.mockito.Mockito.verify; +import static org.springframework.test.util.ReflectionTestUtils.setField; + + +public class TestLcmApi extends TestBase { + + @Mock + private LifecycleManager lifecycleManager; + @Mock + private JobManager jobManager; + @InjectMocks + private LcmApi lcmApi; + + @Before + public void initMocks() throws Exception { + setField(LcmApi.class, "logger", logger); + } + + /** + * test instantiation handled by LCM + */ + @Test + public void testInstantiation() { + VnfInstantiateRequest req = new VnfInstantiateRequest(); + //when + lcmApi.instantiateVnf(req, VNFM_ID, httpResponse); + //verify + verify(lifecycleManager).instantiate(VNFM_ID, req, httpResponse); + verify(httpResponse).setStatus(SC_CREATED); + verify(logger).info("REST: Instantiate VNF"); + } + + /** + * test heal handled by LCM + */ + @Test + public void testHeal() { + VnfHealRequest req = new VnfHealRequest(); + //when + lcmApi.healVnf(req, VNFM_ID, VNF_ID, httpResponse); + //verify + verify(lifecycleManager).healVnf(VNFM_ID, VNF_ID, req, httpResponse); + verify(logger).info("REST: Heal VNF"); + } + + /** + * test query handled by LCM + */ + @Test + public void testQuery() { + //when + lcmApi.queryVnf(VNFM_ID, VNF_ID, httpResponse); + //verify + verify(lifecycleManager).queryVnf(VNFM_ID, VNF_ID); + verify(logger).info("REST: Query VNF"); + + } + + /** + * test scale handled by LCM + */ + @Test + public void testScale() { + VnfScaleRequest req = new VnfScaleRequest(); + //when + lcmApi.scaleVnf(req, VNFM_ID, VNF_ID, httpResponse); + //verify + verify(lifecycleManager).scaleVnf(VNFM_ID, VNF_ID, req, httpResponse); + verify(logger).info("REST: Scale VNF"); + + } + + /** + * test terminate handled by LCM + */ + @Test + public void testTerminate() { + VnfTerminateRequest req = new VnfTerminateRequest(); + //when + lcmApi.terminateVnf(req, VNFM_ID, VNF_ID, httpResponse); + //verify + verify(lifecycleManager).terminateVnf(VNFM_ID, VNF_ID, req, httpResponse); + verify(logger).info("REST: Terminate VNF"); + + } + + /** + * test job query handled by job manager + */ + @Test + public void testJob() { + //when + lcmApi.getJob(VNFM_ID, JOB_ID, httpResponse); + //verify + verify(jobManager).getJob(VNFM_ID, JOB_ID); + verify(logger).debug("REST: Query job"); + + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcnApi.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcnApi.java new file mode 100644 index 00000000..fc6b97b4 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestLcnApi.java @@ -0,0 +1,65 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi; + +import com.nokia.cbam.lcm.v32.model.VnfLifecycleChangeNotification; +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager; + +import static org.mockito.Mockito.verify; +import static org.springframework.test.util.ReflectionTestUtils.setField; + + +public class TestLcnApi extends TestBase { + + @Mock + private VnfLifecycleChangeNotification lcn; + @Mock + private LifecycleChangeNotificationManager lcnManager; + @InjectMocks + private LcnApi lcnApi; + + @Before + public void initMocks() throws Exception { + setField(LcnApi.class, "logger", logger); + } + + /** + * test REST "ping" from CBAM to driver + */ + @Test + public void testPing() { + lcnApi.testLcnConnectivity(null); + //verify no exception is thrown + } + + /** + * test LCN is handled by LCN manager + */ + @Test + public void testHandleLcn() { + //when + lcnApi.handleLcn(lcn, httpResponse); + //verify + verify(lcnManager).handleLcn(lcn); + verify(logger).info("REST: handle LCN"); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerApi.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerApi.java new file mode 100644 index 00000000..638f7237 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerApi.java @@ -0,0 +1,62 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; + +import javax.servlet.ServletOutputStream; + +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + + +public class TestSwaggerApi extends TestBase { + + @InjectMocks + private SwaggerApi swaggerApi; + + + @Before + public void initMocks() throws Exception { + setField(SwaggerApi.class, "logger", logger); + } + + /** + * test swagger definition get + */ + @Test + public void testSwaggerRetrieval() throws Exception { + byte[] bytes = new byte[]{1, 2}; + when(selfRegistrationManager.getSwaggerApiDefinition()).thenReturn(bytes); + ServletOutputStream os = Mockito.mock(ServletOutputStream.class); + when(httpResponse.getOutputStream()).thenReturn(os); + //when + swaggerApi.getSwaggerApiDefinition(httpResponse); + //verify + verify(httpResponse).addHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE); + verify(httpResponse).addHeader(HttpHeaders.CONTENT_LENGTH, Integer.toString(bytes.length)); + verify(os).write(bytes); + verify(logger).info("REST: get swagger definition"); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerDefinitionConsistency.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerDefinitionConsistency.java new file mode 100644 index 00000000..eeb79be8 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/restapi/TestSwaggerDefinitionConsistency.java @@ -0,0 +1,82 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.restapi; + +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Sets; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import junit.framework.TestCase; +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; + +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.NoSuchElementException; +import java.util.Set; + +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.child; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil.loadFile; + +public class TestSwaggerDefinitionConsistency extends TestBase { + + public static final HashSet<Class<?>> CLASSES = Sets.newHashSet(LcmApi.class, LcnApi.class, SwaggerApi.class, ConverterApi.class); + + @Test + public void test() throws Exception { + JsonObject root = new JsonParser().parse(new String(loadFile("self.swagger.json"))).getAsJsonObject(); + String basePath = root.get("basePath").getAsString(); + HashMultimap<String, RequestMethod> expectedPaths = HashMultimap.create(); + for (String pathName : child(root, "paths").keySet()) { + JsonObject path = child(child(root, "paths"), pathName); + for (String method : path.keySet()) { + locate(basePath + pathName); + expectedPaths.put(basePath + pathName, RequestMethod.valueOf(method.toUpperCase())); + } + } + + for (Class<?> clazz : CLASSES) { + RequestMapping currentBasePath = clazz.getAnnotation(RequestMapping.class); + for (Method method : clazz.getMethods()) { + RequestMapping methodMapping = method.getAnnotation(RequestMapping.class); + if (methodMapping != null) { + String fPath = currentBasePath.value()[0] + methodMapping.value()[0]; + RequestMethod restMethod = methodMapping.method()[0]; + Set<RequestMethod> currentMethods = expectedPaths.get(fPath); + if (!currentMethods.contains(restMethod)) { + TestCase.fail("Not documented REST API" + fPath + " " + restMethod + " current " + currentMethods); + } + } + } + } + } + + private void locate(String path) { + for (Class<?> clazz : CLASSES) { + RequestMapping basePath = clazz.getAnnotation(RequestMapping.class); + for (Method method : clazz.getMethods()) { + RequestMapping methodMapping = method.getAnnotation(RequestMapping.class); + if (methodMapping != null && path.equals(basePath.value()[0] + methodMapping.value()[0])) { + return; + } + } + } + throw new NoSuchElementException(path); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestConditions.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestConditions.java new file mode 100644 index 00000000..f716cad6 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestConditions.java @@ -0,0 +1,66 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring; + +import junit.framework.TestCase; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.springframework.context.annotation.ConditionContext; +import org.springframework.core.env.Environment; + +import static org.mockito.Mockito.when; + +public class TestConditions { + + @Mock + private ConditionContext conditionContext; + @Mock + private Environment environment; + + private String[] activeProfiles = new String[]{"a", "b"}; + + @Before + public void init() { + MockitoAnnotations.initMocks(this); + when(conditionContext.getEnvironment()).thenReturn(environment); + when(environment.getActiveProfiles()).thenReturn(activeProfiles); + } + + /** + * if direct integration is not specified VF-C based integration is used + */ + @Test + public void testVfcBased() throws Exception { + //verify + TestCase.assertTrue(new Conditions.UseForVfc().matches(conditionContext, null)); + TestCase.assertFalse(new Conditions.UseForDirect().matches(conditionContext, null)); + } + + /** + * if direct integration is not specified VF-C based integration is used + */ + @Test + public void testDirectBased() throws Exception { + activeProfiles[1] = "direct"; + //verify + TestCase.assertFalse(new Conditions.UseForVfc().matches(conditionContext, null)); + TestCase.assertTrue(new Conditions.UseForDirect().matches(conditionContext, null)); + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestRealConfig.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestRealConfig.java new file mode 100644 index 00000000..1c92a75a --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestRealConfig.java @@ -0,0 +1,43 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring; + +import com.nokia.cbam.lcm.v32.model.VnfIdentifierCreationNotification; +import com.nokia.cbam.lcm.v32.model.VnfIdentifierDeletionNotification; +import com.nokia.cbam.lcm.v32.model.VnfInfoAttributeValueChangeNotification; +import com.nokia.cbam.lcm.v32.model.VnfLifecycleChangeNotification; +import org.junit.Test; +import org.springframework.boot.autoconfigure.web.HttpMessageConverters; +import org.springframework.http.MediaType; + +public class TestRealConfig { + + /** + * test that the converter can transform the inherited classes + */ + @Test + public void test() throws Exception { + HttpMessageConverters converters = new RealConfig().customConverters(); + //verify + converters.getConverters().get(0).canRead(VnfIdentifierCreationNotification.class, MediaType.APPLICATION_JSON); + converters.getConverters().get(0).canRead(VnfIdentifierDeletionNotification.class, MediaType.APPLICATION_JSON); + converters.getConverters().get(0).canRead(VnfInfoAttributeValueChangeNotification.class, MediaType.APPLICATION_JSON); + converters.getConverters().get(0).canRead(VnfLifecycleChangeNotification.class, MediaType.APPLICATION_JSON); + converters.getConverters().get(0).canRead(String.class, MediaType.APPLICATION_JSON); + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestServletInitializer.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestServletInitializer.java new file mode 100644 index 00000000..75c68959 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/spring/TestServletInitializer.java @@ -0,0 +1,40 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.spring; + +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.NokiaSvnfmApplication; +import org.springframework.boot.builder.SpringApplicationBuilder; + +import static org.mockito.Mockito.verify; + +public class TestServletInitializer { + + /** + * test that the Nokia application is added to the Spring context + */ + @Test + public void testSpringBootApplicationInit() throws Exception { + SpringApplicationBuilder springApplicationBuilder = Mockito.mock(SpringApplicationBuilder.class); + //when + new ServletInitializer().configure(springApplicationBuilder); + //verify + verify(springApplicationBuilder).sources(NokiaSvnfmApplication.class); + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestCbamUtils.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestCbamUtils.java new file mode 100644 index 00000000..7f544616 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestCbamUtils.java @@ -0,0 +1,136 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util; + +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; +import org.junit.Test; +import org.mockito.Mockito; +import org.slf4j.Logger; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.fail; +import static org.mockito.Mockito.verify; + +public class TestCbamUtils { + + /** + * test child of json object + */ + @Test + public void testChild() throws Exception { + JsonObject parent = new JsonObject(); + JsonObject child = new JsonObject(); + parent.add("x", child); + assertEquals(child, CbamUtils.child(parent, "x")); + } + + /** + * if child is not a json object error is propagated + */ + @Test + public void testNonJsonObjectChild() throws Exception { + JsonObject parent = new JsonObject(); + JsonPrimitive child = new JsonPrimitive("y"); + parent.add("x", child); + try { + CbamUtils.child(parent, "x"); + fail(); + } catch (RuntimeException e) { + assertEquals("Not a JSON Object: \"y\"", e.getMessage()); + } + } + + /** + * if no child is present error is propagated + */ + @Test + public void testMissingChild() throws Exception { + JsonObject parent = new JsonObject(); + try { + CbamUtils.child(parent, "z"); + fail(); + } catch (RuntimeException e) { + assertEquals("Missing child z", e.getMessage()); + } + } + + /** + * test child of json object + */ + @Test + public void testChildElement() throws Exception { + JsonObject parent = new JsonObject(); + JsonPrimitive child = new JsonPrimitive("y"); + parent.add("x", child); + assertEquals(child, CbamUtils.childElement(parent, "x")); + } + + /** + * if no child is present error is propagated + */ + @Test + public void testMissingChildElement() throws Exception { + JsonObject parent = new JsonObject(); + try { + CbamUtils.childElement(parent, "z"); + fail(); + } catch (RuntimeException e) { + assertEquals("Missing child z", e.getMessage()); + } + } + + + /** + * test fatal failure handling + */ + @Test + public void testFatalFailure() throws Exception { + Exception expectedException = new Exception(); + Logger logger = Mockito.mock(Logger.class); + try { + CbamUtils.fatalFailure(logger, "msg", expectedException); + fail(); + } catch (RuntimeException e) { + assertEquals("msg", e.getMessage()); + assertEquals(expectedException, e.getCause()); + verify(logger).error("msg", expectedException); + } + } + + /** + * test fatal failure handling with no wrapped exception + */ + @Test + public void testFatalFailureWithNoException() throws Exception { + Logger logger = Mockito.mock(Logger.class); + try { + CbamUtils.fatalFailure(logger, "msg"); + fail(); + } catch (RuntimeException e) { + assertEquals("msg", e.getMessage()); + verify(logger).error("msg"); + } + } + + @Test + public void useStaticWay() { + TestUtil.coveragePrivateConstructorForClassesWithStaticMethodsOnly(CbamUtils.class); + } + + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestStoreLoader.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestStoreLoader.java new file mode 100644 index 00000000..2dc33f3b --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestStoreLoader.java @@ -0,0 +1,346 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util; + +import org.junit.BeforeClass; +import org.junit.Test; + +import java.io.File; +import java.io.FileInputStream; +import java.io.IOException; +import java.net.URL; +import java.security.KeyStore; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; +import java.security.cert.CertificateException; +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; + +import static com.google.common.collect.Sets.newHashSet; +import static org.junit.Assert.*; + +public class TestStoreLoader { + + private static final String PASSWORD = "password"; + private static final String SUN = "SUN"; + private static final String JKS = "JKS"; + private static final String TEST_JKS = "test.jks"; + private static final String PEM_WITHOUT_BEGIN = "" + + "INVALID\n" + + "-----END RSA PRIVATE KEY-----"; + private static final String PEM_WITHOUT_END = "-----BEGIN RSA PRIVATE KEY-----\n" + + "INVALID\n" + + ""; + private static final String PEMS_WITHOUT_PRIVATE_KEY = "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4jUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----\n" + + "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4tUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----"; + private static final String PEMS = "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4jUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----\n" + + "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4tUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----\n" + + "-----BEGIN RSA PRIVATE KEY-----\n" + + "MIIEuwIBADANBgkqhkiG9w0BAQEFAASCBKUwggShAgEAAoIBAF53wUbKmDHtvfOb8u1HPqEBFNNF\n" + + "csnOMjIcSEhAwIQMbgrOuQ+vH/YgXuuDJaURS85H8P4UTt6lYOJn+SFnXvS82E7LHJpVrWwQzbh2\n" + + "QKh13/akPe90DlNTUGEYO7rHaPLqTlld0jkLFSytwqfwqn9yrYpM1ncUOpCciK5j8t8MzO71LJoJ\n" + + "g24CFxpjIS0tBrJvKzrRNcxWSRDLmu2kNmtsh7yyJouE6XoizVmBmNVltHhFaDMmqjugMQA2CZfL\n" + + "rxiR1ep8TH8IBvPqysqZI1RIpB/e0engP4/1KLrOt+6gGS0JEDh1kG2fJObl+N4n3sCOtgaz5Uz8\n" + + "8jpwbmZ3Se8CAwEAAQKCAQAdOsSs2MbavAsIM3qo/GBehO0iqdxooMpbQvECmjZ3JTlvUqNkPPWQ\n" + + "vFdiW8PsHTvtackhdLsqnNUreKxXL5rr8vqi9qm0/0mXpGNi7gP3m/FeaVdYnfpIwgCe6lag5k6M\n" + + "yv7PG/6N8+XrWyBdwlOe96bGohvB4Jp2YFjSTM67QONQ8CdmfqokqJ8/3RyrpDvGN3iX3yzBqXGO\n" + + "jPkoJQv3I4lsYdR0nl4obHHnMSeWCQCYvJoZ7ZOliu/Dd0ksItlodG6s8r/ujkSa8VIhe0fnXTf0\n" + + "i7lqa55CAByGN4MOR0bAkJwIB7nZzQKurBPcTAYJFFvAc5hgMnWT0XW83TehAoGBALVPGnznScUw\n" + + "O50OXKI5yhxGf/XDT8g28L8Oc4bctRzI+8YfIFfLJ57uDGuojO/BpqtYmXmgORru0jYR8idEkZrx\n" + + "gf62czOiJrCWTkBCEMtrNfFHQJQCQrjfbHofp7ODnEHbHFm7zdlbfNnEBBaKXxd2rVv4UTEhgftv\n" + + "wsHcimbXAoGBAIViWrHWElMeQT0datqlThE/u51mcK4VlV7iRWXVa1/gAP85ZAu44VvvDlkpYVkF\n" + + "zSRR+lHSOzsubDMN45OBQW6UA3RPg4TCvrTOmhQUeF5XPuSdcD0R2At6pdaLwAKnOtILg13Ha6ym\n" + + "Igjv8glodvem3hWLmpHIhNBiaXtf8wqpAoGADH5a8OhvKOtd8EChGXyp9LDW+HRw9vbyN/gi9dQX\n" + + "ltgyoUBb1jDllgoJSRHgRFUvyvbb/ImR5c03JwqtiQ8siWTC9G5WGeS+jcSNt9fVmG7W1L14MbrG\n" + + "Jj8fFns/7xrOlasnlPdgA+5N+CONtI/sZY2D/KZr0drhPhZBcWJlFxkCgYAn+4SOPEo/6hjKNhA6\n" + + "vER7fSxDEVsDg+rDh3YgAWpvUdlaqBxqOyAqi600YugQZGHK2lv7vNYOdmrunuIx7BPuDqY+bjtR\n" + + "R4Mc9bVQAZbXSLXMl7j2RWwKfNhLSJbk9LX4EoVtTgLjvOUE4tAdq9fFgpqdwLwzqPTO9kECP4++\n" + + "CQKBgH6tO/xcNxG/uXUideluAn3H2KeyyznZMJ7oCvzf26/XpTAMI243OoeftiKVMgxuZ7hjwqfn\n" + + "/VHXABc4i5gchr9RzSb1hZ/IqFzq2YGmbppg5Ok2cgwalDoDBi21bRf8aDRweL62mO+7aPnCQZ58\n" + + "j5W72PB8BAr6xg0Oro25O4os\n" + + "-----END RSA PRIVATE KEY-----"; + private static final String PEM = "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4jUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----\n" + + "-----BEGIN RSA PRIVATE KEY-----\n" + + "MIIEuwIBADANBgkqhkiG9w0BAQEFAASCBKUwggShAgEAAoIBAF53wUbKmDHtvfOb8u1HPqEBFNNF\n" + + "csnOMjIcSEhAwIQMbgrOuQ+vH/YgXuuDJaURS85H8P4UTt6lYOJn+SFnXvS82E7LHJpVrWwQzbh2\n" + + "QKh13/akPe90DlNTUGEYO7rHaPLqTlld0jkLFSytwqfwqn9yrYpM1ncUOpCciK5j8t8MzO71LJoJ\n" + + "g24CFxpjIS0tBrJvKzrRNcxWSRDLmu2kNmtsh7yyJouE6XoizVmBmNVltHhFaDMmqjugMQA2CZfL\n" + + "rxiR1ep8TH8IBvPqysqZI1RIpB/e0engP4/1KLrOt+6gGS0JEDh1kG2fJObl+N4n3sCOtgaz5Uz8\n" + + "8jpwbmZ3Se8CAwEAAQKCAQAdOsSs2MbavAsIM3qo/GBehO0iqdxooMpbQvECmjZ3JTlvUqNkPPWQ\n" + + "vFdiW8PsHTvtackhdLsqnNUreKxXL5rr8vqi9qm0/0mXpGNi7gP3m/FeaVdYnfpIwgCe6lag5k6M\n" + + "yv7PG/6N8+XrWyBdwlOe96bGohvB4Jp2YFjSTM67QONQ8CdmfqokqJ8/3RyrpDvGN3iX3yzBqXGO\n" + + "jPkoJQv3I4lsYdR0nl4obHHnMSeWCQCYvJoZ7ZOliu/Dd0ksItlodG6s8r/ujkSa8VIhe0fnXTf0\n" + + "i7lqa55CAByGN4MOR0bAkJwIB7nZzQKurBPcTAYJFFvAc5hgMnWT0XW83TehAoGBALVPGnznScUw\n" + + "O50OXKI5yhxGf/XDT8g28L8Oc4bctRzI+8YfIFfLJ57uDGuojO/BpqtYmXmgORru0jYR8idEkZrx\n" + + "gf62czOiJrCWTkBCEMtrNfFHQJQCQrjfbHofp7ODnEHbHFm7zdlbfNnEBBaKXxd2rVv4UTEhgftv\n" + + "wsHcimbXAoGBAIViWrHWElMeQT0datqlThE/u51mcK4VlV7iRWXVa1/gAP85ZAu44VvvDlkpYVkF\n" + + "zSRR+lHSOzsubDMN45OBQW6UA3RPg4TCvrTOmhQUeF5XPuSdcD0R2At6pdaLwAKnOtILg13Ha6ym\n" + + "Igjv8glodvem3hWLmpHIhNBiaXtf8wqpAoGADH5a8OhvKOtd8EChGXyp9LDW+HRw9vbyN/gi9dQX\n" + + "ltgyoUBb1jDllgoJSRHgRFUvyvbb/ImR5c03JwqtiQ8siWTC9G5WGeS+jcSNt9fVmG7W1L14MbrG\n" + + "Jj8fFns/7xrOlasnlPdgA+5N+CONtI/sZY2D/KZr0drhPhZBcWJlFxkCgYAn+4SOPEo/6hjKNhA6\n" + + "vER7fSxDEVsDg+rDh3YgAWpvUdlaqBxqOyAqi600YugQZGHK2lv7vNYOdmrunuIx7BPuDqY+bjtR\n" + + "R4Mc9bVQAZbXSLXMl7j2RWwKfNhLSJbk9LX4EoVtTgLjvOUE4tAdq9fFgpqdwLwzqPTO9kECP4++\n" + + "CQKBgH6tO/xcNxG/uXUideluAn3H2KeyyznZMJ7oCvzf26/XpTAMI243OoeftiKVMgxuZ7hjwqfn\n" + + "/VHXABc4i5gchr9RzSb1hZ/IqFzq2YGmbppg5Ok2cgwalDoDBi21bRf8aDRweL62mO+7aPnCQZ58\n" + + "j5W72PB8BAr6xg0Oro25O4os\n" + + "-----END RSA PRIVATE KEY-----"; + private static final String PEM_WITHOUT_PRIVATE_KEY = + "-----BEGIN CERTIFICATE-----\n" + + "MIICUTCCAfugAwIBAgIBADANBgkqhkiG9w0BAQQFADBXMQswCQYDVQQGEwJDTjEL\n" + + "MAkGA1UECBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMC\n" + + "VU4xFDASBgNVBAMTC0hlcm9uZyBZYW5nMB4XDTA1MDcxNTIxMTk0N1oXDTA1MDgx\n" + + "NDIxMTk0N1owVzELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAlBOMQswCQYDVQQHEwJD\n" + + "TjELMAkGA1UEChMCT04xCzAJBgNVBAsTAlVOMRQwEgYDVQQDEwtIZXJvbmcgWWFu\n" + + "ZzBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQCp5hnG7ogBhtlynpOS21cBewKE/B7j\n" + + "V14qeyslnr26xZUsSVko36ZnhiaO/zbMOoRcKK9vEcgMtcLFuQTWDl3RAgMBAAGj\n" + + "gbEwga4wHQYDVR0OBBYEFFXI70krXeQDxZgbaCQoR4jUDncEMH8GA1UdIwR4MHaA\n" + + "FFXI70krXeQDxZgbaCQoR4jUDncEoVukWTBXMQswCQYDVQQGEwJDTjELMAkGA1UE\n" + + "CBMCUE4xCzAJBgNVBAcTAkNOMQswCQYDVQQKEwJPTjELMAkGA1UECxMCVU4xFDAS\n" + + "BgNVBAMTC0hlcm9uZyBZYW5nggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEE\n" + + "BQADQQA/ugzBrjjK9jcWnDVfGHlk3icNRq0oV7Ri32z/+HQX67aRfgZu7KWdI+Ju\n" + + "Wm7DCfrPNGVwFWUQOmsPue9rZBgO\n" + + "-----END CERTIFICATE-----"; + private static final String INVALID_CERT = + "-----BEGIN CERTIFICATE-----\n" + + "MIIC" + + "-----END CERTIFICATE-----"; + private static final String PEM_WITH_INVALID_PRIVATE_KEY = "-----BEGIN RSA PRIVATE KEY-----\n" + + "INVALID\n" + + "-----END RSA PRIVATE KEY-----"; + private static final String EMPTY_PEM = ""; + private static KeyStore testStore; + + @BeforeClass + public static void setUpBefore() throws NoSuchProviderException, KeyStoreException, CertificateException, NoSuchAlgorithmException, IOException { + testStore = KeyStore.getInstance(JKS, SUN); + ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); + URL url = classLoader.getResource(TEST_JKS); + String jksFileName = url.getFile(); + File jks = new File(jksFileName); + FileInputStream fos = new FileInputStream(jks); + testStore.load(fos, PASSWORD.toCharArray()); + } + + @Test + public void useInStaticWay() { + TestUtil.coveragePrivateConstructorForClassesWithStaticMethodsOnly(StoreLoader.class); + } + + /** + * test certificate extraction from PEM + */ + @Test + public void testCertifate() { + assertEquals(new HashSet<>(), StoreLoader.getCertifacates("")); + String pem = "-----BEGIN CERTIFICATE-----\ncontent1\n-----END CERTIFICATE-----\n-----BEGIN CERTIFICATE-----\ncontent2\n-----END CERTIFICATE-----"; + Set<String> certifacates = StoreLoader.getCertifacates(pem); + assertEquals(newHashSet("-----BEGIN CERTIFICATE-----\ncontent1\n-----END CERTIFICATE-----", "-----BEGIN CERTIFICATE-----\ncontent2\n-----END CERTIFICATE-----"), certifacates); + } + + /** + * test keystore loading from PEM with single certificate & key + */ + @Test + public void loadStrore() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(PEM, PASSWORD, PASSWORD); + + //then + assertNotNull(ks.getCertificate(PASSWORD)); + assertTrue(Arrays.equals(testStore.getCertificate(PASSWORD).getPublicKey().getEncoded(), ks.getCertificate(PASSWORD).getPublicKey().getEncoded())); + } + + /** + * test keystore loading from PEM with multiple certifcates + */ + @Test + public void loadStroreWithCerts() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(PEMS, PASSWORD, PASSWORD); + + //then + assertNotNull(ks.getCertificate(PASSWORD)); + assertTrue(Arrays.equals(testStore.getCertificate(PASSWORD).getPublicKey().getEncoded(), ks.getCertificate(PASSWORD).getPublicKey().getEncoded())); + } + + /** + * test keystore loading from PEM without a private key + */ + @Test + public void loadStroreWithCertsWithoutPrivateKey() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(PEMS_WITHOUT_PRIVATE_KEY, PASSWORD, PASSWORD); + + //then + assertNotNull(ks); + String alias = PASSWORD + "0"; + assertNotNull(ks.getCertificate(alias)); + assertTrue(Arrays.equals(testStore.getCertificate(PASSWORD).getPublicKey().getEncoded(), ks.getCertificate(alias).getPublicKey().getEncoded())); + } + + /** + * non closed BEGIN CERTIFICATE pattern results in empty keystore + */ + @Test + public void loadStroreWithPemWithoutBegin() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(PEM_WITHOUT_BEGIN, PASSWORD, PASSWORD); + + //then + assertNull(ks.getCertificate(PASSWORD)); + } + + /** + * non closed END CERTIFICATE pattern results in empty keystore + */ + @Test + public void loadStroreWithPemWithoutEnd() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(PEM_WITHOUT_END, PASSWORD, PASSWORD); + + //then + assertNull(ks.getCertificate(PASSWORD)); + } + + /** + * empty PEM results in empty keystore + */ + @Test + public void loadStroreWithPemWithoutBeginAndEnd() throws Exception { + //when + KeyStore ks = StoreLoader.loadStore(EMPTY_PEM, PASSWORD, PASSWORD); + + //then + assertNull(ks.getCertificate(PASSWORD)); + } + + /** + * invalid private key results in an error + */ + @Test + public void loadStroreWithPemWithInvalidKey() throws Exception { + //when + try { + StoreLoader.loadStore(PEM_WITH_INVALID_PRIVATE_KEY, PASSWORD, PASSWORD); + fail(); + } catch (Exception e) { + assertEquals("Unable to load key", e.getMessage()); + + } + } + + /** + * invalid password results in error + */ + @Test + public void testInvlaidPassword() throws Exception { + //when + try { + StoreLoader.loadStore(PEM, null, null); + fail(); + } catch (Exception e) { + assertEquals("Unable to create keystore", e.getMessage()); + } + } + + /** + * invalid certificate results in error + */ + @Test + public void testInvlaidCertificate() throws Exception { + //when + try { + StoreLoader.loadStore(INVALID_CERT, null, null); + fail(); + } catch (Exception e) { + assertEquals("Unable to load certificates", e.getMessage()); + + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestSystemFunctions.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestSystemFunctions.java new file mode 100644 index 00000000..ec1ebd78 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestSystemFunctions.java @@ -0,0 +1,118 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util; + +import org.junit.Test; + +import java.util.Base64; +import java.util.HashSet; +import java.util.Set; + +import static org.junit.Assert.*; + +public class TestSystemFunctions { + + /** + * test sleep + */ + @Test + public void testSleep() throws Exception { + long start = System.currentTimeMillis(); + SystemFunctions.systemFunctions().sleep(123); + long end = System.currentTimeMillis(); + assertTrue(end - start >= 123); + } + + /** + * test interrupted sleep + */ + @Test + public void testInterruptedSleep() throws Exception { + long start = System.currentTimeMillis(); + Set<RuntimeException> exceptions = new HashSet<>(); + class Inter extends Thread { + @Override + public void run() { + try { + SystemFunctions.systemFunctions().sleep(10000); + } catch (RuntimeException e) { + exceptions.add(e); + } + } + } + Inter inter = new Inter(); + inter.start(); + //when + inter.interrupt(); + + //verify + while (exceptions.size() != 1) { + + } + } + + /** + * test current time + */ + @Test + public void testCurrentTime() { + long now = System.currentTimeMillis(); + long now2 = SystemFunctions.systemFunctions().currentTimeMillis(); + assertTrue(Math.abs(now2 - now) < 1000); + } + + /** + * test file load + */ + @Test + public void testFileLoad() { + byte[] bytes = SystemFunctions.systemFunctions().loadFile("unittests/empty.zip"); + assertEquals("UEsFBgAAAAAAAAAAAAAAAAAAAAAAAA==", Base64.getEncoder().encodeToString(bytes)); + } + + /** + * missing file results in error + */ + @Test + public void testMissingFileLoad() { + try { + SystemFunctions.systemFunctions().loadFile("unittests/missing"); + fail(); + } catch (Exception e) { + assertEquals("Unable to load unittests/missing", e.getMessage()); + } + } + + /** + * Test standard stream wrapping + */ + @Test + public void testStandardStreams() { + assertEquals(System.err, SystemFunctions.systemFunctions().err()); + assertEquals(System.out, SystemFunctions.systemFunctions().out()); + assertEquals(System.in, SystemFunctions.systemFunctions().in()); + } + + /** + * Test HTTP client wrapping + * (semi useless test) + */ + @Test + public void testHttp() { + assertNotNull(SystemFunctions.systemFunctions().getHttpClient()); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestUtil.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestUtil.java new file mode 100644 index 00000000..f5d9cc41 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/util/TestUtil.java @@ -0,0 +1,57 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util; + +import com.google.common.io.ByteStreams; + +import java.io.InputStream; +import java.lang.reflect.Constructor; + +public class TestUtil { + /** + * Due to sonar issue you have to create a private constructor for classes + * that only have static methods to prevent the creation of instances. This + * constructor can not be coveraged / tested since it is private. + * + * @param clazz + */ + public static void coveragePrivateConstructorForClassesWithStaticMethodsOnly(Class<?> clazz) { + for (Constructor<?> constructor : clazz.getDeclaredConstructors()) { + if (constructor.getParameterTypes().length == 0) { + constructor.setAccessible(true); + try { + constructor.newInstance(); + } catch (Exception e) { + throw new IllegalStateException(e); + } + } else { + throw new IllegalStateException("This should only be used if the class has a singe private constructor"); + } + } + } + + public static byte[] loadFile(String url) { + try { + InputStream stream = SystemFunctions.class.getClassLoader().getResourceAsStream(url); + byte[] bytes = ByteStreams.toByteArray(stream); + return bytes; + } catch (Exception e) { + throw new RuntimeException("Unable to load " + url, e); + } + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestAdditionalParams.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestAdditionalParams.java new file mode 100644 index 00000000..e0e90000 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestAdditionalParams.java @@ -0,0 +1,61 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.common.collect.Maps; +import com.nokia.cbam.lcm.v32.model.NetworkAddress; +import org.junit.Test; +import pl.pojo.tester.internal.field.AbstractFieldValueChanger; +import pl.pojo.tester.internal.field.DefaultFieldValueChanger; +import pl.pojo.tester.internal.field.collections.map.AbstractMapFieldValueChanger; + +import java.util.List; +import java.util.Map; +import java.util.UUID; + +import static pl.pojo.tester.api.assertion.Assertions.assertPojoMethodsFor; + + +public class TestAdditionalParams { + + /** + * Test basic POJO behaviour + */ + @Test + public void test() { + + class MapValueChanger extends AbstractMapFieldValueChanger<Map<String, List<NetworkAddress>>> { + @Override + protected Map<String, List<NetworkAddress>> increaseValue(Map<String, List<NetworkAddress>> stringListMap, Class<?> aClass) { + if (stringListMap == null) { + return Maps.newHashMap(); + } else { + stringListMap.put(UUID.randomUUID().toString(), null); + return stringListMap; + } + } + + @Override + protected boolean canChange(Class<?> type) { + return type.getCanonicalName().contains("Map"); + } + } + + final AbstractFieldValueChanger valueChanger = new MapValueChanger().attachNext(DefaultFieldValueChanger.INSTANCE); + assertPojoMethodsFor(AdditionalParams.class).using(valueChanger).areWellImplemented(); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestBase.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestBase.java new file mode 100644 index 00000000..be3ea0eb --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestBase.java @@ -0,0 +1,174 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.common.io.ByteStreams; +import com.nokia.cbam.catalog.v1.api.DefaultApi; +import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi; +import com.nokia.cbam.lcm.v32.api.VnfsApi; +import com.nokia.cbam.lcn.v32.api.SubscriptionsApi; +import org.apache.commons.lang3.ArrayUtils; +import org.apache.http.HttpEntity; +import org.apache.http.client.methods.CloseableHttpResponse; +import org.apache.http.client.methods.HttpUriRequest; +import org.apache.http.impl.client.CloseableHttpClient; +import org.assertj.core.util.Lists; +import org.junit.After; +import org.junit.Before; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.onap.msb.sdk.httpclient.msb.MSBServiceClient; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.INotificationSender; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VnfmInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.MsbApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcRestApiProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions; +import org.onap.vfccatalog.api.VnfpackageApi; +import org.onap.vnfmdriver.api.NslcmApi; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.core.env.Environment; +import org.springframework.test.util.ReflectionTestUtils; + +import javax.servlet.http.HttpServletResponse; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.lang.reflect.Field; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertTrue; +import static org.mockito.Mockito.when; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getFileInZip; + +public class TestBase { + public static final String VNF_ID = "myVnfId"; + public static final String VNFM_ID = "myVnfmId"; + public static final String ONAP_CSAR_ID = "myOnapCsarId"; + public static final String VIM_ID = "myVimId"; + public static final String JOB_ID = "myJobId"; + public static final String CBAM_VNFD_ID = "cbamVnfdId"; + @Mock + protected CbamRestApiProvider cbamRestApiProvider; + @Mock + protected VfcRestApiProvider vfcRestApiProvider; + @Mock + protected MsbApiProvider msbApiProvider; + @Mock + protected VnfmInfoProvider vnfmInfoProvider; + @Mock + protected VnfsApi vnfApi; + @Mock + protected OperationExecutionsApi operationExecutionApi; + @Mock + protected SelfRegistrationManager selfRegistrationManager; + @Mock + protected Logger logger; + @Mock + protected SubscriptionsApi lcnApi; + @Mock + protected MSBServiceClient msbClient; + @Mock + protected DriverProperties driverProperties; + @Mock + protected NslcmApi nsLcmApi; + @Mock + protected INotificationSender notificationSender; + @Mock + protected SystemFunctions systemFunctions; + @Mock + protected VnfpackageApi vfcCatalogApi; + @Mock + protected DefaultApi cbamCatalogApi; + @Mock + protected CloseableHttpClient httpClient; + @Mock + protected CloseableHttpResponse response; + protected ArgumentCaptor<HttpUriRequest> request = ArgumentCaptor.forClass(HttpUriRequest.class); + @Mock + protected HttpEntity entity; + @Mock + protected HttpServletResponse httpResponse; + @Mock + protected Environment environment; + + @Before + public void genericSetup() throws Exception { + MockitoAnnotations.initMocks(this); + ReflectionTestUtils.setField(SystemFunctions.class, "INSTANCE", systemFunctions); + when(cbamRestApiProvider.getCbamLcmApi(VNFM_ID)).thenReturn(vnfApi); + when(cbamRestApiProvider.getCbamOperationExecutionApi(VNFM_ID)).thenReturn(operationExecutionApi); + when(cbamRestApiProvider.getCbamLcnApi(VNFM_ID)).thenReturn(lcnApi); + when(cbamRestApiProvider.getCbamCatalogApi(VNFM_ID)).thenReturn(cbamCatalogApi); + when(msbApiProvider.getMsbClient()).thenReturn(msbClient); + when(vfcRestApiProvider.getNsLcmApi()).thenReturn(nsLcmApi); + when(vfcRestApiProvider.getOnapCatalogApi()).thenReturn(vfcCatalogApi); + when(systemFunctions.getHttpClient()).thenReturn(httpClient); + when(httpClient.execute(request.capture())).thenReturn(response); + when(response.getEntity()).thenReturn(entity); + when(driverProperties.getVnfmId()).thenReturn(VNFM_ID); + when(systemFunctions.getHttpClient()).thenReturn(httpClient); + } + + @After + public void tearGeneric() { + ReflectionTestUtils.setField(SystemFunctions.class, "INSTANCE", null); + } + + protected void assertFileInZip(byte[] zip, String path, byte[] expectedContent) throws Exception { + assertTrue(Arrays.equals(expectedContent, getFileInZip(new ByteArrayInputStream(zip), path).toByteArray())); + } + + protected void assertItenticalZips(byte[] expected, byte[] actual) throws Exception { + assertEquals(build(expected), build(actual)); + } + + private Map<String, List<Byte>> build(byte[] zip) throws Exception { + Map<String, List<Byte>> files = new HashMap<>(); + ZipInputStream zipInputStream = new ZipInputStream(new ByteArrayInputStream(zip)); + ZipEntry zipEntry; + while ((zipEntry = zipInputStream.getNextEntry()) != null) { + ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); + ByteStreams.copy(zipInputStream, byteArrayOutputStream); + files.put(zipEntry.getName(), Lists.newArrayList(ArrayUtils.toObject(byteArrayOutputStream.toByteArray()))); + } + zipInputStream.close(); + return files; + } + + protected void setFieldWithPropertyAnnotation(Object obj, String key, String value) { + for (Field field : obj.getClass().getDeclaredFields()) { + for (Value fieldValue : field.getAnnotationsByType(Value.class)) { + if (fieldValue.value().equals(key)) { + try { + field.setAccessible(true); + field.set(obj, value); + } catch (IllegalAccessException e) { + throw new RuntimeException(e); + } + } + } + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamCatalogManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamCatalogManager.java new file mode 100644 index 00000000..f38758f0 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamCatalogManager.java @@ -0,0 +1,261 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.IPackageProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +import static junit.framework.TestCase.*; +import static org.junit.Assert.assertArrayEquals; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CatalogManager.getFileInZip; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestCbamCatalogManager extends TestBase { + + private static final String CSAR_ID = "csarId"; + private static final String CBAM_VNFD_ID = "CBAM_VNFD_ID"; + private CatalogManager cbamCatalogManager; + @Mock + private IPackageProvider packageProvider; + + private List<CatalogAdapterVnfpackage> existingVnfPackages = new ArrayList<>(); + private ArgumentCaptor<File> uploadedFile = ArgumentCaptor.forClass(File.class); + + @Before + public void initMocks() throws Exception { + setField(CatalogManager.class, "logger", logger); + when(cbamCatalogApi.list()).thenReturn(existingVnfPackages); + cbamCatalogManager = new CatalogManager(cbamRestApiProvider, packageProvider); + } + + /** + * the package is transferred from source to CBAM catalog + */ + @Test + public void testPackageTransfer() throws Exception { + CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage(); + existingPackage.setVnfdId("unknownId"); + existingVnfPackages.add(existingPackage); + CatalogAdapterVnfpackage createdPackage = new CatalogAdapterVnfpackage(); + createdPackage.setVnfdId(CBAM_VNFD_ID); + when(cbamCatalogApi.create(uploadedFile.capture())).thenAnswer(new Answer<CatalogAdapterVnfpackage>() { + @Override + public CatalogAdapterVnfpackage answer(InvocationOnMock invocationOnMock) throws Throwable { + return createdPackage; + } + }); + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(packageProvider.getPackage(CSAR_ID)).thenReturn(onapPackageContent); + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + //when + CatalogAdapterVnfpackage cbamPackage = cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + //verify + byte[] a2 = Files.readAllBytes(uploadedFile.getValue().toPath()); + assertArrayEquals(getFileInZip(new ByteArrayInputStream(onapPackageContent), "Artifacts/Deployment/OTHER/cbam.package.zip").toByteArray(), a2); + assertEquals(createdPackage, cbamPackage); + } + + /** + * the package is transfer fails, but the package has been uploaded (possibly by other thread / work flow) + * the transfer succeeds + */ + @Test + public void testPackageTransferConcurrency() throws Exception { + CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage(); + existingPackage.setVnfdId("unknownId"); + existingVnfPackages.add(existingPackage); + CatalogAdapterVnfpackage createdPackage = new CatalogAdapterVnfpackage(); + createdPackage.setVnfdId(CBAM_VNFD_ID); + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(packageProvider.getPackage(CSAR_ID)).thenReturn(onapPackageContent); + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + RuntimeException can_not_upload_package = new RuntimeException("Can not upload package"); + when(cbamCatalogApi.create(uploadedFile.capture())).thenAnswer(new Answer<CatalogAdapterVnfpackage>() { + @Override + public CatalogAdapterVnfpackage answer(InvocationOnMock invocationOnMock) throws Throwable { + //this is done by an other thread + existingVnfPackages.add(createdPackage); + when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(createdPackage); + throw can_not_upload_package; + } + }); + //when + CatalogAdapterVnfpackage cbamPackage = cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + //verify + //the correct portion of the package is extracted and uploaded to CBAM + byte[] expectedContentToUpload = getFileInZip(new ByteArrayInputStream(onapPackageContent), "Artifacts/Deployment/OTHER/cbam.package.zip").toByteArray(); + assertTrue(Arrays.equals(expectedContentToUpload, Files.readAllBytes(uploadedFile.getValue().toPath()))); + assertEquals(createdPackage, cbamPackage); + verify(logger).debug("Probably concurrent package uploads", can_not_upload_package); + } + + /** + * If the package already exists in CBAM catalog it is not re-uploaded + */ + @Test + public void testIdempotentPackageUpload() throws Exception { + CatalogAdapterVnfpackage createdPackage = new CatalogAdapterVnfpackage(); + createdPackage.setVnfdId(CBAM_VNFD_ID); + when(cbamCatalogApi.create(uploadedFile.capture())).thenAnswer(new Answer<CatalogAdapterVnfpackage>() { + @Override + public CatalogAdapterVnfpackage answer(InvocationOnMock invocationOnMock) throws Throwable { + return createdPackage; + } + }); + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage(); + existingPackage.setVnfdId(CBAM_VNFD_ID); + existingVnfPackages.add(existingPackage); + when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenReturn(existingPackage); + //when + CatalogAdapterVnfpackage cbamPackage = cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + //verify + verify(cbamCatalogApi, never()).create(Mockito.any()); + assertEquals(existingPackage, cbamPackage); + verify(packageProvider, never()).getPackage(CSAR_ID); + } + + /** + * failure to list package in CBAM results in error + */ + @Test + public void testFailureToListVnfPackagesInCbam() throws Exception { + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException(); + when(cbamCatalogApi.list()).thenThrow(expectedException); + //when + try { + cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to determine if the VNF package has been replicated in CBAM", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * failure to query package from CBAM results in error + */ + @Test + public void testFailureToQueryVnfPackagesFromCbam() throws Exception { + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage(); + existingPackage.setVnfdId(CBAM_VNFD_ID); + existingVnfPackages.add(existingPackage); + com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException(); + when(cbamCatalogApi.getById(CBAM_VNFD_ID)).thenThrow(expectedException); + //when + try { + cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VNF package with CBAM_VNFD_ID from CBAM", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * failure to create package in CBAM results in error + */ + @Test + public void testFailureToCreatePackageInCbam() throws Exception { + CatalogAdapterVnfpackage existingPackage = new CatalogAdapterVnfpackage(); + existingPackage.setVnfdId("unknownId"); + existingVnfPackages.add(existingPackage); + when(packageProvider.getCbamVnfdId(CSAR_ID)).thenReturn(CBAM_VNFD_ID); + byte[] onapPackageContent = TestUtil.loadFile("unittests/TestCbamCatalogManager.sample.csar"); + when(packageProvider.getPackage(CSAR_ID)).thenReturn(onapPackageContent); + com.nokia.cbam.catalog.v1.ApiException expectedException = new com.nokia.cbam.catalog.v1.ApiException(); + when(cbamCatalogApi.create(Mockito.any())).thenThrow(expectedException); + try { + cbamCatalogManager.preparePackageInCbam(VNFM_ID, CSAR_ID); + fail(); + } catch (Exception e) { + verify(logger).error("Unable to create VNF with csarId CSAR identifier in package in CBAM", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * the VNFD is extracted from zip + */ + @Test + public void testExtractVnfdFromPackage() throws Exception { + Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar"); + Files.write(csar, TestUtil.loadFile("unittests/cbam.package.zip")); + when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile()); + //when + String content = cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID); + //verify + assertEquals("dummy vnfd\n", content); + } + + /** + * if VNFD the Tosca meta can not be extracted sensible error is returned + */ + @Test + public void testEmptyCbamPackage() throws Exception { + Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar"); + Files.write(csar, TestUtil.loadFile("unittests/empty.zip")); + when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile()); + //when + try { + cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID); + fail(); + } catch (RuntimeException e) { + verify(logger).error("Unable to get package with (CBAM_VNFD_ID)", e.getCause()); + assertEquals("Unable to find the TOSCA-Metadata/TOSCA.meta in archive found: []", e.getCause().getMessage()); + } + } + + /** + * if VNFD can not be extracted sensible error is returned + */ + @Test + public void testMissingVnfdCbamPackage() throws Exception { + Path csar = Files.createTempFile(UUID.randomUUID().toString(), "csar"); + Files.write(csar, TestUtil.loadFile("unittests/missing.vnfd.zip")); + when(cbamCatalogApi.content(CBAM_VNFD_ID)).thenReturn(csar.toFile()); + //when + try { + cbamCatalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID); + fail(); + } catch (RuntimeException e) { + verify(logger).error("Unable to get package with (" + CBAM_VNFD_ID + ")", e.getCause()); + assertTrue("Unable to find the vnfdloc/a.yaml in archive found: [TOSCA-Metadata/, TOSCA-Metadata/TOSCA.meta]".equals(e.getCause().getMessage()) + || "Unable to find the vnfdloc/a.yaml in archive found: [TOSCA-Metadata/TOSCA.meta, TOSCA-Metadata/]".equals(e.getCause().getMessage()) + ); + } + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamTokenProvider.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamTokenProvider.java new file mode 100644 index 00000000..670aa77f --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestCbamTokenProvider.java @@ -0,0 +1,438 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.common.io.ByteStreams; +import org.eclipse.jetty.server.NetworkTrafficServerConnector; +import org.eclipse.jetty.server.Server; +import org.eclipse.jetty.server.handler.AbstractHandler; +import org.eclipse.jetty.util.ssl.SslContextFactory; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VnfmInfoProvider; +import org.onap.vnfmdriver.model.VnfmInfo; +import org.springframework.http.HttpStatus; + +import javax.net.ssl.*; +import javax.servlet.ServletException; +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; +import java.io.IOException; +import java.net.URI; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.security.GeneralSecurityException; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.NoSuchProviderException; +import java.security.cert.CertificateException; +import java.security.spec.InvalidKeySpecException; +import java.util.ArrayList; +import java.util.Base64; +import java.util.List; + +import static junit.framework.TestCase.*; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +class HttpTestServer { + Server _server; + List<String> requests = new ArrayList<>(); + List<Integer> codes = new ArrayList<>(); + List<String> respones = new ArrayList<>(); + + public void start() throws Exception { + configureServer(); + startServer(); + } + + private void startServer() throws Exception { + requests.clear(); + codes.clear(); + _server.start(); + } + + protected void configureServer() throws Exception { + Path jksPath = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.jks").toURI()); + String path = jksPath.normalize().toAbsolutePath().toUri().toString(); + _server = new Server(); + SslContextFactory factory = new SslContextFactory(path); + factory.setKeyStorePassword("changeit"); + NetworkTrafficServerConnector connector = new NetworkTrafficServerConnector(_server, factory); + connector.setHost("127.0.0.1"); + _server.addConnector(connector); + _server.setHandler(new AbstractHandler() { + @Override + public void handle(String target, org.eclipse.jetty.server.Request request, HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws IOException, ServletException { + requests.add(new String(ByteStreams.toByteArray(request.getInputStream()))); + httpServletResponse.getWriter().write(respones.remove(0)); + httpServletResponse.setStatus(codes.remove(0)); + request.setHandled(true); + } + }); + } + + public void stop() throws Exception { + _server.stop(); + } +} + +public class TestCbamTokenProvider extends TestBase { + + private static String GOOD_RESPONSE = "{ \"access_token\" : \"myToken\", \"expires_in\" : 1000 }"; + @InjectMocks + private CbamTokenProvider cbamTokenProvider; + private VnfmInfo vnfmInfo = new VnfmInfo(); + private ArgumentCaptor<SSLSocketFactory> sslSocketFactory = ArgumentCaptor.forClass(SSLSocketFactory.class); + private ArgumentCaptor<HostnameVerifier> hostnameVerifier = ArgumentCaptor.forClass(HostnameVerifier.class); + private HttpTestServer testServer; + + @Before + public void initMocks() throws Exception { + setField(CbamTokenProvider.class, "logger", logger); + setField(cbamTokenProvider, "username", "myUserName"); + setField(cbamTokenProvider, "password", "myPassword"); + setField(cbamTokenProvider, "skipCertificateVerification", true); + setField(cbamTokenProvider, "skipHostnameVerification", true); + when(vnfmInfoProvider.getVnfmInfo(VNFM_ID)).thenReturn(vnfmInfo); + vnfmInfo.setPassword("vnfmPassword"); + vnfmInfo.setUserName("vnfmUserName"); + vnfmInfo.setUrl("http://127.0.0.3:12345"); + testServer = new HttpTestServer(); + testServer.start(); + URI uri = testServer._server.getURI(); + setField(cbamTokenProvider, "cbamKeyCloakBaseUrl", uri.toString()); + } + + private void addGoodTokenResponse() { + testServer.respones.add(GOOD_RESPONSE); + testServer.codes.add(HttpStatus.OK.value()); + } + + @After + public void testServer() throws Exception { + testServer.stop(); + } + + /** + * a new token is requested no token has been requested before + */ + @Test + public void testBasicTokenRequest() throws Exception { + //given + addGoodTokenResponse(); + //when + String token = cbamTokenProvider.getToken(VNFM_ID); + //verify + assertEquals(1, testServer.requests.size()); + assertTokenRequest(testServer.requests.get(0)); + assertEquals("myToken", token); + + } + + /** + * a new token is requested if the previous token has expired + */ + @Test + public void testTokenIsRequestedIfPreviousExpired() throws Exception { + //given + addGoodTokenResponse(); + String firstToken = cbamTokenProvider.getToken(VNFM_ID); + testServer.respones.add("{ \"access_token\" : \"myToken2\", \"expires_in\" : 2000 }"); + testServer.codes.add(HttpStatus.OK.value()); + when(systemFunctions.currentTimeMillis()).thenReturn(500L * 1000 + 1L); + //when + String token = cbamTokenProvider.getToken(VNFM_ID); + //verify + assertEquals(2, testServer.requests.size()); + assertTokenRequest(testServer.requests.get(0)); + assertTokenRequest(testServer.requests.get(1)); + assertEquals("myToken2", token); + } + + /** + * a new token is not requested if the previous token has not expired + */ + @Test + public void testTokenIsNotRequestedIfPreviousHasNotExpired() throws Exception { + //given + addGoodTokenResponse(); + String firstToken = cbamTokenProvider.getToken(VNFM_ID); + testServer.respones.add("{ \"access_token\" : \"myToken2\", \"expires_in\" : 2000 }"); + testServer.codes.add(HttpStatus.OK.value()); + when(systemFunctions.currentTimeMillis()).thenReturn(500L * 1000); + //when + String token = cbamTokenProvider.getToken(VNFM_ID); + //verify + assertEquals(1, testServer.requests.size()); + assertTokenRequest(testServer.requests.get(0)); + assertEquals("myToken", token); + } + + /** + * failed token requests are retried for a fixed number amount of times + */ + @Test + public void testRetry() throws Exception { + //given + addFailedResponse(); + addFailedResponse(); + addFailedResponse(); + addFailedResponse(); + addGoodTokenResponse(); + //cbamTokenProvider.failOnRequestNumber = 5; + //when + String token = cbamTokenProvider.getToken(VNFM_ID); + //verify + assertEquals(5, testServer.requests.size()); + assertTokenRequest(testServer.requests.get(0)); + assertTokenRequest(testServer.requests.get(1)); + assertTokenRequest(testServer.requests.get(2)); + assertTokenRequest(testServer.requests.get(3)); + assertTokenRequest(testServer.requests.get(4)); + verify(logger).warn(eq("Unable to get token to access CBAM API (1/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (2/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (3/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (4/5)"), Mockito.<RuntimeException>any()); + assertEquals("myToken", token); + } + + /** + * failed token requests are retried for a fixed number amount of times (reacing maximal number or retries) + */ + @Test + public void testNoMoreRetry() throws Exception { + //given + addFailedResponse(); + addFailedResponse(); + addFailedResponse(); + addFailedResponse(); + addFailedResponse(); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + fail(); + } catch (RuntimeException e) { + assertNotNull(e.getCause()); + } + //verify + assertEquals(5, testServer.requests.size()); + assertTokenRequest(testServer.requests.get(0)); + assertTokenRequest(testServer.requests.get(1)); + assertTokenRequest(testServer.requests.get(2)); + assertTokenRequest(testServer.requests.get(3)); + assertTokenRequest(testServer.requests.get(4)); + verify(logger).warn(eq("Unable to get token to access CBAM API (1/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (2/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (3/5)"), Mockito.<RuntimeException>any()); + verify(logger).warn(eq("Unable to get token to access CBAM API (4/5)"), Mockito.<RuntimeException>any()); + verify(logger).error(eq("Unable to get token to access CBAM API (giving up retries)"), Mockito.<RuntimeException>any()); + } + + private void addFailedResponse() { + testServer.codes.add(HttpStatus.UNAUTHORIZED.value()); + testServer.respones.add(new String()); + } + + /** + * the SSL connection is established without certificate & hostname verification + */ + @Test + public void noSslVerification() throws Exception { + //given + //the default settings is no SSL & hostname check + addGoodTokenResponse(); + //when + cbamTokenProvider.getToken(VNFM_ID); + //verify + //no exception is thrown + } + + /** + * if SSL is verified the certificates must be defined + */ + @Test + public void testInvalidCombinationOfSettings() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + //verify + fail(); + } catch (RuntimeException e) { + assertEquals("If the skipCertificateVerification is set to false (default) the trustedCertificates can not be empty", e.getMessage()); + } + } + + /** + * if SSL is verified the certificates must be defined + */ + @Test + public void testInvalidCombinationOfSettings2() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + setField(cbamTokenProvider, "trustedCertificates", "xx\nxx"); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + //verify + fail(); + } catch (RuntimeException e) { + assertEquals("The trustedCertificates must be a base64 encoded collection of PEM certificates", e.getMessage()); + assertNotNull(e.getCause()); + } + } + + /** + * the SSL connection is established without certificate & hostname verification + */ + @Test + public void testNotTrustedSslConnection() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/sample.cert.pem").toURI()); + setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem))); + addGoodTokenResponse(); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + //verify + fail(); + } catch (RuntimeException e) { + assertTrue(e.getMessage().contains("unable to find valid certification path")); + assertTrue(e.getCause() instanceof SSLHandshakeException); + } + } + + /** + * the SSL connection is established with certificate & hostname verification + */ + @Test + public void testHostnameVerificationSucceeds() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI()); + setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem))); + setField(cbamTokenProvider, "cbamKeyCloakBaseUrl", testServer._server.getURI().toString().replace("127.0.0.1", "localhost")); + setField(cbamTokenProvider, "skipHostnameVerification", false); + addGoodTokenResponse(); + //when + cbamTokenProvider.getToken(VNFM_ID); + //verify + //no seception is thrown + } + + /** + * the SSL connection is dropped with certificate & hostname verification due to invalid hostname + */ + @Test + public void testHostnameverifcationfail() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + Path caPem = Paths.get(TestCbamTokenProvider.class.getResource("/unittests/localhost.cert.pem").toURI()); + setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString(Files.readAllBytes(caPem))); + setField(cbamTokenProvider, "skipHostnameVerification", false); + addGoodTokenResponse(); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + //verify + fail(); + } catch (RuntimeException e) { + assertTrue(e.getMessage().contains("Hostname 127.0.0.1 not verified")); + assertTrue(e.getCause() instanceof SSLPeerUnverifiedException); + } + } + + /** + * invalid certificate content + */ + @Test + public void testInvalidCerificateContent() throws Exception { + //given + setField(cbamTokenProvider, "skipCertificateVerification", false); + setField(cbamTokenProvider, "trustedCertificates", Base64.getEncoder().encodeToString("-----BEGIN CERTIFICATE-----\nkuku\n-----END CERTIFICATE-----\n".getBytes())); + setField(cbamTokenProvider, "skipHostnameVerification", false); + addGoodTokenResponse(); + //when + try { + cbamTokenProvider.getToken(VNFM_ID); + //verify + fail(); + } catch (RuntimeException e) { + assertTrue(e.getMessage().contains("Unable to load certificates")); + assertTrue(e.getCause() instanceof GeneralSecurityException); + } + } + + /** + * Verify client certificates are not verified + * \ + */ + @Test + public void testClientCertificates() throws Exception { + //when + new CbamTokenProvider.AllTrustedTrustManager().checkClientTrusted(null, null); + //verify + //no security exception is thrown + } + + /** + * Exception during keystore creation is logged (semi-useless) + */ + @Test + public void testKeystoreCreationFailure() { + KeyStoreException expectedException = new KeyStoreException(); + class X extends CbamTokenProvider { + X(VnfmInfoProvider vnfmInfoProvider) { + super(vnfmInfoProvider); + } + + @Override + TrustManager[] buildTrustManager() throws KeyStoreException, NoSuchProviderException, NoSuchAlgorithmException, InvalidKeySpecException, CertificateException { + throw expectedException; + } + } + try { + new X(null).buildSSLSocketFactory(); + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to create SSL socket factory", expectedException); + } + } + + private void assertTokenRequest(String body) { + assertContains(body, "grant_type", "password"); + assertContains(body, "client_id", "vnfmUserName"); + assertContains(body, "client_secret", "vnfmPassword"); + assertContains(body, "username", "myUserName"); + assertContains(body, "password", "myPassword"); + } + + private void assertContains(String content, String key, String value) { + assertTrue(content.contains(key + "=" + value)); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestDriverProperties.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestDriverProperties.java new file mode 100644 index 00000000..22db05b2 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestDriverProperties.java @@ -0,0 +1,35 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import org.junit.Test; + +import static pl.pojo.tester.api.assertion.Assertions.assertPojoMethodsFor; + + +public class TestDriverProperties { + + /** + * Test basic POJO behaviour + */ + @Test + public void test() { + + + assertPojoMethodsFor(DriverProperties.class).areWellImplemented(); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestJobManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestJobManager.java new file mode 100644 index 00000000..1ba58abe --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestJobManager.java @@ -0,0 +1,544 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.common.collect.Lists; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import com.nokia.cbam.lcm.v32.ApiException; +import com.nokia.cbam.lcm.v32.model.*; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.vnfmdriver.model.JobDetailInfo; +import org.onap.vnfmdriver.model.JobResponseInfo; +import org.onap.vnfmdriver.model.JobStatus; +import org.springframework.test.util.ReflectionTestUtils; +import org.threeten.bp.OffsetDateTime; + +import javax.servlet.http.HttpServletResponse; +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.UUID; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +import static junit.framework.TestCase.*; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.ILifecycleChangeNotificationManager.SEPARATOR; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager.extractOnapJobId; +import static org.onap.vnfmdriver.model.JobStatus.*; + +public class TestJobManager extends TestBase { + + @Mock + private HttpServletResponse httpResponse; + + @InjectMocks + private JobManager jobManager; + private List<VnfInfo> vnfs = new ArrayList<>(); + + @Before + public void initMocks() throws Exception { + ReflectionTestUtils.setField(JobManager.class, "logger", logger); + when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(vnfs); + when(selfRegistrationManager.isReady()).thenReturn(true); + } + + /** + * Only the _ can be used as separator + * . / % & handled specially in URLs + * - used in CBAM for separation + */ + @Test + public void testSeparator() { + assertEquals("_", SEPARATOR); + } + + /** + * The operation result must contain the ONAP job identifier under the jobId field + */ + @Test + public void testJobIdExtractionFromOperationResult() { + assertEquals("1234", extractOnapJobId(new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"1234\"}}"))); + try { + extractOnapJobId(new JsonParser().parse("{ }")); + fail(); + } catch (NoSuchElementException e) { + assertEquals("The operation result {} does not contain the mandatory additionalParams structure", e.getMessage()); + } + try { + extractOnapJobId(new JsonParser().parse("{ \"additionalParams\" : { } }")); + fail(); + } catch (NoSuchElementException e) { + assertEquals("The operation result {\"additionalParams\":{}} does not contain the mandatory jobId in the additionalParams structure", e.getMessage()); + } + } + + /** + * If the VNF does not exists but the job manager still runs the VNF manipulation process the job is reported to be running + */ + @Test + public void testJobForNonExistingVnfReportedRunningIfJobIsOngoing() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + //when + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, STARTED, "50", "Operation started"); + } + + /** + * If the VNF does not exists and the internal job is not running the job is reported to be finished + */ + @Test + public void testJobForExistingVnfReportedRunningIfJobIsFinished() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + jobManager.jobFinished(jobId); + //when + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, JobStatus.FINISHED, "100", "Operation finished"); + } + + /** + * Spawning jobs after preparing for shutdown results in error + */ + @Test + public void testNoMoreJobsAreAllowedAfterPrepareForShutdown() throws Exception { + jobManager.prepareForShutdown(); + //when + try { + jobManager.spawnJob(JOB_ID, httpResponse); + fail(); + } catch (Exception e) { + verify(logger).error("The service is preparing to shut down"); + } + } + + /** + * Verify if the jobId has valid format + */ + @Test + public void testJobIdValidation() throws Exception { + try { + //when + jobManager.getJob(VNFM_ID, "bad"); + //verify + fail(); + } catch (IllegalArgumentException e) { + assertEquals("The jobId should be in the <vnfId>_<UUID> format, but was bad", e.getMessage()); + } + try { + //when + jobManager.getJob(VNFM_ID, "vnfId_"); + //verify + fail(); + } catch (IllegalArgumentException e) { + assertEquals("The UUID in the jobId (vnfId_) can not be empty", e.getMessage()); + } + try { + //when + jobManager.getJob(VNFM_ID, "_UUID"); + //verify + fail(); + } catch (IllegalArgumentException e) { + assertEquals("The vnfId in the jobId (_UUID) can not be empty", e.getMessage()); + } + } + + /** + * If the VNF exists but no operation execution is present with given internalJobId, than the state of the + * job is ongoing if the internal job is ongoing + */ + @Test + public void testExistingVnfWithNotYetStartedOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, STARTED, "50", "Operation started"); + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * If the VNF exists but no operation execution is present with given internalJobId, than the state of the + * job is failed if the internal job is finished (the operation on CBAM was not able to start) + */ + @Test + public void testExistingVnfWithNotUnableToStartOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + jobManager.jobFinished(jobId); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, ERROR, "100", "Operation failed due to The requested operation was not able to start on CBAM"); + assertFalse(jobManager.hasOngoingJobs()); + } + + /** + * If the VNF exists but and the operation execution is present with given internalJobId, than the state of the + * job is ongoing if the operation is ongoing + */ + @Test + public void testExistingVnfWithStartedOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + operation.setStartTime(OffsetDateTime.now()); + operation.setStatus(OperationStatus.STARTED); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, STARTED, "50", "Operation started"); + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * If the VNF does not exists till the time the job queries the status of the operation + */ + @Test + public void testTerminatedVnf() throws Exception { + //ddd + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + List<Integer> vnfQueryCallCounter = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<VnfInfo>() { + @Override + public VnfInfo answer(InvocationOnMock invocation) throws Throwable { + vnfs.clear(); + return detailedVnf; + } + }); + + jobManager.jobFinished(jobId); + + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + operation.setStartTime(OffsetDateTime.now()); + operation.setStatus(OperationStatus.FINISHED); + operation.setOperationType(OperationType.TERMINATE); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams); + //when + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, FINISHED, "100", "Operation finished"); + } + + /** + * If the VNF exists but and the operation execution is present with given internalJobId, than the state of the + * job is error if the operation is failed + */ + @Test + public void testExistingVnfWithFailedOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + List<Integer> vnfCounter = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + operation.setStartTime(OffsetDateTime.now()); + operation.setStatus(OperationStatus.FAILED); + ProblemDetails errorDetails = new ProblemDetails(); + errorDetails.setTitle("Title"); + errorDetails.setDetail("detail"); + operation.setError(errorDetails); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams); + //when + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, ERROR, "100", "Operation failed due to Title: detail"); + assertTrue(jobManager.hasOngoingJobs()); + } + + private void assertResult(String jobId, JobDetailInfo job, JobStatus status, String progress, String descriptor) { + assertEquals(jobId, job.getJobId()); + assertEquals(status, job.getResponseDescriptor().getStatus()); + assertEquals(progress, job.getResponseDescriptor().getProgress()); + assertNull(job.getResponseDescriptor().getErrorCode()); + boolean finalState = JobStatus.ERROR.equals(status) || JobStatus.FINISHED.equals(status); + if (finalState) { + assertEquals(2, job.getResponseDescriptor().getResponseHistoryList().size()); + JobResponseInfo startEvent = job.getResponseDescriptor().getResponseHistoryList().get(0); + JobResponseInfo endEvent = job.getResponseDescriptor().getResponseHistoryList().get(1); + assertNull(startEvent.getErrorCode()); + assertEquals("50", startEvent.getProgress()); + assertEquals(JobStatus.STARTED.name(), startEvent.getStatus()); + assertEquals("1", startEvent.getResponseId()); + assertEquals("Operation started", startEvent.getStatusDescription()); + + assertNull(endEvent.getErrorCode()); + assertEquals("100", endEvent.getProgress()); + assertEquals(job.getResponseDescriptor().getStatus().name(), endEvent.getStatus()); + assertEquals("2", endEvent.getResponseId()); + assertEquals(descriptor, endEvent.getStatusDescription()); + } else { + assertEquals(1, job.getResponseDescriptor().getResponseHistoryList().size()); + assertNull(job.getResponseDescriptor().getResponseHistoryList().get(0).getErrorCode()); + assertEquals(progress, job.getResponseDescriptor().getResponseHistoryList().get(0).getProgress()); + assertEquals(job.getResponseDescriptor().getStatus().name(), job.getResponseDescriptor().getResponseHistoryList().get(0).getStatus()); + assertEquals("1", job.getResponseDescriptor().getResponseHistoryList().get(0).getResponseId()); + assertEquals(descriptor, job.getResponseDescriptor().getResponseHistoryList().get(0).getStatusDescription()); + } + assertEquals(Integer.toString(job.getResponseDescriptor().getResponseHistoryList().size()), job.getResponseDescriptor().getResponseId()); + assertEquals(descriptor, job.getResponseDescriptor().getStatusDescription()); + } + + /** + * If the VNF exists but and the operation execution is present with given internalJobId, than the state of the + * job is finished if the operation is finished, but is not a termination + */ + @Test + public void testExistingVnfWithFinishedOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + operation.setStartTime(OffsetDateTime.now()); + operation.setStatus(OperationStatus.FINISHED); + operation.setOperationType(OperationType.SCALE); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, JobStatus.FINISHED, "100", "Operation finished"); + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * If the VNF exists but and the operation execution is present with given internalJobId, than the state of the + * job is ongoing if the termination operation is finished. In ONAP terminology the termination includes + * delete, so the ONAP operation is ongoing since the VNF is not yet deleted + */ + @Test + public void testExistingVnfWithFinishedTerminationOperation() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + operation.setStartTime(OffsetDateTime.now()); + operation.setStatus(OperationStatus.FINISHED); + operation.setOperationType(OperationType.TERMINATE); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationParams); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, STARTED, "50", "Operation started"); + //when + jobManager.jobFinished(jobId); + job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertResult(jobId, job, ERROR, "100", "Operation failed due to unable to delete VNF"); + assertFalse(jobManager.hasOngoingJobs()); + + } + + /** + * Failuire to retrieve operation parameters (CBAM REST API fail) is logged and propagated + */ + @Test + public void failuresDuringOperationExecutionRetrievalIsLoggedAndPropagated() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution operation = new OperationExecution(); + operation.setId(UUID.randomUUID().toString()); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(operation); + ApiException expectedException = new ApiException(); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(operation.getId(), NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //verify + try { + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to retrieve operation parameters", expectedException); + } + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * Failure to retrieve VNF (CBAM REST API fail) is logged and propagated + */ + @Test + public void failuresDuringVnfRetrievalIsLoggedAndPropagated() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //verify + try { + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to retrieve VNF", expectedException); + } + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * When searching for the ONAP job by iterating the operation executions. The newest jobs + * are inspected first (performance optimalization) + */ + @Test + public void testNewestOperationAreInspectedFirst() throws Exception { + String jobId = jobManager.spawnJob(VNF_ID, httpResponse); + VnfInfo vnf = new VnfInfo(); + vnf.setId(VNF_ID); + vnfs.add(vnf); + VnfInfo detailedVnf = new VnfInfo(); + detailedVnf.setId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(detailedVnf); + OperationExecution olderOperation = new OperationExecution(); + olderOperation.setId(UUID.randomUUID().toString()); + olderOperation.setStartTime(OffsetDateTime.now()); + olderOperation.setStatus(OperationStatus.FINISHED); + olderOperation.setOperationType(OperationType.TERMINATE); + OperationExecution newerOperation = new OperationExecution(); + newerOperation.setId(UUID.randomUUID().toString()); + newerOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + newerOperation.setStatus(OperationStatus.FINISHED); + newerOperation.setOperationType(OperationType.TERMINATE); + detailedVnf.setOperationExecutions(new ArrayList<>()); + detailedVnf.getOperationExecutions().add(olderOperation); + detailedVnf.getOperationExecutions().add(newerOperation); + JsonElement operationParams = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + List<String> queriedOperaionsInOrder = new ArrayList<>(); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(Mockito.anyString(), Mockito.eq(NOKIA_LCM_API_VERSION))) + .then(new Answer<Object>() { + @Override + public Object answer(InvocationOnMock invocationOnMock) throws Throwable { + queriedOperaionsInOrder.add(invocationOnMock.getArguments()[0].toString()); + if (invocationOnMock.getArguments()[0].equals(olderOperation.getId())) { + return new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + jobId + "\"}}"); + } else { + return new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + "nonMatching" + "\"}}"); + } + } + }); + JobDetailInfo job = jobManager.getJob(VNFM_ID, jobId); + //verify + assertEquals(Lists.newArrayList(newerOperation.getId(), olderOperation.getId()), queriedOperaionsInOrder); + assertTrue(jobManager.hasOngoingJobs()); + } + + /** + * if the registration process has not finished it is prevented to spawn jobs + */ + @Test + public void noJobCanBeStartedIfRegistrationNotFinished() throws Exception { + //given + when(selfRegistrationManager.isReady()).thenReturn(false); + //when + try { + jobManager.spawnJob(VNF_ID, httpResponse); + fail(); + } catch (RuntimeException e) { + assertEquals("The service is not yet ready", e.getMessage()); + } + } + + /** + * Ongoing job are out waited during the the preparation for shutdown + */ + @Test + public void onGoingJobsAreOutwaitedDuringShutdown() throws Exception { + String firstJobId = jobManager.spawnJob(VNF_ID, httpResponse); + ExecutorService executorService = Executors.newCachedThreadPool(); + ArgumentCaptor<Integer> sleeps = ArgumentCaptor.forClass(Integer.class); + doNothing().when(systemFunctions).sleep(sleeps.capture()); + Future<?> shutDown = executorService.submit(new Runnable() { + @Override + public void run() { + jobManager.prepareForShutdown(); + } + }); + while (sleeps.getAllValues().size() == 0) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + } + } + assertFalse(shutDown.isDone()); + jobManager.jobFinished(firstJobId); + //verify + shutDown.get(); + verify(systemFunctions, times(sleeps.getAllValues().size())).sleep(500L); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java new file mode 100644 index 00000000..64adaab1 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestLifecycleManager.java @@ -0,0 +1,1336 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.nokia.cbam.catalog.v1.model.CatalogAdapterVnfpackage; +import com.nokia.cbam.lcm.v32.ApiException; +import com.nokia.cbam.lcm.v32.model.*; +import com.nokia.cbam.lcm.v32.model.OperationType; +import com.nokia.cbam.lcm.v32.model.VimInfo; +import com.nokia.cbam.lcm.v32.model.VnfInfo; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InOrder; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.VimInfoProvider; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.TestVfcGrantManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.vfc.VfcGrantManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.StoreLoader; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification.LifecycleChangeNotificationManager; +import org.onap.vnfmdriver.model.ExtVirtualLinkInfo; +import org.onap.vnfmdriver.model.*; +import org.onap.vnfmdriver.model.ScaleDirection; +import org.threeten.bp.OffsetDateTime; + +import javax.servlet.http.HttpServletResponse; +import java.nio.file.Paths; +import java.util.*; + +import static java.lang.Boolean.parseBoolean; +import static java.nio.file.Files.readAllBytes; +import static junit.framework.TestCase.*; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions.systemFunctions; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestLifecycleManager extends TestBase { + public static final String JOB_ID = "myJobId"; + public static final String CBAM_VNFD_ID = "cbamVnfdId"; + public static final String TENANT = "myTenant"; + public static final String OPERATION_EXECUTION_ID = "operationExecutionId"; + private static final String ONAP_CSAR_ID = "myOnapCsarId"; + private static final String VIM_ID = "ownerId_regionId"; + private GrantVNFResponseVim vim = new GrantVNFResponseVim(); + @Mock + private CatalogManager catalogManager; + @Mock + private VfcGrantManager vfcGrantManager; + @Mock + private CbamTokenProvider tokenProvider; + @Mock + private JobManager jobManager; + @Mock + private LifecycleChangeNotificationManager notificationManager; + @Mock + private HttpServletResponse restResponse; + @Mock + private VimInfoProvider vimInfoProvider; + + private ArgumentCaptor<CreateVnfRequest> createRequest = ArgumentCaptor.forClass(CreateVnfRequest.class); + private AdditionalParams additionalParam = new AdditionalParams(); + private String INSTANTIATION_LEVEL = "level1"; + private GrantVNFResponseVim grantResponse = new GrantVNFResponseVim(); + private String cbamVnfdContent; + private OperationExecution instantiationOperationExecution = new OperationExecution(); + private OperationExecution modifyPropertyoperationExecution = new OperationExecution(); + private OperationExecution scaleOperationExecution = new OperationExecution(); + private OperationExecution healOperationExecution = new OperationExecution(); + + private VnfInfo vnfInfo = new VnfInfo(); + private List<OperationExecution> operationExecutions = new ArrayList<>(); + private org.onap.vnfmdriver.model.VimInfo vimInfo = new org.onap.vnfmdriver.model.VimInfo(); + private ExtVirtualLinkInfo externalVirtualLink = new ExtVirtualLinkInfo(); + private ExtManagedVirtualLinkData extManVl = new ExtManagedVirtualLinkData(); + private ArgumentCaptor<ModifyVnfInfoRequest> actualVnfModifyRequest = ArgumentCaptor.forClass(ModifyVnfInfoRequest.class); + private Set<Boolean> finished = new HashSet<>(); + private ArgumentCaptor<ScaleVnfRequest> actualScaleRequest = ArgumentCaptor.forClass(ScaleVnfRequest.class); + private ArgumentCaptor<HealVnfRequest> actualHealRequest = ArgumentCaptor.forClass(HealVnfRequest.class); + + private LifecycleManager lifecycleManager; + + @Before + public void initMocks() throws Exception { + vnfInfo.setExtensions(new ArrayList<>()); + vnfInfo.setOperationExecutions(new ArrayList<>()); + lifecycleManager = new LifecycleManager(catalogManager, vfcGrantManager, cbamRestApiProvider, vimInfoProvider, jobManager, notificationManager); + cbamVnfdContent = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/vnfd.full.yaml").toURI()))); + setField(LifecycleManager.class, "logger", logger); + CatalogAdapterVnfpackage cbamPackage = new CatalogAdapterVnfpackage(); + when(catalogManager.preparePackageInCbam(VNFM_ID, ONAP_CSAR_ID)).thenReturn(cbamPackage); + cbamPackage.setVnfdId(CBAM_VNFD_ID); + vnfInfo.setVnfdId(CBAM_VNFD_ID); + vnfInfo.setId(VNF_ID); + when(jobManager.spawnJob(VNF_ID, restResponse)).thenReturn(JOB_ID); + when(catalogManager.getCbamVnfdContent(VNFM_ID, CBAM_VNFD_ID)).thenReturn(cbamVnfdContent); + cbamPackage.setId(CBAM_VNFD_ID); + vimInfo.setUrl("cloudUrl"); + vimInfo.setPassword("vimPassword"); + vimInfo.setUserName("vimUsername"); + vimInfo.setSslInsecure("true"); + vimInfo.setVimId(VIM_ID); + vimInfo.setName("vimName"); + when(vimInfoProvider.getVimInfo((VIM_ID))).thenReturn(vimInfo); + instantiationOperationExecution.setId(OPERATION_EXECUTION_ID); + instantiationOperationExecution.setOperationType(OperationType.INSTANTIATE); + instantiationOperationExecution.setStartTime(OffsetDateTime.now()); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions); + operationExecutions.add(modifyPropertyoperationExecution); + modifyPropertyoperationExecution.setStartTime(OffsetDateTime.now()); + modifyPropertyoperationExecution.setOperationType(OperationType.MODIFY_INFO); + operationExecutions.add(instantiationOperationExecution); + instantiationOperationExecution.setStatus(OperationStatus.FINISHED); + modifyPropertyoperationExecution.setStatus(OperationStatus.FINISHED); + modifyPropertyoperationExecution.setId(UUID.randomUUID().toString()); + scaleOperationExecution.setId(UUID.randomUUID().toString()); + healOperationExecution.setId(UUID.randomUUID().toString()); + when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(modifyPropertyoperationExecution); + doAnswer(new Answer() { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + finished.add(Boolean.TRUE); + return null; + } + }).when(jobManager).jobFinished(JOB_ID); + when(vnfApi.vnfsVnfInstanceIdScalePost(eq(VNF_ID), actualScaleRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + operationExecutions.add(scaleOperationExecution); + return scaleOperationExecution; + } + }); + when(vnfApi.vnfsVnfInstanceIdHealPost(eq(VNF_ID), actualHealRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + operationExecutions.add(healOperationExecution); + return healOperationExecution; + } + }); + } + + /** + * test instantiation + */ + @Test + public void testInstantiation() throws Exception { + //given + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + //verify + assertEquals(VNF_ID, response.getVnfInstanceId()); + assertEquals(JOB_ID, response.getJobId()); + assertEquals(createRequest.getAllValues().size(), 1); + assertEquals("myDescription", createRequest.getValue().getDescription()); + assertEquals("vnfName", createRequest.getValue().getName()); + assertEquals(CBAM_VNFD_ID, createRequest.getValue().getVnfdId()); + assertEquals(1, actualInstantiationRequest.getAllValues().size()); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(VIM_ID, actualVim.getId()); + assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO, actualVim.getVimInfoType()); + assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint()); + //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates()); + assertEquals("vimPassword", actualVim.getAccessInfo().getPassword()); + assertEquals("regionId", actualVim.getAccessInfo().getRegion()); + assertEquals("myTenant", actualVim.getAccessInfo().getTenant()); + assertEquals("vimUsername", actualVim.getAccessInfo().getUsername()); + assertEquals(1, actualInstantiationRequest.getValue().getComputeResourceFlavours().size()); + assertEquals("flavourProviderId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getResourceId()); + assertEquals(VIM_ID, actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVimId()); + assertEquals("virtualComputeDescId", actualInstantiationRequest.getValue().getComputeResourceFlavours().get(0).getVnfdVirtualComputeDescId()); + assertEquals(1, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().size()); + assertEquals(extManVl, actualInstantiationRequest.getValue().getExtManagedVirtualLinks().get(0)); + assertEquals(2, actualInstantiationRequest.getValue().getExtVirtualLinks().size()); + + assertEquals("myNetworkProviderId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getResourceId()); + assertEquals("myEVlId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtVirtualLinkId()); + assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().size()); + assertEquals("myCpdId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(0).getExtCps().get(0).getCpdId()); + + assertEquals(VIM_ID, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getVimId()); + assertEquals("evlId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtVirtualLinkId()); + assertEquals("networkProviderId1", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getResourceId()); + assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().size()); + + + assertEquals(Integer.valueOf(2), actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getNumDynamicAddresses()); + assertEquals("cpdId3", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getCpdId()); + assertEquals(1, actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().size()); + assertEquals("1.2.3.4", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getIp()); + assertEquals("mac", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getMac()); + assertEquals("subnetId", actualInstantiationRequest.getValue().getExtVirtualLinks().get(1).getExtCps().get(0).getAddresses().get(0).getSubnetId()); + + assertEquals("myFlavorId", actualInstantiationRequest.getValue().getFlavourId()); + assertEquals(Boolean.TRUE, actualInstantiationRequest.getValue().isGrantlessMode()); + assertEquals("level1", actualInstantiationRequest.getValue().getInstantiationLevelId()); + assertEquals(1, actualInstantiationRequest.getValue().getZones().size()); + assertEquals(VIM_ID, actualInstantiationRequest.getValue().getZones().get(0).getVimId()); + assertEquals("zoneProviderId", actualInstantiationRequest.getValue().getZones().get(0).getResourceId()); + assertEquals("zoneId", actualInstantiationRequest.getValue().getZones().get(0).getId()); + assertEquals(1, actualInstantiationRequest.getValue().getSoftwareImages().size()); + assertEquals(VIM_ID, actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVimId()); + assertEquals("imageProviderId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getResourceId()); + assertEquals("imageId", actualInstantiationRequest.getValue().getSoftwareImages().get(0).getVnfdSoftwareImageId()); + String actualEmbeddedAdditionParams = new Gson().toJson(actualInstantiationRequest.getValue().getAdditionalParams()); + assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(actualEmbeddedAdditionParams) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(actualEmbeddedAdditionParams)); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + + assertEquals(1, actualVnfModifyRequest.getAllValues().size()); + assertEquals(2, actualVnfModifyRequest.getValue().getExtensions().size()); + assertEquals(LifecycleManager.ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getName()); + assertEquals(ONAP_CSAR_ID, actualVnfModifyRequest.getValue().getExtensions().get(0).getValue()); + assertEquals(ILifecycleChangeNotificationManager.EXTERNAL_VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getName()); + assertEquals(VNFM_ID, actualVnfModifyRequest.getValue().getExtensions().get(1).getValue()); + + //the 3.2 API does not accept empty array + assertNull(actualVnfModifyRequest.getValue().getVnfConfigurableProperties()); + verify(jobManager).spawnJob(VNF_ID, restResponse); + } + + /** + * invalid VIM type results in failure + */ + @Test + public void testInstantiationWithInvalidVimType() throws Exception { + //given + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + //when + try { + lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verify + fail(); + } catch (Exception e) { + assertEquals("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types", e.getMessage()); + } + verify(vnfApi, never()).vnfsPost(Mockito.any(), Mockito.any()); + verify(logger).error("Only OPENSTACK_V2_INFO, OPENSTACK_V3_INFO and VMWARE_VCLOUD_INFO is the supported VIM types"); + } + + /** + * test instantiation with KeyStone V2 based with SSL + */ + @Test + public void testInstantiationV2WithSsl() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI()))); + vimInfo.setSslInsecure("false"); + vimInfo.setSslCacert(caCert); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + //verify + OPENSTACKV2INFO actualVim = (OPENSTACKV2INFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0))); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + } + + /** + * test instantiation with KeyStone V3 based + */ + @Test + public void testInstantiationV3() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + //verify + OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(VIM_ID, actualVim.getId()); + assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType()); + assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint()); + //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates()); + assertEquals("vimPassword", actualVim.getAccessInfo().getPassword()); + assertEquals("regionId", actualVim.getAccessInfo().getRegion()); + assertEquals("myTenant", actualVim.getAccessInfo().getProject()); + assertEquals("myDomain", actualVim.getAccessInfo().getDomain()); + assertEquals("vimUsername", actualVim.getAccessInfo().getUsername()); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + } + + /** + * test instantiation with KeyStone V3 based with SSL + */ + @Test + public void testInstantiationV3WithSsl() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI()))); + vimInfo.setSslInsecure("false"); + vimInfo.setSslCacert(caCert); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + //verify + OPENSTACKV3INFO actualVim = (OPENSTACKV3INFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(VIM_ID, actualVim.getId()); + assertEquals(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO, actualVim.getVimInfoType()); + assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint()); + //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates()); + assertEquals("vimPassword", actualVim.getAccessInfo().getPassword()); + assertEquals("regionId", actualVim.getAccessInfo().getRegion()); + assertEquals("myTenant", actualVim.getAccessInfo().getProject()); + assertEquals("myDomain", actualVim.getAccessInfo().getDomain()); + assertEquals("vimUsername", actualVim.getAccessInfo().getUsername()); + assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0))); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + } + + /** + * test instantiation with vcloud + */ + @Test + public void testInstantiationVcloud() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + //verify + VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(VIM_ID, actualVim.getId()); + assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType()); + assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint()); + //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates()); + assertEquals("vimPassword", actualVim.getAccessInfo().getPassword()); + assertEquals("regionId", actualVim.getAccessInfo().getOrganization()); + assertEquals("vimUsername", actualVim.getAccessInfo().getUsername()); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + } + + /** + * test instantiation with vCloud with SSL + */ + @Test + public void testInstantiationVcloudWithSsl() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI()))); + vimInfo.setSslInsecure("false"); + vimInfo.setSslCacert(caCert); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualInstantiationRequest.getValue().getVims().size()); + //verify + VMWAREVCLOUDINFO actualVim = (VMWAREVCLOUDINFO) actualInstantiationRequest.getValue().getVims().get(0); + assertEquals(VIM_ID, actualVim.getId()); + assertEquals(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO, actualVim.getVimInfoType()); + assertEquals(Boolean.valueOf(parseBoolean(vimInfo.getSslInsecure())), actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertEquals("cloudUrl", actualVim.getInterfaceInfo().getEndpoint()); + //FIXME assertEquals();actualVim.getInterfaceInfo().getTrustedCertificates()); + assertEquals("vimPassword", actualVim.getAccessInfo().getPassword()); + assertEquals("regionId", actualVim.getAccessInfo().getOrganization()); + assertEquals("vimUsername", actualVim.getAccessInfo().getUsername()); + assertEquals(StoreLoader.getCertifacates(caCert).iterator().next(), new String(actualVim.getInterfaceInfo().getTrustedCertificates().get(0))); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateVerification()); + assertTrue(!actualVim.getInterfaceInfo().isSkipCertificateHostnameCheck()); + } + + /** + * test failure in the instantiation request marks the job to be finished in job manager + */ + @Test + public void testFailureInTheInstantiationRequest() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException); + + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verfiy + waitForJobToFinishInJobManager(finished); + assertEquals(VNF_ID, response.getVnfInstanceId()); + assertEquals(JOB_ID, response.getJobId()); + verify(logger).error("Unable to instantiate VNF with myVnfId identifier", expectedException); + } + + /** + * instantiation fails if VF-C does not send vim identifier in grant response + */ + @Test + public void testVfcFailsToSendVimId() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + //grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + String caCert = new String(readAllBytes(Paths.get(TestVfcGrantManager.class.getResource("/unittests/localhost.cert.pem").toURI()))); + vimInfo.setSslInsecure("false"); + vimInfo.setSslCacert(caCert); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + waitForJobToFinishInJobManager(finished); + assertEquals(0, actualInstantiationRequest.getAllValues().size()); + //verify + verify(logger).error("VF-C did not send VIM identifier in grant response"); + + } + + /** + * test operation execution polling is retried in case of failures + */ + @Test + public void testFailureInTheOperationExecutionPollingDuringInstantiationRequest() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + additionalParam.setInstantiationLevel(INSTANTIATION_LEVEL); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + ArgumentCaptor<InstantiateVnfRequest> actualInstantiationRequest = ArgumentCaptor.forClass(InstantiateVnfRequest.class); + ApiException expectedException = new ApiException(); + List<ApiException> polling = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdInstantiatePost(eq(VNF_ID), actualInstantiationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(instantiationOperationExecution); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).then(new Answer<List<OperationExecution>>() { + @Override + public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable { + if (polling.size() > 2) { + return operationExecutions; + } + ApiException apiException = new ApiException(); + polling.add(apiException); + throw apiException; + } + }); + //when + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verfiy + waitForJobToFinishInJobManager(finished); + assertEquals(VNF_ID, response.getVnfInstanceId()); + assertEquals(JOB_ID, response.getJobId()); + assertEquals(3, polling.size()); + for (ApiException e : polling) { + verify(logger).warn("Unable to retrieve operations details", e); + } + verify(systemFunctions, Mockito.times(3)).sleep(5000); + } + + /** + * failure in VNF creation is logged an proagated + */ + @Test + public void failureInVnfCreationIsPropagated() throws Exception { + //given + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException); + //when + try { + lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verify + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to create the VNF", expectedException); + } + } + + /** + * failure in updating the modifyable attributes of the VNF is logged an proagated + */ + @Test + public void failureInVnfModificationIsPropagated() throws Exception { + //given + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + when(vnfApi.vnfsVnfInstanceIdPatch(eq(VNF_ID), actualVnfModifyRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenThrow(expectedException); + + //when + try { + lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verify + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause().getCause()); + verify(logger).error("Unable to set the onapCsarId property on the VNF", expectedException); + } + } + + /** + * if the VIM info can not be queried the VNF is not instantiated and + * error propagated through job + */ + @Test + public void testFailureInQueryVimInfo() throws Exception { + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + when(vnfApi.vnfsPost(createRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenReturn(vnfInfo); + when(vfcGrantManager.requestGrantForInstantiate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, INSTANTIATION_LEVEL, cbamVnfdContent, JOB_ID)).thenReturn(grantResponse); + grantResponse.setVimId(VIM_ID); + GrantVNFResponseVimAccessInfo accessInfo = new GrantVNFResponseVimAccessInfo(); + accessInfo.setTenant(TENANT); + grantResponse.setAccessInfo(accessInfo); + + when(vimInfoProvider.getVimInfo(VIM_ID)).thenThrow(new RuntimeException()); + //when + lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + verify(vnfApi, never()).vnfsVnfInstanceIdInstantiatePost(Mockito.any(), Mockito.any(), Mockito.any()); + } + + /** + * test termination basic success scenario + * - the VNF is not deleted before the notifications are processed + */ + @Test + public void testTermination() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + OperationExecution terminationOperation = new OperationExecution(); + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.FINISHED); + return terminationOperation; + } + }); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualTerminationRequest.getAllValues().size()); + assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType()); + InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi); + notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID); + notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId"); + notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + verify(jobManager).spawnJob(VNF_ID, restResponse); + } + + /** + * test termination of a non instantiated VNF + * - the VNF is not terminated (only deleted) + */ + @Test + public void testTerminationOfNonInstantiated() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + vnfInfo.setInstantiationState(InstantiationState.NOT_INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + boolean deleted = false; + while (!deleted) { + try { + Mockito. + verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + deleted = true; + } catch (Error e) { + } + } + verify(vfcGrantManager, never()).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID); + verify(notificationManager, never()).waitForTerminationToBeProcessed("terminationId"); + } + + /** + * test that the VNF deletion is not started before the termination finishes + */ + @Test + public void testTerminationOperationIsOutwaited() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + OperationExecution terminationOperation = new OperationExecution(); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.STARTED); + return terminationOperation; + } + }); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + Set<Integer> calls = new HashSet<>(); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() { + @Override + public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable { + if (calls.size() == 1000) { + terminationOperation.setStatus(OperationStatus.FINISHED); + } + calls.add(calls.size()); + return operationExecutions; + } + }); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + verify(vnfApi, times(1001)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION); + verify(systemFunctions, times(1000)).sleep(5000); + } + + + /** + * test that failured during waiting for the operation to finish is tolerated (idefineiatelly) + */ + @Test + public void testTerminationOperationIsOutwaitedWithErrors() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + OperationExecution terminationOperation = new OperationExecution(); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.STARTED); + return terminationOperation; + } + }); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + Set<Integer> calls = new HashSet<>(); + List<ApiException> expectedExceptions = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() { + @Override + public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable { + if (calls.size() >= 100) { + terminationOperation.setStatus(OperationStatus.FINISHED); + return operationExecutions; + } + calls.add(calls.size()); + ApiException apiException = new ApiException(); + expectedExceptions.add(apiException); + throw apiException; + } + }); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + verify(vnfApi, times(101)).vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION); + verify(systemFunctions, times(100)).sleep(5000); + for (ApiException expectedException : expectedExceptions) { + verify(logger).warn("Unable to retrieve operations details", expectedException); + } + } + + /** + * test gracefull termination + */ + @Test + public void testGracefullTermination() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + terminationRequest.setTerminationType(VnfTerminationType.GRACEFUL); + terminationRequest.setGracefulTerminationTimeout("1234"); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + OperationExecution terminationOperation = new OperationExecution(); + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.FINISHED); + return terminationOperation; + } + }); + doAnswer(invocation -> { + verify(jobManager, Mockito.never()).jobFinished(JOB_ID); + return null; + }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualTerminationRequest.getAllValues().size()); + assertEquals(TerminationType.GRACEFUL, actualTerminationRequest.getValue().getTerminationType()); + assertEquals(Integer.valueOf(1234), actualTerminationRequest.getValue().getGracefulTerminationTimeout()); + InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi); + notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID); + notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId"); + notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + } + + /** + * instantiation with missing ONAP csarId to instantiation extra param result in failure + */ + @Test + public void testMissingVnfParameters() throws Exception { + //given + VnfInstantiateRequest instantiationRequest = prepareInstantiationRequest(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "invalid" + "\" : {}}}, \"vimId\" : \"" + VIM_ID + "\"}"; + instantiationRequest.setAdditionalParam(new JsonParser().parse(src)); + //when + try { + VnfInstantiateResponse response = lifecycleManager.instantiate(VNFM_ID, instantiationRequest, restResponse); + fail(); + } catch (Exception e) { + assertEquals("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id", e.getMessage()); + verify(logger).error("The additional parameter section does not contain setting for VNF with myOnapCsarId CSAR id"); + } + } + + /** + * test explicit forceful termination + */ + @Test + public void testExplicitForcefulTermination() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL); + terminationRequest.setGracefulTerminationTimeout("1234"); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + OperationExecution terminationOperation = new OperationExecution(); + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.FINISHED); + return terminationOperation; + } + }); + doAnswer(invocation -> { + verify(jobManager, Mockito.never()).jobFinished(JOB_ID); + return null; + }).when(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualTerminationRequest.getAllValues().size()); + assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType()); + assertNull(actualTerminationRequest.getValue().getGracefulTerminationTimeout()); + InOrder notificationIsProcessedBeforeDeletingTheVnf = Mockito.inOrder(vfcGrantManager, notificationManager, vnfApi); + notificationIsProcessedBeforeDeletingTheVnf.verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID); + notificationIsProcessedBeforeDeletingTheVnf.verify(notificationManager).waitForTerminationToBeProcessed("terminationId"); + notificationIsProcessedBeforeDeletingTheVnf.verify(vnfApi).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + } + + /** + * test failure in the termination workflow finishes the job + */ + @Test + public void testFailureInTheTerminationFinishesTheManagedJob() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + terminationRequest.setTerminationType(VnfTerminationType.FORCEFUL); + terminationRequest.setGracefulTerminationTimeout("1234"); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + OperationExecution terminationOperation = new OperationExecution(); + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.FINISHED); + return terminationOperation; + } + }); + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(0, actualTerminationRequest.getAllValues().size()); + Mockito.verifyZeroInteractions(vfcGrantManager); + } + + /** + * if termination fails the VNF is not deleted + */ + @Test + public void testFailedTerminationAbortsTerminationWorkflow() throws Exception { + //given + VnfTerminateRequest terminationRequest = new VnfTerminateRequest(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + vnfInfo.setInstantiationState(InstantiationState.INSTANTIATED); + vnfInfo.setOperationExecutions(operationExecutions); + VnfProperty vnfdId = new VnfProperty(); + vnfdId.setName(LifecycleManager.ONAP_CSAR_ID); + vnfdId.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(vnfdId); + ArgumentCaptor<TerminateVnfRequest> actualTerminationRequest = ArgumentCaptor.forClass(TerminateVnfRequest.class); + when(vnfApi.vnfsVnfInstanceIdTerminatePost(eq(VNF_ID), actualTerminationRequest.capture(), eq(NOKIA_LCM_API_VERSION))).thenAnswer(new Answer<OperationExecution>() { + @Override + public OperationExecution answer(InvocationOnMock invocation) throws Throwable { + OperationExecution terminationOperation = new OperationExecution(); + terminationOperation.setId("terminationId"); + operationExecutions.add(terminationOperation); + terminationOperation.setStatus(OperationStatus.FAILED); + return terminationOperation; + } + }); + JsonElement instantiationParameters = new JsonParser().parse("{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] } "); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet("operationExecutionId", NOKIA_LCM_API_VERSION)).thenReturn(instantiationParameters); + //when + JobInfo jobInfo = lifecycleManager.terminateVnf(VNFM_ID, VNF_ID, terminationRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualTerminationRequest.getAllValues().size()); + assertEquals(TerminationType.FORCEFUL, actualTerminationRequest.getValue().getTerminationType()); + verify(vfcGrantManager).requestGrantForTerminate(VNFM_ID, VNF_ID, VIM_ID, ONAP_CSAR_ID, vnfInfo, JOB_ID); + verify(vnfApi, never()).vnfsVnfInstanceIdDelete(VNF_ID, NOKIA_LCM_API_VERSION); + verify(logger).error("Unable to terminate VNF the operation did not finish with success"); + } + + /** + * test VNF query basic success scenario + */ + @Test + public void testQuery() throws Exception { + vnfInfo.setDescription("myDescription"); + vnfInfo.setName("myName"); + vnfInfo.setVnfSoftwareVersion("vnfSoftwareVersion"); + vnfInfo.setVnfProvider("myProvider"); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + prop.setValue(ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + //when + org.onap.vnfmdriver.model.VnfInfo vnf = lifecycleManager.queryVnf(VNFM_ID, VNF_ID); + //verify + assertEquals(VNF_ID, vnf.getVnfInstanceId()); + //FIXME ? (do not know what exactly the vnf version mean in core terminology) + assertEquals("vnfSoftwareVersion", vnf.getVersion()); + assertEquals(ONAP_CSAR_ID, vnf.getVnfdId()); + assertEquals("myDescription", vnf.getVnfInstanceDescription()); + assertEquals("myName", vnf.getVnfInstanceName()); + assertEquals(ONAP_CSAR_ID, vnf.getVnfPackageId()); + assertEquals("myProvider", vnf.getVnfProvider()); + //FIXME (in swagger schema ) + assertEquals("ACTIVE", vnf.getVnfStatus()); + assertEquals("Kuku", vnf.getVnfType()); + } + + /** + * error is propagated and logged if the queried VNF does not exist + */ + @Test + public void testQueryForNonExistingVnf() throws Exception { + + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + lifecycleManager.queryVnf(VNFM_ID, VNF_ID); + //verify + fail(); + } catch (Exception e) { + verify(logger).error("Unable to query VNF (myVnfId)", expectedException); + assertEquals(expectedException, e.getCause()); + } + } + + /** + * test scale basic scenario + */ + @Test + public void testScale() throws Exception { + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setNumberOfSteps("2"); + scaleRequest.setAspectId("myAspect"); + scaleRequest.setType(ScaleDirection.IN); + scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\", \"c\" : \"d\" }")); + scaleOperationExecution.setStatus(OperationStatus.FINISHED); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setValue(ONAP_CSAR_ID); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + vnfInfo.getOperationExecutions().add(instantiationOperationExecution); + String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }"; + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams)); + //when + JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualScaleRequest.getAllValues().size()); + ScaleVnfRequest sRequest = actualScaleRequest.getValue(); + InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi); + workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID)); + workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION); + assertEquals("myAspect", sRequest.getAspectId()); + assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.IN, sRequest.getType()); + assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps()); + assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams()))); + verify(jobManager).spawnJob(VNF_ID, restResponse); + } + + /** + * test scale out basic scenario + */ + @Test + public void testScaleOut() throws Exception { + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setNumberOfSteps("2"); + scaleRequest.setAspectId("myAspect"); + scaleRequest.setType(ScaleDirection.OUT); + scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }")); + scaleOperationExecution.setStatus(OperationStatus.FINISHED); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setValue(ONAP_CSAR_ID); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + vnfInfo.getOperationExecutions().add(instantiationOperationExecution); + String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }"; + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams)); + //when + JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualScaleRequest.getAllValues().size()); + ScaleVnfRequest sRequest = actualScaleRequest.getValue(); + InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi); + workflowOrder.verify(vfcGrantManager).requestGrantForScale(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(scaleRequest), eq(JOB_ID)); + workflowOrder.verify(vnfApi).vnfsVnfInstanceIdScalePost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION); + assertEquals("myAspect", sRequest.getAspectId()); + assertEquals(com.nokia.cbam.lcm.v32.model.ScaleDirection.OUT, sRequest.getType()); + assertEquals(Integer.valueOf(2), sRequest.getNumberOfSteps()); + assertTrue("{\"jobId\":\"myJobId\",\"a\":\"b\"}".equals(new Gson().toJson(sRequest.getAdditionalParams())) || "{\"a\":\"b\",\"jobId\":\"myJobId\"}".equals(new Gson().toJson(sRequest.getAdditionalParams()))); + } + + /** + * test scale operation is out waited + */ + @Test + public void testScaleOutwait() throws Exception { + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setNumberOfSteps("2"); + scaleRequest.setAspectId("myAspect"); + scaleRequest.setType(ScaleDirection.IN); + scaleRequest.setAdditionalParam(new JsonParser().parse("{ \"a\" : \"b\" }")); + scaleOperationExecution.setStatus(OperationStatus.STARTED); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setValue(ONAP_CSAR_ID); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + vnfInfo.getOperationExecutions().add(instantiationOperationExecution); + String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }"; + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams)); + List<ApiException> expectedExceptions = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer((Answer<List<OperationExecution>>) invocation -> { + if (expectedExceptions.size() >= 100) { + scaleOperationExecution.setStatus(OperationStatus.FINISHED); + return operationExecutions; + } + ApiException apiException = new ApiException(); + expectedExceptions.add(apiException); + // when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(scaleOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(scaleOperationExecution); + throw apiException; + }); + + //when + JobInfo job = lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(100, expectedExceptions.size()); + for (ApiException expectedException : expectedExceptions) { + verify(logger).warn("Unable to retrieve operations details", expectedException); + } + verify(systemFunctions, times(100)).sleep(5000); + } + + /** + * test scale failure propagation + */ + @Test + public void testScaleFailurePropagation() throws Exception { + ApiException expectedException = new ApiException(); + VnfScaleRequest scaleRequest = new VnfScaleRequest(); + scaleRequest.setNumberOfSteps("2"); + scaleRequest.setAspectId("myAspect"); + scaleRequest.setType(ScaleDirection.IN); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + lifecycleManager.scaleVnf(VNFM_ID, VNF_ID, scaleRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + verify(logger).error("Unable to scale VNF with myVnfId identifier", expectedException); + } + + /** + * test heal basic scenario + */ + @Test + public void testHeal() throws Exception { + VnfHealRequest healRequest = new VnfHealRequest(); + healRequest.setAction("myAction"); + VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm(); + affectedVm.setVmname("vmName"); + healRequest.setAffectedvm(affectedVm); + healOperationExecution.setStatus(OperationStatus.FINISHED); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setValue(ONAP_CSAR_ID); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + vnfInfo.getOperationExecutions().add(instantiationOperationExecution); + String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }"; + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams)); + //when + JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(1, actualHealRequest.getAllValues().size()); + HealVnfRequest sRequest = actualHealRequest.getValue(); + InOrder workflowOrder = Mockito.inOrder(vfcGrantManager, vnfApi); + workflowOrder.verify(vfcGrantManager).requestGrantForHeal(eq(VNFM_ID), eq(VNF_ID), eq(VIM_ID), eq(ONAP_CSAR_ID), eq(healRequest), eq(JOB_ID)); + workflowOrder.verify(vnfApi).vnfsVnfInstanceIdHealPost(VNF_ID, sRequest, NOKIA_LCM_API_VERSION); + JsonObject root = new Gson().toJsonTree(sRequest.getAdditionalParams()).getAsJsonObject(); + assertEquals("myAction", root.get("action").getAsString()); + assertEquals("vmName", root.get("vmName").getAsString()); + assertEquals(JOB_ID, root.get("jobId").getAsString()); + verify(jobManager).spawnJob(VNF_ID, restResponse); + } + + /** + * test heal operation is out waited + */ + @Test + public void testHealOutwait() throws Exception { + VnfHealRequest healRequest = new VnfHealRequest(); + healRequest.setAction("myAction"); + VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm(); + affectedVm.setVmname("vmName"); + healRequest.setAffectedvm(affectedVm); + healOperationExecution.setStatus(OperationStatus.FINISHED); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnfInfo); + VnfProperty prop = new VnfProperty(); + prop.setValue(ONAP_CSAR_ID); + prop.setName(LifecycleManager.ONAP_CSAR_ID); + vnfInfo.getExtensions().add(prop); + vnfInfo.getOperationExecutions().add(instantiationOperationExecution); + String instantiationParams = "{ \"vims\" : [ { \"id\" : \"" + VIM_ID + "\" } ] }"; + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new JsonParser().parse(instantiationParams)); + List<ApiException> expectedExceptions = new ArrayList<>(); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenAnswer(new Answer<List<OperationExecution>>() { + @Override + public List<OperationExecution> answer(InvocationOnMock invocation) throws Throwable { + if (expectedExceptions.size() >= 100) { + scaleOperationExecution.setStatus(OperationStatus.FINISHED); + return operationExecutions; + } + ApiException apiException = new ApiException(); + expectedExceptions.add(apiException); + throw apiException; + } + }); + //when + JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + assertEquals(100, expectedExceptions.size()); + for (ApiException expectedException : expectedExceptions) { + verify(logger).warn("Unable to retrieve operations details", expectedException); + } + verify(systemFunctions, times(100)).sleep(5000); + } + + /** + * failure in heal propagates in error + */ + @Test + public void testHealFailurePropagation() throws Exception { + ApiException expectedException = new ApiException(); + VnfHealRequest healRequest = new VnfHealRequest(); + healRequest.setAction("myAction"); + VnfHealRequestAffectedvm affectedVm = new VnfHealRequestAffectedvm(); + affectedVm.setVmname("vmName"); + healRequest.setAffectedvm(affectedVm); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + JobInfo job = lifecycleManager.healVnf(VNFM_ID, VNF_ID, healRequest, restResponse); + //verify + waitForJobToFinishInJobManager(finished); + verify(logger).error("Unable to heal VNF with myVnfId identifier", expectedException); + } + + private void waitForJobToFinishInJobManager(Set<Boolean> finished) throws InterruptedException { + while (finished.size() == 0) { + systemFunctions().sleep(100); + } + } + + private VnfInstantiateRequest prepareInstantiationRequest(VimInfo.VimInfoTypeEnum cloudType) { + VnfInstantiateRequest instantiationRequest = new VnfInstantiateRequest(); + instantiationRequest.setVnfPackageId(ONAP_CSAR_ID); + instantiationRequest.setVnfDescriptorId(ONAP_CSAR_ID); + instantiationRequest.setVnfInstanceDescription("myDescription"); + instantiationRequest.setVnfInstanceName("vnfName"); + additionalParam.setInstantiationLevel("level1"); + switch (cloudType) { + case OPENSTACK_V2_INFO: + additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V2_INFO); + break; + case OPENSTACK_V3_INFO: + additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OPENSTACK_V3_INFO); + additionalParam.setDomain("myDomain"); + break; + case VMWARE_VCLOUD_INFO: + additionalParam.setVimType(VimInfo.VimInfoTypeEnum.VMWARE_VCLOUD_INFO); + break; + default: + additionalParam.setVimType(VimInfo.VimInfoTypeEnum.OTHER_VIM_INFO); + } + + Map<String, List<NetworkAddress>> exteranalConnectionPointAddresses = new HashMap<>(); + exteranalConnectionPointAddresses.put("ecp1", new ArrayList<>()); + NetworkAddress networkAddress = new NetworkAddress(); + networkAddress.setIp("1.2.3.4"); + networkAddress.setMac("mac"); + networkAddress.setSubnetId("subnetId"); + exteranalConnectionPointAddresses.get("ecp1").add(networkAddress); + additionalParam.setExternalConnectionPointAddresses(exteranalConnectionPointAddresses); + VimComputeResourceFlavour flavor = new VimComputeResourceFlavour(); + flavor.setResourceId("flavourProviderId"); + flavor.setVimId(VIM_ID); + flavor.setVnfdVirtualComputeDescId("virtualComputeDescId"); + additionalParam.getComputeResourceFlavours().add(flavor); + ExtVirtualLinkData evl = new ExtVirtualLinkData(); + evl.setResourceId("networkProviderId1"); + evl.setVimId(VIM_ID); + evl.setExtVirtualLinkId("evlId1"); + VnfExtCpData ecp2 = new VnfExtCpData(); + ecp2.setCpdId("cpdId3"); + ecp2.setAddresses(new ArrayList<>()); + ecp2.getAddresses().add(networkAddress); + ecp2.setNumDynamicAddresses(2); + evl.getExtCps().add(ecp2); + additionalParam.getExtVirtualLinks().add(evl); + externalVirtualLink.setCpdId("myCpdId"); + externalVirtualLink.setResourceId("myNetworkProviderId"); + externalVirtualLink.setVlInstanceId("myEVlId"); + externalVirtualLink.setResourceSubnetId("notUsedSubnetId"); + instantiationRequest.setExtVirtualLink(new ArrayList<>()); + instantiationRequest.getExtVirtualLink().add(externalVirtualLink); + additionalParam.getExtManagedVirtualLinks().add(extManVl); + ZoneInfo zone = new ZoneInfo(); + zone.setId("zoneId"); + zone.setResourceId("zoneProviderId"); + zone.setVimId(VIM_ID); + additionalParam.getZones().add(zone); + VimSoftwareImage image = new VimSoftwareImage(); + image.setResourceId("imageProviderId"); + image.setVimId(VIM_ID); + image.setVnfdSoftwareImageId("imageId"); + additionalParam.getSoftwareImages().add(image); + additionalParam.setAdditionalParams(new JsonParser().parse("{ \"a\" : \"b\" }")); + String params = new Gson().toJson(additionalParam); + String src = "{ \"inputs\" : { \"vnfs\" : { \"" + ONAP_CSAR_ID + "\" : " + params + "}}, \"vimId\" : \"" + VIM_ID + "\"}"; + instantiationRequest.setAdditionalParam(new JsonParser().parse(src)); + return instantiationRequest; + } + + /** + * Test vimId decomposition + */ + @Test + public void testVimIdSplitting() { + assertEquals("regionId", LifecycleManager.getRegionName("cloudOwner_regionId")); + assertEquals("cloudOwner", LifecycleManager.getCloudOwner("cloudOwner_regionId")); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestSelfRegistrationManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestSelfRegistrationManager.java new file mode 100644 index 00000000..79ec1a83 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/TestSelfRegistrationManager.java @@ -0,0 +1,345 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm; + +import com.google.common.collect.Lists; +import com.nokia.cbam.lcn.v32.ApiException; +import com.nokia.cbam.lcn.v32.model.CreateSubscriptionRequest; +import com.nokia.cbam.lcn.v32.model.Subscription; +import com.nokia.cbam.lcn.v32.model.SubscriptionAuthentication; +import com.nokia.cbam.lcn.v32.model.VnfNotificationType; +import org.junit.Before; +import org.junit.Test; +import org.mockito.*; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.onap.msb.sdk.discovery.common.RouteException; +import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo; +import org.onap.msb.sdk.discovery.entity.MicroServiceInfo; +import org.onap.msb.sdk.discovery.entity.Node; +import org.onap.msb.sdk.discovery.entity.RouteResult; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +import static com.nokia.cbam.lcn.v32.model.OperationType.*; +import static junit.framework.TestCase.*; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCN_API_VERSION; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestSelfRegistrationManager extends TestBase { + @Mock + private JobManager jobManager; + private List<Subscription> subscriptions = new ArrayList<>(); + private ArgumentCaptor<MicroServiceInfo> registeredMicroservice = ArgumentCaptor.forClass(MicroServiceInfo.class); + private ArgumentCaptor<CreateSubscriptionRequest> subscriptionToCreate = ArgumentCaptor.forClass(CreateSubscriptionRequest.class); + @InjectMocks + private SelfRegistrationManager selfRegistrationManager; + + @Before + public void initMocks() throws Exception { + setField(SelfRegistrationManager.class, "logger", logger); + when(lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)).thenReturn(subscriptions); + when(driverProperties.getVnfmId()).thenReturn(VNFM_ID); + setField(selfRegistrationManager, "driverMsbExternalIp", "1.2.3.4"); + setField(selfRegistrationManager, "driverVnfmExternalIp", "5.6.7.8"); + setField(selfRegistrationManager, "driverPort", "12345"); + Subscription unknownSubscription = new Subscription(); + unknownSubscription.setId(UUID.randomUUID().toString()); + unknownSubscription.setCallbackUrl("unknown"); + subscriptions.add(unknownSubscription); + } + + /** + * test the basic registration process + * - first subscribe to CBAM LCNs + * - second publish it's existence on MSB + */ + @Test + public void testRegistration() throws Exception { + //given + Subscription subscription = new Subscription(); + when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenReturn(subscription); + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenReturn(returnedMicroService); + //when + selfRegistrationManager.register(); + //verify + InOrder registrationOrder = Mockito.inOrder(lcnApi, msbClient); + registrationOrder.verify(lcnApi).subscriptionsPost(any(), any()); + registrationOrder.verify(msbClient).registerMicroServiceInfo(any()); + + assertMicroserviceRegistered(); + assertNewLcnSubscription(); + assertServiceUp(); + } + + private void assertNewLcnSubscription() { + CreateSubscriptionRequest subscriptionCreation = subscriptionToCreate.getValue(); + assertEquals("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn", subscriptionCreation.getCallbackUrl()); + assertEquals(SubscriptionAuthentication.TypeEnum.NONE, subscriptionCreation.getAuthentication().getType()); + assertNull(subscriptionCreation.getAuthentication().getUserName()); + assertNull(subscriptionCreation.getAuthentication().getClientName()); + assertNull(subscriptionCreation.getAuthentication().getClientPassword()); + assertNull(subscriptionCreation.getAuthentication().getPassword()); + assertNull(subscriptionCreation.getAuthentication().getTokenUrl()); + assertNull(subscriptionCreation.getFilter().getVnfdId()); + assertNull(subscriptionCreation.getFilter().getVnfInstanceId()); + assertNull(subscriptionCreation.getFilter().getVnfProductName()); + assertNull(subscriptionCreation.getFilter().getVnfSoftwareVersion()); + assertEquals(Lists.newArrayList(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION), subscriptionCreation.getFilter().getNotificationTypes()); + assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(HEAL)); + assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(SCALE)); + assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(TERMINATE)); + assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(INSTANTIATE)); + assertEquals(4, subscriptionCreation.getFilter().getOperationTypes().size()); + } + + private void assertMicroserviceRegistered() { + MicroServiceInfo microserviceRequest = registeredMicroservice.getValue(); + assertEquals(1, microserviceRequest.getNodes().size()); + Node node = microserviceRequest.getNodes().iterator().next(); + assertEquals("0", node.getTtl()); + assertEquals("1.2.3.4", node.getIp()); + assertEquals("12345", node.getPort()); + assertEquals("REST", microserviceRequest.getProtocol()); + assertNull(microserviceRequest.getMetadata()); + //very strange, but it should be null for ONAP to work + assertEquals("", microserviceRequest.getPath()); + assertEquals(SelfRegistrationManager.SERVICE_NAME, microserviceRequest.getServiceName()); + assertEquals("/api/NokiaSVNFM/v1", microserviceRequest.getUrl()); + assertEquals("v1", microserviceRequest.getVersion()); + //1 means internal service to ONAP + assertEquals("1", microserviceRequest.getVisualRange()); + } + + /** + * If the subscription already exists the subscription is not recreated + */ + @Test + public void testResubscription() throws Exception { + //given + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenReturn(returnedMicroService); + Subscription existingSubscription = new Subscription(); + existingSubscription.setId(UUID.randomUUID().toString()); + existingSubscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscriptions.add(existingSubscription); + //when + selfRegistrationManager.register(); + //verify + assertMicroserviceRegistered(); + verify(lcnApi, never()).subscriptionsPost(any(), any()); + assertServiceUp(); + } + + /** + * If the LCN subscription fails the microservice is not registered + */ + @Test + public void testFailedLcnSubscription() throws Exception { + //given + ApiException expectedException = new ApiException(); + when(lcnApi.subscriptionsPost(any(), any())).thenThrow(expectedException); + //when + try { + selfRegistrationManager.register(); + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + } + //verify + verify(msbClient, never()).registerMicroServiceInfo(any()); + verify(logger).error("Unable to subscribe to CBAM LCN", expectedException); + assertServiceDown(); + } + + /** + * If the registration to MSB fails the subscription is deleted + */ + @Test + public void testFailedMsbPublish() throws Exception { + //given + Subscription subscription = new Subscription(); + when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(new Answer<Subscription>() { + @Override + public Subscription answer(InvocationOnMock invocationOnMock) throws Throwable { + subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscription.setId(UUID.randomUUID().toString()); + subscriptions.add(subscription); + return subscription; + } + }); + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + RouteException expectedException = new RouteException(); + when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenThrow(expectedException); + //when + try { + selfRegistrationManager.register(); + //verify + fail(); + } catch (RuntimeException e) { + assertEquals(expectedException, e.getCause()); + } + assertNewLcnSubscription(); + verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + assertServiceDown(); + } + + /** + * basic service unregistration + * - ongoing jobs are outwaited + * - first the service is removed from MSB + * - second unregistration + */ + @Test + public void testUnregistration() throws Exception { + //given + Subscription subscription = new Subscription(); + subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscription.setId(UUID.randomUUID().toString()); + subscriptions.add(subscription); + when(jobManager.hasOngoingJobs()).thenReturn(false); + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + //when + selfRegistrationManager.deRegister(); + //verify + InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi); + inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + assertServiceDown(); + } + + /** + * if the MSB reports that it could not cancel the service, but the service has + * disappeared from MSB the cancellation is considered to be successful + */ + @Test + public void testPartiallyFailedMsbCancel() throws Exception { + //given + Subscription subscription = new Subscription(); + subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscription.setId(UUID.randomUUID().toString()); + subscriptions.add(subscription); + when(jobManager.hasOngoingJobs()).thenReturn(false); + when(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() { + @Override + public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable { + when(msbClient.queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).thenThrow(new RouteException()); + throw new RouteException(); + } + }); + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + //when + selfRegistrationManager.deRegister(); + //verify + InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi); + inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + assertServiceDown(); + } + + /** + * failure of unregistration from MSB should be propagated + */ + @Test + public void testUnregistrationFailure() throws Exception { + //given + Subscription subscription = new Subscription(); + subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscription.setId(UUID.randomUUID().toString()); + subscriptions.add(subscription); + when(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() { + @Override + public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable { + throw new RouteException(); + } + }); + MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo(); + //when + try { + selfRegistrationManager.deRegister(); + fail(); + } catch (RuntimeException e) { + + } + //verify + InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi); + inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + verify(lcnApi, Mockito.never()).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + assertServiceDown(); + } + + /** + * failure of subscription deletion from MSB should be propagated + */ + @Test + public void testSubscriptionFailure() throws Exception { + //given + Subscription subscription = new Subscription(); + subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn"); + subscription.setId(UUID.randomUUID().toString()); + subscriptions.add(subscription); + when(jobManager.hasOngoingJobs()).thenReturn(false); + ApiException expectedException = new ApiException(); + doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + //when + try { + selfRegistrationManager.deRegister(); + fail(); + } catch (RuntimeException e) { + + } + //verify + InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi); + inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION); + inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION); + assertServiceDown(); + } + + /** + * the swagger API definitions embedded in the code + */ + @Test + public void testSwaggerApi() throws Exception { + //no idea how to test this except repeat implementation + byte[] a = TestUtil.loadFile(SelfRegistrationManager.SWAGGER_API_DEFINITION); + tearGeneric(); + //when + assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition())); + } + + public void assertServiceUp() throws Exception { + assertTrue(selfRegistrationManager.isReady()); + } + + /** + * if there are ongoing jobs then the guard thros exception + */ + public void assertServiceDown() { + assertFalse(selfRegistrationManager.isReady()); + + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestLifecycleChangeNotificationManager.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestLifecycleChangeNotificationManager.java new file mode 100644 index 00000000..ed009b97 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestLifecycleChangeNotificationManager.java @@ -0,0 +1,457 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification; + +import com.google.gson.*; +import com.nokia.cbam.lcm.v32.ApiException; +import com.nokia.cbam.lcm.v32.model.*; +import org.joda.time.DateTime; +import org.junit.Before; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.ILifecycleChangeNotificationManager; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; +import org.threeten.bp.OffsetDateTime; + +import java.util.ArrayList; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.concurrent.Callable; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; + +import static com.nokia.cbam.lcm.v32.model.OperationType.*; +import static junit.framework.TestCase.*; +import static org.mockito.Mockito.*; +import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION; +import static org.springframework.test.util.ReflectionTestUtils.setField; + +public class TestLifecycleChangeNotificationManager extends TestBase { + + public static final String OPERATION_EXECUTION_ID = "myOperationExecutionId"; + + @InjectMocks + private LifecycleChangeNotificationManager lifecycleChangeNotificationManager; + private VnfLifecycleChangeNotification recievedLcn = new VnfLifecycleChangeNotification(); + private List<OperationExecution> operationExecutions = new ArrayList<>(); + private OperationExecution instantiationOperation = new OperationExecution(); + private OperationExecution scaleOperation = new OperationExecution(); + private OperationExecution healOperation = new OperationExecution(); + private OperationExecution terminationOperation = new OperationExecution(); + + private ArgumentCaptor<OperationExecution> currentOperationExecution = ArgumentCaptor.forClass(OperationExecution.class); + private ArgumentCaptor<ReportedAffectedConnectionPoints> affectedConnectionPoints = ArgumentCaptor.forClass(ReportedAffectedConnectionPoints.class); + + private List<VnfInfo> vnfs = new ArrayList<>(); + private VnfInfo vnf = new VnfInfo(); + + @Before + public void initMocks() throws Exception { + setField(LifecycleChangeNotificationManager.class, "logger", logger); + instantiationOperation.setId("instantiationOperationExecutionId"); + instantiationOperation.setStartTime(OffsetDateTime.now()); + instantiationOperation.setOperationType(OperationType.INSTANTIATE); + scaleOperation.setId("scaleOperationExecutionId"); + scaleOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + scaleOperation.setOperationType(OperationType.SCALE); + terminationOperation.setId("terminationExecutionId"); + terminationOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + terminationOperation.setOperationType(OperationType.TERMINATE); + healOperation.setId("healOperaitonExecutionId"); + healOperation.setOperationType(OperationType.HEAL); + recievedLcn.setLifecycleOperationOccurrenceId("instantiationOperationExecutionId"); + healOperation.setStartTime(OffsetDateTime.now().plusDays(1)); + recievedLcn.setVnfInstanceId(VNF_ID); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(operationExecutions); + prepOperation(instantiationOperation); + prepOperation(scaleOperation); + prepOperation(healOperation); + prepOperation(terminationOperation); + doNothing().when(notificationSender).processNotification(eq(recievedLcn), currentOperationExecution.capture(), affectedConnectionPoints.capture(), eq(VIM_ID)); + InstantiateVnfRequest instantiateVnfRequest = new InstantiateVnfRequest(); + VimInfo vimInfo = new VimInfo(); + vimInfo.setId(VIM_ID); + instantiateVnfRequest.getVims().add(vimInfo); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperation.getId(), NOKIA_LCM_API_VERSION)).thenReturn(new Gson().toJsonTree(instantiateVnfRequest)); + when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenReturn(vnfs); + vnfs.add(vnf); + vnf.setId(VNF_ID); + VnfProperty prop = new VnfProperty(); + prop.setName(ILifecycleChangeNotificationManager.EXTERNAL_VNFM_ID); + prop.setValue(VNFM_ID); + vnf.setExtensions(new ArrayList<>()); + vnf.getExtensions().add(prop); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenReturn(vnf); + } + + private void prepOperation(OperationExecution operationExecution) throws ApiException { + addEmptyModifiedConnectionPoints(operationExecution); + JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}"); + operationExecution.setOperationParams(root); + switch (operationExecution.getOperationType()) { + case TERMINATE: + root.getAsJsonObject().addProperty("terminationType", "GRACEFULL"); + } + when(operationExecutionApi.operationExecutionsOperationExecutionIdGet(operationExecution.getId(), NOKIA_LCM_API_VERSION)).thenReturn(operationExecution); + operationExecutions.add(operationExecution); + } + + private void addEmptyModifiedConnectionPoints(OperationExecution operationExecution) { + OperationResult operationResult = new OperationResult(); + operationResult.operationResult = new ReportedAffectedConnectionPoints(); + JsonElement additionalData = new Gson().toJsonTree(operationResult); + operationExecution.setAdditionalData(additionalData); + } + + /** + * The first instantiation before the current operation is selected + */ + @Test + public void testLastInstantiationSelection() { + List<OperationExecution> operations = new ArrayList<>(); + + OperationExecution operation = buildOperation(OffsetDateTime.now(), TERMINATE); + OperationExecution operationScale = buildOperation(OffsetDateTime.now().minusDays(1), SCALE); + OperationExecution operationClosestInstantiate = buildOperation(OffsetDateTime.now().minusDays(2), INSTANTIATE); + OperationExecution operationFurthers = buildOperation(OffsetDateTime.now().minusDays(3), INSTANTIATE); + + operations.add(operation); + operations.add(operationScale); + operations.add(operationClosestInstantiate); + operations.add(operationFurthers); + assertEquals(operationClosestInstantiate, LifecycleChangeNotificationManager.findLastInstantiationBefore(operations, operation)); + } + + /** + * The instantiation operation itself is valid as the last instantiation operation + */ + @Test + public void testInstantiationSufficesTheLastInstantiation() { + DateTime baseTime = DateTime.now(); + List<OperationExecution> operations = new ArrayList<>(); + + OperationExecution operation = buildOperation(OffsetDateTime.now(), INSTANTIATE); + OperationExecution operationScale = buildOperation(OffsetDateTime.now().minusDays(1), SCALE); + OperationExecution operationFurthers = buildOperation(OffsetDateTime.now().minusDays(2), INSTANTIATE); + + operations.add(operation); + operations.add(operationScale); + operations.add(operationFurthers); + assertEquals(operation, LifecycleChangeNotificationManager.findLastInstantiationBefore(operations, operation)); + } + + /** + * If no instantiation operation is found for before the selected operation + */ + @Test + public void testNoInstantiation() { + DateTime baseTime = DateTime.now(); + List<OperationExecution> operations = new ArrayList<>(); + + OperationExecution operation = buildOperation(OffsetDateTime.now(), TERMINATE); + OperationExecution operationScale = buildOperation(OffsetDateTime.now().minusDays(1), SCALE); + + operations.add(operation); + operations.add(operationScale); + try { + LifecycleChangeNotificationManager.findLastInstantiationBefore(operations, operation); + fail(); + } catch (NoSuchElementException e) { + + } + } + + /** + * the operations are ordered from newest (first) to oldest (last) + */ + @Test + public void testOperationOrdering() { + List<OperationExecution> operationExecutions = new ArrayList<>(); + OperationExecution before = buildOperation(OffsetDateTime.now(), OperationType.INSTANTIATE); + operationExecutions.add(before); + OperationExecution after = buildOperation(OffsetDateTime.now().plusDays(1), OperationType.SCALE); + operationExecutions.add(after); + List<OperationExecution> sorted1 = LifecycleChangeNotificationManager.NEWEST_OPERATIONS_FIRST.sortedCopy(operationExecutions); + assertEquals(after, sorted1.get(0)); + assertEquals(before, sorted1.get(1)); + } + + /** + * if VNF listing fails the processing of the notifications is aborted + */ + @Test + public void testUnableToListVnfs() throws Exception { + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsGet(NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + fail(); + } catch (Exception e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to list VNFs / query VNF", expectedException); + } + } + + /** + * if VNF query fails the processing of the notifications is aborted + */ + @Test + public void testUnableToQueryVnf() throws Exception { + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + fail(); + } catch (Exception e) { + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to list VNFs / query VNF", expectedException); + } + } + + /** + * if the VNF is not managed by this VNFM the LCN is dropped + */ + @Test + public void testNonManagedVnf() throws Exception { + vnf.getExtensions().clear(); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + //verify + Mockito.verifyZeroInteractions(operationExecutionApi); + verify(logger).warn("The VNF with " + VNF_ID + " identifier is not a managed VNF"); + } + + /** + * if the VNF is not managed by this VNFM the LCN is dropped + */ + @Test + public void testManagedByOtherVnf() throws Exception { + vnf.getExtensions().get(0).setValue("unknownVnfmId"); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + //verify + Mockito.verifyZeroInteractions(operationExecutionApi); + verify(logger).warn("The VNF with " + VNF_ID + " identifier is not a managed by the VNFM with id unknownVnfmId"); + } + + /** + * if the VNF disappeared before processing the LCN + */ + @Test + public void testDisappearedVnf() throws Exception { + vnfs.clear(); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + //verify + Mockito.verifyZeroInteractions(operationExecutionApi); + verify(logger).warn("The VNF with " + VNF_ID + " disappeared before being able to process the LCN"); + } + + /** + * if the operation parameters of the last instantiation is non querieable error is propagated + */ + @Test + public void testUnableToQueryOperationParams() throws Exception { + recievedLcn.setOperation(OperationType.TERMINATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + RuntimeException expectedException = new RuntimeException(); + when(operationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(instantiationOperation.getId(), NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + fail(); + } catch (Exception e) { + //verify + Mockito.verifyZeroInteractions(nsLcmApi); + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to detect last instantiation operation", e.getCause()); + } + } + + /** + * if unable to send LCN to VF-C the error is propagated + */ + @Test + public void testUnableToQueryCurrentOperation() throws Exception { + recievedLcn.setOperation(OperationType.TERMINATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + ApiException expectedException = new ApiException(); + when(vnfApi.vnfsVnfInstanceIdOperationExecutionsGet(VNF_ID, NOKIA_LCM_API_VERSION)).thenThrow(expectedException); + //when + try { + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + fail(); + } catch (Exception e) { + //verify + assertEquals(expectedException, e.getCause()); + verify(logger).error("Unable to retrieve the current VNF myVnfId", e.getCause()); + } + } + + /** + * test that waitForTerminationToBeProcessed outwaits the successfull processing of the termination notification + */ + @Test + public void testWaitForTermination() throws Exception { + //given + //add an non processed notification + VnfLifecycleChangeNotification nonProcessedEvent = new VnfLifecycleChangeNotification(); + nonProcessedEvent.setStatus(OperationStatus.FINISHED); + nonProcessedEvent.setOperation(OperationType.TERMINATE); + OperationExecution secondTerminationOperationExecution = new OperationExecution(); + secondTerminationOperationExecution.setOperationType(OperationType.TERMINATE); + secondTerminationOperationExecution.setId("secondId"); + secondTerminationOperationExecution.setOperationParams(buildTerminationParams()); + nonProcessedEvent.setLifecycleOperationOccurrenceId(secondTerminationOperationExecution.getId()); + lifecycleChangeNotificationManager.handleLcn(nonProcessedEvent); + //add second termination + recievedLcn.setOperation(OperationType.TERMINATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + recievedLcn.setLifecycleOperationOccurrenceId(terminationOperation.getId()); + ExecutorService executorService = Executors.newCachedThreadPool(); + Future<Boolean> waitExitedWithSuccess = executorService.submit(new Callable<Boolean>() { + @Override + public Boolean call() throws Exception { + try { + lifecycleChangeNotificationManager.waitForTerminationToBeProcessed(terminationOperation.getId()); + return true; + } catch (Exception e) { + return false; + } + } + }); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + //verify + assertTrue(waitExitedWithSuccess.get()); + } + + /** + * Forceful termination results in an empty affected connection points + */ + @Test + public void testMissingPreResultForForcefullTermination() { + //given + recievedLcn.setOperation(OperationType.INSTANTIATE); + recievedLcn.setStatus(OperationStatus.FINISHED); + recievedLcn.setLifecycleOperationOccurrenceId(terminationOperation.getId()); + JsonObject additionalData = new JsonObject(); + additionalData.add("operationResult", new JsonObject()); + ((JsonObject) terminationOperation.getOperationParams()).addProperty("terminationType", "FORCEFUL"); + terminationOperation.setAdditionalData(additionalData); + terminationOperation.setStatus(OperationStatus.FINISHED); + terminationOperation.setOperationType(OperationType.TERMINATE); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + assertNull(affectedConnectionPoints.getValue()); + verify(logger).warn("Unable to send information related to affected connection points during forceful termination"); + } + + /** + * test end notification scenario for failed scale-out + * - LCN is sent to VF-C, but the + */ + @Test + public void testMissingPreResultForFailedOperation() { + //given + recievedLcn.setOperation(OperationType.SCALE); + recievedLcn.setStatus(OperationStatus.FAILED); + recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId()); + ScaleVnfRequest request = new ScaleVnfRequest(); + request.setAdditionalParams(new JsonParser().parse("{ \"type\" : \"IN\", \"jobId\" : \"" + JOB_ID + "\" }")); + request.setType(ScaleDirection.OUT); + scaleOperation.setOperationParams(request); + scaleOperation.setAdditionalData(null); + scaleOperation.setStatus(OperationStatus.FAILED); + scaleOperation.setOperationType(OperationType.SCALE); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + assertEquals(0, affectedConnectionPoints.getValue().getPost().size()); + assertEquals(0, affectedConnectionPoints.getValue().getPre().size()); + verify(logger).warn("The operation failed and the affected connection points were not reported"); + } + + /** + * test end notification success scenario for scale-out + * - LCN is sent to VF-C + */ + @Test + public void testMissingPreResult() { + //given + recievedLcn.setOperation(OperationType.SCALE); + recievedLcn.setStatus(OperationStatus.FINISHED); + recievedLcn.setLifecycleOperationOccurrenceId(scaleOperation.getId()); + ScaleVnfRequest request = new ScaleVnfRequest(); + request.setAdditionalParams(new JsonParser().parse("{ \"type\" : \"IN\", \"jobId\" : \"" + JOB_ID + "\" }")); + request.setType(ScaleDirection.OUT); + scaleOperation.setOperationParams(request); + JsonObject additionalData = new JsonObject(); + additionalData.add("operationResult", new JsonObject()); + scaleOperation.setAdditionalData(additionalData); + scaleOperation.setStatus(OperationStatus.FINISHED); + scaleOperation.setOperationType(OperationType.SCALE); + JsonElement root = new JsonParser().parse("{ \"additionalParams\" : { \"jobId\" : \"" + JOB_ID + "\"}}"); + JsonObject operationParams = new JsonObject(); + //when + try { + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + fail(); + } catch (Exception e) { + assertEquals("All operations must return the { \"operationResult\" : { \"cbam_pre\" : [<fillMeOut>], \"cbam_post\" : [<fillMeOut>] } } structure", e.getMessage()); + } + } + + /** + * missing connection points are tolerated in case of failed operations + */ + @Test + public void testMissingConnectionPoints() { + //given + recievedLcn.setOperation(OperationType.INSTANTIATE); + recievedLcn.setStatus(OperationStatus.FAILED); + recievedLcn.setLifecycleOperationOccurrenceId(instantiationOperation.getId()); + instantiationOperation.setAdditionalData(null); + instantiationOperation.setStatus(OperationStatus.FAILED); + //when + lifecycleChangeNotificationManager.handleLcn(recievedLcn); + assertEquals(0, affectedConnectionPoints.getValue().getPost().size()); + assertEquals(0, affectedConnectionPoints.getValue().getPre().size()); + verify(logger).warn("The operation failed and the affected connection points were not reported"); + } + + private JsonObject buildTerminationParams() { + JsonObject root = new JsonObject(); + root.add("terminationType", new JsonPrimitive("GRACEFULL")); + return root; + } + + private OperationExecution buildOperation(OffsetDateTime baseTime, OperationType operationType) { + OperationExecution operation = new OperationExecution(); + operation.setStartTime(baseTime); + operation.setOperationType(operationType); + return operation; + } + + class OperationResult { + ReportedAffectedConnectionPoints operationResult; + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestProcessedNotification.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestProcessedNotification.java new file mode 100644 index 00000000..bbe660a0 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestProcessedNotification.java @@ -0,0 +1,28 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import static pl.pojo.tester.api.assertion.Assertions.assertPojoMethodsFor; + +public class TestProcessedNotification extends TestBase { + @Test + public void testPojo() { + assertPojoMethodsFor(ProcessedNotification.class).areWellImplemented(); + } +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedConnectionPoints.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedConnectionPoints.java new file mode 100644 index 00000000..83699723 --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedConnectionPoints.java @@ -0,0 +1,30 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import static pl.pojo.tester.api.assertion.Assertions.assertPojoMethodsFor; + +public class TestReportedAffectedConnectionPoints extends TestBase { + @Test + public void testPojo() { + assertPojoMethodsFor(ReportedAffectedConnectionPoints.class).areWellImplemented(); + + } + +} diff --git a/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedCp.java b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedCp.java new file mode 100644 index 00000000..cb4d7e1c --- /dev/null +++ b/nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/notification/TestReportedAffectedCp.java @@ -0,0 +1,30 @@ +/* + * Copyright 2016-2017, Nokia Corporation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification; + +import org.junit.Test; +import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase; + +import static pl.pojo.tester.api.assertion.Assertions.assertPojoMethodsFor; + +public class TestReportedAffectedCp extends TestBase { + @Test + public void testPojo() { + assertPojoMethodsFor(ReportedAffectedCp.class).areWellImplemented(); + + } + +} diff --git a/nokiav2/driver/src/test/resources/.gitignore b/nokiav2/driver/src/test/resources/.gitignore new file mode 100644 index 00000000..03941911 --- /dev/null +++ b/nokiav2/driver/src/test/resources/.gitignore @@ -0,0 +1 @@ +application-real.properties diff --git a/nokiav2/driver/src/test/resources/application.properties b/nokiav2/driver/src/test/resources/application.properties new file mode 100644 index 00000000..f5c42fc0 --- /dev/null +++ b/nokiav2/driver/src/test/resources/application.properties @@ -0,0 +1,66 @@ +############################################################################### +# Copyright 2016, Nokia Corporation +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +############################################################################### +server.error.whitelabel.enabled=false +############################################################################### +# Beginning of mandatory properties # +############################################################################### +# The TCP port of the server +server.port=8089 +# the base path of the server +server.context-path= +# the IP address to which the server binds to +server.address=127.0.0.1 +# the IP address of the server reported to the micro service bus +driverMsbExternalIp=127.0.0.1 +# the IP address of the server reported to VNFM +driverVnfmExternalIp=127.0.0.1 +# the IP address of the message bus +messageBusIp=127.0.0.1 +# the TCP port of the message bus +messageBusPort=8089 +# the URL of the CBAM catalog service +cbamCatalogUrl=https://127.0.0.1:443/api/catalog/adapter +# the URL of the CBAM LCN service +cbamLcnUrl=https://127.0.0.0.1:443/vnfm/lcn/v3 +# the URL of the CBAM authentication service +cbamKeyCloakBaseUrl=https://127.0.0.0.1:443/auth +# skip hostname verification during SSL on CBAM LCN, LCM and authorization interface +skipHostnameVerification=true +# skip certificate verification during SSL on CBAM LCN, LCM and authorization interface +skipCertificateVerification=true +# the collection of trusted certificates for SSL on CBAM LCN, LCM and authorization interface +# in PEM format encoded in BASE64 to a single line +trustedCertificates= +# the username to be used for requesting a token on CBAM authorization interface +cbamUsername=onap +# the password to be used for requesting a token on CBAM authorization interface +cbamPassword=myPassword +# the identifier of the VNFM in A&AI core system registry +vnfmId=53fbba58-464e-4cc4-8d33-aaaf072f0a27 +############################################################################### +# End of mandatory properties for driver # +############################################################################### + + +spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration +vnfmInfoCacheEvictionInMs=600000 + +## for logging begin ## +com.fasterxml.jackson.core=jackson-databind +#logging.file=${catalina.base}/logs/vfcadaptor.log +logging.level.org.springframework.web=TRACE +logging.level.org.hibernate=OFF +## for logging end ## diff --git a/nokiav2/driver/src/test/resources/test.jks b/nokiav2/driver/src/test/resources/test.jks Binary files differnew file mode 100644 index 00000000..5506b9a8 --- /dev/null +++ b/nokiav2/driver/src/test/resources/test.jks diff --git a/nokiav2/driver/src/test/resources/unittests/TestCbamCatalogManager.sample.csar b/nokiav2/driver/src/test/resources/unittests/TestCbamCatalogManager.sample.csar Binary files differnew file mode 100644 index 00000000..94f476f4 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/TestCbamCatalogManager.sample.csar diff --git a/nokiav2/driver/src/test/resources/unittests/cbam.package.zip b/nokiav2/driver/src/test/resources/unittests/cbam.package.zip Binary files differnew file mode 100644 index 00000000..d7c6a673 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/cbam.package.zip diff --git a/nokiav2/driver/src/test/resources/unittests/empty.zip b/nokiav2/driver/src/test/resources/unittests/empty.zip Binary files differnew file mode 100644 index 00000000..15cb0ecb --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/empty.zip diff --git a/nokiav2/driver/src/test/resources/unittests/lcn.json b/nokiav2/driver/src/test/resources/unittests/lcn.json new file mode 100644 index 00000000..1ed3f5f4 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/lcn.json @@ -0,0 +1,9 @@ +{ + "status": "STARTED", + "vnfInstanceId": "CBAM-d59f413228af4a35b00eb168d636f567", + "timestamp": "2018-01-02T10:50:54.903260Z", + "notificationType": "VnfLifecycleChangeNotification", + "lifecycleOperationOccurrenceId": "CBAM-9b7dd0c2591d463b890021c38ead3f24", + "subscriptionId": "CBAM-1b89306bcd494879b7cb02369d2b2503", + "operation": "TERMINATE" +}
\ No newline at end of file diff --git a/nokiav2/driver/src/test/resources/unittests/localhost.cert.pem b/nokiav2/driver/src/test/resources/unittests/localhost.cert.pem new file mode 100644 index 00000000..879a6a5a --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/localhost.cert.pem @@ -0,0 +1,73 @@ +Certificate: + Data: + Version: 3 (0x2) + Serial Number: 878178886 (0x3457f246) + Signature Algorithm: sha256WithRSAEncryption + Issuer: C=Unknown, ST=Unknown, L=Unknown, O=Unknown, OU=Unknown, CN=localhost + Validity + Not Before: Dec 16 01:51:53 2017 GMT + Not After : Mar 16 01:51:53 2018 GMT + Subject: C=Unknown, ST=Unknown, L=Unknown, O=Unknown, OU=Unknown, CN=localhost + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + Public-Key: (2048 bit) + Modulus: + 00:85:90:1e:2e:d5:b6:55:c4:56:ac:f7:3d:fb:12: + c3:a5:be:30:bb:56:03:e7:b2:cb:0e:e5:27:d2:82: + 41:11:09:ff:3b:1c:aa:bc:3d:97:0e:2f:c1:b5:bf: + de:ed:fe:36:e9:71:d6:3d:3d:ca:00:b0:3b:69:b0: + b8:0a:ef:e3:df:91:2e:8f:f7:92:9d:29:0c:5d:15: + ad:47:10:db:34:8c:10:01:ad:68:dc:df:80:d5:42: + 1f:55:be:06:7c:b0:c7:0a:04:87:9a:0a:57:ba:67: + 43:39:a4:91:09:91:bb:6f:00:dc:ff:ff:4c:53:e0: + 38:37:de:50:2f:a7:04:e7:c3:bc:a8:56:cd:d6:a7: + 99:51:43:14:00:32:85:46:3d:92:31:f6:5b:de:74: + de:11:4f:23:c2:0d:c6:65:0d:1d:d5:66:d8:bb:79: + 21:0e:b8:b9:0c:75:6e:7b:35:de:1e:a1:35:00:2e: + 74:84:7d:a9:b6:55:f8:58:c4:a9:8e:cf:ae:3e:17: + 12:71:05:b8:8a:50:05:7a:e9:55:db:68:26:e9:02: + 0c:1d:43:7f:bd:00:ab:4b:6e:cf:3f:1a:68:a8:52: + a2:b8:36:19:ca:fb:37:f8:79:54:6a:b4:7b:41:54: + af:bc:6a:49:2d:15:6d:14:95:18:b1:37:b2:9a:52: + 21:47 + Exponent: 65537 (0x10001) + X509v3 extensions: + X509v3 Subject Key Identifier: + B4:A1:34:DA:34:7F:52:3E:76:AB:81:A4:5C:7E:10:3E:FD:84:9A:3E + Signature Algorithm: sha256WithRSAEncryption + 6b:9f:d7:de:1b:38:f0:46:7a:40:df:47:b1:1c:5c:05:2c:9a: + 4a:ad:5e:81:84:d1:ac:d4:8d:27:4b:8f:92:2e:02:18:7a:84: + 2f:bb:68:f5:ea:2b:ae:cc:3f:21:f7:d0:47:ea:6d:21:73:db: + 35:f0:e4:27:ba:95:db:2b:99:93:aa:a1:ab:23:bd:78:4f:7c: + e1:63:cb:2b:e8:2c:fb:e1:ad:af:2d:01:1d:67:d8:7c:bb:82: + 00:30:1a:de:b2:1c:d3:25:b0:de:b1:b5:3c:dc:42:4b:ae:b9: + 1c:e2:f4:dd:45:6c:87:75:d8:9e:bd:1d:27:05:e7:8c:63:ec: + de:87:aa:95:d7:65:64:80:42:95:88:14:16:6b:43:22:0f:e7: + c0:06:36:0d:93:14:be:d6:22:24:c0:43:c4:fa:83:bd:6c:5b: + 24:7f:ac:a5:f5:ea:a7:61:fd:5d:67:e3:9d:d1:59:b5:e6:d6: + 9b:20:ca:23:44:44:b7:65:a7:f9:74:34:de:68:87:fd:1c:2f: + 32:d7:48:c0:10:ba:7e:83:06:a4:21:05:d5:6b:b0:9e:9c:dc: + 12:5a:5a:45:b7:84:94:96:a4:29:e6:05:47:1f:f5:a5:93:db: + 21:fc:2e:2a:4d:55:09:54:38:0c:56:ba:59:5b:b2:36:85:c6: + 63:78:93:0c +-----BEGIN CERTIFICATE----- +MIIDezCCAmOgAwIBAgIENFfyRjANBgkqhkiG9w0BAQsFADBuMRAwDgYDVQQGEwdV +bmtub3duMRAwDgYDVQQIEwdVbmtub3duMRAwDgYDVQQHEwdVbmtub3duMRAwDgYD +VQQKEwdVbmtub3duMRAwDgYDVQQLEwdVbmtub3duMRIwEAYDVQQDEwlsb2NhbGhv +c3QwHhcNMTcxMjE2MDE1MTUzWhcNMTgwMzE2MDE1MTUzWjBuMRAwDgYDVQQGEwdV +bmtub3duMRAwDgYDVQQIEwdVbmtub3duMRAwDgYDVQQHEwdVbmtub3duMRAwDgYD +VQQKEwdVbmtub3duMRAwDgYDVQQLEwdVbmtub3duMRIwEAYDVQQDEwlsb2NhbGhv +c3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCFkB4u1bZVxFas9z37 +EsOlvjC7VgPnsssO5SfSgkERCf87HKq8PZcOL8G1v97t/jbpcdY9PcoAsDtpsLgK +7+PfkS6P95KdKQxdFa1HENs0jBABrWjc34DVQh9VvgZ8sMcKBIeaCle6Z0M5pJEJ +kbtvANz//0xT4Dg33lAvpwTnw7yoVs3Wp5lRQxQAMoVGPZIx9lvedN4RTyPCDcZl +DR3VZti7eSEOuLkMdW57Nd4eoTUALnSEfam2VfhYxKmOz64+FxJxBbiKUAV66VXb +aCbpAgwdQ3+9AKtLbs8/GmioUqK4NhnK+zf4eVRqtHtBVK+8akktFW0UlRixN7Ka +UiFHAgMBAAGjITAfMB0GA1UdDgQWBBS0oTTaNH9SPnargaRcfhA+/YSaPjANBgkq +hkiG9w0BAQsFAAOCAQEAa5/X3hs48EZ6QN9HsRxcBSyaSq1egYTRrNSNJ0uPki4C +GHqEL7to9eorrsw/IffQR+ptIXPbNfDkJ7qV2yuZk6qhqyO9eE984WPLK+gs++Gt +ry0BHWfYfLuCADAa3rIc0yWw3rG1PNxCS665HOL03UVsh3XYnr0dJwXnjGPs3oeq +lddlZIBClYgUFmtDIg/nwAY2DZMUvtYiJMBDxPqDvWxbJH+spfXqp2H9XWfjndFZ +tebWmyDKI0REt2Wn+XQ03miH/RwvMtdIwBC6foMGpCEF1WuwnpzcElpaRbeElJak +KeYFRx/1pZPbIfwuKk1VCVQ4DFa6WVuyNoXGY3iTDA== +-----END CERTIFICATE----- diff --git a/nokiav2/driver/src/test/resources/unittests/localhost.jks b/nokiav2/driver/src/test/resources/unittests/localhost.jks Binary files differnew file mode 100644 index 00000000..80b72992 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/localhost.jks diff --git a/nokiav2/driver/src/test/resources/unittests/maria.vnfd.scalable.tosca.nated.yaml b/nokiav2/driver/src/test/resources/unittests/maria.vnfd.scalable.tosca.nated.yaml new file mode 100644 index 00000000..76ed67ce --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/maria.vnfd.scalable.tosca.nated.yaml @@ -0,0 +1,593 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + properties: + descriptor_id: Nokia~Maria DB~1.0~1.0 + descriptor_version: '1.0' + provider: Nokia + product_name: Maria DB + software_version: '1.0' + product_info_name: Maria DB + product_info_description: Relational database, non-scalable + vnfm_info: + - CBAM + requirements: + - virtual_link: [ dbBackendIpv4, external_virtual_link ] # IPv4 for SQL + - virtual_link: [ dbBackendIpv6, external_virtual_link ] # IPv6 for SQL + - virtual_link: [ serviceNodeIpv4, external_virtual_link ] # IPv4 for SSH + - virtual_link: [ loadBalancer, external_virtual_link ] # IPv4 for SQL (load balanced) + capabilities: + deployment_flavour: + properties: + flavour_id: scalable + description: .. + scaling_aspects: + dbBackendAspect: + name: .. + description: .. + associated_group: dbBackendScalingGroup + max_scale_level: 8 + serviceNodeAspect: + name: .. + description: .. + associated_group: serviceNodeScalingGroup + max_scale_level: 3 + instantiation_levels: + small: + description: .. + vdu_levels: + dbBackend: + number_of_instances: 3 + serviceNode: + number_of_instances: 2 + scale_info: + dbBackendAspect: + scale_level: 0 + serviceNodeAspect: + scale_level: 1 + medium: + description: .. + vdu_levels: + dbBackend: + number_of_instances: 4 + serviceNode: + number_of_instances: 2 + scale_info: + dbBackendAspect: + scale_level: 1 + serviceNodeAspect: + scale_level: 1 + large: + description: .. + vdu_levels: + dbBackend: + number_of_instances: 5 + serviceNode: + number_of_instances: 4 + scale_info: + dbBackendAspect: + scale_level: 2 + serviceNodeAspect: + scale_level: 2 + default_instantiation_level_id: small + vdu_profile: + dbBackend: + min_number_of_instances: 3 + max_number_of_instances: 11 + serviceNode: + min_number_of_instances: 0 + max_number_of_instances: 6 + vnf: + properties: + modifiable_attributes: + extensions: + http_proxy: + default: "http://87.254.212.120:8080" + https_proxy: + default: "https://87.254.212.120:8080" + no_proxy: + default: "10.41.49.231,10.41.49.5" + mysqlPassword: + default: "password" + mysqlUsername: + default: "mysql" + loginUsername: + default: "ubuntu" + rhel_yum_repository_host: + default: "http://10.41.49.231/mirror/rhel-7-server-rpms/" + ubuntu_repository_host: + default: "deb [arch=amd64] http://10.41.49.5/cobbler/repo_mirror/ubuntu-16.04-x86_64/ xenial main universe" + mariadb_rhel_repo_host: +# default: "http://yum.mariadb.org/10.0/rhel7-amd64" + default: "http://10.41.49.5/cobbler/repo_mirror/mariadb-10.0-el7-x86_64/" + mariadb_ubuntu_repo_host: +# default: "deb http://mirror.netinch.com/pub/mariadb/repo/10.0/ubuntu trusty main" + default: "deb [arch=amd64] http://10.41.49.5/cobbler/repo_mirror/ubuntu-mariadb-10.0-x86_64/ xenial main" + custom_backend_root_volume_size: + default: "10" + dry_run: + default: "false" + interfaces: + Basic: + instantiate: + inputs: + extensions: + pre_actions: + - javascript: javascript/scalable_instantiate_hot_params.js + include: + - javascript/scalable_prepare_cbam_include.js + output: stack_parameters + - javascript: javascript/cbam.pre.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + post_actions: + - javascript: javascript/workaround_inventory_on_kilo.js + output: ansible_inventory + - ansible: ansible/playbook-scalable.yml + - javascript: javascript/cbam.post.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + additional_parameters: + jobId: onapJobId + terminate: + inputs: + extensions: + pre_actions: + - javascript: javascript/cbam.pre.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + post_actions: + - javascript: javascript/cbam.post.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + additional_parameters: + jobId: onapJobId + Scalable: + scale: + inputs: + extensions: + pre_actions: + - javascript: javascript/scalable_instantiate_hot_params.js + include: + - javascript/scalable_prepare_cbam_include.js + output: stack_parameters + - ansible: ansible/playbook-scalable-scale-in.yml + - javascript: javascript/cbam.pre.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + post_actions: + - javascript: javascript/workaround_inventory_on_kilo.js + output: ansible_inventory + - ansible: ansible/playbook-scalable.yml + - javascript: javascript/cbam.post.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + additional_parameters: + jobId: onapJobId + Healable: + heal: + implementation: mistral-workbooks/heal_workbook.yaml + inputs: + extensions: + pre_actions: + - javascript: javascript/cbam.pre.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + post_actions: + - javascript: javascript/cbam.post.collectConnectionPoints.js + include: + - javascript/cbam.collectConnectionPoints.js + output: operation_result + additional_parameters: + vmName: null + action: null + jobId: onapJobId + Custom: + upgrade: + implementation: mistral-workbooks/upgrade_workbook.yaml + inputs: + additional_parameters: + imageId: ubuntu.16.04 + jobId: onapJobId + node_templates: + dbBackend: + type: tosca.nodes.nfv.VDU + properties: + description: .. + configurable_properties: + additional_vnfc_configurable_properties: {} + boot_order: + - rootVolume + requirements: + - virtual_compute: dbBackendCompute + - virtual_storage: rootVolume + - virtual_storage: dataVolume + - sw_image: mariaDbImage #FIXME + + serviceNode: + type: tosca.nodes.nfv.VDU + properties: + description: .. + configurable_properties: + additional_vnfc_configurable_properties: {} + requirements: + - virtual_compute: serviceNodeCompute + - sw_image: mariaDbImage + + dbBackendCompute: + type: tosca.nodes.nfv.VirtualCompute + properties: + virtual_memory: + virtual_mem_size: 8096 MB + virtual_cpu: + cpu_architecture: x86 + num_virtual_cpu: 2 + virtual_cpu_clock: 1800 MHz + + serviceNodeCompute: + type: tosca.nodes.nfv.VirtualCompute + properties: + virtual_memory: + virtual_mem_size: 8096 MB + virtual_cpu: + cpu_architecture: x86 + num_virtual_cpu: 2 + virtual_cpu_clock: 1800 MHz + + rootVolume: + type: tosca.nodes.nfv.VirtualStorage + properties: + type_of_storage: volume + size_of_storage: 10 GB + #rdma_enabled: false + requirements: + - sw_image: mariaDbImage + + dataVolume: + type: tosca.nodes.nfv.VirtualStorage + properties: + type_of_storage: volume + size_of_storage: 1 GB + #rdma_enabled: false + requirements: + - sw_image: mariaDbImage + + mariaDbImage: + type: tosca.nodes.nfv.SwImage + properties: + name: Software of Maria Db + version: 1.0 + checksum: 9af30fce37a4c5c831e095745744d6d2 + container_format: qcow2 + disk_format: bare + # the ubuntu image is minimum 4GB the Centos is minimum 8 GB ? + min_disk: 10 GB + min_ram: 8096 MB + size: 10 GB + sw_image: maria.db.image.v1.0.qcow2 + operating_system: Linux + supported_virtualisation_environments: + - KVM + + dbBackendCpOnIpv4: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: Connection point to access the DB on IPv4 externally + requirements: + - virtual_binding: dbBackend + - virtual_link: internalNetworkForFloatingIp + + dbBackendCpOnIpv6: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv6 + role: leaf + description: Connection point to access the DB on IPv6 externally + requirements: + - virtual_binding: dbBackend + #- virtual_link: the CP is connected to the core network (IPv6) + + dbBackendCpOnIpv4Redundancy1: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: Connection point for DB replication + requirements: + - virtual_binding: dbBackend + - virtual_link: internalReplicationNetwork1 + + dbBackendCpOnIpv4Redundancy2: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: Connection point for DB replication + requirements: + - virtual_binding: dbBackend + - virtual_link: internalReplicationNetwork2 + + dbBackendExternallyManagedCp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv6 + role: leaf + description: Connection point to access the DB on IPv6 externally + requirements: + - virtual_binding: dbBackend + - virtual_link: extManagedVl + + serviceNodeCp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: Connection point to access the DB on IPv4 externally + requirements: + - virtual_binding: serviceNode + - virtual_link: internalNetworkForFloatingIp + + serviceNodeExternallyManagedCp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: External connection point to access the DB on IPv4 + requirements: + - virtual_binding: dbBackend + - virtual_link: extManagedVl + + movingIpCp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + role: leaf + description: Moving IP + requirements: + #- virtual_binding: # no corresponding VDU + - virtual_link: internalNetworkForFloatingIp + internalNetworkForFloatingIp: + type: tosca.nodes.nfv.VL + properties: + connectivity_type: + layer_protocol: ipv4 + flow_pattern: mesh + vl_flavours: {} + + internalReplicationNetwork1: + type: tosca.nodes.nfv.VL + properties: + connectivity_type: + layer_protocol: ipv4 + flow_pattern: mesh + test_access: [] + description: .. + vl_flavours: {} + + internalReplicationNetwork2: + type: tosca.nodes.nfv.VL + properties: + connectivity_type: + layer_protocol: ipv4 + flow_pattern: mesh + test_access: [] + description: .. + vl_flavours: {} + + extManagedVl: + type: tosca.nodes.nfv.VL + properties: + connectivity_type: + layer_protocol: ipv4 + flow_pattern: mesh + test_access: [] + description: .. + vl_flavours: {} + + dbBackendIpv4: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv4 + requirements: + - internal_connection_point: dbBackendCpOnIpv4 + #- external_virtual_link: # exposed on VNF boundary + + dbBackendIpv6: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv6 + requirements: + - internal_connection_point: dbBackendCpOnIpv6 + #- external_virtual_link: # exposed on VNF boundary + + serviceNodeIpv4: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv4 + requirements: + - internal_connection_point: serviceNodeCp + #- external_virtual_link: # exposed on VNF boundary + + loadBalancer: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv4 + requirements: + - internal_connection_point: movingIpCp + #- external_virtual_link: # exposed on VNF boundary + + groups: + dbBackendScalingGroup: + type: tosca.groups.nfv.ElementGroup + description: .. + members: [ dbBackend ] + + serviceNodeScalingGroup: + type: tosca.groups.nfv.ElementGroup + description: .. + members: [ serviceNode ] + + policies: + - service_node_anti_affinity: + type: tosca.policies.nfv.ScalingStepLocalAntiAffinity + targets: [ serviceNode ] + properties: + scope: nfvi_node + + - backend_node_anti_affinity: + type: tosca.policies.nfv.LocalAntiAffinity + targets: [ dbBackend ] + properties: + scope: nfvi_node + + - nfvi_affinity: + type: tosca.policies.nfv.LocalAffinity + targets: [ dbBackend ] + properties: + scope: nfvi + + - zone_affinity: + type: tosca.policies.nfv.LocalAffinity + targets: [ dbBackend ] + properties: + scope: resource_zone_group + + - commissioning: + type: tosca.policies.nfv.Commissioning #FIXME + properties: + connection_points: + - dbBackendIpv6 + - serviceNodeIpv4 + + - heat_mapping: + type: tosca.policies.nfv.HeatMapping + properties: + template: + hotPath: hot/ + main: maria.hot.scalable.main.nated.yaml + nested: + - maria.hot.common.nated.yaml + - maria.hot.scalable.service.scaling.nated.yaml + - maria.hot.scalable.service.static.nated.yaml + - maria.hot.scalable.service.nated.yaml + - maria.hot.scalable.backend.static.nated.yaml + - maria.hot.scalable.backend.single.nated.yaml + - maria.hot.scalable.backend.nated.yaml + - maria.hot.scalable.backend.single.wrapper.nated.yaml + - maria.hot.scalable.backend.wrapper.nated.yaml +# environment: + static: + virtualLinks: + internalReplicationNetwork1: db_backend_static.replication_network_1 + internalReplicationNetwork2: db_backend_static.replication_network_2 + internalNetworkForFloatingIp: common_resources.internal_network_for_floatingip + vdus: + dbBackend: + - heatResource: db_backend_static.static_node_0.wrapper_rg.0.server + connectionPoints: + dbBackendCpOnIpv4: db_backend_static.static_node_0.wrapper_rg.0.port_ipv4_nated + dbBackendCpOnIpv6: db_backend_static.static_node_0.wrapper_rg.0.port_ipv6 + dbBackendCpOnIpv4Redundancy1: db_backend_static.static_node_0.wrapper_rg.0.port_replication_1 + dbBackendCpOnIpv4Redundancy2: db_backend_static.static_node_0.wrapper_rg.0.port_replication_2 + dbBackendExternallyManagedCp: db_backend_static.static_node_0.wrapper_rg.0.port_internal_ext_managed + virtualStorages: + rootVolume: db_backend_static.static_node_0.wrapper_rg.0.volume_root + dataVolume: db_backend_static.static_node_0.wrapper_rg.0.volume_data + externalConnectionPoints: + dbBackendIpv4: + - db_backend_static.static_node_0.wrapper_rg.0.floating_ip + dbBackendIpv6: + - db_backend_static.static_node_0.wrapper_rg.0.port_ipv6 + - heatResource: db_backend_static.static_node_1.wrapper_rg.0.server + connectionPoints: + dbBackendCpOnIpv4: db_backend_static.static_node_1.wrapper_rg.0.port_ipv4_nated + dbBackendCpOnIpv6: db_backend_static.static_node_1.wrapper_rg.0.port_ipv6 + dbBackendCpOnIpv4Redundancy1: db_backend_static.static_node_1.wrapper_rg.0.port_replication_1 + dbBackendCpOnIpv4Redundancy2: db_backend_static.static_node_1.wrapper_rg.0.port_replication_2 + dbBackendExternallyManagedCp: db_backend_static.static_node_1.wrapper_rg.0.port_internal_ext_managed + virtualStorages: + rootVolume: db_backend_static.static_node_1.wrapper_rg.0.volume_root + dataVolume: db_backend_static.static_node_1.wrapper_rg.0.volume_data + externalConnectionPoints: + dbBackendIpv4: + - db_backend_static.static_node_1.wrapper_rg.0.floating_ip + dbBackendIpv6: + - db_backend_static.static_node_1.wrapper_rg.0.port_ipv6 + - heatResource: db_backend_static.static_node_2.wrapper_rg.0.server + connectionPoints: + dbBackendCpOnIpv4: db_backend_static.static_node_2.wrapper_rg.0.port_ipv4_nated + dbBackendCpOnIpv6: db_backend_static.static_node_2.wrapper_rg.0.port_ipv6 + dbBackendCpOnIpv4Redundancy1: db_backend_static.static_node_2.wrapper_rg.0.port_replication_1 + dbBackendCpOnIpv4Redundancy2: db_backend_static.static_node_2.wrapper_rg.0.port_replication_2 + dbBackendExternallyManagedCp: db_backend_static.static_node_2.wrapper_rg.0.port_internal_ext_managed + virtualStorages: + rootVolume: db_backend_static.static_node_2.wrapper_rg.0.volume_root + dataVolume: db_backend_static.static_node_2.wrapper_rg.0.volume_data + externalConnectionPoints: + dbBackendIpv4: + - db_backend_static.static_node_2.wrapper_rg.0.floating_ip + dbBackendIpv6: + - db_backend_static.static_node_2.wrapper_rg.0.port_ipv6 + externalConnectionPoints: + loadBalancer: + - service_node_static.moving_ip_floating_ip + aspects: + dbBackendAspect: + heatResource: db_backend_aspect_group + vdus: + dbBackend: + - heatResource: wrapper_rg.0.server + connectionPoints: + dbBackendCpOnIpv4: wrapper_rg.0.port_ipv4_nated + dbBackendCpOnIpv6: wrapper_rg.0.port_ipv6 + dbBackendCpOnIpv4Redundancy1: wrapper_rg.0.port_replication_1 + dbBackendCpOnIpv4Redundancy2: wrapper_rg.0.port_replication_2 + dbBackendExternallyManagedCp: wrapper_rg.0.port_internal_ext_managed + virtualStorages: + rootVolume: wrapper_rg.0.volume_root + dataVolume: wrapper_rg.0.volume_data + externalConnectionPoints: + dbBackendIpv4: + - wrapper_rg.0.floating_ip + dbBackendIpv6: + - wrapper_rg.0.port_ipv6 + serviceNodeAspect: + heatResource: service_node_aspect_group + affinity: + local: + - type: same + place: vim + resources: [node_a.server, node_b.server] + - type: same + place: zone + resources: [node_a.server, node_b.server] + - type: different + place: host + resources: [node_a.server, node_b.server] + vdus: + serviceNode: + - heatResource: node_a.server + connectionPoints: + serviceNodeCp: node_a.port_ipv4_nated + serviceNodeExternallyManagedCp: node_a.port_internal_ext_managed + externalConnectionPoints: + serviceNodeIpv4: + - node_a.floating_ip + - heatResource: node_b.server + connectionPoints: + serviceNodeCp: node_b.port_ipv4_nated + serviceNodeExternallyManagedCp: node_b.port_internal_ext_managed + externalConnectionPoints: + serviceNodeIpv4: + - node_b.floating_ip diff --git a/nokiav2/driver/src/test/resources/unittests/missing.vnfd.zip b/nokiav2/driver/src/test/resources/unittests/missing.vnfd.zip Binary files differnew file mode 100644 index 00000000..cfabc407 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/missing.vnfd.zip diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.modified.vnfd.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.modified.vnfd.yaml new file mode 100644 index 00000000..83f1ea35 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.modified.vnfd.yaml @@ -0,0 +1,87 @@ +--- +tosca_definitions_version: "tosca_simple_profile_for_nfv_1_0_0_nokia" +topology_template: + substitution_mappings: + node_type: "tosca.nodes.nfv.VNF" + capabilities: + vnf: + properties: + modifiable_attributes: + extensions: + existingAttribute: + default: "value" + onapCsarId: + default: "kuku" + vimId: + default: "kuku" + interfaces: + Basic: + instantiate: + inputs: + extensions: + pre_actions: + - javascript: "pre" + include: + - "javascript/scalable_prepare_cbam_include.js" + output: "stack_parameters" + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "post" + output: "ansible_inventory" + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + kuku: "muku" + jobId: "kuku" + terminate: + inputs: + extensions: + pre_actions: + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + jobId: "kuku" + Scalable: + scale: + inputs: + extensions: + pre_actions: + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + jobId: "kuku" + Healable: + heal: + inputs: + extensions: + pre_actions: + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + jobId: "kuku" diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.original.vnfd.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.original.vnfd.yaml new file mode 100644 index 00000000..42569b04 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.full.original.vnfd.yaml @@ -0,0 +1,33 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + capabilities: + vnf: + properties: + modifiable_attributes: + extensions: + existingAttribute: + default: "value" + interfaces: + Basic: + instantiate: + inputs: + extensions: + pre_actions: + - javascript: pre + include: + - javascript/scalable_prepare_cbam_include.js + output: stack_parameters + post_actions: + - javascript: post + output: ansible_inventory + additional_parameters: + kuku: muku + terminate: + Scalable: + scale: + Healable: + heal: + diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.modified.vnfd.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.modified.vnfd.yaml new file mode 100644 index 00000000..2b05ecf1 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.modified.vnfd.yaml @@ -0,0 +1,46 @@ +--- +tosca_definitions_version: "tosca_simple_profile_for_nfv_1_0_0_nokia" +topology_template: + substitution_mappings: + node_type: "tosca.nodes.nfv.VNF" + interfaces: + Basic: + instantiate: + inputs: + extensions: + pre_actions: + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + jobId: "kuku" + terminate: + inputs: + extensions: + pre_actions: + - javascript: "javascript/cbam.pre.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + post_actions: + - javascript: "javascript/cbam.post.collectConnectionPoints.js" + include: + - "javascript/cbam.collectConnectionPoints.js" + output: "operation_result" + additional_parameters: + jobId: "kuku" + capabilities: + vnf: + properties: + modifiable_attributes: + extensions: + onapCsarId: + default: "kuku" + vimId: + default: "kuku" diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.original.vnfd.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.original.vnfd.yaml new file mode 100644 index 00000000..7709793c --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.minimal.original.vnfd.yaml @@ -0,0 +1,9 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + interfaces: + Basic: + instantiate: + terminate: diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip Binary files differnew file mode 100644 index 00000000..ac555dff --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip.vnfd b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip.vnfd new file mode 100644 index 00000000..3c121386 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/cbam.package.zip.vnfd @@ -0,0 +1,17 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + properties: + descriptor_id: Nokia~Maria DB~1.0~1.0 + descriptor_version: '1.0' + provider: Nokia + product_name: Maria DB + software_version: '1.0' + product_info_name: Maria DB + product_info_description: Relational database, non-scalable + interfaces: + Basic: + instantiate: + terminate: diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.cbam.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.cbam.yaml new file mode 100644 index 00000000..45bfb73f --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.cbam.yaml @@ -0,0 +1,11 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + properties: + descriptor_version: '1.0' + provider: myProvider + product_name: 'myName' + software_version: '2.0' + product_info_name: product_info_name
\ No newline at end of file diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.onap.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.onap.yaml new file mode 100644 index 00000000..1cbc8ef7 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/empty.vnfd.onap.yaml @@ -0,0 +1,14 @@ +tosca_definitions_version: tosca_simple_yaml_1_0 + +metadata: + vendor: Nokia + csarVersion: 1.0 + csarProvider: myProvider + id: Simple + version: 2.0 + csarType: NFAR + name: myName + vnfdVersion: 1.0 + +topology_template: + node_templates: diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.cbam.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.cbam.yaml new file mode 100644 index 00000000..a5e18eec --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.cbam.yaml @@ -0,0 +1,85 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + properties: + descriptor_version: '1.0' + provider: myProvider + product_name: 'myName' + software_version: '2.0' + product_info_name: product_info_name + node_templates: + vduNode: + type: tosca.nodes.nfv.VDU + properties: + description: myVduDesc + requirements: + - virtual_compute: myCompute + - virtual_storage: myStorage1 + - virtual_storage: myStorage2 + + + myCompute: + type: tosca.nodes.nfv.VirtualCompute + properties: + virtual_memory: + virtual_mem_size: 8192 MB + virtual_cpu: + num_virtual_cpu: 4 + virtual_cpu_clock: 1234 Mhz + myStorage1: + type: tosca.nodes.nfv.VirtualStorage + properties: + id: myStorage1 + size_of_storage: 1G + + myStorage2: + type: tosca.nodes.nfv.VirtualStorage + properties: + id: myStorage2 + size_of_storage: 2G + + myNetwork1: + type: tosca.nodes.nfv.VL + + myNetwork2: + type: tosca.nodes.nfv.VL + + icpWithOutEcp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + description: myDescription + requirements: + - virtual_binding: vduNode + - virtual_link: myNetwork1 + + icpWithEcp: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + description: myDescription + requirements: + - virtual_binding: vduNode + - virtual_link: myNetwork1 + + myEcp: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv4 + requirements: + - internal_connection_point: icpWithEcp + + icpWithOutVdu: + type: tosca.nodes.nfv.ICP + properties: + layer_protocol: ipv4 + description: myDescription + + ecpWithIcpWithOutVdu: + type: tosca.nodes.nfv.ECP + properties: + layer_protocol: ipv4 + requirements: + - internal_connection_point: icpWithOutVdu
\ No newline at end of file diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.inconsistent.cbam.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.inconsistent.cbam.yaml new file mode 100644 index 00000000..abb1243f --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.inconsistent.cbam.yaml @@ -0,0 +1,18 @@ +tosca_definitions_version: tosca_simple_profile_for_nfv_1_0_0_nokia + +topology_template: + substitution_mappings: + node_type: tosca.nodes.nfv.VNF + properties: + descriptor_version: '1.0' + provider: myProvider + product_name: 'myName' + software_version: '2.0' + product_info_name: product_info_name + node_templates: + vduNode: + type: tosca.nodes.nfv.VDU + properties: + description: myVduDesc + requirements: + - virtual_compute: myComputeMissing diff --git a/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.onap.yaml b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.onap.yaml new file mode 100644 index 00000000..ddb96bf0 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/packageconverter/nodes.vnfd.onap.yaml @@ -0,0 +1,80 @@ +tosca_definitions_version: tosca_simple_yaml_1_0 + +metadata: + vendor: Nokia + csarVersion: 1.0 + csarProvider: myProvider + id: Simple + version: 2.0 + csarType: NFAR + name: myName + vnfdVersion: 1.0 + +topology_template: + node_templates: + vduNode: + type: tosca.nodes.nfv.VDU.Compute + capabilities: + virtual_compute: + properties: + virtual_memory: + virtual_mem_size: 8192 MB + virtual_cpu: + num_virtual_cpu: 4 + requirements: + - virtual_storage: + capability: tosca.capabilities.nfv.VirtualStorage + node: myStorage1 + - virtual_storage: + capability: tosca.capabilities.nfv.VirtualStorage + node: myStorage2 + myStorage1: + type: tosca.nodes.nfv.VDU.VirtualStorage + properties: + id: myStorage1 + type_of_storage: volume + size_of_storage: 1G + myStorage2: + type: tosca.nodes.nfv.VDU.VirtualStorage + properties: + id: myStorage2 + type_of_storage: volume + size_of_storage: 2G + myNetwork1: + type: tosca.nodes.nfv.VnfVirtualLinkDesc + properties: + vl_flavours: + flavours: + flavourId: notUsed + myNetwork2: + type: tosca.nodes.nfv.VnfVirtualLinkDesc + properties: + vl_flavours: + flavours: + flavourId: notUsed + icpWithOutEcp: + type: tosca.nodes.nfv.VduCpd + properties: + layer_protocol: ipv4 + role: leaf + description: myDescription + requirements: + - virtual_binding: vduNode + - virtual_link: myNetwork1 + icpWithEcp: + type: tosca.nodes.nfv.VduCpd + properties: + layer_protocol: ipv4 + role: leaf + description: myDescription + requirements: + - virtual_binding: vduNode + - virtual_link: myNetwork1 + myEcp: + type: tosca.nodes.nfv.VduCpd + properties: + layer_protocol: ipv4 + role: leaf + description: myDescription + requirements: + - virtual_binding: vduNode diff --git a/nokiav2/driver/src/test/resources/unittests/sample.cert.pem b/nokiav2/driver/src/test/resources/unittests/sample.cert.pem new file mode 100644 index 00000000..0e41d269 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/sample.cert.pem @@ -0,0 +1,14 @@ +-----BEGIN CERTIFICATE----- +MIICEjCCAXsCAg36MA0GCSqGSIb3DQEBBQUAMIGbMQswCQYDVQQGEwJKUDEOMAwG +A1UECBMFVG9reW8xEDAOBgNVBAcTB0NodW8ta3UxETAPBgNVBAoTCEZyYW5rNERE +MRgwFgYDVQQLEw9XZWJDZXJ0IFN1cHBvcnQxGDAWBgNVBAMTD0ZyYW5rNEREIFdl +YiBDQTEjMCEGCSqGSIb3DQEJARYUc3VwcG9ydEBmcmFuazRkZC5jb20wHhcNMTIw +ODIyMDUyNjU0WhcNMTcwODIxMDUyNjU0WjBKMQswCQYDVQQGEwJKUDEOMAwGA1UE +CAwFVG9reW8xETAPBgNVBAoMCEZyYW5rNEREMRgwFgYDVQQDDA93d3cuZXhhbXBs +ZS5jb20wXDANBgkqhkiG9w0BAQEFAANLADBIAkEAm/xmkHmEQrurE/0re/jeFRLl +8ZPjBop7uLHhnia7lQG/5zDtZIUC3RVpqDSwBuw/NTweGyuP+o8AG98HxqxTBwID +AQABMA0GCSqGSIb3DQEBBQUAA4GBABS2TLuBeTPmcaTaUW/LCB2NYOy8GMdzR1mx +8iBIu2H6/E2tiY3RIevV2OW61qY2/XRQg7YPxx3ffeUugX9F4J/iPnnu1zAxxyBy +2VguKv4SWjRFoRkIfIlHX0qVviMhSlNy2ioFLy7JcPZb+v3ftDGywUqcBiVDoea0 +Hn+GmxZA +-----END CERTIFICATE-----
\ No newline at end of file diff --git a/nokiav2/driver/src/test/resources/unittests/vnfd.full.yaml b/nokiav2/driver/src/test/resources/unittests/vnfd.full.yaml new file mode 100644 index 00000000..460f7f10 --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/vnfd.full.yaml @@ -0,0 +1,24 @@ +topology_template: + substitution_mappings: + capabilities: + deployment_flavour: + properties: + flavour_id: myFlavorId + instantiation_levels: + level1: + vdu_levels: + vdu1: + number_of_instances: 1 + vdu2: + number_of_instances: 2 + level2: + vdu_levels: + vdu1: + number_of_instances: 2 + interfaces: + Basic: + scale: + inputs: + additional_parameters: + jobId: kuku + a: valueInVnfd
\ No newline at end of file diff --git a/nokiav2/driver/src/test/resources/unittests/vnfd.instantiation.yaml b/nokiav2/driver/src/test/resources/unittests/vnfd.instantiation.yaml new file mode 100644 index 00000000..ef858dbc --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/vnfd.instantiation.yaml @@ -0,0 +1,16 @@ +topology_template: + substitution_mappings: + capabilities: + deployment_flavour: + properties: + instantiation_levels: + level1: + vdu_levels: + vdu1: + number_of_instances: 1 + vdu2: + number_of_instances: 2 + level2: + vdu_levels: + vdu1: + number_of_instances: 2 diff --git a/nokiav2/driver/src/test/resources/unittests/vnfd.scale.yaml b/nokiav2/driver/src/test/resources/unittests/vnfd.scale.yaml new file mode 100644 index 00000000..478fedaf --- /dev/null +++ b/nokiav2/driver/src/test/resources/unittests/vnfd.scale.yaml @@ -0,0 +1,12 @@ +topology_template: + policies: + - heat_mapping: + properties: + aspects: + aspect1: + vdus: + vdu1: + - heatResource: wrapper_rg.0.server + - heatResource: wrapper_rg.1.server + vdu2: + - heatResource: wrapper_rg2.0.server
\ No newline at end of file |