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