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
9 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 * SPDX-License-Identifier: Apache-2.0
18 * ============LICENSE_END=========================================================
20 package org.onap.so.monitoring.rest.service;
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 import java.util.List;
28 import java.util.UUID;
29 import org.junit.Test;
30 import org.onap.so.monitoring.camunda.model.ActivityInstance;
31 import org.onap.so.monitoring.camunda.model.ProcessDefinition;
32 import org.onap.so.monitoring.camunda.model.ProcessInstance;
33 import org.onap.so.monitoring.camunda.model.ProcessInstanceVariable;
34 import org.onap.so.monitoring.configuration.camunda.CamundaRestUrlProvider;
35 import org.onap.so.monitoring.model.ActivityInstanceDetail;
36 import org.onap.so.monitoring.model.ProcessDefinitionDetail;
37 import org.onap.so.monitoring.model.ProcessInstanceIdDetail;
38 import org.onap.so.monitoring.model.ProcessInstanceVariableDetail;
39 import org.onap.so.rest.service.HttpRestServiceProvider;
40 import com.google.common.base.Optional;
44 * @author waqas.ikram@ericsson.com
46 public class CamundaProcessDataServiceProviderTest {
47 private static final String DURATION = "1";
48 private static final String FLOW_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
49 private static final String NAME = "Test";
50 private static final String DEFAULT = "default";
51 private static final String CAMUNDA_REST_API_URL = "http://localhost:9080/engine-rest/engine/";
53 private static final String ID = UUID.randomUUID().toString();
54 private static final String PROCESS_ID = UUID.randomUUID().toString();
55 private static final String DEF_ID = UUID.randomUUID().toString();
56 private static final String SUPER_PROCESS_ID = UUID.randomUUID().toString();
57 private final HttpRestServiceProvider httpRestServiceProvider = mock(HttpRestServiceProvider.class);
58 private final CamundaRestUrlProvider camundaRestUrlProvider =
59 new CamundaRestUrlProvider(CAMUNDA_REST_API_URL, DEFAULT);
63 public void test_GetProcessInstanceDetail_EmptyResponse() {
64 final Optional<ProcessInstance[]> response = Optional.<ProcessInstance[]>absent();
65 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
66 when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
67 final CamundaProcessDataServiceProvider objUnderTest =
68 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
70 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
71 assertFalse(actualResponse.isPresent());
75 public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNull() {
76 final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance());
77 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
78 when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
79 final CamundaProcessDataServiceProvider objUnderTest =
80 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
82 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
83 assertTrue(actualResponse.isPresent());
85 final ProcessInstanceIdDetail actualProcessInstanceDetail = actualResponse.get();
86 assertEquals(PROCESS_ID, actualProcessInstanceDetail.getProcessInstanceId());
90 public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNotNull() {
91 final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance(SUPER_PROCESS_ID));
92 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
93 when(httpRestServiceProvider.get(url, ProcessInstance[].class)).thenReturn(response);
94 final CamundaProcessDataServiceProvider objUnderTest =
95 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
97 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
98 assertFalse(actualResponse.isPresent());
103 public void test_GetProcessDefinition_EmptyResponse() {
104 final Optional<ProcessDefinition> response = Optional.<ProcessDefinition>absent();
105 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + ID + "/xml";
106 when(httpRestServiceProvider.get(url, ProcessDefinition.class)).thenReturn(response);
107 final CamundaProcessDataServiceProvider objUnderTest =
108 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
110 final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(ID);
111 assertFalse(actualResponse.isPresent());
115 public void test_GetProcessDefinition_NonEmptyResponse() {
116 final Optional<ProcessDefinition> response = getProcessDefinition();
117 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + PROCESS_ID + "/xml";
118 when(httpRestServiceProvider.get(url, ProcessDefinition.class)).thenReturn(response);
119 final CamundaProcessDataServiceProvider objUnderTest =
120 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
122 final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(PROCESS_ID);
123 assertTrue(actualResponse.isPresent());
124 assertEquals(PROCESS_ID, actualResponse.get().getProcessDefinitionId());
125 assertEquals(FLOW_XML, actualResponse.get().getProcessDefinitionXml());
129 public void test_GetActivityInstance_EmptyResponse() {
130 final Optional<ActivityInstance[]> response = Optional.<ActivityInstance[]>absent();
131 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
132 + "&sortBy=startTime&sortOrder=asc";
133 when(httpRestServiceProvider.get(url, ActivityInstance[].class)).thenReturn(response);
134 final CamundaProcessDataServiceProvider objUnderTest =
135 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
137 final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
138 assertTrue(actualResponse.isEmpty());
143 public void test_GetActivityInstance_NonEmptyResponse() {
144 final Optional<ActivityInstance[]> response = getActivityInstance();
145 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
146 + "&sortBy=startTime&sortOrder=asc";
147 when(httpRestServiceProvider.get(url, ActivityInstance[].class)).thenReturn(response);
148 final CamundaProcessDataServiceProvider objUnderTest =
149 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
151 final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
152 assertFalse(actualResponse.isEmpty());
153 final ActivityInstanceDetail actualActivityInstanceDetail = actualResponse.get(0);
154 assertEquals(ID, actualActivityInstanceDetail.getActivityId());
155 assertEquals(NAME, actualActivityInstanceDetail.getActivityName());
156 assertEquals(NAME, actualActivityInstanceDetail.getActivityType());
161 public void test_GetProcessInstanceVariable_EmptyResponse() {
162 final Optional<ProcessInstanceVariable[]> response = Optional.<ProcessInstanceVariable[]>absent();
164 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
165 when(httpRestServiceProvider.get(url, ProcessInstanceVariable[].class)).thenReturn(response);
166 final CamundaProcessDataServiceProvider objUnderTest =
167 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
169 final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
170 assertTrue(actualResponse.isEmpty());
175 public void test_GetProcessInstanceVariable_NonEmptyResponse() {
176 final Optional<ProcessInstanceVariable[]> response = getProcessInstanceVariable();
178 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
179 when(httpRestServiceProvider.get(url, ProcessInstanceVariable[].class)).thenReturn(response);
180 final CamundaProcessDataServiceProvider objUnderTest =
181 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
183 final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
184 assertFalse(actualResponse.isEmpty());
185 final ProcessInstanceVariableDetail variableDetail = actualResponse.get(0);
186 assertEquals(NAME, variableDetail.getName());
187 assertEquals(NAME, variableDetail.getType());
188 assertEquals(NAME, variableDetail.getValue());
192 private Optional<ProcessInstanceVariable[]> getProcessInstanceVariable() {
193 final ProcessInstanceVariable instanceVariable = new ProcessInstanceVariable();
194 instanceVariable.setName(NAME);
195 instanceVariable.setType(NAME);
196 instanceVariable.setValue(NAME);
197 return Optional.of(new ProcessInstanceVariable[] {instanceVariable});
200 private Optional<ActivityInstance[]> getActivityInstance() {
201 final ActivityInstance activityInstance = new ActivityInstance();
202 activityInstance.setActivityId(ID);
203 activityInstance.setActivityName(NAME);
204 activityInstance.setActivityType(NAME);
205 activityInstance.setDurationInMillis(DURATION);
206 return Optional.of(new ActivityInstance[] {activityInstance});
209 private Optional<ProcessDefinition> getProcessDefinition() {
210 final ProcessDefinition processDefinition = new ProcessDefinition();
211 processDefinition.setId(PROCESS_ID);
212 processDefinition.setBpmn20Xml(FLOW_XML);
213 return Optional.of(processDefinition);
216 private ProcessInstance[] getProcessInstance() {
217 return getProcessInstance(null);
220 private ProcessInstance[] getProcessInstance(final String superProcessInstanceId) {
221 final ProcessInstance instance = new ProcessInstance();
222 instance.setId(PROCESS_ID);
223 instance.setProcessDefinitionId(DEF_ID);
224 instance.setProcessDefinitionName(NAME);
225 instance.setSuperProcessInstanceId(superProcessInstanceId);
226 return new ProcessInstance[] {instance};