policy-agent/src/test/java/org/oransc/policyagent/tasks/RicSupervisionTest.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2020 Nordix Foundation
   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.oransc.policyagent.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.util.ArrayList;
  32 import java.util.Arrays;
  33 import java.util.Collections;
  34 import java.util.List;
  35 import java.util.Vector;
  36
  37 import org.junit.jupiter.api.AfterEach;
  38 import org.junit.jupiter.api.BeforeEach;
  39 import org.junit.jupiter.api.Test;
  40 import org.junit.jupiter.api.extension.ExtendWith;
  41 import org.mockito.Mock;
  42 import org.mockito.junit.jupiter.MockitoExtension;
  43 import org.oransc.policyagent.clients.A1Client;
  44 import org.oransc.policyagent.clients.A1ClientFactory;
  45 import org.oransc.policyagent.configuration.ImmutableRicConfig;
  46 import org.oransc.policyagent.repository.ImmutablePolicy;
  47 import org.oransc.policyagent.repository.ImmutablePolicyType;
  48 import org.oransc.policyagent.repository.Lock.LockType;
  49 import org.oransc.policyagent.repository.Policies;
  50 import org.oransc.policyagent.repository.Policy;
  51 import org.oransc.policyagent.repository.PolicyType;
  52 import org.oransc.policyagent.repository.PolicyTypes;
  53 import org.oransc.policyagent.repository.Ric;
  54 import org.oransc.policyagent.repository.Ric.RicState;
  55 import org.oransc.policyagent.repository.Rics;
  56 import reactor.core.publisher.Mono;
  57
  58 @ExtendWith(MockitoExtension.class)
  59 public class RicSupervisionTest {
  60     private static final String POLICY_TYPE_1_NAME = "type1";
  61     private static final PolicyType POLICY_TYPE_1 = ImmutablePolicyType.builder() //
  62         .name(POLICY_TYPE_1_NAME) //
  63         .schema("") //
  64         .build();
  65
  66     private static final Ric RIC_1 = new Ric(ImmutableRicConfig.builder() //
  67         .name("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 = ImmutablePolicy.builder() //
  75         .id(POLICY_1_ID) //
  76         .json("") //
  77         .ownerServiceName("service") //
  78         .ric(RIC_1) //
  79         .type(POLICY_TYPE_1) //
  80         .lastModified("now") //
  81         .build();
  82
  83     private static final Policy POLICY_2 = ImmutablePolicy.builder() //
  84         .id("policyId2") //
  85         .json("") //
  86         .ownerServiceName("service") //
  87         .ric(RIC_1) //
  88         .type(POLICY_TYPE_1) //
  89         .lastModified("now") //
  90         .build();
  91
  92     @Mock
  93     private A1Client a1ClientMock;
  94
  95     @Mock
  96     private A1ClientFactory a1ClientFactory;
  97
  98     @Mock
  99     private RicSynchronizationTask synchronizationTaskMock;
 100
 101     private final PolicyTypes types = new PolicyTypes();
 102     private Policies policies = new Policies();
 103     private Rics rics = new Rics();
 104
 105     @BeforeEach
 106     public void init() {
 107         types.clear();
 108         policies.clear();
 109         rics.clear();
 110         RIC_1.setState(RicState.UNAVAILABLE);
 111         RIC_1.clearSupportedPolicyTypes();
 112     }
 113
 114     @AfterEach
 115     public void verifyNoRicLocks() {
 116         for (Ric ric : this.rics.getRics()) {
 117             ric.getLock().lockBlocking(LockType.EXCLUSIVE);
 118             ric.getLock().unlockBlocking();
 119             assertThat(ric.getLock().getLockCounter()).isEqualTo(0);
 120         }
 121     }
 122
 123     @Test
 124     public void whenRicIdleAndNoChangedPoliciesOrPolicyTypes_thenNoSynchronization() {
 125         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 126         RIC_1.setState(RicState.AVAILABLE);
 127         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 128         rics.put(RIC_1);
 129
 130         types.put(POLICY_TYPE_1);
 131
 132         policies.put(POLICY_1);
 133
 134         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID)));
 135         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME)));
 136
 137         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 138
 139         supervisorUnderTest.checkAllRics();
 140
 141         verify(supervisorUnderTest).checkAllRics();
 142         verifyNoMoreInteractions(supervisorUnderTest);
 143     }
 144
 145     @Test
 146     public void whenRicUndefined_thenSynchronization() {
 147         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 148         RIC_1.setState(RicState.UNAVAILABLE);
 149         rics.put(RIC_1);
 150
 151         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 152
 153         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 154
 155         supervisorUnderTest.checkAllRics();
 156
 157         verify(supervisorUnderTest).checkAllRics();
 158         verify(supervisorUnderTest).createSynchronizationTask();
 159         verify(synchronizationTaskMock).run(RIC_1);
 160         verifyNoMoreInteractions(supervisorUnderTest);
 161     }
 162
 163     @Test
 164     public void whenRicSynchronizing_thenNoSynchronization() {
 165         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 166         RIC_1.setState(RicState.SYNCHRONIZING);
 167         rics.put(RIC_1);
 168
 169         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 170
 171         supervisorUnderTest.checkAllRics();
 172
 173         verify(supervisorUnderTest).checkAllRics();
 174         verifyNoMoreInteractions(supervisorUnderTest);
 175     }
 176
 177     @Test
 178     public void whenRicIdleAndErrorGettingPolicyIdentities_thenNoSynchronization() {
 179         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 180         RIC_1.setState(RicState.AVAILABLE);
 181         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 182         rics.put(RIC_1);
 183
 184         setUpGetPolicyIdentitiesToReturn(new Exception("Failed"));
 185
 186         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 187         supervisorUnderTest.checkAllRics();
 188
 189         verify(supervisorUnderTest).checkAllRics();
 190         verifyNoMoreInteractions(supervisorUnderTest);
 191         assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
 192     }
 193
 194     @Test
 195     public void whenRicIdleAndNotSameAmountOfPolicies_thenSynchronization() {
 196         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 197         RIC_1.setState(RicState.AVAILABLE);
 198         rics.put(RIC_1);
 199
 200         policies.put(POLICY_1);
 201         policies.put(POLICY_2);
 202
 203         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID)));
 204
 205         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 206
 207         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 208
 209         supervisorUnderTest.checkAllRics();
 210
 211         verify(supervisorUnderTest).checkAllRics();
 212         verify(supervisorUnderTest).createSynchronizationTask();
 213         verify(synchronizationTaskMock).run(RIC_1);
 214         verifyNoMoreInteractions(supervisorUnderTest);
 215     }
 216
 217     @Test
 218     public void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenSynchronization() {
 219         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 220         RIC_1.setState(RicState.AVAILABLE);
 221         rics.put(RIC_1);
 222
 223         policies.put(POLICY_1);
 224         policies.put(POLICY_2);
 225
 226         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID, "Another_policy")));
 227
 228         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 229
 230         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 231
 232         supervisorUnderTest.checkAllRics();
 233
 234         verify(supervisorUnderTest).checkAllRics();
 235         verify(supervisorUnderTest).createSynchronizationTask();
 236         verify(synchronizationTaskMock).run(RIC_1);
 237         verifyNoMoreInteractions(supervisorUnderTest);
 238     }
 239
 240     @Test
 241     public void whenRicIdleAndErrorGettingPolicyTypes_thenNoSynchronization() {
 242         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 243         RIC_1.setState(RicState.AVAILABLE);
 244         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 245         rics.put(RIC_1);
 246
 247         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 248         setUpGetPolicyTypeIdentitiesToReturn(new Exception("Failed"));
 249
 250         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 251         supervisorUnderTest.checkAllRics();
 252
 253         verify(supervisorUnderTest).checkAllRics();
 254         verifyNoMoreInteractions(supervisorUnderTest);
 255     }
 256
 257     @Test
 258     public void whenRicIdleAndNotSameAmountOfPolicyTypes_thenSynchronization() {
 259         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 260         RIC_1.setState(RicState.AVAILABLE);
 261         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 262         rics.put(RIC_1);
 263
 264         types.put(POLICY_TYPE_1);
 265
 266         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 267         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 268
 269         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 270
 271         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 272
 273         supervisorUnderTest.checkAllRics();
 274
 275         verify(supervisorUnderTest).checkAllRics();
 276         verify(supervisorUnderTest).createSynchronizationTask();
 277         verify(synchronizationTaskMock).run(RIC_1);
 278         verifyNoMoreInteractions(supervisorUnderTest);
 279     }
 280
 281     @Test
 282     public void whenRicIdleAndSameAmountOfPolicyTypesButNotSameTypes_thenSynchronization() {
 283         doReturn(Mono.just(a1ClientMock)).when(a1ClientFactory).createA1Client(any(Ric.class));
 284         PolicyType policyType2 = ImmutablePolicyType.builder() //
 285             .name("policyType2") //
 286             .schema("") //
 287             .build();
 288
 289         RIC_1.setState(RicState.AVAILABLE);
 290         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 291         RIC_1.addSupportedPolicyType(policyType2);
 292         rics.put(RIC_1);
 293
 294         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 295         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 296
 297         RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
 298
 299         doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 300
 301         supervisorUnderTest.checkAllRics();
 302
 303         verify(supervisorUnderTest).checkAllRics();
 304         verify(supervisorUnderTest).createSynchronizationTask();
 305         verify(synchronizationTaskMock).run(RIC_1);
 306         verifyNoMoreInteractions(supervisorUnderTest);
 307     }
 308
 309     @SuppressWarnings("unchecked")
 310     private void setUpGetPolicyIdentitiesToReturn(Object returnValue) {
 311         if (returnValue instanceof List<?>) {
 312             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 313         } else if (returnValue instanceof Exception) {
 314             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.error((Exception) returnValue));
 315         }
 316     }
 317
 318     @SuppressWarnings("unchecked")
 319     private void setUpGetPolicyTypeIdentitiesToReturn(Object returnValue) {
 320         if (returnValue instanceof List<?>) {
 321             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 322         } else if (returnValue instanceof Exception) {
 323             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.error((Exception) returnValue));
 324         }
 325     }
 326 }