gerrit.onap Code Review - ccsdk/oran.git/blob

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * ONAP : ccsdk oran
   4  * ======================================================================
   5  * Copyright (C) 2024 OpenInfra Foundation Europe. All rights reserved.
   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.onap.ccsdk.oran.a1policymanagementservice.service.v3;
  22
  23 import com.google.gson.Gson;
  24 import com.google.gson.JsonParser;
  25 import org.junit.jupiter.api.*;
  26 import org.mockito.Mockito;
  27 import org.onap.ccsdk.oran.a1policymanagementservice.config.TestConfig;
  28 import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
  29 import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
  30 import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyInformation;
  31 import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
  32 import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyTypeInformation;
  33 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
  34 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policy;
  35 import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyType;
  36 import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
  37 import org.onap.ccsdk.oran.a1policymanagementservice.util.v3.Helper;
  38 import org.onap.ccsdk.oran.a1policymanagementservice.utils.MockA1ClientFactory;
  39 import org.onap.ccsdk.oran.a1policymanagementservice.utils.v3.TestHelper;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.springframework.beans.factory.annotation.Autowired;
  43 import org.springframework.boot.test.context.SpringBootTest;
  44 import org.springframework.boot.test.mock.mockito.MockBean;
  45 import org.springframework.http.HttpStatus;
  46 import org.springframework.http.ResponseEntity;
  47 import org.springframework.test.context.ContextConfiguration;
  48 import org.springframework.test.context.TestPropertySource;
  49 import org.springframework.util.FileSystemUtils;
  50 import org.springframework.web.server.ServerWebExchange;
  51 import org.springframework.web.server.adapter.DefaultServerWebExchange;
  52 import reactor.core.publisher.Flux;
  53 import reactor.core.publisher.Mono;
  54
  55 import java.io.IOException;
  56 import java.lang.invoke.MethodHandles;
  57 import java.nio.file.Path;
  58 import java.util.ArrayList;
  59 import java.util.Collection;
  60 import java.util.Map;
  61
  62 import static org.junit.jupiter.api.Assertions.assertEquals;
  63 import static org.junit.jupiter.api.Assertions.assertThrows;
  64 import static org.mockito.ArgumentMatchers.any;
  65 import static org.mockito.Mockito.when;
  66
  67 @TestMethodOrder(MethodOrderer.MethodName.class)
  68 @SpringBootTest
  69 @ContextConfiguration(classes = TestConfig.class)
  70 @TestPropertySource(properties = { //
  71         "app.vardata-directory=/tmp/pmstestv3", //
  72 })
  73 public class PolicyServiceTest {
  74
  75     private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
  76
  77     @Autowired
  78     private Policies policies;
  79
  80     @Autowired
  81     private Rics rics;
  82
  83     @Autowired
  84     private PolicyService policyService;
  85
  86     @Autowired
  87     private TestHelper testHelper;
  88
  89     @MockBean
  90     private Helper helper;
  91
  92     @MockBean
  93     private AuthorizationService authorizationService;
  94
  95     @Autowired
  96     private MockA1ClientFactory a1ClientFactory;
  97
  98     @Autowired
  99     private Gson gson;
 100
 101     @AfterEach
 102     public void clear() {
 103         policies.clear();
 104         rics.clear();
 105     }
 106
 107     @AfterAll
 108     static void clearTestDir() {
 109         try {
 110             FileSystemUtils.deleteRecursively(Path.of("/tmp/pmstestv3"));
 111         } catch (Exception e) {
 112             logger.warn("Could test directory : {}", e.getMessage());
 113         }
 114     }
 115
 116     @Test
 117     public void testPolicyAlreadyCreatedTrue() throws Exception{
 118
 119         String policyTypeName = "uri_type_123";
 120         String nonRtRicId = "Ric_347";
 121         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 122         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 123         Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
 124         when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.TRUE);
 125         when(helper.buildPolicy(any(),any(), any(), any())).thenReturn(policy);
 126         when(helper.isPolicyAlreadyCreated(any(), any())).thenReturn(Mono.error(new ServiceException
 127                 ("Same policy content already created with policy ID: 122344-5674", HttpStatus.BAD_REQUEST)));
 128         Mono<ResponseEntity<PolicyObjectInformation>> responseMono = policyService.createPolicyService(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), serverWebExchange);
 129         testHelper.verifyMockError(responseMono, "Same policy content already created with policy ID: 122344-5674");
 130     }
 131
 132     @Test
 133     public void testPolicyNotAuthorizedFail() throws IOException {
 134
 135         String policyTypeName = "uri_type_123";
 136         String nonRtRicId = "Ric_347";
 137         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 138         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 139         when(helper.jsonSchemaValidation(any())).thenReturn(Boolean.TRUE);
 140         when(helper.isPolicyAlreadyCreated(any(), any())).thenReturn(Mono.just(Policy.builder().build()));
 141         when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.error(new ServiceException("Not authorized", HttpStatus.UNAUTHORIZED)));
 142         Mono<ResponseEntity<PolicyObjectInformation>> responseMono = policyService.createPolicyService(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), serverWebExchange);
 143         testHelper.verifyMockError(responseMono, "Not authorized");
 144     }
 145
 146     @Test
 147     public void testDeletePolicySuccess() throws Exception {
 148
 149         String policyTypeName = "uri_type_123";
 150         String nonRtRicId = "Ric_347";
 151         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 152         Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
 153         policies.put(policy);
 154         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 155         when(helper.checkRicStateIdle(any())).thenReturn(Mono.just(policy.getRic()));
 156         when(helper.checkSupportedType(any(), any())).thenReturn(Mono.just(policy.getRic()));
 157         when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
 158         Mono<ResponseEntity<Void>> responseMonoDelete = policyService.deletePolicyService(policy.getId(), serverWebExchange);
 159         assert(policies.size() == 1);
 160         testHelper.testSuccessResponse(responseMonoDelete, HttpStatus.NO_CONTENT, responseBody -> policies.size() == 0);
 161     }
 162
 163     @Test
 164     public void testDeletePolicyThrowsException() throws Exception {
 165
 166         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 167         assertThrows(EntityNotFoundException.class, () -> policyService.deletePolicyService("dummyPolicyID", serverWebExchange));
 168     }
 169
 170     @Test
 171     public void testPutPolicy() throws Exception {
 172
 173         String policyTypeName = "uri_type_123";
 174         String nonRtRicId = "Ric_347";
 175         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 176         Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
 177         policies.put(policy);
 178         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 179         PolicyObjectInformation updatedPolicyObjectInfo = testHelper.policyObjectInfo(nonRtRicId, policyTypeName);
 180         updatedPolicyObjectInfo.setPolicyObject(gson.fromJson(JsonParser.parseString("{\n" +
 181                 "        \"scope\": {\n" +
 182                 "            \"ueId\": \"ue6100\",\n" +
 183                 "            \"qosId\": \"qos6100\"\n" +
 184                 "        },\n" +
 185                 "        \"qosObjectives\": {\n" +
 186                 "            \"priorityLevel\": 6100.0\n" +
 187                 "        }\n" +
 188                 "    }").getAsJsonObject().toString(), Map.class));
 189         Policy updatedPolicy = testHelper.buidTestPolicy(updatedPolicyObjectInfo, "122344-5674");
 190         when(helper.buildPolicy(any(),any(), any(), any())).thenReturn(updatedPolicy);
 191         when(helper.checkRicStateIdle(any())).thenReturn(Mono.just(updatedPolicy.getRic()));
 192         when(helper.checkSupportedType(any(), any())).thenReturn(Mono.just(updatedPolicy.getRic()));
 193         when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(updatedPolicy));
 194         Mono<ResponseEntity<Object>> responseMono = policyService.putPolicyService(policy.getId(), updatedPolicyObjectInfo.getPolicyObject(), serverWebExchange);
 195         testHelper.testSuccessResponse(responseMono, HttpStatus.OK, responseBody -> {
 196             if (responseBody instanceof String returnPolicy)
 197                 return returnPolicy.contains(updatedPolicy.getJson());
 198             return false;
 199         });
 200     }
 201
 202     @Test
 203     public void testGetPolicyTypes() throws Exception {
 204
 205         String policyTypeName = "uri_type_123";
 206         String nonRtRicId = "Ric_347";
 207         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 208         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 209         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 210         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, null,null, serverWebExchange);
 211         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
 212     }
 213
 214     @Test
 215     public void testGetPolicyTypesEmpty() throws Exception {
 216         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 217         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 218         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, null, null, serverWebExchange);
 219         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 0);
 220     }
 221
 222     @Test
 223     public void testGetPolicyTypesNoRic() {
 224         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 225         assertThrows(EntityNotFoundException.class, () -> policyService.getPolicyTypesService("NoRic", "","", serverWebExchange));
 226     }
 227
 228     @Test
 229     public void testGetPolicyTypesNoMatchedTypeName() throws Exception {
 230         String policyTypeName = "uri_type_123";
 231         String nonRtRicId = "Ric_347";
 232         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 233         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 234         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 235         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService("", "noTypeName", null, serverWebExchange);
 236         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().findAny().isEmpty());
 237     }
 238
 239     @Test
 240     public void testGetPolicyTypesNoMatchedTypeNameWithRic() throws Exception {
 241         String policyTypeName = "uri_type_123";
 242         String nonRtRicId = "Ric_347";
 243         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 244         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 245         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 246         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService("Ric_347", "noTypeName", null, serverWebExchange);
 247         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().findAny().isEmpty());
 248     }
 249
 250     @Test
 251     public void testGetPolicyTypesMatchedTypeName() throws Exception {
 252         String policyTypeName = "uri_type_123";
 253         String nonRtRicId = "Ric_347";
 254         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 255         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 256         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 257         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService.getPolicyTypesService(null, "uri_type", null, serverWebExchange);
 258         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
 259     }
 260
 261     @Test
 262     public void testGetPolicyTypesMatchedTypeNameWithRic() throws Exception {
 263         String policyTypeName = "uri_type_123";
 264         String nonRtRicId = "Ric_347";
 265         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 266         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 267         when(helper.toPolicyTypeInfoCollection(any(), any())).thenCallRealMethod();
 268         Mono<ResponseEntity<Flux<PolicyTypeInformation>>> responseEntityMono = policyService
 269                 .getPolicyTypesService("Ric_347", "uri_type", null, serverWebExchange);
 270         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
 271     }
 272
 273     @Test
 274     public void testGetPolicyIds() throws Exception {
 275         String policyTypeName = "uri_type_123";
 276         String nonRtRicId = "Ric_347";
 277         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 278         Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
 279         policies.put(policy);
 280         when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
 281         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 282         Policy singlePolicy = policies.filterPolicies(null, null, null, null).iterator().next();
 283         Collection<PolicyInformation> mockPolicyInfoCollection = new ArrayList<>();
 284         mockPolicyInfoCollection.add(new PolicyInformation(singlePolicy.getId(), singlePolicy.getRic().getConfig().getRicId()));
 285         when(helper.toFluxPolicyInformation(any())).thenReturn(Flux.fromIterable(mockPolicyInfoCollection));
 286         Mono<ResponseEntity<Flux<PolicyInformation>>> responseEntityMono = policyService
 287                 .getPolicyIdsService(null, null, null, null, serverWebExchange);
 288         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> responseBody.toStream().count() == 1);
 289     }
 290
 291     @Test
 292     public void testGetPolicyIdsNoRic() throws Exception {
 293         testHelper.addPolicyType("uri_type_123", "Ric_347");
 294         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 295         EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
 296                 .getPolicyIdsService("uri_type_123", "noRic", "", "", serverWebExchange));
 297         assertEquals("Near-RT RIC not found using ID: noRic", exception.getMessage());
 298     }
 299
 300     @Test
 301     public void testGetPolicyIdsNoPolicyType() {
 302         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 303         EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
 304                 .getPolicyIdsService("noPolicyType", "noRic", "", "", serverWebExchange));
 305         assertEquals("Policy type not found using ID: noPolicyType", exception.getMessage());
 306     }
 307
 308     @Test
 309     public void testGetPolicyService() throws Exception {
 310         String policyTypeName = "uri_type_123";
 311         String nonRtRicId = "Ric_347";
 312         testHelper.addPolicyType(policyTypeName, nonRtRicId);
 313         Policy policy = testHelper.buidTestPolicy(testHelper.policyObjectInfo(nonRtRicId, policyTypeName), "122344-5674");
 314         policies.put(policy);
 315         when(authorizationService.authCheck(any(), any(), any())).thenReturn(Mono.just(policy));
 316         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 317         Mono<ResponseEntity<Object>> responseEntityMono = policyService.getPolicyService(policy.getId(), serverWebExchange);
 318         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> {
 319             if (responseBody instanceof String returnPolicy)
 320                 return returnPolicy.contains(policy.getJson());
 321             return false;
 322         });
 323     }
 324
 325     @Test
 326     public void testGetPolicyServiceNoPolicy() throws Exception {
 327         ServerWebExchange serverWebExchange = Mockito.mock(DefaultServerWebExchange.class);
 328         EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
 329                 .getPolicyService("NoPolicy", serverWebExchange));
 330         assertEquals("Could not find policy: NoPolicy", exception.getMessage());
 331     }
 332
 333     @Test
 334     public void testGetPolicyTypeService() throws Exception {
 335         String policyTypeName = "uri_type_123";
 336         String nonRtRicId = "Ric_347";
 337         PolicyType addedPolicyType = testHelper.addPolicyType(policyTypeName, nonRtRicId);
 338         Mono<ResponseEntity<Object>> responseEntityMono = policyService.getPolicyTypeDefinitionService(policyTypeName);
 339         testHelper.testSuccessResponse(responseEntityMono, HttpStatus.OK, responseBody -> {
 340             if (responseBody instanceof String returnPolicyType)
 341                 return returnPolicyType.contains(addedPolicyType.getSchema());
 342             return false;
 343         });
 344     }
 345
 346     @Test
 347     public void testGetPolicyTypeServiceNoPolicyType() {
 348         EntityNotFoundException exception = assertThrows(EntityNotFoundException.class, () -> policyService
 349                 .getPolicyTypeDefinitionService("NoPolicyType"));
 350         assertEquals("PolicyType not found with ID: NoPolicyType", exception.getMessage());
 351     }
 352 }