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