policy-agent/src/test/java/org/oransc/policyagent/tasks/RicSynchronizationTaskTest.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2020 Nordix Foundation
   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.oransc.policyagent.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.util.Arrays;
  41 import java.util.Collections;
  42
  43 import org.junit.jupiter.api.BeforeEach;
  44 import org.junit.jupiter.api.Test;
  45 import org.junit.jupiter.api.extension.ExtendWith;
  46 import org.mockito.Mock;
  47 import org.mockito.junit.jupiter.MockitoExtension;
  48 import org.oransc.policyagent.clients.A1Client;
  49 import org.oransc.policyagent.clients.A1ClientFactory;
  50 import org.oransc.policyagent.clients.AsyncRestClient;
  51 import org.oransc.policyagent.configuration.ImmutableRicConfig;
  52 import org.oransc.policyagent.repository.ImmutablePolicy;
  53 import org.oransc.policyagent.repository.ImmutablePolicyType;
  54 import org.oransc.policyagent.repository.Policies;
  55 import org.oransc.policyagent.repository.Policy;
  56 import org.oransc.policyagent.repository.PolicyType;
  57 import org.oransc.policyagent.repository.PolicyTypes;
  58 import org.oransc.policyagent.repository.Ric;
  59 import org.oransc.policyagent.repository.Ric.RicState;
  60 import org.oransc.policyagent.repository.Service;
  61 import org.oransc.policyagent.repository.Services;
  62 import org.oransc.policyagent.utils.LoggingUtils;
  63
  64 import reactor.core.publisher.Flux;
  65 import reactor.core.publisher.Mono;
  66
  67 @ExtendWith(MockitoExtension.class)
  68 class RicSynchronizationTaskTest {
  69     private static final String POLICY_TYPE_1_NAME = "type1";
  70     private static final PolicyType POLICY_TYPE_1 = ImmutablePolicyType.builder() //
  71         .name(POLICY_TYPE_1_NAME) //
  72         .schema("") //
  73         .build();
  74
  75     private static final String RIC_1_NAME = "ric1";
  76     private static final Ric RIC_1 = new Ric(ImmutableRicConfig.builder() //
  77         .name(RIC_1_NAME) //
  78         .baseUrl("baseUrl1") //
  79         .managedElementIds(Collections.emptyList()) //
  80         .controllerName("controllerName") //
  81         .build());
  82
  83     private static Policy createPolicy(String policyId, boolean isTransient) {
  84         return ImmutablePolicy.builder() //
  85             .id(policyId) //
  86             .json("") //
  87             .ownerServiceName("service") //
  88             .ric(RIC_1) //
  89             .type(POLICY_TYPE_1) //
  90             .lastModified("now") //
  91             .isTransient(isTransient) //
  92             .build();
  93     }
  94
  95     private static final Policy POLICY_1 = createPolicy("policyId1", false);
  96
  97     private static final String SERVICE_1_NAME = "service1";
  98     private static final String SERVICE_1_CALLBACK_URL = "callbackUrl";
  99     private static final Service SERVICE_1 = new Service(SERVICE_1_NAME, Duration.ofSeconds(1), SERVICE_1_CALLBACK_URL);
 100
 101     @Mock
 102     private A1Client a1ClientMock;
 103
 104     @Mock
 105     private A1ClientFactory a1ClientFactoryMock;
 106
 107     private PolicyTypes policyTypes;
 108     private Policies policies;
 109     private Services services;
 110
 111     @BeforeEach
 112     void init() {
 113         policyTypes = new PolicyTypes();
 114         policies = new Policies();
 115         services = new Services();
 116         RIC_1.setState(RicState.UNAVAILABLE);
 117         RIC_1.clearSupportedPolicyTypes();
 118     }
 119
 120     @Test
 121     void ricAlreadySynchronizing_thenNoSynchronization() {
 122         RIC_1.setState(RicState.SYNCHRONIZING);
 123         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 124
 125         policyTypes.put(POLICY_TYPE_1);
 126         policies.put(POLICY_1);
 127
 128         RicSynchronizationTask synchronizerUnderTest =
 129             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 130
 131         synchronizerUnderTest.run(RIC_1);
 132
 133         verifyNoInteractions(a1ClientMock);
 134
 135         assertThat(policyTypes.size()).isEqualTo(1);
 136         assertThat(policies.size()).isEqualTo(1);
 137         assertThat(RIC_1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 138         assertThat(RIC_1.getSupportedPolicyTypeNames()).hasSize(1);
 139     }
 140
 141     @Test
 142     void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 143         RIC_1.setState(RicState.AVAILABLE);
 144
 145         policyTypes.put(POLICY_TYPE_1);
 146
 147         services.put(SERVICE_1);
 148         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 149         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 150
 151         setUpCreationOfA1Client();
 152         simulateRicWithOnePolicyType();
 153
 154         RicSynchronizationTask synchronizerUnderTest =
 155             spy(new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services));
 156
 157         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 158         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.just("Ok"));
 159
 160         synchronizerUnderTest.run(RIC_1);
 161
 162         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 163         verifyNoMoreInteractions(a1ClientMock);
 164
 165         verify(synchronizerUnderTest).run(RIC_1);
 166         verify(synchronizerUnderTest).createNotificationClient(SERVICE_1_CALLBACK_URL);
 167         verifyNoMoreInteractions(synchronizerUnderTest);
 168
 169         verify(restClientMock).put("", "Synchronization completed for:" + RIC_1_NAME);
 170         verifyNoMoreInteractions(restClientMock);
 171
 172         assertThat(policyTypes.size()).isEqualTo(1);
 173         assertThat(policies.size()).isZero();
 174         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 175     }
 176
 177     @Test
 178     void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 179         RIC_1.setState(RicState.AVAILABLE);
 180
 181         setUpCreationOfA1Client();
 182         simulateRicWithOnePolicyType();
 183         String typeSchema = "schema";
 184         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 185
 186         RicSynchronizationTask synchronizerUnderTest =
 187             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 188
 189         synchronizerUnderTest.run(RIC_1);
 190
 191         verify(a1ClientMock).getPolicyTypeIdentities();
 192         verifyNoMoreInteractions(a1ClientMock);
 193
 194         assertThat(policyTypes.size()).isEqualTo(1);
 195         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).schema()).isEqualTo(typeSchema);
 196         assertThat(policies.size()).isZero();
 197         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 198     }
 199
 200     @Test
 201     void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 202         RIC_1.setState(RicState.AVAILABLE);
 203
 204         Policy transientPolicy = createPolicy("transientPolicyId", true);
 205
 206         policies.put(transientPolicy);
 207         policies.put(POLICY_1);
 208
 209         setUpCreationOfA1Client();
 210         simulateRicWithNoPolicyTypes();
 211
 212         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.just("OK"));
 213         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 214
 215         RicSynchronizationTask synchronizerUnderTest =
 216             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 217
 218         synchronizerUnderTest.run(RIC_1);
 219
 220         verify(a1ClientMock).deleteAllPolicies();
 221         verify(a1ClientMock).putPolicy(POLICY_1);
 222         verifyNoMoreInteractions(a1ClientMock);
 223
 224         assertThat(policyTypes.size()).isZero();
 225         assertThat(policies.size()).isEqualTo(1); // The transient policy shall be deleted
 226         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 227     }
 228
 229     @Test
 230     void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
 231         RIC_1.setState(RicState.AVAILABLE);
 232
 233         policies.put(POLICY_1);
 234
 235         setUpCreationOfA1Client();
 236         simulateRicWithNoPolicyTypes();
 237
 238         when(a1ClientMock.deleteAllPolicies()) //
 239             .thenReturn(Flux.error(new Exception("Exception"))) //
 240             .thenReturn(Flux.just("OK"));
 241
 242         RicSynchronizationTask synchronizerUnderTest =
 243             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 244
 245         synchronizerUnderTest.run(RIC_1);
 246
 247         verify(a1ClientMock, times(2)).deleteAllPolicies();
 248         verifyNoMoreInteractions(a1ClientMock);
 249
 250         assertThat(policyTypes.size()).isZero();
 251         assertThat(policies.size()).isZero();
 252         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 253     }
 254
 255     @Test
 256     void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 257         RIC_1.setState(RicState.AVAILABLE);
 258
 259         policies.put(POLICY_1);
 260
 261         setUpCreationOfA1Client();
 262         simulateRicWithNoPolicyTypes();
 263
 264         String originalErrorMessage = "Exception";
 265         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.error(new Exception(originalErrorMessage)));
 266
 267         RicSynchronizationTask synchronizerUnderTest =
 268             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 269
 270         final ListAppender<ILoggingEvent> logAppender =
 271             LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 272
 273         synchronizerUnderTest.run(RIC_1);
 274
 275         verifyCorrectLogMessage(0, logAppender,
 276             "Synchronization failure for ric: " + RIC_1_NAME + ", reason: " + originalErrorMessage);
 277
 278         verify(a1ClientMock, times(2)).deleteAllPolicies();
 279         verifyNoMoreInteractions(a1ClientMock);
 280
 281         assertThat(policyTypes.size()).isZero();
 282         assertThat(policies.size()).isZero();
 283         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 284     }
 285
 286     @Test
 287     void ricIdlePolicyTypeInRepo_thenSynchronizationWithErrorOnServiceNotificationErrorLogged() {
 288         RIC_1.setState(RicState.AVAILABLE);
 289
 290         policyTypes.put(POLICY_TYPE_1);
 291
 292         services.put(SERVICE_1);
 293
 294         setUpCreationOfA1Client();
 295         simulateRicWithOnePolicyType();
 296
 297         final ListAppender<ILoggingEvent> logAppender =
 298             LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 299
 300         RicSynchronizationTask synchronizerUnderTest =
 301             spy(new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services));
 302
 303         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 304         String originalErrorMessage = "Exception";
 305         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.error(new Exception(originalErrorMessage)));
 306
 307         synchronizerUnderTest.run(RIC_1);
 308
 309         ILoggingEvent loggingEvent = logAppender.list.get(0);
 310         assertThat(loggingEvent.getLevel()).isEqualTo(WARN);
 311         verifyCorrectLogMessage(0, logAppender,
 312             "Service notification failed for service: " + SERVICE_1_NAME + ". Cause: " + originalErrorMessage);
 313     }
 314
 315     private void setUpCreationOfA1Client() {
 316         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 317         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 318     }
 319
 320     private AsyncRestClient setUpCreationOfAsyncRestClient(RicSynchronizationTask synchronizerUnderTest) {
 321         AsyncRestClient restClientMock = mock(AsyncRestClient.class);
 322         doReturn(restClientMock).when(synchronizerUnderTest).createNotificationClient(anyString());
 323         return restClientMock;
 324     }
 325
 326     private void simulateRicWithOnePolicyType() {
 327         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 328     }
 329
 330     private void simulateRicWithNoPolicyTypes() {
 331         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 332     }
 333
 334     private void verifyCorrectLogMessage(int messageIndex, ListAppender<ILoggingEvent> logAppender,
 335         String expectedMessage) {
 336         ILoggingEvent loggingEvent = logAppender.list.get(messageIndex);
 337         assertThat(loggingEvent.getFormattedMessage()).isEqualTo(expectedMessage);
 338     }
 339 }