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