2 * Copyright 2016-2017, Nokia Corporation
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm;
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;
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;
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;
49 public class TestSelfRegistrationManager extends TestBase {
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);
56 private SelfRegistrationManager selfRegistrationManager;
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);
73 * test the basic registration process
74 * - first subscribe to CBAM LCNs
75 * - second publish it's existence on MSB
78 public void testRegistration() throws Exception {
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));
85 selfRegistrationManager.register();
87 InOrder registrationOrder = Mockito.inOrder(lcnApi, msbClient);
88 registrationOrder.verify(lcnApi).subscriptionsPost(any(), any());
89 registrationOrder.verify(msbClient).addMicroService(any(), any(), any());
91 assertMicroserviceRegistered();
92 assertNewLcnSubscription();
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");
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());
137 * If the subscription already exists the subscription is not recreated
140 public void testResubscription() throws Exception {
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);
149 selfRegistrationManager.register();
151 assertMicroserviceRegistered();
152 verify(lcnApi, never()).subscriptionsPost(any(), any());
157 * If the LCN subscription fails the microservice is not registered
160 public void testFailedLcnSubscription() throws Exception {
162 RuntimeException expectedException = new RuntimeException();
163 when(lcnApi.subscriptionsPost(any(), any())).thenThrow(expectedException);
166 selfRegistrationManager.register();
168 } catch (RuntimeException e) {
169 assertEquals(expectedException, e.getCause());
172 verify(msbClient, never()).addMicroService(any(), any(), any());
173 verify(logger).error("Unable to subscribe to CBAM LCN", expectedException);
178 * If the registration to MSB fails the subscription is deleted
181 public void testFailedMsbPublish() throws Exception {
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);
191 MicroServiceFullInfo returnedMicroService = new MicroServiceFullInfo();
192 RuntimeException expectedException = new RuntimeException();
193 when(msbClient.addMicroService(registeredMicroservice.capture(), eq(true), eq(false))).thenThrow(expectedException);
196 selfRegistrationManager.register();
199 } catch (RuntimeException e) {
200 assertEquals(expectedException, e.getCause());
202 assertNewLcnSubscription();
203 verify(lcnApi).subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION);
208 * basic service unregistration
209 * - ongoing jobs are outwaited
210 * - first the service is removed from MSB
211 * - second unregistration
214 public void testUnregistration() throws Exception {
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());
225 selfRegistrationManager.deRegister();
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);
231 VOID_OBSERVABLE.assertCalled();
232 MSB_DELETE.assertCalled();
233 verify(logger).info("Deleting subscription with {} identifier", subscription.getId());
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
241 public void testPartiallyFailedMsbCancel() throws Exception {
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>>() {
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();
255 when(lcnApi.subscriptionsSubscriptionIdDelete(subscription.getId(), NOKIA_LCN_API_VERSION)).thenReturn(VOID_OBSERVABLE.value());
257 selfRegistrationManager.deRegister();
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);
264 VOID_OBSERVABLE.assertCalled();
268 * failure of unregistration from MSB should be propagated
271 public void testUnregistrationFailure() throws Exception {
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>>() {
279 public Observable<Void> answer(InvocationOnMock invocationOnMock) throws Throwable {
280 throw new RuntimeException();
285 selfRegistrationManager.deRegister();
287 } catch (RuntimeException e) {
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);
299 * failure of subscription deletion from MSB should be propagated
302 public void testSubscriptionFailure() throws Exception {
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());
314 selfRegistrationManager.deRegister();
316 } catch (RuntimeException e) {
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);
327 * the swagger API definitions embedded in the code
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);
335 assertTrue(Arrays.equals(a, selfRegistrationManager.getSwaggerApiDefinition()));
338 public void assertServiceUp() throws Exception {
339 assertTrue(selfRegistrationManager.isReady());
343 * if there are ongoing jobs then the guard thros exception
345 public void assertServiceDown() {
346 assertFalse(selfRegistrationManager.isReady());