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.ApiException;
  20 import com.nokia.cbam.lcn.v32.model.CreateSubscriptionRequest;
  21 import com.nokia.cbam.lcn.v32.model.Subscription;
  22 import com.nokia.cbam.lcn.v32.model.SubscriptionAuthentication;
  23 import com.nokia.cbam.lcn.v32.model.VnfNotificationType;
  24 import org.junit.Before;
  25 import org.junit.Test;
  26 import org.mockito.*;
  27 import org.mockito.invocation.InvocationOnMock;
  28 import org.mockito.stubbing.Answer;
  29 import org.onap.msb.sdk.discovery.common.RouteException;
  30 import org.onap.msb.sdk.discovery.entity.MicroServiceFullInfo;
  31 import org.onap.msb.sdk.discovery.entity.MicroServiceInfo;
  32 import org.onap.msb.sdk.discovery.entity.Node;
  33 import org.onap.msb.sdk.discovery.entity.RouteResult;
  34 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.onap.core.SelfRegistrationManager;
  35 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.TestUtil;
  36
  37 import java.util.ArrayList;
  38 import java.util.Arrays;
  39 import java.util.List;
  40 import java.util.UUID;
  41
  42 import static com.nokia.cbam.lcn.v32.model.OperationType.*;
  43 import static junit.framework.TestCase.*;
  44 import static org.mockito.Matchers.any;
  45 import static org.mockito.Mockito.*;
  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 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(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(subscription);
  82         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
  83         when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenReturn(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).registerMicroServiceInfo(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     }
 116
 117     private void assertMicroserviceRegistered() {
 118         MicroServiceInfo microserviceRequest = registeredMicroservice.getValue();
 119         assertEquals(1, microserviceRequest.getNodes().size());
 120         Node node = microserviceRequest.getNodes().iterator().next();
 121         assertEquals("0", node.getTtl());
 122         assertEquals("1.2.3.4", node.getIp());
 123         assertEquals("12345", node.getPort());
 124         assertEquals("REST", microserviceRequest.getProtocol());
 125         assertNull(microserviceRequest.getMetadata());
 126         //very strange, but it should be null for ONAP to work
 127         assertEquals("", microserviceRequest.getPath());
 128         assertEquals(SelfRegistrationManager.SERVICE_NAME, microserviceRequest.getServiceName());
 129         assertEquals("/api/NokiaSVNFM/v1", microserviceRequest.getUrl());
 130         assertEquals("v1", microserviceRequest.getVersion());
 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         ApiException expectedException = new ApiException();
 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(new Answer<Subscription>() {
 184             @Override
 185             public Subscription answer(InvocationOnMock invocationOnMock) throws Throwable {
 186                 subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 187                 subscription.setId(UUID.randomUUID().toString());
 188                 subscriptions.add(subscription);
 189                 return subscription;
 190             }
 191         });
 192         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 193         RouteException expectedException = new RouteException();
 194         when(msbClient.registerMicroServiceInfo(registeredMicroservice.capture())).thenThrow(expectedException);
 195         //when
 196         try {
 197             selfRegistrationManager.register();
 198             //verify
 199             fail();
 200         } catch (RuntimeException e) {
 201             assertEquals(expectedException, e.getCause());
 202         }
 203         assertNewLcnSubscription();
 204         verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 205         assertServiceDown();
 206     }
 207
 208     /**
 209      * basic service unregistration
 210      * - ongoing jobs are outwaited
 211      * - first the service is removed from MSB
 212      * - second unregistration
 213      */
 214     @Test
 215     public void testUnregistration() throws Exception {
 216         //given
 217         Subscription subscription = new Subscription();
 218         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 219         subscription.setId(UUID.randomUUID().toString());
 220         subscriptions.add(subscription);
 221         when(jobManager.hasOngoingJobs()).thenReturn(false);
 222         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 223         //when
 224         selfRegistrationManager.deRegister();
 225         //verify
 226         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 227         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 228         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 229         assertServiceDown();
 230     }
 231
 232     /**
 233      * if the MSB reports that it could not cancel the service, but the service has
 234      * disappeared from MSB the cancellation is considered to be successful
 235      */
 236     @Test
 237     public void testPartiallyFailedMsbCancel() throws Exception {
 238         //given
 239         Subscription subscription = new Subscription();
 240         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 241         subscription.setId(UUID.randomUUID().toString());
 242         subscriptions.add(subscription);
 243         when(jobManager.hasOngoingJobs()).thenReturn(false);
 244         when(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() {
 245             @Override
 246             public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable {
 247                 when(msbClient.queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).thenThrow(new RouteException());
 248                 throw new RouteException();
 249             }
 250         });
 251         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 252         //when
 253         selfRegistrationManager.deRegister();
 254         //verify
 255         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 256         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 257         inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 258         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 259         assertServiceDown();
 260     }
 261
 262     /**
 263      * failure of unregistration from MSB should be propagated
 264      */
 265     @Test
 266     public void testUnregistrationFailure() throws Exception {
 267         //given
 268         Subscription subscription = new Subscription();
 269         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 270         subscription.setId(UUID.randomUUID().toString());
 271         subscriptions.add(subscription);
 272         when(msbClient.cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION)).then(new Answer<RouteResult>() {
 273             @Override
 274             public RouteResult answer(InvocationOnMock invocationOnMock) throws Throwable {
 275                 throw new RouteException();
 276             }
 277         });
 278         MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
 279         //when
 280         try {
 281             selfRegistrationManager.deRegister();
 282             fail();
 283         } catch (RuntimeException e) {
 284
 285         }
 286         //verify
 287         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 288         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 289         inOrder.verify(msbClient).queryMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 290         verify(lcnApi, Mockito.never()).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 291         assertServiceDown();
 292     }
 293
 294     /**
 295      * failure of subscription deletion from MSB should be propagated
 296      */
 297     @Test
 298     public void testSubscriptionFailure() throws Exception {
 299         //given
 300         Subscription subscription = new Subscription();
 301         subscription.setCallbackUrl("http://5.6.7.8:12345/api/NokiaSVNFM/v1/lcn");
 302         subscription.setId(UUID.randomUUID().toString());
 303         subscriptions.add(subscription);
 304         when(jobManager.hasOngoingJobs()).thenReturn(false);
 305         ApiException expectedException = new ApiException();
 306         doThrow(expectedException).when(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 307         //when
 308         try {
 309             selfRegistrationManager.deRegister();
 310             fail();
 311         } catch (RuntimeException e) {
 312
 313         }
 314         //verify
 315         InOrder inOrder = Mockito.inOrder(jobManager, msbClient, lcnApi);
 316         inOrder.verify(msbClient).cancelMicroServiceInfo(SelfRegistrationManager.SERVICE_NAME, SelfRegistrationManager.DRIVER_VERSION);
 317         inOrder.verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
 318         assertServiceDown();
 319     }
 320
 321     /**
 322      * the swagger API definitions embedded in the code
 323      */
 324     @Test
 325     public void testSwaggerApi() throws Exception {
 326         //no idea how to test this except repeat implementation
 327         byte[] a = TestUtil.loadFile(SelfRegistrationManager.SWAGGER_API_DEFINITION);
 328         tearGeneric();
 329         //when
 330         assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition()));
 331     }
 332
 333     public void assertServiceUp() throws Exception {
 334         assertTrue(selfRegistrationManager.isReady());
 335     }
 336
 337     /**
 338      * if there are ongoing jobs then the guard thros exception
 339      */
 340     public void assertServiceDown() {
 341         assertFalse(selfRegistrationManager.isReady());
 342
 343     }
 344
 345 }