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 public 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         .build());
  81
  82     private static final Policy POLICY_1 = ImmutablePolicy.builder() //
  83         .id("policyId1") //
  84         .json("") //
  85         .ownerServiceName("service") //
  86         .ric(RIC_1) //
  87         .type(POLICY_TYPE_1) //
  88         .lastModified("now") //
  89         .build();
  90
  91     private static final String SERVICE_1_NAME = "service1";
  92     private static final String SERVICE_1_CALLBACK_URL = "callbackUrl";
  93     private static final Service SERVICE_1 = new Service(SERVICE_1_NAME, Duration.ofSeconds(1), SERVICE_1_CALLBACK_URL);
  94
  95     @Mock
  96     private A1Client a1ClientMock;
  97
  98     @Mock
  99     private A1ClientFactory a1ClientFactoryMock;
 100
 101     private PolicyTypes policyTypes;
 102     private Policies policies;
 103     private Services services;
 104
 105     @BeforeEach
 106     public void init() {
 107         policyTypes = new PolicyTypes();
 108         policies = new Policies();
 109         services = new Services();
 110         RIC_1.setState(RicState.UNDEFINED);
 111         RIC_1.clearSupportedPolicyTypes();
 112     }
 113
 114     @Test
 115     public void ricAlreadySynchronizing_thenNoSynchronization() {
 116         RIC_1.setState(RicState.SYNCHRONIZING);
 117         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 118
 119         policyTypes.put(POLICY_TYPE_1);
 120         policies.put(POLICY_1);
 121
 122         RicSynchronizationTask synchronizerUnderTest =
 123             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 124
 125         synchronizerUnderTest.run(RIC_1);
 126
 127         verifyNoInteractions(a1ClientMock);
 128
 129         assertThat(policyTypes.size()).isEqualTo(1);
 130         assertThat(policies.size()).isEqualTo(1);
 131         assertThat(RIC_1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 132         assertThat(RIC_1.getSupportedPolicyTypeNames().size()).isEqualTo(1);
 133     }
 134
 135     @Test
 136     public void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 137         RIC_1.setState(RicState.IDLE);
 138
 139         policyTypes.put(POLICY_TYPE_1);
 140
 141         services.put(SERVICE_1);
 142         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 143         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 144
 145         setUpCreationOfA1Client();
 146         simulateRicWithOnePolicyType();
 147
 148         RicSynchronizationTask synchronizerUnderTest =
 149             spy(new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services));
 150
 151         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 152         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.just("Ok"));
 153
 154         synchronizerUnderTest.run(RIC_1);
 155
 156         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 157         verifyNoMoreInteractions(a1ClientMock);
 158
 159         verify(synchronizerUnderTest).run(RIC_1);
 160         verify(synchronizerUnderTest).createNotificationClient(SERVICE_1_CALLBACK_URL);
 161         verifyNoMoreInteractions(synchronizerUnderTest);
 162
 163         verify(restClientMock).put("", "Synchronization completed for:" + RIC_1_NAME);
 164         verifyNoMoreInteractions(restClientMock);
 165
 166         assertThat(policyTypes.size()).isEqualTo(1);
 167         assertThat(policies.size()).isEqualTo(0);
 168         assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
 169     }
 170
 171     @Test
 172     public void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 173         RIC_1.setState(RicState.IDLE);
 174
 175         setUpCreationOfA1Client();
 176         simulateRicWithOnePolicyType();
 177         String typeSchema = "schema";
 178         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 179
 180         RicSynchronizationTask synchronizerUnderTest =
 181             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 182
 183         synchronizerUnderTest.run(RIC_1);
 184
 185         verify(a1ClientMock).getPolicyTypeIdentities();
 186         verifyNoMoreInteractions(a1ClientMock);
 187
 188         assertThat(policyTypes.size()).isEqualTo(1);
 189         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).schema()).isEqualTo(typeSchema);
 190         assertThat(policies.size()).isEqualTo(0);
 191         assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
 192     }
 193
 194     @Test
 195     public void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 196         RIC_1.setState(RicState.IDLE);
 197
 198         policies.put(POLICY_1);
 199
 200         setUpCreationOfA1Client();
 201         simulateRicWithNoPolicyTypes();
 202
 203         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.just("OK"));
 204         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 205
 206         RicSynchronizationTask synchronizerUnderTest =
 207             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 208
 209         synchronizerUnderTest.run(RIC_1);
 210
 211         verify(a1ClientMock).deleteAllPolicies();
 212         verify(a1ClientMock).putPolicy(POLICY_1);
 213         verifyNoMoreInteractions(a1ClientMock);
 214
 215         assertThat(policyTypes.size()).isEqualTo(0);
 216         assertThat(policies.size()).isEqualTo(1);
 217         assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
 218     }
 219
 220     @Test
 221     public void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
 222         RIC_1.setState(RicState.IDLE);
 223
 224         policies.put(POLICY_1);
 225
 226         setUpCreationOfA1Client();
 227         simulateRicWithNoPolicyTypes();
 228
 229         when(a1ClientMock.deleteAllPolicies()) //
 230             .thenReturn(Flux.error(new Exception("Exception"))) //
 231             .thenReturn(Flux.just("OK"));
 232
 233         RicSynchronizationTask synchronizerUnderTest =
 234             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 235
 236         synchronizerUnderTest.run(RIC_1);
 237
 238         verify(a1ClientMock, times(2)).deleteAllPolicies();
 239         verifyNoMoreInteractions(a1ClientMock);
 240
 241         assertThat(policyTypes.size()).isEqualTo(0);
 242         assertThat(policies.size()).isEqualTo(0);
 243         assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
 244     }
 245
 246     @Test
 247     public void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 248         RIC_1.setState(RicState.IDLE);
 249
 250         policies.put(POLICY_1);
 251
 252         setUpCreationOfA1Client();
 253         simulateRicWithNoPolicyTypes();
 254
 255         String originalErrorMessage = "Exception";
 256         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.error(new Exception(originalErrorMessage)));
 257
 258         RicSynchronizationTask synchronizerUnderTest =
 259             new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services);
 260
 261         final ListAppender<ILoggingEvent> logAppender =
 262             LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 263
 264         synchronizerUnderTest.run(RIC_1);
 265
 266         verifyCorrectLogMessage(0, logAppender,
 267             "Recreation of policies failed for ric: " + RIC_1_NAME + ", reason: " + originalErrorMessage);
 268
 269         verify(a1ClientMock, times(2)).deleteAllPolicies();
 270         verifyNoMoreInteractions(a1ClientMock);
 271
 272         assertThat(policyTypes.size()).isEqualTo(0);
 273         assertThat(policies.size()).isEqualTo(0);
 274         assertThat(RIC_1.getState()).isEqualTo(RicState.UNDEFINED);
 275     }
 276
 277     @Test
 278     public void ricIdlePolicyTypeInRepo_thenSynchronizationWithErrorOnServiceNotificationErrorLogged() {
 279         RIC_1.setState(RicState.IDLE);
 280
 281         policyTypes.put(POLICY_TYPE_1);
 282
 283         services.put(SERVICE_1);
 284
 285         setUpCreationOfA1Client();
 286         simulateRicWithOnePolicyType();
 287
 288         final ListAppender<ILoggingEvent> logAppender =
 289             LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 290
 291         RicSynchronizationTask synchronizerUnderTest =
 292             spy(new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services));
 293
 294         AsyncRestClient restClientMock = setUpCreationOfAsyncRestClient(synchronizerUnderTest);
 295         String originalErrorMessage = "Exception";
 296         when(restClientMock.put(anyString(), anyString())).thenReturn(Mono.error(new Exception(originalErrorMessage)));
 297
 298         synchronizerUnderTest.run(RIC_1);
 299
 300         ILoggingEvent loggingEvent = logAppender.list.get(0);
 301         assertThat(loggingEvent.getThrowableProxy().getMessage()).isEqualTo(originalErrorMessage);
 302         verifyCorrectLogMessage(0, logAppender, "Service notification failed for service: " + SERVICE_1_NAME);
 303     }
 304
 305     private void setUpCreationOfA1Client() {
 306         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 307         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 308     }
 309
 310     private AsyncRestClient setUpCreationOfAsyncRestClient(RicSynchronizationTask synchronizerUnderTest) {
 311         AsyncRestClient restClientMock = mock(AsyncRestClient.class);
 312         doReturn(restClientMock).when(synchronizerUnderTest).createNotificationClient(anyString());
 313         return restClientMock;
 314     }
 315
 316     private void simulateRicWithOnePolicyType() {
 317         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 318     }
 319
 320     private void simulateRicWithNoPolicyTypes() {
 321         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 322     }
 323
 324     private void verifyCorrectLogMessage(int messageIndex, ListAppender<ILoggingEvent> logAppender,
 325         String expectedMessage) {
 326         ILoggingEvent loggingEvent = logAppender.list.get(messageIndex);
 327         assertThat(loggingEvent.toString().contains(expectedMessage)).isTrue();
 328     }
 329 }