policy-agent/src/test/java/org/oransc/policyagent/tasks/RepositorySupervisionTest.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 RepositorySupervisionTest {
  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         RepositorySupervision supervisorUnderTest =
 137             spy(new RepositorySupervision(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_thenRecovery() {
 147         RIC_1.setState(RicState.UNDEFINED);
 148         rics.put(RIC_1);
 149
 150         RepositorySupervision supervisorUnderTest =
 151             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 152
 153         doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 154
 155         supervisorUnderTest.checkAllRics();
 156
 157         verify(supervisorUnderTest).checkAllRics();
 158         verify(supervisorUnderTest).createSynchronizationTask();
 159         verify(recoveryTaskMock).run(RIC_1);
 160         verifyNoMoreInteractions(supervisorUnderTest);
 161     }
 162
 163     @Test
 164     public void whenRicRecovering_thenNoRecovery() {
 165         RIC_1.setState(RicState.SYNCHRONIZING);
 166         rics.put(RIC_1);
 167
 168         RepositorySupervision supervisorUnderTest =
 169             spy(new RepositorySupervision(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_thenNoRecovery() {
 179         RIC_1.setState(RicState.IDLE);
 180         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 181         rics.put(RIC_1);
 182
 183         setUpGetPolicyIdentitiesToReturn(new Exception("Failed"));
 184
 185         RepositorySupervision supervisorUnderTest =
 186             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 187         supervisorUnderTest.checkAllRics();
 188
 189         verify(supervisorUnderTest).checkAllRics();
 190         verifyNoMoreInteractions(supervisorUnderTest);
 191     }
 192
 193     @Test
 194     public void whenRicIdleAndNotSameAmountOfPolicies_thenRecovery() {
 195         RIC_1.setState(RicState.IDLE);
 196         rics.put(RIC_1);
 197
 198         policies.put(POLICY_1);
 199         policies.put(POLICY_2);
 200
 201         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID)));
 202
 203         RepositorySupervision supervisorUnderTest =
 204             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 205
 206         doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 207
 208         supervisorUnderTest.checkAllRics();
 209
 210         verify(supervisorUnderTest).checkAllRics();
 211         verify(supervisorUnderTest).createSynchronizationTask();
 212         verify(recoveryTaskMock).run(RIC_1);
 213         verifyNoMoreInteractions(supervisorUnderTest);
 214     }
 215
 216     @Test
 217     public void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenRecovery() {
 218         RIC_1.setState(RicState.IDLE);
 219         rics.put(RIC_1);
 220
 221         policies.put(POLICY_1);
 222         policies.put(POLICY_2);
 223
 224         setUpGetPolicyIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_1_ID, "Another_policy")));
 225
 226         RepositorySupervision supervisorUnderTest =
 227             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 228
 229         doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 230
 231         supervisorUnderTest.checkAllRics();
 232
 233         verify(supervisorUnderTest).checkAllRics();
 234         verify(supervisorUnderTest).createSynchronizationTask();
 235         verify(recoveryTaskMock).run(RIC_1);
 236         verifyNoMoreInteractions(supervisorUnderTest);
 237     }
 238
 239     @Test
 240     public void whenRicIdleAndErrorGettingPolicyTypes_thenNoRecovery() {
 241         RIC_1.setState(RicState.IDLE);
 242         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 243         rics.put(RIC_1);
 244
 245         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 246         setUpGetPolicyTypeIdentitiesToReturn(new Exception("Failed"));
 247
 248         RepositorySupervision supervisorUnderTest =
 249             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 250         supervisorUnderTest.checkAllRics();
 251
 252         verify(supervisorUnderTest).checkAllRics();
 253         verifyNoMoreInteractions(supervisorUnderTest);
 254     }
 255
 256     @Test
 257     public void whenRicIdleAndNotSameAmountOfPolicyTypes_thenRecovery() {
 258         RIC_1.setState(RicState.IDLE);
 259         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 260         rics.put(RIC_1);
 261
 262         types.put(POLICY_TYPE_1);
 263
 264         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 265         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 266
 267         RepositorySupervision supervisorUnderTest =
 268             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 269
 270         doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 271
 272         supervisorUnderTest.checkAllRics();
 273
 274         verify(supervisorUnderTest).checkAllRics();
 275         verify(supervisorUnderTest).createSynchronizationTask();
 276         verify(recoveryTaskMock).run(RIC_1);
 277         verifyNoMoreInteractions(supervisorUnderTest);
 278     }
 279
 280     @Test
 281     public void whenRicIdleAndSameAmountOfPolicyTypesButNotSameTypes_thenRecovery() {
 282         PolicyType policyType2 = ImmutablePolicyType.builder() //
 283             .name("policyType2") //
 284             .schema("") //
 285             .build();
 286
 287         RIC_1.setState(RicState.IDLE);
 288         RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
 289         RIC_1.addSupportedPolicyType(policyType2);
 290         rics.put(RIC_1);
 291
 292         setUpGetPolicyIdentitiesToReturn(Collections.emptyList());
 293         setUpGetPolicyTypeIdentitiesToReturn(new ArrayList<>(Arrays.asList(POLICY_TYPE_1_NAME, "another_policy_type")));
 294
 295         RepositorySupervision supervisorUnderTest =
 296             spy(new RepositorySupervision(rics, policies, a1ClientFactory, types, null));
 297
 298         doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
 299
 300         supervisorUnderTest.checkAllRics();
 301
 302         verify(supervisorUnderTest).checkAllRics();
 303         verify(supervisorUnderTest).createSynchronizationTask();
 304         verify(recoveryTaskMock).run(RIC_1);
 305         verifyNoMoreInteractions(supervisorUnderTest);
 306     }
 307
 308     @SuppressWarnings("unchecked")
 309     private void setUpGetPolicyIdentitiesToReturn(Object returnValue) {
 310         if (returnValue instanceof List<?>) {
 311             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 312         } else if (returnValue instanceof Exception) {
 313             when(a1ClientMock.getPolicyIdentities()).thenReturn(Mono.error((Exception) returnValue));
 314         }
 315     }
 316
 317     @SuppressWarnings("unchecked")
 318     private void setUpGetPolicyTypeIdentitiesToReturn(Object returnValue) {
 319         if (returnValue instanceof List<?>) {
 320             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.just((List<String>) returnValue));
 321         } else if (returnValue instanceof Exception) {
 322             when(a1ClientMock.getPolicyTypeIdentities()).thenReturn(Mono.error((Exception) returnValue));
 323         }
 324     }
 325 }