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