public virtual void testCreateRecursiveHistoricIncidents()
{
startProcessInstance("process");
ProcessInstance pi1 = runtimeService.createProcessInstanceQuery().processDefinitionKey("process").singleResult();
assertNotNull(pi1);
ProcessInstance pi2 = runtimeService.createProcessInstanceQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).singleResult();
assertNotNull(pi2);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
HistoricIncident rootCauseHistoricIncident = query.processInstanceId(pi2.Id).singleResult();
assertNotNull(rootCauseHistoricIncident);
// cause and root cause id is equal to the id of the root incident
assertEquals(rootCauseHistoricIncident.Id, rootCauseHistoricIncident.CauseIncidentId);
assertEquals(rootCauseHistoricIncident.Id, rootCauseHistoricIncident.RootCauseIncidentId);
HistoricIncident historicIncident = query.processInstanceId(pi1.Id).singleResult();
assertNotNull(historicIncident);
// cause and root cause id is equal to the id of the root incident
assertEquals(rootCauseHistoricIncident.Id, historicIncident.CauseIncidentId);
assertEquals(rootCauseHistoricIncident.Id, historicIncident.RootCauseIncidentId);
}
// historic incident query (standalone) //////////////////////////////
public virtual void testQueryForStandaloneHistoricIncidents()
{
// given
disableAuthorization();
repositoryService.suspendProcessDefinitionByKey(ONE_INCIDENT_PROCESS_KEY, true, DateTime.Now);
string jobId = null;
IList <Job> jobs = managementService.createJobQuery().list();
foreach (Job job in jobs)
{
if (string.ReferenceEquals(job.ProcessDefinitionKey, null))
{
jobId = job.Id;
break;
}
}
managementService.setJobRetries(jobId, 0);
enableAuthorization();
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 1);
disableAuthorization();
managementService.deleteJob(jobId);
enableAuthorization();
clearDatabase();
}
public virtual void testDoNotCreateNewIncident()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
ProcessInstance pi = runtimeService.createProcessInstanceQuery().singleResult();
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().processInstanceId(pi.Id);
HistoricIncident incident = query.singleResult();
assertNotNull(incident);
JobDefinition jobDefinition = managementService.createJobDefinitionQuery().singleResult();
// set retries to 1 by job definition id
managementService.setJobRetriesByJobDefinitionId(jobDefinition.Id, 1);
// the incident still exists
HistoricIncident tmp = query.singleResult();
assertEquals(incident.Id, tmp.Id);
assertNull(tmp.EndTime);
assertTrue(tmp.Open);
// execute the available job (should fail again)
executeAvailableJobs();
// the incident still exists and there
// should be not a new incident
assertEquals(1, query.count());
tmp = query.singleResult();
assertEquals(incident.Id, tmp.Id);
assertNull(tmp.EndTime);
assertTrue(tmp.Open);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testQueryByJobDefinitionId()
public virtual void testQueryByJobDefinitionId()
{
string processDefinitionId1 = testHelper.deployAndGetDefinition(FAILING_SERVICE_TASK_MODEL).Id;
string processDefinitionId2 = testHelper.deployAndGetDefinition(FAILING_SERVICE_TASK_MODEL).Id;
runtimeService.startProcessInstanceById(processDefinitionId1);
runtimeService.startProcessInstanceById(processDefinitionId2);
testHelper.executeAvailableJobs();
string jobDefinitionId1 = managementService.createJobQuery().processDefinitionId(processDefinitionId1).singleResult().JobDefinitionId;
string jobDefinitionId2 = managementService.createJobQuery().processDefinitionId(processDefinitionId2).singleResult().JobDefinitionId;
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().jobDefinitionIdIn(jobDefinitionId1, jobDefinitionId2);
assertEquals(2, query.list().size());
assertEquals(2, query.count());
query = historyService.createHistoricIncidentQuery().jobDefinitionIdIn(jobDefinitionId1);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
query = historyService.createHistoricIncidentQuery().jobDefinitionIdIn(jobDefinitionId2);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual IList <HistoricIncidentDto> getHistoricIncidents(UriInfo uriInfo, int?firstResult, int?maxResults)
{
HistoricIncidentQueryDto queryDto = new HistoricIncidentQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricIncidentQuery query = queryDto.toQuery(processEngine);
IList <HistoricIncident> queryResult;
if (firstResult != null || maxResults != null)
{
queryResult = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
queryResult = query.list();
}
IList <HistoricIncidentDto> result = new List <HistoricIncidentDto>();
foreach (HistoricIncident historicIncident in queryResult)
{
HistoricIncidentDto dto = HistoricIncidentDto.fromHistoricIncident(historicIncident);
result.Add(dto);
}
return(result);
}
private void createHistoricIncidentMock()
{
HistoricIncidentQuery mockHistoricIncidentQuery = mock(typeof(HistoricIncidentQuery));
IList <HistoricIncident> historicIncidents = MockProvider.createMockHistoricIncidents();
when(mockHistoricIncidentQuery.list()).thenReturn(historicIncidents);
when(mockHistoryService.createHistoricIncidentQuery()).thenReturn(mockHistoricIncidentQuery);
}
public virtual void testQueryNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
assertThat(query.count(), @is(0L));
}
public virtual void testQueryByOpen()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().open();
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testQueryByIncidentType()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().incidentType(org.camunda.bpm.engine.runtime.Incident_Fields.FAILED_JOB_HANDLER_TYPE);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testQueryDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
assertThat(query.count(), @is(2L));
}
public virtual void testQueryByTenantId()
{
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().tenantIdIn(TENANT_ONE);
assertThat(query.count(), @is(1L));
query = historyService.createHistoricIncidentQuery().tenantIdIn(TENANT_TWO);
assertThat(query.count(), @is(1L));
}
public virtual void testQueryAuthenticatedTenants()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO));
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
assertThat(query.count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(1L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(1L));
}
public virtual void testMixedQueryWithReadHistoryPermissionOnAnyProcessDefinition()
{
// given
disableAuthorization();
repositoryService.suspendProcessDefinitionByKey(ONE_INCIDENT_PROCESS_KEY, true, DateTime.Now);
string firstJobId = null;
IList <Job> jobs = managementService.createJobQuery().withRetriesLeft().list();
foreach (Job job in jobs)
{
if (string.ReferenceEquals(job.ProcessDefinitionKey, null))
{
firstJobId = job.Id;
break;
}
}
managementService.setJobRetries(firstJobId, 0);
repositoryService.suspendProcessDefinitionByKey(ONE_INCIDENT_PROCESS_KEY, true, DateTime.Now);
string secondJobId = null;
jobs = managementService.createJobQuery().withRetriesLeft().list();
foreach (Job job in jobs)
{
if (string.ReferenceEquals(job.ProcessDefinitionKey, null))
{
secondJobId = job.Id;
break;
}
}
managementService.setJobRetries(secondJobId, 0);
enableAuthorization();
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ANOTHER_ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ANOTHER_ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ANOTHER_ONE_INCIDENT_PROCESS_KEY);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 7);
disableAuthorization();
managementService.deleteJob(firstJobId);
managementService.deleteJob(secondJobId);
enableAuthorization();
clearDatabase();
}
// historic incident query ///////////////////////////////////////////
public virtual void testSimpleQueryWithoutAuthorization()
{
// given
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 0);
}
private HistoricIncidentQuery setUpMockHistoricIncidentQuery(IList <HistoricIncident> mockedHistoricIncidents)
{
HistoricIncidentQuery mockedHistoricIncidentQuery = mock(typeof(HistoricIncidentQuery));
when(mockedHistoricIncidentQuery.list()).thenReturn(mockedHistoricIncidents);
when(mockedHistoricIncidentQuery.count()).thenReturn((long)mockedHistoricIncidents.Count);
when(processEngine.HistoryService.createHistoricIncidentQuery()).thenReturn(mockedHistoricIncidentQuery);
return(mockedHistoricIncidentQuery);
}
public virtual void testQueryByConfiguration()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
string configuration = managementService.createJobQuery().singleResult().Id;
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().configuration(configuration);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testQueryPaging()
{
startProcessInstances(PROCESS_DEFINITION_KEY, 4);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
assertEquals(4, query.listPage(0, 4).size());
assertEquals(1, query.listPage(2, 1).size());
assertEquals(2, query.listPage(1, 2).size());
assertEquals(3, query.listPage(1, 4).size());
}
public virtual void testQueryByExecutionId()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
ProcessInstance pi = runtimeService.createProcessInstanceQuery().singleResult();
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().executionId(pi.Id);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testQueryByIncidentId()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
string incidentId = historyService.createHistoricIncidentQuery().singleResult().Id;
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().incidentId(incidentId);
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testSimpleQueryWithReadHistoryPermissionOnAnyProcessDefinition()
{
// given
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 1);
}
private IList <HistoricIncident> executePaginatedQuery(HistoricIncidentQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
public virtual CountResultDto getHistoricIncidentsCount(UriInfo uriInfo)
{
HistoricIncidentQueryDto queryDto = new HistoricIncidentQueryDto(objectMapper, uriInfo.QueryParameters);
HistoricIncidentQuery query = queryDto.toQuery(processEngine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.Count = count;
return(result);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testQueryByUnknownJobDefinitionId()
public virtual void testQueryByUnknownJobDefinitionId()
{
string processDefinitionId = testHelper.deployAndGetDefinition(FAILING_SERVICE_TASK_MODEL).Id;
runtimeService.startProcessInstanceById(processDefinitionId);
testHelper.executeAvailableJobs();
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().jobDefinitionIdIn("unknown");
assertEquals(0, query.list().size());
assertEquals(0, query.count());
}
public virtual void testQueryByRootCauseIncidentId()
{
startProcessInstance("process");
string processInstanceId = runtimeService.createProcessInstanceQuery().processDefinitionKey(PROCESS_DEFINITION_KEY).singleResult().Id;
Incident incident = runtimeService.createIncidentQuery().processInstanceId(processInstanceId).singleResult();
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().rootCauseIncidentId(incident.Id);
assertEquals(2, query.list().size());
assertEquals(2, query.count());
}
public virtual void testQueryByDeleted()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
string processInstanceId = runtimeService.createProcessInstanceQuery().singleResult().Id;
runtimeService.deleteProcessInstance(processInstanceId, null);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().deleted();
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
public virtual void testQueryByResolved()
{
startProcessInstance(PROCESS_DEFINITION_KEY);
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.setJobRetries(jobId, 1);
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery().resolved();
assertEquals(1, query.list().size());
assertEquals(1, query.count());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testQueryByInvalidDeleted()
public virtual void testQueryByInvalidDeleted()
{
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
try
{
query.deleted().deleted();
fail("It was possible to set a the deleted flag twice.");
}
catch (ProcessEngineException)
{
}
}
// historic incident query (start timer job incident) //////////////////////////////
public virtual void testStartTimerJobIncidentQueryWithoutAuthorization()
{
// given
disableAuthorization();
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.setJobRetries(jobId, 0);
enableAuthorization();
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 0);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testQueryByInvalidConfigurationId()
public virtual void testQueryByInvalidConfigurationId()
{
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
assertEquals(0, query.configuration("invalid").list().size());
assertEquals(0, query.configuration("invalid").count());
try
{
query.configuration(null);
fail("It was possible to set a null value as configuration.");
}
catch (ProcessEngineException)
{
}
}
public virtual void testStartTimerJobIncidentQueryWithReadInstancePermissionOnAnyProcessDefinition()
{
// given
disableAuthorization();
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.setJobRetries(jobId, 0);
enableAuthorization();
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricIncidentQuery query = historyService.createHistoricIncidentQuery();
// then
verifyQueryResults(query, 1);
}
