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

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * ONAP : ccsdk oran
   4  * ======================================================================
   5  * Copyright (C) 2020-2023 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 org.assertj.core.api.Assertions.assertThat;
  24 import static org.awaitility.Awaitility.await;
  25 import static org.mockito.ArgumentMatchers.any;
  26 import static org.mockito.ArgumentMatchers.anySet;
  27 import static org.mockito.Mockito.doReturn;
  28 import static org.mockito.Mockito.times;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.verifyNoMoreInteractions;
  31 import static org.mockito.Mockito.when;
  32
  33 import java.time.Duration;
  34 import java.time.Instant;
  35 import java.util.Arrays;
  36 import java.util.Collections;
  37
  38 import org.junit.jupiter.api.BeforeEach;
  39 import org.junit.jupiter.api.DisplayName;
  40 import org.junit.jupiter.api.Test;
  41 import org.junit.jupiter.api.extension.ExtendWith;
  42 import org.mockito.Mock;
  43 import org.mockito.junit.jupiter.MockitoExtension;
  44 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
  45 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
  46 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
  47 import org.onap.ccsdk.oran.a1policymanagementservice.clients.SecurityContext;
  48 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ApplicationConfig;
  49 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.RicConfig;
  50 import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
  51 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Lock.LockType;
  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.springframework.web.reactive.function.client.WebClientRequestException;
  62 import org.springframework.web.reactive.function.client.WebClientResponseException;
  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 = PolicyType.builder() //
  71             .id(POLICY_TYPE_1_NAME) //
  72             .schema("") //
  73             .build();
  74
  75     private static final String RIC_1_NAME = "ric1";
  76
  77     private static Ric ric1;
  78
  79     private static Policy createPolicy(String policyId, boolean isTransient) {
  80         return Policy.builder() //
  81                 .id(policyId) //
  82                 .json("") //
  83                 .ownerServiceId("service") //
  84                 .ric(ric1) //
  85                 .type(POLICY_TYPE_1) //
  86                 .lastModified(Instant.now()) //
  87                 .isTransient(isTransient) //
  88                 .statusNotificationUri("statusNotificationUri") //
  89                 .build();
  90     }
  91
  92     private static Policy policy1;
  93     private static final String SERVICE_1_NAME = "service1";
  94     private static final String SERVICE_1_CALLBACK_URL = "callbackUrl";
  95     private static Service service1;
  96
  97     @Mock
  98     private A1Client a1ClientMock;
  99
 100     @Mock
 101     private A1ClientFactory a1ClientFactoryMock;
 102
 103     private PolicyTypes policyTypes;
 104     private Policies policies;
 105     private Services services;
 106     private Rics rics;
 107
 108     private final ApplicationConfig appConfig = new ApplicationConfig();
 109
 110     @BeforeEach
 111     void init() {
 112         ric1 = new Ric(RicConfig.builder() //
 113                 .ricId(RIC_1_NAME) //
 114                 .baseUrl("baseUrl1") //
 115                 .controllerName("controllerName") //
 116                 .build());
 117         policy1 = createPolicy("policyId1", false);
 118         policyTypes = new PolicyTypes(appConfig);
 119         policies = new Policies(appConfig);
 120         services = new Services(appConfig);
 121         rics = new Rics();
 122
 123         service1 = new Service(SERVICE_1_NAME, Duration.ofSeconds(1), SERVICE_1_CALLBACK_URL);
 124     }
 125
 126     private RicSynchronizationTask createTask() {
 127         ApplicationConfig config = new ApplicationConfig();
 128         AsyncRestClientFactory restClientFactory =
 129                 new AsyncRestClientFactory(config.getWebClientConfig(), new SecurityContext(""));
 130         return new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services, restClientFactory,
 131                 rics);
 132     };
 133
 134     @Test
 135     @DisplayName("test ric Idle And Error Deleting Policies then Synchronization With Failed Recovery")
 136     void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 137         setUpCreationOfA1Client();
 138         simulateRicWithNoPolicyTypes();
 139         policies.put(policy1);
 140         WebClientResponseException exception = new WebClientResponseException(404, "", null, null, null);
 141         when(a1ClientMock.deleteAllPolicies(anySet())).thenReturn(Flux.error(exception));
 142         ric1.setState(RicState.AVAILABLE);
 143         runSynch(ric1);
 144         await().untilAsserted(() -> RicState.UNAVAILABLE.equals(ric1.getState()));
 145         assertThat(policies.size()).isZero();
 146         assertThat(ric1.getState()).isEqualTo(RicState.UNAVAILABLE);
 147     }
 148
 149     @Test
 150     @DisplayName("test Connection Error")
 151     void testConnectionError() {
 152         setUpCreationOfA1Client();
 153         simulateRicWithNoPolicyTypes();
 154         policies.put(policy1);
 155         WebClientRequestException exception = new WebClientRequestException(new ServiceException("x"), null, null,
 156                 new org.springframework.http.HttpHeaders());
 157         when(a1ClientMock.deleteAllPolicies(anySet())).thenReturn(Flux.error(exception));
 158         ric1.setState(RicState.AVAILABLE);
 159         runSynch(ric1);
 160         await().untilAsserted(() -> RicState.UNAVAILABLE.equals(ric1.getState()));
 161     }
 162
 163     @Test
 164     @DisplayName("test ric Idle then Synchronization With Reuse Of Type From Repo And Correct Service Notified")
 165     void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 166         rics.put(ric1);
 167         ric1.setState(RicState.AVAILABLE);
 168
 169         policyTypes.put(POLICY_TYPE_1);
 170
 171         services.put(service1);
 172         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 173         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 174
 175         setUpCreationOfA1Client();
 176         simulateRicWithOnePolicyType();
 177
 178         ric1.setState(RicState.UNAVAILABLE);
 179         runSynch(ric1);
 180         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 181
 182         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 183         verifyNoMoreInteractions(a1ClientMock);
 184
 185         assertThat(policyTypes.size()).isEqualTo(1);
 186         assertThat(policies.size()).isZero();
 187         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 188     }
 189
 190     @Test
 191     @DisplayName("test ric Idle then Synchronization With Type From Ric")
 192     void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 193         ric1.setState(RicState.AVAILABLE);
 194         rics.put(ric1);
 195
 196         setUpCreationOfA1Client();
 197         simulateRicWithOnePolicyType();
 198         String typeSchema = "schema";
 199         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 200
 201         ric1.setState(RicState.UNAVAILABLE);
 202         runSynch(ric1);
 203         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 204
 205         verify(a1ClientMock).getPolicyTypeIdentities();
 206         verifyNoMoreInteractions(a1ClientMock);
 207
 208         assertThat(policyTypes.size()).isEqualTo(1);
 209         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).getSchema()).isEqualTo(typeSchema);
 210         assertThat(policies.size()).isZero();
 211         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 212     }
 213
 214     @Test
 215     @DisplayName("test ric Idle then Synchronization With Recreation Of Policies")
 216     void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 217         ric1.setState(RicState.AVAILABLE);
 218         rics.put(ric1);
 219
 220         Policy transientPolicy = createPolicy("transientPolicyId", true);
 221
 222         policies.put(transientPolicy);
 223         policies.put(policy1);
 224
 225         setUpCreationOfA1Client();
 226         simulateRicWithNoPolicyTypes();
 227
 228         when(a1ClientMock.deleteAllPolicies(anySet())).thenReturn(Flux.just("OK"));
 229         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 230
 231         ric1.setState(RicState.UNAVAILABLE);
 232         runSynch(ric1);
 233         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 234
 235         verify(a1ClientMock).deleteAllPolicies(anySet());
 236         verify(a1ClientMock).putPolicy(policy1);
 237         verifyNoMoreInteractions(a1ClientMock);
 238
 239         assertThat(policyTypes.size()).isZero();
 240         assertThat(policies.size()).isEqualTo(1); // The transient policy shall be deleted
 241         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 242     }
 243
 244     private void runSynch(Ric ric) {
 245         RicSynchronizationTask synchronizerUnderTest = createTask();
 246         ric.getLock().lock(LockType.EXCLUSIVE, "RicSynchronizationTask") //
 247                 .flatMap(notUsed -> synchronizerUnderTest.synchronizeRic(ric)) //
 248                 .doFinally(sig -> ric.getLock().unlockBlocking()) //
 249                 .block();
 250     }
 251
 252     private void setUpCreationOfA1Client() {
 253         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 254         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies(anySet());
 255     }
 256
 257     private void simulateRicWithOnePolicyType() {
 258         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 259     }
 260
 261     private void simulateRicWithNoPolicyTypes() {
 262         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 263     }
 264 }