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