so-monitoring/so-monitoring-handler/src/test/java/org/onap/so/monitoring/rest/service/CamundaProcessDataServiceProviderTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2018 Ericsson. All rights reserved.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.so.monitoring.rest.service;
  21
  22 import static org.junit.Assert.assertEquals;
  23 import static org.junit.Assert.assertFalse;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.Mockito.mock;
  26 import static org.mockito.Mockito.when;
  27
  28 import java.util.List;
  29 import java.util.UUID;
  30
  31 import org.junit.Test;
  32 import org.onap.so.monitoring.camunda.model.ActivityInstance;
  33 import org.onap.so.monitoring.camunda.model.ProcessDefinition;
  34 import org.onap.so.monitoring.camunda.model.ProcessInstance;
  35 import org.onap.so.monitoring.camunda.model.ProcessInstanceVariable;
  36 import org.onap.so.monitoring.configuration.camunda.CamundaRestUrlProvider;
  37 import org.onap.so.monitoring.model.ActivityInstanceDetail;
  38 import org.onap.so.monitoring.model.ProcessDefinitionDetail;
  39 import org.onap.so.monitoring.model.ProcessInstanceIdDetail;
  40 import org.onap.so.monitoring.model.ProcessInstanceVariableDetail;
  41 import org.onap.so.rest.service.HttpRestServiceProvider;
  42
  43 import com.google.common.base.Optional;
  44
  45
  46 /**
  47  * @author waqas.ikram@ericsson.com
  48  */
  49 public class CamundaProcessDataServiceProviderTest {
  50     private static final String DURATION = "1";
  51     private static final String FLOW_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
  52     private static final String NAME = "Test";
  53     private static final String DEFAULT = "default";
  54     private static final String CAMUNDA_REST_API_URL = "http://localhost:9080/engine-rest/engine/";
  55
  56     private static final String ID = UUID.randomUUID().toString();
  57     private static final String PROCESS_ID = UUID.randomUUID().toString();
  58     private static final String DEF_ID = UUID.randomUUID().toString();
  59     private static final String SUPER_PROCESS_ID = UUID.randomUUID().toString();
  60     private final HttpRestServiceProvider httpRestServiceProvider = mock(HttpRestServiceProvider.class);
  61     private final CamundaRestUrlProvider camundaRestUrlProvider =
  62             new CamundaRestUrlProvider(CAMUNDA_REST_API_URL, DEFAULT);
  63
  64
  65     @Test
  66     public void test_GetProcessInstanceDetail_EmptyResponse() {
  67         final Optional<ProcessInstance[]> response = Optional.<ProcessInstance[]>absent();
  68         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
  69         when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
  70         final CamundaProcessDataServiceProvider objUnderTest =
  71                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
  72
  73         final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
  74         assertFalse(actualResponse.isPresent());
  75     }
  76
  77     @Test
  78     public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNull() {
  79         final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance());
  80         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
  81         when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
  82         final CamundaProcessDataServiceProvider objUnderTest =
  83                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
  84
  85         final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
  86         assertTrue(actualResponse.isPresent());
  87
  88         final ProcessInstanceIdDetail actualProcessInstanceDetail = actualResponse.get();
  89         assertEquals(PROCESS_ID, actualProcessInstanceDetail.getProcessInstanceId());
  90     }
  91
  92     @Test
  93     public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNotNull() {
  94         final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance(SUPER_PROCESS_ID));
  95         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
  96         when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
  97         final CamundaProcessDataServiceProvider objUnderTest =
  98                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
  99
 100         final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
 101         assertFalse(actualResponse.isPresent());
 102
 103     }
 104
 105     @Test
 106     public void test_GetProcessDefinition_EmptyResponse() {
 107         final Optional<ProcessDefinition> response = Optional.<ProcessDefinition>absent();
 108         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + ID + "/xml";
 109         when(httpRestServiceProvider.get(url, ProcessDefinition.class)).thenReturn(response);
 110         final CamundaProcessDataServiceProvider objUnderTest =
 111                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 112
 113         final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(ID);
 114         assertFalse(actualResponse.isPresent());
 115     }
 116
 117     @Test
 118     public void test_GetProcessDefinition_NonEmptyResponse() {
 119         final Optional<ProcessDefinition> response = getProcessDefinition();
 120         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + PROCESS_ID + "/xml";
 121         when(httpRestServiceProvider.get(url, ProcessDefinition.class)).thenReturn(response);
 122         final CamundaProcessDataServiceProvider objUnderTest =
 123                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 124
 125         final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(PROCESS_ID);
 126         assertTrue(actualResponse.isPresent());
 127         assertEquals(PROCESS_ID, actualResponse.get().getProcessDefinitionId());
 128         assertEquals(FLOW_XML, actualResponse.get().getProcessDefinitionXml());
 129     }
 130
 131     @Test
 132     public void test_GetActivityInstance_EmptyResponse() {
 133         final Optional<ActivityInstance[]> response = Optional.<ActivityInstance[]>absent();
 134         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
 135                 + "&sortBy=startTime&sortOrder=asc";
 136         when(httpRestServiceProvider.get(url, ActivityInstance[].class)).thenReturn(response);
 137         final CamundaProcessDataServiceProvider objUnderTest =
 138                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 139
 140         final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
 141         assertTrue(actualResponse.isEmpty());
 142
 143     }
 144
 145     @Test
 146     public void test_GetActivityInstance_NonEmptyResponse() {
 147         final Optional<ActivityInstance[]> response = getActivityInstance();
 148         final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
 149                 + "&sortBy=startTime&sortOrder=asc";
 150         when(httpRestServiceProvider.get(url, ActivityInstance[].class)).thenReturn(response);
 151         final CamundaProcessDataServiceProvider objUnderTest =
 152                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 153
 154         final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
 155         assertFalse(actualResponse.isEmpty());
 156         final ActivityInstanceDetail actualActivityInstanceDetail = actualResponse.get(0);
 157         assertEquals(ID, actualActivityInstanceDetail.getActivityId());
 158         assertEquals(NAME, actualActivityInstanceDetail.getActivityName());
 159         assertEquals(NAME, actualActivityInstanceDetail.getActivityType());
 160
 161     }
 162
 163     @Test
 164     public void test_GetProcessInstanceVariable_EmptyResponse() {
 165         final Optional<ProcessInstanceVariable[]> response = Optional.<ProcessInstanceVariable[]>absent();
 166         final String url =
 167                 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
 168         when(httpRestServiceProvider.get(url, ProcessInstanceVariable[].class)).thenReturn(response);
 169         final CamundaProcessDataServiceProvider objUnderTest =
 170                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 171
 172         final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
 173         assertTrue(actualResponse.isEmpty());
 174
 175     }
 176
 177     @Test
 178     public void test_GetProcessInstanceVariable_NonEmptyResponse() {
 179         final Optional<ProcessInstanceVariable[]> response = getProcessInstanceVariable();
 180         final String url =
 181                 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
 182         when(httpRestServiceProvider.get(url, ProcessInstanceVariable[].class)).thenReturn(response);
 183         final CamundaProcessDataServiceProvider objUnderTest =
 184                 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
 185
 186         final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
 187         assertFalse(actualResponse.isEmpty());
 188         final ProcessInstanceVariableDetail variableDetail = actualResponse.get(0);
 189         assertEquals(NAME, variableDetail.getName());
 190         assertEquals(NAME, variableDetail.getType());
 191         assertEquals(NAME, variableDetail.getValue());
 192
 193     }
 194
 195     private Optional<ProcessInstanceVariable[]> getProcessInstanceVariable() {
 196         final ProcessInstanceVariable instanceVariable = new ProcessInstanceVariable();
 197         instanceVariable.setName(NAME);
 198         instanceVariable.setType(NAME);
 199         instanceVariable.setValue(NAME);
 200         return Optional.of(new ProcessInstanceVariable[] {instanceVariable});
 201     }
 202
 203     private Optional<ActivityInstance[]> getActivityInstance() {
 204         final ActivityInstance activityInstance = new ActivityInstance();
 205         activityInstance.setActivityId(ID);
 206         activityInstance.setActivityName(NAME);
 207         activityInstance.setActivityType(NAME);
 208         activityInstance.setDurationInMillis(DURATION);
 209         return Optional.of(new ActivityInstance[] {activityInstance});
 210     }
 211
 212     private Optional<ProcessDefinition> getProcessDefinition() {
 213         final ProcessDefinition processDefinition = new ProcessDefinition();
 214         processDefinition.setId(PROCESS_ID);
 215         processDefinition.setBpmn20Xml(FLOW_XML);
 216         return Optional.of(processDefinition);
 217     }
 218
 219     private ProcessInstance[] getProcessInstance() {
 220         return getProcessInstance(null);
 221     }
 222
 223     private ProcessInstance[] getProcessInstance(final String superProcessInstanceId) {
 224         final ProcessInstance instance = new ProcessInstance();
 225         instance.setId(PROCESS_ID);
 226         instance.setProcessDefinitionId(DEF_ID);
 227         instance.setProcessDefinitionName(NAME);
 228         instance.setSuperProcessInstanceId(superProcessInstanceId);
 229         return new ProcessInstance[] {instance};
 230     }
 231
 232
 233 }