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;
28 import java.util.List;
29 import java.util.UUID;
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;
42 import com.google.common.base.Optional;
46 * @author waqas.ikram@ericsson.com
48 public class CamundaProcessDataServiceProviderTest {
49 private static final String DURATION = "1";
50 private static final String FLOW_XML = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
51 private static final String NAME = "Test";
52 private static final String DEFAULT = "default";
53 private static final String CAMUNDA_REST_API_URL = "http://localhost:9080/engine-rest/engine/";
55 private static final String ID = UUID.randomUUID().toString();
56 private static final String PROCESS_ID = UUID.randomUUID().toString();
57 private static final String DEF_ID = UUID.randomUUID().toString();
58 private static final String SUPER_PROCESS_ID = UUID.randomUUID().toString();
59 private final HttpRestServiceProvider httpRestServiceProvider = mock(HttpRestServiceProvider.class);
60 private final CamundaRestUrlProvider camundaRestUrlProvider =
61 new CamundaRestUrlProvider(CAMUNDA_REST_API_URL, DEFAULT);
65 public void test_GetProcessInstanceDetail_EmptyResponse() {
66 final Optional<ProcessInstance[]> response = Optional.<ProcessInstance[]>absent();
67 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
68 when(httpRestServiceProvider.getHttpResponse(url, ProcessInstance[].class)).thenReturn(response);
69 final CamundaProcessDataServiceProvider objUnderTest =
70 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
72 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
73 assertFalse(actualResponse.isPresent());
77 public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNull() {
78 final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance());
79 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
80 when(httpRestServiceProvider.getHttpResponse(url, ProcessInstance[].class)).thenReturn(response);
81 final CamundaProcessDataServiceProvider objUnderTest =
82 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
84 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
85 assertTrue(actualResponse.isPresent());
87 final ProcessInstanceIdDetail actualProcessInstanceDetail = actualResponse.get();
88 assertEquals(PROCESS_ID, actualProcessInstanceDetail.getProcessInstanceId());
92 public void test_GetProcessInstanceDetail_NonEmptyResponseWithSuperProcessIdNotNull() {
93 final Optional<ProcessInstance[]> response = Optional.of(getProcessInstance(SUPER_PROCESS_ID));
94 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/process-instance?variables=requestId_eq_" + ID;
95 when(httpRestServiceProvider.getHttpResponse(url, ProcessInstance[].class)).thenReturn(response);
96 final CamundaProcessDataServiceProvider objUnderTest =
97 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
99 final Optional<ProcessInstanceIdDetail> actualResponse = objUnderTest.getProcessInstanceIdDetail(ID);
100 assertFalse(actualResponse.isPresent());
105 public void test_GetProcessDefinition_EmptyResponse() {
106 final Optional<ProcessDefinition> response = Optional.<ProcessDefinition>absent();
107 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + ID + "/xml";
108 when(httpRestServiceProvider.getHttpResponse(url, ProcessDefinition.class)).thenReturn(response);
109 final CamundaProcessDataServiceProvider objUnderTest =
110 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
112 final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(ID);
113 assertFalse(actualResponse.isPresent());
117 public void test_GetProcessDefinition_NonEmptyResponse() {
118 final Optional<ProcessDefinition> response = getProcessDefinition();
119 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/process-definition/" + PROCESS_ID + "/xml";
120 when(httpRestServiceProvider.getHttpResponse(url, ProcessDefinition.class)).thenReturn(response);
121 final CamundaProcessDataServiceProvider objUnderTest =
122 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
124 final Optional<ProcessDefinitionDetail> actualResponse = objUnderTest.getProcessDefinition(PROCESS_ID);
125 assertTrue(actualResponse.isPresent());
126 assertEquals(PROCESS_ID, actualResponse.get().getProcessDefinitionId());
127 assertEquals(FLOW_XML, actualResponse.get().getProcessDefinitionXml());
131 public void test_GetActivityInstance_EmptyResponse() {
132 final Optional<ActivityInstance[]> response = Optional.<ActivityInstance[]>absent();
133 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
134 + "&sortBy=startTime&sortOrder=asc";
135 when(httpRestServiceProvider.getHttpResponse(url, ActivityInstance[].class)).thenReturn(response);
136 final CamundaProcessDataServiceProvider objUnderTest =
137 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
139 final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
140 assertTrue(actualResponse.isEmpty());
145 public void test_GetActivityInstance_NonEmptyResponse() {
146 final Optional<ActivityInstance[]> response = getActivityInstance();
147 final String url = CAMUNDA_REST_API_URL + DEFAULT + "/history/activity-instance?processInstanceId=" + PROCESS_ID
148 + "&sortBy=startTime&sortOrder=asc";
149 when(httpRestServiceProvider.getHttpResponse(url, ActivityInstance[].class)).thenReturn(response);
150 final CamundaProcessDataServiceProvider objUnderTest =
151 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
153 final List<ActivityInstanceDetail> actualResponse = objUnderTest.getActivityInstance(PROCESS_ID);
154 assertFalse(actualResponse.isEmpty());
155 final ActivityInstanceDetail actualActivityInstanceDetail = actualResponse.get(0);
156 assertEquals(ID, actualActivityInstanceDetail.getActivityId());
157 assertEquals(NAME, actualActivityInstanceDetail.getActivityName());
158 assertEquals(NAME, actualActivityInstanceDetail.getActivityType());
163 public void test_GetProcessInstanceVariable_EmptyResponse() {
164 final Optional<ProcessInstanceVariable[]> response = Optional.<ProcessInstanceVariable[]>absent();
166 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
167 when(httpRestServiceProvider.getHttpResponse(url, ProcessInstanceVariable[].class)).thenReturn(response);
168 final CamundaProcessDataServiceProvider objUnderTest =
169 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
171 final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
172 assertTrue(actualResponse.isEmpty());
177 public void test_GetProcessInstanceVariable_NonEmptyResponse() {
178 final Optional<ProcessInstanceVariable[]> response = getProcessInstanceVariable();
180 CAMUNDA_REST_API_URL + DEFAULT + "/history/variable-instance?processInstanceId=" + PROCESS_ID;
181 when(httpRestServiceProvider.getHttpResponse(url, ProcessInstanceVariable[].class)).thenReturn(response);
182 final CamundaProcessDataServiceProvider objUnderTest =
183 new CamundaProcessDataServiceProviderImpl(camundaRestUrlProvider, httpRestServiceProvider);
185 final List<ProcessInstanceVariableDetail> actualResponse = objUnderTest.getProcessInstanceVariable(PROCESS_ID);
186 assertFalse(actualResponse.isEmpty());
187 final ProcessInstanceVariableDetail variableDetail = actualResponse.get(0);
188 assertEquals(NAME, variableDetail.getName());
189 assertEquals(NAME, variableDetail.getType());
190 assertEquals(NAME, variableDetail.getValue());
194 private Optional<ProcessInstanceVariable[]> getProcessInstanceVariable() {
195 final ProcessInstanceVariable instanceVariable = new ProcessInstanceVariable();
196 instanceVariable.setName(NAME);
197 instanceVariable.setType(NAME);
198 instanceVariable.setValue(NAME);
199 return Optional.of(new ProcessInstanceVariable[] {instanceVariable});
202 private Optional<ActivityInstance[]> getActivityInstance() {
203 final ActivityInstance activityInstance = new ActivityInstance();
204 activityInstance.setActivityId(ID);
205 activityInstance.setActivityName(NAME);
206 activityInstance.setActivityType(NAME);
207 activityInstance.setDurationInMillis(DURATION);
208 return Optional.of(new ActivityInstance[] {activityInstance});
211 private Optional<ProcessDefinition> getProcessDefinition() {
212 final ProcessDefinition processDefinition = new ProcessDefinition();
213 processDefinition.setId(PROCESS_ID);
214 processDefinition.setBpmn20Xml(FLOW_XML);
215 return Optional.of(processDefinition);
218 private ProcessInstance[] getProcessInstance() {
219 return getProcessInstance(null);
222 private ProcessInstance[] getProcessInstance(final String superProcessInstanceId) {
223 final ProcessInstance instance = new ProcessInstance();
224 instance.setId(PROCESS_ID);
225 instance.setProcessDefinitionId(DEF_ID);
226 instance.setProcessDefinitionName(NAME);
227 instance.setSuperProcessInstanceId(superProcessInstanceId);
228 return new ProcessInstance[] {instance};