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