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.mockito.ArgumentMatchers.any;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.spy;
  27 import static org.mockito.Mockito.times;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30
  31 import java.time.Instant;
  32 import java.util.ArrayList;
  33 import java.util.Arrays;
  34 import java.util.Collections;
  35 import java.util.List;
  36 import java.util.Vector;
  37
  38 import org.junit.jupiter.api.AfterEach;
  39 import org.junit.jupiter.api.BeforeEach;
  40 import org.junit.jupiter.api.DisplayName;
  41 import org.junit.jupiter.api.Test;
  42 import org.junit.jupiter.api.extension.ExtendWith;
  43 import org.mockito.Mock;
  44 import org.mockito.junit.jupiter.MockitoExtension;
  45 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
  46 import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
  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.repository.Lock;
  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 reactor.core.publisher.Mono;
  60
  61 @ExtendWith(MockitoExtension.class)
  62 class RicSupervisionTest {
  63     private static final String POLICY_TYPE_1_NAME = "type1";
  64     private static final PolicyType POLICY_TYPE_1 = PolicyType.builder() //
  65             .id(POLICY_TYPE_1_NAME) //
  66             .schema("") //
  67             .build();
  68
  69     private static final Ric RIC_1 = new Ric(RicConfig.builder() //
  70             .ricId("ric_1") //
  71             .baseUrl("baseUrl1") //
  72             .managedElementIds(new Vector<String>(Arrays.asList("kista_1", "kista_2"))) //
  73             .build());
  74
  75     private static final String POLICY_1_ID = "policyId1";
  76     private static final Policy POLICY_1 = Policy.builder() //
  77             .id(POLICY_1_ID) //
  78             .json("") //
  79             .ownerServiceId("service") //
  80             .ric(RIC_1) //
  81             .type(POLICY_TYPE_1) //
  82             .lastModified(Instant.now()) //
  83             .isTransient(false) //
  84             .statusNotificationUri("statusNotificationUri") //
  85             .build();
  86
  87     private static final Policy POLICY_2 = Policy.builder() //
  88             .id("policyId2") //
  89             .json("") //
  90             .ownerServiceId("service") //
  91             .ric(RIC_1) //
  92             .type(POLICY_TYPE_1) //
  93             .lastModified(Instant.now()) //
  94             .isTransient(false) //
  95             .statusNotificationUri("statusNotificationUri") //
  96             .build();
  97
  98     @Mock
  99     private A1Client a1ClientMock;
 100
 101     @Mock
 102     private A1ClientFactory a1ClientFactory;
 103
 104     @Mock
 105     private RicSynchronizationTask synchronizationTaskMock;
 106
 107     private final ApplicationConfig appConfig = new ApplicationConfig();
 108
 109     private PolicyTypes types;
 110     private Policies policies;
 111     private Rics rics = new Rics();
 112
 113     @BeforeEach
 114     void init() {
 115         types = new PolicyTypes(appConfig);
 116         policies = new Policies(appConfig);
 117
 118         rics.clear();
 119         RIC_1.setState(RicState.UNAVAILABLE);
 120         RIC_1.clearSupportedPolicyTypes();
 121     }
 122
 123     @AfterEach
 124     void verifyNoRicLocks() {
 125         for (Ric ric : this.rics.getRics()) {
 126             Lock.Grant grant = ric.getLock().lockBlocking(LockType.EXCLUSIVE, "");
 127             grant.unlockBlocking();
 128             assertThat(ric.getLock().getLockCounter()).isZero();
 129         }
 130     }
 131
 132     @Test
 133     @DisplayName("test when Ric Idle And No Changed Policies Or PolicyTypes then No Synchronization")
 134     void whenRicIdleAndNoChangedPoliciesOrPolicyTypes_thenNoSynchronization() {
 135         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 136         RIC_1.setState(RicState.AVAILABLE);
 137         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 138         rics.put(RIC_1);
 139
 140         types.put(POLICY_TYPE_1);
 141
 142         policies.put(POLICY_1);
 143
 144         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID)));
 145         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME)));
 146
 147         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 148
 149         supervisorUnderTest.checkAllRics();
 150
 151         verify(supervisorUnderTest).checkAllRics();
 152         verify(synchronizationTaskMock, times(0)).synchronizeRic(RIC_1);
 153         assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
 154     }
 155
 156     @Test
 157     @DisplayName("test when Ric Undefined then Synchronization")
 158     void whenRicUndefined_thenSynchronization() {
 159         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 160         RIC_1.setState(RicState.UNAVAILABLE);
 161         rics.put(RIC_1);
 162         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 163         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 164         doReturn(Mono.just(RIC_1)).when(synchronizationTaskMock).synchronizeRic(any());
 165         supervisorUnderTest.checkAllRics();
 166         verify(synchronizationTaskMock).synchronizeRic(RIC_1);
 167
 168         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 169     }
 170
 171     @Test
 172     @DisplayName("test when Ric Synchronizing then No Synchronization")
 173     void whenRicSynchronizing_thenNoSynchronization() {
 174         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 175         RIC_1.setState(RicState.SYNCHRONIZING);
 176         rics.put(RIC_1);
 177
 178         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 179
 180         supervisorUnderTest.checkAllRics();
 181
 182         verify(supervisorUnderTest).checkAllRics();
 183         verify(synchronizationTaskMock, times(0)).synchronizeRic(RIC_1);
 184         assertThat(RIC_1.getState()).isEqualTo(RicState.SYNCHRONIZING);
 185     }
 186
 187     @Test
 188     @DisplayName("test when Ric Idle And Error Getting Policy Identities then No Synchronization")
 189     void whenRicIdleAndErrorGettingPolicyIdentities_thenNoSynchronization() {
 190         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 191         RIC_1.setState(RicState.AVAILABLE);
 192         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 193         rics.put(RIC_1);
 194
 195         setUpGetPolicyIdentitiesToReturn(new Exception("Failed"));
 196
 197         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 198         supervisorUnderTest.checkAllRics();
 199
 200         verify(supervisorUnderTest).checkAllRics();
 201         verify(synchronizationTaskMock, times(0)).synchronizeRic(RIC_1);
 202
 203         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 204     }
 205
 206     @Test
 207     @DisplayName("test when Ric Idle And Not Same Amount Of Policies then Synchronization")
 208     void whenRicIdleAndNotSameAmountOfPolicies_thenSynchronization() {
 209         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 210         RIC_1.setState(RicState.AVAILABLE);
 211         rics.put(RIC_1);
 212
 213         policies.put(POLICY_1);
 214         policies.put(POLICY_2);
 215
 216         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID)));
 217
 218         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 219
 220         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 221
 222         supervisorUnderTest.checkAllRics();
 223
 224         verify(supervisorUnderTest).checkAllRics();
 225         verify(synchronizationTaskMock).synchronizeRic(RIC_1);
 226
 227         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 228     }
 229
 230     @Test
 231     @DisplayName("test when Ric Idle And Same Amount Of Policies But Not Same Policies then Synchronization")
 232     void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenSynchronization() {
 233         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 234         RIC_1.setState(RicState.AVAILABLE);
 235         rics.put(RIC_1);
 236
 237         policies.put(POLICY_1);
 238         policies.put(POLICY_2);
 239
 240         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID, "Another_policy")));
 241
 242         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 243
 244         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 245
 246         supervisorUnderTest.checkAllRics();
 247
 248         verify(supervisorUnderTest).checkAllRics();
 249         verify(synchronizationTaskMock).synchronizeRic(RIC_1);
 250
 251         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 252     }
 253
 254     @Test
 255     @DisplayName("test when Ric Idle And Error Getting Policy Types then No Synchronization")
 256     void whenRicIdleAndErrorGettingPolicyTypes_thenNoSynchronization() {
 257         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 258         RIC_1.setState(RicState.AVAILABLE);
 259         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 260         rics.put(RIC_1);
 261
 262         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 263         setUpGetPolicyTypeIdentitiesToReturn(new Exception("Failed"));
 264
 265         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 266         supervisorUnderTest.checkAllRics();
 267
 268         verify(supervisorUnderTest).checkAllRics();
 269         verify(synchronizationTaskMock, times(0)).synchronizeRic(RIC_1);
 270
 271         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 272     }
 273
 274     @Test
 275     @DisplayName("test when Ric Idle And Not Same Amount Of PolicyTypes then Synchronization")
 276     void whenRicIdleAndNotSameAmountOfPolicyTypes_thenSynchronization() {
 277         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 278         RIC_1.setState(RicState.AVAILABLE);
 279         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 280         rics.put(RIC_1);
 281
 282         types.put(POLICY_TYPE_1);
 283
 284         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 285         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 286
 287         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 288
 289         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 290
 291         supervisorUnderTest.checkAllRics();
 292
 293         verify(supervisorUnderTest).checkAllRics();
 294         verify(synchronizationTaskMock).synchronizeRic(RIC_1);
 295
 296         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 297     }
 298
 299     @Test
 300     @DisplayName("test when Ric Idle And Same Amount Of Policy Types But Not Same Types then Synchronization")
 301     void whenRicIdleAndSameAmountOfPolicyTypesButNotSameTypes_thenSynchronization() {
 302         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 303         PolicyType policyType2 = PolicyType.builder() //
 304                 .id("policyType2") //
 305                 .schema("") //
 306                 .build();
 307
 308         RIC_1.setState(RicState.AVAILABLE);
 309         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 310         RIC_1.addSupportedPolicyType(policyType2);
 311         rics.put(RIC_1);
 312
 313         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 314         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 315
 316         RicSupervision supervisorUnderTest = spy(createRicSupervision());
 317
 318         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 319
 320         supervisorUnderTest.checkAllRics();
 321
 322         verify(supervisorUnderTest).checkAllRics();
 323         verify(synchronizationTaskMock).synchronizeRic(RIC_1);
 324         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 325     }
 326
 327     @SuppressWarnings("unchecked")
 328     private void setUpGetPolicyIdentitiesToReturn(Object returnValue) {
 329         if (returnValue instanceof List<?>) {
 330             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 331         } else if (returnValue instanceof Exception) {
 332             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.error((Exception) returnValue));
 333         }
 334     }
 335
 336     @SuppressWarnings("unchecked")
 337     private void setUpGetPolicyTypeIdentitiesToReturn(Object returnValue) {
 338         if (returnValue instanceof List<?>) {
 339             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 340         } else if (returnValue instanceof Exception) {
 341             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.error((Exception) returnValue));
 342         }
 343     }
 344
 345     private RicSupervision createRicSupervision() {
 346         ApplicationConfig config = new ApplicationConfig();
 347         return new RicSupervision(rics, policies, a1ClientFactory, types, null, config, new SecurityContext(""));
 348     }
 349 }