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