gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. 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.so.apihandlerinfra;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertNull;
  25 import static org.mockito.Mockito.doReturn;
  26 import static org.mockito.Mockito.doThrow;
  27 import static org.mockito.Mockito.times;
  28 import static org.mockito.Mockito.verify;
  29 import static org.mockito.Mockito.when;
  30 import java.io.IOException;
  31 import java.nio.file.Files;
  32 import java.nio.file.Paths;
  33 import java.util.ArrayList;
  34 import java.util.List;
  35 import org.camunda.bpm.engine.impl.persistence.entity.HistoricActivityInstanceEntity;
  36 import org.camunda.bpm.engine.impl.persistence.entity.HistoricProcessInstanceEntity;
  37 import org.junit.Before;
  38 import org.junit.Rule;
  39 import org.junit.Test;
  40 import org.junit.rules.ExpectedException;
  41 import org.junit.runner.RunWith;
  42 import org.mockito.InjectMocks;
  43 import org.mockito.Mock;
  44 import org.mockito.Spy;
  45 import org.mockito.junit.MockitoJUnitRunner;
  46 import org.onap.so.apihandlerinfra.exceptions.ContactCamundaException;
  47 import org.onap.so.apihandlerinfra.exceptions.RequestDbFailureException;
  48 import org.springframework.core.ParameterizedTypeReference;
  49 import org.springframework.core.env.Environment;
  50 import org.springframework.http.HttpEntity;
  51 import org.springframework.http.HttpHeaders;
  52 import org.springframework.http.HttpMethod;
  53 import org.springframework.http.HttpStatus;
  54 import org.springframework.http.ResponseEntity;
  55 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
  56 import org.springframework.web.client.HttpClientErrorException;
  57 import org.springframework.web.client.HttpStatusCodeException;
  58 import org.springframework.web.client.ResourceAccessException;
  59 import org.springframework.web.client.RestClientException;
  60 import org.springframework.web.client.RestTemplate;
  61 import com.fasterxml.jackson.core.type.TypeReference;
  62 import com.fasterxml.jackson.databind.DeserializationFeature;
  63 import com.fasterxml.jackson.databind.ObjectMapper;
  64
  65 @RunWith(MockitoJUnitRunner.class)
  66 public class CamundaRequestHandlerUnitTest {
  67
  68     @Mock
  69     private RestTemplate restTemplate;
  70
  71     @Mock
  72     private RestTemplate restTemplateRetry;
  73
  74     @Mock
  75     private Environment env;
  76
  77     @InjectMocks
  78     @Spy
  79     private CamundaRequestHandler camundaRequestHandler;
  80
  81     @Rule
  82     public ExpectedException thrown = ExpectedException.none();
  83
  84     private static final String REQUEST_ID = "eca3a1b1-43ab-457e-ab1c-367263d148b4";
  85     private ResponseEntity<List<HistoricActivityInstanceEntity>> activityInstanceResponse = null;
  86     private ResponseEntity<List<HistoricProcessInstanceEntity>> processInstanceResponse = null;
  87     private List<HistoricActivityInstanceEntity> activityInstanceList = null;
  88     private List<HistoricProcessInstanceEntity> processInstanceList = null;
  89
  90
  91
  92     @Before
  93     public void setup() throws IOException {
  94         ObjectMapper mapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
  95         activityInstanceList = mapper.readValue(
  96                 new String(Files.readAllBytes(
  97                         Paths.get("src/test/resources/OrchestrationRequest/ActivityInstanceHistoryResponse.json"))),
  98                 new TypeReference<List<HistoricActivityInstanceEntity>>() {});
  99         processInstanceList = mapper.readValue(
 100                 new String(Files.readAllBytes(
 101                         Paths.get("src/test/resources/OrchestrationRequest/ProcessInstanceHistoryResponse.json"))),
 102                 new TypeReference<List<HistoricProcessInstanceEntity>>() {});
 103         processInstanceResponse =
 104                 new ResponseEntity<List<HistoricProcessInstanceEntity>>(processInstanceList, HttpStatus.ACCEPTED);
 105         activityInstanceResponse =
 106                 new ResponseEntity<List<HistoricActivityInstanceEntity>>(activityInstanceList, HttpStatus.ACCEPTED);
 107
 108         doReturn("/sobpmnengine/history/process-instance").when(env).getProperty("mso.camunda.rest.history.uri");
 109         doReturn("/sobpmnengine/history/activity-instance").when(env).getProperty("mso.camunda.rest.activity.uri");
 110         doReturn("auth").when(env).getRequiredProperty("mso.camundaAuth");
 111         doReturn("key").when(env).getRequiredProperty("mso.msoKey");
 112         doReturn("http://localhost:8089").when(env).getProperty("mso.camundaURL");
 113
 114         HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
 115         factory.setReadTimeout(30000);
 116         factory.setConnectTimeout(30000);
 117         restTemplate.setRequestFactory(factory);
 118         doReturn(restTemplate).when(camundaRequestHandler).getRestTemplate(false);
 119
 120         HttpComponentsClientHttpRequestFactory factoryRetry = new HttpComponentsClientHttpRequestFactory();
 121         factoryRetry.setReadTimeout(15000);
 122         factoryRetry.setConnectTimeout(15000);
 123         restTemplate.setRequestFactory(factoryRetry);
 124         doReturn(restTemplateRetry).when(camundaRequestHandler).getRestTemplate(true);
 125     }
 126
 127     public HttpHeaders setHeaders() {
 128         HttpHeaders headers = new HttpHeaders();
 129         List<org.springframework.http.MediaType> acceptableMediaTypes = new ArrayList<>();
 130         acceptableMediaTypes.add(org.springframework.http.MediaType.APPLICATION_JSON);
 131         headers.setAccept(acceptableMediaTypes);
 132         headers.add(HttpHeaders.AUTHORIZATION, "auth");
 133
 134         return headers;
 135     }
 136
 137     @Test
 138     public void getActivityNameTest() throws IOException {
 139         String expectedActivityName = "Last task executed: BB to Execute";
 140         String actualActivityName = camundaRequestHandler.getActivityName(activityInstanceList);
 141
 142         assertEquals(expectedActivityName, actualActivityName);
 143     }
 144
 145     @Test
 146     public void getActivityNameNullActivityNameTest() throws IOException {
 147         String expectedActivityName = "Task name is null.";
 148         HistoricActivityInstanceEntity activityInstance = new HistoricActivityInstanceEntity();
 149         List<HistoricActivityInstanceEntity> activityInstanceList = new ArrayList<>();
 150         activityInstanceList.add(activityInstance);
 151
 152         String actualActivityName = camundaRequestHandler.getActivityName(activityInstanceList);
 153
 154         assertEquals(expectedActivityName, actualActivityName);
 155     }
 156
 157     @Test
 158     public void getActivityNameNullListTest() throws IOException {
 159         String expectedActivityName = "No results returned on activityInstance history lookup.";
 160         List<HistoricActivityInstanceEntity> activityInstanceList = null;
 161         String actualActivityName = camundaRequestHandler.getActivityName(activityInstanceList);
 162
 163         assertEquals(expectedActivityName, actualActivityName);
 164     }
 165
 166     @Test
 167     public void getActivityNameEmptyListTest() throws IOException {
 168         String expectedActivityName = "No results returned on activityInstance history lookup.";
 169         List<HistoricActivityInstanceEntity> activityInstanceList = new ArrayList<>();
 170         String actualActivityName = camundaRequestHandler.getActivityName(activityInstanceList);
 171
 172         assertEquals(expectedActivityName, actualActivityName);
 173     }
 174
 175     @Test
 176     public void getCamundActivityHistoryNullTest() throws IOException, ContactCamundaException {
 177         HistoricProcessInstanceEntity processInstance = new HistoricProcessInstanceEntity();
 178         processInstance.setId("c4c6b647-a26e-11e9-b144-0242ac14000b");
 179         List<HistoricProcessInstanceEntity> processInstanceList = new ArrayList<>();
 180         processInstanceList.add(processInstance);
 181         ResponseEntity<List<HistoricProcessInstanceEntity>> response =
 182                 new ResponseEntity<>(processInstanceList, HttpStatus.OK);
 183         doReturn(null).when(camundaRequestHandler).getCamundaActivityHistory("c4c6b647-a26e-11e9-b144-0242ac14000b");
 184
 185         String actualTaskName = camundaRequestHandler.getTaskInformation(response, REQUEST_ID);
 186
 187         assertNull(actualTaskName);
 188     }
 189
 190     @Test
 191     public void getCamundActivityHistoryErrorTest() throws IOException, ContactCamundaException {
 192         HistoricProcessInstanceEntity processInstance = new HistoricProcessInstanceEntity();
 193         processInstance.setId("c4c6b647-a26e-11e9-b144-0242ac14000b");
 194         List<HistoricProcessInstanceEntity> processInstanceList = new ArrayList<>();
 195         processInstanceList.add(processInstance);
 196         ResponseEntity<List<HistoricProcessInstanceEntity>> response =
 197                 new ResponseEntity<>(processInstanceList, HttpStatus.OK);
 198         doThrow(RestClientException.class).when(camundaRequestHandler)
 199                 .getCamundaActivityHistory("c4c6b647-a26e-11e9-b144-0242ac14000b");
 200
 201         String actualTaskName = camundaRequestHandler.getTaskInformation(response, REQUEST_ID);
 202
 203         assertNull(actualTaskName);
 204     }
 205
 206     @Test
 207     public void getTaskName() throws IOException, ContactCamundaException {
 208         doReturn(processInstanceResponse).when(camundaRequestHandler).getCamundaProcessInstanceHistory(REQUEST_ID,
 209                 false, false, true);
 210         doReturn(activityInstanceResponse).when(camundaRequestHandler)
 211                 .getCamundaActivityHistory("c2fd4066-a26e-11e9-b144-0242ac14000b");
 212         doReturn("Last task executed: BB to Execute").when(camundaRequestHandler).getActivityName(activityInstanceList);
 213         String expectedTaskName = "Last task executed: BB to Execute";
 214
 215         String actualTaskName = camundaRequestHandler.getTaskName(REQUEST_ID);
 216
 217         assertEquals(expectedTaskName, actualTaskName);
 218     }
 219
 220     @Test
 221     public void getTaskNameNullProcessInstanceListTest() throws IOException, ContactCamundaException {
 222         ResponseEntity<List<HistoricProcessInstanceEntity>> response = new ResponseEntity<>(null, HttpStatus.OK);
 223
 224         String actual = camundaRequestHandler.getTaskInformation(response, REQUEST_ID);
 225
 226         assertNull(actual);
 227     }
 228
 229     @Test
 230     public void getTaskNameNullProcessInstanceIdTest() throws IOException, ContactCamundaException {
 231         HistoricProcessInstanceEntity processInstance = new HistoricProcessInstanceEntity();
 232         List<HistoricProcessInstanceEntity> processInstanceList = new ArrayList<>();
 233         processInstanceList.add(processInstance);
 234         ResponseEntity<List<HistoricProcessInstanceEntity>> response =
 235                 new ResponseEntity<>(processInstanceList, HttpStatus.OK);
 236
 237         String actual = camundaRequestHandler.getTaskInformation(response, REQUEST_ID);
 238
 239         assertNull(actual);
 240     }
 241
 242     @Test
 243     public void getTaskNameEmptyProcessInstanceListTest() throws IOException, ContactCamundaException {
 244         List<HistoricProcessInstanceEntity> processInstanceList = new ArrayList<>();
 245         ResponseEntity<List<HistoricProcessInstanceEntity>> response =
 246                 new ResponseEntity<>(processInstanceList, HttpStatus.OK);
 247
 248         String actual = camundaRequestHandler.getTaskInformation(response, REQUEST_ID);
 249
 250         assertNull(actual);
 251     }
 252
 253     @Test
 254     public void getTaskNameProcessInstanceLookupFailureTest() throws IOException, ContactCamundaException {
 255         doThrow(HttpClientErrorException.class).when(camundaRequestHandler).getCamundaProcessInstanceHistory(REQUEST_ID,
 256                 false, false, true);
 257
 258         String result = camundaRequestHandler.getTaskName(REQUEST_ID);
 259         assertNull(result);
 260     }
 261
 262     @Test
 263     public void getCamundaActivityHistoryTest() throws IOException, ContactCamundaException {
 264         HttpHeaders headers = setHeaders();
 265         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 266         String targetUrl =
 267                 "http://localhost:8089/sobpmnengine/history/activity-instance?processInstanceId=c4c6b647-a26e-11e9-b144-0242ac14000b&maxResults=1";
 268         doReturn(activityInstanceResponse).when(restTemplate).exchange(targetUrl, HttpMethod.GET, requestEntity,
 269                 new ParameterizedTypeReference<List<HistoricActivityInstanceEntity>>() {});
 270         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 271         ResponseEntity<List<HistoricActivityInstanceEntity>> actualResponse =
 272                 camundaRequestHandler.getCamundaActivityHistory("c4c6b647-a26e-11e9-b144-0242ac14000b");
 273         assertEquals(activityInstanceResponse, actualResponse);
 274     }
 275
 276     @Test
 277     public void getCamundaActivityHistoryErrorTest() {
 278         HttpHeaders headers = setHeaders();
 279         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 280         String targetUrl =
 281                 "http://localhost:8089/sobpmnengine/history/activity-instance?processInstanceId=c4c6b647-a26e-11e9-b144-0242ac14000b&maxResults=1";
 282         doThrow(new ResourceAccessException("IOException")).when(restTemplate).exchange(targetUrl, HttpMethod.GET,
 283                 requestEntity, new ParameterizedTypeReference<List<HistoricActivityInstanceEntity>>() {});
 284         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 285
 286         thrown.expect(ResourceAccessException.class);
 287         camundaRequestHandler.getCamundaActivityHistory("c4c6b647-a26e-11e9-b144-0242ac14000b");
 288
 289         verify(restTemplate, times(1)).exchange(targetUrl, HttpMethod.GET, requestEntity,
 290                 new ParameterizedTypeReference<List<HistoricActivityInstanceEntity>>() {});
 291     }
 292
 293     @Test
 294     public void getCamundaProccesInstanceHistoryTest() throws IOException, ContactCamundaException {
 295         HttpHeaders headers = setHeaders();
 296         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 297         String targetUrl = "http://localhost:8089/sobpmnengine/history/process-instance?processInstanceBusinessKey="
 298                 + REQUEST_ID + "&active=true&maxResults=1";
 299         doReturn(processInstanceResponse).when(restTemplate).exchange(targetUrl, HttpMethod.GET, requestEntity,
 300                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 301         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 302
 303         ResponseEntity<List<HistoricProcessInstanceEntity>> actualResponse =
 304                 camundaRequestHandler.getCamundaProcessInstanceHistory(REQUEST_ID, false, true, false);
 305         assertEquals(processInstanceResponse, actualResponse);
 306     }
 307
 308     @Test
 309     public void getCamundaProccesInstanceHistoryRetryTest() {
 310         HttpHeaders headers = setHeaders();
 311         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 312         String targetUrl = "http://localhost:8089/sobpmnengine/history/process-instance?processInstanceBusinessKey="
 313                 + REQUEST_ID + "&active=true&maxResults=1";
 314         doThrow(new ResourceAccessException("I/O error")).when(restTemplateRetry).exchange(targetUrl, HttpMethod.GET,
 315                 requestEntity, new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 316         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 317
 318         thrown.expect(ResourceAccessException.class);
 319         camundaRequestHandler.getCamundaProcessInstanceHistory(REQUEST_ID, true, true, false);
 320
 321         verify(restTemplateRetry, times(2)).exchange(targetUrl, HttpMethod.GET, requestEntity,
 322                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 323     }
 324
 325     @Test
 326     public void getCamundaProccesInstanceHistoryNoRetryTest() {
 327         HttpHeaders headers = setHeaders();
 328         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 329         String targetUrl = "http://localhost:8089/sobpmnengine/history/process-instance?processInstanceBusinessKey="
 330                 + REQUEST_ID + "&sortBy=startTime&sortOrder=desc&maxResults=1";
 331         doThrow(HttpClientErrorException.class).when(restTemplate).exchange(targetUrl, HttpMethod.GET, requestEntity,
 332                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 333         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 334
 335         thrown.expect(HttpStatusCodeException.class);
 336         camundaRequestHandler.getCamundaProcessInstanceHistory(REQUEST_ID, false, false, true);
 337
 338         verify(restTemplate, times(1)).exchange(targetUrl, HttpMethod.GET, requestEntity,
 339                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 340     }
 341
 342     @Test
 343     public void getCamundaProccesInstanceHistoryFailThenSuccessTest() throws IOException, ContactCamundaException {
 344         HttpHeaders headers = setHeaders();
 345         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
 346         String targetUrl = "http://localhost:8089/sobpmnengine/history/process-instance?processInstanceBusinessKey="
 347                 + REQUEST_ID + "&sortBy=startTime&sortOrder=desc&maxResults=1";
 348         when(restTemplateRetry.exchange(targetUrl, HttpMethod.GET, requestEntity,
 349                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {}))
 350                         .thenThrow(new ResourceAccessException("I/O Exception")).thenReturn(processInstanceResponse);
 351         doReturn(headers).when(camundaRequestHandler).setCamundaHeaders("auth", "key");
 352
 353         ResponseEntity<List<HistoricProcessInstanceEntity>> actualResponse =
 354                 camundaRequestHandler.getCamundaProcessInstanceHistory(REQUEST_ID, true, false, true);
 355
 356         assertEquals(processInstanceResponse, actualResponse);
 357         verify(restTemplateRetry, times(2)).exchange(targetUrl, HttpMethod.GET, requestEntity,
 358                 new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
 359     }
 360
 361     @Test
 362     public void setCamundaHeadersTest() throws ContactCamundaException, RequestDbFailureException {
 363         String encryptedAuth = "015E7ACF706C6BBF85F2079378BDD2896E226E09D13DC2784BA309E27D59AB9FAD3A5E039DF0BB8408"; // user:password
 364         String key = "07a7159d3bf51a0e53be7a8f89699be7";
 365
 366         HttpHeaders headers = camundaRequestHandler.setCamundaHeaders(encryptedAuth, key);
 367         List<org.springframework.http.MediaType> acceptedType = headers.getAccept();
 368
 369         String expectedAcceptedType = "application/json";
 370         assertEquals(expectedAcceptedType, acceptedType.get(0).toString());
 371         String basicAuth = headers.getFirst(HttpHeaders.AUTHORIZATION);
 372         String expectedBasicAuth = "Basic dXNlcjpwYXNzd29yZA==";
 373
 374         assertEquals(expectedBasicAuth, basicAuth);
 375     }
 376 }