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         //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.registerMicroServiceInfo(registeredMicroservice.capture())).thenReturn(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()).registerMicroServiceInfo(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         RouteException expectedException = new RouteException();
 190         when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).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         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 219         //when
 220         selfRegistrationManager.deRegister();
 221         //verify
 222         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 223         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 224         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 225         assertServiceDown();
 226     }
 227
 228     /**
 229      * if the MSB reports that it could not cancel the service, but the service has
 230      * disappeared from MSB the cancellation is considered to be successful
 231      */
 232     @Test
 233     public void testPartiallyFailedMsbCancel() throws Exception {
 234         //given
 235         Subscription subscription = new Subscription();
 236         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 237         subscription.setId(UUID.randomUUID().toString());
 238         subscriptions.add(subscription);
 239         when(jobManager.hasOngoingJobs()).thenReturn(false);
 240         when(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() {
 241             @Override
 242             public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable {
 243                 when(msbClient.queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).thenThrow(new RouteException());
 244                 throw new RouteException();
 245             }
 246         });
 247         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 248         //when
 249         selfRegistrationManager.deRegister();
 250         //verify
 251         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 252         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 253         inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 254         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 255         assertServiceDown();
 256     }
 257
 258     /**
 259      * failure of unregistration from MSB should be propagated
 260      */
 261     @Test
 262     public void testUnregistrationFailure() throws Exception {
 263         //given
 264         Subscription subscription = new Subscription();
 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(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() {
 269             @Override
 270             public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable {
 271                 throw new RouteException();
 272             }
 273         });
 274         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 275         //when
 276         try {
 277             selfRegistrationManager.deRegister();
 278             fail();
 279         } catch (RuntimeException e) {
 280
 281         }
 282         //verify
 283         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 284         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 285         inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 286         verify(lcnApi, Mockito.never()).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 287         assertServiceDown();
 288     }
 289
 290     /**
 291      * failure of subscription deletion from MSB should be propagated
 292      */
 293     @Test
 294     public void testSubscriptionFailure() throws Exception {
 295         //given
 296         Subscription subscription = new Subscription();
 297         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 298         subscription.setId(UUID.randomUUID().toString());
 299         subscriptions.add(subscription);
 300         when(jobManager.hasOngoingJobs()).thenReturn(false);
 301         RuntimeException expectedException = new RuntimeException();
 302         doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 303         //when
 304         try {
 305             selfRegistrationManager.deRegister();
 306             fail();
 307         } catch (RuntimeException e) {
 308
 309         }
 310         //verify
 311         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 312         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 313         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 314         assertServiceDown();
 315     }
 316
 317     /**
 318      * the swagger API definitions embedded in the code
 319      */
 320     @Test
 321     public void testSwaggerApi() throws Exception {
 322         //no idea how to test this except repeat implementation
 323         byte[] a = TestUtil.loadFile(SelfRegistrationManager.SWAGGER_API_DEFINITION);
 324         tearGeneric();
 325         //when
 326         assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition()));
 327     }
 328
 329     public void assertServiceUp() throws Exception {
 330         assertTrue(selfRegistrationManager.isReady());
 331     }
 332
 333     /**
 334      * if there are ongoing jobs then the guard thros exception
 335      */
 336     public void assertServiceDown() {
 337         assertFalse(selfRegistrationManager.isReady());
 338
 339     }
 340
 341 }