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