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.Mockito.doReturn;
  27 import static org.mockito.Mockito.spy;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.verifyNoInteractions;
  31 import static org.mockito.Mockito.verifyNoMoreInteractions;
  32 import static org.mockito.Mockito.when;
  33
  34 import ch.qos.logback.classic.spi.ILoggingEvent;
  35 import ch.qos.logback.core.read.ListAppender;
  36
  37 import java.time.Duration;
  38 import java.time.Instant;
  39 import java.util.Arrays;
  40 import java.util.Collections;
  41
  42 import org.junit.jupiter.api.BeforeEach;
  43 import org.junit.jupiter.api.Test;
  44 import org.junit.jupiter.api.extension.ExtendWith;
  45 import org.mockito.Mock;
  46 import org.mockito.junit.jupiter.MockitoExtension;
  47 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
  48 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
  49 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
  50 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ApplicationConfig;
  51 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ImmutableRicConfig;
  52 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
  53 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
  54 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyType;
  55 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
  56 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric;
  57 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric.RicState;
  58 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
  59 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Service;
  60 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Services;
  61 import org.onap.ccsdk.oran.a1policymanagementservice.utils.LoggingUtils;
  62
  63 import reactor.core.publisher.Flux;
  64 import reactor.core.publisher.Mono;
  65
  66 @ExtendWith(MockitoExtension.class)
  67 class RicSynchronizationTaskTest {
  68     private static final String POLICY_TYPE_1_NAME = "type1";
  69     private static final PolicyType POLICY_TYPE_1 = PolicyType.builder() //
  70             .id(POLICY_TYPE_1_NAME) //
  71             .schema("") //
  72             .build();
  73
  74     private static final String RIC_1_NAME = "ric1";
  75     private static final Ric RIC_1 = new Ric(ImmutableRicConfig.builder() //
  76             .ricId(RIC_1_NAME) //
  77             .baseUrl("baseUrl1") //
  78             .managedElementIds(Collections.emptyList()) //
  79             .controllerName("controllerName") //
  80             .build());
  81
  82     private static Policy createPolicy(String policyId, boolean isTransient) {
  83         return Policy.builder() //
  84                 .id(policyId) //
  85                 .json("") //
  86                 .ownerServiceId("service") //
  87                 .ric(RIC_1) //
  88                 .type(POLICY_TYPE_1) //
  89                 .lastModified(Instant.now()) //
  90                 .isTransient(isTransient) //
  91                 .statusNotificationUri("statusNotificationUri") //
  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     private Rics rics;
 111
 112     private final ApplicationConfig appConfig = new ApplicationConfig();
 113
 114     @BeforeEach
 115     void init() {
 116         policyTypes = new PolicyTypes(appConfig);
 117         policies = new Policies(appConfig);
 118         services = new Services();
 119         rics = new Rics();
 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                 rics);
 129     };
 130
 131     @Test
 132     void ricAlreadySynchronizing_thenNoSynchronization() {
 133         RIC_1.setState(RicState.SYNCHRONIZING);
 134         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 135
 136         policyTypes.put(POLICY_TYPE_1);
 137         policies.put(POLICY_1);
 138
 139         RicSynchronizationTask synchronizerUnderTest = createTask();
 140
 141         synchronizerUnderTest.run(RIC_1);
 142
 143         verifyNoInteractions(a1ClientMock);
 144
 145         assertThat(policyTypes.size()).isEqualTo(1);
 146         assertThat(policies.size()).isEqualTo(1);
 147         assertThat(RIC_1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 148         assertThat(RIC_1.getSupportedPolicyTypeNames()).hasSize(1);
 149     }
 150
 151     @Test
 152     void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 153         rics.put(RIC_1);
 154         RIC_1.setState(RicState.AVAILABLE);
 155
 156         policyTypes.put(POLICY_TYPE_1);
 157
 158         services.put(SERVICE_1);
 159         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 160         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 161
 162         setUpCreationOfA1Client();
 163         simulateRicWithOnePolicyType();
 164
 165         RicSynchronizationTask synchronizerUnderTest = spy(createTask());
 166
 167         synchronizerUnderTest.run(RIC_1);
 168
 169         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 170         verifyNoMoreInteractions(a1ClientMock);
 171
 172         verify(synchronizerUnderTest).run(RIC_1);
 173         verify(synchronizerUnderTest).notifyServices(any());
 174         verifyNoMoreInteractions(synchronizerUnderTest);
 175
 176         assertThat(policyTypes.size()).isEqualTo(1);
 177         assertThat(policies.size()).isZero();
 178         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 179     }
 180
 181     @Test
 182     void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 183         RIC_1.setState(RicState.AVAILABLE);
 184         rics.put(RIC_1);
 185
 186         setUpCreationOfA1Client();
 187         simulateRicWithOnePolicyType();
 188         String typeSchema = "schema";
 189         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 190
 191         RicSynchronizationTask synchronizerUnderTest = createTask();
 192
 193         synchronizerUnderTest.run(RIC_1);
 194
 195         verify(a1ClientMock).getPolicyTypeIdentities();
 196         verifyNoMoreInteractions(a1ClientMock);
 197
 198         assertThat(policyTypes.size()).isEqualTo(1);
 199         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).getSchema()).isEqualTo(typeSchema);
 200         assertThat(policies.size()).isZero();
 201         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 202     }
 203
 204     @Test
 205     void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 206         RIC_1.setState(RicState.AVAILABLE);
 207         rics.put(RIC_1);
 208
 209         Policy transientPolicy = createPolicy("transientPolicyId", true);
 210
 211         policies.put(transientPolicy);
 212         policies.put(POLICY_1);
 213
 214         setUpCreationOfA1Client();
 215         simulateRicWithNoPolicyTypes();
 216
 217         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.just("OK"));
 218         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 219
 220         RicSynchronizationTask synchronizerUnderTest = createTask();
 221
 222         synchronizerUnderTest.run(RIC_1);
 223
 224         verify(a1ClientMock).deleteAllPolicies();
 225         verify(a1ClientMock).putPolicy(POLICY_1);
 226         verifyNoMoreInteractions(a1ClientMock);
 227
 228         assertThat(policyTypes.size()).isZero();
 229         assertThat(policies.size()).isEqualTo(1); // The transient policy shall be deleted
 230         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 231     }
 232
 233     @Test
 234     void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
 235         RIC_1.setState(RicState.AVAILABLE);
 236         rics.put(RIC_1);
 237
 238         policies.put(POLICY_1);
 239
 240         setUpCreationOfA1Client();
 241         simulateRicWithNoPolicyTypes();
 242
 243         when(a1ClientMock.deleteAllPolicies()) //
 244                 .thenReturn(Flux.error(new Exception("Exception"))) //
 245                 .thenReturn(Flux.just("OK"));
 246
 247         RicSynchronizationTask synchronizerUnderTest = createTask();
 248
 249         synchronizerUnderTest.run(RIC_1);
 250
 251         verify(a1ClientMock, times(2)).deleteAllPolicies();
 252         verifyNoMoreInteractions(a1ClientMock);
 253
 254         assertThat(policyTypes.size()).isZero();
 255         assertThat(policies.size()).isZero();
 256         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 257     }
 258
 259     @Test
 260     void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 261         RIC_1.setState(RicState.AVAILABLE);
 262
 263         policies.put(POLICY_1);
 264
 265         setUpCreationOfA1Client();
 266         simulateRicWithNoPolicyTypes();
 267
 268         String originalErrorMessage = "Exception";
 269         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.error(new Exception(originalErrorMessage)));
 270
 271         RicSynchronizationTask synchronizerUnderTest = createTask();
 272
 273         final ListAppender<ILoggingEvent> logAppender =
 274                 LoggingUtils.getLogListAppender(RicSynchronizationTask.class, WARN);
 275
 276         synchronizerUnderTest.run(RIC_1);
 277
 278         verifyCorrectLogMessage(0, logAppender,
 279                 "Synchronization failure for ric: " + RIC_1_NAME + ", reason: " + originalErrorMessage);
 280
 281         verify(a1ClientMock, times(2)).deleteAllPolicies();
 282         verifyNoMoreInteractions(a1ClientMock);
 283
 284         assertThat(policyTypes.size()).isZero();
 285         assertThat(policies.size()).isZero();
 286         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 287     }
 288
 289     private void setUpCreationOfA1Client() {
 290         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 291         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 292     }
 293
 294     private void simulateRicWithOnePolicyType() {
 295         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 296     }
 297
 298     private void simulateRicWithNoPolicyTypes() {
 299         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 300     }
 301
 302     private void verifyCorrectLogMessage(int messageIndex, ListAppender<ILoggingEvent> logAppender,
 303             String expectedMessage) {
 304         ILoggingEvent loggingEvent = logAppender.list.get(messageIndex);
 305         assertThat(loggingEvent.getFormattedMessage()).isEqualTo(expectedMessage);
 306     }
 307 }