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