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