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