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