webapp-backend/src/test/java/org/oransc/portal/nonrtric/controlpanel/policyagentapi/PolicyAgentApiImplTest.java

   1 /*-
   2  * ========================LICENSE_START=================================
   3  * O-RAN-SC
   4  * %%
   5  * Copyright (C) 2020 Nordix Foundation
   6  * Modifications Copyright (C) 2020 Nordix Foundation
   7  * %%
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ========================LICENSE_END===================================
  20  */
  21 package org.oransc.portal.nonrtric.controlpanel.policyagentapi;
  22
  23 import static org.junit.jupiter.api.Assertions.assertEquals;
  24 import static org.junit.jupiter.api.Assertions.assertNull;
  25 import static org.junit.jupiter.api.Assertions.assertTrue;
  26 import static org.mockito.ArgumentMatchers.eq;
  27 import static org.mockito.Mockito.doThrow;
  28 import static org.mockito.Mockito.mock;
  29 import static org.mockito.Mockito.verify;
  30 import static org.mockito.Mockito.when;
  31
  32 import com.google.gson.GsonBuilder;
  33 import com.google.gson.JsonArray;
  34 import com.google.gson.JsonElement;
  35 import com.google.gson.JsonObject;
  36 import com.google.gson.JsonParser;
  37 import com.google.gson.reflect.TypeToken;
  38
  39 import java.lang.reflect.Type;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.Collection;
  43 import java.util.List;
  44 import java.util.Map;
  45
  46 import org.junit.jupiter.api.BeforeEach;
  47 import org.junit.jupiter.api.Test;
  48 import org.oransc.portal.nonrtric.controlpanel.model.PolicyInfo;
  49 import org.oransc.portal.nonrtric.controlpanel.model.PolicyInstances;
  50 import org.oransc.portal.nonrtric.controlpanel.model.PolicyType;
  51 import org.oransc.portal.nonrtric.controlpanel.model.PolicyTypes;
  52 import org.oransc.portal.nonrtric.controlpanel.policyagentapi.PolicyAgentApiImpl;
  53 import org.oransc.portal.nonrtric.controlpanel.policyagentapi.PolicyAgentApiImpl.RicInfo;
  54 import org.oransc.portal.nonrtric.controlpanel.model.ImmutablePolicyInfo;
  55 import org.springframework.http.HttpEntity;
  56 import org.springframework.http.HttpHeaders;
  57 import org.springframework.http.HttpStatus;
  58 import org.springframework.http.MediaType;
  59 import org.springframework.http.ResponseEntity;
  60 import org.springframework.web.client.RestClientException;
  61 import org.springframework.web.client.RestTemplate;
  62
  63 public class PolicyAgentApiImplTest {
  64     private static final String URL_PREFIX = "UrlPrefix";
  65     private static final String URL_POLICY_SCHEMAS = "/policy_schemas";
  66     private static final String URL_POLICY_INSTANCES = "/policies?type={type}";
  67     private static final String URL_POLICY_INSTANCE = "/policy?id={id}";
  68     private static final String URL_PUT_POLICY = "/policy?type={type}&id={id}&ric={ric}&service={service}";
  69     private static final String URL_DELETE_POLICY = "/policy?id={id}";
  70     private static final String URL_RIC_INFO = "/rics?policyType={typeName}";
  71     private static final String POLICY_TYPE_1_ID = "type1";
  72     private static final String POLICY_TYPE_1_VALID = "{\"title\":\"type1\"}";
  73     private static final String POLICY_TYPE_1_INVALID = "\"title\":\"type1\"}";
  74     private static final String POLICY_TYPE_2_VALID = "{\"title\":\"type2\"}";
  75     private static final String POLICY_1_ID = "policy1";
  76     private static final String POLICY_1_VALID = "{\"policyId\":\"policy1\"}";
  77     private static final String POLICY_1_INVALID = "\"policyId\":\"policy1\"}";
  78     private static final String RIC_1_ID = "ric1";
  79     private static final String RIC_1_INFO_VALID = "{\"name\":\"ric1\",\"policyTypes\":[\"type1\"]}";
  80     private static final String RIC_1_INFO_INVALID = "{\"name\":\"ric1\",\"policyTypes\":\"type1\"]}";
  81     private static final String CLIENT_ERROR_MESSAGE = "Exception: Client returned failure";
  82
  83     private static com.google.gson.Gson gson = new GsonBuilder() //
  84         .serializeNulls() //
  85         .create(); //
  86
  87     PolicyAgentApiImpl apiUnderTest;
  88
  89     RestTemplate restTemplateMock;
  90
  91     @BeforeEach
  92     public void init() {
  93         restTemplateMock = mock(RestTemplate.class);
  94         apiUnderTest = new PolicyAgentApiImpl(URL_PREFIX, restTemplateMock);
  95     }
  96
  97     @Test
  98     public void testGetAllPolicyTypesFailure() {
  99         ResponseEntity<String> getAllPolicyTypesResp = new ResponseEntity<>(null, HttpStatus.NOT_FOUND);
 100         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_SCHEMAS), eq(String.class)))
 101             .thenReturn(getAllPolicyTypesResp);
 102
 103         ResponseEntity<String> returnedResp = apiUnderTest.getAllPolicyTypes();
 104
 105         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_SCHEMAS, String.class);
 106         assertNull(returnedResp.getBody());
 107         assertEquals(HttpStatus.NOT_FOUND, returnedResp.getStatusCode());
 108     }
 109
 110     @Test
 111     public void testGetAllPolicyTypesSuccessValidJson() {
 112         String policyTypes = Arrays.asList(POLICY_TYPE_1_VALID, POLICY_TYPE_2_VALID).toString();
 113         String policyTypesJson = parsePolicyTypesJson(policyTypes);
 114         ResponseEntity<String> getAllPolicyTypesResp = new ResponseEntity<>(policyTypes, HttpStatus.OK);
 115         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_SCHEMAS), eq(String.class)))
 116             .thenReturn(getAllPolicyTypesResp);
 117
 118         ResponseEntity<String> returnedResp = apiUnderTest.getAllPolicyTypes();
 119
 120         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_SCHEMAS, String.class);
 121         assertEquals(returnedResp.getBody(), policyTypesJson);
 122         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 123     }
 124
 125     @Test
 126     public void testGetAllPolicyTypesSuccessInvalidJson() {
 127         String policyTypes = Arrays.asList(POLICY_TYPE_1_INVALID, POLICY_TYPE_2_VALID).toString();
 128         ResponseEntity<String> getAllPolicyTypesResp = new ResponseEntity<>(policyTypes, HttpStatus.OK);
 129         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_SCHEMAS), eq(String.class)))
 130             .thenReturn(getAllPolicyTypesResp);
 131
 132         ResponseEntity<String> returnedResp = apiUnderTest.getAllPolicyTypes();
 133
 134         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_SCHEMAS, String.class);
 135         assertTrue(returnedResp.getBody().contains("Exception"));
 136         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, returnedResp.getStatusCode());
 137     }
 138
 139     @Test
 140     public void testGetPolicyInstancesForTypeFailure() {
 141         ResponseEntity<String> getPolicyInstancesForTypeResp = new ResponseEntity<>(null, HttpStatus.NOT_FOUND);
 142         Map<String, ?> uriVariables = Map.of("type", POLICY_TYPE_1_ID);
 143         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_INSTANCES), eq(String.class), eq(uriVariables)))
 144             .thenReturn(getPolicyInstancesForTypeResp);
 145
 146         ResponseEntity<String> returnedResp = apiUnderTest.getPolicyInstancesForType(POLICY_TYPE_1_ID);
 147
 148         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_INSTANCES, String.class, uriVariables);
 149         assertNull(returnedResp.getBody());
 150         assertEquals(HttpStatus.NOT_FOUND, returnedResp.getStatusCode());
 151     }
 152
 153     @Test
 154     public void testGetPolicyInstancesForTypeSuccessValidJson() {
 155         String policyInstances = Arrays.asList(POLICY_1_VALID).toString();
 156         String policyInstancesJson = parsePolicyInstancesJson(policyInstances);
 157         ResponseEntity<String> getPolicyInstancesForTypeResp = new ResponseEntity<>(policyInstances, HttpStatus.OK);
 158         Map<String, ?> uriVariables = Map.of("type", POLICY_TYPE_1_ID);
 159         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_INSTANCES), eq(String.class), eq(uriVariables)))
 160             .thenReturn(getPolicyInstancesForTypeResp);
 161
 162         ResponseEntity<String> returnedResp = apiUnderTest.getPolicyInstancesForType(POLICY_TYPE_1_ID);
 163
 164         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_INSTANCES, String.class, uriVariables);
 165         assertEquals(returnedResp.getBody(), policyInstancesJson);
 166         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 167     }
 168
 169     @Test
 170     public void testGetPolicyInstancesForTypeSuccessInvalidJson() {
 171         String policyInstances = Arrays.asList(POLICY_1_INVALID).toString();
 172         ResponseEntity<String> getPolicyInstancesForTypeResp = new ResponseEntity<>(policyInstances, HttpStatus.OK);
 173         Map<String, ?> uriVariables = Map.of("type", POLICY_TYPE_1_ID);
 174         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_INSTANCES), eq(String.class), eq(uriVariables)))
 175             .thenReturn(getPolicyInstancesForTypeResp);
 176
 177         ResponseEntity<String> returnedResp = apiUnderTest.getPolicyInstancesForType(POLICY_TYPE_1_ID);
 178
 179         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_INSTANCES, String.class, uriVariables);
 180         assertTrue(returnedResp.getBody().contains("Exception"));
 181         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, returnedResp.getStatusCode());
 182     }
 183
 184     @Test
 185     public void testGetPolicyInstance() {
 186         ResponseEntity<Object> getPolicyInstanceResp = new ResponseEntity<>(POLICY_1_VALID, HttpStatus.OK);
 187         Map<String, ?> uriVariables = Map.of("id", POLICY_1_ID);
 188         when(restTemplateMock.getForEntity(eq(URL_PREFIX + URL_POLICY_INSTANCE), eq(Object.class), eq(uriVariables)))
 189             .thenReturn(getPolicyInstanceResp);
 190
 191         ResponseEntity<Object> returnedResp = apiUnderTest.getPolicyInstance(POLICY_1_ID);
 192
 193         verify(restTemplateMock).getForEntity(URL_PREFIX + URL_POLICY_INSTANCE, Object.class, uriVariables);
 194         assertEquals(POLICY_1_VALID, returnedResp.getBody());
 195         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 196     }
 197
 198     @Test
 199     public void testPutPolicyFailure() {
 200         HttpEntity<Object> jsonHttpEntity = createJsonHttpEntity(POLICY_1_VALID);
 201         Map<String, ?> uriVariables = Map.of( //
 202             "type", POLICY_TYPE_1_ID, //
 203             "id", POLICY_1_ID, //
 204             "ric", RIC_1_ID, //
 205             "service", "controlpanel");
 206         doThrow(new RestClientException(CLIENT_ERROR_MESSAGE)).when(restTemplateMock)
 207             .put(eq(URL_PREFIX + URL_PUT_POLICY), eq(jsonHttpEntity), eq(uriVariables));
 208
 209         ResponseEntity<String> returnedResp =
 210             apiUnderTest.putPolicy(POLICY_TYPE_1_ID, POLICY_1_ID, POLICY_1_VALID, RIC_1_ID);
 211
 212         verify(restTemplateMock).put(URL_PREFIX + URL_PUT_POLICY, jsonHttpEntity, uriVariables);
 213         assertTrue(returnedResp.getBody().contains("Exception"));
 214         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, returnedResp.getStatusCode());
 215     }
 216
 217     @Test
 218     public void testPutPolicySuccess() {
 219         HttpEntity<Object> jsonHttpEntity = createJsonHttpEntity(POLICY_1_VALID);
 220         Map<String, ?> uriVariables = Map.of( //
 221             "type", POLICY_TYPE_1_ID, //
 222             "id", POLICY_1_ID, //
 223             "ric", RIC_1_ID, //
 224             "service", "controlpanel");
 225
 226         ResponseEntity<String> returnedResp =
 227             apiUnderTest.putPolicy(POLICY_TYPE_1_ID, POLICY_1_ID, POLICY_1_VALID, RIC_1_ID);
 228
 229         verify(restTemplateMock).put(URL_PREFIX + URL_PUT_POLICY, jsonHttpEntity, uriVariables);
 230         assertNull(returnedResp.getBody());
 231         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 232     }
 233
 234     @Test
 235     public void testDeletePolicyFailure() {
 236         Map<String, ?> uriVariables = Map.of("id", POLICY_1_ID);
 237         doThrow(new RestClientException(CLIENT_ERROR_MESSAGE)).when(restTemplateMock)
 238             .delete(eq(URL_PREFIX + URL_DELETE_POLICY), eq(uriVariables));
 239
 240         ResponseEntity<String> returnedResp = apiUnderTest.deletePolicy(POLICY_1_ID);
 241
 242         verify(restTemplateMock).delete(URL_PREFIX + URL_DELETE_POLICY, uriVariables);
 243         assertTrue(returnedResp.getBody().contains("Exception"));
 244         assertEquals(HttpStatus.NOT_FOUND, returnedResp.getStatusCode());
 245     }
 246
 247     @Test
 248     public void testDeletePolicySuccess() {
 249         Map<String, ?> uriVariables = Map.of("id", POLICY_1_ID);
 250
 251         ResponseEntity<String> returnedResp = apiUnderTest.deletePolicy(POLICY_1_ID);
 252
 253         verify(restTemplateMock).delete(URL_PREFIX + URL_DELETE_POLICY, uriVariables);
 254         assertNull(returnedResp.getBody());
 255         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 256     }
 257
 258     @Test
 259     public void testGetRicsSupportingTypeValidJson() {
 260         String rics = Arrays.asList(RIC_1_INFO_VALID).toString();
 261         String ricsJson = parseRicsJson(rics);
 262         Map<String, ?> uriVariables = Map.of("typeName", POLICY_TYPE_1_ID);
 263         when(restTemplateMock.getForObject(eq(URL_PREFIX + URL_RIC_INFO), eq(String.class), eq(uriVariables)))
 264             .thenReturn(rics);
 265
 266         ResponseEntity<String> returnedResp = apiUnderTest.getRicsSupportingType(POLICY_TYPE_1_ID);
 267
 268         verify(restTemplateMock).getForObject(URL_PREFIX + URL_RIC_INFO, String.class, uriVariables);
 269         assertEquals(returnedResp.getBody(), ricsJson);
 270         assertEquals(HttpStatus.OK, returnedResp.getStatusCode());
 271     }
 272
 273     @Test
 274     public void testGetRicsSupportingTypeInvalidJson() {
 275         String rics = Arrays.asList(RIC_1_INFO_INVALID).toString();
 276         Map<String, ?> uriVariables = Map.of("typeName", POLICY_TYPE_1_ID);
 277         when(restTemplateMock.getForObject(eq(URL_PREFIX + URL_RIC_INFO), eq(String.class), eq(uriVariables)))
 278             .thenReturn(rics);
 279
 280         ResponseEntity<String> returnedResp = apiUnderTest.getRicsSupportingType(POLICY_TYPE_1_ID);
 281
 282         verify(restTemplateMock).getForObject(URL_PREFIX + URL_RIC_INFO, String.class, uriVariables);
 283         assertTrue(returnedResp.getBody().contains("Exception"));
 284         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, returnedResp.getStatusCode());
 285     }
 286
 287     private String parsePolicyTypesJson(String inputString) {
 288         PolicyTypes policyTypes = new PolicyTypes();
 289         JsonArray schemas = JsonParser.parseString(inputString).getAsJsonArray();
 290         for (JsonElement schema : schemas) {
 291             JsonObject schemaObj = schema.getAsJsonObject();
 292             policyTypes.add(new PolicyType(schemaObj.get("title").getAsString(), schemaObj.toString()));
 293         }
 294         return gson.toJson(policyTypes);
 295     }
 296
 297     private String parsePolicyInstancesJson(String inputString) {
 298         Type listType = new TypeToken<List<ImmutablePolicyInfo>>() {}.getType();
 299         List<PolicyInfo> rspParsed = gson.fromJson(inputString, listType);
 300         PolicyInstances policyInstances = new PolicyInstances();
 301         for (PolicyInfo policy : rspParsed) {
 302             policyInstances.add(policy);
 303         }
 304         return gson.toJson(policyInstances);
 305     }
 306
 307     private String parseRicsJson(String inputString) {
 308         Type listType = new TypeToken<List<ImmutableRicInfo>>() {}.getType();
 309         List<RicInfo> rspParsed = gson.fromJson(inputString, listType);
 310         Collection<String> rics = new ArrayList<>(rspParsed.size());
 311         for (RicInfo ric : rspParsed) {
 312             rics.add(ric.ricName());
 313         }
 314         return gson.toJson(rics);
 315     }
 316
 317     private HttpEntity<Object> createJsonHttpEntity(Object content) {
 318         HttpHeaders headers = new HttpHeaders();
 319         headers.setContentType(MediaType.APPLICATION_JSON);
 320         return new HttpEntity<>(content, headers);
 321     }
 322 }