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

   1 /*
   2  * Copyright 2016-2017, Nokia Corporation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core;
  17
  18 import com.google.common.collect.Lists;
  19 import com.nokia.cbam.lcn.v32.model.CreateSubscriptionRequest;
  20 import com.nokia.cbam.lcn.v32.model.Subscription;
  21 import com.nokia.cbam.lcn.v32.model.SubscriptionAuthentication;
  22 import com.nokia.cbam.lcn.v32.model.VnfNotificationType;
  23 import io.reactivex.Observable;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.UUID;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29 import org.mockito.ArgumentCaptor;
  30 import org.mockito.InOrder;
  31 import org.mockito.Mock;
  32 import org.mockito.Mockito;
  33 import org.mockito.invocation.InvocationOnMock;
  34 import org.mockito.stubbing.Answer;
  35 import org.onap.msb.model.MicroServiceFullInfo;
  36 import org.onap.msb.model.MicroServiceInfo;
  37 import org.onap.msb.model.Node;
  38 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
  39 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.JobManager;
  40 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.TestBase;
  41
  42 import static com.google.common.collect.Sets.newHashSet;
  43 import static com.nokia.cbam.lcn.v32.model.OperationType.*;
  44 import static junit.framework.TestCase.*;
  45 import static org.mockito.Mockito.*;
  46 import static org.onap.msb.model.MicroServiceInfo.ProtocolEnum.REST;
  47 import static org.onap.msb.model.MicroServiceInfo.VisualRangeEnum._1;
  48 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager.DRIVER_VERSION;
  49 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager.SERVICE_NAME;
  50 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCN_API_VERSION;
  51 import static org.springframework.test.util.ReflectionTestUtils.setField;
  52
  53 public class TestSelfRegistrationManager extends TestBase {
  54     @Mock
  55     private JobManager jobManager;
  56     private java.util.List<Subscription> subscriptions = new ArrayList<>();
  57     private ArgumentCaptor<MicroServiceInfo> registeredMicroservice = ArgumentCaptor.forClass(MicroServiceInfo.class);
  58     private ArgumentCaptor<CreateSubscriptionRequest> subscriptionToCreate = ArgumentCaptor.forClass(CreateSubscriptionRequest.class);
  59     private SelfRegistrationManager selfRegistrationManager;
  60
  61     @Before
  62     public void initMocks() throws Exception {
  63         selfRegistrationManager = new SelfRegistrationManager(vnfmInfoProvider, msbApiProvider, cbamRestApiProvider);
  64
  65         setField(SelfRegistrationManager.class, "logger", logger);
  66         when(lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)).thenReturn(buildObservable(subscriptions));
  67         setField(selfRegistrationManager, "driverMsbExternalIp", "1.2.3.4");
  68         setField(selfRegistrationManager, "driverVnfmExternalIp", "5.6.7.8");
  69         setField(selfRegistrationManager, "driverPort", "12345");
  70         Subscription unknownSubscription = new Subscription();
  71         unknownSubscription.setId(UUID.randomUUID().toString());
  72         unknownSubscription.setCallbackUrl("unknown");
  73         subscriptions.add(unknownSubscription);
  74     }
  75
  76     /**
  77      * test the basic registration process
  78      * - first subscribe to CBAM LCNs
  79      * - second publish it's existence on MSB
  80      */
  81     @Test
  82     public void testRegistration() throws Exception {
  83         //given
  84         Subscription subscription = new Subscription();
  85         subscription.setId(SUBCRIPTION_ID);
  86         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
  87         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenReturn(buildObservable(subscription));
  88         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
  89         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenReturn(buildObservable(returnedMicroService));
  90         //when
  91         selfRegistrationManager.register();
  92         //verify
  93         InOrder registrationOrder = Mockito.inOrder(lcnApi, msbClient);
  94         registrationOrder.verify(lcnApi).subscriptionsPost(any(), any());
  95         registrationOrder.verify(msbClient).addMicroService(any(), any(), any());
  96         assertEquals(VNFM_ID, selfRegistrationManager.getVnfmId(SUBCRIPTION_ID));
  97         assertMicroserviceRegistered();
  98         assertNewLcnSubscription();
  99         assertServiceUp();
 100     }
 101
 102     private void assertNewLcnSubscription() {
 103         CreateSubscriptionRequest subscriptionCreation = subscriptionToCreate.getValue();
 104         assertEquals("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn", subscriptionCreation.getCallbackUrl());
 105         assertEquals(SubscriptionAuthentication.TypeEnum.NONE, subscriptionCreation.getAuthentication().getType());
 106         assertNull(subscriptionCreation.getAuthentication().getUserName());
 107         assertNull(subscriptionCreation.getAuthentication().getClientName());
 108         assertNull(subscriptionCreation.getAuthentication().getClientPassword());
 109         assertNull(subscriptionCreation.getAuthentication().getPassword());
 110         assertNull(subscriptionCreation.getAuthentication().getTokenUrl());
 111         assertNull(subscriptionCreation.getFilter().getVnfdId());
 112         assertNull(subscriptionCreation.getFilter().getVnfInstanceId());
 113         assertNull(subscriptionCreation.getFilter().getVnfProductName());
 114         assertNull(subscriptionCreation.getFilter().getVnfSoftwareVersion());
 115         assertEquals(Lists.newArrayList(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION), subscriptionCreation.getFilter().getNotificationTypes());
 116         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(HEAL));
 117         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(SCALE));
 118         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(TERMINATE));
 119         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(INSTANTIATE));
 120         assertEquals(4, subscriptionCreation.getFilter().getOperationTypes().size());
 121         verify(logger).info("Subscribing to CBAM LCN {} with callback to {}", HTTP_LCN_URL, "http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 122     }
 123
 124     private void assertMicroserviceRegistered() {
 125         MicroServiceInfo microserviceRequest = registeredMicroservice.getValue();
 126         assertEquals(1, microserviceRequest.getNodes().size());
 127         Node node = microserviceRequest.getNodes().iterator().next();
 128         assertEquals("0", node.getTtl());
 129         assertEquals("1.2.3.4", node.getIp());
 130         assertEquals("12345", node.getPort());
 131         assertEquals(REST, microserviceRequest.getProtocol());
 132         assertNull(microserviceRequest.getMetadata());
 133         //very strange, but it should be null for ONAP to work
 134         assertEquals(SERVICE_NAME, microserviceRequest.getServiceName());
 135         assertEquals("/api/NokiaSVNFM/v1", microserviceRequest.getUrl());
 136         assertEquals("v1", microserviceRequest.getVersion());
 137         assertEquals(Boolean.FALSE, microserviceRequest.isEnableSsl());
 138         //1 means internal service to ONAP
 139         assertEquals(_1, microserviceRequest.getVisualRange());
 140     }
 141
 142     /**
 143      * If the subscription already exists the subscription is not recreated
 144      */
 145     @Test
 146     public void testResubscription() throws Exception {
 147         //given
 148         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 149         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenReturn(buildObservable(returnedMicroService));
 150         Subscription existingSubscription = new Subscription();
 151         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 152         existingSubscription.setId(UUID.randomUUID().toString());
 153         existingSubscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 154         subscriptions.add(existingSubscription);
 155         //when
 156         selfRegistrationManager.register();
 157         //verify
 158         assertMicroserviceRegistered();
 159         verify(lcnApi, never()).subscriptionsPost(any(), any());
 160         assertServiceUp();
 161     }
 162
 163     /**
 164      * If the LCN subscription fails the microservice is not registered
 165      */
 166     @Test
 167     public void testFailedLcnSubscription() throws Exception {
 168         //given
 169         RuntimeException expectedException = new RuntimeException();
 170         when(lcnApi.subscriptionsPost(any(), any())).thenThrow(expectedException);
 171         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 172         //when
 173         try {
 174             selfRegistrationManager.register();
 175             fail();
 176         } catch (RuntimeException e) {
 177             assertEquals(expectedException, e.getCause());
 178         }
 179         //verify
 180         verify(msbClient, never()).addMicroService(any(), any(), any());
 181         verify(logger).error("Unable to subscribe to CBAM LCN", expectedException);
 182         assertServiceDown();
 183     }
 184
 185     /**
 186      * If the registration to MSB fails the subscription is deleted
 187      */
 188     @Test
 189     public void testFailedMsbPublish() throws Exception {
 190         //given
 191         Subscription subscription = new Subscription();
 192         subscription.setId(SUBCRIPTION_ID);
 193         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 194         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
 195             subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 196             subscription.setId(UUID.randomUUID().toString());
 197             subscriptions.add(subscription);
 198             when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 199             return buildObservable(subscription);
 200         });
 201         RuntimeException expectedException = new RuntimeException();
 202         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenThrow(expectedException);
 203         //when
 204         try {
 205             selfRegistrationManager.register();
 206             //verify
 207             fail();
 208         } catch (RuntimeException e) {
 209             assertEquals(expectedException, e.getCause());
 210         }
 211         assertNewLcnSubscription();
 212         verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 213         assertServiceDown();
 214     }
 215
 216     /**
 217      * basic service unregistration
 218      * - ongoing jobs are outwaited
 219      * - first the service is removed from MSB
 220      * - second unregistration
 221      */
 222     @Test
 223     public void testUnregistration() throws Exception {
 224         //given
 225         Subscription subscription = new Subscription();
 226         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 227         subscription.setId(SUBCRIPTION_ID);
 228         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 229         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
 230             subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 231             subscription.setId(UUID.randomUUID().toString());
 232             subscriptions.add(subscription);
 233             when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 234             return buildObservable(subscription);
 235         });
 236         selfRegistrationManager.assureSubscription(VNFM_ID);
 237         when(jobManager.hasOngoingJobs()).thenReturn(false);
 238         when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 239         VoidObservable MSB_DELETE = new VoidObservable();
 240         when(msbClient.deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null)).thenReturn(MSB_DELETE.value());
 241         //when
 242         selfRegistrationManager.deRegister();
 243         //verify
 244         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 245         inOrder.verify(msbClient).deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null);
 246         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 247         assertServiceDown();
 248         VOID_OBSERVABLE.assertCalled();
 249         MSB_DELETE.assertCalled();
 250         verify(logger).info("Deleting subscription with {} identifier", subscription.getId());
 251     }
 252
 253     /**
 254      * if the MSB reports that it could not cancel the service, but the service has
 255      * disappeared from MSB the cancellation is considered to be successful
 256      */
 257     @Test
 258     public void testPartiallyFailedMsbCancel() throws Exception {
 259         //given
 260         Subscription subscription = new Subscription();
 261         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 262         subscription.setId(SUBCRIPTION_ID);
 263         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 264         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
 265             subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 266             subscription.setId(UUID.randomUUID().toString());
 267             subscriptions.add(subscription);
 268             when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 269             return buildObservable(subscription);
 270         });
 271         selfRegistrationManager.assureSubscription(VNFM_ID);
 272         when(jobManager.hasOngoingJobs()).thenReturn(false);
 273         when(msbClient.deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null)).then(new Answer<Observable<Void>>() {
 274             @Override
 275             public Observable<Void> answer(InvocationOnMock invocationOnMock) throws Throwable {
 276                 when(msbClient.getMicroService_0(SERVICE_NAME, DRIVER_VERSION, null, null, null, null, null)).thenThrow(new RuntimeException());
 277                 throw new RuntimeException();
 278             }
 279         });
 280         when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 281         //when
 282         selfRegistrationManager.deRegister();
 283         //verify
 284         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 285         inOrder.verify(msbClient).deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null);
 286         inOrder.verify(msbClient).getMicroService_0(SERVICE_NAME, DRIVER_VERSION, null, null, null, null, null);
 287         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 288         assertServiceDown();
 289         VOID_OBSERVABLE.assertCalled();
 290     }
 291
 292     /**
 293      * failure of unregistration from MSB should be propagated
 294      */
 295     @Test
 296     public void testUnregistrationFailure() throws Exception {
 297         //given
 298         Subscription subscription = new Subscription();
 299         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 300         subscription.setId(SUBCRIPTION_ID);
 301         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 302         subscriptions.add(subscription);
 303         when(msbClient.deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null)).then(new Answer<Observable<Void>>() {
 304             @Override
 305             public Observable<Void> answer(InvocationOnMock invocationOnMock) throws Throwable {
 306                 throw new RuntimeException();
 307             }
 308         });
 309         //when
 310         try {
 311             selfRegistrationManager.deRegister();
 312             fail();
 313         } catch (RuntimeException e) {
 314
 315         }
 316         //verify
 317         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 318         inOrder.verify(msbClient).deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null);
 319         inOrder.verify(msbClient).getMicroService_0(SERVICE_NAME, DRIVER_VERSION, null, null, null, null, null);
 320         verify(lcnApi, Mockito.never()).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 321         assertServiceDown();
 322     }
 323
 324     /**
 325      * failure of subscription deletion from MSB should be propagated
 326      */
 327     @Test
 328     public void testSubscriptionFailure() throws Exception {
 329         //given
 330         Subscription subscription = new Subscription();
 331         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 332         subscription.setId(SUBCRIPTION_ID);
 333         when(vnfmInfoProvider.getVnfms()).thenReturn(newHashSet(VNFM_ID));
 334         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
 335             subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 336             subscription.setId(UUID.randomUUID().toString());
 337             subscriptions.add(subscription);
 338             when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
 339             return buildObservable(subscription);
 340         });
 341         selfRegistrationManager.assureSubscription(VNFM_ID);
 342         when(jobManager.hasOngoingJobs()).thenReturn(false);
 343         RuntimeException expectedException = new RuntimeException();
 344         doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 345         when(msbClient.deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null)).thenReturn(VOID_OBSERVABLE.value());
 346         //when
 347         try {
 348             selfRegistrationManager.deRegister();
 349             fail();
 350         } catch (RuntimeException e) {
 351
 352         }
 353         //verify
 354         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 355         inOrder.verify(msbClient).deleteMicroService(SERVICE_NAME, DRIVER_VERSION, null, null);
 356         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 357         assertServiceDown();
 358     }
 359
 360     /**
 361      * the swagger API definitions embedded in the code
 362      */
 363     @Test
 364     public void testSwaggerApi() throws Exception {
 365         //no idea how to test this except repeat implementation
 366         byte[] a = TestUtil.loadFile(SelfRegistrationManager.SWAGGER_API_DEFINITION);
 367         tearGeneric();
 368         //when
 369         assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition()));
 370     }
 371
 372     public void assertServiceUp() throws Exception {
 373         assertTrue(selfRegistrationManager.isReady());
 374     }
 375
 376     /**
 377      * if there are ongoing jobs then the guard thros exception
 378      */
 379     public void assertServiceDown() {
 380         assertFalse(selfRegistrationManager.isReady());
 381
 382     }
 383
 384 }