public virtual void testQuery()
{
runtimeService.startProcessInstanceByKey("process");
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
verifyQueryResults(query, 1);
}
// historic job log query (standalone job) ///////////////////////
public virtual void testQueryAfterStandaloneJob()
{
// given
disableAuthorization();
repositoryService.suspendProcessDefinitionByKey(TIMER_BOUNDARY_PROCESS_KEY, true, DateTime.Now);
enableAuthorization();
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 1);
HistoricJobLog jobLog = query.singleResult();
assertNull(jobLog.ProcessDefinitionKey);
deleteDeployment(deploymentId);
disableAuthorization();
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.deleteJob(jobId);
enableAuthorization();
}
public virtual IList <HistoricJobLogDto> queryHistoricJobLogs(HistoricJobLogQueryDto queryDto, int?firstResult, int?maxResults)
{
queryDto.ObjectMapper = objectMapper;
HistoricJobLogQuery query = queryDto.toQuery(processEngine);
IList <HistoricJobLog> matchingHistoricJobLogs;
if (firstResult != null || maxResults != null)
{
matchingHistoricJobLogs = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
matchingHistoricJobLogs = query.list();
}
IList <HistoricJobLogDto> results = new List <HistoricJobLogDto>();
foreach (HistoricJobLog historicJobLog in matchingHistoricJobLogs)
{
HistoricJobLogDto result = HistoricJobLogDto.fromHistoricJobLog(historicJobLog);
results.Add(result);
}
return(results);
}
private void createHistoricJobLogMock()
{
HistoricJobLogQuery mockHistoricJobLogQuery = mock(typeof(HistoricJobLogQuery));
IList <HistoricJobLog> historicJobLogs = MockProvider.createMockHistoricJobLogs();
when(mockHistoricJobLogQuery.list()).thenReturn(historicJobLogs);
when(mockHistoryService.createHistoricJobLogQuery()).thenReturn(mockHistoricJobLogQuery);
}
public virtual void testQueryNoAuthenticatedTenants()
{
identityService.setAuthentication("user", null, null);
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
assertThat(query.count(), @is(0L));
}
public virtual void testQueryByJobDefinitionType()
{
runtimeService.startProcessInstanceByKey("process");
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().jobDefinitionType(AsyncContinuationJobHandler.TYPE);
verifyQueryResults(query, 1);
}
public virtual void testQueryByJobDefinitionConfiguration()
{
runtimeService.startProcessInstanceByKey("process");
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().jobDefinitionConfiguration(MessageJobDeclaration.ASYNC_BEFORE);
verifyQueryResults(query, 1);
}
public virtual void testQueryByProcessDefinitionKey()
{
runtimeService.startProcessInstanceByKey("process");
string processDefinitionKey = managementService.createJobQuery().singleResult().ProcessDefinitionKey;
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().processDefinitionKey(processDefinitionKey);
verifyQueryResults(query, 1);
}
public virtual void testQueryDisabledTenantCheck()
{
processEngineConfiguration.TenantCheckEnabled = false;
identityService.setAuthentication("user", null, null);
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
assertThat(query.count(), @is(4L));
}
public virtual void testQueryByDeploymentId()
{
runtimeService.startProcessInstanceByKey("process");
string deploymentId = managementService.createJobQuery().singleResult().DeploymentId;
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().deploymentId(deploymentId);
verifyQueryResults(query, 1);
}
public virtual void testQueryByLogId()
{
runtimeService.startProcessInstanceByKey("process");
string logId = historyService.createHistoricJobLogQuery().singleResult().Id;
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().logId(logId);
verifyQueryResults(query, 1);
}
public virtual void testQueryByTenantId()
{
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().tenantIdIn(TENANT_ONE);
assertThat(query.count(), @is(2L));
query = historyService.createHistoricJobLogQuery().tenantIdIn(TENANT_TWO);
assertThat(query.count(), @is(2L));
}
public virtual void testQueryByDeletionLog()
{
string processInstanceId = runtimeService.startProcessInstanceByKey("process").Id;
runtimeService.deleteProcessInstance(processInstanceId, null);
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().deletionLog();
verifyQueryResults(query, 1);
}
public virtual void testQueryAuthenticatedTenants()
{
identityService.setAuthentication("user", null, Arrays.asList(TENANT_ONE, TENANT_TWO));
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
assertThat(query.count(), @is(4L));
assertThat(query.tenantIdIn(TENANT_ONE).count(), @is(2L));
assertThat(query.tenantIdIn(TENANT_TWO).count(), @is(2L));
}
protected internal virtual void verifySingleResultFails(HistoricJobLogQuery query)
{
try
{
query.singleResult();
fail();
}
catch (ProcessEngineException)
{
}
}
// historic job log query ////////////////////////////////////////////////
public virtual void testSimpleQueryWithoutAuthorization()
{
// given
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 0);
}
public virtual void testQueryBySuccessLog()
{
runtimeService.startProcessInstanceByKey("process", Variables.createVariables().putValue("fail", false));
string jobId = managementService.createJobQuery().singleResult().Id;
managementService.executeJob(jobId);
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().successLog();
verifyQueryResults(query, 1);
}
protected internal virtual HistoricJobLogQuery setUpMockHistoricJobLogQuery(IList <HistoricJobLog> mockedHistoricJogLogs)
{
HistoricJobLogQuery mockedhistoricJobLogQuery = mock(typeof(HistoricJobLogQuery));
when(mockedhistoricJobLogQuery.list()).thenReturn(mockedHistoricJogLogs);
when(mockedhistoricJobLogQuery.count()).thenReturn((long)mockedHistoricJogLogs.Count);
when(processEngine.HistoryService.createHistoricJobLogQuery()).thenReturn(mockedhistoricJobLogQuery);
return(mockedhistoricJobLogQuery);
}
// historic job log query (start timer job) ////////////////////////////////
public virtual void testStartTimerJobLogQueryWithoutAuthorization()
{
// given
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 0);
}
public virtual void testStartTimerJobLogQueryWithReadHistoryPermissionOnProcessDefinition()
{
// given
createGrantAuthorization(PROCESS_DEFINITION, TIMER_START_PROCESS_KEY, userId, READ_HISTORY);
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 1);
}
protected internal virtual IList <HistoricJobLog> executePaginatedQuery(HistoricJobLogQuery query, int?firstResult, int?maxResults)
{
if (firstResult == null)
{
firstResult = 0;
}
if (maxResults == null)
{
maxResults = int.MaxValue;
}
return(query.listPage(firstResult, maxResults));
}
public virtual CountResultDto queryHistoricJobLogsCount(HistoricJobLogQueryDto queryDto)
{
queryDto.ObjectMapper = objectMapper;
HistoricJobLogQuery query = queryDto.toQuery(processEngine);
long count = query.count();
CountResultDto result = new CountResultDto();
result.Count = count;
return(result);
}
public virtual void testSimpleQueryWithHistoryReadPermissionOnAnyProcessDefinition()
{
// given
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
createGrantAuthorization(PROCESS_DEFINITION, ANY, userId, READ_HISTORY);
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 5);
}
public virtual void testQueryByInvalidLogId()
{
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().logId("invalid");
verifyQueryResults(query, 0);
try
{
query.logId(null);
fail();
}
catch (Exception)
{
}
}
public virtual void testQueryByInvalidJobDefinitionConfiguration()
{
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().jobDefinitionConfiguration("invalid");
verifyQueryResults(query, 0);
try
{
query.jobDefinitionConfiguration(null);
fail();
}
catch (Exception)
{
}
}
public virtual void testQueryByInvalidProcessDefinitionKey()
{
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().processDefinitionKey("invalid");
verifyQueryResults(query, 0);
try
{
query.processDefinitionKey(null);
fail();
}
catch (Exception)
{
}
}
protected internal virtual void verifyQueryResults(HistoricJobLogQuery query, int countExpected)
{
assertEquals(countExpected, query.list().size());
assertEquals(countExpected, query.count());
if (countExpected == 1)
{
assertNotNull(query.singleResult());
}
else if (countExpected > 1)
{
verifySingleResultFails(query);
}
else if (countExpected == 0)
{
assertNull(query.singleResult());
}
}
public virtual void testQueryByFailureLog()
{
runtimeService.startProcessInstanceByKey("process");
string jobId = managementService.createJobQuery().singleResult().Id;
try
{
managementService.executeJob(jobId);
fail();
}
catch (Exception)
{
// expected
}
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery().failureLog();
verifyQueryResults(query, 1);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testTenantIdListParameter()
public virtual void testTenantIdListParameter()
{
mockedQuery = setUpMockHistoricJobLogQuery(createMockHistoricJobLogsTwoTenants());
Response response = given().queryParam("tenantIdIn", MockProvider.EXAMPLE_TENANT_ID_LIST).then().expect().statusCode(Status.OK.StatusCode).when().get(HISTORIC_JOB_LOG_RESOURCE_URL);
verify(mockedQuery).tenantIdIn(MockProvider.EXAMPLE_TENANT_ID, MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
verify(mockedQuery).list();
string content = response.asString();
IList <string> jobLogs = from(content).getList("");
assertThat(jobLogs).hasSize(2);
string returnedTenantId1 = from(content).getString("[0].tenantId");
string returnedTenantId2 = from(content).getString("[1].tenantId");
assertThat(returnedTenantId1).isEqualTo(MockProvider.EXAMPLE_TENANT_ID);
assertThat(returnedTenantId2).isEqualTo(MockProvider.ANOTHER_EXAMPLE_TENANT_ID);
}
// historic job log query (multiple process instance) ////////////////////////////////////////////////
public virtual void testQueryWithoutAuthorization()
{
// given
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
startProcessAndExecuteJob(ONE_INCIDENT_PROCESS_KEY);
disableAuthorization();
string jobId = managementService.createJobQuery().processDefinitionKey(TIMER_START_PROCESS_KEY).singleResult().Id;
managementService.executeJob(jobId);
jobId = managementService.createJobQuery().processDefinitionKey(TIMER_START_PROCESS_KEY).singleResult().Id;
managementService.executeJob(jobId);
enableAuthorization();
// when
HistoricJobLogQuery query = historyService.createHistoricJobLogQuery();
// then
verifyQueryResults(query, 0);
}
