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