nokiav2/driver/src/test/java/org/onap/vfc/nfvo/driver/vnfm/svnfm/nokia/vnfm/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.vnfm;
  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.*;
  30 import org.mockito.invocation.InvocationOnMock;
  31 import org.mockito.stubbing.Answer;
  32 import org.onap.msb.model.MicroServiceFullInfo;
  33 import org.onap.msb.model.MicroServiceInfo;
  34 import org.onap.msb.model.Node;
  35 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager;
  36 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
  37
  38 import static com.nokia.cbam.lcn.v32.model.OperationType.*;
  39 import static junit.framework.TestCase.*;
  40 import static org.mockito.Matchers.any;
  41 import static org.mockito.Mockito.*;
  42 import static org.onap.msb.model.MicroServiceInfo.ProtocolEnum.REST;
  43 import static org.onap.msb.model.MicroServiceInfo.VisualRangeEnum._1;
  44 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCN_API_VERSION;
  45 import static org.springframework.test.util.ReflectionTestUtils.setField;
  46
  47 public class TestSelfRegistrationManager extends TestBase {
  48     @Mock
  49     private JobManager jobManager;
  50     private java.util.List<Subscription> subscriptions = new ArrayList<>();
  51     private ArgumentCaptor<MicroServiceInfo> registeredMicroservice = ArgumentCaptor.forClass(MicroServiceInfo.class);
  52     private ArgumentCaptor<CreateSubscriptionRequest> subscriptionToCreate = ArgumentCaptor.forClass(CreateSubscriptionRequest.class);
  53     @InjectMocks
  54     private SelfRegistrationManager selfRegistrationManager;
  55
  56     @Before
  57     public void initMocks() throws Exception {
  58         setField(SelfRegistrationManager.class, "logger", logger);
  59         when(lcnApi.subscriptionsGet(NOKIA_LCN_API_VERSION)).thenReturn(buildObservable(subscriptions));
  60         when(driverProperties.getVnfmId()).thenReturn(VNFM_ID);
  61         setField(selfRegistrationManager, "driverMsbExternalIp", "1.2.3.4");
  62         setField(selfRegistrationManager, "driverVnfmExternalIp", "5.6.7.8");
  63         setField(selfRegistrationManager, "driverPort", "12345");
  64         Subscription unknownSubscription = new Subscription();
  65         unknownSubscription.setId(UUID.randomUUID().toString());
  66         unknownSubscription.setCallbackUrl("unknown");
  67         subscriptions.add(unknownSubscription);
  68     }
  69
  70     /**
  71      * test the basic registration process
  72      * - first subscribe to CBAM LCNs
  73      * - second publish it's existence on MSB
  74      */
  75     @Test
  76     public void testRegistration() throws Exception {
  77         //given
  78         Subscription subscription = new Subscription();
  79         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenReturn(buildObservable(subscription));
  80         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
  81         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenReturn(buildObservable(returnedMicroService));
  82         //when
  83         selfRegistrationManager.register();
  84         //verify
  85         InOrder registrationOrder = Mockito.inOrder(lcnApi, msbClient);
  86         registrationOrder.verify(lcnApi).subscriptionsPost(any(), any());
  87         registrationOrder.verify(msbClient).addMicroService(any(), any(), any());
  88
  89         assertMicroserviceRegistered();
  90         assertNewLcnSubscription();
  91         assertServiceUp();
  92     }
  93
  94     private void assertNewLcnSubscription() {
  95         CreateSubscriptionRequest subscriptionCreation = subscriptionToCreate.getValue();
  96         assertEquals("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn", subscriptionCreation.getCallbackUrl());
  97         assertEquals(SubscriptionAuthentication.TypeEnum.NONE, subscriptionCreation.getAuthentication().getType());
  98         assertNull(subscriptionCreation.getAuthentication().getUserName());
  99         assertNull(subscriptionCreation.getAuthentication().getClientName());
 100         assertNull(subscriptionCreation.getAuthentication().getClientPassword());
 101         assertNull(subscriptionCreation.getAuthentication().getPassword());
 102         assertNull(subscriptionCreation.getAuthentication().getTokenUrl());
 103         assertNull(subscriptionCreation.getFilter().getVnfdId());
 104         assertNull(subscriptionCreation.getFilter().getVnfInstanceId());
 105         assertNull(subscriptionCreation.getFilter().getVnfProductName());
 106         assertNull(subscriptionCreation.getFilter().getVnfSoftwareVersion());
 107         assertEquals(Lists.newArrayList(VnfNotificationType.VNFLIFECYCLECHANGENOTIFICATION), subscriptionCreation.getFilter().getNotificationTypes());
 108         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(HEAL));
 109         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(SCALE));
 110         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(TERMINATE));
 111         assertTrue(subscriptionCreation.getFilter().getOperationTypes().contains(INSTANTIATE));
 112         assertEquals(4, subscriptionCreation.getFilter().getOperationTypes().size());
 113         verify(logger).info("Subscribing to CBAM LCN {} with callback to {}", driverProperties.getCbamLcnUrl(), "http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 114     }
 115
 116     private void assertMicroserviceRegistered() {
 117         MicroServiceInfo microserviceRequest = registeredMicroservice.getValue();
 118         assertEquals(1, microserviceRequest.getNodes().size());
 119         Node node = microserviceRequest.getNodes().iterator().next();
 120         assertEquals("0", node.getTtl());
 121         assertEquals("1.2.3.4", node.getIp());
 122         assertEquals("12345", node.getPort());
 123         assertEquals(REST, microserviceRequest.getProtocol());
 124         assertNull(microserviceRequest.getMetadata());
 125         //very strange, but it should be null for ONAP to work
 126         assertEquals(SelfRegistrationManager.SERVICE_NAME, microserviceRequest.getServiceName());
 127         assertEquals("/api/NokiaSVNFM/v1", microserviceRequest.getUrl());
 128         assertEquals("v1", microserviceRequest.getVersion());
 129         assertEquals(Boolean.FALSE, microserviceRequest.isEnableSsl());
 130         //1 means internal service to ONAP
 131         assertEquals(_1, microserviceRequest.getVisualRange());
 132     }
 133
 134     /**
 135      * If the subscription already exists the subscription is not recreated
 136      */
 137     @Test
 138     public void testResubscription() throws Exception {
 139         //given
 140         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 141         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenReturn(buildObservable(returnedMicroService));
 142         Subscription existingSubscription = new Subscription();
 143         existingSubscription.setId(UUID.randomUUID().toString());
 144         existingSubscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 145         subscriptions.add(existingSubscription);
 146         //when
 147         selfRegistrationManager.register();
 148         //verify
 149         assertMicroserviceRegistered();
 150         verify(lcnApi, never()).subscriptionsPost(any(), any());
 151         assertServiceUp();
 152     }
 153
 154     /**
 155      * If the LCN subscription fails the microservice is not registered
 156      */
 157     @Test
 158     public void testFailedLcnSubscription() throws Exception {
 159         //given
 160         RuntimeException expectedException = new RuntimeException();
 161         when(lcnApi.subscriptionsPost(any(), any())).thenThrow(expectedException);
 162         //when
 163         try {
 164             selfRegistrationManager.register();
 165             fail();
 166         } catch (RuntimeException e) {
 167             assertEquals(expectedException, e.getCause());
 168         }
 169         //verify
 170         verify(msbClient, never()).addMicroService(any(), any(), any());
 171         verify(logger).error("Unable to subscribe to CBAM LCN", expectedException);
 172         assertServiceDown();
 173     }
 174
 175     /**
 176      * If the registration to MSB fails the subscription is deleted
 177      */
 178     @Test
 179     public void testFailedMsbPublish() throws Exception {
 180         //given
 181         Subscription subscription = new Subscription();
 182         when(lcnApi.subscriptionsPost(subscriptionToCreate.capture(), Mockito.eq(NOKIA_LCN_API_VERSION))).thenAnswer(invocationOnMock -> {
 183             subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 184             subscription.setId(UUID.randomUUID().toString());
 185             subscriptions.add(subscription);
 186             return buildObservable(subscription);
 187         });
 188         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 189         RuntimeException expectedException = new RuntimeException();
 190         when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenThrow(expectedException);
 191         //when
 192         try {
 193             selfRegistrationManager.register();
 194             //verify
 195             fail();
 196         } catch (RuntimeException e) {
 197             assertEquals(expectedException, e.getCause());
 198         }
 199         assertNewLcnSubscription();
 200         verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 201         assertServiceDown();
 202     }
 203
 204     /**
 205      * basic service unregistration
 206      * - ongoing jobs are outwaited
 207      * - first the service is removed from MSB
 208      * - second unregistration
 209      */
 210     @Test
 211     public void testUnregistration() throws Exception {
 212         //given
 213         Subscription subscription = new Subscription();
 214         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 215         subscription.setId(UUID.randomUUID().toString());
 216         subscriptions.add(subscription);
 217         when(jobManager.hasOngoingJobs()).thenReturn(false);
 218         Observable delete = Mockito.mock(Observable.class);
 219         when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(delete);
 220         //when
 221         selfRegistrationManager.deRegister();
 222         //verify
 223         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 224         inOrder.verify(msbClient).deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null);
 225         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 226         assertServiceDown();
 227         verify(systemFunctions).blockingFirst(delete);
 228         verify(logger).info("Deleting subscription with {} identifier", subscription.getId());
 229     }
 230
 231     /**
 232      * if the MSB reports that it could not cancel the service, but the service has
 233      * disappeared from MSB the cancellation is considered to be successful
 234      */
 235     @Test
 236     public void testPartiallyFailedMsbCancel() throws Exception {
 237         //given
 238         Subscription subscription = new Subscription();
 239         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 240         subscription.setId(UUID.randomUUID().toString());
 241         subscriptions.add(subscription);
 242         when(jobManager.hasOngoingJobs()).thenReturn(false);
 243         when(msbClient.deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null)).then(new Answer<Observable<Void>>() {
 244             @Override
 245             public Observable<Void> answer(InvocationOnMock invocationOnMock) throws Throwable {
 246                 when(msbClient.getMicroService_0(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null, null, null, null)).thenThrow(new RuntimeException());
 247                 throw new RuntimeException();
 248             }
 249         });
 250         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 251         //when
 252         selfRegistrationManager.deRegister();
 253         //verify
 254         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 255         inOrder.verify(msbClient).deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null);
 256         inOrder.verify(msbClient).getMicroService_0(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null, null, null, null);
 257         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 258         assertServiceDown();
 259     }
 260
 261     /**
 262      * failure of unregistration from MSB should be propagated
 263      */
 264     @Test
 265     public void testUnregistrationFailure() throws Exception {
 266         //given
 267         Subscription subscription = new Subscription();
 268         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 269         subscription.setId(UUID.randomUUID().toString());
 270         subscriptions.add(subscription);
 271         when(msbClient.deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null)).then(new Answer<Observable<Void>>() {
 272             @Override
 273             public Observable<Void> answer(InvocationOnMock invocationOnMock) throws Throwable {
 274                 throw new RuntimeException();
 275             }
 276         });
 277         //when
 278         try {
 279             selfRegistrationManager.deRegister();
 280             fail();
 281         } catch (RuntimeException e) {
 282
 283         }
 284         //verify
 285         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 286         inOrder.verify(msbClient).deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null);
 287         inOrder.verify(msbClient).getMicroService_0(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null, null, null, null);
 288         verify(lcnApi, Mockito.never()).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 289         assertServiceDown();
 290     }
 291
 292     /**
 293      * failure of subscription deletion from MSB should be propagated
 294      */
 295     @Test
 296     public void testSubscriptionFailure() 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(UUID.randomUUID().toString());
 301         subscriptions.add(subscription);
 302         when(jobManager.hasOngoingJobs()).thenReturn(false);
 303         RuntimeException expectedException = new RuntimeException();
 304         doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 305         //when
 306         try {
 307             selfRegistrationManager.deRegister();
 308             fail();
 309         } catch (RuntimeException e) {
 310
 311         }
 312         //verify
 313         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 314         inOrder.verify(msbClient).deleteMicroService(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION, null, null);
 315         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 316         assertServiceDown();
 317     }
 318
 319     /**
 320      * the swagger API definitions embedded in the code
 321      */
 322     @Test
 323     public void testSwaggerApi() throws Exception {
 324         //no idea how to test this except repeat implementation
 325         byte[] a = TestUtil.loadFile(SelfRegistrationManager.SWAGGER_API_DEFINITION);
 326         tearGeneric();
 327         //when
 328         assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition()));
 329     }
 330
 331     public void assertServiceUp() throws Exception {
 332         assertTrue(selfRegistrationManager.isReady());
 333     }
 334
 335     /**
 336      * if there are ongoing jobs then the guard thros exception
 337      */
 338     public void assertServiceDown() {
 339         assertFalse(selfRegistrationManager.isReady());
 340
 341     }
 342
 343 }