public virtual void testQueryByInvalidProcessInstanceIds()
{
// given
IDictionary <string, object> variables1 = new Dictionary <string, object>();
variables1["stringVar"] = "test";
runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables1);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
try
{
// when
query.processInstanceIdIn(null);
fail("A ProcessEngineException was expected.");
}
catch (ProcessEngineException)
{
// then fails
}
try
{
// when
query.processInstanceIdIn((string)null);
fail("A ProcessEngineException was expected.");
}
catch (ProcessEngineException)
{
// then fails
}
}
public virtual void testQueryByOccurredAfterAndOccurredBefore()
{
// given
DateTime startTime = new DateTime();
ClockUtil.CurrentTime = startTime;
DateTime hourAgo = new DateTime();
hourAgo.AddHours(-1);
DateTime hourFromNow = new DateTime();
hourFromNow.AddHours(1);
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["stringVar"] = "test";
runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
// then
assertEquals(0, query.occurredAfter(hourFromNow).occurredBefore(hourFromNow).count());
assertEquals(1, query.occurredAfter(hourAgo).occurredBefore(hourFromNow).count());
assertEquals(0, query.occurredAfter(hourFromNow).occurredBefore(hourAgo).count());
assertEquals(0, query.occurredAfter(hourAgo).occurredBefore(hourAgo).count());
}
public virtual void testDetailQueryWithReadHistoryOnAnyProcessDefinition()
{
// given
startProcessInstanceByKey(PROCESS_KEY);
string taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY);
taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
// then
verifyQueryResults(query, 7);
}
// historic detail query (variable update + form field) //////////
public virtual void testDetailQueryWithoutAuthorization()
{
// given
startProcessInstanceByKey(PROCESS_KEY);
string taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY);
taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
// then
verifyQueryResults(query, 0);
}
public virtual void testQueryByVariableTypeInWithCapitalLetter()
{
// given
IDictionary <string, object> variables1 = new Dictionary <string, object>();
variables1["stringVar"] = "test";
variables1["boolVar"] = true;
runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("Boolean");
// then
assertEquals(1, query.list().size());
assertEquals(1, query.count());
HistoricDetail historicDetail = query.list().get(0);
if (historicDetail is HistoricVariableUpdate)
{
HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)historicDetail;
assertEquals(variableUpdate.VariableName, "boolVar");
assertEquals(variableUpdate.TypeName, "boolean");
}
else
{
fail("Historic detail should be a variable update!");
}
}
private IList <HistoricDetailDto> executeHistoricDetailQuery(HistoricDetailQuery query, int?firstResult, int?maxResults, bool deserializeObjectValues)
{
query.disableBinaryFetching();
if (!deserializeObjectValues)
{
query.disableCustomObjectDeserialization();
}
IList <HistoricDetail> queryResult;
if (firstResult != null || maxResults != null)
{
queryResult = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
queryResult = query.list();
}
IList <HistoricDetailDto> result = new List <HistoricDetailDto>();
foreach (HistoricDetail historicDetail in queryResult)
{
HistoricDetailDto dto = HistoricDetailDto.fromHistoricDetail(historicDetail);
result.Add(dto);
}
return(result);
}
public virtual IList <HistoricDetailDto> getHistoricDetails(UriInfo uriInfo, int?firstResult, int?maxResults, bool deserializeObjectValues)
{
HistoricDetailQueryDto queryDto = new HistoricDetailQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricDetailQuery query = queryDto.toQuery(processEngine);
return(executeHistoricDetailQuery(query, firstResult, maxResults, deserializeObjectValues));
}
public virtual void testQueryNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
assertThat(query.count(), @is(0L));
}
private void createHistoricDetailMock()
{
IList <HistoricDetail> details = MockProvider.createMockHistoricDetails();
HistoricDetailQuery query = mock(typeof(HistoricDetailQuery));
when(mockHistoryService.createHistoricDetailQuery()).thenReturn(query);
when(query.list()).thenReturn(details);
}
public virtual void testQueryDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
assertThat(query.count(), @is(4L));
}
public virtual void testQueryAuthenticatedTenants()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO));
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
assertThat(query.count(), @is(4L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(2L));
}
public virtual void testQueryByTenantId()
{
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().tenantIdIn(TENANT_ONE);
assertThat(query.count(), @is(2L));
query = historyService.createHistoricDetailQuery().variableUpdates().tenantIdIn(TENANT_TWO);
assertThat(query.count(), @is(2L));
}
// historic variable update query (case variables) /////////////////////////////////////////////
public virtual void testQueryAfterCaseVariables()
{
// given
createCaseInstanceByKey(CASE_KEY, Variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 1);
}
// historic variable update query (process task) /////////////////////////////////////////////
public virtual void testSimpleVariableUpdateQueryWithoutAuthorization()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 0);
}
public virtual CountResultDto getHistoricDetailsCount(UriInfo uriInfo)
{
HistoricDetailQueryDto queryDto = new HistoricDetailQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricDetailQuery query = queryDto.toQuery(processEngine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.Count = count;
return(result);
}
private IList <HistoricDetail> executePaginatedQuery(HistoricDetailQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
public virtual void testSimpleVariableUpdateQueryWithReadHistoryPermissionOnProcessDefinition()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 1);
}
// delete deployment (cascade = false)
public virtual void testQueryAfterDeletingDeployment()
{
// given
startProcessInstanceByKey(PROCESS_KEY);
string taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY);
taskId = selectSingleTask().Id;
disableAuthorization();
formService.submitTaskForm(taskId, Variables);
enableAuthorization();
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, PROCESS_KEY, userId, READ_HISTORY);
disableAuthorization();
IList <Task> tasks = taskService.createTaskQuery().list();
foreach (Task task in tasks)
{
taskService.complete(task.Id);
}
enableAuthorization();
disableAuthorization();
repositoryService.deleteDeployment(deploymentId);
enableAuthorization();
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery();
// then
verifyQueryResults(query, 7);
disableAuthorization();
IList <HistoricProcessInstance> instances = historyService.createHistoricProcessInstanceQuery().list();
foreach (HistoricProcessInstance instance in instances)
{
historyService.deleteHistoricProcessInstance(instance.Id);
}
enableAuthorization();
}
public virtual void testQueryByNonExistingProcessInstanceId()
{
// given
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["stringVar"] = "test";
runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().processInstanceIdIn("foo");
// then
assertEquals(0, query.count());
}
public virtual void testQueryByInvalidExecutionId()
{
startProcessInstance(PROCESS_KEY);
string taskId = taskService.createTaskQuery().singleResult().Id;
// when
taskService.resolveTask(taskId, Variables);
//then
HistoricDetailQuery query = historyService.createHistoricDetailQuery().executionId("invalid");
assertEquals(0, query.list().size());
assertEquals(0, query.count());
}
public virtual void testQueryBySingleProcessInstanceId()
{
// given
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["stringVar"] = "test";
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().processInstanceIdIn(processInstance.ProcessInstanceId);
// then
assertEquals(1, query.count());
assertEquals(query.list().get(0).ProcessInstanceId, processInstance.Id);
}
// historic variable update query (multiple process instances) ///////////////////////////////////////////
public virtual void testFormFieldQueryWithoutAuthorization()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().formFields();
// then
verifyQueryResults(query, 0);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Ignore @Test public void testHistoryServiceEngineAccess_HistoricDetailBinaryFile()
public virtual void testHistoryServiceEngineAccess_HistoricDetailBinaryFile()
{
HistoricDetailQuery query = mock(typeof(HistoricDetailQuery));
HistoricVariableUpdate instance = mock(typeof(HistoricVariableUpdate));
string filename = "test.txt";
sbyte[] byteContent = "test".GetBytes();
string encoding = "UTF-8";
FileValue variableValue = Variables.fileValue(filename).file(byteContent).mimeType(ContentType.TEXT.ToString()).encoding(encoding).create();
when(instance.TypedValue).thenReturn(variableValue);
when(query.singleResult()).thenReturn(instance);
when(mockHistoryService.createHistoricDetailQuery()).thenReturn(query);
given().pathParam("name", EXAMPLE_ENGINE_NAME).then().expect().statusCode(Status.OK.StatusCode).body(@is(equalTo(StringHelper.NewString(byteContent)))).and().header("Content-Disposition", "attachment; filename=" + filename).contentType(CoreMatchers.either <string>(equalTo(ContentType.TEXT.ToString() + ";charset=UTF-8")).or(equalTo(ContentType.TEXT.ToString() + " ;charset=UTF-8"))).when().get(HISTORY_BINARY_DETAIL_URL);
verify(mockHistoryService).createHistoricDetailQuery();
verifyZeroInteractions(processEngine);
}
// historic variable update query (standalone task) /////////////////////////////////////////////
public virtual void testQueryAfterStandaloneTaskVariableUpdates()
{
// given
string taskId = "myTask";
createTask(taskId);
disableAuthorization();
taskService.setVariables(taskId, Variables);
enableAuthorization();
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 1);
deleteTask(taskId, true);
}
public virtual void testMixedQueryWithReadHistoryPermissionOnAnyProcessDefinition()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
createTask("one");
createTask("two");
createTask("three");
createTask("four");
createTask("five");
disableAuthorization();
taskService.setVariables("one", Variables);
taskService.setVariables("two", Variables);
taskService.setVariables("three", Variables);
taskService.setVariables("four", Variables);
taskService.setVariables("five", Variables);
enableAuthorization();
createCaseInstanceByKey(CASE_KEY, Variables);
createCaseInstanceByKey(CASE_KEY, Variables);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 14);
deleteTask("one", true);
deleteTask("two", true);
deleteTask("three", true);
deleteTask("four", true);
deleteTask("five", true);
}
public virtual void testQueryByUserOperationId()
{
startProcessInstance(PROCESS_KEY);
identityService.AuthenticatedUserId = "demo";
string taskId = taskService.createTaskQuery().singleResult().Id;
// when
taskService.resolveTask(taskId, Variables);
//then
string userOperationId = historyService.createHistoricDetailQuery().singleResult().UserOperationId;
HistoricDetailQuery query = historyService.createHistoricDetailQuery().userOperationId(userOperationId);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
// historic variable update query (mixed) ////////////////////////////////////
public virtual void testMixedQueryWithoutAuthorization()
{
// given
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
startProcessInstanceByKey(MESSAGE_START_PROCESS_KEY, Variables);
createTask("one");
createTask("two");
createTask("three");
createTask("four");
createTask("five");
disableAuthorization();
taskService.setVariables("one", Variables);
taskService.setVariables("two", Variables);
taskService.setVariables("three", Variables);
taskService.setVariables("four", Variables);
taskService.setVariables("five", Variables);
enableAuthorization();
createCaseInstanceByKey(CASE_KEY, Variables);
createCaseInstanceByKey(CASE_KEY, Variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates();
// then
verifyQueryResults(query, 7);
deleteTask("one", true);
deleteTask("two", true);
deleteTask("three", true);
deleteTask("four", true);
deleteTask("five", true);
}
public virtual void testQueryByInvalidVariableTypeIn()
{
// given
IDictionary <string, object> variables1 = new Dictionary <string, object>();
variables1["stringVar"] = "test";
variables1["boolVar"] = true;
variables1["intVar"] = 5;
runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("invalid");
// then
assertEquals(0, query.count());
try
{
// when
query.variableTypeIn(null);
fail("A ProcessEngineException was expected.");
}
catch (ProcessEngineException)
{
// then fails
}
try
{
// when
query.variableTypeIn((string)null);
fail("A ProcessEngineException was expected.");
}
catch (ProcessEngineException)
{
// then fails
}
}
public virtual void testQueryBySeveralProcessInstanceIds()
{
// given
IDictionary <string, object> variables = new Dictionary <string, object>();
variables["stringVar"] = "test";
ProcessInstance processInstance = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
runtimeService.startProcessInstanceByKey(PROCESS_KEY, variables);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableUpdates().processInstanceIdIn(processInstance.ProcessInstanceId, processInstance2.ProcessInstanceId);
// then
ISet <string> expectedProcessInstanceIds = new HashSet <string>();
expectedProcessInstanceIds.Add(processInstance.Id);
expectedProcessInstanceIds.Add(processInstance2.Id);
assertEquals(2, query.count());
assertTrue(expectedProcessInstanceIds.Contains(query.list().get(0).ProcessInstanceId));
assertTrue(expectedProcessInstanceIds.Contains(query.list().get(1).ProcessInstanceId));
}
public virtual void testQueryByVariableTypeInWithSeveralTypes()
{
// given
IDictionary <string, object> variables1 = new Dictionary <string, object>();
variables1["stringVar"] = "test";
variables1["boolVar"] = true;
variables1["intVar"] = 5;
variables1["nullVar"] = null;
variables1["pojoVar"] = new TestPojo("str", .0);
runtimeService.startProcessInstanceByKey("oneTaskProcess", variables1);
// when
HistoricDetailQuery query = historyService.createHistoricDetailQuery().variableTypeIn("boolean", "integer", "Serializable");
// then
assertEquals(3, query.list().size());
assertEquals(3, query.count());
ISet <string> allowedVariableTypes = new HashSet <string>();
allowedVariableTypes.Add("boolean");
allowedVariableTypes.Add("integer");
allowedVariableTypes.Add("object");
foreach (HistoricDetail detail in query.list())
{
if (detail is HistoricVariableUpdate)
{
HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)detail;
assertTrue(allowedVariableTypes.Contains(variableUpdate.TypeName));
}
else
{
fail("Historic detail should be a variable update!");
}
}
}
