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.utils.v3;
  22
  23 import com.fasterxml.jackson.databind.ObjectMapper;
  24 import com.google.common.io.CharStreams;
  25 import com.google.gson.Gson;
  26 import com.google.gson.JsonObject;
  27 import com.google.gson.JsonParser;
  28 import org.apache.commons.io.FileUtils;
  29 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClient;
  30 import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
  31 import org.onap.ccsdk.oran.a1policymanagementservice.clients.SecurityContext;
  32 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.ApplicationConfig;
  33 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.RicConfig;
  34 import org.onap.ccsdk.oran.a1policymanagementservice.configuration.WebClientConfig;
  35 import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.Consts;
  36 import org.onap.ccsdk.oran.a1policymanagementservice.models.v3.PolicyObjectInformation;
  37 import org.onap.ccsdk.oran.a1policymanagementservice.repository.*;
  38 import org.springframework.beans.factory.annotation.Autowired;
  39 import org.springframework.context.ApplicationContext;
  40 import org.springframework.http.HttpStatus;
  41 import org.springframework.http.HttpStatusCode;
  42 import org.springframework.http.MediaType;
  43 import org.springframework.http.ResponseEntity;
  44 import org.springframework.stereotype.Component;
  45 import org.springframework.web.reactive.function.client.WebClientResponseException;
  46 import reactor.core.publisher.Mono;
  47 import reactor.test.StepVerifier;
  48
  49 import java.io.File;
  50 import java.io.IOException;
  51 import java.io.InputStream;
  52 import java.io.InputStreamReader;
  53 import java.nio.charset.StandardCharsets;
  54 import java.time.Instant;
  55 import java.util.ArrayList;
  56 import java.util.List;
  57 import java.util.Objects;
  58 import java.util.function.Predicate;
  59
  60 import static org.assertj.core.api.Assertions.assertThat;
  61 import static org.junit.jupiter.api.Assertions.assertTrue;
  62
  63 @Component
  64 public class TestHelper {
  65
  66     @Autowired
  67     ApplicationConfig applicationConfig;
  68
  69     @Autowired
  70     ApplicationContext context;
  71
  72     @Autowired
  73     private Rics rics;
  74
  75     @Autowired
  76     private Policies policies;
  77
  78     @Autowired
  79     private PolicyTypes policyTypes;
  80
  81     @Autowired
  82     private ObjectMapper objectMapper;
  83
  84     @Autowired
  85     private Gson gson;
  86
  87     public int port;
  88
  89     public AsyncRestClient restClientV3() {
  90         return restClientV3(false);
  91     }
  92
  93     public AsyncRestClient restClient(String baseUrl, boolean useTrustValidation) {
  94         WebClientConfig config = this.applicationConfig.getWebClientConfig();
  95         config = WebClientConfig.builder()
  96                 .keyStoreType(config.getKeyStoreType())
  97                 .keyStorePassword(config.getKeyStorePassword())
  98                 .keyStore(config.getKeyStore())
  99                 .keyPassword(config.getKeyPassword())
 100                 .isTrustStoreUsed(useTrustValidation)
 101                 .trustStore(config.getTrustStore())
 102                 .trustStorePassword(config.getTrustStorePassword())
 103                 .httpProxyConfig(config.getHttpProxyConfig())
 104                 .build();
 105
 106         AsyncRestClientFactory f = new AsyncRestClientFactory(config, new SecurityContext(""));
 107         return f.createRestClientNoHttpProxy(baseUrl);
 108
 109     }
 110
 111     public String baseUrl() {
 112         return "https://localhost:" + port;
 113     }
 114
 115     public AsyncRestClient restClientV3(boolean useTrustValidation) {
 116         return restClient(baseUrl() + Consts.V3_API_ROOT, useTrustValidation);
 117     }
 118
 119     public AsyncRestClient restClient(boolean useTrustValidation) {
 120         return restClient(baseUrl() + Consts.V2_API_ROOT, useTrustValidation);
 121     }
 122
 123     public PolicyType createPolicyType(String policyTypeName, String filePath) throws IOException {
 124         InputStream in = getClass().getResourceAsStream(filePath);
 125         assert in != null;
 126         String schema = CharStreams.toString(new InputStreamReader(in, StandardCharsets.UTF_8));
 127         return PolicyType.builder()
 128                 .id(policyTypeName)
 129                 .schema(schema)
 130                 .build();
 131     }
 132
 133     public Ric addRic(String ricId) {
 134         return addRic(ricId, null);
 135     }
 136
 137     public RicConfig ricConfig(String ricId, String managedElement) {
 138         List<String> mes = new ArrayList<>();
 139         if (managedElement != null) {
 140             mes.add(managedElement);
 141         }
 142         return RicConfig.builder()
 143                 .ricId(ricId)
 144                 .baseUrl(ricId)
 145                 .managedElementIds(mes)
 146                 .build();
 147     }
 148     public Ric addRic(String ricId, String managedElement) {
 149         if (rics.get(ricId) != null) {
 150             return rics.get(ricId);
 151         }
 152
 153         RicConfig conf = ricConfig(ricId, managedElement);
 154         Ric ric = new Ric(conf);
 155         ric.setState(Ric.RicState.AVAILABLE);
 156         this.rics.put(ric);
 157         return ric;
 158     }
 159     public PolicyType addPolicyType(String policyTypeName, String ricId) throws IOException {
 160         PolicyType type = createPolicyType(policyTypeName, "/policy_types/demo-policy-schema-3.json");
 161         policyTypes.put(type);
 162         addRic(ricId).addSupportedPolicyType(type);
 163         return type;
 164     }
 165
 166     public String postPolicyBody(String nearRtRicId, String policyTypeName, String policyId) {
 167         PolicyObjectInformation policyObjectInfo = new PolicyObjectInformation(nearRtRicId, dummyPolicyObject(), policyTypeName);
 168         if (policyId != null && !policyId.isEmpty() && !policyId.isBlank())
 169             policyObjectInfo.setPolicyId(policyId);
 170         return gson.toJson(policyObjectInfo);
 171     }
 172
 173     public PolicyObjectInformation policyObjectInfo(String nearRtRicId, String policyTypeName) {
 174         return gson.fromJson(postPolicyBody(nearRtRicId, policyTypeName, ""), PolicyObjectInformation.class);
 175     }
 176
 177     public JsonObject dummyPolicyObject() {
 178         return JsonParser.parseString("{\n" +
 179                 "        \"scope\": {\n" +
 180                 "            \"ueId\": \"ue5100\",\n" +
 181                 "            \"qosId\": \"qos5100\"\n" +
 182                 "        },\n" +
 183                 "        \"qosObjectives\": {\n" +
 184                 "            \"priorityLevel\": 5100.0\n" +
 185                 "        }\n" +
 186                 "    }").getAsJsonObject();
 187     }
 188
 189     public Policy buidTestPolicy(PolicyObjectInformation policyInfo, String id) throws Exception{
 190         return Policy.builder().ric(rics.getRic(policyInfo.getNearRtRicId()))
 191                 .type(policyTypes.getType(policyInfo.getPolicyTypeId()))
 192                 .json(objectMapper.writeValueAsString(policyInfo.getPolicyObject()))
 193                 .lastModified(Instant.now())
 194                 .id(id).build();
 195     }
 196
 197     public <T> void testSuccessResponse(Mono<ResponseEntity<T>> responseEntityMono, HttpStatus httpStatusCode,
 198                                                Predicate<T> responsePredicate) {
 199         StepVerifier.create(responseEntityMono)
 200                 .expectNextMatches(responseEntity -> {
 201                     // Assert status code
 202                     HttpStatusCode status = responseEntity.getStatusCode();
 203                     T responseBody = responseEntity.getBody();
 204                     assert responsePredicate.test(responseBody);
 205                     return status.value() == httpStatusCode.value();
 206                 })
 207                 .expectComplete()
 208                 .verify();
 209     }
 210
 211     public void testSuccessHeader(Mono<ResponseEntity<String>> responseEntityMono, String headerKey,
 212                                   Predicate<String> responsePredicate) {
 213         StepVerifier.create(responseEntityMono)
 214                 .expectNextMatches(responseEntity -> {
 215                     String headerValue = Objects.requireNonNull(responseEntity.getHeaders().get(headerKey)).get(0);
 216                     return responsePredicate.test(headerValue);
 217                 })
 218                 .expectComplete()
 219                 .verify();
 220     }
 221
 222     public void testErrorCode(Mono<?> request, HttpStatus expStatus, String responseContains) {
 223         testErrorCode(request, expStatus, responseContains, true);
 224     }
 225
 226     public void testErrorCode(Mono<?> request, HttpStatus expStatus, String responseContains,
 227                                boolean expectApplicationProblemJsonMediaType) {
 228         StepVerifier.create(request)
 229                 .expectSubscription()
 230                 .expectErrorMatches(
 231                         t -> checkWebClientError(t, expStatus, responseContains, expectApplicationProblemJsonMediaType))
 232                 .verify();
 233     }
 234
 235     private boolean checkWebClientError(Throwable throwable, HttpStatus expStatus, String responseContains,
 236                                         boolean expectApplicationProblemJsonMediaType) {
 237         assertTrue(throwable instanceof WebClientResponseException);
 238         WebClientResponseException responseException = (WebClientResponseException) throwable;
 239         String body = responseException.getResponseBodyAsString();
 240         assertThat(body).contains(responseContains);
 241         assertThat(responseException.getStatusCode()).isEqualTo(expStatus);
 242
 243         if (expectApplicationProblemJsonMediaType) {
 244             assertThat(responseException.getHeaders().getContentType()).isEqualTo(MediaType.APPLICATION_PROBLEM_JSON);
 245         }
 246         return true;
 247     }
 248
 249     public void verifyMockError(Mono<?> responseMono, String responseCheck) {
 250         StepVerifier.create(responseMono)
 251                 .expectSubscription()
 252                 .expectErrorMatches(response -> {
 253                     String status = response.getMessage();
 254                     return status.contains(responseCheck);
 255                 })
 256                 .verify();
 257     }
 258
 259     public String configAsString() throws Exception {
 260         File configFile =
 261                 new File(Objects.requireNonNull(getClass().getClassLoader().getResource("test_application_configuration.json")).getFile());
 262         return FileUtils.readFileToString(configFile, "UTF-8");
 263     }
 264 }