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 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.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 java.time.Duration;
  35 import java.time.Instant;
  36 import java.util.Arrays;
  37 import java.util.Collections;
  38
  39 import org.junit.jupiter.api.BeforeEach;
  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.ImmutableRicConfig;
  50 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
  51 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
  52 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyType;
  53 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
  54 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric;
  55 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric.RicState;
  56 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
  57 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Service;
  58 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Services;
  59
  60 import reactor.core.publisher.Flux;
  61 import reactor.core.publisher.Mono;
  62
  63 @ExtendWith(MockitoExtension.class)
  64 class RicSynchronizationTaskTest {
  65     private static final String POLICY_TYPE_1_NAME = "type1";
  66     private static final PolicyType POLICY_TYPE_1 = PolicyType.builder() //
  67             .id(POLICY_TYPE_1_NAME) //
  68             .schema("") //
  69             .build();
  70
  71     private static final String RIC_1_NAME = "ric1";
  72
  73     private static Ric ric1;
  74
  75     private static Policy createPolicy(String policyId, boolean isTransient) {
  76         return Policy.builder() //
  77                 .id(policyId) //
  78                 .json("") //
  79                 .ownerServiceId("service") //
  80                 .ric(ric1) //
  81                 .type(POLICY_TYPE_1) //
  82                 .lastModified(Instant.now()) //
  83                 .isTransient(isTransient) //
  84                 .statusNotificationUri("statusNotificationUri") //
  85                 .build();
  86     }
  87
  88     private static Policy policy1;
  89     private static final String SERVICE_1_NAME = "service1";
  90     private static final String SERVICE_1_CALLBACK_URL = "callbackUrl";
  91     private static Service service1;
  92
  93     @Mock
  94     private A1Client a1ClientMock;
  95
  96     @Mock
  97     private A1ClientFactory a1ClientFactoryMock;
  98
  99     private PolicyTypes policyTypes;
 100     private Policies policies;
 101     private Services services;
 102     private Rics rics;
 103
 104     private final ApplicationConfig appConfig = new ApplicationConfig();
 105
 106     @BeforeEach
 107     void init() {
 108         ric1 = new Ric(ImmutableRicConfig.builder() //
 109                 .ricId(RIC_1_NAME) //
 110                 .baseUrl("baseUrl1") //
 111                 .managedElementIds(Collections.emptyList()) //
 112                 .controllerName("controllerName") //
 113                 .customAdapterClass("") //
 114                 .build());
 115         policy1 = createPolicy("policyId1", false);
 116         policyTypes = new PolicyTypes(appConfig);
 117         policies = new Policies(appConfig);
 118         services = new Services(appConfig);
 119         rics = new Rics();
 120
 121         service1 = new Service(SERVICE_1_NAME, Duration.ofSeconds(1), SERVICE_1_CALLBACK_URL);
 122     }
 123
 124     private RicSynchronizationTask createTask() {
 125         ApplicationConfig config = new ApplicationConfig();
 126         AsyncRestClientFactory restClientFactory =
 127                 new AsyncRestClientFactory(config.getWebClientConfig(), new SecurityContext(""));
 128         return new RicSynchronizationTask(a1ClientFactoryMock, policyTypes, policies, services, restClientFactory,
 129                 rics);
 130     };
 131
 132     @Test
 133     void ricAlreadySynchronizing_thenNoSynchronization() {
 134         ric1.setState(RicState.SYNCHRONIZING);
 135         ric1.addSupportedPolicyType(POLICY_TYPE_1);
 136
 137         policyTypes.put(POLICY_TYPE_1);
 138         policies.put(policy1);
 139
 140         RicSynchronizationTask synchronizerUnderTest = createTask();
 141
 142         synchronizerUnderTest.run(ric1);
 143
 144         verifyNoInteractions(a1ClientMock);
 145
 146         assertThat(policyTypes.size()).isEqualTo(1);
 147         assertThat(policies.size()).isEqualTo(1);
 148         assertThat(ric1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 149         assertThat(ric1.getSupportedPolicyTypeNames()).hasSize(1);
 150     }
 151
 152     @Test
 153     void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
 154         rics.put(ric1);
 155         ric1.setState(RicState.AVAILABLE);
 156
 157         policyTypes.put(POLICY_TYPE_1);
 158
 159         services.put(service1);
 160         Service serviceWithoutCallbackUrlShouldNotBeNotified = new Service("service2", Duration.ofSeconds(1), "");
 161         services.put(serviceWithoutCallbackUrlShouldNotBeNotified);
 162
 163         setUpCreationOfA1Client();
 164         simulateRicWithOnePolicyType();
 165
 166         RicSynchronizationTask synchronizerUnderTest = spy(createTask());
 167
 168         ric1.setState(RicState.UNAVAILABLE);
 169         synchronizerUnderTest.run(ric1);
 170         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 171
 172         verify(a1ClientMock, times(1)).getPolicyTypeIdentities();
 173         verifyNoMoreInteractions(a1ClientMock);
 174
 175         verify(synchronizerUnderTest).run(ric1);
 176
 177         assertThat(policyTypes.size()).isEqualTo(1);
 178         assertThat(policies.size()).isZero();
 179         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 180     }
 181
 182     @Test
 183     void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
 184         ric1.setState(RicState.AVAILABLE);
 185         rics.put(ric1);
 186
 187         setUpCreationOfA1Client();
 188         simulateRicWithOnePolicyType();
 189         String typeSchema = "schema";
 190         when(a1ClientMock.getPolicyTypeSchema(POLICY_TYPE_1_NAME)).thenReturn(Mono.just(typeSchema));
 191
 192         RicSynchronizationTask synchronizerUnderTest = createTask();
 193
 194         ric1.setState(RicState.UNAVAILABLE);
 195         synchronizerUnderTest.run(ric1);
 196         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 197
 198         verify(a1ClientMock).getPolicyTypeIdentities();
 199         verifyNoMoreInteractions(a1ClientMock);
 200
 201         assertThat(policyTypes.size()).isEqualTo(1);
 202         assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).getSchema()).isEqualTo(typeSchema);
 203         assertThat(policies.size()).isZero();
 204         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 205     }
 206
 207     @Test
 208     void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
 209         ric1.setState(RicState.AVAILABLE);
 210         rics.put(ric1);
 211
 212         Policy transientPolicy = createPolicy("transientPolicyId", true);
 213
 214         policies.put(transientPolicy);
 215         policies.put(policy1);
 216
 217         setUpCreationOfA1Client();
 218         simulateRicWithNoPolicyTypes();
 219
 220         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.just("OK"));
 221         when(a1ClientMock.putPolicy(any(Policy.class))).thenReturn(Mono.just("OK"));
 222
 223         RicSynchronizationTask synchronizerUnderTest = createTask();
 224
 225         ric1.setState(RicState.UNAVAILABLE);
 226         synchronizerUnderTest.run(ric1);
 227         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 228
 229         verify(a1ClientMock).deleteAllPolicies();
 230         verify(a1ClientMock).putPolicy(policy1);
 231         verifyNoMoreInteractions(a1ClientMock);
 232
 233         assertThat(policyTypes.size()).isZero();
 234         assertThat(policies.size()).isEqualTo(1); // The transient policy shall be deleted
 235         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 236     }
 237
 238     @Test
 239     void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
 240         ric1.setState(RicState.AVAILABLE);
 241         rics.put(ric1);
 242
 243         policies.put(policy1);
 244
 245         setUpCreationOfA1Client();
 246         simulateRicWithNoPolicyTypes();
 247
 248         when(a1ClientMock.deleteAllPolicies()) //
 249                 .thenReturn(Flux.error(new Exception("Exception"))) //
 250                 .thenReturn(Flux.just("OK"));
 251
 252         RicSynchronizationTask synchronizerUnderTest = createTask();
 253
 254         ric1.setState(RicState.UNAVAILABLE);
 255         synchronizerUnderTest.run(ric1);
 256         await().untilAsserted(() -> RicState.AVAILABLE.equals(ric1.getState()));
 257
 258         verify(a1ClientMock, times(2)).deleteAllPolicies();
 259         verifyNoMoreInteractions(a1ClientMock);
 260
 261         assertThat(policyTypes.size()).isZero();
 262         assertThat(policies.size()).isZero();
 263         assertThat(ric1.getState()).isEqualTo(RicState.AVAILABLE);
 264     }
 265
 266     @Test
 267     void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
 268         setUpCreationOfA1Client();
 269         simulateRicWithNoPolicyTypes();
 270
 271         policies.put(policy1);
 272
 273         String originalErrorMessage = "Exception";
 274         when(a1ClientMock.deleteAllPolicies()).thenReturn(Flux.error(new Exception(originalErrorMessage)));
 275
 276         RicSynchronizationTask synchronizerUnderTest = createTask();
 277
 278         ric1.setState(RicState.AVAILABLE);
 279         synchronizerUnderTest.run(ric1);
 280         await().untilAsserted(() -> RicState.UNAVAILABLE.equals(ric1.getState()));
 281
 282         verify(a1ClientMock, times(2)).deleteAllPolicies();
 283         verifyNoMoreInteractions(a1ClientMock);
 284
 285         assertThat(policyTypes.size()).isZero();
 286         assertThat(policies.size()).isZero();
 287         assertThat(ric1.getState()).isEqualTo(RicState.UNAVAILABLE);
 288     }
 289
 290     private void setUpCreationOfA1Client() {
 291         when(a1ClientFactoryMock.createA1Client(any(Ric.class))).thenReturn(Mono.just(a1ClientMock));
 292         doReturn(Flux.empty()).when(a1ClientMock).deleteAllPolicies();
 293     }
 294
 295     private void simulateRicWithOnePolicyType() {
 296         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Arrays.asList(POLICY_TYPE_1_NAME)));
 297     }
 298
 299     private void simulateRicWithNoPolicyTypes() {
 300         when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just(Collections.emptyList()));
 301     }
 302 }