gerrit.onap Code Review - ccsdk/oran.git/blob

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * ONAP : ccsdk oran
   4  * ======================================================================
   5  * Copyright (C) 2020 Nordix Foundation. All rights reserved.
   6  * ======================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ========================LICENSE_END===================================
  19  */
  20
  21 package org.onap.ccsdk.oran.a1policymanagementservice.tasks;
  22
  23 import static ch.qos.logback.classic.Level.WARN;
  24 import static org.assertj.core.api.Assertions.assertThat;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.ArgumentMatchers.anyString;
  27 import static org.mockito.Mockito.doReturn;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.spy;
  30 import static org.mockito.Mockito.times;
  31 import static org.mockito.Mockito.verify;
  32 import static org.mockito.Mockito.verifyNoInteractions;
  33 import static org.mockito.Mockito.verifyNoMoreInteractions;
  34 import static org.mockito.Mockito.when;
  35
  36 import ch.qos.logback.classic.spi.ILoggingEvent;
  37 import ch.qos.logback.core.read.ListAppender;
  38
  39 import java.time.Duration;
  40 import java.time.Instant;
  41 import java.util.Arrays;
  42 import java.util.Collections;
  43
  44 import org.junit.jupiter.api.BeforeEach;
  45 import org.junit.jupiter.api.Test;
  46 import org.junit.jupiter.api.extension.ExtendWith;
  47 import org.mockito.Mock;
  48 import org.mockito.junit.jupiter.MockitoExtension;
  49 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
  50 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
  51 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClient;
  52 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
  53 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ApplicationConfig;
  54 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ImmutableRicConfig;
  55 import org.onap.ccsdk.oran.a1policymanagementservice.repository.ImmutablePolicy;
  56 import org.onap.ccsdk.oran.a1policymanagementservice.repository.ImmutablePolicyType;
  57 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
  58 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
  59 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyType;
  60 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
  61 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric;
  62 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric.RicState;
  63 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Service;
  64 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Services;
  65 import org.onap.ccsdk.oran.a1policymanagementservice.utils.LoggingUtils;
  66
  67 import reactor.core.publisher.Flux;
  68 import reactor.core.publisher.Mono;
  69
  70 @ExtendWith(MockitoExtension.class)
  71 class RicSynchronizationTaskTest {
  72     private static final String POLICY_TYPE_1_NAME = "type1";
  73     private static final PolicyType POLICY_TYPE_1 = ImmutablePolicyType.builder() //
  74             .id(POLICY_TYPE_1_NAME) //
  75             .schema("") //
  76             .build();
  77
  78     private static final String RIC_1_NAME = "ric1";
  79     private static final Ric RIC_1 = new Ric(ImmutableRicConfig.builder() //
  80             .ricId(RIC_1_NAME) //
  81             .baseUrl("baseUrl1") //
  82             .managedElementIds(Collections.emptyList()) //
  83             .controllerName("controllerName") //
  84             .build());
  85
  86     private static Policy createPolicy(String policyId, boolean isTransient) {
  87         return ImmutablePolicy.builder() //
  88                 .id(policyId) //
  89                 .json("") //
  90                 .ownerServiceId("service") //
  91                 .ric(RIC_1) //
  92                 .type(POLICY_TYPE_1) //
  93                 .lastModified(Instant.now()) //
  94                 .isTransient(isTransient) //
  95                 .statusNotificationUri("statusNotificationUri") //
  96                 .build();
  97     }
  98
  99     private static final Policy POLICY_1 = createPolicy("policyId1", false);
 100
 101     private static final String SERVICE_1_NAME = "service1";
 102     private static final String SERVICE_1_CALLBACK_URL = "callbackUrl";
 103     private static final Service SERVICE_1 = new Service(SERVICE_1_NAME, Duration.ofSeconds(1), SERVICE_1_CALLBACK_URL);
 104
 105     @Mock
 106     private A1Client a1ClientMock;
 107
 108     @Mock
 109     private A1ClientFactory a1ClientFactoryMock;
 110
 111     private PolicyTypes policyTypes;
 112     private Policies policies;
 113     private Services services;
 114
 115     @BeforeEach
 116     void init() {
 117         policyTypes = new PolicyTypes();
 118         policies = new Policies();
 119         services = new Services();
 120         RIC_1.setState(RicState.UNAVAILABLE);
 121         RIC_1.clearSupportedPolicyTypes();
 122     }
 123
 124     private RicSynchronizationTask createTask() {
 125         ApplicationConfig config = new ApplicationConfig();
 126         AsyncRestClientFactory restClientFactory = new AsyncRestClientFactory(config.getWebClientConfig());
 127         return new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services, restClientFactory);
 128     };
 129
 130     @Test
 131     void ricAlreadySynchronizing_thenNoSynchronization() {
 132         RIC_1.setState(RicState.SYNCHRONIZING);
 133         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 134
 135         policyTypes.put(POLICY_TYPE_1);
 136         policies.put(POLICY_1);
 137
 138         RicSynchronizationTask synchronizerUnderTest = createTask();
 139
 140         synchronizerUnderTest.run(RIC_1);
 141
 142         verifyNoInteractions(a1ClientMock);
 143
 144         assertThat(policyTypes.size()).isEqualTo(1);
 145         assertThat(policies.size()).isEqualTo(1);
 146         assertThat(RIC_1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 147         assertThat(RIC_1.getSupportedPolicyTypeNames()).hasSize(1);
 148     }
 149
 150     @Test
 151     void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 152         RIC_1.setState(RicState.AVAILABLE);
 153
 154         policyTypes.put(POLICY_TYPE_1);
 155
 156         services.put(SERVICE_1);
 157         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 158         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 159
 160         setUpCreationOfA1Client();
 161         simulateRicWithOnePolicyType();
 162
 163         RicSynchronizationTask synchronizerUnderTest = spy(createTask());
 164
 165         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 166         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.just("Ok"));
 167
 168         synchronizerUnderTest.run(RIC_1);
 169
 170         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 171         verifyNoMoreInteractions(a1ClientMock);
 172
 173         verify(synchronizerUnderTest).run(RIC_1);
 174         verify(synchronizerUnderTest).createNotificationClient(SERVICE_1_CALLBACK_URL);
 175         verifyNoMoreInteractions(synchronizerUnderTest);
 176
 177         verify(restClientMock).put("", "Synchronization completed for:" + RIC_1_NAME);
 178         verifyNoMoreInteractions(restClientMock);
 179
 180         assertThat(policyTypes.size()).isEqualTo(1);
 181         assertThat(policies.size()).isZero();
 182         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 183     }
 184
 185     @Test
 186     void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 187         RIC_1.setState(RicState.AVAILABLE);
 188
 189         setUpCreationOfA1Client();
 190         simulateRicWithOnePolicyType();
 191         String typeSchema = "schema";
 192         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 193
 194         RicSynchronizationTask synchronizerUnderTest = createTask();
 195
 196         synchronizerUnderTest.run(RIC_1);
 197
 198         verify(a1ClientMock).getPolicyTypeIdentities();
 199         verifyNoMoreInteractions(a1ClientMock);
 200
 201         assertThat(policyTypes.size()).isEqualTo(1);
 202         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).schema()).isEqualTo(typeSchema);
 203         assertThat(policies.size()).isZero();
 204         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 205     }
 206
 207     @Test
 208     void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 209         RIC_1.setState(RicState.AVAILABLE);
 210
 211         Policy transientPolicy = createPolicy("transientPolicyId", true);
 212
 213         policies.put(transientPolicy);
 214         policies.put(POLICY_1);
 215
 216         setUpCreationOfA1Client();
 217         simulateRicWithNoPolicyTypes();
 218
 219         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.just("OK"));
 220         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 221
 222         RicSynchronizationTask synchronizerUnderTest = createTask();
 223
 224         synchronizerUnderTest.run(RIC_1);
 225
 226         verify(a1ClientMock).deleteAllPolicies();
 227         verify(a1ClientMock).putPolicy(POLICY_1);
 228         verifyNoMoreInteractions(a1ClientMock);
 229
 230         assertThat(policyTypes.size()).isZero();
 231         assertThat(policies.size()).isEqualTo(1); // The transient policy shall be deleted
 232         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 233     }
 234
 235     @Test
 236     void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
 237         RIC_1.setState(RicState.AVAILABLE);
 238
 239         policies.put(POLICY_1);
 240
 241         setUpCreationOfA1Client();
 242         simulateRicWithNoPolicyTypes();
 243
 244         when(a1ClientMock.deleteAllPolicies()) //
 245                 .thenReturn(Flux.error(new Exception("Exception"))) //
 246                 .thenReturn(Flux.just("OK"));
 247
 248         RicSynchronizationTask synchronizerUnderTest = createTask();
 249
 250         synchronizerUnderTest.run(RIC_1);
 251
 252         verify(a1ClientMock, times(2)).deleteAllPolicies();
 253         verifyNoMoreInteractions(a1ClientMock);
 254
 255         assertThat(policyTypes.size()).isZero();
 256         assertThat(policies.size()).isZero();
 257         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 258     }
 259
 260     @Test
 261     void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 262         RIC_1.setState(RicState.AVAILABLE);
 263
 264         policies.put(POLICY_1);
 265
 266         setUpCreationOfA1Client();
 267         simulateRicWithNoPolicyTypes();
 268
 269         String originalErrorMessage = "Exception";
 270         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.error(new Exception(originalErrorMessage)));
 271
 272         RicSynchronizationTask synchronizerUnderTest = createTask();
 273
 274         final ListAppender<ILoggingEvent> logAppender =
 275                 LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 276
 277         synchronizerUnderTest.run(RIC_1);
 278
 279         verifyCorrectLogMessage(0, logAppender,
 280                 "Synchronization failure for ric: " + RIC_1_NAME + ", reason: " + originalErrorMessage);
 281
 282         verify(a1ClientMock, times(2)).deleteAllPolicies();
 283         verifyNoMoreInteractions(a1ClientMock);
 284
 285         assertThat(policyTypes.size()).isZero();
 286         assertThat(policies.size()).isZero();
 287         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 288     }
 289
 290     @Test
 291     void ricIdlePolicyTypeInRepo_thenSynchronizationWithErrorOnServiceNotificationErrorLogged() {
 292         RIC_1.setState(RicState.AVAILABLE);
 293
 294         policyTypes.put(POLICY_TYPE_1);
 295
 296         services.put(SERVICE_1);
 297
 298         setUpCreationOfA1Client();
 299         simulateRicWithOnePolicyType();
 300
 301         final ListAppender<ILoggingEvent> logAppender =
 302                 LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 303
 304         RicSynchronizationTask synchronizerUnderTest = spy(createTask());
 305
 306         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 307         String originalErrorMessage = "Exception";
 308         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.error(new Exception(originalErrorMessage)));
 309
 310         synchronizerUnderTest.run(RIC_1);
 311
 312         ILoggingEvent loggingEvent = logAppender.list.get(0);
 313         assertThat(loggingEvent.getLevel()).isEqualTo(WARN);
 314         verifyCorrectLogMessage(0, logAppender,
 315                 "Service notification failed for service: " + SERVICE_1_NAME + ". Cause: " + originalErrorMessage);
 316     }
 317
 318     private void setUpCreationOfA1Client() {
 319         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 320         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 321     }
 322
 323     private AsyncRestClient setUpCreationOfAsyncRestClient(RicSynchronizationTask synchronizerUnderTest) {
 324         AsyncRestClient restClientMock = mock(AsyncRestClient.class);
 325         doReturn(restClientMock).when(synchronizerUnderTest).createNotificationClient(anyString());
 326         return restClientMock;
 327     }
 328
 329     private void simulateRicWithOnePolicyType() {
 330         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 331     }
 332
 333     private void simulateRicWithNoPolicyTypes() {
 334         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 335     }
 336
 337     private void verifyCorrectLogMessage(int messageIndex, ListAppender<ILoggingEvent> logAppender,
 338             String expectedMessage) {
 339         ILoggingEvent loggingEvent = logAppender.list.get(messageIndex);
 340         assertThat(loggingEvent.getFormattedMessage()).isEqualTo(expectedMessage);
 341     }
 342 }